; =====================================================================================
; CONVERSION OF THE GAME 'THE HOBBIT' FROM SPECTRUM 48K (Z80) TO 6809 (CoCo2-3-Dragon)
; V0.8.16f8 - 2016-09-04 - PERE SERRAT 
; =====================================================================================
	org	$2600
	jmp	Start
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; exo2CoCo.asm adapted to CoCo2 by Pere Serrat
; Exomizer2 algorithm, backward with litterals for 6809
; by Fool-DupleX, PrehisTO and Sam from PULS (www.pulsdemos.com)
; edouard@forler.ch
; This routine decrunches data compressed with Exomizer2 in raw mode, backward
; with litterals.
; This routine was developed and tested on a Thomson MO5 in July 2011.
; Please direct any questions about this decruncher to edouard@forler.ch
; The Exomizer2 decruncher starts here.
; call with a JSR deExo2 or equivalent.
; Calculated: U = pointer to last byte of compressed data
;             Y = pointer to last byte of output buffer
; All registers are preserved except regY
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; This code self modifies so cannot be run in ROM.
; This code must be contained within a single page (makes use of DP)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
deExo2	pshs	y			; save working register
	ldy	#$1DE0			; $1BE0 for D64. HERE the END of destination area
	pshs  	cc,d,dp,x,y,u           ; Save register context
	orcc	#$50
	ldx	#$0928			; FCBs table beginning
	ldb	$095b			; get number of files
	aslb				; multiply by 2
	ldx	b,x			; point to system FCB
	lda	8,x			; get number of sectors
	ldb	20,x			; get bytes in last sector
	beq	1f			; if zero, skip adjustement
	deca				; subtract one sector if last one has bytes (1-255)
					; now regD contains file length
1	ldu   	#$0DFF			; get screen beginning-1
	leau  	d,u			; calculate END of compressed data on screen
	leau	-10,u			; subtract header and tail
	tfr   	pc,d                    ; Set direct page
        tfr   	a,dp			; to the exomizer code page
        lda   	,u                      ; Save first byte of data
        sta   	<bitbuf+1
        ldy   	#biba                	; Set ptr to bits and base table
        clrb
nxt     clra
        pshs  	a,b
        bitb  	#$0f                    ; if (i&15==0)
        bne   	skp
        ldx   	#$0001                  ; b2 = 1
skp     ldb   	#4                      ; Fetch 4 bits
        bsr   	getbits
        stb   	,y+                     ; bits[i] = b1
        comb				; CC=1
roll    rol   	,s
        rola
        incb
        bmi   	roll
        ldb   	,s
        stx   	,y++                    ; base[i] = b2
        leax  	d,x                     ; b2 += accu1
        puls  	a,b
        incb	
        cmpb  	#52                     ; 52 times ?
        bne   	nxt
go      ldy   	6,s                     ; Y = ptr to output
mloop   ldb   	#1                      ; for(;;)
        bsr   	getbits                 ; Fetch 1 bit
        bne   	cpy                     ; is 1 ?
        stb   	<idx+1                  ; B always 0 here
        fcb   	$8c                     ; (CMPX) to skip first iteration
rbl     inc   	<idx+1                  ; Compute index
        incb
        bsr   	getbits
        beq   	rbl
idx     ldb   	#$00                    ; Self-modified code
        cmpb  	#$10                    ; index = 16 ?
        beq   	endr
        blo   	coffs                   ; index < 16 ?
        decb                          	; index = 17
        bsr   	getbits                 ; Get size
cpy     tfr   	d,x                     ; Copy litteral
cpyl    lda   	,-u
        sta   	,-y
        leax  	-1,x
        bne   	cpyl
        bra   	mloop
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
coffs   bsr   	cook                    ; Compute length
        pshs  	d
        ldx  	#tab1
        cmpd  	#$03
        bhs   	scof
        abx
scof    ldb   	,x
        bsr   	getbits
        addb  	3,x
        bsr   	cook
        std   	<offs+2
        puls  	x
cpy2    leay  	-1,y                    ; Copy non litteral
offs    lda   	$1234,y                 ; Self-modified code
        sta   	,y
        leax  	-1,x
        bne   	cpy2
        bra   	mloop
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
endr    sty   	6,s                     ; End
	bsr	fill1st
        puls  	cc,d,dp,x,y,u	        ; Restore context
        puls	y,pc
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; getbits  : get 0 to 16 bits from input stream
; Input    : B = bit count, U points to input buffer
; Output   : D = bits
; Modifies : D,U
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
getbits clr	,-s                     ; Clear local bits
        clr   	,-s
bitbuf  lda   	#$01                    ; Self-modified code
        bra   	get3
get1    lda   	,-u
get2    rora
        beq   	get1                    ; Bit buffer = 1 ?
        rol   	1,s
        rol   	,s
get3    decb
        bpl   	get2
        sta   	<bitbuf+1               ; Save buffer
        ldd   	,s++                    ; Retrieve bits
        rts
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; cook     : computes base[index] + readbits(&in, bits[index])
; Input    : B = index
; Output   : D = base[index] + readbits(&in, bits[index])
; Modifies : D,X,U
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
cook    ldx  	#biba
        abx                           	; bits+base = 3 bytes
        aslb                          	; times 2
        abx
        ldb   	,x                      ; fetch bits[index]
        bsr   	getbits                 ; readbits
        addd  	1,x                     ; add base[index]
        rts
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; finally clean the first not used row!
fill1st	ldu	#$0E00 			; point to 1st byte of 1st screen row
	ldd	#$FFFF			; to fill color white/green
cln1st	std	,u++			; fill a word
	cmpu	#$0E1F			; got to the end of file?
	blo	cln1st			; no, loop
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
CoCo3Uti				; to add number '3' in Utils screen
	ldb	CoCoFlg			; get CoCo flag
	cmpb	#2			; is it a CoCo3?
	bne	eCo3U			; no, skip next two
	ldb	#$33			; get inverse colour code for number THREE
	stb	$4d6			; to show COCO3
eCo3U	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
CoCo3Cre				; to add inverse number '3' in credits screen
	ldb	CoCoFlg			; get CoCo flag
	cmpb	#2			; is it a CoCo3?
	bne	eCo3C			; no, skip next two
	ldb	#$73			; get inverse colour code for number THREE
	stb	$40c			; to show COCO3
eCo3C	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Paleta  equ	$F7			; si $F7=0 color blanco, otro valor Color verde
reg_BC	equ	$F8			; area para guardar el pseudo BC ($F8-F9)
reg_B	equ	reg_BC			; apunta al 1er byte de BC
reg_C	equ	reg_BC+1		; apunta al 2o byte de BC
reg_DE  equ     $FA     		; area para guardar el pseudo DE ($FA-FB)
reg_D	equ	reg_DE			; apunta al 1er byte de DE
reg_E	equ	reg_DE+1		; apunta al 2o byte de DE
reg_HL	equ	$FC			; area para guardar el pseudo HL ($FC-FD)
reg_H	equ	reg_HL			; apunta al 1er byte de HL
reg_L	equ	reg_HL+1		; apunta al 2o byte de HL
reg_IX	equ	$FE			; area para guardar el pseudo IX ($FE-FF)
reg_IY	equ	$76			; area para guardar el pseudo IY ($76-77)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; Configura modo grfico		; 							; (# sinNumero)
Start	jsr	LoadParts		; carga partes del programa
	orcc	#$50			; deshabilita interrupciones		;Start:	DI			 ; 6C00 F3		; Deshabilita interrupciones
	sta	$FFC0			; SAM v0 = 0				;	LD DE, OBJ_BAK		 ; 6C01 11 00 F4	; DE = OBJ_BAK	; DE Apunta al destino de la copia de la tabla de objetos OBJ_TABLE a $F400, de $0615 bytes
	sta   	$FFC3			; SAM v1 = 1				;	LD HL, OBJ_TABLE	 ; 6C04 21 1B C1	; HL, OBJ_TABLE	; HL Apunta al origen tabla de objetos
	sta   	$FFC5			; SAM v2 = 1 (usar 6144 bytes)		;	LD BC, $0615		 ; 6C07 01 15 06	; BC = $0615	; Tamao de la tabla de objetos
	sta   	$FFC7			; pone %x000 0111			;	LDIR			 ; 6C0A ED B0		; (DE+)=(HL+);BC-	; copia $615 bytes de HL en DE
	sta   	$FFC9			; para dar factor multiplicador 7	;	; DE = LOC_BAK		 ;			; DE se qued apuntando a $FA15 (destino de la copia de la tabla de localizaciones)
	sta   	$FFCB			; por $200 da como			;	LD HL, LOCATION		 ; 6C0C 21 8A BA	; HL = LOCATION	; HL Apunta al origen tabla de localidades (LOCATION), $05D9 bytes
	sta   	$FFCC			; inicio de RAM grfica:		;	LD BC, $05D9		 ; 6C0F 01 D9 05	; BC = $05D9	; Tamao de la tabla de localizaciones
	sta   	$FFCE			; $200 x 7 = $E00			;	LDIR			 ; 6C12 ED B0		; (DE+)=(HL+);BC-	; copia $5D9 bytes de HL en DE
	sta   	$FFD0			; que es lo necesario para		;	LD DE, DATAB1_BAK	 ; 6C14 11 00 5F	; DE = $5F00	; DE Apunta al destino de la copia de la tabla DATABLOCK1 a $5F00, $001D bytes
	sta   	$FFD2			; trabajar en PMODE 4 con discos	;	LD HL, DATABLK1		 ; 6C17 21 EB B6	; HL = DATABLK1	; HL Apunta al origen tabla de DATABLOCK1
	lda   	#$F0			; PMODE4 color verde-negro		;	LD BC, $001D		 ; 6C1A 01 1D 00	; BC = $001D	; Tamao de DATABLOCK1
	ldb	<$F7			; verifica flag blanco-verde		;	LDIR			 ; 6C1D ED B0		; (DE+)=(HL+);BC-	; copia $1D bytes de HL en DE
	bne     eStart			; si es verde saltar instruccin	;	; DE = DATAB3_BAK				; DE se qued apuntando a $5F1D (destino de la copia de la tabla DATABLOCK3)
	adda	#8			; valor $F8 para color blanco-negro	;	LD HL, DATABLK3		 ; 6C1F 21 84 CA	; HL = DATABLK3	; HL Apunta al origen tabla DATABLOCK3 a $5F1D, $00BF bytes
eStart	sta   	$FF22			; configura PM4 y paleta		;	LD BC, $00BF		 ; 6C22 01 BF 00	; BC = $00BF	; Tamao de la tabla DATABLOCK3
	andcc	#$af			; enable interrupts x DOS and CoCo sound
	bra	WaitForKey		; se salta el 'rearranque'		;	LDIR			 ; 6C25 ED B0		; (DE+)=(HL+);BC-	; copia $BF bytes de HL en DE
										;							; Si los datos estuvieran contiguos no se necesitaria tanto cdigo ... o podran cargarse directamente del disco!
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; inicializa bloques de datos		;							; (# sinNumero)
ReStart orcc 	#$50			; deshabilita interrupciones x Stack	;ReStart: DI			 ; 6C27 F3		; Deshabilita interrupciones
	lds	#$7F36			; deja 200 bytes para cadenas en Basic	;	LD SP, $5EFF		 ; 6C28 31 FF 5E	; SP = $5EFF	; Asigna posicin para el puntero del stack en $5EFF
	andcc   #$AF			; habilita interrupciones x DOS		;	LD IX, GFX_TABL		 ; 6C2B DD 21 00 CC	; IX = $CC00	; IX Apunta a la tabla de grficos(GFX_TABL)
	ldx	#RstFile		; apunta a datos para resturarlos	;	LD A, $05		 ; 6C2F 3E 05		; A = 5		; Nmero de grfico a buscar
	stx	FilePtr			; guarda puntero			;	CALL FindPointer	 ; 6C31 CD BD 9D	; Llama rutina FindPointer que devuelve el puntero a la localizacin 05 de la tabla GFX_TABL (DB $05,LE142; "trolls clearing")
	jsr	LdFilePgm		; carga fichero de disco		;	LD L, (IX+$01)		 ; 6C34 DD 6E 01	; L = $42	; Carga el byte bajo
	ldx	#Pmode4			; apunta a presentacin en PMode4	;	LD H, (IX+$02)		 ; 6C37 DD 66 02	; H = $E1	; Carga el byte alto (HL = $E142)
	stx	FilePtr			; guarda puntero			;	LD (HL), $00		 ; 6C3A 36 00		; HL($E142) = 0	; Coloca 0
	jsr	LdFilePgm		; carga fichero de disco		;	INC HL			 ; 6C3C 23		; HL = HL + 1	; Incrementa apuntador
										;	LD (HL), $00		 ; 6C3D 36 00		; (HL)($E143)=0	; Coloca 0 en ($E142-43) = $0000
										;	LD HL, OBJ_BAK		 ; 6C3F 21 00 F4	; Copia al contrario todo lo de Start
										;	LD DE, OBJ_TABLE	 ; 6C42 11 1B C1	; Carga DE con OBJ_TABLE
	clr	trlClr			; set NIGHT for trolls clearing		;	LD BC, $0615		 ; 6C45 01 15 06	; Carga BC con $0615
										;	LDIR			 ; 6C48 ED B0		; (DE+)=(HL+);BC-; Copia $615 bytes de HL a DE
										;	LD DE, LOCATION		 ; 6C4A 11 8A BA	; Carga DE con LOCATION
										;	LD BC, $05D9		 ; 6C4D 01 D9 05	; Carga BC con $05D9
										;	LDIR			 ; 6C50 ED B0		; (DE+)=(HL+);BC-; Copia $5D9 bytes de HL a DE
										;	LD HL, $5F00		 ; 6C52 21 00 5F	; Carga HL con $5F00
	clr	loaded			; set flag to FALSE			;	LD DE, DATABLK1		 ; 6C55 11 EB B6	; Carga DE con DATABLK1
										;	LD BC, $001D		 ; 6C58 01 1D 00	; Carga BC con $001D
										;	LDIR			 ; 6C5B ED B0		; (DE+)=(HL+);BC-; Copia $1D bytes de HL a DE
										;	LD DE, DATABLK3		 ; 6C5D 11 84 CA	; Carga DE con DATABLK3
										;	LD BC, $00BF		 ; 6C60 01 BF 00	; Carga BC con $00BF
										;	LDIR			 ; 6C63 ED B0		; (DE+)=(HL+);BC-; Copia $BF bytes de HL a DE
										;	XOR A			 ; 6C65 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
										;	OUT ($FE), A		 ; 6C66 D3 FE		; Inicializa los bits 0, 1 y 2 que controlan el color del borde, Bit 4 Altavoz y Bit 3 cassette 
										;	LD A, $38		 ; 6C68 3E 38		; A = $38	; Coloca $38(56)'8'  ??
										;	LD ($5C48), A		 ; 6C6A 32 48 5C	; ($5C48) = A	
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
																	; RAM de Video $4000 - $5B00
																	; (# sinNumero)
WaitForKey									; WaitForKey: 						; Esperar hasta que el usuario pulse una tecla
	jsr	ReadKey			; leer teclado				; 	XOR A			 ; 6C6D AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	beq     WaitForKey		; si ninguna tecla, espera		; 	IN A, ($FE)		 ; 6C6E DB FE		; Carga un byte desde el puerto $FE (Puerto de teclado)	
	clrb				; valor si N pulsada ($00)		; 	AND $1F			 ; 6C70 E6 1F		; borra los Bits altos 5-6-7 de A
	cmpa	#'N			; tecla N pulsada?			; 	CP $1F			 ; 6C72 FE 1F		; Lo compara con $1F (alguna tecla presionada?)
	beq	iWfK			; no, salta siguiente instruccin	; 	JR Z, WaitForKey	 ; 6C74 28 F7		; Repetir, salta a WaitForKey, si no hay tecla presionada
	incb				; valor para N no pulsada($01)		; 	LD A, $7F		 ; 6C76 3E 7F		; Busca las teclas B, "N, M, SYMB, SPACE
iWfK	stb	L_B707			; guarda indicador en L_B707		; 	IN A, ($FE)		 ; 6C78 DB FE		; Acepta un Byte del puerto de teclado con la semifila $7E($EF)
										; 	AND $08			 ; 6C7A E6 08		; Verifica si el bit3 = 8 esta encendido, Se puls "N"?
										; 	LD (L_B707), A		 ; 6C7C 32 07 B7	; Coloca un 8 ("N" no presionada) o un 0 ("N" presionada) en L_B707
	ldx	<$8A			; carga cero de 16 bits
	stx	L_B6F7			; pone a 0 L_B6F7-F8
wFK01	ldd	#$2500			; inicio lnea 24 de pantalla		; 	LD HL, $50E0		 ; 6C7F 21 E0 50	; Coloca $50E0 en (es el comienzo de la fila 24 de pantalla)
	std	L_85B4			; se guarda en L_85B4			; 	LD (L_85B4), HL		 ; 6C82 22 B4 85	; L_85B4
	ldd	#$1F00			; inicio linea 18 de pantalla		; 	LD A, $2B		 ; 6C85 3E 2B		; Carga $2B(43)'+'
	std	L_869C			; se guarda en L_869C			; 	LD (L_85B6), A		 ; 6C87 32 B6 85	; en L_85B6
	ldd	#$2B01			; valores fijos				; 	LD HL, $5020		 ; 6C8A 21 20 50	; guarda Comienzo de la fila 18 de pantalla
	sta	L_85B6			; guarda 43 ($2B) signo '+'		; 	LD (L_869C), HL		 ; 6C8D 22 9C 86	; en L_869C
	stb	L_869E			; guarda $01				; 	LD A, $01		 ; 6C90 3E 01		; pone 1
										; 	LD (L_869E), A		 ; 6C92 32 9E 86	; en L_869E
	ldd	#$202A			; valores fijos				; 	LD A, $20		 ; 6C95 3E 20		; pone 32 ($20)
	sta	L_85B3			; guarda 32 ($20) numChars abajo	; 	LD (L_85B3), A		 ; 6C97 32 B3 85	; en L_85B3
	stb	L_869B			; guarda 42 ($2A) numChars arriba	; 	LD A, $2A		 ; 6C9A 3E 2A		; pone 42 ($2A) '*'
										; 	LD (L_869B), A		 ; 6C9C 32 9B 86	; en L_869B
	ldb	#$C8			; para borrar 8x25 (200 bytes)		; 	LD B, $C8		 ; 6C9F 06 C8		; Borra $C8(200) Bytes desde UserTokenizedCommands hasta $B800
	ldx	#UserTokenizedCommands						; 	LD HL, UserTokenizedCommands
					; apunta a Area datos usuario		; 				 ; 6CA1 21 38 B7	; apunta a UserTokenizedCommands
	jsr	FillWithZeros		; borra los 200 bytes 			; 	CALL FillWithZeros	 ; 6CA4 CD E2 70	; Pone a cero B bytes apuntados por HL
	lda	>$0113			; byte bajo del timer			; 	LD A, R			 ; 6CA7 ED 5F		; recibe un valor aleatorio del 'Memory Refresh register'
	sta	InitRandomSeed		; guarda semilla para nums aleatorios	; 	LD (InitRandomSeed), A	 ; 6CA9 32 0E B7	; lo guarda en InitRandomSeed (semilla para la generacin de cifras aleatorias)
	clra				; pone 0 en				; 	XOR A			 ; 6CAC AF		; pone 0
	sta	L_869F								; 	LD (L_869F), A		 ; 6CAD 32 9F 86	; en $869F
	sta	L_86A0								; 	LD (L_86A0), A		 ; 6CB0 32 A0 86	; en $86A0
	sta	L_B71A								; 	LD (L_B71A), A		 ; 6CB3 32 1A B7	; en $B71A
	sta	L_B700								; 	LD (L_B700), A		 ; 6CB6 32 00 B7	; en $B700
	sta	L_B6F2								; 	LD (L_B6F2), A		 ; 6CB9 32 F2 B6	; y en $B6F2
	inca				; pone 1 en				; 	LD A, $01		 ; 6CBC 3E 01		; pone 1
	sta	L_B702								; 	LD (L_B702), A		 ; 6CBE 32 02 B7	; en $B702
	sta	L_B6FA								; 	LD (L_B6FA), A		 ; 6CC1 32 FA B6	; en $B6FA
	sta	L_B704								; 	LD (L_B704), A		 ; 6CC4 32 04 B7	; y en $B704
										; 	LD HL, $0000		 ; 6CC7 21 00 00	; pone 0 de 16 bits 
										; 	LD (L_B6F7), HL		 ; 6CCA 22 F7 B6	; en $B6F7-F8
	jsr	ClearScreen		; borra pantalla			; 	CALL ClearScreen	 ; 6CCD CD D3 6F	; borra la pantalla
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; Pinta la barra de separacin en forma de lineas entrecruzadas 
										; Toma los bytes del bloque de 10 que empieza en L_6DCC y de 2 en 2
										; repetidos 16 veces = 32 bytes, los pone en 5 lineas de pixels de pantalla
										;------------------------------------------------------------------------------------
	ldy	#$2020			; 2a fila pixels linea 19 pantalla	; 	LD HL, $5140		 ; 6CD0 21 40 51	; apunta a 2a fila de pixels de lnea 19 
	ldx	#Separator		; apunta a datos separador		; 	LD DE, Separator	 ; 6CD3 11 CC 6D	; apunta a datos para el separador de zonas de pantalla
i_6CD8	ldb	#$1E			; para ir atrs de +30 hasta +0		; 	LD C, $05		 ; 6CD6 0E 05		; contador de filas de pixels a 5
	ldu	,x++			; lee 2 bytes del separador		; i_6CD8: LD B, $10		 ; 6CD8 06 10		; numero de repeticiones 16
i_6CDB	stu	b,y			; los pone en 2 bytes de la fila	; 	PUSH HL			 ; 6CDA E5		; Guarda HL
	subb	#2			; decrementa contador de bytes en fila	; i_6CDB: LD A, (DE)		 ; 6CDB 1A		; recupera un byte del separador
	bhs	i_6CDB			; si no negativo, sigue copiando	; 	LD (HL), A		 ; 6CDC 77		; lo pone a destino
	leay	32,y			; apunta a siguiente lnea de pixels	; 	INC HL			 ; 6CDD 23		; Incrementa puntero destino
	cmpx	#Separator+10		; lleg al final de datos?		; 	INC DE			 ; 6CDE 13		; Incrementa puntero origen
	bne	i_6CD8			; no, siguiente lnea de pixels		; 	LD A, (DE)		 ; 6CDF 1A		; lee otro byte
										; 	LD (HL), A		 ; 6CE0 77		; lo pone a destino
										; 	INC HL			 ; 6CE1 23		; Incrementa puntero destino
										; 	DEC DE			 ; 6CE2 1B		; Decrementa puntero origen para volver al primer byte
										; 	DJNZ i_6CDB		 ; 6CE3 10 F6		; repite proceso 16 veces, como son de 2 bytes, llena una linea de pixeles (32 bytes)
										; 	INC DE			 ; 6CE5 13		; Incrementa puntero origen
										; 	INC DE			 ; 6CE6 13		; dos veces (pasa al siguiente bloque de dos bytes)
										; 	POP HL			 ; 6CE7 E1		; recupera puntero HL
										; 	INC H			 ; 6CE8 24		; le suma 256 para pasar a siguiente fila de pixels
										; 	DEC C			 ; 6CE9 0D		; Decrementa contador de filas de pixels
										; 	JR NZ, i_6CD8		 ; 6CEA 20 EC		; si no es cero vuelve a i_6CD8
	lda	#$11			; pone 17 ($11)				; 	LD A, $11		 ; 6CEC 3E 11		; Pone 17 ($11) 
	sta	L_B716			; en L_B716				; 	LD (L_B716), A		 ; 6CEE 32 16 B7	; en L_B716
	lda	L_B706			; recupera L_B706 (1a vez = $FF)	; 	LD A, (L_B706)		 ; 6CF1 3A 06 B7	; recupera L_B706 (contiene $FF inicialmente)
	inca				; lo incrementa				; 	INC A			 ; 6CF4 3C		; incrementa A
	bne	MainLoop		; si no es cero, salta a mainLoop	; 	JR NZ, MainLoop		 ; 6CF5 20 1C		; si no es cero, salta a MainLoop
	tst	loaded			; have we just loaded a savegame?
	bne	1f			; yes, skip next subroutine
	jsr	L_97AD			; llama L_97AD				; 	CALL L_97AD		 ; 6CF7 CD AD 97	; si es cero llama a L_97AD (#86# OK)
1	clr	loaded			; reset flag
	ldx	#INP_BUFF_PROMPT	; apunta al prompt del buffer entrada	; 	LD HL, INP_BUFF_PROMPT	 ; 6CFA 21 F2 6F	; apunta a INP_BUFF_PROMPT
i_6CFD	lda	,x+			; lee 1 byte del prompt y suma 1 a X	; i_6CFD: LD A, (HL)		 ; 6CFD 7E		; lee un byte del buffer
	jsr	L_85B8			; llama L_85B8				; 	CALL L_85B8		 ; 6CFE CD B8 85	; llama a L_85B8 (#03#) - Parte de la impresin de un byte ASCII (sin restaurar AF) 
										; 	INC HL			 ; 6D01 23		; incrementa puntero al buffer
	cmpa	#$0D			; se imprimi un Enter?			; 	CP $0D			 ; 6D02 FE 0D		; era un $0D(ENTER)?
	bne	i_6CFD			; no, trata otro byte			; 	JR NZ, i_6CFD		 ; 6D04 20 F7		; no, vuelve a i_6CFD y lee otro byte del buffer
	ldx	#L_6FF4			; apunta a "LOOK"+CR			; 	LD HL, L_6FF4		 ; 6D06 21 F4 6F	; apunta a "LOOK"+CR
	ldu	#INP_BUFF		; apunta a buffer entrada (U=DE)	; 	LD DE, INP_BUFF		 ; 6D09 11 F9 6F	; apunta al Buffer de entrada
	ldb	#5			; numero de bytes a copiar (B=BC)	; 	LD BC, $0005		 ; 6D0C 01 05 00	; numero de bytes a mostrar
	jsr	do_ldir			; copiar datos				; 	LDIR			 ; 6D0F ED B0		; (DE+)=(HL+);BC-; Copia 5 bytes de HL a DE
	stu	<reg_DE			; actualiza reg_DE
	bra	i_6D22			; salta a i_6D22			; 	JR i_6D22		 ; 6D11 18 0F		; Salta mas abajo i_6D22 dentro del MainLoop
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
MainLoop									; MainLoop:						; (#181# --) - BUCLE PRINCIPAL
	ldd	#$0109			; valores fijos				; 	LD A, $01		 ; 6D13 3E 01		; pone 1
	sta	L_B705			; pone $01 en L_B705			; 	LD (L_B705), A		 ; 6D15 32 05 B7	; en L_B705
										; 	LD A, $09		 ; 6D18 3E 09		; pone 9
	stb	L_B716			; pone $09 en L_B716			; 	LD (L_B716), A		 ; 6D1A 32 16 B7	; en L_B716
	jsr	L_6DD6			; recibe ordenes del usuario		; 	CALL L_6DD6		 ; 6D1D CD D6 6D	; llama rutina L_6DD6 (#83# --)
	beq	i_6D8A			; si pulsada tecla '@', salta a i_6D8A	; 	JR Z, i_6D8A		 ; 6D20 28 68		; si flag Z=1, salta a i_6D8A
i_6D22	ldx	#L_709C			; apunta a L_709C (rea de 64 bytes)	; i_6D22: LD HL, L_709C		 ; 6D22 21 9C 70	; apunta a L_709C
	ldb	#$40			; contador a 64 ($40)			; 	LD B, $40		 ; 6D25 06 40		; contador a 64 ($40)
	jsr	FillWithZeros		; limpia rea 64 bytes			; 	CALL FillWithZeros	 ; 6D27 CD E2 70	; pone a cero B bytes apuntados por HL - regresa con B=0
	ldx	#INP_BUFF		; apunta al buffer de entrada (origen)	; 	LD HL, INP_BUFF		 ; 6D2A 21 F9 6F	; apunta al Buffer de entrada
	ldy	#L_709C			; apunta a L_709C (Y=IY) (destino)	; 	LD IY, L_709C		 ; 6D2D FD 21 9C 70	; apunta a zona de 64 bytes recin pasada a ceros
	sty	<reg_IY			; lo guarda en reg_IY
i_6D31	jsr	L_6E97			; parseo/validacin de palabras		; i_6D31: CALL L_6E97		 ; 6D31 CD 97 6E	; llama rutina L_6E97 (#122# OK) - Busca el final del Buffer de entradas
	ldy	<reg_IY
	cmpa	#$D0			; es A=$D0 (palabra no encontrada)?	; 	CP $D0			 ; 6D34 FE D0		; es A = $D0?
	beq	i_6DA2			; si, salta a i_6DA2			; 	JR Z, i_6DA2		 ; 6D36 28 6A		; si, salta a i_6DA2
	cmpa	#$90			; es A=$90?				; 	CP $90			 ; 6D38 FE 90		; es A = $90?
	bne	i_6D6C			; no, salta a i_6D6C			; 	JR NZ, i_6D6C		 ; 6D3A 20 30		; no, salta a i_6D6C
	lda	<reg_B			; recupera registro B			; 	LD A, B			 ; 6D3C 78		; pasa B a A
	anda	#$0F			; pone a cero nibble alto		; 	AND $0F			 ; 6D3D E6 0F		; borra 4 bits altos
	ora	<reg_C			; resultado=0?				; 	OR C			 ; 6D3F B1		; mira si BC tenia algn bit a 1 (salvo nibble alto de B)
	bne	i_6D6C			; no, salta a i_6D6C			; 	JR NZ, i_6D6C		 ; 6D40 20 2A		; no es cero, salta a i_6D6C
	lda	L_B71B			; recupera L_B71B			; 	LD A, (L_B71B)		 ; 6D42 3A 1B B7	; recupera L_B71B
										; 	AND A			 ; 6D45 A7		; es 0?
	bne	i_6D4E			; si no es cero, salta a i_6D4E		; 	JR NZ, i_6D4E		 ; 6D46 20 06		; no, salta a i_6D4E
	inca				; incrementa A				; 	INC A			 ; 6D48 3C		; es cero, incrementa A (A = 1)
	sta	L_B71B			; guarda valor en L_B71B		; 	LD (L_B71B), A		 ; 6D49 32 1B B7	; lo pone en L_B71B
	bra	i_6D6C			; salta a i_6D6C			; 	JR i_6D6C		 ; 6D4C 18 1E		; salta a i_6D6C
i_6D4E	deca				; decrementa A				; i_6D4E: DEC A			 ; 6D4E 3D		; decrementa A
	sta	L_B71B			; guarda valor en L_B71B 		; 	LD (L_B71B), A		 ; 6D4F 32 1B B7	; lo guarda en L_B71B
	lda	-2,y			; recupera valor de (Y-2)		; 	LD A, (IY-$02)		 ; 6D52 FD 7E FE	; recupera (IY-$02)
	anda	#$F0			; pasa a cero el nibble bajo		; 	AND $F0			 ; 6D55 E6 F0		; borra nibble bajo
	cmpa	#$B0			; A=$B0 (punto)?			; 	CP $B0			 ; 6D57 FE B0		; es A = $B0?
	beq	i_6D6C			; si, salta a i_6D6C			; 	JR Z, i_6D6C		 ; 6D59 28 11		; si, salta a i_6D6C
	cmpa	#$A0			; A=$A0 (coma)?				; 	CP $A0			 ; 6D5B FE A0		; es A = $A0?
	beq	i_6D6C			; si, salta a i_6D6C			; 	JR Z, i_6D6C		 ; 6D5D 28 0D		; si, salta a i_6D6C
	ldd	#$B000			; pone valor $B000 en D			; 	LD A, $B0		 ; 6D5F 3E B0		; pone $B0
	std	,y++			; en (Y+0/1), suma 2 a Y		; 	LD (IY+$00), A		 ; 6D61 FD 77 00	; en (IY+$00)
										; 	XOR A			 ; 6D64 AF		; pone 0
										; 	LD (IY+$01), A		 ; 6D65 FD 77 01	; en (IY+$01)
										; 	INC IY			 ; 6D68 FD 23		; Incrementa IY
										; 	INC IY			 ; 6D6A FD 23		; dos veces (IY=IY+2)
i_6D6C	ldd	<reg_BC			; recupera reg_BC			; i_6D6C: LD (IY+$00), B	 ; 6D6C FD 70 00	; guarda B en (IY+$00)
	std	,y++			; guarda 'BC' en (Y+0)(Y+1), suma 2 a Y	; 	LD (IY+$01), C		 ; 6D6F FD 71 01	; guarda C en (IY+$01)
										; 	INC IY			 ; 6D72 FD 23		; Incrementa IY
										; 	INC IY			 ; 6D74 FD 23		; dos veces (IY=IY+2)
	sty	<reg_IY
	lda	<reg_D			; recupera registro D			; 	LD A, D			 ; 6D76 7A		; pasa D a A
	cmpa	#$C0			; a=$C0?				; 	CP $C0			 ; 6D77 FE C0		; es $C0?
	bne	i_6D31			; no, salta a i_6D31			; 	JR NZ, i_6D31		 ; 6D79 20 B6		; no, vuelve a i_6D31
	lda	L_B71B			; recupera L_B71B 			; 	LD A, (L_B71B)		 ; 6D7B 3A 1B B7	; recupera L_B71B
										; 	AND A			 ; 6D7E A7		; es 0?
	beq	i_6D8A			; si cero, salta a i_6D8A		; 	JR Z, i_6D8A		 ; 6D7F 28 09		; si, salta a i_6D8A
					 					; 	XOR A			 ; 6D81 AF		; pone 0
	clr	L_B71B			; pone 0 en L_B71B			; 	LD (L_B71B), A		 ; 6D82 32 1B B7	; en L_B71B
	jsr	SayWhat			; llama SayWhat				; 	CALL SayWhat?		 ; 6D85 CD 2F 79	; llama SayWhat?
	bra	MainLoop		; vuelve a MainLoop			; 	JR MainLoop		 ; 6D88 18 89		; vuelve a MainLoop
					; proceso de la tecla '@'
i_6D8A	ldx	#L_709C			; apunta a L_709C			; i_6D8A: LD HL, L_709C		 ; 6D8A 21 9C 70	; apunta a L_709C
	stx	L_B6DC			; lo guarda en L_B6DC			; 	LD (L_B6DC), HL		 ; 6D8D 22 DC B6	; guarda puntero en L_B6DC
i_6D90	jsr	IfB17AZeroClearAndJmpTable75D2					; i_6D90: CALL IfB17AZeroClearAndJmpTable75D2
					; llama IfB17AZeroClearAndJmpTable75D2	; 				 ; 6D90 CD 85 75	; llama IfB17AZeroClearAndJmpTable75D2
	bne	MainLoop		; si resultado no 0, vuelve a MainLoop	; 	JP NZ, MainLoop		 ; 6D93 C2 13 6D	; Si flag Z=0, vuelve a MainLoop
	jsr	ExecuteUsrCommandsBilboEvents					; 	CALL ExecuteUsrCommandsBilboEvents
					; llama ExecuteUsrCommandsBilboEvents	; 				 ; 6D96 CD 60 79	; llama ExecuteUsrCommandsBilboEvents
	lda	L_B705			; recupera L_B705			; 	LD A, (L_B705)		 ; 6D99 3A 05 B7	; recupera L_B705
										; 	AND A			 ; 6D9C A7		; es 0?
	bne	i_6D90			; si no es cero, salta a i_6D90		; 	JR NZ, i_6D90		 ; 6D9D 20 F1		; no, vuelve a i_6D90
	lbra	MainLoop		; vuelve a mainLoop			; 	JP MainLoop		 ; 6D9F C3 13 6D	; vuelve a MainLoop
i_6DA2	ldx	#L_AD93			; apunta a L_AD93			; i_6DA2: LD HL, L_AD93		 ; 6DA2 21 93 AD	; apunta a mensaje " i do not know the word " [0x16]"
	lda	#1			; pone 1				; 	LD A, $01		 ; 6DA5 3E 01		; pone 1
	sta	PrintAreaFlag		; en PrintAreaFlag (abajo)		; 	LD (PrintAreaFlag), A	 ; 6DA7 32 01 B7	; en PrintAreaFlag (indica escribir Abajo)
	jsr	PrintMsg		; llama PrintMsg			; 	CALL PrintMsg		 ; 6DAA CD DD 72	; Muestra el mensaje " i do not know the word " [0x16]"	
	ldx	L_B6DA			; recupera (L_B6DA-DB) 			; 	LD HL, (L_B6DA)		 ; 6DAD 2A DA B6	; recupera L_B6DA. Tiene guardado PUNTERO al input buffer
i_6DB0	lda	,x			; lee 1 byte				; i_6DB0: LD A, (HL)		 ; 6DB0 7E		; recupera un caracter
	cmpa	#$0D			; es Enter?				; 	CP $0D			 ; 6DB1 FE 0D		; es Enter?
	beq	i_6DC1			; si, salta a i_6DC1			; 	JR Z, i_6DC1		 ; 6DB3 28 0C		; si, salta a i_6DC1
	cmpa	#$22			; es comillas?				; 	CP $22			 ; 6DB5 FE 22		; no, entonces, es $22(34)(")?
	beq	i_6DC1			; si, salta a i_6DC1			; 	JR Z, i_6DC1		 ; 6DB7 28 08		; si, salta a i_6DC1
	jsr	PutChar			; llama Putchar				; 	CALL PutChar		 ; 6DB9 CD 8B 85	; no, llama rutina PutChar para mostrar el caracter
	leax	1,x			; incrementa puntero			; 	INC HL			 ; 6DBC 23		; Incrementa puntero HL
	cmpa	#$20			; era espacio?				; 	CP $20			 ; 6DBD FE 20		; se mostro un espacio?
	bne	i_6DB0			; no, toma siguiente char		; 	JR NZ, i_6DB0		 ; 6DBF 20 EF		; si, vuelve a i_6DB0
i_6DC1	lda	#$22			; carga comillas			; i_6DC1: LD A, $22		 ; 6DC1 3E 22		; pone 34 ($22)(") en A
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 6DC3 CD 8B 85	; llama rutina PutChar
	jsr	PutEnter		; llama PutEnter			; 	CALL PutEnter		 ; 6DC6 CD 83 85	; llama rutina PutEnter
	lbra	MainLoop		; vuelve a MainLoop			; 	JP MainLoop		 ; 6DC9 C3 13 6D	; vuelve a MainLoop
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Interactua con usuario (acepta comandos)		      (#83# --)	;
; Resultado: Z=1 si se pulsa @ al inicio, otros casos Z=0			;
;   Utiliza: D, X(HL), reg_B, reg_C						;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_6DD6	lda 	CoCoFlg			; is it a CoCo?
	beq	1f			; no, skip two rows
	cmpa	#2			; is it a CoCo3?
	bne	2f			; no, skip two
   if DOUBLE==1 			; if running H2X
	ldx	#$3000			; timeout value for CoCo3
   else					; if running H1X or HIMG
   	ldx	#$1800			; time out for CoCo2
   endif
	fcb	#$10			; to mask next one
2	ldx	#$1800			; timeout value for CoCo2
	fcb	#$10			; to mask next one
1	ldx 	#$7fff			; pone valor $7fff			; L_6DD6: LD HL, $0BB8		 ; 6DD6 21 B8 0B	; pone valor $2EE0 12000d  (antes $0BB8 3000 decimal)
	stx	L_B714			; en control inactividad		; 	LD (L_B714), HL		 ; 6DD9 22 14 B7	; en contador inactividad L_B714
	ldd	#$3E01			; pone 1 (de B)				; 	LD A, $01		 ; 6DDC 3E 01		; pone 1
	stb	PrintAreaFlag		; en PrintAreaFlag (abajo)		; 	LD (PrintAreaFlag), A	 ; 6DDE 32 01 B7	; en PrintAreaFlag (indica Abajo)
	stb	L_B6FA			; y en L_B6FA				; 	LD (L_B6FA), A		 ; 6DE1 32 FA B6	; y en L_B6FA
					; toma '>' (de A)			; 	LD A, $3E		 ; 6DE4 3E 3E		; toma char ">"
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 6DE6 CD 8B 85	; llama PutChar
	lda	#$20			; toma espacio				; 	LD A, $20		 ; 6DE9 3E 20		; toma char " "
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 6DEB CD 8B 85	; llama PutChar
	ldx	#INP_BUFF		; apunta a buffer entrada		; 	LD HL, INP_BUFF		 ; 6DEE 21 F9 6F	; apunta al inicio del buffer de entrada
	ldb	#$80			; pone 128 en B (long. buffer)		; 	LD B, $80		 ; 6DF1 06 80		; pone $80(128) en contador B
	stb	<reg_B
i_6DF3	clr	<reg_C			; pone a cero reg_C			; i_6DF3: LD C, $00		 ; 6DF3 0E 00		; pone C a 0
i_6DF5	jsr	L_7249			; llama L_7249 (ctrl inactividad)	; i_6DF5: CALL L_7249		 ; 6DF5 CD 49 72	; llama L_7249 - A=f(B)
	tst	<reg_B			; es negativo B?			; 	BIT 7, B		 ; 6DF8 CB 78		; est a 1 el bit7 de B?
	bpl	i_6E01			; no, salta a i_6E01			; 	JR Z, i_6E01		 ; 6DFA 28 05		; no, salta a i_6E01
	cmpa	#$40			; es A #$40 '@'?			; 	CP $40			 ; 6DFC FE 40		; es A $40 ("@")? - Ver posibles teclas segun KEYBMAP1-2
	lbeq	i_6E7A			; si, salta a i_6E7A			; 	JP Z, i_6E7A		 ; 6DFE CA 7A 6E	; si, salta a i_6E7A
i_6E01	ldb	<reg_C			; recupera reg_C			; i_6E01: BIT 0, C		 ; 6E01 CB 41		; est a 1 el bit0 de C?
	bitb	#%00000001		; es 1 el bit0?
	bne	i_001			; si, salta a i_001
	jsr	L_6E4F 			; llama L_6E4F (ctrl cursores)		; 	CALL Z, L_6E4F		 ; 6E03 CC 4F 6E	; no, llama L_6E4F - flag Z=f(A,B,HL)
i_001	cmpa	#91			; para detectar Shift+Cursores
	bcs	a6E01			; si no es el caso, salta a a6E01
	anda	#%10111111		; elimina bit6, por tanto tecla pulsada
a6E01	ldb	#1			; pone 1				; 	LD C, $01		 ; 6E06 0E 01		; pone $01 en C
	stb	<reg_C			; en reg_C
	cmpa	#$15			; es A $15 (shift+'<-')?		; 	CP $18			 ; 6E08 FE 18		; es A $18? (equiv. a tecla '0' con shift o Symbol)
	bne	i_6E11			; no, salta a i_6E11			; 	JR NZ, i_6E11		 ; 6E0A 20 05		; no, salta a i_6E11
	jsr	L_6E8B			; llama L_6E8B (borra lnea)		; 	CALL L_6E8B		 ; 6E0C CD 8B 6E	; si, llama L_6E8B (#91# OK)
	bra	i_6DF3			; vuelve a i_6DF3			; 	JR i_6DF3		 ; 6E0F 18 E2		; vuelve a i_6DF3
i_6E11	cmpa	#$08			; es A $08 (backspace)?			; i_6E11: CP $08		 ; 6E11 FE 08		; es A $08 (BackSpace)?
	bne	i_6E22			; no, salta a i_6E22			; 	JR NZ, i_6E22		 ; 6E13 20 0D		; no, salta a i_6E22
	tst	<reg_B			; es negativo B?			; 	BIT 7, B		 ; 6E15 CB 78		; est a 1 el bit7 de B?
	bmi	i_6DF5			; si, vuelve a i_6DF5 (nada por borrar)	; 	JR NZ, i_6DF5		 ; 6E17 20 DC		; si, vuelve a i_6DF5
	lda	#8			; toma backspace			; 	LD A, $08		 ; 6E19 3E 08		; pone $08 en A
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 6E1B CD 8B 85	; llama PutChar
	inc	<reg_B			; incrementa contador B (chars libres)	; 	INC B			 ; 6E1E 04		; Incrementa contador B
	leax	-1,x			; decrementa puntero buffer entrada	; 	DEC HL			 ; 6E1F 2B		; Decrementa puntero buffer entrada HL
	bra	i_6DF5			; vuelve a i_6DF5			; 	JR i_6DF5		 ; 6E20 18 D3		; vuelve a i_6DF5
i_6E22	cmpa	#$40			; es A mayor que $3F?			; i_6E22: CP $40		 ; 6E22 FE 40		; compara A con $40
	bcc	i_6E3A			; si, salta a i_6E3A (son letras)	; 	JR NC, i_6E3A		 ; 6E24 30 14		; si A>=$40, salta a i_6E3A
	cmpa	#$22			; es A doble comilla?			; 	CP $22			 ; 6E26 FE 22		; es signo dobles comillas (")?
	beq	i_6E3A			; si, salta a i_6E3A			; 	JR Z, i_6E3A		 ; 6E28 28 10		; si, salta a i_6E3A
	cmpa	#$20			; es A espacio?				; 	CP $20			 ; 6E2A FE 20		; es espacio en blanco?
	beq	i_6E3A			; si, salta a i_6E3A			; 	JR Z, i_6E3A		 ; 6E2C 28 0C		; si, salta a i_6E3A
	cmpa	#$0D			; es A Enter?				; 	CP $0D			 ; 6E2E FE 0D		; es un Intro?
	beq	i_6E3A			; si, salta a i_6E3A			; 	JR Z, i_6E3A		 ; 6E30 28 08		; si, salta a i_6E3A
	cmpa	#$2E			; es A punto?				; 	CP $2E			 ; 6E32 FE 2E		; es un punto '.'?
	beq	i_6E3A			; si, salta a i_6E3A			; 	JR Z, i_6E3A		 ; 6E34 28 04		; si, salta a i_6E3A
	cmpa	#$2C			; es A coma?				; 	CP $2C			 ; 6E36 FE 2C		; es una coma ','?
	bne	i_6DF5			; no, vuelve a L_6DF5 (rechaza otros)	; 	JR NZ, i_6DF5		 ; 6E38 20 BB		; no, vueve a i_6DF5
i_6E3A	sta	L_B704			; guarda A en L_B704			; i_6E3A: LD (L_B704), A	 ; 6E3A 32 04 B7	; guarda A en L_B704
	tst	<reg_B			; es B=0? (buffer lleno)		; 	DEC B			 ; 6E3D 05		; Decrementa B
										; 	INC B			 ; 6E3E 04		; Incrementa B
	beq	i_6E47			; si, salta a i_6E47			; 	JR Z, i_6E47		 ; 6E3F 28 06		; si es 0, salta a i_6E47
	jsr	PutChar			; llama Putchar				; 	CALL PutChar		 ; 6E41 CD 8B 85	; llama PutChar
	sta	,x+			; guarda caracter en buffer entrada	; 	LD (HL), A		 ; 6E44 77		; guarda A en el buffer de entrada
					; e incrementa puntero al buffer	; 	INC HL			 ; 6E45 23		; Incrementa puntero HL
	dec	<reg_B			; decrementa contador			; 	DEC B			 ; 6E46 05		; Decrementa contador B
i_6E47	cmpa	#$0D			; era A un Enter?			; i_6E47: CP $0D		 ; 6E47 FE 0D		; era un Enter?
	bne	i_6DF5			; no, vuelve a i_6DF5			; 	JP NZ, i_6DF5		 ; 6E49 C2 F5 6D	; no, vuelve a i_6DF5
	ora	#1			; hace flag Z=0				; 	OR $01			 ; 6E4C F6 01		; pone bit0 de A a 1 (flag Z=0)
	rts				; retorna con Z=0			; 	RET			 ; 6E4E C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Gestiona los cursores, asigna direccin movimiento       (#90# OK)	;
; Parmetro: A     caracter  							;
;	     reg_B contador							;
;	     X     input buffer (HL)						;
; Resultado: flag Z								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_6E4F	cmpa	#$09			; es A $09 (cursor derecha)?		; L_6E4F: CP $09		 ; 6E4F FE 09		; es A $09 (flecha derecha)?
	beq	i_6E72			; si, salta a i_6E72			; 	JR Z, i_6E72		 ; 6E51 28 1F		; si, salta a i_6E72
	cmpa	#$08			; es A $08 (cursor izquierda)?		; 	CP $08			 ; 6E53 FE 08		; es A $08 (flecha izquierda)?
	beq	i_6E76			; si, salta a i_6E76			; 	JR Z, i_6E76		 ; 6E55 28 1F		; si, salta a i_6E76
	cmpa	#$0A			; es A $0A (cursor abajo)?		; 	CP $0A			 ; 6E57 FE 0A		; es A $0A (flecha abajo)?
	beq	i_6E6E			; si, salta a i_6E6E			; 	JR Z, i_6E6E		 ; 6E59 28 13		; si, salta a i_6E6E
	cmpa	#$5E			; es A $5E (94d)(cursor arriba)?	; 	CP $5B			 ; 6E5B FE 5B		; es A cursor arriba?
	bne	eCursor			; no, sale con Z=0			; 	RET NZ			 ; 6E5D C0		; no, retorna (no era tecla de movimiento)
	lda	#$4E			; carga letra 'N'			; 	LD A, $4E		 ; 6E5E 3E 4E		; carga A con 'N'
	fcb	$CE			; esconde siguiente como LDU $8653	; i_6E60: LD (HL), A		 ; 6E60 77		; guarda letra de 'movimiento' en zona buffer entrada
i_6E6E	lda	#$53			; carga letra 'S'			; 	INC HL			 ; 6E61 23		; incrementa el puntero
	fcb	$CE			; esconde siguiente como LDU $8645	; 	CALL PutChar		 ; 6E62 CD 8B 85	; llama rutina PutChar
i_6E72	lda	#$45			; carga letra 'E'			; 	DEC B			 ; 6E65 05		; decrementa contador B
	fcb	$CE			; esconde siguiente como LDU $8657	; 	LD A, $0D		 ; 6E66 3E 0D		; carga A con Enter
i_6E76	lda	#$57			; carga letra 'W'			; 	LD (HL), A		 ; 6E68 77		; lo pone tras el cdigo de movimiento
	sta	,x+			; la guarda en buffer entrada		; 	INC HL			 ; 6E69 23		; incrementa el puntero
										; 	DEC B			 ; 6E6A 05		; decrementa contador B
	jsr	PutChar			; llama PutChar				; 	OR $01			 ; 6E6B F6 01		; pone flag Z=0
	dec	<reg_B			; decrementa contador			; 	RET			 ; 6E6D C9		; retorna
	lda	#$0D			; carga Enter				; i_6E6E: LD A, $53		 ; 6E6E 3E 53		; carga A con 'S'
	sta	,x+			; lo guarda en buffer entrada		; 	JR i_6E60		 ; 6E70 18 EE		; vuelve a i_6E60
										; i_6E72: LD A, $45		 ; 6E72 3E 45		; carga A con 'E'
	dec	<reg_B			; decrementa contador			; 	JR i_6E60		 ; 6E74 18 EA		; vuelve a i_6E60
	ora	#1			; hace flag Z=0				; i_6E76: LD A, $57		 ; 6E76 3E 57		; carga A con 'W'
eCursor	rts				; retorna				; 	JR i_6E60		 ; 6E78 18 E6		; vuelve a i_6E60
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; proceso tecla $40 '@'			;							; proceso tecla cdigo $40
i_6E7A	lda	L_B71A			; recupera L_B71A			; i_6E7A: LD A, (L_B71A)	 ; 6E7A 3A 1A B7	; recupera L_B71A
										; 	AND A			 ; 6E7D A7		; es 0?
	lbne	i_6DF5			; si no es 0, vuelve a i_6DF5		; 	JP NZ, i_6DF5		 ; 6E7E C2 F5 6D	; no, vuelve a i_6DF5
	lda	#8			; toma valor backspace			; 	LD A, $08		 ; 6E81 3E 08		; toma valor backspace en A
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 6E83 CD 8B 85	; llama PutChar
	jsr	PutChar			; llama Putchar				; 	CALL PutChar		 ; 6E86 CD 8B 85	; llama PutChar
	clra				; A=0, flag Z=1				; 	XOR A			 ; 6E89 AF		; A=0, flag Z = 1
e6E7A	rts				; retorna				; 	RET			 ; 6E8A C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Borra la lnea de entrada  			      (#91# OK)	;
; Parmetro: reg_B  num. chars libres en linea					;
;	     X      puntero bufer entrada (HL)					;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_6E8B	tst	<reg_B			; es negativo B? (est vaca la linea)	; L_6E8B: BIT 7, B		 ; 6E8B CB 78		; est a 1 el bit7 de B?
	bmi	e6E7A			; si, sale via e6E7A			; 	RET NZ			 ; 6E8D C0		; si, retorna
	lda	#8			; carga backspace			; 	LD A, $08		 ; 6E8E 3E 08		; no, carga 8 en A (espacio atrs)
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 6E90 CD 8B 85	; llama rutina PutChar
	inc	<reg_B			; incrementa contador			; 	INC B			 ; 6E93 04		; incrementa contador B
	leax	-1,x			; decrementa puntero a buffer entrada	; 	DEC HL			 ; 6E94 2B		; decrementa HL (para apuntar un caracter antes en el buffer de entrada)
	bra	L_6E8B			; vuelve a L_6E8B			; 	JR L_6E8B		 ; 6E95 18 F4		; vuelve al principio L_6E8B
;e6E8B	rts				; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Gestiona parseo palabras entradas			     (#122# OK)	;
; Parmetro: X  Puntero al Buffer de Entrada (HL)	   			;
; Resultado: A  								;
;  Preserva: reg_DE(U)								;
;   Utiliza: D, reg_BC, reg_B, reg_C, reg_IX(Y)					;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_6E97  ldu	<reg_DE		; recupera reg_DE 
	pshs	u		; lo guarda en stack				; L_6E97: PUSH DE		 ; 6E97 D5		; Guarda el valor de "DE"
	   	     		; 						; i_6E98: LD A, (HL)		 ; 6E98 7E		; A = (HL)	; toma el contenido de (HL)
i_6E98	lda	,x+		; recupera byte de buffer entrada		; 	INC HL			 ; 6E99 23		; HL = HL + 1	; Incrementa HL
	cmpa	#$20		; es espacio?					; 	CP $20			 ; 6E9A FE 20		; A = $20?	; Compara con $20(32) = Espacio
	beq	i_6E98		; si, lee siguiente				; 	JR Z, i_6E98		 ; 6E9C 28 FA		; Si, vuelve a i_6E98 (proximo valor)
	leax	-1,x		; decrementa puntero. Apunta al ltimo	leido	; 	DEC HL			 ; 6E9E 2B		; HL = HL - 1	; Decrementa HL (Se posiciona antes del final)
	stx	L_B6DA		; guarda puntero a buffer			; 	LD (L_B6DA), HL		 ; 6E9F 22 DA B6	; (L_B6DA) = HL	; Coloca HL en $B6DA  ltimo caracter del input buffer
	cmpa	#$0D		; es Intro?					; 	CP $0D			 ; 6EA2 FE 0D		; A = 13?	; Compara con 13 (CR = Fin de linea)
	beq	i_6EDE		; si, sale via i_6EDE				; 	JR Z, i_6EDE		 ; 6EA4 28 38		; Z = 1?	; Si, salta a i_6EDE
	jsr	L_6F30		; llama L_6F30 - detecta signos especiales	; 	CALL L_6F30		 ; 6EA6 CD 30 6F	; llama a Rutina (#123# OK) que busca .," punto coma y comillas
	beq	i_6EE3		; si char especial, sale via i_6EE3		; 	JR Z, i_6EE3		 ; 6EA9 28 38		; Z = 1?	; Si es cero salta a i_6EE3, hace B = B + A y retorna a quien llamo a esta rutina
	jsr	L_6F47		; llama L_6F47					; 	CALL L_6F47		 ; 6EAB CD 47 6F	; LLama a L_6F47 (#124# OK)
	bne	i_6EBC		; si no da 0, sale via i_6EBC con marca $D0	; 	JR NZ, i_6EBC		 ; 6EAE 20 0C		; Z = 0?	; Si no es cero salta a i_6EBC
	pshs	x		; guarda puntero a buffer			; 	PUSH HL			 ; 6EB0 E5		; Guarda HL
i_6EB1	jsr	L_6FBA		; llama L_6BFA (compara palabras)		; i_6EB1: CALL L_6FBA		 ; 6EB1 CD BA 6F	; LLama rutina L_6FBA - Compara 2 cadenas (#92# OK) 
	beq	i_6EC0		; si da 0 (encontrada), salta a i_6EC0		; 	JR Z, i_6EC0		 ; 6EB4 28 0A		; Z = 1?	; Si es cero salta a i_6EC0
i_6EB6  jsr	L_6F72		; llama L_6F72	(siguiente palabra)		; i_6EB6: CALL L_6F72		 ; 6EB6 CD 72 6F	; Llama rutina L_6F72 (#125# OK)
	beq	i_6EB1		; si da 0 (encontrada una), vuelve a i_6EB1	; 	JR Z, i_6EB1		 ; 6EB9 28 F6		; Z = 1?	; si es cero salta a i_6EB1
	puls	x		; fracaso, recupera puntero al buffer		; 	POP HL			 ; 6EBB E1		; Recupera HL
i_6EBC	lda	#$D0		; carga $D0 (marca de no encontrada)		; i_6EBC: LD A, $D0		 ; 6EBC 3E D0		; A = $D0
	bra 	i_6EE0		; sale via i_6EE0				; 	JR i_6EE0		 ; 6EBE 18 20		; Salta a i_6EE0
i_6EC0	ldb	L_708A		; recupera L_708A (entrado usuario)		; i_6EC0: LD A, (L_708A)	 ; 6EC0 3A 8A 70	; A = (L_708A)	; Bytes de 0 despues del buffer de entradas
	stb	<reg_B		; lo guarda en reg_B				; 	LD B, A			 ; 6EC3 47		; B = A		; Pasa A a B
	lda	L_709B		; recupera L_709B (palabra diccionario)		; 	LD A, (L_709B)		 ; 6EC4 3A 9B 70	; A = (L_709B)	; Toma 
	cmpa	<reg_B		; es mayor que L_708A?				; 	CP B			 ; 6EC7 B8		; A = B?	; Compara B
	bcc	i_6EEB		; acepta solo si son iguales o mas cortas	; 	JR NC, i_6EEB		 ; 6EC8 30 21		; C = 0?	; Si A > B salta a i_6EEB
	cmpa	#$04		; control longitud minima aceptada		; 	CP $04			 ; 6ECA FE 04		; A = 4?	; Compara con 4
	bcs	i_6EB6		; si, vuelve a i_6EB6				; 	JR C, i_6EB6		 ; 6ECC 38 E8		; C = 1?	; Si A > 4 salta a i_6EB6, Repite
	ldy	<reg_IX		; recupera reg_IX			  	; 	PUSH IX			 ; 6ECE DD E5		; Guarda IX
	pshs	y		; guarda Y en stack
	jsr	L_6F76		; llama L_6F76					; 	CALL L_6F76		 ; 6ED0 CD 76 6F	; Llama rutuna L_6F76 (#126# OK)
	bne	i_6EE9		; si no da 0, salta a i_6EE9			; 	JR NZ, i_6EE9		 ; 6ED3 20 14		; Z = 0?	; Si no es cero salta a i_6EE9
	jsr	L_6FBA		; llama L_6FBA (compara palabras)		; 	CALL L_6FBA		 ; 6ED5 CD BA 6F	; Llama a rutina L_6FBA - Compara 2 cadenas (#92# OK) 
	bne	i_6EE9		; si no da 0, salta a i_6EE9			; 	JR NZ, i_6EE9		 ; 6ED8 20 0F		; Si no es cero salta a i_6EE9
	puls	y		; recupera Y			  	 	; 	POP IX			 ; 6EDA DD E1		; Recupera IX
	sty	<reg_IX		; actualiza reg_IX
	bra	i_6EB6		; vuelve a i_6EB6				; 	JR i_6EB6		 ; 6EDC 18 D8		; Salta a i_6EB6, Repite
i_6EDE	lda	#$C0		; carga $C0 (una marca - cdigo)		; i_6EDE: LD A, $C0		 ; 6EDE 3E C0		; A = $C0
i_6EE0	clr	<reg_B		; pone a 0
	clr 	<reg_C		; reg_BC					; i_6EE0: LD BC, $0000		 ; 6EE0 01 00 00	; BC = $0000
i_6EE3	puls	u		; recupera U
	stu	<reg_DE		; la guarda en reg_DE				; i_6EE3: POP DE		 ; 6EE3 D1		; Recupera DE
	sta	<reg_D		; guarda A en reg_D				; 	LD D, A			 ; 6EE4 57		; D = A,	; Guarda el valor de "A"
	adda	<reg_B		; le suma reg_B					; 	ADD A, B		 ; 6EE5 80		; A = A + B
	sta	<reg_B		; guarda resultado en reg_B			; 	LD B, A			 ; 6EE6 47		; B = A,	; B = B + A
	lda	<reg_D		; recupera A de reg_D				; 	LD A, D			 ; 6EE7 7A		; A = D,	; Repone el valor de "A"
	rts			; retorna					; 	RET			 ; 6EE8 C9		; Retorna
i_6EE9	puls	y		; recupera Y					; i_6EE9: POP IX		 ; 6EE9 DD E1		; Recupera IX	
	sty	<reg_IX		; actualiza reg_IX
i_6EEB	ldy	L_B717		; recupera L_B717-18
	sty	<reg_IX		; lo pasa a reg_IX				; i_6EEB: LD IX, (L_B717)	 ; 6EEB DD 2A 17 B7	; Carga IX con (L_B717)
	pshs	y		; guarda y					; 	PUSH IX			 ; 6EEF DD E5		; Guarda IX
	clra			; borra A					; 	XOR A			 ; 6EF1 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
i_6EF2	leay	1,y		; incrementa puntero Y				; i_6EF2: INC IX		 ; 6EF2 DD 23		; Incrementa IX
	sty	<reg_IX
	inca			; incrementa A					; 	INC A			 ; 6EF4 3C		; Incrementa A
	tst	-1,y		; es (Y-1) negativo?				; 	BIT 7, (IX-$01)		 ; 6EF5 DD CB FF 7E	; Esta a 1 el bit 7 de (IX-$01)?
	bpl	i_6EF2		; no, vuelve a i_6EF2				; 	JR Z, i_6EF2		 ; 6EF9 28 F7		; Si Z = 1, Salta a i_6EF2
	cmpa	#2		; es A $02?					; 	CP $02			 ; 6EFB FE 02		; Compara A con $02
	beq	i_6EF2		; si, vuelve a i_6EF2				; 	JR Z, i_6EF2		 ; 6EFD 28 F3		; Si Z = 1, Salta a i_6EF2
	cmpa	#3		; es A $03					; 	CP $03			 ; 6EFF FE 03		; Compara A con $03
	bne	i_6F09		; no, salta a i_6F09				; 	JR NZ, i_6F09		 ; 6F01 20 06		; Si Z = 0, Salta a i_6F09
	tst	-2,y		; es (Y-2) negativo?				; 	BIT 7, (IX-$02)		 ; 6F03 DD CB FE 7E	; Esta a 1 el bit 7 de (IX-$02)?
	bmi	i_6EF2		; si, vuelve a i_6EF2				; 	JR NZ, i_6EF2		 ; 6F07 20 E9		; Si Z = 0, Salta a i_6EF2
i_6F09	ldb	-1,y		; recupera (Y-1)
	andb	#%01000000	; $40, tiene bit6 a 1?				; i_6F09: BIT 6, (IX-$01)	 ; 6F09 DD CB FF 76	; Esta a 1 el bit 6 de (IX-$01)?
	beq	i_6F1A		; no, salta a i_6F1A				; 	JR Z, i_6F1A		 ; 6F0D 28 0B		; Si Z = 1, Salta a i_6F1A
	ldx	,y		; toma dos bytes de Y				; 	LD L, (IX+$00)		 ; 6F0F DD 6E 00	; Carga L con (IX+$00)
	ldd	#WordIndex	; carga direccin de WordIndex			; 	LD H, (IX+$01)		 ; 6F12 DD 66 01	; Carga H con (IX+$01)
	std	<reg_DE		; lo guarda en reg_DE				; 	LD DE, WordIndex	 ; 6F15 11 00 60	; Pointers to words A-Z
	leax	d,x		; la suma a X					; 	ADD HL, DE		 ; 6F18 19		; Adiciona DE en HL
	stx	,s		; actualiza X(HL) en el stack		   	; 	EX (SP), HL		 ; 6F19 E3		; Intercambia (SP) con HL
i_6F1A	puls	x		; recupera X 					; i_6F1A: POP HL		 ; 6F1A E1		; Recupera HL
	lda	,x		; toma un byte del buffer			; 	LD A, (HL)		 ; 6F1B 7E		; Carga A con (HL)
	lsla			; rota a izquierda (bit7 al carry)		; 	RLCA			 ; 6F1C 07		; Rota A a la izquierda circularmente (b7 entra en b0)
	anda	#%11000000	; $C0, deja solo bits 6-7			; 	AND $C0			 ; 6F1D E6 C0		; Hace AND lgico de A con $C0
	sta	<reg_B		; guarda resultado en reg_B			; 	LD B, A			 ; 6F1F 47		; Carga B con A
	leax	1,x		; incrementa X					; 	INC HL			 ; 6F20 23		; Incrementa HL
	lda	,x		; toma siguiente byte del buffer		; 	LD A, (HL)		 ; 6F21 7E		; Carga A con (HL)
	lsra			; rota a derecha (bit0 al carry)		; 	RRCA			 ; 6F22 0F		; Rota A a la derecha circularmente (b0 entra en b7)
i_003	anda	#%00110000	; $30, deja solo bits 4-5			; 	AND $30			 ; 6F23 E6 30		; Hace AND lgico de A con $30
	adda	<reg_B		; le suma reg_B					; 	ADD A, B		 ; 6F25 80		; Adiciona B en A
	leax	-1,x		; decrementa puntero				; 	DEC HL			 ; 6F26 2B		; Decrementa HL
										; 	LD DE, $A000		 ; 6F27 11 00 A0	; Carga DE con $A000
	leax	$A000,x		; le suma a puntero X $A000			; 	ADD HL, DE		 ; 6F2A 19		; Adiciona DE en HL
	stx	<reg_BC		; pasa X al reg_BC				; 	PUSH HL			 ; 6F2B E5		; Guarda HL
										; 	POP BC			 ; 6F2C C1		; Recupera BC
	puls	x		; recupera X					; 	POP HL			 ; 6F2D E1		; Recupera HL
	bra	i_6EE3		; sale via i_6EE3				; 	JR i_6EE3		 ; 6F2E 18 B3		; B = B + A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Detecta y codifica signos especiales ('.', ',', '"')    (#123# OK)	;
; Parmetro: A - char a analizar						;
; Resultado: A y flag Z	(1=char especial, 0=no char especial)			;
;   Utiliza: B, X(HL), reg_BC							;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_6F30	ldb	#$B0		; carga $B0 (marca de '.')			; L_6F30: LD B, $B0		 ; 6F30 06 B0		; B = $B0
	cmpa	#$2E		; es A $2E '.'?					; 	CP $2E			 ; 6F32 FE 2E		; Compara con $2E(46) = '.' = Punto
	beq	i_6F41		; si, salta a i_6F41				; 	JR Z, i_6F41		 ; 6F34 28 0B		; Salta si son iguales
	ldb	#$A0		; carga $A0 (marca de ',')			; 	LD B, $A0		 ; 6F36 06 A0		; B = $A0
	cmpa	#$2C		; es A $2C ','?					; 	CP $2C			 ; 6F38 FE 2C		; Compara con $2C(44) = ',' = coma
	beq	i_6F41		; si, salta a i_6F41				; 	JR Z, i_6F41		 ; 6F3A 28 05		; Salta si son iguales
	stb	<reg_B
	cmpa	#$22		; es A $22 '"'?					; 	CP $22			 ; 6F3C FE 22		; Compara con $22(34) = '"' = comillas
	bne	e6F30		; no, sale 					; 	RET NZ			 ; 6F3E C0		; Retorna si no es cero
	ldb	#$90		; carga $90 (marca de '"')			; 	LD B, $90		 ; 6F3F 06 90		; B = $90
i_6F41	leax	1,x		; incrementa puntero X				; i_6F41: INC HL		 ; 6F41 23		; Incrementa HL
	tfr	b,a		; pasa B a A					; 	LD A, B			 ; 6F42 78		; A = B
	clr	<reg_B		;
	clr	<reg_C		; borra reg_BC					; 	LD BC, $0000		 ; 6F43 01 00 00	; BC = $0000
e6F30	rts			; retorna					; 	RET			 ; 6F46 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Busca Palabras en el Diccionario			     (#124# OK) ;
; Parmetro: X  Buffer Entrada	(HL)						;
; Resultado: Area 16 bytes (L_707A) via U(DE)					;
;	     flag Z (0=1a letra diferente, 1=una palabra encontrada)		;
;   Utiliza: D, reg_DE(U), reg_BC, reg_IX(Y) 					;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_6F47	ldu	#L_707A		; carga direccin de L_707A (16 bytes)
	stu	<reg_DE		; la guarda en reg_DE				; L_6F47: LD DE, L_707A		 ; 6F47 11 7A 70	; DE = $707A	;Almacenamiento de 32 bytes despues del buffer de entrada
	clr	<reg_B		; borra reg_B					; 	LD B, $00		 ; 6F4A 06 00		; B = 0
i_6F4C	lda	,x		; toma un byte del buffer			; i_6F4C: LD A, (HL)		 ; 6F4C 7E		; A = (HL)
	cmpa	#$40		; es menor que $40 (signo)?			; 	CP $40			 ; 6F4D FE 40		; Comparar con $40 = @
	bcs	i_6F59		; si, salta a i_6F59				; 	JR C, i_6F59		 ; 6F4F 38 08		; Salta si Carry = 1, A es menor que $40 (no es letra, luego es fin de palabra!)
	anda	#%00011111	; $1F, borra los 3 bits altos			; 	AND $1F			 ; 6F51 E6 1F		; A = A AND $1F
	sta	,u+		; lo guarda en bloque 16 bytes			; 	LD (DE), A		 ; 6F53 12		; (DE) = A
										; 	INC DE			 ; 6F54 13		; DE = DE +1
	leax	1,x		; incrementa puntero X				; 	INC HL			 ; 6F55 23		; HL = HL +1
	inc	<reg_B		; incrementa contador reg_B			; 	INC B			 ; 6F56 04		; B = B + 1
	bra	i_6F4C		; vuelve a i_6F4C				; 	JR i_6F4C		 ; 6F57 18 F3		; Repetir
i_6F59	lda	<reg_B		; recupera reg_B				; i_6F59: LD A, B		 ; 6F59 78		; A = B
	sta	L_708A		; lo guarda en L_708A				; 	LD (L_708A), A		 ; 6F5A 32 8A 70	; ($708A) = A	;Almacenamiento de 32 bytes despues del buffer de entrada
	pshs	d,x		; guarda D,X					; 	PUSH HL			 ; 6F5D E5		; Guarda el valor de HL
	ldb	L_707A		; carga la primera letra de L_707A		; 	LD HL, (L_707A)		 ; 6F5E 2A 7A 70	; HL = ($707A)
	clra			; borra byte alto				; 	LD H, $00		 ; 6F61 26 00		; H = 0
	aslb			; multiplica D					
	rola			; por 2						; 	LD DE, WordIndex	 ; 6F63 11 00 60	; DE = $6000	;Pointers to words A-Z
	ldx	#WordIndex	; le suma direccion de WordIndex		; 	ADD HL, HL		 ; 6F66 29		; HL = HL + HL			
										; 	ADD HL, DE		 ; 6F67 19		; HL = HL + DE
	ldu	d,x		; lee 2 bytes de X 			        ; 	LD E, (HL)		 ; 6F68 5E		; E = (HL)
	stu	<reg_DE		; lo guarda en reg_DE				; 	INC HL			 ; 6F69 23		; HL = HL + 1
	ldd	#WordIndex	; carga direccin de WordIndex			; 	LD D, (HL)		 ; 6F6A 56		; D = (HL)
	leau	d,u		; la suma a los 2 bytes leidos de X		; 	LD IX, WordIndex	 ; 6F6B DD 21 00 60	; IX = $6000	;Pointers to words A-Z
	stu	<reg_IX		; lo pasa a reg_IX				; 	ADD IX, DE		 ; 6F6F DD 19		; IX = IX + DE  ; apunta a 1a palabra que empieza por la letra recibida
	puls	d,x		; recupera D,X					; 	POP HL			 ; 6F71 E1		; recupera HL
										; 							; (#125# OK)
L_6F72	ldy	<reg_IX		; recupera reg_IX				; L_6F72: LD (L_B717), IX	 ; 6F72 DD 22 17 B7	; ($B717) = IX
	sty	L_B717		; lo guarda en L_B717				; 
										; 							; (#126# OK)
L_6F76	lda	,y		; recupera (Y)					; L_6F76: LD A, (IX + $00)	 ; 6F76 DD 7E 00	; A = (IX)
	anda	#$1F		; borra 3 bits altos (MODO)			; 	AND $1F			 ; 6F79 E6 1F		; A = A AND $1F
	sta	<reg_B		; lo guarda en reg_B				; 	LD B, A			 ; 6F7B 47		; B = A
	lda	L_707A		; recupera L_707A (primer caracter)		; 	LD A, (L_707A)		 ; 6F7C 3A 7A 70	; A = ($707A)
	cmpa	<reg_B		; es igual a reg_B?				; 	CP B			 ; 6F7F B8		; Comparar con B
	bne	e6F76		; no, sale via e6F76 con Z=0			; 	RET NZ			 ; 6F80 C0		; Retorna si no es cero
	pshs	x		; guarda X					; 	PUSH HL			 ; 6F81 E5		; Guarda HL
	ldx	#L_708B		; apunta a L_708B				; 	LD HL, L_708B		 ; 6F82 21 8B 70	; HL = $708B
	clr	<reg_B		;
	clr	<reg_C		; borra reg_BC					; 	LD BC, $0000		 ; 6F85 01 00 00	; BC = $0000
i_6F88	lda	,y		; lee (Y)					; i_6F88: LD A, (IX+$00)	 ; 6F88 DD 7E 00	; A = (IX)
	anda	#$1F		; borra los 3 bits altos			; 	AND $1F			 ; 6F8B E6 1F		; A = A + $1F
	beq	i_6F92		; si da 0, salta a i_6F92			; 	JR Z, i_6F92		 ; 6F8D 28 03		; Salta si es cero
	sta	,x+		; guarda el byte en el buffer			; 	LD (HL), A		 ; 6F8F 77		; (HL) = A
				; e incrementa puntero				; 	INC HL			 ; 6F90 23		; HL = HL +1
	inc	<reg_B		; incrementa contador reg_B			; 	INC B			 ; 6F91 04		; B = B + 1
i_6F92	leay	1,y		; incrementa puntero Y(IX)			; i_6F92: INC IX		 ; 6F92 DD 23		; IX = IX + 1
	sty	<reg_IX		; guarda Y en reg_IX
	inc	<reg_C		; incrementa contador reg_C			; 	INC C			 ; 6F94 0C		; C = C + 1
	tst	-1,y		; es (Y-1) negativo?				; 	BIT 7, (IX-$01)		 ; 6F95 DD CB FF 7E	; Si el BIT 7 de (XI + 1)
	bpl	i_6F88		; no, vuelve a i_6F88				; 	JR Z, i_6F88		 ; 6F99 28 ED		; Si flag Z=1, salta a i_6F88
	lda	<reg_C		; recupera reg_C				; 	LD A, C			 ; 6F9B 79		; A = C
	cmpa	#2		; es $02?					; 	CP $02			 ; 6F9C FE 02		; Compara con $02
	beq	i_6F88		; si, vuelve a i_6F88				; 	JR Z, i_6F88		 ; 6F9E 28 E8		; Si flag Z=1, salta a i_6F88
	cmpa	#3		; es $03?					; 	CP $03			 ; 6FA0 FE 03		; Compara con $03
	bne	i_6FAA		; no, salta a $6FAA				; 	JR NZ, i_6FAA		 ; 6FA2 20 06		; Si flag Z=0, salta a i_6FAA
	tst	-2,y		; es (Y-2) negativo?				; 	BIT 7, (IX-$02)		 ; 6FA4 DD CB FE 7E	; Test BIT 7 de (IX + $02)
	bmi	i_6F88		; si, vuelve a i_6F88				; 	JR NZ, i_6F88		 ; 6FA8 20 DE		; Salta si no es cero
i_6FAA	puls	x		; recupera X					; i_6FAA: POP HL		 ; 6FAA E1		; Recupera HL
	lda	<reg_B		; recupera reg_B				; 	LD A, B			 ; 6FAB 78		; A = B
	sta	L_709B		; lo guarda en L_709B				; 	LD (L_709B), A		 ; 6FAC 32 9B 70	; ($709B) = A
	ldb	-1,y		; recupera (Y-1)
	bitb	#%01000000	; est el bit6 a 1? (estamos ante sinnimo)	; 	BIT 6, (IX-$01)		 ; 6FAF DD CB FF 76	; Test BIT 6 de (IX - $01)		
	beq	e6F76		; no, sale con Z=1				; 	RET Z			 ; 6FB3 C8		; Z = 1?	; Retorna si es cero
	leay	2,y		; suma 2 a puntero Y para saltarlo		; 	INC IX			 ; 6FB4 DD 23		; IX = IX + 1
	sty	<reg_IX		; guarda reg_IX					; 	INC IX			 ; 6FB6 DD 23		; IX = IX + 1
	clra			; borra A para salir con Z=1			; 	XOR A			 ; 6FB8 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
e6F76	rts			; retorna					; 	RET			 ; 6FB9 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Compara dos cadenas				      (#92# OK)	;
; Parmetro: L_709B y L_708A longitud de las cadenas				;				  			; Compara DOS cadenas 
;            L_708B y L_707A direccin inicio cadenas				;				  			; L_708A y L_709B deben ser las longitudes de las cadenas a comparar
; Resultado: flag Z=1 si son iguales, Z=0 resto casos				;				  			; (#92# OK) - Si iguales retorna con flag Z=1, si distintas con flag Z=0
;   Utiliza: D, X(HL), U(DE) 							;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_6FBA	ldb	L_708A		; recupera L_708A				; L_6FBA: LD A, (L_708A)	 ; 6FBA 3A 8A 70	; A toma el valor de L_708A
	stb	<reg_B		; guarda reg_B					; 	LD B, A			 ; 6FBD 47		; se guarda en B
	lda	L_709B		; recupera L_709B				; 	LD A, (L_709B)		 ; 6FBE 3A 9B 70	; A toma el valor de L_709B
	cmpa	<reg_B		; es A mayor o igual que L_708A?		; 	CP B			 ; 6FC1 B8		; calcula A-B
	bcc	i_6FC5		; si, salta a i_6FC5				; 	JR NC, i_6FC5		 ; 6FC2 30 01		; si A >= B (flag C=0), se salta la proxima instruccin
	sta	<reg_B		; pasa A a B (guarda el menor)			; 	LD B, A			 ; 6FC4 47		; guarda en B el valor de A (menor de A,B)
i_6FC5	ldx	#L_707A		; apunta a L_707A				; i_6FC5: LD HL, L_707A		 ; 6FC5 21 7A 70	; carga puntero HL desde L_707A
	ldu	#L_708B		; apunta a L_708B				; 	LD DE, L_708B		 ; 6FC8 11 8B 70	; y puntero DE desde L_708B
i_6FCB	lda	,u		; lee un byte de U				; i_6FCB: LD A, (DE)		 ; 6FCB 1A		; lee un byte de DE
	cmpa	,x		; es igual al de X?				; 	CP (HL)			 ; 6FCC BE		; lo compara con el apuntado por HL
	bne	e6FBA		; no, sale					; 	RET NZ			 ; 6FCD C0		; si no son iguales retorna
	leau	1,u		; incrementa puntero U(DE)			; 	INC DE			 ; 6FCE 13		; incrementa puntero DE
	leax	1,x		; incrementa puntero X(HL)			; 	INC HL			 ; 6FCF 23		; incrementa puntero HL
	stu	<reg_DE		; guarda reg_DE
	dec	<reg_B		; decrementa contador letras
	bne	i_6FCB		; si no es 0, siguiente letra			; 	DJNZ i_6FCB		 ; 6FD0 10 F9		; decrementa contador de bytes a comparar y mientras flag Z=0, bucle a i_6FCB
e6FBA	rts			; retorna					; 	RET			 ; 6FD2 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Borra pantalla PMode4				  (# sinNumero)	;
;  Preserva: D, X								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ClearScreen				; borrado de pantalla completa		; ClearScreen:
	pshs	d,x			; guarda registros			; 	PUSH HL			 ; 6FD3 E5		; Guarda HL
	ldx	#$0E00			; apunta a inicio de pantalla		; 	PUSH DE			 ; 6FD4 D5		; Guarda DE
	ldd	#$FFFF			; carga todo Unos (fondo blanco)	; 	PUSH BC			 ; 6FD5 C5		; Guarda BC
CLS01	std	,x++			; pasa a 0 2 bytes			; 	LD A, $07		 ; 6FD6 3E 07		; Carga A con $07
	cmpx	#$2600			; fin de pantalla?			; 	OUT ($FE), A		 ; 6FD8 D3 FE		; el valor de A se escribe en el puerto $FE
	blo	CLS01			; no, sigue				; 	LD HL, $4000		 ; 6FDA 21 00 40	; Carga HL con $4000
	puls	d,x,pc			; recupera registros y retorna		; 	LD DE, $4001		 ; 6FDD 11 01 40	; Carga DE con $4001
										; 	LD BC, $1800		 ; 6FE0 01 00 18	; Carga BC con $1800
										; 	LD (HL), $00		 ; 6FE3 36 00		; Carga (HL) con $00
										; 	LDIR			 ; 6FE5 ED B0		; (DE+)=(HL+);BC-	; Copia $1800 bytes de HL a DE
										; 	LD BC, $0300		 ; 6FE7 01 00 03	; Carga BC con $0300
										; 	LD (HL), $38		 ; 6FEA 36 38		; Carga (HL) con $38
										; 	LDIR			 ; 6FEC ED B0		; (DE+)=(HL+);BC-	; Copia $300 bytes de HL en DE
										; 	POP BC			 ; 6FEE C1		; Recupera BC
										; 	POP DE			 ; 6FEF D1		; Recupera DE
										; 	POP HL			 ; 6FF0 E1		; Recupera HL
										; 	RET			 ; 6FF1 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Llenar con ceros algunos bytes			  (# sinNumero)	;
; Parmetro: X puntero al inicio de bytes a pasar a 0				;
;            B nmero de Bytes que hay que pasar a 0				;
;   Utiliza: A 									;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
FillWithZeros				; pone 0 en B bytes apuntados por X	; FillWithZeros:					; Borra B Bytes desde HL ; (# sinNumero)
	clra				; toma valor 0				; 	XOR A			 ; 70E2 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
i_70E3	sta	,x+			; borra un byte				; i_70E3: LD (HL), A		 ; 70E3 77		; (HL) = A	; Borra el contenido apuntado por HL
	decb				; decrementa contador			; 	INC HL			 ; 70E4 23		; HL = HL + 1	; con B como contador de veces
	bne	i_70E3			; si todava no es cero, sigue		; 	DJNZ i_70E3		 ; 70E5 10 FC		; B=B-1, Z=0?	; Decrementa B y Repite si no es 0
	rts				; retorna				; 	RET			 ; 70E7 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; GetActionPtr - devuelve puntero en HL a la accin recibida en A	; antes (#104# OK)
										; 							; Entrada A es el cdigo de la acccin ($01-$3B)	
										; 							; Salida	  HL apuntador a la accin
GetActionPtr									; GetActionPtr:						; (# sinNumero)
	pshs	a			; guarda A				; 	LD L, A		 	 ; 70E8 6F		; L = A		; carga codigo como byte bajo
	ldb	#8			; factor a aplicar			; 	LD H, $00		 ; 70E9 26 00		; H = 0		; a cero byte alto
	mul				; multiplica				; 	ADD HL, HL		 ; 70EB 29		; lo multiplica	; HL = HL + HL
										; 	ADD HL, HL		 ; 70EC 29		; por 8
										; 	ADD HL, HL		 ; 70ED 29		; cada entrada son 8 bytes
	ldx	#ACTIONS-8		; direccin 8 bytes antes de ACTIONS	; 	LD  DE, ACTIONS-$08	 ; 70EE 11 4B AB	; DE = $AB4B	; apunta 8 bytes antes de la tabla de Acciones
	leax	d,x			; apunta al offset calculado		; 	ADD HL, DE		 ; 70F1 19		; HL = HL + DE	; le suma offset al cdigo deseado
	puls	a,pc			; recupera A y retorna			; 	RET			 ; 70F2 C9		; Retorna	; retorna HL como puntero
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; antes ; (#127# OK)
										; 							; guarda los flags de las 4 palabras de la accion (8 bytes) 
										; 							; en memoria fija en bytes ActionFlags1 y ActionFlags2
										; 							; ActionFlags1 contiene los flags de los bytes 3 y 1 en nibble alto-bajo respectivamente
SaveActionFlags									; SaveActionFlags:					; ActionFlags2 contiene los flags de los bytes 7 y 5 en nibble alto-bajo respectivamente
	ldy	<reg_IX			; recupera reg_IX			; 	LD A, (IX+$05)		 ; 70F3 DD 7E 05	; Carga en A El contenido de IX + 5
	lda	4,y			; toma byte de (Y+4)
	lsra				; lo divide				; 	RRCA			 ; 70F6 0F		; pasa los
	lsra				; por 16				; 	RRCA			 ; 70F7 0F		; 4 bits altos (atributos)
	lsra				; los 4 bits altos			; 	RRCA			 ; 70F8 0F		; hacia los
	lsra				; aparecen en los 4 bajos		; 	RRCA			 ; 70F9 0F		; 4 bits bajos 
										; 	AND $0F			 ; 70FA E6 0F		; Conserva solo los bits 0-3 (atributos movidos abajo)
	sta	<reg_C			; guarda resultado en reg_C		; 	LD C, A			 ; 70FC 4F		; guarda resultado en C
	lda	6,y			; toma byte de (Y+6)			; 	LD A, (IX+$07)		 ; 70FD DD 7E 07	; carga en A el contenido de IX + 7
	anda	#$F0			; a 0 los 4 bits bajos			; 	AND $F0			 ; 7100 E6 F0		; Conserva solo los bits 4-7 (atributos)
	adda	<reg_C			; le suma los 4 bits bajos de reg_C	; 	ADD A, C		 ; 7102 81		; forma un byte con los dos nibbles calculados: Atributos (4a palabra - 3a palabra)
	sta	ActionFlags2		; lo guarda en ActionFlags2		; 	LD (ActionFlags2), A	 ; 7103 32 1E B7	; guarda este resultado en ActionFlags2
	lda	,y			; toma byte de (Y+0)			; 	LD A, (IX+$01)		 ; 7106 DD 7E 01	; carga en A el contenido de IX + 1
	lsra				; lo divide				; 	RRCA			 ; 7109 0F		; pasa los
	lsra				; por 16				; 	RRCA			 ; 710A 0F		; 4 bits altos (atributos)
	lsra				; los 4 bits altos			; 	RRCA			 ; 710B 0F		; hacia los
	lsra				; aparecen en los 4 bajos		; 	RRCA			 ; 710C 0F		; 4 bits bajos 
										; 	AND $0F			 ; 710D E6 0F		; Conserva solo los bits 0-3 (atributos movidos abajo)
	sta	<reg_C			; guarda resultado en reg_C		; 	LD C, A			 ; 710F 4F		; guarda resultado en C
	lda	2,y			; toma byte de (Y+2)			; 	LD A, (IX+$03)		 ; 7110 DD 7E 03	; Carga en A el contenido de IX + 3
	anda	#$F0			; a 0 los 4 bits bajos			; 	AND $F0			 ; 7113 E6 F0		; Conserva solo los bits 4-7 (atributos)
	adda	<reg_C			; le suma los 4 bits bajos de reg_C	; 	ADD A, C		 ; 7115 81		; forma un byte con los dos nibbles calculados: Atributos (2a palabra - 1a palabra)
	sta	ActionFlags1		; lo guarda en ActionFlags1		; 	LD (ActionFlags1), A	 ; 7116 32 1D B7	; guarda este resultado en ActionFlags1
	rts				; retorna				; 	RET			 ; 7119 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_711A	clra				; pone 0				; L_711A: XOR A			 ; 711A AF		; pasa a 0
	sta	L_B6FB			; en L_B6FB				; 	LD (L_B6FB), A		 ; 711B 32 FB B6	; L_B6FB
	inca				; pone 1				; 	INC A			 ; 711E 3C		; pasa a 1
	sta	L_B6FA			; en L_B6FA				; 	LD (L_B6FA), A		 ; 711F 32 FA B6	; L_B6FA
	lda	L_B71B			; recupera L_B71B			; 	LD A, (L_B71B)		 ; 7122 3A 1B B7	; Carga A con (L_B71B)
	bne	e_711A			; si no 0, salta siguiente		; 	AND A			 ; 7125 A7		; adecua flags
	jsr	DescribeActionOnScreen	; llama	DescribeActionOnScreen		; 	CALL Z, DescribeActionOnScreen
										; 				 ; 7126 CC 2B 71	; si es cero, llama DescribeActionOnScreen
e_711A	clra				; flag Z=1				; 	XOR A			 ; 7129 AF		; A=0, flag Z = 1
	rts				; retorna				; 	RET			 ; 712A C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DescribeActionOnScreen								; DescribeActionOnScreen:				; presenta en pantalla la accin que se lleva a cabo ; antes ; (#93# --)
	lda	#1			; pone 1				; 	LD A, $01            	 ; 712B 3E 01   	; pone 1
	sta	DeterminerTable		; en DeterminerTable			; 	LD (DeterminerTable), A	 ; 712D 32 DF 70 	; en DeterminerTable
	clr	L_B703			; pone 0 en L_B703			; 	XOR A             	 ; 7130 AF      	; pone 0
	ldy	<reg_IY			; recupera reg_IY			; 	LD (L_B703), A           ; 7131 32 03 B7 	; en L_B703
	pshs	y			; guarda Y(IY)				; 	PUSH IY             	 ; 7134 FD E5   	; Guarda IY
	ldu	<reg_BC			; recupera reg_BC
	pshs	u			; guarda U(BC)				; 	PUSH BC             	 ; 7136 C5      	; Guarda BC
	ldb	L_B6FB			; recupera L_B6FB			; 	LD A, (L_B6FB)           ; 7137 3A FB B6 	; recupera L_B6FB
	stb	<reg_B			; lo guarda en reg_B			; 	LD B, A             	 ; 713A 47      	; guarda A en B
	lda	#1			; toma valor 1				; 	AND A             	 ; 713B A7      	; actualiza flags
	tstb				; es reg_B 0?				; 	LD A, $01             	 ; 713C 3E 01   	; A = 1
	beq	i_7141			; si, salta a i_7141			; 	JR Z, i_7141          	 ; 713E 28 01   	; Si L_B6FB es 0, se salta la siguiente instruccin
	clra				; toma valor 0				; 	XOR A             	 ; 7140 AF      	; A = 0
i_7141	sta	PrintAreaFlag		; pone A en PrintAreaFlag		; i_7141: LD (PrintAreaFlag), A  ; 7141 32 01 B7 	; pone A en PrintAreaFlag
	ldy	<reg_IX			; recupera reg_IX
	pshs	x,y			; guarda X(HL), Y(IX)			; 	PUSH IX             	 ; 7144 DD E5   	; Guarda IX
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH HL             	 ; 7146 E5      	; Guarda HL
	pshs	u			; guarda U(DE)				; 	PUSH DE             	 ; 7147 D5      	; Guarda DE
	lda	CurrentAction		; recupera CurrentAction		; 	LD A, (CurrentAction)    ; 7148 3A E7 B6   	; Carga ID de accin
	jsr	GetActionPtr		; llama GetActionPtr			; 	CALL GetActionPtr        ; 714B CD E8 70   	; recibe en HL puntero a la accin pasada en A
										; 	PUSH HL             	 ; 714E E5      	; pasa HL
	leay	,x			; pasa X(HL) a Y(IX)			; 	PUSH HL             	 ; 714E E5      	; pasa HL
	stx	<reg_IX			; guarda reg_IX				; 	POP IX             	 ; 714F DD E1   	; a IX
										; 	XOR A             	 ; 7151 AF      	; A = 0
	tst	<reg_B			; es reg_B 0?				; 	CP B                	 ; 7152 B8      	; era 0 el contenido de L_B6FB?
	beq	i_715C			; si, salta a i_715C			; 	JR Z, i_715C          	 ; 7153 28 07   	; si, salta a i_715C
	lda	ActionActor		; recupera ActionActor			; 	LD A, (ActionActor)      ; 7155 3A EA B6   	; Carga ActionActor
	bne	i_715C			; si no es 0, salta una instruccion	; 	AND A             	 ; 7158 A7      	; es 0?
	jsr	PutEnter		; llama PutEnter			; 	CALL Z, PutEnter       	 ; 7159 CC 83 85   	; si, llama PutEnter
i_715C	jsr	SaveActionFlags		; llama SaveActionFlags			; i_715C: CALL SaveActionFlags   ; 715C CD F3 70   	; llama SaveActionFlags: A=$B71D contiene Flags2 y 1 - $B71E contiene Flags4 y 3
	sta	<reg_C			; guarda A en reg_C			; 	BIT 4, A             	 ; 715F CB 67      	; Est a 1 el bit4 de A?
	bita	#%00010000		; est el bit4 a 1?			; 	LD C, A            	 ; 7161 4F      	; Guarda A en C (copia de los flags de palabras 2 y 1)
	bne	i_71C9			; si, salta a i_71C9			; 	JP NZ, i_71C9          	 ; 7162 C2 C9 71   	; Si flag 0 de la palabra 2 est a uno, salir
	jsr	PrintActorName		; llama PrintActorName			; 	CALL PrintActorName    	 ; 7165 CD A7 73   	; llama PrintActorName
	ldu	#$00EE			; pone valor $00EE
	stu	<reg_DE			; en reg_DE				; 	LD DE, $00EE          	 ; 7168 11 EE 00   	; Carga DE con $00EE = palabra "CANNOT"
										; 	XOR A             	 ; 716B AF      	; A = 0
	tst	<reg_B			; es reg_B 0?				; 	CP B                	 ; 716C B8      	; era 0 el contenido de L_B6FB?
	bne	e_715C			; no, salta siguiente
	jsr	PrintWord		; llama PrintWord			; 	CALL Z, PrintWord        ; 716D CC C1 74   	; si, aade al buffer de salida la palabra apuntada por DE
e_715C	pshs	x			; guarda X(HL)				; 	PUSH HL             	 ; 7170 E5      	; Guarda HL (puntero a la accin)
	ldd	#$0006			; pone valor $0006
	std	<reg_DE			; en reg_DE				; 	LD DE, $0006          	 ; 7171 11 06 00   	; Carga DE con $0006 (offset)
	leax	d,x			; sumaq D(DE a X(HL)			; 	ADD HL, DE          	 ; 7174 19      	; suma DE en HL para apuntar a la cuarta palabra de la accin en curso (solo puede ser "GO")
	jsr	PrintWordNoAttr		; llama PrintWordNoAttr			; 	CALL PrintWordNoAttr   	 ; 7175 CD BA 74   	; llama rutina PrintWordNoAttr
	jsr	IsItDark		; llama IsItDark			; 	CALL IsItDark          	 ; 7178 CD ED 95   	; llama rutina IsItDark
	puls	x			; recupera X(HL)			; 	POP HL             	 ; 717B E1      	; Recupera HL (puntero a la accin)
	bcc	i_718F			; si Carry es 0, salta a i_718F		; 	JR NC, i_718F          	 ; 717C 30 11   	; Si C = 0 (NO es oscuro), salta a i_718F
	lda	CurrentAction		; recupera CurrentAction		; 	LD A, (CurrentAction)    ; 717E 3A E7 B6   	; recupera CurrentAction
	cmpa	#$0B			; es mayor o igual que 11?		; 	CP $0B                	 ; 7181 FE 0B   	; Compara A con $0B
	bcc	i_718F			; si, salta a i_718F			; 	JR NC, i_718F          	 ; 7183 30 0A   	; Si Carry = 0 (A >= $0B), Salta a i_718F
	ldu	#$0AEA			; pone valor $0AEA
	stu	<reg_DE			; en reg_DE				; 	LD DE, $0AEA          	 ; 7185 11 EA 0A   	; Carga DE con $0AEA = palabra "SOMEWHERE" 
	leax	2,x			; suma 2 a X(HL)			; 	INC HL             	 ; 7188 23      	; Incrementa HL
										; 	INC HL             	 ; 7189 23      	; dos veces, apunta a segunda palabra de la accin
	jsr	PrintWord		; llama PrintWord			; 	CALL PrintWord           ; 718A CD C1 74   	; aade al buffer de salida la palabra apuntada por DE
	bra	i_7192			; salta a i_7192			; 	JR i_7192             	 ; 718D 18 03   	; Salta a i_7192
i_718F	jsr	PrintWordNoAttr		; llama PrintWordNoAttr			; i_718F: CALL PrintWordNoAttr   ; 718F CD BA 74   	; llama rutina PrintWordNoAttr con primera palabra de la accin
i_7192	ldb	<reg_C			; recupera reg_C			; i_7192: BIT 3, C          	 ; 7192 CB 59      	; Es cero el flag 3 de la palabra 1?
	bitb	#%00001000		; est a 1 el bit3?
	beq	i_71A6			; no, salta a i_71A6			; 	JR Z, i_71A6          	 ; 7194 28 10      	; Si, Salta a i_71A6
	bitb	#%00100000		; est a 1 el bit5?			; 	BIT 5, C             	 ; 7196 CB 69      	; Esta a 1 el flag 1 de la palabra 2?
	beq	e_7192			; no, salta siguiente
	jsr	PrintWordNoAttr		; llama PrintWordNoAttr			; 	CALL NZ, PrintWordNoAttr ; 7198 C4 BA 74   	; si, llama rutina PrintWordNoAttr (imprime la segunda palabra)
e_7192	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)   	 ; 719B 3A 1E B7   	; recuepra ActionFlags2 = flags de palabras 4 y 3
	bpl	c_7192			; si bit7 es 0, salta a c_7192		; 	BIT 7, A             	 ; 719E CB 7F      	; Esta a 1 el flag 3 de la palabra 4?
	jsr	PrintWordNoAttr		; llama PrintWordNoAttr			; 	CALL NZ, PrintWordNoAttr ; 71A0 C4 BA 74   	; si, llama rutina PrintWordNoAttr, imprime siguiente palabra de la accin
c_7192	jsr	PrintMainObjectLoc	; llama	PrintMainObjectLoc		; 	CALL PrintMainObjectLoc	 ; 71A3 CD B4 73   	; llama PrintMainObjectLoc
i_71A6	lda	SecondObject		; recupera SecondObject			; i_71A6: LD A, (SecondObject)   ; 71A6 3A E9 B6   	; Carga cdigo objeto secundario
	cmpa	#$FF			; es $FF (ninguno)?			; 	CP $FF             	 ; 71A9 FE FF      	; es A = $FF?
	beq	i_71C1			; si, salta a i_71C1			; 	JR Z, i_71C1          	 ; 71AB 28 14      	; Si, Salta a i_71C1
	ldb	<reg_C			; recupera reg_C
	bitb	#%00000100		; est a 1 el bit2?			; 	BIT 2, C             	 ; 71AD CB 51      	; Esta a 1 el flag 2 de palabra1?
	beq	i_71C1			; no, salta a i_71C1			; 	JR Z, i_71C1          	 ; 71AF 28 10      	; no, Salta a i_71C1
	bitb	#%00100000		; esta a 1 el bit5?			; 	BIT 5, C             	 ; 71B1 CB 69      	; Esta a 1 el flag 1 de palabra2?
	bne	e_71A6			; si, salta siguiente
	jsr	PrintWordNoAttr		; llama PrintWordNoAttr			; 	CALL Z, PrintWordNoAttr  ; 71B3 CC BA 74   	; no, llama rutina PrintWordNoAttr
e_71A6	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)     ; 71B6 3A 1E B7   	; recupera ActionFlags2 = flags de palabras 4 y 3
	bmi	c_71A6			; si bit7 a 1, salta siguiente		; 	BIT 7, A             	 ; 71B9 CB 7F      	; Esta a 1 el flag 3 de palabra4?
	jsr	PrintWordNoAttr		; llama PrintWordNoAttr			; 	CALL Z, PrintWordNoAttr  ; 71BB CC BA 74   	; no, llama rutina PrintWordNoAttr
c_71A6	jsr	PrintSecObjectLoc	; llama PrintSecObjectLoc		; 	CALL PrintSecObjectLoc   ; 71BE CD C7 73   	; llama PrintSecObjectLoc
i_71C1	lda	#$2E			; toma ASCII de '.'			; i_71C1: LD A, $2E          	 ; 71C1 3E 2E      	; Carga A con $2E = codigo ASCII de '.'
	jsr	PutChar			; llama	PutChar				; 	CALL PutChar          	 ; 71C3 CD 8B 85   	; llama rutina PutChar
	jsr	PutEnter		; llama PutEnter			; 	CALL PutEnter          	 ; 71C6 CD 83 85   	; llama rutina PutEnter
i_71C9	clra				; pone 0				; i_71C9: XOR A             	 ; 71C9 AF      	; pone valor 0
	sta	DeterminerTable		; en DeterminerTable			; 	LD (DeterminerTable), A	 ; 71CA 32 DF 70   	; en DeterminerTable
	puls	u			; recupera U(DE)
	stu	<reg_DE			; lo guarda en reg_DE			; 	POP DE             	 ; 71CD D1      	; Recupera DE
	puls	x,y			; recupera X(HL), Y(IX)			; 	POP HL             	 ; 71CE E1      	; Recupera HL
	sty	<reg_IX			; lo guarda en reg_IX			; 	POP IX             	 ; 71CF DD E1   	; Recupera IX
	puls	u			; recupera U(BC)
	stu	<reg_BC			; lo guarda en reg_BC			; 	POP BC             	 ; 71D1 C1      	; Recupera BC
	puls	y			; recupera Y(IY)
	sty	<reg_IY			; lo guarda en reg_IY			; 	POP IY             	 ; 71D2 FD E1   	; Recupera IY
	rts				; retorna				; 	RET                	 ; 71D4 C9      	; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#15#	 OK)
										; 							; Rutina que coloca en HL el puntero a la zona de 6 bytes con los punteros a las palabras de 
PointHLTo3WordsLoc								; PointHLTo3WordsLoc:					; descripcin de una localizacin pasada en A.
	ldy	<reg_IX			; recupera reg_IX			; 	PUSH IX          	 ; 71D5 DD E5      	; guarda IX
	pshs	y			; lo guarda				; 	CALL GetLocPointer2IX    ; 71D7 CD B1 9B   	; llama GetLocPointer2IX recibe en IX puntero a localizacin de A
	jsr	GetLocPointer2IX	; llama GetLocPointer2IX		; 	PUSH IX          	 ; 71DA DD E5      	; pasa IX
					 					; 	POP HL          	 ; 71DC E1     		; a HL
	leax	2,y			; pasa Y(IX)+2 a X(HL)			; 	INC HL          	 ; 71DD 23     		; le aade
	puls	y			; recupera Y(IX)			; 	INC HL          	 ; 71DE 23     		; dos para apuntar a la primera palabra descriptiva
	sty	<reg_IX			; lo guarda en reg_IX			; 	POP IX          	 ; 71DF DD E1      	; recupera IX
	rts				; retorna				; 	RET          		 ; 71E1 C9     		; retorna
																				; 							; Rutina que coloca en HL el puntero a la zona de 6 bytes con los punteros a las palabras de 
PointHLTo3WordsObj								; PointHLTo3WordsObj: 					; descripcin de uun objeto pasado en A ; antes ; (#16# OK)
	ldy	<reg_IX			; recupera reg_IX			; 	PUSH DE          	 ; 71E2 D5     		; guarda DE
	pshs	y			; guarda Y(IX)				; 	PUSH IX          	 ; 71E3 DD E5      	; guarda IX
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX    ; 71E5 CD CA 9B   	; llama GetObjPointer2IX devuelve puntero al objeto en IX
										; 	PUSH IX          	 ; 71E8 DD E5      	; pasa IX
										; 	POP HL          	 ; 71EA E1     		; a HL
										; 	LD DE, $0008       	 ; 71EB 11 08 00   	; carga DE con 8
	leax	8,y			; suma 8 a Y(IX) y lo pasa a X(HL)	; 	ADD HL, DE       	 ; 71EE 19     		; lo suma a HL para apuntar a la primera palabra dscriptiva
	puls	y			; recupera Y(IX)			; 	POP IX          	 ; 71EF DD E1      	; recupera IX
	sty	<reg_IX			; lo guarda en reg_IX			; 	POP DE          	 ; 71F1 D1     		; recupera DE
	rts				; retorna				; 	RET          		 ; 71F2 C9     		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Verifica si la orden recibida es procesable ; antes ; (#145# --)
										; 							; parametros IY: tabla ACTIONS (registros de 8 bytes. Cada palabra 2 bytes)
										; 							;            HL: apunta a L_7958 (3 punteros a palabras)
DoesActionMatch									; DoesActionMatch:					; retorna Z=1 si cuadran las palabras, Z=0 si NO cuadran
					; no se guarda (ni se usa)		; 	PUSH DE			 ; 71F3 D5		; Guarda DE
	ldu	<reg_IY			; recupera reg_IY			; 	PUSH HL			 ; 71F4 E5		; Guarda HL
	pshs	u,x			; guarda U(IY),X(HL) quedan invertidos!	; 	PUSH IY			 ; 71F5 FD E5		; Guarda IY
	jsr	Do2WordsMatch		; llama Do2WordsMatch			; 	CALL Do2WordsMatch	 ; 71F7 CD 2E 72	; llama Do2WordsMatch(IY, HL)
	bne	i_7229			; si no da 0, salta a i_7229		; 	JR NZ, i_7229		 ; 71FA 20 2D		; Si Z=0, Sale via i_7229 (1a palabra no cuadra)
	lda	#1			; pone 1				; 	LD A, $01		 ; 71FC 3E 01		; pone valor 1
	sta	L_B6DF			; en L_B6DF				; 	LD (L_B6DF), A		 ; 71FE 32 DF B6	; en L_B6DF
	jsr	Do2WordsMatch		; llama	Do2WordsMatch			; 	CALL Do2WordsMatch	 ; 7201 CD 2E 72	; llama Do2WordsMatch(IY+2, HL+2)
	bne	i_720D			; si no da 0, salta a i_720D		; 	JR NZ, i_720D		 ; 7204 20 07		; Si Z=0, Salta a i_720D  (1a palabra no cuadra)
	jsr	Do2WordsMatch		; llama	Do2WordsMatch			; 	CALL Do2WordsMatch	 ; 7206 CD 2E 72	; llama Do2WordsMatch(IY+4, HL+4)
	tfr	cc,b			; pasa flags a B
	clra				; borra A				; 	LD A, $00		 ; 7209 3E 00		; A=0, no afecta flags
	tfr	b,cc			; recupera flags de B
	beq	i_7229			; si 0, salta a i_7229			; 	JR Z, i_7229		 ; 720B 28 1C		; Si Z=1, sale via i_7229 (han cuadrado las tres palabras)
i_720D	ldu	2,s			; recupera U(IY) x estar invertidos	; i_720D: POP IY		 ; 720D FD E1		; Recupera IY
	ldx	,s			; recupera X(HL)			; 	POP HL			 ; 720F E1		; Recupera HL
										; 	PUSH HL			 ; 7210 E5		; Guarda HL
										; 	PUSH IY			 ; 7211 FD E5		; Guarda IY
	leau	4,u			; suma 4 a U(IY)			; 	LD DE, $0004		 ; 7213 11 04 00	; le suma 4
	stu	<reg_IY			; actualiza reg_IY			; 	ADD IY, DE		 ; 7216 FD 19		; a IY
	leax	2,x			; suma 2 a X(HL)			; 	INC HL			 ; 7218 23		; Incrementa HL
										; 	INC HL			 ; 7219 23		; dos veces
	jsr	Do2WordsMatch		; llama Do2WordsMatch			; 	CALL Do2WordsMatch	 ; 721A CD 2E 72	; llama Do2WordsMatch(IY+4, HL+2) - (mira si 2a y 3a palabras estan invertidas)
	bne	i_7229			; si no da 0, salta a i_7229		; 	JR NZ, i_7229		 ; 721D 20 0A		; Si Z=0, sale via i_7229 (no cuadran tampoco)
	ldu	<reg_IY			; recupera reg_IY
	leau	-4,u			; resta 4 de U(IY)			; 	LD DE, $FFFC		 ; 721F 11 FC FF	; Carga DE con $FFFC (equivale a -4)
	stu	<reg_IY			; actualiza reg_IY			; 	ADD IY, DE		 ; 7222 FD 19		; lo resta de IY
	jsr	Do2WordsMatch		; llama Do2WordsMatch			; 	CALL Do2WordsMatch	 ; 7224 CD 2E 72	; llama Do2WordsMatch(IY+2, HL+4) - (mira 3a con 2a deberian cuadrar)
	tfr	cc,b			; guarda flags resultado en B
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 7227 3E 01		; Carga A con $01, no afecta flags
	bra	e_7229			; salta la siguiente
i_7229	tfr	cc,b			; guarda flags en B
e_7229	puls	x,u			; recupera X(HL),U(IY)			; i_7229: POP IY		 ; 7229 FD E1		; Recupera IY
	stu	<reg_IY			; actualiza reg_IY
	tfr	b,cc			; recupera flags de B			; 	POP HL			 ; 722B E1		; Recupera HL
					; DE no se guard			; 	POP DE			 ; 722C D1		; Recupera DE
	rts				; retorna				; 	RET			 ; 722D C9		; Retorna con Z= resultado comparacin ltima realizada
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Verifica si dos palabras (comando y Actions) coinciden ; antes ; (#170# --)
										; 							; parametros HL = apunta a zona de 3 punteros a palabras ($7958-$795D)
Do2WordsMatch									; Do2WordsMatch:						;            IY = tabla ACTIONS (palabras)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 722E E5		; Guarda HL
	ldy	<reg_IY			; recupera reg_IY
	ldd	,x			; toma 2 bytes de (X+0)			; 	LD A, (HL)		 ; 722F 7E		; Carga A con 1er byte apuntado por HL
										; 	INC HL			 ; 7230 23		; Incrementa HL
										; 	OR (HL)			 ; 7231 B6		; es nula la palabra apuntada por HL?
	beq	i_7241			; si son 0, salta a i_7241		; 	JR Z, i_7241		 ; 7232 28 0D		; si, sale via i_7241
	lda	,y			; toma byte alto			; 	LD A, (IY+$01)		 ; 7234 FD 7E 01	; no, recupera byte alto de la palabra de la tabla acciones
	eora	,x			; hace EOR con (X(HL))			; 	XOR (HL)		 ; 7237 AE		; EXORea A con la palabra alta de zona de punteros a palabras
	anda	#$0F			; guarda 4 bits bajos			; 	AND $0F			 ; 7238 E6 0F		; se guarda los 4 bits bajos
	bne	i_7241			; si no es 0, salta a i_7241		; 	JR NZ, i_7241		 ; 723A 20 05		; Si hay algun bit a 1, sale via i_7241
										; 	DEC HL			 ; 723C 2B		; Decrementa HL (recupera valor inicial)
	lda	1,x			; toma byte bajo     			; 	LD A, (HL)		 ; 723D 7E		; toma byte bajo palabra apuntada por HL
	cmpa	1,y			; es igual byte bajo?			; 	CP (IY+$00)		 ; 723E FD BE 00	; es igual a byte bajo de la tabla de acciones?
i_7241	tfr	cc,b			; guarda flags en B
	puls	x			; recupera X(HL)			; i_7241: POP HL		 ; 7241 E1		; Recupera HL
	leax	2,x			; le suma 2				; 	INC HL			 ; 7242 23		; le suma 2
										; 	INC HL			 ; 7243 23		; para pasar a siguiente palabra
	leay	2,y			; suma 2 a Y(IY)			; 	INC IY			 ; 7244 FD 23		; le suma 2 a IY
	sty	<reg_IY			; actualiza reg_IY			; 	INC IY			 ; 7246 FD 23		; para pasar a siguiente palabra de la accin
	tfr	b,cc			; recupera flags de B (comparacin)
	rts				; retorna				; 	RET			 ; 7248 C9		; Retorna con flag Z segn resultado de $723E
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Controla inactividad de usuario			      (#89# --) ;
; Resultado: A  tecla pulsada por el usuario					;
;  Preserva: X (HL)	 							;
;   Utiliza: B, reg_DE(U), reg_B						;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7249	pshs	x			; guarda registro 			; L_7249: PUSH HL		 ; 7249 E5		; Guarda puntero a buffer entrada HL
	ldx	L_B714			; recupera contador inactividad		; 	LD HL, (L_B714)		 ; 724A 2A 14 B7	; recupera contador inactividad L_B714
i_724D	jsr	GetKey			; llama GetKey				; i_724D: CALL GetKey		 ; 724D CD 93 8B	; llama GetKey
	tsta				; recibida tecla?			; 	AND A			 ; 7250 A7		; recibida alguna tecla?
	bne	i_7273			; si, salta a i_7273			; 	JR NZ, i_7273		 ; 7251 20 20		; si, salta a i_7273
	leax	-1,x			; decrementa contador			; 	DEC HL			 ; 7253 2B		; Decrementa contador inactividad HL
										; 	LD A, H			 ; 7254 7C		; Carga A con byte alto de HL
										; 	OR L			 ; 7255 B5		; es HL=0?
	bne	i_724D			; si no es cero, vuelve a i_724D	; 	JR NZ, i_724D		 ; 7256 20 F5		; no, vuelve a i_724D
	ldx	,s			; carga x con valor recibido		; 	POP HL			 ; 7258 E1		; Recupera HL del stack
										; 	PUSH HL			 ; 7259 E5		; lo guarda de nuevo
	jsr	L_6E8B			; llama L_6E8B	(borra linea)		; 	CALL L_6E8B		 ; 725A CD 8B 6E	; llama rutina L_6E8B - Pone BackSpaces
	ldu	#L_7291			; apunta a "WAIT" (U=DE)		; 	LD DE, L_7291		 ; 725D 11 91 72	; apunta a L_7291 (rea palabra "WAIT")
	ldb	#4			; carga 4 caracteres			; 	LD B, $04		 ; 7260 06 04		; carga B con $04 (cantidad de letras)
i_7262	lda	,u+			; toma un char				; i_7262: LD A, (DE)		 ; 7262 1A		; recupera una letra
	sta	,x+			; lo guarda en buffer entrada		; 	LD (HL), A		 ; 7263 77		; la pone en el buffer de entrada
	stu	<reg_DE			; lo guarda en reg_DE			; 	INC HL			 ; 7264 23		; incrementa puntero buffer entrada
	jsr 	PutChar			; llama PutChar				; 	INC DE			 ; 7265 13		; incrementa puntero area WAIT
	decb				; decrementa contador			; 	CALL PutChar		 ; 7266 CD 8B 85	; llama PutChar
	bne	i_7262			; si no es cero, vuelve a i_7262	; 	DJNZ i_7262		 ; 7269 10 F7		; si no ha acabado de guardar WAIT, vuelve a i_7262
	ldd	,s			; recupera valor anterior de HL (del stack)
	exg	d,x			; lo intercambia con X
	std	,s			; pasa nuevo HL (X) al stack	  	; 	EX (SP), HL		 ; 726B E3		; guarda HL actual en el stack (sustituyendo al recibido)
	ldd	#$0D7C			; carga A y B				; 	LD B, $7C		 ; 726C 06 7C		; carga B con $7C (124)
	stb	<reg_B			; guarda B en reg_B			; 	LD A, $0D		 ; 726E 3E 0D		; carga A con $0D
										;							; proceso tecla recibida
i_7273	ldu	#$9664			; carga U con $9664 (DE)		; i_7273: PUSH AF		 ; 7273 F5		; guarda AF
	stu	<reg_DE			; lo pasa a reg_DE			; 	XOR A			 ; 7274 AF		; A=0, flag Z=1, flag C=0
										; 	LD DE, $01F4		 ; 7275 11 F4 01	; carga DE con $01F4 (decimal +500)
										; 	ADC HL, DE		 ; 7278 ED 5A		; aade DE y el carry a HL
										; 	LD DE, $0BB8		 ; 727A 11 B8 0B	; carga DE con $0BB8 (3000 decimal)
										; 	JR C, i_7284		 ; 727D 38 05		; si flag C=1, Salta a i_7284 (hubo carry al hacer el ADC HL,DE)
										; 	CALL L_728B		 ; 727F CD 8B 72	; llama rutina L_728B - flag C=f(HL,DE) Compara HL y DE
										; 	JR C, i_7285		 ; 7282 38 01		; si flag C=1, Salta a i_7285 (si DE>HL)
										; i_7284: EX DE, HL		 ; 7284 EB		; intercambia DE con HL (para guardar el mayor de los dos)
	stu	L_B714			; guarda U en L_B714			; i_7285: LD (L_B714), HL	 ; 7285 22 14 B7	; guarda HL en contador L_B714
										; 	POP AF			 ; 7288 F1		; recupera AF
										; 	POP HL			 ; 7289 E1		; recupera HL
	puls	x,pc			; recupera X y retorna			; 	RET			 ; 728A C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; NOT for 6809				; 							; (#171# --)
										; L_728B: LD A, H		 ; 728B 7C		; pasa byte alto HL a A
										; 	SUB D			 ; 728C 92		; le resta byte alto de DE
										; 	RET NZ			 ; 728D C0		; si distintos, retorna
										; 	LD A, L			 ; 728E 7D		; pasa byte bajo de HL a A
										; 	SUB E			 ; 728F 93		; le resta byte bajo de DE
										; 	RET			 ; 7290 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#11# OK) Si A = 13 (Enter) borra L_B704 y retorna, Si no Retorna
L_72C3	jsr	PutChar			; llama PutChar				; L_72C3: CALL PutChar		 ; 72C3 CD 8B 85	; llama rutina PutChar
	cmpa	#$0D			; era un Intro?				; 	CP $0D			 ; 72C6 FE 0D		; A = $0D(Enter); es A = 13 (enter)?
	bne	e72C3			; no, sale				; 	RET NZ			 ; 72C8 C0		; Z = 0?	; no, retorna al que llamo
	clra				; pone 0				; 	XOR A			 ; 72C9 AF		; A = A XOR A	; A = 0, flag Z = 1
	sta	L_B704			; en L_B704				; 	LD (L_B704), A		 ; 72CA 32 04 B7	; (L_B704) = A	; Borra L_B704
e72C3	rts				; retorna				; 	RET			 ; 72CD C9		; Retorna al que llamo
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#211# --)
L_72CE	ldx	#L_AFBF			; apunta a L_AFBF			; L_72CE: LD HL, L_AFBF		 ; 72CE 21 BF AF	; HL = L_AFBF	; Direccin de "i cannot do that"
	bra	PrintMsg		; llama PrintMsg			; 	JR PrintMsg		 ; 72D1 18 0A		; Imprime "i cannot do that" PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;###NoName01:						; (#146# --) Va a PrintMsg y pone L_B6FA a 0 si L_B71B no es 0
L_72D3	lda	L_B71B			; recupera L_B71B			; L_72D3: LD A, (L_B71B)	 ; 72D3 3A 1B B7	; A = (L_B71B)
										; 	AND A			 ; 72D6 A7		; Adecua flags
	beq	PrintMsg		; si 0, salta a PrintMsg		; 	JR Z, PrintMsg		 ; 72D7 28 04		; si es cero, salta a PrintMsg
	clra				; pone 0				; 	XOR A			 ; 72D9 AF		; pone valor 0
	sta	L_B6FA			; en L_B6FA				; 	LD (L_B6FA), A		 ; 72DA 32 FA B6	; en L_B6FA y va a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							;	Rutina PrintMsg
										; 							;	Parmetro de Entrada
										; 							;	HL = Direccin del texto a imprimir
										; 							;Los mensajes estn Tokenizados (codificados)
										; 							;Se leen de byte en byte
										; 							;Si tiene el bit 7 a 1 (valor igual o superior a $80)
										; 							;entonces los bits 4-5-6 contienen mas informacin
										; 							;A estos bits se les llama MODO y segn su valor significan
										; 							;	000 - 0	   no hay que hacer nada mas										
										; 							;	001 - 1	   hay que aadir una 's' al final de la palabra							
										; 							;	010 - 2	   es la palabra que cierra el mensaje (la ltima a mostrar)						
										; 							;	011 - 3	   punto final y fin de mensaje tras la palabra								
										; 							;	100 - 4	   la palabra acaba en 's','d','ing','es' (visto como diferencia cual de ellas es)			
										; 							;	101 - 5	   no hace nada, igual que el modo 0									
										; 							;	110 - 6	   sale de PrintMsg con Enter										
										; 							;	111 - 7	   la primera letra de la palabra debe ser mayscula							
										; 							;
										; 							;	En todos estos casos, el puntero a la palabra codificada se forma as
										; 							;	$6000 + (byte ledo & $0F)*256 + siguiente Byte (el &0F elimina los 4 bits altos)
										; 							;	La parte central utiliza los 4 bits mas bajos de byte ya que los otros contienen el Modo y el indicador (bit7)	
										; 							;
										; 							;Si no tiene el bit 7 a 1, entonces
										; 							;	si el byte es menor que $20(32), se trata de una rutina especial que imprime algo. 
										; 							;	Ver PrintMsg Action rutine Table (REQUIERE ESTUDIAR EL CODIGO Z80, Hay muchas!!)			     
										; 							;	si el byte est entre $20(32) y $60(96) es un caracter ASCII directo, se imprime sin mas			
										; 							;	si el byte es mayor que $60(96), se le resta esta cifra (x=byte-96) y se utiliza como ndice para 
										; 							;	acceder a la tabla de palabras comunes donde est el puntero a la palabra representada			     
										; 							;
										; 							;NO hay mas casos posibles.
										; 							;
										; 							;------------------------------------------------------------------------------------
PrintMsg									; 							; (# sinNumero)
	ldu	<reg_DE			; recupera reg_DE
	stu	DECopyPM		; lo guarda en DECopyPM			; PrintMsg: LD (DECopyPM), DE	 ; 72DD ED 53 DD 70	; (DECopyPM) = DE	; Guarda DE en zona de datos (-DATA_PrintMsg-)
	ldu	<reg_IX			; recupera reg_IX 
	stu	IXCopyPM		; lo guarda en IXCopyPM			; 	LD (IXCopyPM), IX	 ; 72E1 DD 22 E0 70	; (IXCopyPM) = IX	; 
	sta	ACopyPM			; guarda A en ACopyPM			; 	LD (ACopyPM), A		 ; 72E5 32 DC 70	; (ACopyPM) = A	; 
	lda	L_B6FA			; recupera L_B6FA			; 	LD A, (L_B6FA)		 ; 72E8 3A FA B6	; A = (L_B6FA)
										; 	AND A			 ; 72EB A7		; A = A AND A	; Adecua flags
	bne	L_72F1			; si no es 0, salta la siguiente	; 	JR NZ, L_72F1		 ; 72EC 20 03		; Z = 0?	; Si no es cero, Salta la proxima instruccin hasta L_72F1
	sta	L_B6FB			; guarda A en L_B6FB			; 	LD (L_B6FB), A		 ; 72EE 32 FB B6	; Si es cero, Borra (L_B6FB)=0 
L_72F1	leay	,x			; pasa X a Y				; L_72F1: PUSH HL		 ; 72F1 E5		; Pasa HL
	sty	<reg_IX			; lo guarda en reg_IX			; 	POP IX			 ; 72F2 DD E1		; a IX, ahora es el apuntador a textos
i_72F4	ldd	,y			; recupera dos bytes			; i_72F4: LD A, (IX+$00)	 ; 72F4 DD 7E 00	; A = (IX+$00) Toma un caracter
	tsta				; es negativo el primero?		; 	BIT 7, A		 ; 72F7 CB 7F		; Tiene el BIT 7 encendido?
	bpl	L_7318			; no, salta a L_7318			; 	JR Z, L_7318		 ; 72F9 28 1D		; No, Salta a L_7318 (no es un puntero)
										; 							; Proceso de bytes dobles (word pointers)
	anda	#$7F			; pasa bit7 a 0				; 	AND $7F			 ; 72FB E6 7F		; Limpia Bit 7 a 0
	std	<reg_DE			; guarda los 2 bytes			; 	LD D, A			 ; 72FD 57		; D = A
	tfr	d,u			; en U					; 	LD E, (IX+$01)		 ; 72FE DD 5E 01	; E = (IX+$01) Proximo byte a E
	leay	1,y			; incrementa puntero			; 	INC IX			 ; 7301 DD 23		; IX = IX + 1 (Ahora apunta al segundo byte cargado)
	sty 	<reg_IX			; actualiza reg_IX
	anda	#$F0			; borra los 4 bis bajos			; 	AND $F0			 ; 7303 E6 F0		; Borra Bits 0-3 para procesar bits 4-5-6 (MODO)
	cmpa	#$30			; es A $30?				; 	CP $30			 ; 7305 FE 30		; Es MODO 3?, esta encendido el bit 4-5? (punto y termina el mensaje)
	beq	L_7348			; si, salta a L_7348			; 	JR Z, L_7348		 ; 7307 28 3F		; Si, salta adelante a L_7348
	cmpa	#$20			; es A $20?				; 	CP $20			 ; 7309 FE 20		; Es MODO 2?, esta encendido el bit 5? (termina el mensaje)
	beq	L_7348			; si, salta a L_7348			; 	JR Z, L_7348		 ; 730B 28 3B		; Si, salta adelante a L_7348
	cmpa	#$60			; es A $60?				; 	CP $60			 ; 730D FE 60		; Es MODO 6?, esta encendido el bit 5-6? (manejo desconocido)
	beq	L_7348			; si, salta a L_7348			; 	JR Z, L_7348		 ; 730F 28 37		; Si, salta adelante a L_7348
										; 							; No, Hace uno de estos modos
										; 							; 1 (termina en 's')
										; 							; 4 (termina en s, d, ing or es)
										; 							; 5 (Desconocido)
										; 							; 7 (Primera letra en mayuscula)
L_7311	jsr	PrintWord		; llama PrintWord			; L_7311: CALL PrintWord	 ; 7311 CD C1 74	; aade al buffer de salida la palabra apuntada por DE
L_7314	ldy	<reg_IX			; recupera reg_IX
	leay	1,y			; incrementa puntero			; L_7314: INC IX		 ; 7314 DD 23		; Incrementa el apuntador a textos
	sty	<reg_IX			; actualiza reg_IX
	bra	i_72F4			; vuelve a L_72F4			; 	JR i_72F4		 ; 7316 18 DC		; bucle a siguiente byte i_72F4
										; 							; Procesa simple byte (sin apuntadores)
L_7318	cmpa	#$20			; es A menor que 32?			; L_7318: CP $20		 ; 7318 FE 20		; Es menor que 32 ($20)? = (Rutina de accin especial)
	bcs	L_7326			; si, ir a rutina acciones especiales	; 	JR C, L_7326		 ; 731A 38 0A		; Si, ir a Rutina de accin especial L_7326 
	cmpa	#$60			; es A mayor que 96?			; 	CP $60			 ; 731C FE 60		; Es mayor que 96 ($60)? = (proceso de palabras comunes)
	lbcc	L_7493			; si, salta a L_7493 (palabras comunes)	; 	JP NC, L_7493		 ; 731E D2 93 74	; Si, ir a proceso de palabras comunes (#10# OK) L_7493
	jsr	L_72C3			; llama L_72C3 (texto ASCII plano)	; 	CALL L_72C3		 ; 7321 CD C3 72	; si no esto es un byte de texto plano, ir a procesarlo (#11# OK)
	bra	L_7314			; vuelve a L_7314			; 	JR L_7314		 ; 7324 18 EE		; Proximo ciclo L_7314, Proximo byte (token)
										; 							; (Rutina de accin especial)
										; 							; Calcula el punto de entrada de la rutina en HL
L_7326	pshs	a			; guarda A				; L_7326: PUSH DE		 ; 7326 D5		; Guarda DE
	ldb	#2			; para doblar valor de A		; 	LD E, A			 ; 7327 5F		; E = A Pasa el byte recibido & $7F (Cdigo de rutina)
	mul				; D = 2* A				; 	LD D, $00		 ; 7328 16 00		; D = 0, Borra byte alto de DE
	ldx	#L_7295			; apunta a tabla acciones especiales	; 	LD HL, L_7295		 ; 732A 21 95 72	; HL = Direccin del comienzo de la Tabla de acciones especiales
	leax	d,x			; calcula offset segun D		; 	ADD HL, DE		 ; 732D 19		; Suma inicio + indice para obtener direccin apuntada
										; 	ADD HL, DE		 ; 732E 19		; 2 veces porque cada entrada tiene 2 bytes
										; 	LD E, (HL)		 ; 732F 5E		; E = (HL) Carga el byte bajo en E
										; 	INC HL			 ; 7330 23		; HL = HL + 1 apunta al proximo byte
										; 	LD D, (HL)		 ; 7331 56		; D = (HL) Ahora DE apunta al proximo byte
	ldx	,x			; recupera direccin de la tabla	; 	EX DE, HL		 ; 7332 EB		; DE <-> HL Ahora HL toma el valor calculado en DE
	puls	a			; recupera A				; 	POP DE			 ; 7333 D1		; Recupera original DE
	cmpa	#$14			; es A mayor o igual que $14?		; 	CP $14			 ; 7334 FE 14		; es el cdigo de la rutina mayor o igual a $14(20) = fin del mensaje
	bcc	i_733F			; si, va a la rutina y finaliza		; 	JR NC, i_733F		 ; 7336 30 07		; Si, ir a la correcta rutina requerida y termina
	jsr	i_733F			; la ejecuta como subrutina		; 	CALL i_733F		 ; 7338 CD 3F 73	; llama a la subrutina requerida y regresa
	beq	L_7314			; si di 0, vuelve a por otro byte	; 	JR Z, L_7314		 ; 733B 28 D7		; si listo, retorna a por un byte mas L_7314
	bra	L_7311			; sin imprime token apuntado por U	; 	JR L_7311		 ; 733D 18 D2		; si no imprime el token apuntado por DE
i_733F	jmp	,x			; salta a direccion apuntada por X	; i_733F: JP (HL)		 ; 733F E9		; Salta a la rutina requerida
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#28# OK)
L_7340	ldb	#$60			; pone valor $60			; L_7340: LD D, $60		 ; 7340 16 60		; Activa los Bits 5 y 6 de D Modo 6 
a7340	stb	<reg_D			; en reg_D
	bra	i_734B			; salta a i_734B			; 	JR i_734B		 ; 7342 18 07		; Solo imprime Enter
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#29# OK)
L_7344	ldb	#$30			; pone valor $30			; L_7344: LD D, $30		 ; 7344 16 30		; Activa los Bits 4 y 5 de D Modo 3 
	bra	a7340			; vuelve a a7340 (re-uso cdigo)	; 	JR i_734B		 ; 7346 18 03		; Imprime punto y Enter
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Llamada cuando es MODO = 2,3,6
L_7348	jsr	PrintWord		; llama PrintWord			; L_7348: CALL PrintWord	 ; 7348 CD C1 74	; aade al buffer de salida la palabra apuntada por DE
i_734B	lda	#$2E			; toma valor '.'			; i_734B: LD A, $2E		 ; 734B 3E 2E		; A = $2E = '.' punto
	ldb	<reg_D			; toma byte alto de reg_DE		; 	BIT 6, D		 ; 734D CB 72		; Esta encendido el Bit 6 de D = (Modo	6)
	bitb	#%01000000		; est a 1 el bit6?
	bne	i_7358			; si, salta a i_7358			; 	JR NZ, i_7358		 ; 734F 20 07		; Si, salta al final i_7358
	bitb	#%00010000		; est a 1 el bit4? 			; 	BIT 4, D		 ; 7351 CB 62		; Esta encendido el Bit 4 (modo 1)
	beq	a_7348			; no, salta siguiente			
	jsr	PutChar			; llama PutChar				; 	CALL NZ, PutChar	 ; 7353 C4 8B 85	; Si, imprime el punto (valor de A) llama rutina PutChar
a_7348	ldb	<reg_D			; toma byte alto de reg_DE
	bitb	#%00010000		; est a 1 el bit4?			; 	BIT 4, D		 ; 7356 CB 62		; Esta encendido el Bit 4 (modo 1)
i_7358	beq	L_735B			; no, salta siguiente			; i_7358: CALL NZ, PutEnter	 ; 7358 C4 83 85	; Si, llama PutEnter
	jsr	PutEnter		; llama PutEnter			; 							;------------------------- 0x16  end of msg -----------------------
										; 							; (#30# OK) - Retornar los valores grabados al entrar a PrintMsg
L_735B	ldu	DECopyPM		; recupera U				; L_735B: LD DE, (DECopyPM)	 ; 735B ED 5B DD 70	; recupera DE de la copia
	stu	<reg_DE			; lo pasa a reg_DE
	ldy	IXCopyPM		; recupera IX				; 	LD IX, (IXCopyPM)	 ; 735F DD 2A E0 70	; recupera IX de la copia
	sty	<reg_IX			; lo pasa a reg_IX
	lda	ACopyPM			; recupera A				; 	LD A, (ACopyPM)		 ; 7363 3A DC 70	; recupera A de la copia
	rts				; retorna				; 	RET			 ; 7366 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#31# OK)
L_7367	clr	L_B703			; pasa a 0 L_B703			; L_7367: XOR A			 ; 7367 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
										; 	LD (L_B703), A		 ; 7368 32 03 B7	; Borra (L_B703) = A
	puls	u			; recupera U(DE)			; 	POP DE			 ; 736B D1		; Recupera DE (direccin de retorno a la que ir al finalizar)
	puls	x			; recupera X(HL)			; 	POP HL			 ; 736C E1		; Recupera HL (2a direccin previa de retorno)
	ldd 	,s			; recupera (SP)
	exg	d,x			; intercambia valores D(SP) con X(HL)
	std	,s			; pasa X(HL) a (SP)			; 	EX (SP), HL		 ; 736D E3		; Pasa el contenido del stack (3er word) a HL mientras vuelve 2a direccin al stack
	pshs	u			; guarda U(DE)				; 	PUSH DE			 ; 736E D5		; deja la 1a direccin de retorno arriba
	stu	<reg_DE			; actualiza reg_DE			; 							; hay que verlo como que ha recuperado la tercera palabra del stack (parmetro)
	cmpx	#$0000			; es X igual a 0?			; 	LD A, H			 ; 736F 7C		; A = H
	beq	a_7367			; si, salta siguiente			; 	OR L			 ; 7370 B5		; A = A OR L
	jsr	PrintDescriptionHL	; no, llama PrintDescriptionHL		; 	CALL NZ, PrintDescriptionHL
										; 				 ; 7371 C4 34 74	; si no es cero, llama PrintDescriptionHL
a_7367	clra				; borra A, flag Z=1			; 	XOR A			 ; 7374 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	rts				; retorna				; 	RET			 ; 7375 C9		; Retorna 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#32# OK)
L_7376	puls	u			; recupera U(DE)			; L_7376: POP DE		 ; 7376 D1		; Recupera DE
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7377 E1		; Recupera HL
	ldd	,s			; recupera (SP)
	exg	d,x			; intercambia valores D(SP) con X(HL)
	std	,s			; pasa X(HL) a (SP)			; 	EX (SP), HL		 ; 7378 E3		; Intercambia el contenido del Stack (SP) <-> HL
	pshs	u			; guarda U(DE)				; 	PUSH DE			 ; 7379 D5		; Guarda DE
	exg	x,u			; intercambia X con U
	stu	<reg_DE			; actualiza reg_DE			; 	EX DE, HL		 ; 737A EB		; Intercambia DE <-> HL
	ora	#1			; pone a 1 el bit0 de A			; 	OR $01			 ; 737B F6 01		; A = A OR 1, flag Z = 0
	rts				; retorna				; 	RET			 ; 737D C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#33# OK)
L_737E	ldb	1,y			; lee byte siguiente			; L_737E: LD E, (IX+$01)	 ; 737E DD 5E 01	; E = (IX+$01), char siguiente al apuntado por IX
	sex				; extiende bit7 de B sobre A		; 	LD D, $00		 ; 7381 16 00		; D = 0, byte alto
										; 	BIT 7, E		 ; 7383 CB 7B		; Est el bit 7 de E a 1?
	std	<reg_DE			; lo guarda en reg_DE			; 	JR Z, i_7389		 ; 7385 28 02		; No, salta la proxima instruccin i_7389
					 					; 	LD D, $FF		 ; 7387 16 FF		; Carga en D = $FF(-1) (implica DE = negativo)
										; i_7389: ADD IX, DE		 ; 7389 DD 19		; suma (en realidad resta) E de IX
	leay	d,y			; lo suma a Y(IX)			
	sty	<reg_IX			; lo guarda en reg_IX			
										; 							;------------- 0x05  only used in message [L_AFCA] & 0x0A ------------
										; 							; (#34# OK)
L_738B	clra				; pone A a 0 y flagZ=1			; L_738B: XOR A			 ; 738B AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	rts				; retorna				; 	RET			 ; 738C C9		; Retorna
										; 							;--------------------- 0x03  [ weapon ] ?? ---------------------------
L_738D	ldu	L_B6FC			; recupera L_B6FC			; 							; (#35# OK)
	stu	<reg_DE			; lo guarda en reg_DE			; L_738D: LD DE, (L_B6FC)	 ; 738D ED 5B FC B6	; DE = (L_B6FC)
	ora	#1			; pone bit0 de A a 1			; 	OR $01			 ; 7391 F6 01		; A = A OR 1, flag Z = 0
	rts				; retorna				; 	RET			 ; 7393 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#36# OK)
L_7394	puls	u			; recupera U(DE)			; L_7394: POP DE		 ; 7394 D1		; Recupera DE
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7395 E1		; Recupera HL
	ldd	,s			; recupera (SP)
	exg	d,x			; intercambia valores D(SP) con X(HL)
	std	,s			; pasa X(HL) a (SP)			; 	EX (SP), HL		 ; 7396 E3		; Intercambia el contenido del Stack con HL; (SP) <-> HL
	pshs	u			; guarda U(DE)				; 	PUSH DE			 ; 7397 D5		; Guarda DE
	exg	x,u			; intercambia U con X			; 	EX DE, HL		 ; 7398 EB		; Inetercambia DE <-> HL
	stu	<reg_DE			; guarda U en reg_DE
	lda	#1			; pone 1				; 	LD A, $01		 ; 7399 3E 01		; A = 1
	sta	L_B703			; en L_B703				; 	LD (L_B703), A		 ; 739B 32 03 B7	; (L_B703) = A
	jsr	IfNotB703BypassAttr	; llama IfNotB703BypassAttr		; 	CALL IfNotB703BypassAttr ; 739E CD 78 74	; llama IfNotB703BypassAttr
	clra				; borra A, flag Z=1			; 	XOR A			 ; 73A1 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	rts				; retorna				; 	RET			 ; 73A2 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#37# OK)
L_73A3	clr	L_B703			; pone 0 en L_B703			; L_73A3: XOR A			 ; 73A3 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
										; 	LD (L_B703), A		 ; 73A4 32 03 B7	; Borra (L_B703) = A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
																	; imprime descripcin del objeto 'agente' (no tiene por qu ser "you") ; antes ; (#128# OK)
PrintActorName									; PrintActorName:					; L_B703 define si solo sustantivo (<>0) o las 3 palabras (=0)
	lda	ActionActor		; recupera ActionActor			; 	LD A, (ActionActor)	 ; 73A7 3A EA B6	; carga ActionActor
	jsr	FillActorIfNull		; llama FillActorIfNull			; 	CALL FillActorIfNull	 ; 73AA CD 88 74	; llama FillActorIfNull
	clra				; pone A a 0, flag Z=1			; 	XOR A			 ; 73AD AF		; borra A, flag Z=1
	rts				; retorna				; 	RET			 ; 73AE C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#38# OK)
L_73AF	lda	#1			; pone 1				; L_73AF: LD A, $01		 ; 73AF 3E 01		; A = 1
	sta	L_B703			; en L_B703				; 	LD (L_B703), A		 ; 73B1 32 03 B7	; Coloca un 1 en (L_B703)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PrintMainObjectLoc								; PrintMainObjectLoc:					; muestra localizacin del objeto principal ; antes ; (#168# OK)
										; 	LD A, (IsMainObjLoc)	 ; 73B4 3A FE B6	; recupera IsMainObjLoc
	lda	MainObject		; recupera MainObject			; 	AND A			 ; 73B7 A7		; es 0 (objeto)?
	tst	IsMainObjLoc		; es 0 IsMainObjLoc?			; 	LD A, (MainObject)	 ; 73B8 3A E8 B6	; recupera MainObject
										; 							;----------------- 0x0F  (unused) -----------------------------------
	bra	i_73CE			; salta a i_73CE			; 	JR i_73CE		 ; 73BB 18 11		; Salta a i_73CE
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#39# OK)
L_73BD	jsr	PutChar			; llama PutChar				; L_73BD: CALL PutChar		 ; 73BD CD 8B 85	; llama rutina PutChar
	clra				; borra A, flag Z=1			; 	XOR A			 ; 73C0 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	rts				; retorna				; 	RET			 ; 73C1 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#40# OK)
L_73C2	lda	#1			; pone 1				; L_73C2: LD A, $01		 ; 73C2 3E 01		; A = 1
	sta	L_B703			; en L_B703				; 	LD (L_B703), A		 ; 73C4 32 03 B7	; (L_B703) = A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PrintSecObjectLoc								; PrintSecObjectLoc:					; muestra localizacin del objeto secundario ; antes ; (#169# OK)
										; 	LD A, (IsSecObjLoc)	 ; 73C7 3A FF B6	; recupera IsSecObjLoc
	lda	SecondObject		; recupera SecodObjet			; 	AND A			 ; 73CA A7		; es 0 (objeto)?
	tst	IsSecObjLoc		; es 0 IsSecObjLoc?			; 	LD A, (SecondObject)	 ; 73CB 3A E9 B6	; carga ID objeto secundario
i_73CE	beq	L_73D6			; si flag Z=1, salta a L_73D6		; i_73CE: JR Z, L_73D6		 ; 73CE 28 06		; si es objeto, salta a L_73D6
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 73D0 E5		; Guarda HL
	jsr	PointHLTo3WordsLoc	; llama PointHLTo3WordsLoc		; 	CALL PointHLTo3WordsLoc	 ; 73D1 CD D5 71	; Llama PointHLTo3WordsLoc (es una Localizacin)
	bra	i_73DA			; salta a i_73DA			; 	JR i_73DA		 ; 73D4 18 04		; Salta mas abajo a i_73DA

L_73D6	pshs	x			; guarda X(HL)				; L_73D6: PUSH HL		 ; 73D6 E5		; Guarda HL
	jsr	PointHLTo3WordsObj	; llama PointHLTo3WordsObj		; 	CALL PointHLTo3WordsObj	 ; 73D7 CD E2 71	; LLamada PointHLTo3WordsObj (es un objeto)
i_73DA	jsr	PrintDescriptionHL	; llama PrintDescriptionHL		; i_73DA: CALL PrintDescriptionHL ; 73DA CD 34 74	; LLamada PrintDescriptionHL
	puls	x			; recupera X(HL)			; 	POP HL			 ; 73DD E1		; Recupera HL
	clra				; pone a 0 A, flag Z=1			; 	XOR A			 ; 73DE AF		; A = 0, flag Z=1
	rts				; retorna				; 	RET			 ; 73DF C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#41# OK)
L_73E0	leay	1,y			; incrementa puntero Y			; L_73E0: INC IX		 ; 73E0 DD 23		; IX = IX + 1, incrementa puntero IX
	leax	,y			; lo pasa a X(HL)			; 	PUSH IX			 ; 73E2 DD E5		; Guarda IX
	stx	<reg_IX			; lo guarda en reg_IX			; 	POP HL			 ; 73E4 E1		; Recupera HL (Pasa IX a HL)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 73E5 E5		; Lo vuelve a guardar,	HL
	ldb	,y			; lee 1 byte				; 	LD E, (IX+$00)		 ; 73E6 DD 5E 00	; E = (IX+$00); recupera byte apuntado por indice IX
	sex				; extiende bit7 de B sobre A		; 	LD D, $00		 ; 73E9 16 00		; Pone a 0 la parte alta de DE
										; 	BIT 7, E		 ; 73EB CB 7B		; Est el bit 7 de E a 1?
	std	<reg_DE			; lo guarda en reg_DE			; 	JR Z, i_73F1		 ; 73ED 28 02		; No, Salta la siguiente instruccin
										; 	LD D, $FF		 ; 73EF 16 FF		; D = $FF(-1)
										; i_73F1: ADD HL, DE		 ; 73F1 19		; A = HL + DE
	leax	d,x			; lo suma a X(HL)
	jsr	L_72F1			; llama L_72F1				; 	CALL L_72F1		 ; 73F2 CD F1 72	; llama rutina PrintMsg (L_72F1) (dentro de ella, no al principio)
	puls	y			; recupera Y(IX)			; 	POP IX			 ; 73F5 DD E1		; Recupera IX (ya incrementado antes)
	sty	<reg_IX			; lo pasa a reg_IX
	clra				; pone A a 0, flag Z=1			; 	XOR A			 ; 73F7 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	rts				; retorna				; 	RET			 ; 73F8 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#42# OK)
L_73F9	lda	ActionActor		; recupera ActionActor			; L_73F9: LD A, (ActionActor)	 ; 73F9 3A EA B6	; carga ActionActor
i_73FC	ldu	#$0990			; pone $0990 en U(DE)			; i_73FC: LD DE, $0990		 ; 73FC 11 90 09	; DE = $0990 (palabra 'his')
	stu	<reg_DE			; lo guarda en reg_DE
	tsta				; es A $0?				; 	AND A			 ; 73FF A7		; A = A AND A	; Adecua flags
	bne	e73F9			; no, sale				; 	RET NZ			 ; 7400 C0		; Retorna si no es cero
	ldu	#$0BEA			; pone $0BEA en U(DE)			; 	LD DE, $0BEA		 ; 7401 11 EA 0B	; DE = $0BEA (palabra 'your')
	stu	<reg_DE			; lo guarda en reg_DE
	ora	#1			; pone a 1 el bit0 de A			; 	OR $01			 ; 7404 F6 01		; A = A OR 1, flag Z = 0
e73F9	rts				; retorna				; 	RET			 ; 7406 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#43# OK)
L_7407	lda	MainObject		; recupera el MainObject		; L_7407: LD A, (MainObject)	 ; 7407 3A E8 B6	; toma cdigo Objeto principal
	bra	i_73FC			; vuelve a i_73FC			; 	JR i_73FC		 ; 740A 18 F0		; Salto a i_73FC, pasa dentro de (#42# OK)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#44# OK)
L_740C	lda	ActionActor		; recupera ActionActor			; L_740C: LD A, (ActionActor)	 ; 740C 3A EA B6	; carga ActionActor
	pshs	a			; guarda A				; 	EX AF, AF'		 ; 740F 08		; Intercambia AF <-> AF', guarda AF en registro 'espejo'
	clra				; pone 0 en A				; 	XOR A			 ; 7410 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
i_7411	sta	L_B703			; guarda A en L_B703			; i_7411: LD (L_B703), A	 ; 7411 32 03 B7	; (L_B703) = 0
	lda	,s			; recupera A sin modificar stack	; 	EX AF, AF'		 ; 7414 08		; Intercambia AF <-> AF', recupera AF del registro 'espejo'
										; 	PUSH AF			 ; 7415 F5		; Guarda AF
	jsr	FillActorIfNull		; llama FillActorIfNull			; 	CALL FillActorIfNull	 ; 7416 CD 88 74	; llama FillActorIfNull
	puls	a			; recupera A				; 	POP AF			 ; 7419 F1		; Recupera AF
	ldu	#$039B			; pone $039B en U(DE)			; 	AND A			 ; 741A A7		; A = A AND A	; Adecua flags
	tsta				; es A $0?				; 	LD DE, $039B		 ; 741B 11 9B 03	; DE = $039B (palabra 'is')
	bne	e7411			; no, sale con Z=0			; 	RET NZ			 ; 741E C0		; Retorna si flag Z = 0
	ldu	#$0065			; pone $0065 en U(DE)			; 	LD DE, $0065		 ; 741F 11 65 00	; DE = $0065 (palabra 'are')
	ora	#1			; pone bit0 de A a 1 y flag Z=0		; 	OR $01			 ; 7422 F6 01		; A = A OR 1, flag Z = 0
e7411	stu	<reg_DE			; guarda U en reg_DE
	rts				; retorna				; 	RET			 ; 7424 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#45# OK)
L_7425	lda	MainObject		; recupera MainObject			; L_7425: LD A, (MainObject)	 ; 7425 3A E8 B6	; toma cdigo Objeto principal
i_7428	pshs	a			; guarda A				; i_7428: EX AF, AF'		 ; 7428 08		; Intercambia AF <-> AF', guarda AF en registro 'espejo'
	lda	#1			; pone 1 en A				; 	LD A, $01		 ; 7429 3E 01		; A = 1, (para ponerlo en L_B703)
	bra	i_7411			; vuelve a i_7411			; 	JR i_7411		 ; 742B 18 E4		; Salto a i_7411, dentro de (#44# OK)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#46# OK)
L_742D	puls	u			; recupera U(DE)			; L_742D: POP DE		 ; 742D D1		; Recupera DE (direccion de retorno)
	puls	x			; recupera X(HL)			; 	POP HL			 ; 742E E1		; Recupera HL
	lda     1,s			; recupera A				; 	POP AF			 ; 742F F1		; Recupera AF
	stx	,s			; guarda X(HL)				; 	PUSH HL			 ; 7430 E5		; Guarda HL
	pshs	u			; guarda U(DE)				; 	PUSH DE			 ; 7431 D5		; Guarda DE (ha eliminado del stack el tercer word, AF)
	bra	i_7428			; vuelve a i_7428			; 	JR i_7428		 ; 7432 18 F4		; Salto a i_7428, dentro de (#45# OK)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PrintDescriptionHL								; PrintDescriptionHL:					; muestra descripcin apuntada por HL ; antes ; (#17# OK)
	ldy	<reg_IY			; recupera Y de reg_IY			; 	PUSH IY			 ; 7434 FD E5		; guarda IY
	pshs	y			; guarda Y(IY)				; 	PUSH HL			 ; 7436 E5		; pasa HL
	tfr	x,y			; pasa X(HL) a Y(IY)			; 	POP IY			 ; 7437 FD E1		; a IY
	stx	<reg_IY			; actualiza reg_IY
	jsr	PrintDescriptionIY	; llama PrintDescriptionIY		; 	CALL PrintDescriptionIY	 ; 7439 CD D6 9E	; llama PrintDescriptionIY
	puls	y			; recupera Y(IY)
	sty	<reg_IY			; lo guarda en reg_IY			; 	POP IY			 ; 743C FD E1		; recupera IY
	rts				; retorna				; 	RET			 ; 743E C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; comprueba si DE apunta a palabra 'you' ; antes ; (#20# OK)
IsDEequalYou									; IsDEequalYou:						; mira si bit7 del byte alto de DE est a 1 (palabra con atributos)
	tst	<reg_D			; est a 1 el bit7 de D?		; 	BIT 7, D		 ; 743F CB 7A		; est a 1 el bit7 del byte alto de la palabra (atributos)
	bpl	GetDeterminerWord	; no, salta a GetDeterminerWord		; 	JR Z, GetDeterminerWord	 ; 7441 28 12		; no, salta a GetDeterminerWord
	ldd	<reg_DE			; recupera reg_DE			; 	LD A, E			 ; 7443 7B		; pasa byte bajo de DE a A
	anda	#$0F			; elimina 4 bits altos de A		; 	LD HL, $07A8		 ; 7444 21 A8 07	; apunta a palabra $07A8 + $6000 = $67A8 -> "YOU"
	cmpd	#$07A8			; es igual a $07A8?			; 	CP L			 ; 7447 BD		; es $A8?
	beq	e744F			; si, sale				; 	JR NZ, i_744F		 ; 7448 20 05		; no, salta a i_744F
										; 	LD A, D			 ; 744A 7A		; pasa byte alto de DE a A
										; 	AND $0F			 ; 744B E6 0F		; se queda con los 4 bits bajos (sin atributos)
										; 	CP H			 ; 744D BC		; es $07?
										; 	RET Z			 ; 744E C8		; si, retorna con palabra 'you'
i_744F	lda	#1			; pone 1				; i_744F: LD A, $01		 ; 744F 3E 01		; pone 1
	sta	L_B704			; en L_B704				; 	LD (L_B704), A		 ; 7451 32 04 B7	; en L_B704
e744F	rts				; retorna				; 	RET			 ; 7454 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; recibe indice a tabla de determinantes en D
GetDeterminerWord								; GetDeterminerWord:					; tratamiento de determinantes (las 2 tablas)
	ldx	#DetTable1		; apunta a DetTable1			; 	LD HL, DetTable1	 ; 7455 21 2D AD	; apunta a DetTable1
										; 	LD A, (PrintAreaFlag)	 ; 7458 3A 01 B7	; recupera PrintAreaFlag
										; 	LD E, A			 ; 745B 5F		; lo guarda en E
	lda	DeterminerTable		; recupera DeterminerTable		; 	LD A, (DeterminerTable)	 ; 745C 3A DF 70	; recupera DeterminerTable (indica que tabla de determinantes hay que usar)
	ora	PrintAreaFlag		; es 0 y tambin lo es PrintAreaFlag?	; 	OR E			 ; 745F B3		; son ambos flags 0?
	beq	i_7465			; si, salta siguiente			; 	JR Z, i_7465		 ; 7460 28 03		; si, salta a i_7465
	ldx	#DetTable2		; apunta a DetTable2			; 	LD HL, DetTable2	 ; 7462 21 35 AD	; apunta a DetTable2
i_7465	lda	<reg_D			; recupera byte alto de reg_DE		; i_7465: LD A, D		 ; 7465 7A		; pasa el byte alto de DE a A
	lsra				; mueve 3 vecesa la derecha		; 	RRCA			 ; 7466 0F		; lo desplaza
	lsra				; bits 6-5-4 pasan a 			; 	RRCA			 ; 7467 0F		; 3 veces a la derecha.
	lsra				; posiciones bits 3-2-1			; 	RRCA			 ; 7468 0F		; bits 6-5-4 pasan a ser bits 3-2-1
										; 							; El resultado es el offset a la tabla (entradas de 2 bytes)
	anda	#$1E			; elimina 3 bits altos y el bit0	; 	AND $1E			 ; 7469 E6 1E		; %0001 1110 deja solo los bits 4,3,2,1 = offset con bit0=0
	ldu	<reg_DE			; recupera U(DE)					
	pshs	u			; lo guarda				; 	PUSH DE			 ; 746B D5		; Guarda DE
	tfr	a,b			; pasa byte alto (rotado) a byte bajo	; 	LD E, A			 ; 746C 5F		; pasa valor 'rotado' (offset) a E
	clra				; byte alto a 0				; 	LD D, $00		 ; 746D 16 00		; byte alto a cero
	leax	d,x			; lo suma a X(HL)			; 	ADD HL, DE		 ; 746F 19		; obtiene posicin del puntero a palabra
										; 	LD E, (HL)		 ; 7470 5E		; carga byte bajo
										; 	INC HL			 ; 7471 23		; incrementa puntero
	ldu	,x+			; recupera puntero a la palabra		; 	LD D, (HL)		 ; 7472 56		; carga byte alto direccin palabra a mostrar
	stu	<reg_DE			; lo guarda en reg_DE
	jsr	PrintWord		; llama PrintWord			; 	CALL PrintWord		 ; 7473 CD C1 74	; aade al buffer de salida la palabra apuntada por DE
	puls	u			; recupera U(DE)			; 	POP DE			 ; 7476 D1		; recupera DE
	stu	<reg_DE			; lo guarda en reg_DE
	rts				; retorna				; 	RET			 ; 7477 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
IfNotB703BypassAttr								; IfNotB703BypassAttr:					; si L_B703 = 0 se omiten los atributos de la palabra apuntada por DE ; antes ; (#13# OK) 
	ldu	<reg_DE			; recupera reg_DE				
	pshs	u			; lo guarda				; 	PUSH DE			 ; 7478 D5		; Guarda DE
	lda	L_B703			; recupera L_B703			; 	LD A, (L_B703)		 ; 7479 3A 03 B7	; recupera L_B703
	beq	aIfNot			; si es 0, salta siguiente		; 	AND A			 ; 747C A7		; es 0?
	jsr	IsDEequalYou		; llama IsDEequalYou			; 	CALL NZ, IsDEequalYou	 ; 747D C4 3F 74	; no, llama IsDEequalYou para tratar atributos de la palabra
aIfNot	puls	u			; recupera U(DE)			; 	POP DE			 ; 7480 D1		; Recupera DE
	stu	<reg_DE			; lo guarda en reg_DE
	lda	<reg_D			; recupera byte alto de reg_DE		; 	LD A, D			 ; 7481 7A		; pasa byte alto de DE a A
	anda	#$0F			; le borra los 4 bits altos		; 	AND $0F			 ; 7482 E6 0F		; pasa a 0 los 4 bits altos (quita atributos)
	sta	<reg_D			; lo devuelve a byte alto de reg_DE	; 	LD D, A			 ; 7484 57		; lo devuelve al byte alto de DE
	ldu	<reg_DE			; carga U con nuevo valor reg_DE
	bra	PrintWord		; salta a PrintWord			; 	JP PrintWord		 ; 7485 C3 C1 74	; aade al buffer de salida la palabra apuntada por DE
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
FillActorIfNull									; FillActorIfNull:					; Si no hay ActionActor ($FF) imprimir "someone" ; antes ; (#14# OK)
	cmpa	#$FF			; es a $FF?				; 	CP $FF			 ; 7488 FE FF		; es A $FF?
	lbne	L_73D6			; no, vuelve a L_73D6			; 	JP NZ, L_73D6		 ; 748A C2 D6 73	; no, salta a L_73D6 (dentro de accin 0x09)
	ldu	#$0AE3			; pone $0AE3 en U(DE)			; 	LD DE, $0AE3		 ; 748D 11 E3 0A	; si, DE apunta a palabra $6000 + $0AE3 = 'someone'
	stu	<reg_DE			; lo guarda en reg_DE
	bra	PrintWord		; salta a PrintWord			; 	JP PrintWord		 ; 7490 C3 C1 74	; aade al buffer de salida la palabra apuntada por DE
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#10# OK) Proceso de palabras comunes
L_7493	suba	#$60			; resta $60 de A			; L_7493: SUB $60		 ; 7493 D6 60		; A = A - $60,	; sustrae $60 de A
	ldb	#2			; para duplicar				; 	LD E, A			 ; 7495 5F		; E = A,	; E toma el resultado
	mul				; hace D = 2 * A			; 	LD D, $00		 ; 7496 16 00		; D = 0,	; Borrar byte alto
	ldx	#CommonWords		; apunta a CommonWords			; 	LD HL, CommonWords	 ; 7498 21 3D AD	; apunta a CommonWords
										 							; en el Bloque de Datos estan invertidos para el 6809!
										; 	ADD HL, DE		 ; 749B 19		; HL =HL + DE	; adicionar el desplazamiento (codigo de la palabra)
	leax	d,x			; le aade el offset calculado		; 	ADD HL, DE		 ; 749C 19		; HL =HL + DE	; Otra vez porque las entradas son de 2 bytes
										; 	LD E, (HL)		 ; 749D 5E		; E = (HL),	; E toma el byte menor
										; 	INC HL			 ; 749E 23		; HL = HL + 1,	; HL apunta al proximo byte
	ldd	,x+			; lee dos bytes				; 	LD A, (HL)		 ; 749F 7E		; A = HL,	; A toma el byte alto
	adda	#$50			; le suma $50 al byte alto		; 	ADD A, $50		 ; 74A0 C6 50		; A = A + $50	; adiciona $5000 a la direccin (Enciende los bits 4 y 6 de A)
	tfr	d,u			; pasa clculo a U(DE)			; 	LD D, A			 ; 74A2 57		; D = A,	; DE forma el apuntador a la palabra
	stu	<reg_DE			; lo guarda en reg_DE
	lbra	L_7311			; vuelve a L_7311			; 	JP L_7311		 ; 74A3 C3 11 73	; ir a imprimir la palabra
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PrintWordNoAttr									; PrintWordNoAttr:  					; imprime palabra SIN atributos - antes (#166# --)
	ldd	,x++			; toma 2 bytes  --- CAMBIO ---		; 	LD E, (HL)		 ; 74BA 5E 		; carga byte bajo apuntado por HL en E
										; 	INC HL		 	 ; 74BB 23		; Incrementa HL
										; 	LD A, (HL)		 ; 74BC 7E		; carga byte alto en A
										; 	INC HL		 	 ; 74BD 23		; Incrementa HL, ahora apunta al siguiente byte del mensaje ...
	anda	#$0F			; a 0 los 4 bits altos			; 	AND $0F			 ; 74BE E6 0F		; pasa a cero los 4 bits altos (4-5-6-7) quitandole los atributos a la palabra
	std	<reg_DE			; pasa valor a reg_DE			; 	LD D, A			 ; 74C0 57		; lo pasa como byte alto a D
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Parametros Apuntador a palabla en DE
										; 							; PrintWord	; antes ; (#09# OK) - aade al buffer de salida la palabra apuntada por DE
PrintWord									; PrintWord: 
	ldu	<reg_DE			; recupera reg_DE
	tfr	u,d			; lo pasa a D				; 	LD A, D		 	 ; 74C1 7A		; A = D		; (byte alto)
	anda	#$0F			; elimina 4 bits altos del byte alto	; 	AND $0F			 ; 74C2 E6 0F		; A = A AND $0F	; (Solo deja los Bits bajos de A) (Nibble Alto a 0)
	cmpd	#0			; es 0 el resultado?			; 	OR E			 ; 74C4 B3		; A = A OR E	; Los Orea con E (Byte bajo)
	lbeq	ePWord			; si, sale				; 	RET Z			 ; 74C5 C8		; Z = 1?	; Retorna si es cero (Direccin fue cero)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 74C6 E5		; Guarda HL
	ldd	<reg_BC			; recupera reg_BC
	pshs	d			; guarda D(BC)				; 	PUSH BC			 ; 74C7 C5		; Guarda BC
	pshs	u			; guarda U(DE)				; 	PUSH DE			 ; 74C8 D5		; Guarda DE
	ldd	<reg_DE			; recupera reg_DE			; 	LD C, D			 ; 74C9 4A		; C = D		; Pasa byte alto a C
	sta	<reg_C			; guarda A(D) en reg_C			; 	LD A, D			 ; 74CA 7A		; A = D		; Pasa byte alto a A
	anda	#$0F			; elimina 4 bits altos			; 	AND $0F			 ; 74CB E6 0F		; A = A AND $0F	; (Solo deja los Bits bajos de A) (Nibble Alto a 0)
	sta	<reg_D			; lo devuelve a reg_D			; 	LD D, A			 ; 74CD 57		; D = A		; Retorna el valor a D
	ldx	#WordIndex		; apunta a WordIndex			; 	LD HL, WordIndex	 ; 74CE 21 00 60	; HL = WordIndex ; Apunta a palabras A-Z, Adiciona $6000 a la direccin
	leax	d,x			; le aade offset calculado		; 	ADD HL, DE		 ; 74D1 19		; HL = HL + DE	; Adiciona DE sin el nibble alto (Bits 5-7 puestos a cero) del byte alto al apuntador
	ldu	#OUTBUFFR		; apunta a buffer salida		; 	LD DE, OUTBUFFR		 ; 74D2 11 A6 74	; DE = OUTBUFFR	; DE apunta al area de datos de trabajo
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 74D5 E5		; Guarda HL	; Guarda el apuntador al comienzo o a la palabra
	clr	<reg_B			; pone reg_B a 0			; 	LD B, $00		 ; 74D6 06 00		; B = 0		; Borra B; Contador de letras a cero
i_74D8	lda	,x			; lee un byte del diccionario		; i_74D8: LD A, (HL)		 ; 74D8 7E		; A = (HL)	; Toma un byte de la palabra elegida
	anda	#$1F			; pone a 0 los 3 bits altos		; 	AND $1F			 ; 74D9 E6 1F		; A = A AND $1F	; La letra esta en los 5 bits bajos (0-4)
	beq	i_74F9			; si 0, salta a i_74F9			; 	JR Z, i_74F9		 ; 74DB 28 1C		; Si cero, ir a terminar palabra
	inc	<reg_B			; incrementa contador letras		; 	INC B			 ; 74DD 04		; B = B +1	; Incrementar contador de letras
	adda	#$60			; obtine ASCII de la letra		; 	ADD A, $60		 ; 74DE C6 60		; A = A + $60(96); Sumar $60 para obtener el codigo ASCII de la letra
	sta	,u+			; lo guarda en buffer salida		; 	LD (DE), A		 ; 74E0 12		; (DE) = A	; Graba A en el sitio de trabajo
	stu	<reg_DE			; actualiza reg_DE			; 	INC DE			 ; 74E1 13		; DE = DE + 1	; Incrementa posicin
	tst	,x+			; tiene bit7 a 1 (ltima letra)?	; 	BIT 7, (HL)		 ; 74E2 CB 7E		; Prueba el bit 7 de (HL); letra procesada actualmente
										; 	INC HL			 ; 74E4 23		; HL = HL + 1	; Incrementa apuntador a letras
	bpl	i_74D8			; no, vuelve a siguiente letra		; 	JR Z, i_74D8		 ; 74E5 28 F1		; Bit 7 = 0?	; Si, Salta atras i_74D8; siguiente letra
										; 									; Si no, el byte contiene una marca especial
	lda	<reg_B			; recupera contador letras reg_B	; 	LD A, B			 ; 74E7 78		; A = B		; pasa el contador a A
	cmpa	#2			; es 2?					; 	CP $02			 ; 74E8 FE 02		; A = 2?	; Es la 2da letra? (conjugacin-declinacin)
	beq	i_74D8			; si, lee otra letra			; 	JR Z, i_74D8		 ; 74EA 28 EC		; Z = 1?	; Si, Lee proxima letra; salta atras; Repite
	cmpa	#3			; es 3?					; 	CP $03			 ; 74EC FE 03		; A = 3?	; Es la 3ra letra? (atributos de la conjugacin)
	bne	i_74F9			; no, salta a i_74F9			; 	JR NZ, i_74F9		 ; 74EE 20 09		; Z = 0?	; No, es mas grande, salta mas abajo i_74F9; salta a finalizar palabra
										; 									; Si, es la tercera letra
	leax	-2,x			; decrementa puntero en 2		; 	DEC HL			 ; 74F0 2B		; HL = HL - 1	; Decrementa HL, (Ya que viene incrementado en 1)
										; 	DEC HL			 ; 74F1 2B		; HL = HL - 1	; Decrementa HL, Apunta a la 2da Letra
	lda	,x++			; relee la segunda letra		; 	LD A, (HL)		 ; 74F2 7E		; A = (HL)	; toma la 2da letra
					; incrementa puntero en 2		; 	INC HL			 ; 74F3 23		; HL = HL + 1	; Incrementa HL
										; 	INC HL			 ; 74F4 23		; HL = HL + 1	; Incrementa HL; coloca HL en la posicin original 3ra letra + 1 
										; 	BIT 7, A		 ; 74F5 CB 7F		; Bit 7 de A?	; Prueba el bit 7 de A (2da letra) (conjugacin-declinacin)
	bmi	i_74D8			; si bit7 a 1, vuelve a leer letra	; 	JR NZ, i_74D8		 ; 74F7 20 DF		; Z = 0?	; Si, leer proxima letra, salto a i_74D8
										; 									; Fin de palabra
i_74F9	puls	x			; recupera X(HL)			; i_74F9: POP HL		 ; 74F9 E1		; Recupera HL	; Restaura el apuntador al principio de la palabra
	lda	<reg_C			; recupera reg_C			; 	LD A, C			 ; 74FA 79		; A = C		; A = al byte alto de la direccin original
	anda	#$F0			; pone a cero 4 bits bajos		; 	AND $F0			 ; 74FB E6 F0		; A = A AND $F0	; mantiene solo el nibble alto de la direccin (bits 4-7)
	cmpa	#$50			; es $50?				; 	CP $50			 ; 74FD FE 50		; A = $50?	; (modo = 5)(valor originalmente adicionado en el proceso de palabras comunes)
	beq	L_7530			; si, salta a L_7530			; 	JR Z, L_7530		 ; 74FF 28 2F		; Z = 1?	; Si son iguales salta a L_7530
	cmpa	#$40			; es $40?				; 	CP $40			 ; 7501 FE 40		; A = $40?	; Lo compara con $40? (modo = 4)
	beq	i_7512			; si, salta a L_7512			; 	JR Z, i_7512		 ; 7503 28 0D		; Z = 1?	; Si son iguales salta mas abajo i_7512
	cmpa	#$10			; es $10?				; 	CP $10			 ; 7505 FE 10		; A = $10?	; Lo compara con 10$? (modo = 1)
	tfr	cc,b			; guarda flags en B							
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 7507 3A E8 B6	; recupera cdigo objeto principal
	tfr	b,cc			; recupera flags. Es B igual a $10?
	beq	i_750F			; si, salta siguiente			; 	JR Z, i_750F		 ; 750A 28 03		; Z = 1?	; Si cero salta a i_750F, salta la proxima instruccin
	lda	ActionActor		; recupera MainActor			; 	LD A, (ActionActor)	 ; 750C 3A EA B6	; carga ActionActor
i_750F	tsta				; es 0?					; i_750F: AND A			 ; 750F A7		; A = A AND A	; Adecua flags
	beq	L_7530			; si, salta a L_7530			; 	JR Z, L_7530		 ; 7510 28 1E		; Z = 1?	; Si, salta a L_7530
										; 							; MODO = 4 (terminaciones)
i_7512	leax	1,x			; incrementa puntero			; i_7512: INC HL		 ; 7512 23		; apunta al segundo caracter de la palabra a imprimir 
	tst	,x			; tiene siguiente letra el bit7 a 1?	; 	BIT 7, (HL)		 ; 7513 CB 7E		; tiene el bit7 a 1? (terminaciones siempre lo tiene a 1)
	bpl	L_7530			; no, salta a L_7530			; 	JR Z, L_7530		 ; 7515 28 19		; no, salta a L_7530 (no hace nada adicional)
	leax	1,x			; incrementa puntero			; 	INC HL			 ; 7517 23		; apunta a la tercera letra (indica el tipo de terminacin asociado a la palabra)
	lda	,x			; lee letra				; 	LD A, (HL)		 ; 7518 7E		; recupera esta letra
	anda	#$E0			; guarda solo los 3 bits altos		; 	AND $E0			 ; 7519 E6 E0		; se queda con los tres bits mas altos (5-6-7)
	lsra				; rota a la derecha			; 	RRCA			 ; 751B 0F		; rota a la derecha, entra un 0 en el bit7
	lsra				; tres veces				; 	RRCA			 ; 751C 0F		; lo mismo
	lsra				; ahora bits7-6-5 estan en bits4-3-2	; 	RRCA			 ; 751D 0F		; otra vez. Los bits 5-6-7 ahora estan en los 2-3-4
					; bits 0-1 a 0 implican x4		; 							;    equivale a cdigos 0-7 multiplicados por 4 debido a empezar en bit2
										; 							;    de esta forma cada cdigo apunta a un byte separado 4 del anterior
										; 							;    solo se emplean los cdigos de 0 a 5
	tfr	a,b			; lo convierte a 16 bits		; 	LD L, A			 ; 751E 6F		; guarda el valor calculado en L
	clra				; byte alto a 0				; 	LD H, $00		 ; 751F 26 00		; byte alto a cero
	ldx	#L_B71F			; apunta a zona de terminaciones	; 	LD BC, L_B71F		 ; 7521 01 1F B7	; BC apunta a zona de terminaciones de palabras
	leax	d,x			; le suma el offset calculado		; 	ADD HL, BC		 ; 7524 09		; se le aade el offset calculado con las rotaciones. HL apunta a inico de la terminacin
	ldb	#4			; contador de letras de la terminacin	; 	LD B, $04		 ; 7525 06 04		; contador de letras a aadir a 4 (mximo)
i_7527	lda	,x			; lee letra				; i_7527: LD A, (HL)		 ; 7527 7E		; recupera letra del rea de terminaciones
										; 	AND A			 ; 7528 A7		; A = A AND A	; Adecua flags
	beq	L_7530			; si 0 (final), salta a L_7530		; 	JR Z, L_7530		 ; 7529 28 05		; si cero, salta a L_7530 (ya no hay mas letras de terminacin por aadir)
	leax	1,x			; incrementa puntero			; 	INC HL			 ; 752B 23		; apunta a la siguiente letra del area de terminaciones
	sta	,u+			; aade letra en buffer salida		; 	LD (DE), A		 ; 752C 12		; guarda letra recuperada en la otra area de trabajo (buffer salida)
	stu	<reg_DE			; actualiza reg_DE
	decb				; decrementa contador letras		; 	INC DE			 ; 752D 13		; incrementa puntero al rea de terminaciones
	bne	i_7527			; si no es 0, siguiente letra		; 	DJNZ i_7527		 ; 752E 10 F7		; decrementa contador B y si no es cero, lee siguiente letra del rea de terminaciones
										; 
										; 							; MODO = 5 (desconocido)
L_7530	ldd	#OUTBUFFR		; recupera inicio buffer salida		; L_7530: LD HL, OUTBUFFR	 ; 7530 21 A6 74	; HL a punta a inicio bufer salida
	pshs	d			; guarda HL en el stack			; 	EX DE, HL		 ; 7533 EB		; intercambia apuntadores. DE = OUTBUFFR - HL = posicion anterior puntero a area de trabajo
	tfr	u,d			; pasa DE D				; 	AND A			 ; 7534 A7		; A = A AND A	; Adecua flags (resetea carry)
	subd	,s++			; le resta inicio, calcula longitud	; 	SBC HL, DE		 ; 7535 ED 52		; resta DE y Carry de HL = calcula el nmero de caracteres a mostrar en pantalla 
	stb	<reg_B			; guarda longitud en reg_B		; 	LD B, L			 ; 7537 45		; guarda byte bajo del puntero en B (contador)
	lda	PrintAreaFlag		; recupera PrintAreaFlag		; 	LD A, (PrintAreaFlag)	 ; 7538 3A 01 B7	; recupera PrintAreaFlag
										; 	AND A			 ; 753B A7		; A = A AND A	; Adecua flags
	pshs	cc			; guarda flags				; 	AND A			 ; 753B A7		; A = A AND A	; Adecua flags
										; 	PUSH AF			 ; 753C F5		; guarda registro e indicadores
	bne	i_7543			; si A no era 0, salta siguiente	; 	JR NZ, i_7543		 ; 753D 20 04		; si A no es cero salta siguientes dos instrucciones
	lda	L_86A0			; recupera L_86A0			; 	LD A, (L_86A0)		 ; 753F 3A A0 86	; A recibe valor de L_86A0 (rea alternativa de datos)
										; 	AND A			 ; 7542 A7		; A = A AND A	; Adecua flags
i_7543	pshs	cc			; guarda flags					
	lda	#$20			; toma valor $20			; i_7543: LD A, $20		 ; 7543 3E 20		; A = ASCII por espacio  cifra 32
	puls	cc			; recupera flags
	beq	a7543			; si flag Z=1, salta siguiente
	jsr	PutChar			; llama PutChar				; 	CALL NZ, PutChar	 ; 7545 C4 8B 85	; si valor recibido en A no era cero, llama a la subrutina PutChar
a7543	lda	L_85B3			; recupera L_85B3			; 	POP AF			 ; 7548 F1		; recupera registro e indicadores
										; 	LD A, (L_85B3)		 ; 7549 3A B3 85	; A recibe valor de L_85B3 (rea de datos a imprimir)
	puls	cc			; recupera flags			; 	LD A, (L_85B3)		 ; 7549 3A B3 85	; A recibe valor de L_85B3 (rea de datos a imprimir)
	bne	i_7551			; si no es 0, salta siguente		; 	JR NZ, i_7551		 ; 754C 20 03		; si no es cero salta siguiente instruccion
	lda	L_869B			; recupera L_869B			; 	LD A, (L_869B)		 ; 754E 3A 9B 86	; A recibe valor de L_869B (rea alternativa)
i_7551	ldx	#L_B704			; apunta a L_B704			; i_7551: LD HL, L_B704		 ; 7551 21 04 B7	; HL apunta a L_B704
	cmpa	<reg_B			; es A>= reg_B				; 	CP B			 ; 7554 B8		; adecua indicadores al resultado de A-B (sin efectuarlo)
	bcc	i_755C			; si, salta a i_755C			; 	JR NC, i_755C		 ; 7555 30 05		; si A>B va a i_755C (no se ha llegado al final de linea)
	lda	,x			; lee byte				; 	LD A, (HL)		 ; 7557 7E		; A recibe valor de (L_B704)
	jsr	PutEnter		; llama PutEnter			; 	CALL PutEnter		 ; 7558 CD 83 85	; llama subrutina PutEnter - Imprime un ENTER
	sta	,x			; guarda A en L_B704			; 	LD (HL), A		 ; 755B 77		; graba A en (L_B704)
i_755C	puls	u			; recupera U(DE)			; i_755C: POP DE		 ; 755C D1		; salva registros
	stu	<reg_DE			; lo guarda en reg_DE
	lda	<reg_D			; recupera byte alto de reg_DE		; 	LD A, D			 ; 755D 7A		; pasa byte alto puntero DE a registro A
	anda	#$F0			; pasa a 0 los 4 bits bajos		; 	AND $F0			 ; 755E E6 F0		; se queda con los cuatro bits altos
	ldb	#1			; toma valor 1				; 	CP $70			 ; 7560 FE 70		; testea los bits 6-5-4
	cmpa	#$70			; es a $70?				; 	LD A, $01		 ; 7562 3E 01		; carga A con 1
	bne	i_7567			; no, salta siguiente			; 	JR NZ, i_7567		 ; 7564 20 01		; si algun bit estaba a 1 salta la siguiente
	stb	,x			; pone 1 en L_B704			; 	LD (HL), A		 ; 7566 77		; guarda en L_B704 el valor de A
i_7567	ldx	#OUTBUFFR		; apunta a buffer salida		; i_7567: LD HL, OUTBUFFR	 ; 7567 21 A6 74	; HL apunta al area de datos OUTBUFFR 
i_756A	lda	,x			; lee byte				; i_756A: LD A, (HL)		 ; 756A 7E		; A recibe una letra  
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 756B CD 8B 85	; llama a la subrutina PutChar
	leax	1,x			; incrementa puntero			; 	INC HL			 ; 756E 23		; incrementa puntero a area de datos
	dec	<reg_B			; decrementa contador longitud palabra
	bne	i_756A			; si no es 0, siguiente letra		; 	DJNZ i_756A		 ; 756F 10 F9		; decrementa contador B y si no cero bucle a i_756A (B tenia el numero de caracteres aadidos al buffer)
	puls	x			; recupera X(BC)			; 	POP BC			 ; 7571 C1		; recupera BC
	stx	<reg_BC			; lo guarda en reg_BC
	puls	x,pc			; recupera X(HL) y retorna		; 	POP HL			 ; 7572 E1		; recupera HL
										; 	RET			 ; 7573 C9		; retorna	  - final de Print_Token
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
IfB17AZeroClearAndJmpTable75D2							; IfB17AZeroClearAndJmpTable75D2:			; si L_B71A es cero, limpia rea de datos y ejecuta rutina ; antes ; (#87# OK)
	ldy	#L_B9C8			; apunta a L_B9C8			; 	LD IY, L_B9C8		 ; 7585 FD 21 C8 B9	; apunta a L_B9C8 (bloque de trabajo de 24 bytes)
	sty	<reg_IY
	clra				; pone 0				; 	XOR A			 ; 7589 AF		; pone 0

L_758A	sta	L_B71B			; en L_B71B				; L_758A: LD (L_B71B), A	 ; 758A 32 1B B7	; en L_B71B
	jsr	ClearB719		; llama ClearB719			; 	CALL ClearB719		 ; 758D CD 5F 78	; llama ClearB719
	sta	L_B706			; pone 0 en L_B706			; 	LD (L_B706), A		 ; 7590 32 06 B7	; pone 0 en L_B706
	ldd	#$A0FF			; pone $A0FF				; 	LD E, $FF		 ; 7593 1E FF		; pone $FF en E
	std	<reg_DE			; en reg_DE
	lda	L_B71A			; recupera L_B71A			; 	LD A, (L_B71A)		 ; 7595 3A 1A B7	; recupera L_B71A
										; 	AND A			 ; 7598 A7		; es 0?
	bne	L_7614			; si no era 0 salta a L_7614		; 	LD D, $A0		 ; 7599 16 A0		; pone $A0 en D  (%1010 0000)
	ldb	#$C0			; pone #$C0				; 	JP NZ, L_7614		 ; 759B C2 14 76	; si no era cero, salta a L_7614
	stb	<reg_D			; en reg_D				; 	LD D, $C0		 ; 759E 16 C0		; si era cero, pone $C0 en D  (%1101 0000)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ClearAndJmpTable75D2								; ClearAndJmpTable75D2:					; limpia rea de datos y ejecuta rutina ; antes ; (#55# OK)
	clra				; pone 0				; 	XOR A			 ; 75A0 AF		; pone 0
	sta	L_757A			; en L_757A				; 	LD (L_757A), A		 ; 75A1 32 7A 75	; en L_757A
	ldb	<reg_E			; recupera reg_E			; 	LD A, E			 ; 75A4 7B		; pasa E a A
	orb	#$C7			; pone a 1 bits 7-6 2-1-0		; 	OR $C7			 ; 75A5 F6 C7		; $C7 = %1100 0111, fuerza a 1 los bits 7,6,2,1,0
	stb	<reg_E			; lo guarda				; 	LD E, A			 ; 75A7 5F		; actualiza E con el resultado obtenido
	lda	L_B719			; recupera L_B719			; 	LD A, (L_B719)		 ; 75A8 3A 19 B7	; recupera L_B719
	cmpa	#2			; es 2?					; 	CP $02			 ; 75AB FE 02		; es 2?
	bne	i_75B1			; no, salta a i_75B1			; 	JR NZ, i_75B1		 ; 75AD 20 02		; no, se salta la siguiente instruccin
	andb	#$FD 			; pasa a 0 el bit1			; 	RES 1, E		 ; 75AF CB 8B		; pone a cero el bit 1 de E  (E = %1100 0101 equiv. a $C5)
	stb	<reg_E			; lo guarda en reg_E
i_75B1	jsr	ClearBlkAndFreePrevious	; llama ClearBlkAndFreePrevious		; i_75B1: CALL ClearBlkAndFreePrevious
										; 				 ; 75B1 CD 64 78	; Llama ClearBlkAndFreePrevious - Borra bloque L_B9C8 y palabra en L_B9B0-B1
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
JmpTable75D2									; JmpTable75D2:						; busca elemento de la tabla L_7D52 y lo ejecuta ; antes ; (#25# OK)
	ldx	#L_757B			; apunta a L_757B			; 	LD HL, L_757B		 ; 75B4 21 7B 75	; apunta a $757B dentro del rea de datos (#D10#)
	ldb	#$0A			; contador a 10				; 	LD B, $0A		 ; 75B7 06 0A		; contador a 10
	jsr	FillWithZeros		; llama FillWithZeros			; 	CALL FillWithZeros	 ; 75B9 CD E2 70	; Pone a cero 10 bytes apuntados por HL (hasta final del bloque #D10#)
	ldb	<reg_E			; recupera reg_E			; 	SET 4, E		 ; 75BC CB E3		; pone a 1 el bit4 de E
	orb	#$10			; pone a 1 el bit4	
	stb	<reg_E			; lo guarda
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_75BE	jsr	GetByteFlags		; llama	GetByteFlags			; L_75BE: CALL GetByteFlags	 ; 75BE CD 73 78	; llama GetByteFlags -  A=4 bits altos de ((L_B6DC-DD))
										; 	PUSH DE			 ; 75C1 D5		; salva DE
	lsra				; divide A				; 	RRCA			 ; 75C2 0F		; rota A 
	lsra				; por 8					; 	RRCA			 ; 75C3 0F		; tres veces a la derecha
	lsra				; offset calculado			; 	RRCA			 ; 75C4 0F		; para calcular el offset (/8). Mltiplo de 2 ya que los 4 bits bajos eran 0
							 			; 	LD E, A			 ; 75C5 5F		; pasa offset al byte bajo
										; 	LD D, $00		 ; 75C6 16 00		; byte alto a cero
	ldx	#L_75D2			; apunta a L_7D52 (inicio tabla)	; 	LD HL, L_75D2		 ; 75C8 21 D2 75	; HL apunta a inicio de tabla (de rutinas de 2 bytes x entrada)
										; 	ADD HL, DE		 ; 75CB 19		; le suma el offset
										; 	LD E, (HL)		 ; 75CC 5E		; carga byte bajo nueva direccion
										; 	INC HL			 ; 75CD 23		; incrementa puntero
										;	LD D, (HL)		 ; 75CE 56		; carga byte alto
										; 	EX DE, HL		 ; 75CF EB		; lo pasa a HL
										; 	POP DE			 ; 75D0 D1		; recupera DE
	jmp	[a,x]			; salta a rutina en offset calculado	; 	JP (HL)			 ; 75D1 E9		; salta a la subrutina recuperada de la tabla
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_75EC	lda	L_B71B			; recupera L_B71B			; L_75EC: LD A, (L_B71B)	 ; 75EC 3A 1B B7	; recupera L_B71B
	deca				; lo decrementa				; 	DEC A			 ; 75EF 3D		; decrementa A
	rts				; retorna				; 	RET			 ; 75F0 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
TestB71B									; TestB71B:						; verifica estado L_B71B (#85# OK)
	lda	L_B71B			; recupera L_B71B			; 	LD A, (L_B71B)		 ; 75F1 3A 1B B7	; recupera L_B71B
										; 	AND A			 ; 75F4 A7		; adecua flags
	rts				; retorna con flag Z informado		; 	RET			 ; 75F5 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#80# OK) offset 12 tabla L_75D2
L_75F6	clra				; pone 0				; L_75F6: XOR A			 ; 75F6 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	sta	L_B705			; en L_B705				; 	LD (L_B705), A		 ; 75F7 32 05 B7	; (L_B705) = A	; (L_B705) = 0
										; 							; Busca un bloque, copia los datos y ejecuta accin (#79# --) offset 11 tabla L_75D2
CopyDataAndJmpTable75D2								; CopyDataAndJmpTable75D2:				; Parametro IY apunta un bloque de 24 bytes
	ldb	<reg_E			; recupera reg_E			; 	BIT 1, E		 ; 75FA CB 4B		; est a 1 el bit1 de E?
	andb	#%00000010		; $02, verifica bit1			; 
	beq	L_7614			; si cero, salta a L_7614		; 	JR Z, L_7614		 ; 75FC 28 16		; no, salta a L_7614
	lda	L_B706			; recupera L_B706			; 	LD A, (L_B706)		 ; 75FE 3A 06 B7	; recupera L_B706
										; 	AND A			 ; 7601 A7		; es 0?
	bne	L_7614			; si no es 0, salta a L_7614		; 	JR NZ, L_7614		 ; 7602 20 10		; no, salta a L_7614
	lda	L_B6DE			; recupera L_B6DE			; 	LD A, (L_B6DE)		 ; 7604 3A DE B6	; recupera L_B6DE
	cmpa	#$C0			; es $C0?				; 	CP $C0			 ; 7607 FE C0		; es $C0?
	bne	i_760E			; no, salta a i_760E			; 	JR NZ, i_760E		 ; 7609 20 03		; no, salta a i_760E
	cmpa	<reg_D			; es igual a reg_D?			; 	CP D			 ; 760B BA		; si, es D $C0?
	beq	L_75EC			; si, sale via L_75EC			; 	JR Z, L_75EC		 ; 760C 28 DE		; si, sale via L_75EC
i_760E	jsr	TestB71B		; llama TestB71B			; i_760E: CALL TestB71B		 ; 760E CD F1 75	; llama TestB71B
	lbeq	SayWhat			; si da 0, salta a SayWhat		; 	JP Z, SayWhat?		 ; 7611 CA 2F 79	; si es 0, salta a SayWhat?
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7614	lda	L_B719			; recupera L_B719			; L_7614: LD A, (L_B719)	 ; 7614 3A 19 B7	; recupera L_B719
	deca				; decrementa valor			; 	DEC A			 ; 7617 3D		; decrementa A
	bne	i_761E			; si no es 0, salta a i_761E		; 	JR NZ, i_761E		 ; 7618 20 04		; si no es cero, salta a i_761E
	ldb	,y			; toma valor de (IY+1)			; 	SET 7, (IY+$01)		 ; 761A FD CB 01 FE	; pone a 1 el bit 7 de (IY+$01), byte alto primera palabra del bloque
	orb	#$80			; bit7 a 1
	stb	,y			; lo guarda de nuevo 
i_761E	ldx	#L_B706			; apunta a L_B706			; i_761E: LD HL, L_B706		 ; 761E 21 06 B7	; apunta a L_B706
	deca				; decrementa valor			; 	DEC A			 ; 7621 3D		; decrementa A de nuevo
	pshs	cc			; guarda flags
	lda	<reg_D			; recupera reg_D			; 	LD A, D			 ; 7622 7A		; pasa D a A
	puls 	cc			; recupera flags
	bne	i_7629			; si no era 0, salta a i_7629		; 	JR NZ, i_7629		 ; 7623 20 04		; si flag Z=0 (tras decrementar A), salta a i_7629
	cmpa	#$A0			; es $A0?				; 	CP $A0			 ; 7625 FE A0		; es A (antes D) $A0?
	beq	i_762A			; si, salta siguiente			; 	JR Z, i_762A		 ; 7627 28 01		; si, salta a i_762A
i_7629	inc	,x			; incrementa (HL+0) 			; i_7629: INC (HL)		 ; 7629 34		; Incrementa L_B706
i_762A	jsr	SearchBlkBackIY		; llama	SearchBlkBackIY			; i_762A: CALL SearchBlkBackIY	 ; 762A CD 93 78	; llama SearchBlkBackIY
	cmpa	#$A0			; es A=$A0?				; 	CP $A0			 ; 762D FE A0		; es A $A0?
	beq	ClearAndJmpTable75D2	; si, salta a ClearAndJmpTable75D2	; 	JP Z, ClearAndJmpTable75D2 ; 762F CA A0 75	; si, vuelve a ClearAndJmpTable75D2
	ldb	L_B71A			; recupera L_B71A (to be used in ABX)	; 	LD A, (L_B71A)		 ; 7632 3A 1A B7	; recupera L_B71A
										; 	AND A			 ; 7635 A7		; es 0?
	beq	i_7682			; si es 0, salta a i_7682		; 	JR Z, i_7682		 ; 7636 28 4A		; si, salta a i_7682 (sin copiar palabras)
	ldu	<reg_DE			; recupera reg_DE
	pshs	u			; lo guarda				; 	PUSH DE			 ; 7638 D5		; Guarda DE		
										; 	LD E, A			 ; 7639 5F		; pasa A a E (contenido de L_B71A)
										; 	LD D, $00		 ; 763A 16 00		; byte alto a 0
	ldx	#L_B9C8			; apunta a L_B9C8			; 	LD HL, L_B9C8		 ; 763C 21 C8 B9	; apunta a L_B9C8 (bloque de trabajo de 24 bytes)
	abx				; le suma offset  - SIN SIGNO -		; 	ADD HL, DE		 ; 763F 19		; le suma el offset de L_B71A
	ldy	<reg_IY			; recupera reg_IY
	pshs	y			; lo guarda				; 	PUSH IY			 ; 7640 FD E5		; Guarda IY
	ldy	#L_B9B0			; apunta a L_B9B0			; 	LD IY, L_B9B0		 ; 7642 FD 21 B0 B9	; Carga IY con L_B9B0 (estructura de 8+10+6 bytes) - 24 bytes mas atrs que L_B9C8
	ldu	#L_B9B8			; apunta a L_B9B8			; 	LD A, (IY+$08)		 ; 7646 FD 7E 08	; recupera primer byte del sub-bloque de 10
	ldd	8,y			; recupera (IY+8/9)			; 	OR (IY+$09)		 ; 7649 FD B6 09	; detecta si primera palabra de este bloque es nula
										; 	LD DE, L_B9B8		 ; 764C 11 B8 B9	; DE apunta a L_B9B8 (inicio bloque de 10)
	beq	i_7668			; si es 0, salta a i_7668		; 	JR Z, i_7668		 ; 764F 28 17		; si era palabra nula, salta a i_7668
	ldd	8,y			; recupera (IY+8/9)			; 	LD A, (IY+$08)		 ; 7651 FD 7E 08	; recupera primer byte del bloque de 10 bytes L_B9B8
	cmpd	,x			; coincide con los apuntados por X?	; 	CP (HL)			 ; 7654 BE		; es igual al byte apuntado por HL?
	beq	i_7668			; si, salta a i_7668			; 	JR NZ, i_765F		 ; 7655 20 08		; no, salta a i_765F
										; 	LD A, (IY+$09)		 ; 7657 FD 7E 09	; recupera segundo byte
										; 	INC HL			 ; 765A 23		; Incrementa HL
										; 	CP (HL)			 ; 765B BE		; es igual el segundo byte al ahora apuntado por HL?
										; 	DEC HL			 ; 765C 2B		; decrementa HL
										; 	JR Z, i_7668		 ; 765D 28 09		; si son iguales, salta a i_7668
i_765F	ldu	#L_B9C2			; apunta a L_B9C2			; i_765F: LD A, (IY+$12)	 ; 765F FD 7E 12	; recupera el byte de $B9C2 (primero del bloque de 6)
	ldd	12,y			; mira si (IY+12/13) es nulo		; 	OR (IY+$13)		 ; 7662 FD B6 13	; detecta si la primera palabra del bloque es nula
									 	; 	LD DE, L_B9C2		 ; 7665 11 C2 B9	; DE apunta al bloque de 6 bytes L_B9C2
i_7668  tfr	cc,b			; save flags
	puls	y			; recupera IY inicial			; i_7668: POP IY		 ; 7668 FD E1		; recupera IY inicial
	sty	<reg_IY			; update variable
	tfr	b,cc			; restore flags
	bne	i_7681			; si NO era nula la palabra, a i_7681	; 	JR NZ, i_7681		 ; 766A 20 15		; si no era nula la palabra, salta a i_7681
	exg	x,u			; intercambia punteros			; 	EX DE, HL		 ; 766C EB		; Intercambia DE con HL  (Ahora HL=L_B9C2 y DE=L_B9C8+offset de L_B71A)
										; 							; si la palabra era nula, copia tres palabras apuntadas por DE (L_B9C2 bloque de 6)
	ldy	#3			; contador palabras a 3			; 	LD B, $03		 ; 766D 06 03		; contador a 3 palabras = 6 bytes
i_766F	ldd	,x			; mira si es nula la palabra apuntada	; i_766F: LD A, (HL)		 ; 766F 7E		; recupera byte apuntado por HL
										; 	INC HL			 ; 7670 23		; Incrementa HL
										; 	OR (HL)			 ; 7671 B6		; detecta si los dos son cero
										; 	DEC HL			 ; 7672 2B		; Decrementa HL
	bne	i_7677			; no, salta a i_7677			; 	JR NZ, i_7677		 ; 7673 20 02		; si no es nula la palabra, no copia, salta a i_7677
	ldd	,u			; recupera dos bytes			; 	LD A, (DE)		 ; 7675 1A		; recupera byte apuntado por DE
	std	,x			; los guarda en destino			; 	LD (HL), A		 ; 7676 77		; lo copia en byte apuntado por HL
i_7677	leax	2,x			; incrementa puntero destino		; i_7677: INC HL		 ; 7677 23		; Incrementa HL
	leau	2,u			; incrementa puntero origen		; 	INC DE			 ; 7678 13		; Incrementa DE
										; 	JR NZ, i_767D		 ; 7679 20 02		; si no era nula la palabra, no copia, salta a i_767D
										; 	LD A, (DE)		 ; 767B 1A		; recupera siguiente byte apuntado por DE
										; 	LD (HL), A		 ; 767C 77		; lo copia en siguiente byte apuntado por HL. Ha copiado UNA palabra
										; i_767D: INC HL		 ; 767D 23		; Incrementa HL
										; 	INC DE			 ; 767E 13		; Incrementa DE
	leay	-1,y			; decrementa contador palabras		; 	DJNZ i_766F		 ; 767F 10 EE		; Decrementa B y si no es cero vuelve a i_766F (3 palabras a copiar)
	bne	i_766F			; si no es 0, vuelve a i_766F
i_7681	puls	u			; recupera U (DE)			; i_7681: POP DE		 ; 7681 D1		; Recupera DE
i_7682	ldy	<reg_IY			; recupera reg_IY
	pshs	y			; guarda Y (IY)				; i_7682: PUSH IY		 ; 7682 FD E5		; Guarda IY
	ldy	#ActionTable		; apunta a ActionTable			; 	LD IY, LOCTABLE		 ; 7684 FD 21 E0 B9	; apunta a LOCTABLE (un byte despus del final de L_B9C8, el ltimo bloque de 24 bytes)
					; due to datablocks reorganization
					; actions are just before ActionTable
					; in 6809 version not before LOCTABLE
	sty	<reg_IY			; update pseudo-register
	lda	L_B706			; recupera L_B706			; 	LD A, (L_B706)		 ; 7688 3A 06 B7	; recupera L_B706 
	sta	<reg_B			; lo guarda en reg_B
	ldb	<reg_C			; recupera reg_C (D=reg_BC)		; 	LD B, A			 ; 768B 47		; lo pasa a B
	pshs	d			; guarda D (BC)				; 	PUSH BC			 ; 768C C5		; Guarda BC
	jsr	DecCounterSearchBlkBackIY					; 	CALL DecCounterSearchBlkBackIY
					; llama DecCounterSearchBlkBackIY	; 				 ; 768D CD 92 78	; llama DecCounterSearchBlkBackIY
i_7690	lda	<reg_B			; recupera reg_B			; i_7690: LD A, B		 ; 7690 78		; pasa B a A (ha sido decrementado en DecCounterSearchBlkBackIY)
										; 	AND A			 ; 7691 A7		; es 0?
	beq	i_76A4			; si es 0, salta a i_76A4		; 	JR Z, i_76A4		 ; 7692 28 10		; si, salta a i_76A4 (no hay mas que buscar)
	jsr	DecCounterSearchBlkBackIY					; 	CALL DecCounterSearchBlkBackIY
					; llama DecCounterSearchBlkBackIY	; 				 ; 7694 CD 92 78	; llama DecCounterSearchBlkBackIY
	lda	,y			; recupera (IY+0)			; 	LD A, (IY+$01)		 ; 7697 FD 7E 01	; recupera segundo byte del bloque de 24 seleccionado (byte alto primera palabra)
	anda	#$7F			; pasa a 0 el bit7 del byte alto	; 	AND $7F			 ; 769A E6 7F		; pasa a cero el bit7
	ora	1,y			; mira si ambos son 0			; 	OR (IY+$00)		 ; 769C FD B6 00	; es nula la palabra?
	bne	i_7690			; no, vuelve a i_7690			; 	CALL Z, MoveUp3WordsAndCopyFromIXToIY
	jsr	MoveUp3WordsAndCopyFromIXToIY					; 				 ; 769F CC B7 78	; si, llama MoveUp3WordsAndCopyFromIXToIY
					; llama MoveUp3WordsAndCopyFromIXToIY 
	bra	i_7690			; vuelve a i_7690			; 	JR i_7690		 ; 76A2 18 EC		; vuelve a i_7690
i_76A4	puls	d			; restaura D(BC)			; i_76A4: POP BC		 ; 76A4 C1		; Recupera BC
	std	<reg_BC			; guarda reg_BC				
										; 	POP IY			 ; 76A5 FD E1		; Recupera IY
	ldy	,s			; toma Y del stack sin modifcar puntero	; 	PUSH IY			 ; 76A7 FD E5		; lo guarda de nuevo
	sty	<reg_IY			; update variable
	jsr	DecCounterSearchBlkFwdIY
					; llama DecCounterSearchBlkFwdIY	; 	CALL DecCounterSearchBlkFwdIY
										; 				 ; 76A9 CD 8C 78	; llama DecCounterSearchBlkFwdIY
i_76AC	lda	<reg_B			; recupera reg_B			; i_76AC: LD A, B		 ; 76AC 78		; pasa B a A
										; 	AND A			 ; 76AD A7		; es 0?
	beq	i_76DE			; si 0, salta a i_76DE			; 	JP Z, i_76DE		 ; 76AE CA DE 76	; si, salta a i_76DE
	jsr	DecCounterSearchBlkFwdIY
					; llama DecCounterSearchBlkFwdIY	; 	CALL DecCounterSearchBlkFwdIY
										; 				 ; 76B1 CD 8C 78	; llama DecCounterSearchBlkFwdIY
	ldd	12,y			; mira si (IY+12/13) es nulo		; 	LD A, (IY+$12)		 ; 76B4 FD 7E 12	; recupera primer byte del sub-bloque de 6 dentro del bloque de 24 bytes
										; 	OR (IY+$13)		 ; 76B7 FD B6 13	; son cero ambos bytes?
	bne	i_76AC			; no, vuelve a i_76AC			; 	JR NZ, i_76AC		 ; 76BA 20 F0		; no, vuelve a i_76AC para buscar otro bloque de 24
	ldd	,y			; recupera palabra  (2 bytes)		; 	LD A, (IY+$00)		 ; 76BC FD 7E 00	; recupera primer byte de la primera palabra del bloque de 24 bytes
	cmpd	,x			; es igual a destino?			; 	CP (IX+$00)		 ; 76BF DD BE 00	; es igual a primer byte de la primera palabra apuntada por IX?
	bne	i_76AC			; no, vuelve a i_76AC			; 	JR NZ, i_76AC		 ; 76C2 20 E8		; no, vuelve a i_76AC para buscar otro bloque de 24
										; 	LD A, (IY+$01)		 ; 76C4 FD 7E 01	; recupera segundo byte de IY
										; 	CP (IX+$01)		 ; 76C7 DD BE 01	; coincide con el segundo de IX?
										; 	JR NZ, i_76AC		 ; 76CA 20 E0		; no, vuelve a i_76AC para buscar otro bloque de 24
	ldd	14,x			; recupera 8a. palabra			; 	LD A, (IX+$0E)		 ; 76CC DD 7E 0E	; recupera primer byte de la octava palabra apuntada por IX
										; 	OR (IX+$0F)		 ; 76CF DD B6 0F	; son cero ambos bytes?
	beq	i_76AC			; si null, vuelve a i_76AC		; 	JR Z, i_76AC		 ; 76D2 28 D8		; si, vuelve a i_76AC para buscar otro bloque de 24
	jsr	do_exx			; intercambia registros con espejos	; 	EXX			 ; 76D4 D9		; Intercambia BC, DE, HL con sus espejos
	ldu	#$000E			; carga offset en U(DE)			; 	LD DE, $000E		 ; 76D5 11 0E 00	; pone valor 14 a DE (offset)
	stu	<reg_DE			; guarda reg_DE
	jsr	Copy10Or12If0FromIXtoIY	; llama Copy10Or12If0FromIXtoIY		; 	CALL Copy10Or12If0FromIXtoIY
										; 				 ; 76D8 CD EA 78	; llama Copy10Or12If0FromIXtoIY
	bra	i_76AC			; vuelve a i_76AC			; 	JP i_76AC		 ; 76DB C3 AC 76	; vuelve a i_76AC
i_76DE	puls	y			; recupera IY				; i_76DE: POP IY		 ; 76DE FD E1		; recupera IY
	sty	<reg_IY			; update variable
	lda	L_B705			; recupera L_B705			; 	LD A, (L_B705)		 ; 76E0 3A 05 B7	; recupera L_B705
	beq	e_76DE			; si 0, sale 				; 	AND A			 ; 76E3 A7		; es 0?
										; 	RET Z			 ; 76E4 C8		; si, retorna
	jsr	TestB71B		; llama TestB71B			; 	CALL TestB71B		 ; 76E5 CD F1 75	; llama TestB71B
										; 	RET Z			 ; 76E8 C8		; si es 0, retorna
	lbne	ClearAndJmpTable75D2	; si no 0, salta a ClearAndJmpTable75D2	; 	JP ClearAndJmpTable75D2	 ; 76E9 C3 A0 75	; vuelve a ClearAndJmpTable75D2
e_76DE	rts				; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#70# OK) offset 02 tabla L_75D2
L_76EC	ldb	<reg_E			; recupera reg_E			; L_76EC: BIT 1, E		 ; 76EC CB 4B		; est a 1 el bit1 de E?
	andb	#%00000010		; $02, verifica bit1			; 
	bne	L_7731			; si no es cero, salta a L_7731		; 	JR NZ, L_7731		 ; 76EE 20 41		; si, salta a L_7331
	clr	<reg_D			; pone 0 en reg_D			; 	LD D, $00		 ; 76F0 16 00		; no, carga $00 en D
										; 							; (#68# OK) offset 00 tabla L_75D2	   
L_76F2	ldb	<reg_E			; recupera reg_E			; L_76F2: BIT 2, E		 ; 76F2 CB 53		; esta a 1 el bit2 de E?
	andb	#%00000100		; $04, verifica bit2			; 
	lbeq	L_7929			; si cero, salta a L_7929		; 	JP Z, L_7929		 ; 76F4 CA 29 79	; no, salta a L_7929
	lda	L_B719			; recupera L_B719			; 	LD A, (L_B719)		 ; 76F7 3A 19 B7	; carga A con valor de L_B719 
	cmpa	#2			; es 2?					; 	CP $02			 ; 76FA FE 02		; es A=2?
	bne	i_7701			; no, salta siguiente			; 	JR NZ, i_7701		 ; 76FC 20 03		; no, salta siguiente instruccin
	jsr	L_7858			; llama L_7858				; 	CALL L_7858		 ; 76FE CD 58 78	; si, llama rutina L_7858 (#101# OK)
i_7701	ldb	<reg_E			; recupera reg_E			; i_7701: RES 2, E		 ; 7701 CB 93		; pasa a 0 el bit2 de E
	andb	#%11111011		; $FB, pasa bit2 a cero			; 
	stb	<reg_E			; actualiza reg_E			; 
	ldb	#2			; pone 2				; 	LD L, $02		 ; 7703 2E 02		; carga L con valor 2
	stb	<reg_L			; en reg_L				; 
	jsr	L_7918			; llama L_7918				; 	CALL L_7918		 ; 7705 CD 18 79	; llama rutina L_7918 (#107# OK)
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 7708 C3 B4 75	; pasa a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#78# OK) offset 10 tabla L_75D2
L_770B	ldd	<reg_DE			; recupera reg_DE			; L_770B: RES 3, E		 ; 770B CB 9B		; pone a 0 el bit3 de E
	andb	#%11110111		; $F7, pasa bit3 a cero			; 
	stb	<reg_E			; actualiza reg_E			; 
	pshs	d			; guarda reg_DE				; 	PUSH DE			 ; 770D D5		; guarda DE
i_770E	jsr	GetByteFlags		; llama	GetByteFlags			; i_770E: CALL GetByteFlags	 ; 770E CD 73 78	; llama GetByteFlags 
	cmpa	#$A0			; es A=$A0?				; 	CP $A0			 ; 7711 FE A0		; es A = $A0
	beq	i_770E			; si, salta a i_770E			; 	JR Z, i_770E		 ; 7713 28 F9		; si, bucle atras
	leax	-2,x			; resta 2 de X(HL)			; 	DEC HL			 ; 7715 2B		; decrementa HL
										; 	DEC HL			 ; 7716 2B		; dos veces
	stx	L_7574			; guarda X en L_7574			; 	LD (L_7574), HL		 ; 7717 22 74 75	; lo guarda en L_7574-75
	stx	L_B6DC			; y en L_B6DC				; 	LD (L_B6DC), HL		 ; 771A 22 DC B6	; y en L_B6DC-DD
	puls	d			; recupera D				; 	POP DE			 ; 771D D1		; recupera DE
	std	<reg_DE			; lo guarda en reg_DE			; 	LD A, E			 ; 771E 7B		; pasa E al registro A
	stb	L_7576			; guarda reg_E en L_7576		; 	LD (L_7576), A		 ; 771F 32 76 75	; lo guarda en L_7576
	ldy	<reg_IY			; recupera reg_IY
	sty	L_7577			; guarda Y en L_7577			; 	LD (L_7577), IY		 ; 7722 FD 22 77 75	; y guarda Y en L_7577
	lda	L_B706			; recupera L_B706			; 	LD A, (L_B706)		 ; 7726 3A 06 B7	; carga A con valor de L_B706
	sta	L_7579			; lo guarda en L_7579			; 	LD (L_7579), A		 ; 7729 32 79 75	; lo guarda en L_7579
	jmp	CopyDataAndJmpTable75D2	; salta a CopyDataAndJmpTable75D2	; 	JP CopyDataAndJmpTable75D2 ; 772C C3 FA 75	; salta a CopyDataAndJmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_772F	ldb	<reg_E			; recupera reg_E			; L_772F: RES 0, E		 ; 772F CB 83		; pasa a 0 el bit0 de E
	andb	#%11111110		; $FE, pasa bit0 a cero			; 
	stb	<reg_E			; actualiza reg_E			; 
L_7731	ldb	#$30			; pone valor $30			; L_7731: LD D, $30		 ; 7731 16 30		; carga D con $30
	stb	<reg_D			; en reg_D				; 
										; 							; (#71# OK) offset 03 tabla L_75D2
L_7733	ldb	<reg_E			; recupera reg_E			; L_7733: BIT 3, E		 ; 7733 CB 5B		; est a 1 el bit3 de E? 
	andb	#%00001000		; $08, verifica bit3			; 
	bne	i_7755			; si no es 0, salta a i_7755		; 	JR NZ, i_7755		 ; 7735 20 1E		; si, salta a i_7755
	jsr	TestB71B		; llama TestB71B			; 	CALL TestB71B		 ; 7737 CD F1 75	; llama TestB71B
	bne	i_7755			; si no da 0, salta a i_7755		; 	JR NZ, i_7755		 ; 773A 20 19		; si no es 0, salta a i_7755
	ldx	L_7574			; recupera L_7574			; 	LD HL, (L_7574)		 ; 773C 2A 74 75	; HL se carga con valor de L_7574-7575
	stx	L_B6DC			; lo guarda en L_B6DC			; 	LD (L_B6DC), HL		 ; 773F 22 DC B6	; guarda HL en L_B6DC
	lda	#$B0			; toma valor $B0			; 	LD D, $B0		 ; 7742 16 B0		; carga D con $B0
	ldb	L_7576			; recupera L_7576			; 	LD A, (L_7576)		 ; 7744 3A 76 75	; carga A con valor de L_7576
	std	<reg_DE			; lo guarda en reg_DE			; 	LD E, A			 ; 7747 5F		; lo guarda en E
	lda	L_7579			; recupera L_7579			; 	LD A, (L_7579)		 ; 7748 3A 79 75	; carga A con valor de L_7579
	sta	L_B706			; lo guarda en L_B706			; 	LD (L_B706), A		 ; 774B 32 06 B7	; lo guarda en L_B706
	ldy	L_7577			; recupera L_7577			; 	LD IY, (L_7577)		 ; 774E FD 2A 77 75	; puntero IY se carga con valor de L_7577-7578
	sty	<reg_IY			; lo guarda en reg_IY 
	jmp	CopyDataAndJmpTable75D2	; salta a CopyDataAndJmpTable75D2	; 	JP CopyDataAndJmpTable75D2 ; 7752 C3 FA 75	; salta a CopyDataAndJmpTable75D2
i_7755	jsr	ClearB719		; llama ClearB719			; i_7755: CALL ClearB719	 ; 7755 CD 5F 78	; llama ClearB719
	ldb	<reg_E			; recupera reg_E			; 	BIT 1, E		 ; 7758 CB 4B		; est a 1 el bit1 de E?
	andb	#%00000010		; $02, verifica bit1			; 
	lbeq	L_7929			; si cero, salta a L_7929		; 	JP Z, L_7929		 ; 775A CA 29 79	; no, salta a L_7929
	ldb	<reg_E			; recupera reg_E			; 	BIT 0, E		 ; 775D CB 43		; est a 1 el bit0 de E?
	andb	#%00000001		; $01, verifica bit0			; 
	beq	i_7767			; si cero, salta a i_7767		; 	JR Z, i_7767		 ; 775F 28 06		; no, salta a i_7767	
i_7761	jsr	L_7914			; llama L_7914				; i_7761: CALL L_7914		 ; 7761 CD 14 79	; llama rutina L_7914 (#112# OK)
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 7764 C3 B4 75	; pasa a JmpTable75D2
i_7767	ldu	<reg_DE			; recupera reg_DE			; i_7767: PUSH DE		 ; 7767 D5		; Guarda DE
	pshs	u			; lo guarda				; 
	ldu	<reg_BC			; recupera reg_BC			; 	PUSH BC			 ; 7768 C5		; Guarda BC
	pshs	u			; lo guarda				; 
	ldx	L_B6DC			; recupera L_B6DC			; 	LD HL, (L_B6DC)		 ; 7769 2A DC B6	; Carga HL con (L_B6DC)
	pshs	x			; lo guarda				; 	PUSH HL			 ; 776C E5		; Guarda HL
i_776D	jsr	GetByteFlags		; llama GetByteFlags			; i_776D: CALL GetByteFlags	 ; 776D CD 73 78	; llama GetByteFlags
	tsta				; es A=0?				; 	CP $00			 ; 7770 FE 00		; Compara A con $00
	beq	i_776D			; si, salta a i_776D			; 	JR Z, i_776D		 ; 7772 28 F9		; Si Z = 1, Salta a i_776D
	ldb	<reg_E			; recupera reg_E			; 	SET 0, E		 ; 7774 CB C3		; Pasa a 1 el bit 0 en E
	orb	#%00000001		; $01, pasa bit0 a 1			; 
	stb	<reg_E			; actualiza reg_E			; 
	cmpa	#$20			; es A=$20?				; 	CP $20			 ; 7776 FE 20		; Compara A con $20
	beq	i_7782			; si, salta a i_7782			; 	JR Z, i_7782		 ; 7778 28 08		; Si Z = 1, Salta a i_7782
	puls	x			; recupera X(HL)			; 	POP HL			 ; 777A E1		; Recupera HL
	stx	L_B6DC			; lo guarda en L_B6DC			; 	LD (L_B6DC), HL		 ; 777B 22 DC B6	; Carga (L_B6DC) con HL
	puls	u			; recupera U(BC)			; 	POP BC			 ; 777E C1		; Recupera BC
	stu	<reg_BC			; lo guarda en reg_BC			; 
	puls    u			; recupera U(DE)			; 	POP DE			 ; 777F D1		; Recupera DE
	stu	<reg_DE			; lo guarda en reg_DE			; 
	bra	i_7761			; vuelve a i_7761			; 	JR i_7761		 ; 7780 18 DF		; Salta a i_7761
i_7782	jsr	L_7914			; llama L_7914				; i_7782: CALL L_7914		 ; 7782 CD 14 79	; llama rutina L_7914 (#112# OK)
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7785 E1		; Recupera HL
	puls	u			; recupera U(BC)			; 	POP BC			 ; 7786 C1		; Recupera BC
	stu	<reg_BC			; lo guarda en reg_BC			; 
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7787 E1		; Recupera HL
	ldb	#2			; pone valor 2				; 	LD L, $02		 ; 7788 2E 02		; Carga L con $02
	stb	<reg_L			; en reg_L				; 
	jsr	L_7918			; llama L_7918				; 	CALL L_7918		 ; 778A CD 18 79	; llama rutina L_7918 (#107# OK)
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 778D C3 B4 75	; pasa a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#76# OK) offset 08 tabla L_75D2
L_7790	ldb	<reg_E			; recupera reg_E			; L_7790: RES 4, E		 ; 7790 CB A3		; pasa a 0 el bit4 de E
	andb	#%11101111		; $EF, pasa el bit4 a cero		; 
	stb	<reg_E			; actualiza reg_E			; 
	jmp	L_75BE			; salta a L_75BE			; 	JP L_75BE		 ; 7792 C3 BE 75	; salta a L_75BE
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7795	ldb	<reg_E			; recupera reg_E			; L_7795: BIT 1, E		 ; 7795 CB 4B		; est a 1 el bit1 de E?
	andb	#%00000010		; $02, verifica bit1			; 
	beq	i_77A0			; si 0, salta a i_77A0			; 	JR Z, i_77A0		 ; 7797 28 07		; no, salta a i_77A0 
	lda	L_B6DE			; recupera L_B6DE			; 	LD A, (L_B6DE)		 ; 7799 3A DE B6	; carga A con valor de L_B6DE
	cmpa	#$A0			; es $A0?				; 	CP $A0			 ; 779C FE A0		; es A = $A0
	lbeq	L_7731			; si, salta a L_7731			; 	JR Z, L_7731		 ; 779E 28 91		; si, salta a L_7331
i_77A0	ldb	#$70			; pone $70				; i_77A0: LD D, $70		 ; 77A0 16 70		; carga D con $70
	stb	<reg_D			; en reg_D				; 
										; 							; (#75# OK) offset 07 tabla L_75D2
L_77A2	jsr	L_781C			; llama L_781C				; L_77A2: CALL L_781C		 ; 77A2 CD 1C 78	; llama rutina L_781C (#110# OK)
i_77A5	jsr	GetByteFlags		; llama GetByteFlags			; i_77A5: CALL GetByteFlags	 ; 77A5 CD 73 78	; llama GetByteFlags
	cmpa	#$70			; es A=$70?				; 	CP $70			 ; 77A8 FE 70		; es A = $70?
	beq	L_77A2			; si, salta a L_77A2			; 	JR Z, L_77A2		 ; 77AA 28 F6		; si, bucle atrs
	cmpa	#$80			; es A=$80?				; 	CP $80			 ; 77AC FE 80		; es A = $80?
	bne	i_77B9			; no, salta a i_77B9			; 	JR NZ, i_77B9		 ; 77AE 20 09		; no, salta a i_77B9
	ldb	<reg_E			; recupera reg_E			; 	BIT 4, E		 ; 77B0 CB 63		; est a 1 el bit4 de E?
	andb	#%00010000		; $10, verifica bit4			; 
	bne	e_77A5			; si no es 0, salta siguiente		; 
	jsr	L_7924			; llama L_7924				; 	CALL Z, L_7924		 ; 77B2 CC 24 79	; no, llama rutina L7924 (#113# OK)
e_77A5	ldb	<reg_E			; recupera reg_E			; 	RES 4, E		 ; 77B5 CB A3		; pasa a 0 el bit4 de E
	andb	#%11101111		; $EF, pasa bit4 a cero			; 
	stb	<reg_E			; actualiza reg_E			; 
	bra	i_77A5			; salta a i_77A5			; 	JR i_77A5		 ; 77B7 18 EC		; vuelve a i_77A5
i_77B9	cmpa	#$60			; es A=$60?				; i_77B9: CP $60			 ; 77B9 FE 60		; compara A con $60
	beq	L_77C9			; si,salta a L_77C9			; 	JR Z, L_77C9		 ; 77BB 28 0C		; si flag Z=1, salta a (#74# OK)
	cmpa	#$50			; es A=$50?				; 	CP $50			 ; 77BD FE 50		; compara A con $50
	beq	L_77D1			; si, salta a L_77D1			; 	JR Z, L_77D1		 ; 77BF 28 10		; si flag Z=1, salta a (#73# OK)
	ldx	L_B6DA			; recupera L_B6DA			; 	LD HL, (L_B6DA)		 ; 77C1 2A DA B6	; carga HL con contenido de L_B6DA-DB
	stx	L_B6DC			; lo guarda en L_B6DC			; 	LD (L_B6DC), HL		 ; 77C4 22 DC B6	; lo guarda en L_B6DC-DD
	bra	i_77D7			; salta a i_77D7			; 	JR i_77D7		 ; 77C7 18 0E		; salta a i_77D7
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#74# OK) offset 06 tabla L_75D2
L_77C9	jsr	L_7809			; llama L_7809				; L_77C9: CALL L_7809		 ; 77C9 CD 09 78	; llama rutina L_7809 (#108# OK)
	jsr	GetByteFlags		; llama GetByteFlags			; 	CALL GetByteFlags	 ; 77CC CD 73 78	; llama GetByteFlags
	bra	i_77B9			; salta a i_77B9			; 	JR i_77B9		 ; 77CF 18 E8		; salta a i_77B9
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#73# OK) offset 05 tabla L_75D2
L_77D1	ldx	#L_757F			; apunta a L_757F			; L_77D1: LD HL, L_757F		 ; 77D1 21 7F 75	; HL apunta a L_757F (dentro de area de datos)
	ldd	<reg_BC			; recupera reg_BC			; 	LD (HL), C		 ; 77D4 71		; guarda C en byte apuntado por HL
										; 	INC HL			 ; 77D5 23		; incrementa HL
	std	,x+			; los guarda X(HL)			; 	LD (HL), B		 ; 77D6 70		; guarda B a continuacin
i_77D7	ldb	#$50			; pone valor $50			; i_77D7: LD D, $50		 ; 77D7 16 50		; carga D con $50
	stb	<reg_D			; en reg_D				; 
	lda	L_B719			; recupera L_B719			; 	LD A, (L_B719)		 ; 77D9 3A 19 B7	; carga A con valor de L_B719
	cmpa	#2			; es 2?					; 	CP $02			 ; 77DC FE 02		; es A = 2?
	bne	i_7802			; no, salta a i_7802			; 	JR NZ, i_7802		 ; 77DE 20 22		; no, salta a i_7802
	ldx	L_757B			; recupera 2 bytes de L_757B		; 	LD HL, (L_757B)		 ; 77E0 2A 7B 75	; carga HL con valor de L_757B-7C
										; 	LD A, H			 ; 77E3 7C		; pasa byte alto a A
										; 	OR L			 ; 77E4 B5		; hace OR con L
	bne	i_77FF			; si no es 0, salta a i_77FF		; 	JR NZ, i_77FF		 ; 77E5 20 18		; si algn bit no es cero, salta a i_77FF 
	ldb	24,y			; recupera 1er byte sig bloque		; 	BIT 6, (IY+$19)		 ; 77E7 FD CB 19 76	; est a 1 el bit6 del byte apuntado por IY+25
	andb	#%01000000		; $40, verifica bit6			; 
	bne	i_77F5			; si no es 0, salta a i_77F5		; 	JR NZ, i_77F5		 ; 77EB 20 08		; si, salta a i_77F5
										; 	LD BC, $FFE8		 ; 77ED 01 E8 FF	; carga BC con $FFE8 (equivale a -24)
	leay	-24,y			; apunta a bloque anterior		; 	ADD IY, BC		 ; 77F0 FD 09		; lo suma (resta 24 en realidad) a IY
	sty	<reg_IY			; guarda nuevo valor en reg_IY
	jsr	ClearBlkAndFreePrevious	; llama ClearBlkAndFreePrevious		; 	CALL ClearBlkAndFreePrevious
										; 				 ; 77F2 CD 64 78	; llama ClearBlkAndFreePrevious
i_77F5	jsr	L_7850			; llama L_7850				; i_77F5: CALL L_7850		 ; 77F5 CD 50 78	; llama rutina L_7850 (#114# OK)	 
	ldb	#$40			; pone valor $40			; 	LD (IY+$01), $40	 ; 77F8 FD 36 01 40	; pone en byte apuntado por IY+1 el valor $40
	stb	,y			; en 2o byte				; 
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 77FC C3 B4 75	; pasa a JmpTable75D2
i_77FF	jsr	L_7858			; llama L_7858				; i_77FF: CALL L_7858		 ; 77FF CD 58 78	; llama rutina L_7858 (#101# OK)
i_7802	jsr	L_782B			; llama L_782B				; i_7802: CALL L_782B		 ; 7802 CD 2B 78	; llama rutina L_782B (#109# OK)
	lbeq	JmpTable75D2		; si da 0, salta a JmpTable75D2		; 	JP Z, JmpTable75D2	 ; 7805 CA B4 75	; si cero, pasa a JmpTable75D2
	rts				; retorna				; 	RET			 ; 7808 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#108# OK)
L_7809	ldx	#L_7581			; apunta a L_7581			; L_7809: LD HL, L_7581		 ; 7809 21 81 75	; HL apunta a L_7581 (rea de datos)
i_780C	ldd	,x+			; toma dos bytes			; i_780C: LD A, (HL)		 ; 780C 7E		; A recibe valor byte apuntado por HL
										; 	INC HL			 ; 780D 23		; incrementa HL
										; 	OR (HL)			 ; 780E B6		; hace OR del byte al que apunta ahora HL con contenido de A
	beq	i_7818			; si cero, salta a i_7818		; 	JR Z, i_7818		 ; 780F 28 07		; si todos los bits quedan a cero, salta a i_7818
	leax	1,x			; incrementa puntero			; 	INC HL			 ; 7811 23		; incrementa HL
	ldd	,x+			; toma dos bytes			; 	LD A, (HL)		 ; 7812 7E		; carga en A el valor del byte apuntado por HL 
										; 	INC HL			 ; 7813 23		; incrementa HL
										; 	OR (HL)			 ; 7814 B6		; hace OR del byte al que apunta ahora HL con contenido de A
	lbne	L_7924			; si no es cero, salta a L_7924		; 	JP NZ, L_7924		 ; 7815 C2 24 79	; si algn bit est en 1, llama rutina L7924 (#113# OK)
i_7818	ldd	<reg_BC			; recupera reg_BC			; i_7818: LD (HL), B		 ; 7818 70		; carga en B el valor del byte apuntado por HL
	leax	-1,x			; decrementa puntero			; 	DEC HL			 ; 7819 2B		; decrementa HL
	std	,x			; guarda reg_BC				; 	LD (HL), C		 ; 781A 71		; carga en C el valor del byte apuntado por HL
	rts				; retorna				; 	RET			 ; 781B C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#110# OK)
L_781C	ldx	#L_757A			; apunta a L_757A			; L_781C: LD HL, L_757A		 ; 781C 21 7A 75	; HL apunta a L_757A (rea de datos)
	inc	,x			; incrementa byte apuntado		; 	INC (HL)		 ; 781F 34		; incrementa valor del byte apuntado
	lda	,x			; lo recupera				; 	LD A, (HL)		 ; 7820 7E		; lo carga en A
	cmpa	#3			; es igual o mayor que 3?		; 	CP $03			 ; 7821 FE 03		; es igual a 3?
	lbcc	L_7924			; si, salta a L_7924			; 	JP NC, L_7924		 ; 7823 D2 24 79	; si flag C=0 (A>=3), llama rutina L7924 (#113# OK)
	ldx	#L_757B			; apunta a L_757B			; 	LD HL, L_757B		 ; 7826 21 7B 75	; HL apunta a L_757B (bastaba con un triste INC HL, un byte en lugar de tres)
	bra	i_780C			; salta a i_780C			; 	JR i_780C		 ; 7829 18 E1		; salta a i_780C
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#109# OK)
L_782B	ldb	<reg_E			; recupera reg_E			; L_782B: BIT 6, E		 ; 782B CB 73		; est a 1 el bit6 de E?
	andb	#%01000000		; $40, verifica bit6			; 
	bne	L_7850			; si no es cero, salta a L_7850		; 	JR NZ, L_7850		 ; 782D 20 21		; no, salta a L_7850 (#114# OK)	       
	tst	<reg_E			; verifica bit7				; 	BIT 7, E		 ; 782F CB 7B		; est a 1 el bit7 de E?
	bmi	L_7838			; si esta a 1, salta a L_7838		; 	JR NZ, L_7838		 ; 7831 20 05		; si, salta a L_7838
	jsr	L_7924			; llama L_7924				; 	CALL L_7924		 ; 7833 CD 24 79	; llama rutina L7924 (#113# OK)
	clra				; para devolver flag Z=1		; 	XOR A			 ; 7836 AF		; A=0, flag Z=1A = A XOR A	-  A = 0, borra A, flag Z = 1
	rts				; retorna				; 	RET			 ; 7837 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7838	ldb	<reg_E			; recupera reg_E			; L_7838: RES 7, E		 ; 7838 CB BB		; pasa a 0 el bit7 de E
	andb	#%01111111		; $7F, pasa bit7 a cero			; 
	stb	<reg_E			; actualiza reg_E			; 
										; 	PUSH DE			 ; 783A D5		; guarda DE
	ldd	#$000E			; toma valor $000E			; 	LD DE, $000E		 ; 783B 11 0E 00	; carga DE con $000E
										; 
i_783E										; i_783E: PUSH BC			 ; 783E C5		; guarda BC
										; 	PUSH IY			 ; 783F FD E5		; pasa IY
	ldx	<reg_IY			; recupera reg_IY			; 	POP HL			 ; 7841 E1		; a HL
										; 	ADD HL, DE		 ; 7842 19		; suma DE a HL
	leau	d,x			; le aade D y lo pasa a U(DE)		; 	EX DE, HL		 ; 7843 EB		; guarda HL en DE
	ldx	#L_757B			; apunta a L_757B			; 	LD HL, L_757B		 ; 7844 21 7B 75	; HL apunta a L_757B (rea de datos)
	ldb	#$0A			; 10 bytes a copiar			; 	LD BC, $000A		 ; 7847 01 0A 00	; carga BC con $000A
	jsr	do_ldir			; hacer la copia de X a U		; 	LDIR			 ; 784A ED B0		; copia 10 bytes del HL a DE
										; 	POP BC			 ; 784C C1		; recupera BC
										; 	POP DE			 ; 784D D1		; recupera DE
	clra				; para devolver flag Z=1		; 	XOR A			 ; 784E AF		; A=0, flag Z=1
	rts				; retorna				; 	RET			 ; 784F C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#114# OK)
L_7850	ldb	<reg_E			; recupera reg_E			; L_7850: RES 6, E		 ; 7850 CB B3		; pasa a 0 el bit6 de E
	andb	#%10111111		; $BF, pasa bit6 a cero			; 
	stb	<reg_E			; actualiza reg_E			; 
										; 	PUSH DE			 ; 7852 D5		; guarda DE 
	ldd	#$0004			; toma valor $0004			; 	LD DE, $0004		 ; 7853 11 04 00	; carga DE con $0004 
	bra	i_783E			; salta a i_783E			; 	JR i_783E		 ; 7856 18 E6		; salta a i_783E  
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#101# OK) - Subrutina para revisar el valor del bit6 de IY + $0018 + 1 (No modifica DE)
L_7858	jsr	SearchBlkFwdIX		; llama SearchBlkFwdIX			; L_7858: CALL SearchBlkFwdIX	 ; 7858 CD A5 78	; llama SearchBlkFwdIX
	sty	<reg_IY			; guarda puntero en reg_IY		; 	PUSH IX			 ; 785B DD E5		; pasa puntero IX 
										; 	POP IY			 ; 785D FD E1		; a IY
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ClearB719									; ClearB719:						; pasa L_B719 a cero, retorna con A=0 (#111# OK)
	clra				; pone 0				; 	XOR A			 ; 785F AF		; pone 0
	sta	L_B719			; en L_B719				; 	LD (L_B719), A		 ; 7860 32 19 B7	; en $B719
	rts				; retorna				; 	RET			 ; 7863 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ClearBlkAndFreePrevious								; ClearBlkAndFreePrevious:				; Borra bloque apuntado por IY y elimina la primera palabra del bloque anterior (IY-24) ; antes ; (#100# OK)
	tfr	y,x			; pasa Y(IY) a X(HL)			; 	PUSH IY			 ; 7864 FD E5		; Pasa IY
										; 	POP HL			 ; 7866 E1		; a HL
	ldb	#$18			; carga B con 24 (bytes a borrar)	; 	LD B, $18		 ; 7867 06 18		; 24 bytes a borrar
	jsr	FillWithZeros		; llama FillWithZeros			; 	CALL FillWithZeros	 ; 7869 CD E2 70	; pone a cero 24 bytes apuntados por HL, B retorna con valor 0		 
	stb	-24,y			; a 0 					; 	LD (IY-$18), B		 ; 786C FD 70 E8	; pone a cero la primera palabra (2 bytes)
	stb	-23,y			; la 1a palabra				; 	LD (IY-$17), B		 ; 786F FD 70 E9	; del bloque anterior de 24 bytes
	rts				; retorna				; 	RET			 ; 7872 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; obtiene B = 4 bits bajos de ((L_B6DC-DD))
										; 							;         A=D = 4 bits altos de ((L_B6DC-DD))
										; 							;         C = byte ((L_B6DC-DD)+1)
GetByteFlags									; GetByteFlags:						;         (L_B6DC-DD)+=2  ; (#27# OK)
	ldx	L_B6DC			; recupera puntero de L_B6DC		; 	LD HL, (L_B6DC)		 ; 7873 2A DC B6	; recupera puntero contenido en L_B6DC-DD
	stx	L_B6DA			; lo guarda en L_B6DA			; 	LD (L_B6DA), HL		 ; 7876 22 DA B6	; se guarda en L_B6DA-DB
	lda	<reg_D			; recupera reg_D			; 	LD A, D			 ; 7879 7A		; guarda D
	sta	L_B6DE			; en L_B6DE				; 	LD (L_B6DE), A		 ; 787A 32 DE B6	; en L_B6DE
	lda	,x			; recupera un byte			; 	LD A, (HL)		 ; 787D 7E		; recupera el byte apuntado por (L_B6DC-DD)
	anda	#$0F			; a 0 los 4 bits altos			; 	AND $0F			 ; 787E E6 0F		; guarda solo los 4 bits bajos
	sta	<reg_B			; lo guarda en reg_B			; 	LD B, A			 ; 7880 47		; pasa resultado al registro B
	lda	,x+			; lo vuelve a recuperar			; 	LD A, (HL)		 ; 7881 7E		; vuelve a cargar byte apuntado por (L_B6DC-DD)
	anda	#$F0			; a 0 los 4 bits bajos			; 	AND $F0			 ; 7882 E6 F0		; se queda con los 4 bits altos
	sta	<reg_D			; lo guarda en reg_D			; 	LD D, A			 ; 7884 57		; guarda resultado en D
										; 	INC HL			 ; 7885 23		; incrementa puntero HL
	ldb	,x+			; recupera siguiente byte		; 	LD C, (HL)		 ; 7886 4E		; carga en C el byte apuntado por HL
	stb	<reg_C			; lo guarda en reg_C			; 	INC HL			 ; 7887 23		; incrementa puntero HL
	stx	L_B6DC			; guarda puntero en L_B6DC		; 	LD (L_B6DC), HL		 ; 7888 22 DC B6	; lo guarda en L_B6DC-DD (ha sido incrementado en 2)
	rts				; retorna				; 	RET			 ; 788B C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; busca un bloque de 24 bytes que tenga el bit6 del segundo byte a cero (#132# --)
										; 							; Parametro IY direccin a partir de donde buscar
										; 							; empieza en IY y va adelante 
DecCounterSearchBlkFwdIY							; DecCounterSearchBlkFwdIY:				; devuelve  IY apuntando al bloque elegido
	dec	<reg_B			; decrementa registro reg_B		; 	DEC B			 ; 788C 05		; decrementa contador B
	jsr	SearchBlkFwdIX		; llama	SearchBlkFwdIX			; 	CALL SearchBlkFwdIX	 ; 788D CD A5 78	; llama rutina SearchBlkFwdIX
	bra	i_7896			; salta a i_7896			; 	JR i_7896		 ; 7890 18 04		; sale via i_7896 inviertiendo IX con IY
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; busca un bloque de 24 bytes que tenga el bit6 del segundo byte a cero (#130# --)
										; 							; Parametro IY direccin a partir de donde buscar
										; 							; empieza en IY-24 y va hacia atrs
										; 							; devuelve IY apuntando al bloque elegido
DecCounterSearchBlkBackIY							; DecCounterSearchBlkBackIY:				;          IX contiene el valor recibido en IY
	dec	<reg_B			; decrementa registro reg_B		; 	DEC B			 ; 7892 05		; Decrementa B
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; busca un bloque de 24 bytes que tenga el bit6 del segundo byte a cero (#129# --)
										; 							; Parametro IY direccin a partir de donde buscar
										; 							; empieza en IY-24 y va hacia atrs
										; 							; devuelve IY apuntando al bloque elegido
					; Devuelve Y como reg_IX
					; e invierte reg_IX con reg_IY
SearchBlkBackIY									; SearchBlkBackIY:					;          IX contiene el valor recibido en IY
	jsr	SearchBlkBackIX		; llama SearchBlkBackIX			; 	CALL SearchBlkBackIX	 ; 7893 CD 9F 78	; llama SearchBlkBackIX
i_7896	pshs	u			; guarda registro trabajo U		; i_7896: PUSH IX		 ; 7896 DD E5		; Guarda IX
	ldy	<reg_IX			; recupera reg_IX			; 	PUSH IY			 ; 7898 FD E5		; Guarda IY, ahora invierte valores
	ldu	<reg_IY			; recupera reg_IY			; 	POP IX			 ; 789A DD E1		; recupera en IX el valor anterior de IY
	sty	<reg_IY			; pasa reg_IX a reg_IY			; 	POP IY			 ; 789C FD E1		; recupera en IY el valor anterior de IX
	stu	<reg_IX			; pasa reg_IY a reg_IX			; 	RET			 ; 789E C9		; Retorna
	puls 	u,pc			; restaura U y retorna			; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; busca un bloque de 24 bytes que tenga el bit6 del segundo byte a cero (#134# --)
										; 							; Parametro IY direccin a partir de donde buscar
										; 							; empieza en IY-24 y va hacia atrs
										; 							; Parametro IY inicio de area donde buscar (no se modifica)
SearchBlkBackIX									; SearchBlkBackIX:					; Devuelve  IX apuntando al bloque elegido
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; 789F D5		; guarda DE
	pshs	d,u			; lo guarda
	ldu	#$FFE8			; toma valor -24			; 	LD DE, $FFE8		 ; 78A0 11 E8 FF	; carga DE con -24 para ir hacia atrs
	stu	<reg_DE			; lo guarda en reg_DE
	bra	SearchBlkToIX		; salta a SearchBlkToIX			; 	JR SearchBlkToIX	 ; 78A3 18 04		; salta a SearchBlkToIX
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; busca un bloque de 24 bytes que tenga el bit6 del segundo byte a cero (#102# OK)
										; 							; Parametro IY direccin a partir de donde buscar
										; 							; empieza en IY+24 y va adelante
										; 							; Parametro IY inicio de area donde buscar (no se modifica)
SearchBlkFwdIX									; SearchBlkFwdIX:					; Devuelve  IX apuntando al bloque elegido
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; 78A5 D5		; guarda DE
	pshs	d,u			; lo guarda
	ldu	#$0018			; toma valor 24				; 	LD DE, $0018		 ; 78A6 11 18 00	; carga DE con 24 para ir hacia adelante
	stu	<reg_DE			; lo guarda en reg_DE

SearchBlkToIX									; SearchBlkToIX:
	ldy	<reg_IY			; recupera reg_IY			; 	PUSH IY			 ; 78A9 FD E5		; Pasa IY
	sty	<reg_IX			; lo pasa a reg_IX			; 	POP IX			 ; 78AB DD E1		; a IX
i_78AD	ldd	<reg_DE			; toma offset de reg_DE			; i_78AD: ADD IX, DE		 ; 78AD DD 19		; pasa al siguiente bloque
	leay	d,y			; lo aade a Y(IX)
	sty	<reg_IX			; OLVIDADO, aadido 19/1/2016
	ldb	,y			; recupera (IX+0)  			; 	BIT 6, (IX+$01)		 ; 78AF DD CB 01 76	; est el bit6 del segundo byte del bloque a 1?
	andb	#$40			; est bit6 a 1?
	bne	i_78AD			; si, vuelve a i_78AD			; 	JR NZ, i_78AD		 ; 78B3 20 F8		; si, busca el siguiente bloque de 24 bytes
	puls	d,u			; restaura U(DE)			; 	POP DE			 ; 78B5 D1		; recupera DE
	stu	<reg_DE			; lo guarda en reg_DE
	rts				; retorna				; 	RET			 ; 78B6 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Copia 3 palabras dentro de un bloque de 24 bytes (de 8+10+6) (#131# --)
										; 							; origen palabras 5-6-7 (las 3 primeras del sub-bloque de 10)
										; 							; destino palabras 10-11-12 (el bloque final de 6)
										; 							; Parametro IX apunta a bloque origen de datos, antes de buscar el bloque libre de IY
										; 							;              al usar -24 como offset estar en memoria mas alta. IX > IY
MoveUp3WordsAndCopyFromIXToIY							; MoveUp3WordsAndCopyFromIXToIY:			;           IY apunta al bloque de 24 bytes seleccionado (destino datos)
	jsr	do_exx			; intercambia registros con espejos	; 	EXX			 ; 78B7 D9		; Intercambia BC, DE, HL con sus espejos (para qu???)
	ldu	<reg_IX			; toma papel de IX
	lda	,u			; toma 1er byte de origen 		; 	LD A, (IX+$01)		 ; 78B8 DD 7E 01	; recupera segundo byte origen (byte alto)
	anda	#$7F			; bit7 a 0				; 	AND $7F			 ; 78BB E6 7F		; pasa a 0 el bit7
	ora	,y			; OR con 1er byte destino		; 	OR (IY+$01)		 ; 78BD FD B6 01	; Hace OR lgico con segundo byte destino (byte alto)
	sta	,y			; actualiza destino			; 	LD (IY+$01), A		 ; 78C0 FD 77 01	; actualiza segundo byte destino (byte alto)
	lda	1,u			; toma 2o byte	 			; 	LD A, (IX+$00)		 ; 78C3 DD 7E 00	; recupera primer byte origen (byte bajo)
	sta	1,y			; lo guarda en destino			; 	LD (IY+$00), A		 ; 78C6 FD 77 00	; lo copia en primer byte destino (byte bajo)
	jsr	do_exx			; intercambia registros con espejos	; 	EXX			 ; 78C9 D9		; recupera BC, DE, HL de sus espejos (solo ha usado A!!!)
	ldd	28,y			; recupera 2 bytes			; 	LD A, (IY+$1C)		 ; 78CA FD 7E 1C	; recupera byte 29 destino = quinto byte del bloque siguiente al destino (?) 
										; 							; si encontr el bit6 del 2ndo byte a 0 al primer intento (IY=IX-24)
										; 							; entonces estara apuntando al 5 byte de IX pero no es seguro que haya tanta suerte ...)
										; 	OR (IY+$1D)		 ; 78CD FD B6 1D	; detecta si la palabra es nula
	beq	eCopy			; si son 0, retorna			; 	RET Z			 ; 78D0 C8		; si, retorna
	tst	<reg_E			; es negativo reg_E?			; 	BIT 7, E		 ; 78D1 CB 7B		; est a 1 el bit7 de E?
	bpl	eCopy			; no, retorna				; 	RET Z			 ; 78D3 C8		; si, retorna
	jsr	do_exx			; intercambia registros con espejos	; 	EXX			 ; 78D4 D9		; intercambia BC, DE, HL con sus espejos
	tfr	y,x			; pasa Y(IY) a X(HL)			; 	PUSH IY			 ; 78D5 FD E5		; pasa IY
										; 	POP HL			 ; 78D7 E1		; a HL
										; 	LD DE, $0012		 ; 78D8 11 12 00	; offset = 18
	leax	18,x			; le suma 18 a X(HL)			; 	ADD HL, DE		 ; 78DB 19		; lo suma en HL
	tfr	x,u			; pasa X(HL) a U(DE)			; 	PUSH HL			 ; 78DC E5		; Guarda HL (igual a IY+18)
										; 	LD DE, $FFF6		 ; 78DD 11 F6 FF	; toma valor -10
	leax	-10,x			; resta 10 de X(HL)			; 	ADD HL, DE		 ; 78E0 19		; lo suma a HL (ahora igual a IY+8)
										; 	POP DE			 ; 78E1 D1		; Recupera DE (igual a IY+18)
	ldb	#6			; numero de bytes a copiar		; 	LD BC, $0006		 ; 78E2 01 06 00	; numero de bytes a copiar (3 palabras)
	jsr	do_ldir			; llama do_ldir				; 	LDIR			 ; 78E5 ED B0		; (DE+)=(HL+);BC- (Copia las 3 palabras iniciales del sub-bloque de 10 en el bloque de 6)
	ldu	#$0004			; pone valor 4				; 	LD DE, $0004		 ; 78E7 11 04 00	; Carga DE con $04 offset a partir del cual se copiarn BC bytes
	stu	<reg_DE			; en reg_DE
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Copy10Or12If0FromIXtoIY								; Copy10Or12If0FromIXtoIY:				; Si palabra 2 (offset 2-3) de IY es cero le copia la de IX ; (#133# --)
	jsr	Copy10BytesFromIXtoIY	; llama Copy10BytesFromIXtoIY		; 	CALL Copy10BytesFromIXtoIY
										; 				 ; 78EA CD FF 78	; llama Copy10BytesFromIXtoIY - copia 10 bytes desde IX+4 en IY+4
										; 							; esto abarca las dos ltimas palabras del sub-bloque de 8 mas las 3 iniciales del de 10,
										; 							; estas ltimas las acaba de copiar en el sub-bloque final de 6 bytes
										; 	LD A, (IY+$02)		 ; 78ED FD 7E 02	; recupera byte bajo de la segunda palabra
	ldu	#$0002			; carga U con valor 2			; 	OR (IY+$03)		 ; 78F0 FD B6 03	; para detectar si es palabra nula
	stu	<reg_DE			; lo guarda en reg_DE			; 	LD DE, $0002		 ; 78F3 11 02 00	; offset a partir del cual se copiarn BC bytes
	ldd	2,y			; mira si (Y+2/3) son 0
	bne	iCopy			; no, salta siguiente			; 	CALL Z, Copy2BytesFromIXtoIY
	jsr	Copy2BytesFromIXtoIY	; llama Copy2BytesFromIXtoIY		; 				 ; 78F6 CC 03 79	; si era nula la segunda palabra, llama Copy2BytesFromIXtoIY, copia 2 bytes desde IX+2 en IY+2
iCopy	jsr	do_exx			; intercambia registros con espejos	; 	EXX			 ; 78F9 D9		; recupera BC, DE, HL de sus espejos
eCopy	rts				; retorna				; 	RET			 ; 78FA C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Copy10BytesFromIXtoIY								; Copy10BytesFromIXtoIY:				; (#135# --) aqu DE llega con valor $0004
	ldb	#$0A			; numero de bytes			; 	LD C, $0A		 ; 78FF 0E 0A		; numero de bytes a copiar
	bra	CopyFromIXtoIY		; llama CopyFromIXtoIY			; 	JR CopyFromIXtoIY	 ; 7901 18 02		; salta a CopyFromIXtoIY
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; copia C bytes de IX en IY ; antes ; (#136# --)
Copy2BytesFromIXtoIY								; Copy2BytesFromIXtoIY:					; aqu llega DE con valor $0002
	ldb	#$02			; numero de bytes			; 	LD C, $02		 ; 7903 0E 02		; C=$02
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
CopyFromIXtoIY									; CopyFromIXtoIY:
	stb	<reg_B			; guarda en reg_B el numero de bytes
	tfr	y,x			; pasa Y(IY) a X(HL)			; 	PUSH IY			 ; 7905 FD E5		; pasa IY
	ldd	<reg_DE			; recupera offset de reg_DE		; 	POP HL			 ; 7907 E1		; a HL
	leax	d,x			; lo suma a X(HL)			; 	ADD HL, DE		 ; 7908 19		; le suma un offset
	tfr	x,u			; pasa X(HL) a U(DE)			; 	PUSH HL			 ; 7909 E5		; Guarda HL (alias IY)
	ldx	<reg_IX			; toma rol de reg_IX			; 	PUSH IX			 ; 790A DD E5		; pasa IX
										; 	POP HL			 ; 790C E1		; a HL (alias IX)
	leax	d,x			; suma el offset a X(HL)		; 	ADD HL, DE		 ; 790D 19		; le suma mismo offset
										; 	POP DE			 ; 790E D1		; Recupera DE (alias IY)
	ldb	<reg_B			; recupera contador			; 	LD B, $00		 ; 790F 06 00		; byte alto contador a cero
	jsr	do_ldir			; llama do_ldir				; 	LDIR			 ; 7911 ED B0		; (DE+)=(HL+);BC-	; equivale a (IY+)=(IX+);BC-
	rts				; retorna				; 	RET			 ; 7913 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#112# OK)
L_7914	ldb	<reg_E			; recupera reg_E			; L_7914: RES 1, E		 ; 7914 CB 8B		; pasa a 0 el bit1 de E
	andb	#%11111101		; $FD, pasa bit1 a cero	
	stb	<reg_E			; actualiza reg_E
	clr	<reg_L			; reg_L a 0				;	LD L, $00		 ; 7916 2E 00		; carga L con 0
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#107# OK)
L_7918										; L_7918: PUSH DE		 ; 7918 D5		; guarda DE
										; 
	ldd	<reg_IY			; recupera reg_IY			; 	PUSH IY			 ; 7919 FD E5		; pasa IY
										; 	POP DE			 ; 791B D1		; a DE
	clr	<reg_H			; a cero el byte alto			; 	LD H, $00		 ; 791C 26 00		; a cero byte alto de HL
	ldx	<reg_HL			; recupera reg_HL			; 
	leax	d,x			; suma Y+X en X(HL)			; 	ADD HL, DE		 ; 791E 19		; suma DE (antes IY) a HL
	ldd	<reg_BC			; recupera reg_BC			; 	LD (HL), C		 ; 791F 71		; carga byte bajo apuntado por HL de C
										; 	INC HL			 ; 7920 23		; incrementa puntero
	std	,x+			; lo guarda en X(HL)			; 	LD (HL), B		 ; 7921 70		; carga byte alto de B
										; 	POP DE			 ; 7922 D1		; recupera DE
e_7918	rts				; retorna				; 	RET			 ; 7923 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#113# OK)	    
L_7924	jsr	TestB71B		; llama	TestB71B			; L_7924: CALL TestB71B		 ; 7924 CD F1 75	; llama TestB71B
	bne	e_7918			; si no da 0, sale			; 	RET NZ			 ; 7927 C0		; si no es 0, retorna
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7928 E1		; recupera HL
L_7929	jsr	TestB71B		; llama	TestB71B			; L_7929: CALL TestB71B		 ; 7929 CD F1 75	; llama TestB71B
	lbne	JmpTable75D2		; si no da 0, salta a JmpTable75D2	; 	JP NZ, JmpTable75D2	 ; 792C C2 B4 75	; si no es 0, salta a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SayWhat										; SayWhat:						; muestra mensaje "what?" (#84# OK)
	ldx	#L_AD9F			; apunta a L_AD9F			; 	LD HL, L_AD9F		 ; 792F 21 9F AD	; apunta a mensaje "what?"
	lda	#1			; pone 1				; 	LD A, $01		 ; 7932 3E 01		; pone un 1 
	sta	PrintAreaFlag		; en PrintAreaFlag			; 	LD (PrintAreaFlag), A	 ; 7934 32 01 B7	; en PrintAreaFlag - indica Abajo
	jsr	PrintMsg		; llama PrintMsg			; 	CALL PrintMsg		 ; 7937 CD DD 72	; muestra el mensaje - PrintMsg
	ora	#1			; pone a 1 el bit0 de A			; 	OR $01			 ; 793A F6 01		; pone a 1 el bit0 de A, flag Z=0
	rts				; retorna				; 	RET			 ; 793C C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ExecuteUsrCommandsBilboEvents							; ExecuteUsrCommandsBilboEvents:			; lleva a cabo posibles acciones para Bilbo (#88# OK)
	clra				; pone 0				; 	XOR A			 ; 7960 AF		; pone 0
	sta	L_B71C			; en L_B71C				; 	LD (L_B71C), A		 ; 7961 32 1C B7	; en L_B71C
	ldy	#L_B9C8			; apunta a L_B9C8
	sty	<reg_IY			; lo guarda en reg_IY			; 	LD IY, L_B9C8		 ; 7964 FD 21 C8 B9	; apunta a L_B9C8 (bloque de trabajo de 24 bytes)
	ldx	#L_B71A			; apunta a L_B71A			; 	LD HL, L_B71A		 ; 7968 21 1A B7	; apunta a L_B71A (offset dentro de bloque de 24)
	cmpa	,x			; es 0 el primer byte?			; 	CP (HL)			 ; 796B BE		; es 0 el offset?
	pshs	cc			; guarda flags
	sta	,x			; pone 1er byte a 0			; 	LD (HL), A		 ; 796C 77		; lo pone a 0
	puls	cc			; recupera flags
	bne	L_7994			; si no 0, salta a L_7994		; 	JP NZ, L_7994		 ; 796D C2 94 79	; si no era 0, salta a L_7994
i_7970	jsr	AnalyzeUserCommand	; llama AnalyzeUserCommand		; i_7970: CALL AnalyzeUserCommand ; 7970 CD B6 79	; llama AnalyzeUserCommand
	bne	i_797A			; si no devuelve 0, salta a i_797A	; 	JR NZ, i_797A		 ; 7973 20 05		; si flag Z=0 (xito), salta a i_797A
	clra				; pone 0				; 	XOR A			 ; 7975 AF		; pone 0
	sta	L_B705			; en L_B705				; 	LD (L_B705), A		 ; 7976 32 05 B7	; en L_B705
x_7970	rts				; retorna				; 	RET			 ; 7979 C9		; retorna
i_797A	jsr	ExecuteGetB6fb		; llama ExecuteGetB6fb			; i_797A: CALL ExecuteGetB6fb	 ; 797A CD ED 7A	; llama ExecuteGetB6fb
	lbeq	L_7DF5			; si devuelve 0, salta a L_7DF5		; 	JP Z, L_7DF5		 ; 797D CA F5 7D	; si es 0, salta a L_7DF5 (omite eventos para Bilbo)
	lda	#1			; pone valor 1				; 	LD A, $01		 ; 7980 3E 01		; pone $01
	sta	L_B6FA			; en L_B6FA				; 	LD (L_B6FA), A		 ; 7982 32 FA B6	; en L_B6FA
	jsr	DescribeActionOnScreen	; llama DescribeActionOnScreen		; 	CALL DescribeActionOnScreen
										; 				 ; 7985 CD 2B 71	; llama DescribeActionOnScreen
	jsr	ExecuteAction		; llama ExecuteAction			; 	CALL ExecuteAction	 ; 7988 CD 0F 95	; llama ExecuteAction
L_798B	jsr	ProcessBilboEvents	; llama ProcessBilboEvents		; L_798B: CALL ProcessBilboEvents ; 798B CD B3 96	; llama ProcessBilboEvents
L_798E	lda	L_B71C			; recupera L_B71C			; L_798E: LD A, (L_B71C)	 ; 798E 3A 1C B7	; recupera L_B71C
										; 	AND A			 ; 7991 A7		; es 0?
	bne	i_7970			; si no es 0, salta a i_7970		; 	JR NZ, i_7970		 ; 7992 20 DC		; no, vuelve a i_7970
L_7994	dec	L_B706			; decrementa L_B706			; L_7994: LD A, (L_B706)	 ; 7994 3A 06 B7	; recupera L_B706 (contador numero de bloques)
										; 	DEC A			 ; 7997 3D		; lo decrementa
	beq	x_7970			; si 0, sale via x_7970			; 	LD (L_B706), A		 ; 7998 32 06 B7	; actualiza L_B706
	ldd	#$FFE8			; pone valor -24			; 	RET Z			 ; 799B C8		; si es 0, retorna (ya no hay mas)
	std	<reg_BC			; en reg_BC				; 	LD BC, $FFE8		 ; 799C 01 E8 FF	; toma valor -24 
										; 							; busca un bloque cuya segunda palabra NO tenga el bit6 a 1
i_799F	ldy	<reg_IY			: get pseudo-reg			; i_799F: ADD IY, BC		 ; 799F FD 09		; lo 'suma' en IY (que apuntar 24 bytes antes)
	leay	d,y			; suma D(BC) en Y(IY)			
	sty	<reg_IY			; update pseudo-reg
	pshs	b			; preserva B
	ldb	,y			; gets high byte (Y+0)			; 							; por orden de bsqueda ir a: L_B9C8, L_B9B0, L_B998, L_B980, L_B968, L_B950 ... L_B800
	bitb	#%01000000		; tiene a 1 el bit6?			; 	BIT 6, (IY+$01)		 ; 79A1 FD CB 01 76	; Est a 1 el bit6 de la segunda palabra del bloque?
	puls    b			; recupera B
	bne	i_799F			; esta a 1, salta a i_799F		; 	JR NZ, i_799F		 ; 79A5 20 F8		; si, vuelve a i_799F para mirar otro bloque
	bra	i_7970			; salta a i_7970			; 	JR i_7970		 ; 79A7 18 C7		; encontrado un bloque ... vuelve a i_7970
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
InitAreaD12Part1								; InitAreaD12Part1:					; borra PrintAreaFlag y AreaD12Part1 ; antes ; (#97# OK) y ; (-02-)
	clra				; pone 0				; 	XOR A			 ; 79A9 AF		; pone valor 0
	sta	PrintAreaFlag		; en PrintAreaFlag			; 	LD (PrintAreaFlag), A	 ; 79AA 32 01 B7	; en PrintAreaFlag - indica arriba
	ldx	#AreaD12Part1		; apunta a AreaD12Part1			; 	LD HL, AreaD12Part1	 ; 79AD 21 3D 79	; apunta a inicio de AreaD12Part1
	ldb	#$11			; toma valor $11			; 	LD B, $11		 ; 79B0 06 11		; 17 bytes a borrar
	jsr	FillWithZeros		; llama FillWithZeros			; 	CALL FillWithZeros	 ; 79B2 CD E2 70	; llama FillWithZeros
eIniP1	rts				; retorna				; 	RET			 ; 79B5 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Analiza comando recibido (#103# --)	; (-01-)
										; 							; parametros IY apunta a un bloque de datos de 24 bytes (de 8x25 tras el ID del actor)
AnalyzeUserCommand								; AnalyzeUserCommand:					;            IX apunta a una accin dentro de la tabla ACTIONS
	lda	#$FF			; pone codigo NO objeto			; 	LD A, $FF		 ; 79B6 3E FF		; A = $FF
	sta	SecondObject		; en SecondObject			; 	LD (SecondObject), A	 ; 79B8 32 E9 B6	; ID objeto secundario a ninguno
	sta	MainObject		; y en MainObject			; 	LD (MainObject), A	 ; 79BB 32 E8 B6	; ID objeto principal a ninguno
	jsr	InitAreaD12Part1	; llama InitAreaD12Part1		; 	CALL InitAreaD12Part1	 ; 79BE CD A9 79	; llama InitAreaD12Part1
	jsr	CheckUserCommand	; llama CheckUserCommand		; 	CALL CheckUserCommand	 ; 79C1 CD 9E 7B	; llama CheckUserCommand
	beq	eIniP1			; si 0 sale via eIniP1			; 	RET Z			 ; 79C4 C8		; si es cero (fracaso), retorna con Z=1
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 79C5 3E 01		; contador ID accin a 1
	pshs	a			; lo guarda en stack			; 	PUSH IX			 ; 79C7 DD E5		; pasa IX
	ldd	<reg_IX			; recupera reg_IX			; 	POP HL			 ; 79C9 E1		; a HL
	subd	#ACTIONS		; le resta ACTIONS			; 	LD DE, ACTIONS		 ; 79CA 11 53 AB	; DE apunta a inicio tabla ACTIONS
	tfr	d,x			; pasa resultado a X(HL)		; 	SBC HL, DE		 ; 79CD ED 52		; resta DE y el carry de HL
	puls	a			; recupera A				; 	JR Z, i_79D9		 ; 79CF 28 08		; si da cero, salta a i_79D9 indica que IX est al principio de la tabla ACTIONS
	beq	i_79D9			; si la resta dio 0, salta a i_79D9	; 	LD DE, $0008		 ; 79D1 11 08 00	; longitud registro tabla ACTIONS
i_79D4	inca				; incrementa contador (ID) accin	; i_79D4: INC A			 ; 79D4 3C		; Incrementa contador de accin
	leax	-8,x			; resta 8 de X(HL)			; 	SBC HL, DE		 ; 79D5 ED 52		; resta DE y el carry de HL (va yendo atrs hasta el principio)
	bne	i_79D4			; si no 0, vuelve a i_79D4		; 	JR NZ, i_79D4		 ; 79D7 20 FB		; mientras no sea cero, vuelve a i_79D4
										; 							; al final tenemos en A el indice de Accin dentro de la tabla ACTIONS
i_79D9	sta	CurrentAction		; guarda ID de accin en CurrentAction	; i_79D9: LD (CurrentAction), A	 ; 79D9 32 E7 B6	; guarda ID de accin a la que apuntaba IX al entrar en la rutina en CurrentAction
	sta	CurActionCpy		; y en CurActionCpy			; 	LD (CurActionCpy), A	 ; 79DC 32 E6 B6	; y en CurActionCpy
	ldy	<reg_IX			; recupera reg_IX
	sty	L_795E			; lo guarda en L_795E			; 	LD (L_795E), IX		 ; 79DF DD 22 5E 79	; guarda puntero a accin en L_795E (apunta a accion = bloque de 4 palabras)
	jsr	TestActionFlags		; llama TestActionFlags			; 	CALL TestActionFlags	 ; 79E3 CD 78 7B	; llama TestActionFlags
	jsr	GetObjIndexOrLocExitPtr	; llama GetObjIndexOrLocExitPtr		; 	CALL GetObjIndexOrLocExitPtr
										; 				 ; 79E6 CD A1 7A	; llama rutina L_7AA1 (#137# --)
	clra				; pone 0				; 	XOR A			 ; 79E9 AF		; pone 0
	sta	L_B6FA			; en L_B6FA				; 	LD (L_B6FA), A		 ; 79EA 32 FA B6	; en L_B6FA
	lda	ActionFlags1		; recupera ActionFlags1			; 	LD A, (ActionFlags1)	 ; 79ED 3A 1D B7	; recupera ActionFlags1
	anda	#%00001100		; guarda solo bits 2-3			; 	AND $0C			 ; 79F0 E6 0C		; %0000 1100 guarda bits 2-3
	beq	i_7A11			; si da 0, salta a i_7A11		; 	JR Z, i_7A11		 ; 79F2 28 1D		; si estn ambos a cero, sale via i_7A11
	lda	L_7952			; copia L_7952				; 	LD A, (L_7952)		 ; 79F4 3A 52 79	; copia L_7952
	sta	L_B71C			; en L_B71C				; 	LD (L_B71C), A		 ; 79F7 32 1C B7	; en L_B71C
	rola				; pasa bit7 al Carry			; 	RLCA			 ; 79FA 07		; Rota A a la izquierda circularmente (b7 entra en b0)
	rola				; pasa carry al bit0
	anda	#1		        ; se queda solo con el bit0		; 	AND $01			 ; 79FB E6 01		; guarda resultado del bit0 (antes era el bit7)
	sta	L_7953			; lo guarda en L_7953			; 	LD (L_7953), A		 ; 79FD 32 53 79	; en L_7953
i_7A00	jsr	ExecuteActionsSeries	; llama ExecuteActionsSeries		; i_7A00: CALL ExecuteActionsSeries ; 7A00 CD 14 7A	; llama ExecuteActionsSeries
	lbne	L_7DBC			; si no da 0, salta a l_7DBC		; 	JP NZ, L_7DBC		 ; 7A03 C2 BC 7D	; Si Z=0, Salta a L_7DBC
	lda	L_B71C			; recupera L_B71C			; 	LD A, (L_B71C)		 ; 7A06 3A 1C B7	; recupera L_B71C
										; 	AND A			 ; 7A09 A7		; adecua flags
	beq	i_7A11			; si es 0, salta a i_7A11		; 	JR Z, i_7A11		 ; 7A0A 28 05		; si 0, sale via i_7A11
	jsr	SearchActionMainObject	; llama	SearchActionMainObject		; 	CALL SearchActionMainObject
										; 				 ; 7A0C CD 73 7A	; llama SearchActionMainObject
	bne	i_7A00			; si no da 0, vuelve a i_7A00		; 	JR NZ, i_7A00		 ; 7A0F 20 EF		; Si Z=0, vuelve a i_7A00
i_7A11	ora	#1			; flag Z=0				; i_7A11: OR $01		 ; 7A11 F6 01		; pone bit0 de A a 1, flag Z=0
	rts				; retorna				; 	RET			 ; 7A13 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Rutina que se encarga de la ejecucin de las acciones.
										; 							; Trata de ejecutar todo lo que puede hasta que se da alguna condicin de salida (#138# --)
										; 							; Como que se ponga L_7940 a algo distinto de 1 
ExecuteActionsSeries								; ExecuteActionsSeries:					; Buscamos si la accin se puede ejecutar a travs del uso de SearchValidObjectByName o SearchValidExitByName
	jsr	IsActionValid		; llama IsActionValid			; 	CALL IsActionValid     	; 7A14 CD CB 7C   	; llama IsActionValid
	bne	i_7A2E			; si no devuelve 0, salta a i_7A2E	; 	JR NZ, i_7A2E       	; 7A17 20 15      	; si encontrado, salta a i_7A2E
										; 							; Si la accin no se puede realizar segn esos criterios
	lda	L_7940			; recupera L_7940			; 	LD A, (L_7940)       	; 7A19 3A 40 79   	; recupera L_7940
	cmpa	#1			; es 1?					; 	CP $01          	; 7A1C FE 01      	; es igual a 1?
	bne	eEAS			; no, sale				; 	RET NZ          	; 7A1E C0      		; no, retorna con Z=0
	lda	MainObjIDCopy		; copia MainObjIDCopy			; 	LD A, (MainObjIDCopy)  	; 7A1F 3A 56 79   	; recupera MainObjIDCopy
	sta	MainObject		; en MainObject				; 	LD (MainObject), A    	; 7A22 32 E8 B6   	; lo guarda en MainObject
										; 							; Llama GetSecObjIndexOrLocDesc, que pone en ObjOrLocPointer puntero a objeto o localizacin, segn la accin a realizar
	jsr	GetSecObjIndexOrLocDesc	; llama GetSecObjIndexOrLocDesc		; 	CALL GetSecObjIndexOrLocDesc
										; 				; 7A25 CD BA 7A   	; llama GetSecObjIndexOrLocDesc
	jsr	AnalyzeActionFlags	; llama AnalyzeActionFlags		; 	CALL AnalyzeActionFlags	; 7A28 CD D8 7A   	; llama AnalyzeActionFlags
										; 							;   si no se necesita objeto secundario o es attack o strike devuelve Z=1
	bne	i_7A55			; si no devuelve 0, salta a i_7A55	; 	JR NZ, i_7A55       	; 7A2B 20 28      	; si devuelve Z=0, salta a i_7A55
eEAS	rts				; retorna				; 	RET          		; 7A2D C9      		; retorna con Z=1
i_7A2E	ldx	#L_793F			; apunta a L_793F			; i_7A2E: LD HL, L_793F       	; 7A2E 21 3F 79   	; apunta a L_793F
	inc	,x			; incrementa byte apuntado por X(HL)	; 	INC (HL)       		; 7A31 34      		; lo incrementa
	jsr	AnalyzeActionFlags	; llama AnalyzeActionFlags		; 	CALL AnalyzeActionFlags	; 7A32 CD D8 7A   	; llama AnalyzeActionFlags
										; 							;   si no se necesita objeto secundario o es attack o strike devuelve Z=1
	beq	i_7A50			; si da 0, salta a i_7A50		; 	JR Z, i_7A50       	; 7A35 28 19      	; Si Z = 1, Salta a i_7A50
	jsr	GetSecObjIndexOrLocDesc	; llama GetSecObjIndexOrLocDesc		; 	CALL GetSecObjIndexOrLocDesc
										; 				; 7A37 CD BA 7A   	; llama GetSecObjIndexOrLocDesc
	jsr	L_7D17			; llama L_7D17				; 	CALL L_7D17       	; 7A3A CD 17 7D   	; llama rutina L_7D17 (#139# --) Que es quien la acaba ejecutando
i_7A3D	beq	ExecuteActionsSeries	; si da 0, salta a ExecuteActionsSeries	; i_7A3D: JR Z, ExecuteActionsSeries
										; 				; 7A3D 28 D5      	; si flag Z=1, vuelve a ExecuteActionsSeries
	lda	L_7953			; recupera L_7953			; 	LD A, (L_7953)       	; 7A3F 3A 53 79   	; recupera L_7953
	deca				; decrementa valor			; 	DEC A          		; 7A42 3D      		; decrementa A
	beq	eEAS			; si es 0, sale				; 	RET Z          		; 7A43 C8      		; si es cero, retorna con Z=1
	lda	MainObject		; copia MainObject			; 	LD A, (MainObject)    	; 7A44 3A E8 B6   	; guarda ID objeto principal
	sta	MainObjIDCopy		; en MainObjIDCopy			; 	LD (MainObjIDCopy), A  	; 7A47 32 56 79   	; en MainObjIDCopy
	ldx	#L_7940			; apunta a L_7940			; 	LD HL, L_7940       	; 7A4A 21 40 79   	; apunta a L_7940
	inc	,x			; incrementa byte apuntado por X(HL)	; 	INC (HL)       		; 7A4D 34      		; lo incrementa
	bra	ExecuteActionsSeries	; salta a ExecuteActionsSeries		; 	JR ExecuteActionsSeries	; 7A4E 18 C4      	; y vuelve a ExecuteActionsSeries
i_7A50	jsr	ExecuteGetB6fb		; llama a ExecuteGetB6fb		; i_7A50: CALL ExecuteGetB6fb   ; 7A50 CD ED 7A   	; llama ExecuteGetB6fb
	bra	i_7A3D			; vuelve a i_7A3D			; 	JR i_7A3D       	; 7A53 18 E8      	; vuelve a i_7A3D
i_7A55	jsr	L_7D17			; llama L_7D17				; i_7A55: CALL L_7D17       	; 7A55 CD 17 7D   	; llama rutina L_7D17 (#139# --) para ir ejecutando
	bne	i_7A67			; si no da 0, salta a i_7A67		; 	JR NZ, i_7A67       	; 7A58 20 0D      	; si Z=0, salta a i_7A67
	lda	L_7941			; recupera L_7941			; 	LD A, (L_7941)       	; 7A5A 3A 41 79   	; si Z=1, recupera L_7941
	cmpa	#1			; es 1?					; 	CP $01          	; 7A5D FE 01      	; es $01?
	bne	e7A55			; no, sale				; 	RET NZ          	; 7A5F C0      		; no, retorna con Z=0
	tfr	cc,b			; to preserve flags
	lda	SecObjIDCopy		; copia SecObjIDCopy			; 	LD A, (SecObjIDCopy)   	; 7A60 3A 57 79   	; recupera SecObjIDCopy
	sta	SecondObject		; en SecondObject			; 	LD (SecondObject), A    ; 7A63 32 E9 B6   	; lo guarda en SecondObject
	tfr	b,cc			; restore flags
e7A55	rts				; rts					; 	RET          		; 7A66 C9      		; retorna con Z=1
i_7A67	lda	SecondObject		; copia SecondObject			; i_7A67: LD A, (SecondObject)  ; 7A67 3A E9 B6   	; guarda ID objeto secundario
	sta	SecObjIDCopy		; en SecObjIDCopy			; 	LD (SecObjIDCopy), A   	; 7A6A 32 57 79   	; en SecObjIDCopy
	ldx	#L_7941			; apunta a L_7941			; 	LD HL, L_7941       	; 7A6D 21 41 79   	; apunta a L_7941
	inc	,x			; incrementa byte apuntado por X(HL)	; 	INC (HL)       		; 7A70 34     	 	; lo incrementa
	bra	i_7A55			; vuelve a i_7A55			; 	JR i_7A55       	; 7A71 18 E2      	; vuelve a i_7A55
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Parametro IY apunta a bloque de 24 en curso
SearchActionMainObject								; SearchActionMainObject:					; devuelve ID de objeto en A ; antes ; (#172# --)
	ldy	<reg_IY			; recupera reg_IY			; 	PUSH IY			 ; 7A73 FD E5		; Guarda IY
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; 7A75 D5		; Guarda DE
	pshs	y,u,x			; guarda Y(IY),U(DE),X(HL)		; 	PUSH HL			 ; 7A76 E5		; Guarda HL
i_7A77	leay	-24,y			; resta 24 de Y(IY)			; i_7A77: LD DE, $FFE8		 ; 7A77 11 E8 FF	; Carga DE con -24
	sty	<reg_IY			; actualiza reg_IY			; 	ADD IY, DE		 ; 7A7A FD 19		; apunta a bloque anterior (24 bytes antes)
	ldb	1,y			; recupera 1 byte
	bitb	#%01000000		; esta el bit6 a 1?			; 	BIT 6, (IY+$01)		 ; 7A7C FD CB 01 76	; est a 1 el bit6 de la segunda palabra de la accin?
	beq	i_7A9C			; no, salta a i_7A9C			; 	JR Z, i_7A9C		 ; 7A80 28 1A		; no, sale via i_7A9C con Z=1
	ldy	#ObjIndexTable-3	; apunta 3 bytes antes de ObjIndexTable	; 	LD IX, ObjIndexTable-$03 ; 7A82 DD 21 60 C0	; apunta 3 bytes antes de ObjIndexTable
	sty	<reg_IX			; guarda valor en reg_IX
i_7A86	ldx	<reg_IY			; X(HL) toma valor de IY		; i_7A86: PUSH IY		 ; 7A86 FD E5		; pasa puntero a nuevo bloque de 24
										; 	POP HL			 ; 7A88 E1		; a HL
										; 	LD DE, $0008		 ; 7A89 11 08 00	; offset a aadir
	leax	8,x			; le suma 8				; 	ADD HL, DE		 ; 7A8C 19		; apunta al inicio del sub-bloque de 10 bytes
	jsr	SearchValidObjectByName	; llama SearchValidObjectByName		; 	CALL SearchValidObjectByName
										; 				 ; 7A8D CD D9 9D	; llama SearchValidObjectByName
	cmpa	#$FF			; encontrado?				; 	CP $FF			 ; 7A90 FE FF		; encontrado un Objeto?
	beq	i_7A77			; no, vuelve a L_7A77			; 	JR Z, i_7A77		 ; 7A92 28 E3		; no, vuelve a i_7A77 para analizar otro bloque de 24
	ldx	#MainObject		; apunta a MainObject			; 	LD HL, MainObject	 ; 7A94 21 E8 B6	; si, apunta a MainObject
	cmpa	,x			; es el MainObject?			; 	CP (HL)			 ; 7A97 BE		; es Objeto encontrado igual a MainObject?
	bne	i_7A86			; no, vuelve a i_7A86			; 	JR NZ, i_7A86		 ; 7A98 20 EC		; no, vuelve a i_7A86
	ora	#1			; fuerza Z=0				; 	OR $01			 ; 7A9A F6 01		; bit0 de A a 1, sale con Z=0
i_7A9C	tfr	cc,b			; guarda flags en B
	puls	x,u,y			; recupera X(HL),U(DE),Y(IY)		; i_7A9C: POP HL		 ; 7A9C E1		; Recupera HL
	stu	<reg_DE			; lo guarda en reg_DE			; 	POP DE			 ; 7A9D D1		; Recupera DE
	sty	<reg_IY			; lo guarda en reg_IY			; 	POP IY			 ; 7A9E FD E1		; Recupera IY
	tfr	b,cc			; recupera flags de B
e_7A9C	rts				; retorna				; 	RET			 ; 7AA0 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; devuelve en ObjIndexPtr un puntero a Indice de Objetos (o tres bytes antes)
GetObjIndexOrLocExitPtr								; GetObjIndexOrLocExitPtr:				; o bien a la Descripcin de la Localizacin (#137# --) si IsMainObjLoc no es 0
	lda	L_B71C			; recupera L_B71C			; 	LD A, (L_B71C)		 ; 7AA1 3A 1C B7	; recupera L_B71C
										; 	AND A			 ; 7AA4 A7		; adecua flags
	bne	e_7A9C			; si no es 0, sale via e_7A9C		; 	RET NZ			 ; 7AA5 C0		; si no es cero, retorna
										; 							; Pone en ObjIndexPtr el puntero al objeto o a la localizacin de salida ; antes ; (#143# --)
										; 							; dependiendo de los flags de la accin. Si *b6fe==0 se trata de un objeto
										; 							; Usa GetObjIndexPtr para obtener el puntero, por lo que rota los flags a la derecha dos veces
										; 							; - si los bits 3 y 2 de la 3a palabra (byte 5) son alguno 1: ObjIndexTable-3 
										; 							;   (drop, attack with, follow, burn, capture, untile, talk to, shoot y carry)
										; 							; - si los bits 3 y 2 de la 3a palabra (byte 5) son 0: ObjIndexTable
										; 							;   (el resto)
GetObjIndexOrLocExitPt2								; GetObjIndexOrLocExitPt2:				; Si *b6fe!=0 es una localizacin, as que llama a GetLocExitPtr
	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)    ; 7AA6 3A 1E B7   	; recupera ActionFlags2 (flags 4a y 3a palabra de la accin)
	lsra				; divide por 4				; 	RRCA          		; 7AA9 0F      		; Rota A a la derecha circularmente (b0 entra en b7)
	lsra				; pasa bits 2-3 a bits 0-1		; 	RRCA          		; 7AAA 0F      		; 2 veces, mueve bits 3-2 a posiciones 1-0 para prxima rutina (flags 3a palabra - byte 5)
	jsr	GetObjIndexPtr		; llama GetObjIndexPtr			; 	CALL GetObjIndexPtr    	; 7AAB CD CC 7A   	; llama GetObjIndexPtr
	lda	IsMainObjLoc		; recupera IsMainObjLoc			; 	LD A, (IsMainObjLoc)   	; 7AAE 3A FE B6   	; recupera IsMainObjLoc
	beq	c_Goio			; si es 0, salta siguiente		; 	AND A          		; 7AB1 A7      		; adecua flags
	jsr	GetLocExitPtr		; llama GetLocExitPtr			; 	CALL NZ, GetLocExitPtr  ; 7AB2 C4 95 9E   	; si no es cero, llama GetLocExitPtr
c_Goio	ldy	<reg_IX			; recupera reg_IX							
	sty	ObjIndexPtr		; lo guarda en ObjIndexPtr		; 	LD (ObjIndexPtr), IX    ; 7AB5 DD 22 4E 79   	; guarda IX en ObjIndexPtr
	rts				; retorna				; 	RET          		; 7AB9 C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; devuelve en ObjOrLocPointer un puntero a Indice de Objetos (o 3 bytes antes)
										; 							; o bien a la Descripcin de la Localizacin (#174# --)
										; 							; Muy parecida a la GetObjIndexOrLocExitPt2, pero trabaja con IsSecObjLoc, los bits 0 y 1 de ActionFlags2
										; 							; y guarda el puntero en ObjOrLocPointer, no en ObjIndexPtr   
										; 							; En el caso de que *IsSecObjLoc sea == 0 es un objeto, as que se guarda ObjIndexTable-3 
										; 							; en el caso de: give to y throw at  y ObjIndexTable para el resto de objetos.
GetSecObjIndexOrLocDesc								; GetSecObjIndexOrLocDesc:				; Si IsSecObjLoc !=0 es una localizacin y se usa GetLocExitPtr
	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)    ; 7ABA 3A 1E B7   	; recupera ActionFlags2 (flags 4a y 3a palabra de la accin - bytes 7 y 5)
	jsr	GetObjIndexPtr		; llama GetObjIndexPtr			; 	CALL GetObjIndexPtr    	; 7ABD CD CC 7A   	; llama GetObjIndexPtr
	lda	IsSecObjLoc		; recupera IsSecObjLoc			; 	LD A, (IsSecObjLoc)    	; 7AC0 3A FF B6   	; recupera IsSecObjLoc
	beq	c_GsOi			; si es 0, salta siguiente		; 	AND A          		; 7AC3 A7      		; es 0?
	jsr	GetLocExitPtr		; llama GetLocExitPtr			; 	CALL NZ, GetLocExitPtr  ; 7AC4 C4 95 9E   	; no, llama rutina GetLocExitPtr
c_GsOi	sty	ObjOrLocPointer		; guarda Y(IX) en ObjOrLocPointer	; 	LD (ObjOrLocPointer), IX ; 7AC7 DD 22 50 79   	; guarda IX en ObjOrLocPointer
	rts				; retorna				; 	RET          		; 7ACB C9      		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Devuelve IX apuntando a la Tabla Indice de Objetos ; antes ; (#141# --)
GetObjIndexPtr									; GetObjIndexPtr:					;                       o 3 bytes antes si 3>='A'>=1
	ldy	#ObjIndexTable		; apunta a ObjIndexTable
	sty	<reg_IX			; lo guarda en reg_IX			; 	LD IX, ObjIndexTable	 ; 7ACC DD 21 63 C0	; Carga IX con ObjIndexTable
	anda	#%00000011		; deja solo los bits 0-1		; 	AND $03			 ; 7AD0 E6 03		; est el valor de A entre 1 y 3? (bits 0 y 1)
	beq	e_Goip			; si da 0, sale				; 	RET Z			 ; 7AD2 C8		; no, retorna
	ldy	#ObjIndexTable-3	; apunta 3 bytes antes de ObjIndexTable	; 	LD IX, ObjIndexTable-$03 ; 7AD3 DD 21 60 C0	; apunta 3 bytes antes de ObjIndexTable
	sty	<reg_IX			; actualiza reg_IX
e_Goip	rts				; retorna				; 	RET			 ; 7AD7 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; retorna con Z=0  1 segn los flags consultados ; (#154# --)
										; 							; retorna con Z=1 si no se necesita objeto secundario 
										; 							;   o bien si se trata de 'attack with' o 'strike with' y el bit 1 de 793e est a cero.
										; 							; ActionFlags1 bit2 a cero provoca Z=1
										; 							; L_793E bit0 a uno  provoca Z=0
										; 							; ActionFlags1 bit1 a uno  provoca Z=1
AnalyzeActionFlags								; AnalyzeActionFlags:        				; otras combinaciones dan Z=0
	lda	ActionFlags1		; recupera ActionFlags1			; 	LD A, (ActionFlags1)    ; 7AD8 3A 1D B7   	; recupera ActionFlags1
	bita	#%00000100		; est el bit2 a 1?			; 	BIT 2, A       		; 7ADB CB 57      	; Est a 1 el bit 2 de A?
	beq	e_Aaf			; no, sale				; 	RET Z          		; 7ADD C8      		; no, retorna con Z=1
	ldx	#L_793E			; apunta a L_793E			; 	LD HL, L_793E       	; 7ADE 21 3E 79   	; apunta a L_793E (AreaD12Part1)
	ldb	,x			; toma 1 byte
	bitb	#%00000001		; est a 1 el bit0?			; 	BIT 0, (HL)       	; 7AE1 CB 46      	; Est a 1 el bit 0 de L_793E?
	bne	e_Aaf			; si, sale				; 	RET NZ          	; 7AE3 C0      		; si, retorna con Z=0
	bita	#%00000010		; est a 1 el bit1 de A?		; 	BIT 1, A       		; 7AE4 CB 4F      	; Est a 1 el bit 1 de A (ActionFlags1)?
	bne	i_7AEB			; si, salta a i_7AEB			; 	JR NZ, i_7AEB       	; 7AE6 20 03      	; si, sale via i_7AEB
	ora	#1			; flag Z=0				; 	OR $01          	; 7AE8 F6 01      	; garantiza bit0 a 1 y flag Z=0
	rts				; retorna				; 	RET          		; 7AEA C9      		; retorna con Z=0
i_7AEB	clra				; flag Z=1				; i_7AEB: XOR A          	; 7AEB AF      		; A=0
e_Aaf	rts				; retorna				; 	RET          		; 7AEC C9      		; retorna con Z=1
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ExecuteGetB6fb									; ExecuteGetB6fb:					; Ejecuta la accin y devuelve L_B6FB en A ; antes ; (#94# OK)
	jsr	ExecuteAction		; llama ExecuteAction			; 	CALL ExecuteAction	 ; 7AED CD 0F 95	; llama ExecuteAction
	lda	L_B6FB			; recupera L_B6FB			; 	LD A, (L_B6FB)		 ; 7AF0 3A FB B6	; recupera L_B6FB
										; 	AND A			 ; 7AF3 A7		; Adecua flags
	rts				; retorna				; 	RET			 ; 7AF4 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;###NoName13:            				; (#229# --)
L_7AF5	pshs	x			; save regX				; L_7AF5: PUSH HL         	; 7AF5 E5      		; Guarda HL
	ldu	<reg_IY			; get pseudo-registers
	ldy	<reg_IX								; 	PUSH IY          	; 7AF6 FD E5      	; Guarda IY
	pshs	y,u			; save them				; 	PUSH IX          	; 7AF8 DD E5      	; Guarda IX
	ldu	<reg_DE			; get pseudo-registers
	ldy	<reg_BC								; 	PUSH DE          	; 7AFA D5      		; Guarda DE
	pshs	y,u			; save them				; 	PUSH BC          	; 7AFB C5      		; Guarda BC
	ldx	ObjIndexPtr		; get ObjIndex pointer			; 	LD HL, (ObjIndexPtr)    ; 7AFC 2A 4E 79   	; recupera ObjIndexPtr
	pshs	x			; save regX				; 	PUSH HL          	; 7AFF E5      		; lo guarda
	lda	CurrentAction		; get action				; 	LD A, (CurrentAction)   ; 7B00 3A E7 B6   	; Carga A con ID accin
	jsr	GetActionPtr		; get its pointer			; 	CALL GetActionPtr	; 7B03 CD E8 70   	; devuelve puntero en HL a la accin recibida en A
										; 	PUSH HL          	; 7B06 E5      		; pasa HL
	stx	<reg_IX			; pass X(HL) to reg_IX			; 	POP IX          	; 7B07 DD E1      	; a IX
	jsr	InitAreaD12Part1	; clean data area			; 	CALL InitAreaD12Part1   ; 7B09 CD A9 79   	; LLama InitAreaD12Part1
	jsr	SaveActionFlags		; save actionFlags			; 	CALL SaveActionFlags    ; 7B0C CD F3 70   	; llama rutina SaveActionFlags
										; 							; Pone b6fe a 1 o a 0 dependiendo del bit 3 del flag en el byte 3 de la accin
										; 							; Me parece que 'enter' y 'go into' lo tienen a 1
										; 							; Pone b6ff a 1 o a 0 dependiendo del bit 2 del flag en el byte 3 de la accin
										; 							; No encuentro ninguno con el flag a 1 (?)
	jsr	TestActionFlags		; test those flags			; 	CALL TestActionFlags    ; 7B0F CD 78 7B   	; llama TestActionFlags
										; 							; Se va a llamar a la rutina en 7b63 dos veces, una para el objeto principal y otra para el secundario.
										; 							; Los parmetros son B=Objeto ID, A=contenido de b6fe (puesto antes, y que
										; 							; vale 1 si es 'enter' o 'go into') y DE=MainObj3WordPtrs, donde van a ir a parar los datos
										; 							; generados en 7b63
	lda	MainObject		; get main object			; 	LD A, (MainObject)    	; 7B12 3A E8 B6   	; recupera ID objeto principal
	sta	<reg_B			; pass to reg_B				; 	LD B, A          	; 7B15 47      		; lo guarda en B
	lda	IsMainObjLoc		; get flag				; 	LD A, (IsMainObjLoc)   	; 7B16 3A FE B6   	; recupera IsMainObjLoc (flag 3 tercera palabra de la accin)
	ldu	#MainObj3WordPtrs	; point to pointers data area
	stu	<reg_DE			; pass to reg_DE			; 	LD DE, MainObj3WordPtrs	; 7B19 11 42 79   	; apunta a MainObj3WordPtrs (destino datos a generar)
	jsr	GetDescPtrs2DE		; get description pointer		; 	CALL GetDescPtrs2DE    	; 7B1C CD 63 7B   	; llama GetDescPtrs2DE
										; 							; Lo mismo para el objeto secundario ahora, usando b6ff (vale 1 o 0 con un significado
										; 							; similar al anterior) y como destino DE=SecObj3WordPtrs
	lda	SecondObject		; get 2nd object			; 	LD A, (SecondObject)    ; 7B1F 3A E9 B6   	; recupera ID objeto secundario
	sta	<reg_B			; pass to reg_B				; 	LD B, A          	; 7B22 47      		; lo guarda en B
	lda	IsSecObjLoc		; get flag				; 	LD A, (IsSecObjLoc)    	; 7B23 3A FF B6   	; recupera IsSecObjLoc (flag2 tercera palabra de la accin)
	ldu	#SecObj3WordPtrs	; point to pointers data area
	stu	<reg_DE			; pass to reg_DE			; 	LD DE, SecObj3WordPtrs 	; 7B26 11 48 79   	; apunta a SecObj3WordPtrs (destino datos a generar)
	jsr	GetDescPtrs2DE		; get description pointer		; 	CALL GetDescPtrs2DE    	; 7B29 CD 63 7B   	; llama GetDescPtrs2DE
										; 							; Ahora se llama a 7aa6 que guarda en ObjIndexPtr el puntero para trabajar despus 
										; 							; y que puede ser ObjIndexTable, ObjIndexTable-3 o un puntero obtenido en GetLocExitPtr (a dnde vamos)
	jsr	GetObjIndexOrLocExitPt2	; get needed pointer			; 	CALL GetObjIndexOrLocExitPt2
										; 				; 7B2C CD A6 7A   	; llama GetObjIndexOrLocExitPt2
	clra				; put value zero			; 	XOR A          		; 7B2F AF      		; pone 0
	sta	L_B6FA			; to L_B6FA				; 	LD (L_B6FA), A       	; 7B30 32 FA B6   	; en L_B6FA
	lda	ActionFlags1		; get action flags			; 	LD A, (ActionFlags1)    ; 7B33 3A 1D B7   	; recupera ActionFlags1
										; 							; Si los bits 2 y 3 de los flags de la 1a palabra de la accin estn a cero, es decir
	anda	#$0c			; test bits 3-2				; 	AND $0C          	; 7B36 E6 0C      	; Hace AND lgico de A con $0C  %0000 1100
	bne	i_7B43			; if any is set, go i_7B43		; 	JR NZ, i_7B43       	; 7B38 20 09      	; Si Z = 0, Salta a i_7B43
										; 							; entonces no necesitamos objetos ('run', 'look', 'inventory')
										; 							; ejecutamos la accin directamente y recogemos el resultado de b6fb
										; 							; que puede ser 0 o <> 0 . Esto se guarda en el flag Z
	jsr	ExecuteAction		; execute action			; 	CALL ExecuteAction    	; 7B3A CD 0F 95   	; llama ExecuteAction
	lda	L_B6FB			; get L_B6FB				; 	LD A, (L_B6FB)       	; 7B3D 3A FB B6	   	; recupera L_B6FB
										; 	AND A          		; 7B40 A7      		; adecua flags
	bra	i_7B52			; go i_7B52				; 	JR i_7B52       	; 7B41 18 0F      	; Salta a i_7B52
										; 							; sino (alguno de los dos bits era 1)
i_7B43	lda	#1			; put value 1				; i_7B43: LD A, $01       	; 7B43 3E 01      	; pone 1
	sta	L_7953			; in L_7953				; 	LD (L_7953), A       	; 7B45 32 53 79   	; en L_7953
										; 							; Llamamos a ExecuteActionsSeries que busca la accin asociada y la ejecuta
										; 							; Devuelve xito como Z=0 y fracaso como Z=1.
	jsr	ExecuteActionsSeries	; execute actions			; 	CALL ExecuteActionsSeries
										; 				; 7B48 CD 14 7A   	; llama ExecuteActionsSeries
										; 							; Invertimos la lgica del flag Z (para que sea igual a la del caso anterior)
	beq	i_7B50			; if returns Z=1, go i_7B50		; 	JR Z, i_7B50       	; 7B4B 28 03      	; si xito, Z=1, salta a i_7B50 para dar Z=0
	clra				; set Z=1				; 	XOR A          		; 7B4D AF      		; sino, Z=0 (fracaso), hace Z=1
	bra	i_7B52			; go i_7B52				; 	JR i_7B52       	; 7B4E 18 02      	; Salta a i_7B52
i_7B50	ora	#1			; set Z=0 				; i_7B50: OR $01          	; 7B50 F6 01      	; garantiza bit0 a 1 y flag Z=0
i_7B52	tfr	cc,b			; save flags				; i_7B52: LD A, $01       	; 7B52 3E 01      	; pone $01
	lda	#1			; put value 1
	sta	L_B6FA			; in L_B6FA				; 	LD (L_B6FA), A       	; 7B54 32 FA B6   	; en L_B6FA
	puls	x			; restore regX				; 	POP HL          	; 7B57 E1      		; Recupera HL
	stx	ObjIndexPtr		; update variable			; 	LD (ObjIndexPtr), HL    ; 7B58 22 4E 79   	; lo guarda en ObjIndexPtr
	puls	y,u			; restore pseudo-registers
	sty	<reg_BC			; update them				; 	POP BC          	; 7B5B C1      		; Recupera BC
	stu	<reg_DE								; 	POP DE          	; 7B5C D1      		; Recupera DE
	puls	y,u			; restore pseudo-registers
	sty	<reg_IX			; update them				; 	POP IX          	; 7B5D DD E1   	   	; Recupera IX
	stu	<reg_IY								; 	POP IY          	; 7B5F FD E1      	; Recupera IY
	puls	x			; restore regX				; 	POP HL          	; 7B61 E1      		; Recupera HL
	tfr	b,cc			; restore flags
	rts				; return				; 	RET          		; 7B62 C9      		; retorna con el valor de Z calculado anteriormente
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; copia los punteros a las palabras de descripcin de un objeto de una
										; 							; accin en una zona de memoria ; antes ; (#142# --)
										; 							; Parmetros B=ID objeto o localizacin, A=contenido de b6fe o b6ff, 
										; 							; que indican si el objeto es una localizacin o un objeto normal 
										; 							; DE=destino
GetDescPtrs2DE									; GetDescPtrs2DE:						; Retorna con Z=1 si hay algn error.
	inc	<reg_B			; increment reg_B			; 	INC B          		; 7B63 04      		; Incrementa ID para detectar objeto nulo ($FF)
	beq	eGDP2D			; if zero, exit				; 	RET Z          		; 7B64 C8      		; si era objeto nulo, retorna
	dec	<reg_B			; decrement reg_B			; 	DEC B          		; 7B65 05      		; vuelve al valor recibido en B
	tsta				; test parameter (flag)			; 	AND A          		; 7B66 A7      		; adecua flags (segn b6fe o b6ff recibido en A)
	tfr	cc,b			; save flags
	lda	<reg_B			; get reg_B				; 	LD A, B          	; 7B67 78      		; pasa ID a A
	tfr	b,cc			; restore flags
	beq	i_7B6F			; if zero, go i_7B6F			; 	JR Z, i_7B6F       	; 7B68 28 05      	; si antes A era 0, Salta a i_7B6F
	jsr	PointHLTo3WordsLoc	; process location			; 	CALL PointHLTo3WordsLoc	; 7B6A CD D5 71   	; llama PointHLTo3WordsLoc (tratar localizacin)
	bra	i_7B72			; skip next				; 	JR i_7B72       	; 7B6D 18 03      	; salta a i_7B72
i_7B6F	jsr	PointHLTo3WordsObj	; process object			; i_7B6F: CALL PointHLTo3WordsObj ; 7B6F CD E2 71   	; llama PointHLTo3WordsObj (tratar objeto)
										; 							; Copiamos los 6 bytes (3 punteros a las palabras) en la direccin de destino
i_7B72	ldb	#6			; numer of bytes to copy		; i_7B72: LD BC, $0006       	; 7B72 01 06 00   	; Carga BC con $0006
	ldu	<reg_DE			; point to destination
	jsr	do_ldir			; do the copy				; 	LDIR          		; 7B75 ED B0      	; (DE+)=(HL+);BC-   ; copia $6 bytes de HL en DE
eGDP2D	rts				; return				; 	RET          		; 7B77 C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Procesa los flags de las 4 palabras de la accin (#99# OK)
										; 							; parametros ActionFlags1 y ActionFlags2 (contienen los flags de las 4 palabras de la accin)
										; 							; efectos colaterales  resultados:
										; 							; L_B711 = $40  $00 segn bit6 del parmetro ActionFlags2 (1 - 0)
										; 							; L_B70F = $01  $00 segn bit0 del parmetro ActionFlags1 (1 - 0)
										; 							; IsSecObjLoc  = $01  $00 segn bit6 del parmetro ActionFlags1 (1 - 0)
TestActionFlags									; TestActionFlags:					; IsMainObjLoc = $01  $00 segn bit7 del parmetro ActionFlags1 (1 - 0)
	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)	 ; 7B78 3A 1E B7	; recupera ActionFlags2
	anda	#%01000000		; deja solo el bit6			; 	AND $40			 ; 7B7B E6 40		; se queda con el bit6
	sta	L_B711			; lo guarda en L_B711			; 	LD (L_B711), A		 ; 7B7D 32 11 B7	; guarda resultado en L_B711
	lda	ActionFlags1		; guarda ActionFlags1			; 	LD A, (ActionFlags1)	 ; 7B80 3A 1D B7	; recupera ActionFlags1 
	sta	<reg_B			; en reg_B				; 	LD B, A			 ; 7B83 47		; guarda A en B
	anda	#%00000001		; deja solo el bit0			; 	AND $01			 ; 7B84 E6 01		; se queda con el bit0
	sta	L_B70F			; guada resultado en L_B70F		; 	LD (L_B70F), A		 ; 7B86 32 0F B7	; guarda resultado en L_B70F
	lda	<reg_B			; recupera reg_B			; 	LD A, B			 ; 7B89 78		; recupera A
	anda	#%10000000		; deja solo el bit7			; 	AND $80			 ; 7B8A E6 80		; est a 1 el bit7?
	beq	i_7B90			; si est a 0, salta siguiente		; 	JR Z, i_7B90		 ; 7B8C 28 02		; no, salta siguiente instruccin con A=0
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 7B8E 3E 01		; pone A a 1
i_7B90	sta	IsMainObjLoc		; guarda A en IsMainObjLoc		; i_7B90: LD (IsMainObjLoc), A	 ; 7B90 32 FE B6	; guarda valor de A en IsMainObjLoc (0-1)
	lda	<reg_B			; recupera reg_B			; 	LD A, B			 ; 7B93 78		; recupera A
	anda	#%01000000		; est a 1 el bit6?			; 	AND $40			 ; 7B94 E6 40		; est a 1 el bit6? 
	beq	i_7B9A			; no, salta siguiente			; 	JR Z, i_7B9A		 ; 7B96 28 02		; no, salta siguiente instruccin con A=0
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 7B98 3E 01		; pone A a 1
i_7B9A	sta	IsSecObjLoc		; guarda A en IsSecObjLoc		; i_7B9A: LD (IsSecObjLoc), A	 ; 7B9A 32 FF B6	; guarda valor de A en IsSecObjLoc (0-1)
	rts				; retorna				; 	RET			 ; 7B9D C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
 																	; Monta en buffer 3 palabras el comando entrado x el usuario ; antes ; (#98# --) (-03-)
CheckUserCommand								; CheckUserCommand:					; parametros IY apunta a bloque de 24 bytes (sin el ID de delante)
	ldy	<reg_IY			; recupera reg_IY
	pshs	y			; guarda Y(IY)				; 	PUSH IY			 ; 7B9E FD E5		; Guarda IY
	ldd	,y			; recupera 2 bytes			; 	LD L, (IY+$00)		 ; 7BA0 FD 6E 00	; L = (IY+$00)
										; 	LD H, (IY+$01)		 ; 7BA3 FD 66 01	; H = (IY+$01)	; Toma primer puntero a palabra del bloque de 24
										; 	LD A, H			 ; 7BA6 7C		; byte alto a A
	anda	#%10000000		; deja solo el bit7 de A		; 	AND $80			 ; 7BA7 E6 80		; guarda el bit7
	sta	L_7952			; guarda resultado en L_7952		; 	LD (L_7952), A		 ; 7BA9 32 52 79	; en L_7952
	lda	,y			; toma primer byte de nuevo
	anda	#%01111111		; pasa bit7 a 0				; 	RES 7, H		 ; 7BAC CB BC		; pasa bit7 de H a cero
	std	L_7958			; guarda D en L_7958			; 	LD (L_7958), HL		 ; 7BAE 22 58 79	; guarda HL en L_7958
	ldx	#L_795A			; apunta a L_795A			; 	LD HL, L_795A		 ; 7BB1 21 5A 79	; apunta a L_795A (Tabla (#D12#)) - para montar accin entrada x ususario
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7BB4 E5		; Guarda HL
	ldb	#4			; contador a 4				; 	LD B, $04		 ; 7BB5 06 04		; B = 4
	jsr	FillWithZeros		; llama FillWithZeros			; 	CALL FillWithZeros	 ; 7BB7 CD E2 70	; borra 4 bytes apuntados por HL
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7BBA E1		; Recupera HL
	ldd	#$0204			; toma valores $02 y $04					
	sta	<reg_B			; pone 2 en reg_B			; 	LD B, $02		 ; 7BBB 06 02		; Chequear solamente DOS palabras
	stb	<reg_E			; y 4 en reg_E				; 	LD E, $04		 ; 7BBD 1E 04		; offset = 4
	jsr	ActionWord2Buffer	; llama	ActionWord2Buffer		; 	CALL ActionWord2Buffer	 ; 7BBF CD AC 7C	; llama ActionWord2Buffer
	ldb	#$0E			; pone valor $0E
	stb	<reg_E			; en reg_E				; 	LD E, $0E		 ; 7BC2 1E 0E		; offset = 14
	jsr	ActionWord2Buffer	; llama	ActionWord2Buffer		; 	CALL ActionWord2Buffer	 ; 7BC4 CD AC 7C	; llama ActionWord2Buffer
	ldb	#$06			; pone valor $06
	stb	<reg_E			; en reg_E				; 	LD E, $06		 ; 7BC7 1E 06		; offset = 6
	jsr	ActionWord2Buffer	; llama	ActionWord2Buffer		; 	CALL ActionWord2Buffer	 ; 7BC9 CD AC 7C	; llama ActionWord2Buffer
	ldb	#$10			; pone valor $10
	stb	<reg_E			; en reg_E				; 	LD E, $10		 ; 7BCC 1E 10		; offset 0 16
	jsr	ActionWord2Buffer	; llama	ActionWord2Buffer		; 	CALL ActionWord2Buffer	 ; 7BCE CD AC 7C	; llama ActionWord2Buffer
	clra				; pone 0				; 	XOR A			 ; 7BD1 AF		; pone a 0
	sta	L_B6DF			; en L_B6DF				; 	LD (L_B6DF), A		 ; 7BD2 32 DF B6	; L_B6DF
	ldx	#L_7958			; apunta a L_7958			; 	LD HL, L_7958		 ; 7BD5 21 58 79	; apunta a incio del bloque de 3 palabras
										; 	LD DE, $0008		 ; 7BD8 11 08 00	; DE = $0008 (longitud registro en acciones)
	ldy	#ACTIONS		; apunta a ACTIONS			; 	LD IX, ACTIONS		 ; 7BDB DD 21 53 AB	; IX = ACTIONS	; Tabla de acciones
	sty	<reg_IX			; lo guarda en reg_IX
i_7BDF	ldy	<reg_IX			; recupera reg_IX			; i_7BDF: PUSH IX		 ; 7BDF DD E5		; pasa IX
	sty	<reg_IY			; lo guarda como reg_IY			; 	POP IY			 ; 7BE1 FD E1		; a IY
	jsr	DoesActionMatch		; llama DoesActionMatch			; 	CALL DoesActionMatch	 ; 7BE3 CD F3 71	; LLama DoesActionMatch
	beq	i_7C1B			; si da 0, salta a i_7C1B		; 	JR Z, i_7C1B		 ; 7BE6 28 33		; cuadran?	Si, salta a i_7C1B
	ldy	<reg_IX			; recupera reg_IX
	leay	8,y			; le suma 8				; 	ADD IX, DE		 ; 7BE8 DD 19		; IX = IX + DE
	sty	<reg_IX			; actualiza reg_IX
	ldd	,y			; toma 2 bytes				; 	LD A, (IX+$01)		 ; 7BEA DD 7E 01	; A = (IX+$01)
										; 	OR (IX+$00)		 ; 7BED DD B6 00	; A = A OR (IX+$01)
	bne	i_7BDF			; si no son cero, salta a i_7BDF	; 	JR NZ, i_7BDF		 ; 7BF0 20 ED		; Z = 0?	; Si no es cero salta a i_7BDF
	puls	y			; recupera Y(IY)			; 	POP IY			 ; 7BF2 FD E1		; Recupera IY
	sty	<reg_IY			; lo guarda en reg_IY
	lda	L_B6DF			; recupera L_B6DF			; 	LD A, (L_B6DF)		 ; 7BF4 3A DF B6	; A = (L_B6DF)
										; 	AND A			 ; 7BF7 A7		; A = A AND A	; Adecua flags
	lbne	L_7EA8			; si no es 0, salta a L_7EA8		; 	JP NZ, L_7EA8		 ; 7BF8 C2 A8 7E	; Z = 0?	; Si no es cero salta a L_7EA8
	ldx	L_7958			; recupera L_7958			; 	LD HL, (L_7958)		 ; 7BFB 2A 58 79	; HL = (L_7958)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7BFE E5		; Guarda HL
	ldx	#L_ADA3			; apunta a L_ADA3			; 	LD HL, L_ADA3		 ; 7BFF 21 A3 AD	; HL = L_ADA3	; Apunta a mensaje "[0x0d] You[0x01].[0x0d] Time passes..[0x15]"
	clra				; pone 0				; 	XOR A			 ; 7C02 AF		; pone 0
	sta	PrintAreaFlag		; en PrintAreaFlag			; 	LD (PrintAreaFlag), A	 ; 7C03 32 01 B7	; en PrintAreaFlag - indica Arriba
	sta	L_B71C			; y en L_B71C				; 	LD (L_B71C), A		 ; 7C06 32 1C B7	; y en L_B71C
	inca				; pone 1				; 	LD A, $01		 ; 7C09 3E 01		; pone valor 1
	sta	L_B6FA			; en L_B6FA				; 	LD (L_B6FA), A		 ; 7C0B 32 FA B6	; en L_B6FA
	jsr	L_72D3			; llama L_72D3				; 	CALL L_72D3		 ; 7C0E CD D3 72	; LLama a la rutina L_72D3 (#146# --)
	lda	L_B71B			; recupera L_B71B			; 	LD A, (L_B71B)		 ; 7C11 3A 1B B7	; recupera valor de L_B71B 
	deca				; decrementa A				; 	DEC A			 ; 7C14 3D		; lo decrementa
	beq	e_7C1B			; si es 0, sale via e_7C1B		; 	RET Z			 ; 7C15 C8		; se ahora es cero, retorna
	puls	x			; desecha 2 bytes del stack		; 	POP HL			 ; 7C16 E1		; Recupera HL
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7C17 E1		; Recupera HL     --- quita 2 bytes extra del stack (parametro o direccin de retorno)
	lbra	L_798B			; salta a L_798B			; 	JP L_798B		 ; 7C18 C3 8B 79	; Salta a L_798B
i_7C1B	puls	y			; recupera Y(IY)			; i_7C1B: POP IY		 ; 7C1B FD E1		; Recupera IY
	sty	<reg_IY			; lo guarda en reg_IY
	jsr	L_7C23			; llama L_7C23				; 	CALL L_7C23		 ; 7C1D CD 23 7C	; llama rutina L_7C23 (#147# --)
	ora	#1			; flag Z=0				; 	OR $01			 ; 7C20 F6 01		; Hace OR lgico de A con $01
e_7C1B	rts				; retorna				; 	RET			 ; 7C22 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#147# --)
L_7C23	tsta				; actualiza flags segun contenido de A	; L_7C23: AND A			 ; 7C23 A7		; A = A AND A	; Adecua flags
	beq	i_7C34			; si es 0, salta a i_7C34		; 	JR Z, i_7C34		 ; 7C24 28 0E		; Si Z = 1, Salta a i_7C34
	ldx	L_795A			; recupera L_795A			; 	LD HL, (L_795A)		 ; 7C26 2A 5A 79	; Carga HL con (L_795A)
	ldu	L_795C			; recupera L_795C			; 	LD DE, (L_795C)		 ; 7C29 ED 5B 5C 79	; Carga DE con (L_795C)
	stu	<reg_DE			; lo pasa a reg_DE
	stu	L_795A			; y a L_795A				; 	LD (L_795A), DE		 ; 7C2D ED 53 5A 79	; Carga (L_795A) con DE
	stx	L_795C			; guarda X(HL) en L_795C		; 	LD (L_795C), HL		 ; 7C31 22 5C 79	; Carga (L_795C) con HL
i_7C34	jsr	SaveActionFlags		; llama SaveActionFlags			; i_7C34: CALL SaveActionFlags	 ; 7C34 CD F3 70	; llama rutina SaveActionFlags
	ldx	#L_795A			; apunta a L_795A			; 	LD HL, L_795A		 ; 7C37 21 5A 79	; Carga HL con L_795A
	ldd	,x+			; toma 2 bytes				; 	LD A, (HL)		 ; 7C3A 7E		; Carga A con (HL)
										; 	INC HL			 ; 7C3B 23		; Incrementa HL
										; 	OR (HL)			 ; 7C3C B6		; Hace OR lgico de A con (HL)
	bne	i_7C44			; si no son 0, salta a i_7C44		; 	JR NZ, i_7C44		 ; 7C3D 20 05		; Si Z = 0, Salta a i_7C44
	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)	 ; 7C3F 3A 1E B7	; recupera ActionFlags2
	bra	i_7C63			; salta a i_7C63			; 	JR i_7C63		 ; 7C42 18 1F		; Salta a i_7C63
i_7C44	leax	-1,x			; resta 1 de X(HL)			; i_7C44: DEC HL		 ; 7C44 2B		; Decrementa HL
	ldd	,x			; toma 2 bytes				; 	LD A, (HL)		 ; 7C45 7E		; Carga A con (HL)
	ldy	<reg_IY			; recupera reg_IY
	cmpd	14,y			; es D=(14,y)?				; 	CP (IY+$0E)		 ; 7C46 FD BE 0E	; Compara A con (IY+$0E)
	beq	i_7C5E			; si, salta a i_7C5E			; 	JR NZ, i_7C53		 ; 7C49 20 08		; Si Z = 0, Salta a i_7C53
										; 	INC HL			 ; 7C4B 23		; Incrementa HL
										; 	LD A, (HL)		 ; 7C4C 7E		; Carga A con (HL)
										; 	CP (IY+$0F)		 ; 7C4D FD BE 0F	; Compara A con (IY+$0F)
										; 	JR Z, i_7C5E		 ; 7C50 28 0C		; Si Z = 1, Salta a i_7C5E
										; 	DEC HL			 ; 7C52 2B		; Decrementa HL
i_7C53	cmpd	16,y			; es D=(16,y)?				; i_7C53: LD A, (HL)		 ; 7C53 7E		; Carga A con (HL)
										; 	CP (IY+$10)		 ; 7C54 FD BE 10	; Compara A con (IY+$10)
										; 	JR NZ, i_7C5E		 ; 7C57 20 05		; Si Z = 0, Salta a i_7C5E
										; 	INC HL			 ; 7C59 23		; Incrementa HL
										; 	LD A, (HL)		 ; 7C5A 7E		; Carga A con (HL)
										; 	CP (IY+$11)		 ; 7C5B FD BE 11	; Compara A con (IY+$11)
i_7C5E	pshs	cc			; guarda flags				; i_7C5E: LD A, (ActionFlags1)	 ; 7C5E 3A 1D B7	; recupera ActionFlags1
	lda	ActionFlags1		; recupera ActionFlags1
	puls	cc			; recupera flags
	bne	i_7C65			; si no eran iguales, salta siguiente	; 	JR NZ, i_7C65		 ; 7C61 20 02		; Si Z = 0, Salta a i_7C65
i_7C63	eora	#%00100000		; invierte bit5				; i_7C63: XOR $20		 ; 7C63 EE 20		; Exorea A con $20
i_7C65	ldu	#$1208			; carga valores $1208			; i_7C65: BIT 5, A		 ; 7C65 CB 6F		; Esta a 1 el bit 5 de A?
	bita	#%00100000		; est a 1 el bit5?			; 	LD BC, $1208		 ; 7C67 01 08 12	; Carga BC con $1208
	beq	i_7C6F			; no, salta siguiente			; 	JR Z, i_7C6F		 ; 7C6A 28 03		; Si Z = 1, Salta a i_7C6F
	ldu	#$0812			; carga valores $0812			; 	LD BC, $0812		 ; 7C6C 01 12 08	; Carga BC con $0812
i_7C6F	stu	<reg_BC			; guarda valor en reg_BC
	ldx	#L_7954			; apunta a L_7954			; i_7C6F: LD HL, L_7954		 ; 7C6F 21 54 79	; Carga HL con L_7954
	stu	,x+			; guarda reg_BC				; 	LD (HL), B		 ; 7C72 70		; Carga (HL) con B
										; 	INC HL			 ; 7C73 23		; Incrementa HL
										; 	LD (HL), C		 ; 7C74 71		; Carga (HL) con C
	lda	<reg_B			; recupera reg_B			; 	LD A, B			 ; 7C75 78		; Carga A con B
	ldu	#MainObj3WordPtrs	; apunta a MainObj3WordPtrs		; 	LD DE, MainObj3WordPtrs	 ; 7C76 11 42 79	; recupera MainObj3WordPtrs
	stu	<reg_DE			; lo guarda en reg_DE
	ldx	#L_793D			; apunta a L_793D			; 	LD HL, L_793D		 ; 7C79 21 3D 79	; HL = L_793D	; HL = L_793D apunta a inicio de tabla de datos (#D12#)
	jsr	L_7C91			; llama L_7C91				; 	CALL L_7C91		 ; 7C7C CD 91 7C	; llama rutina L_7C91 (#148# --)
	lda	<reg_C			; recupera reg_C			; 	LD A, C			 ; 7C7F 79		; Carga A con C
	ldx	#MainObj3WordPtrs	; apunta a MainObj3WordPtrs		; 	LD HL, MainObj3WordPtrs	 ; 7C80 21 42 79	; recupera MainObj3WordPtrs
	ldu	#L_B6E0			; apunta a L_B6E0			; 	LD DE, L_B6E0		 ; 7C83 11 E0 B6	; Carga DE con L_B6E0
	stu	<reg_DE			; lo guarda en reg_DE
	ldb	#6			; contador a 6				; 	LD BC, $0006		 ; 7C86 01 06 00	; Carga BC con $0006
	jsr	do_ldir			; realiza la copia			; 	LDIR			 ; 7C89 ED B0		; (DE+)=(HL+);BC-	; copia $6 bytes de HL en DE
	ldu	#SecObj3WordPtrs	; apunta a SecObj3WordPtrs		; 	LD DE, SecObj3WordPtrs	 ; 7C8B 11 48 79	; apunta a SecObj3WordPtrs
	stu	<reg_DE			; lo guarda en reg_DE
	ldx	#L_793E			; apunta a L_793E			; 	LD HL, L_793E		 ; 7C8E 21 3E 79	; Carga HL con L_793E
										; 							; (#148# --)
L_7C91	ldu	<reg_BC			; recupera reg_BC					
	pshs	u			; guarda U(BC)				; L_7C91: PUSH BC		 ; 7C91 C5		; Guarda BC
	ldu	<reg_DE			; recupera reg_DE (raya en pantalla)
	sta	<reg_C			; guarda A en reg_C			; 	LD C, A			 ; 7C92 4F		; Carga C con A
	clr	<reg_B			; pasa reg_B a cero			; 	LD B, $00		 ; 7C93 06 00		; Carga B con $00
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7C95 E5		; Guarda HL
	ldx	<reg_IY			; pasa IY a X(HL)			; 	PUSH IY			 ; 7C96 FD E5		; Guarda IY
	ldd	<reg_BC			; recupera reg_BC			; 	POP HL			 ; 7C98 E1		; Recupera HL
	leax	d,x			; lo suma a X(HL)			; 	ADD HL, BC		 ; 7C99 09		; Adiciona BC en HL
	ldb	#6			; contador a 6				; 	LD BC, $0006		 ; 7C9A 01 06 00	; Carga BC con $0006
	jsr	do_ldir			; realiza la copia			; 	LDIR			 ; 7C9D ED B0		; (DE+)=(HL+);BC-	; copia $6 bytes de HL en DE
	clra				; A=0 para hacer EORs			; 	XOR A			 ; 7C9F AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	ldb	#6			; contador a 6				; 	LD B, $06		 ; 7CA0 06 06		; Carga B con $06
i_7CA2	leax	-1,x			; decrementa puntero			; i_7CA2: DEC HL		 ; 7CA2 2B		; Decrementa HL
	ora	,x			; hace EOR de A con (X)			; 	OR (HL)			 ; 7CA3 B6		; Hace OR lgico de A con (HL)
	decb				; decrementa contador
	bne	i_7CA2			; si no es 0, sigue			; 	DJNZ i_7CA2		 ; 7CA4 10 FC		; Decrementa B y si no es cero vuelve a i_7CA2
	puls	x,u			; recupera X(HL),U(BC)			; 	POP HL			 ; 7CA6 E1		; Recupera HL
	stu	<reg_BC			; lo guarda en reg_BC			; 	POP BC			 ; 7CA7 C1		; Recupera BC
	tsta				; actualiza flags segun contenido de A
	beq	e_7CA2			; si es 0, sale				; 	RET Z			 ; 7CA8 C8		; Z = 1?	; Retorna si es cero
	ldb	,x			; toma el byte de (X)
	orb	#1			; fuerza bit0 a 1
	stb	,x			; lo actualiza				; 	SET 0, (HL)		 ; 7CA9 CB C6		; Pasa a 1 el bit 0 en (HL)
e_7CA2	rts				; retorna				; 	RET			 ; 7CAB C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Pasa al buffer de 3 palabras una del bloque de 24 ; antes ; (#144# --)
										; 							; Parametros E = offset dentro de bloque de 24 bytes
										; 							;            B = contador que se decrementa si direccion no nula
										; 							;           IY = apunta al inicio del bloque de 25 + 1 (justo tras cdigo de personaje)
ActionWord2Buffer								; ActionWord2Buffer:					;           HL = apunta a $795A (dentro bloque de 3 palabras)
										; 	XOR A			 ; 7CAC AF		; borra A
	tst	<reg_B			; es reg_B 0?				; 	CP B			 ; 7CAD B8		; es B 0?
	beq	eAW2B			; si, sale via eAW2B			; 	RET Z			 ; 7CAE C8		; si, retorna
	clr	<reg_D			; pone reg_D a 0			; 	LD D, $00		 ; 7CAF 16 00		; byte alto a $00. DE = offset
	ldy	<reg_IY			; recupera reg_IY			; 	PUSH IY			 ; 7CB1 FD E5		; Guarda IY
	pshs y				; guarda Y(IY)
	ldd	<reg_DE			; recupera reg_DE			; 	ADD IY, DE		 ; 7CB3 FD 19		; Adiciona DE en IY. Apunta a palabra en el bloque de 25
	leay	d,y			; lo suma a Y(IY)
	ldd	,y			; toma 2 bytes de (Y)			; 	LD A, (IY+$00)		 ; 7CB5 FD 7E 00	; pasa el byte bajo de la palabra apuntada por IY
										; 	LD (HL), A		 ; 7CB8 77		; al byte bajo apuntado por HL
										; 	INC HL			 ; 7CB9 23		; Incrementa HL
										; 	LD A, (IY+$01)		 ; 7CBA FD 7E 01	; pasa el byte alto apuntado por IY
	std	,x			; los pasa a (X)			; 	LD (HL), A		 ; 7CBD 77		; al byte alto apuntado por HL
	tfr	cc,b			; guarda flags en B ((Y)=0?)		; 	DEC HL			 ; 7CBE 2B		; deja HL como estaba
	puls	y			; recupera Y(IY)			; 	OR (IY+$00)		 ; 7CBF FD B6 00	; es nula la palabra apuntada por IY?
	sty	<reg_IY			; lo guarda en reg_IY			; 	POP IY			 ; 7CC2 FD E1		; Recupera IY (inicio de bloque + 1)
	tfr	b,cc			; recupera flags de B
	beq	eAW2B			; si era 0, sale			; 	RET Z			 ; 7CC4 C8		; si era nula, retorna
	dec	<reg_B			; decrementa reg_B			; 	DEC B			 ; 7CC5 05		; Decrementa B (una palabra ya traspasada)
	leax	2,x			; suma 2 a X(HL)			; 	INC HL			 ; 7CC6 23		; suma 2 a HL
										; 	INC HL			 ; 7CC7 23		; para apuntar a siguiente palabra
eAW2B	rts				; retorna				; 	RET			 ; 7CC8 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SpecialExecute									; SpecialExecute:					; ejecuta la rutina indicada por IY (SearchValidObjectByName o bien SearchValidExitByName) ; antes ; (#150# --)
	ldy	<reg_IY			; recupera reg_IY
	jmp	,y			; salta a rutina indicada en IY		; 	JP (IY)			 ; 7CC9 FD E9		; Salta a (IY)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
IsActionValid									; IsActionValid:             				; si no encontrado, devuelve Z=1 y A=$FF ; (#173# --)
	ldu	<reg_IY			; recupera reg_IY
	pshs	u			; guarda U(IY)				; 	PUSH IY          	; 7CCB FD E5      	; Guarda IY
	ldu	ObjIndexPtr		; recupera ObjIndexPtr			; 	LD IX, (ObjIndexPtr)    ; 7CCD DD 2A 4E 79   	; recupera ObjIndexPtr (puntero a ObjIndexTable  3 bytes antes)
	stu	<reg_IX			; lo copia en reg_IX
	lda	IsMainObjLoc		; recupera IsMainObjLoc			; 	LD A, (IsMainObjLoc)   	; 7CD1 3A FE B6   	; recupera IsMainObjLoc
	deca				; lo decrementa 			; 	DEC A          		; 7CD4 3D      		; lo decrementa
	beq	i_7CF1			; si es 0, salta a i_7CF1		; 	JR Z, i_7CF1       	; 7CD5 28 1A      	; si ahora es cero, salta a i_7CF1 (tratar Localizaciones)
	ldy	#SearchValidObjectByName ; apunta a SearchValidObjectByName	; 	LD IY, SearchValidObjectByName
	sty	<reg_IY			; actualiza reg_IY			; 				; 7CD7 FD 21 D9 9D   	; IY apunta a rutina SearchValidObjectByName para tratar Objetos
	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)    ; 7CDB 3A 1E B7   	; recupera ActionFlags2
	lsra				; divide por 4				; 	RRCA          		; 7CDE 0F      		; Rota A a la derecha circularmente (b0 entra en b7)
	lsra				; bits 3-2 pasan a ser bits1-0		; 	RRCA          		; 7CDF 0F      		; dos veces. Bits 3-2 pasan a bits 1-0
	anda	#%00000011		; deja solo los bits1-0			; 	AND $03          	; 7CE0 E6 03      	; se queda solo con los bits 1 y 0
	sta	L_B710			; guarda resultado en L_B710		; 	LD (L_B710), A       	; 7CE2 32 10 B7   	; guarda resultado en L_B710
i_7CE5	jsr	SearchMainObjAction	; llama SearchMainObjAction		; 	CALL SearchMainObjAction; 7CE5 CD FC 7C   	; llama SearchMainObjAction con IY=SearchValidObjectByName
	cmpa	#$FF			; devuelve $FF?				; 	CP $FF          	; 7CE8 FE FF      	; lleg a final de tabla?
i_7CEA	tfr	cc,b			; guarda flags en B
	ldu	<reg_IX			; recupera reg_IX
	stu	ObjIndexPtr		; guarda U(IX) en ObjIndexPtr		; i_7CEA: LD (ObjIndexPtr), IX  ; 7CEA DD 22 4E 79   	; guarda IX recibido en ObjIndexPtr
	puls	y			; recupera Y(IY)			; 	POP IY          	; 7CEE FD E1      	; Recupera IY
	sty	<reg_IY			; actualiza reg_IY
	tfr	b,cc			; recupera flags de B
	rts				; retorna				; 	RET          		; 7CF0 C9      		; retorna. Si final de tabla Z=1
i_7CF1	ldy	#SearchValidExitByName	; apunta a SearchValidExitByName	; i_7CF1: LD IY, SearchValidExitByName
	sty	<reg_IY			; actualiza reg_IY			; 				; 7CF1 FD 21 A0 9E   	; IY apunta a rutina SearchValidExitByName (para Localizaciones)
										; 							; No entiendo por qu no saltan a 7ce5 para ahorrar lo siguiente. OTRO GRAN OLVIDO o PARCHE!
										; 	CALL SearchMainObjAction; 7CF5 CD FC 7C   	; llama SearchMainObjAction con IY=SearchValidExitByName
										; 	CP $FF          	; 7CF8 FE FF      	; lleg a final de tabla?
	bra	i_7CE5			; vuelve a i_7CE5			; 	JR i_7CEA       	; 7CFA 18 EE      	; Salta a i_7CEA
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Busca la accin para el MainObject ; antes ; (#149# --)
										; 							; Devuelve IX=registro de la tabla donde se encontr y en A el cdigo del objeto o 
										; 							; de la localizacin de destino o $ff si no lo encuentra. 
SearchMainObjAction								; SearchMainObjAction:					; recibe in IY la rutina a llamar (Objeto - Localizacin)				
	ldx	#MainObj3WordPtrs	; apunta a MainObj3WordPtrs		; 	LD HL, MainObj3WordPtrs	 ; 7CFC 21 42 79	; apunta a MainObj3WordPtrs
	jsr	SpecialExecute		; llama SpecialExecute			; 	CALL SpecialExecute	 ; 7CFF CD C9 7C	; llama SpecialExecute
	cmpa	#$FF			; devuelve $FF?				; 	CP $FF			 ; 7D02 FE FF		; lleg a fin de tabla (no encontrado)?
	beq	eSmOa			; si, sale				; 	RET Z			 ; 7D04 C8		; si, retorna con Z=1
	sta	MainObject		; guarda resultado en MainObject	; 	LD (MainObject), A	 ; 7D05 32 E8 B6	; guarda cdigo objeto como MainObject
	ldx	#L_793D			; apunta a L_793D			; 	LD HL, L_793D		 ; 7D08 21 3D 79	; apunta a inicio de tabla AreaD12Part1
	ldb	,x			; recupera 1 byte de X(HL)
	orb	#%00000010		; fuerza bit1 a 1
	stb	,x			; actualiza el byte			; 	SET 1, (HL)		 ; 7D0B CB CE		; Activa bit1 al contenido del primer byte de la tabla AreaD12Part1 (L_793D)
	jsr	IsActionInTables	; llama IsActionInTables		; 	CALL IsActionInTables	 ; 7D0D CD D6 94	; llama IsActionInTables
	lda	L_B6FB			; recupera 				; 	LD A, (L_B6FB)		 ; 7D10 3A FB B6	; recupera L_B6FB (resultado bsqueda)
										; 	AND A			 ; 7D13 A7		; adecua flags
	beq	SearchMainObjAction	; si es 0, salta a SearchMainObjAction	; 	JR Z, SearchMainObjAction ; 7D14 28 E6		; si es 0, vuelve a SearchMainObjAction
eSmOa	rts				; retorna				; 	RET			 ; 7D16 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Rutina que decide qu accin ejecutar en algunos casos
										; 							; La estructura es extraa, como si se hubiese parcheado la parte a partir de 7d49
										;###NoName08:                  				; (#139# --)
L_7D17	clra				; pone 0				; L_7D17: XOR A          	; 7D17 AF      		; pone a 0
	sta	L_B70F			; en L_B70F				; 	LD (L_B70F), A       	; 7D18 32 0F B7   	; L_B70F
	ldu	<reg_IY			; recupera reg_IY
	pshs	u			; guarda U(IY)				; 	PUSH IY          	; 7D1B FD E5      	; Guarda IY
	ldu	ObjOrLocPointer		; recupera ObjOrLocPointer		; 	LD IX, (ObjOrLocPointer) ; 7D1D DD 2A 50 79   	; recupera ObjOrLocPointer
	stu	<reg_IX			; actualiza reg_IX
	lda	IsSecObjLoc		; recupera IsSecObjLoc			; 	LD A, (IsSecObjLoc)    	; 7D21 3A FF B6   	; recupera IsSecObjLoc
	deca				; lo decrementa				; 	DEC A           	; 7D24 3D      		; lo decrementa
	beq	i_7D49			; si es 0, salta a i_7D49		; 	JR Z, i_7D49       	; 7D25 28 22      	; si era 1, salta a i_7D49 (para Localizaciones)
	ldu	#SearchValidObjectByName ; apunta a SearchValidObjectByName	; 	LD IY, SearchValidObjectByName
	stu	<reg_IY			; actualiza reg_IY			; 				; 7D27 FD 21 D9 9D   	; si era 0, apunta a rutina SearchValidObjectByName para Objetos
	lda	ActionFlags2		; recupera ActionFlags2			; 	LD A, (ActionFlags2)    ; 7D2B 3A 1E B7   	; recupera ActionFlags2
	anda	#%00000011		; deja solo los bits1-0			; 	AND $03          	; 7D2E E6 03      	; guarda los bits 0-1 de la 3a palabra de la accin (byte5)
	sta	L_B710			; guarda resultado en L_B710		; 	LD (L_B710), A       	; 7D30 32 10 B7   	; en L_B710
	jsr	L_7D54			; llama L_7D54				; 	CALL L_7D54       	; 7D33 CD 54 7D   	; llama rutina L_7D54 (#152# --)
	cmpa	#$FF			; devuelve $FF?				; 	CP $FF          	; 7D36 FE FF      	; lleg a fin de tabla (no encontrado)?
i_7D38	tfr	cc,b			; guarda flags en B
	ldu	<reg_IX			; pasa reg_IX
	stu	ObjOrLocPointer		; a ObjOrLocPointer			; i_7D38: LD (ObjOrLocPointer), IX ; 7D38 DD 22 50 79   ; guarda IX en ObjOrLocPointer (puntero a Objeto)
	puls	u			; recupera U(IY)			; 	POP IY          	; 7D3C FD E1      	; Recupera IY
	stu	<reg_IY			; actualiza reg_IY
	tfr	b,cc			; recupera flags de B
	pshs	a,cc			; guarda registro A y flags		; 	PUSH AF          	; 7D3E F5      		; Guarda A y flags
	lda	ActionFlags1		; recupera ActionFlags1			; 	LD A, (ActionFlags1)    ; 7D3F 3A 1D B7   	; recupera ActionFlags1
	anda	#%00000001		; deja solo el bit0			; 	AND $01          	; 7D42 E6 01      	; guarda el bit0 del byte 1 de la accin (take off, follow, jump onto ?)
	sta	L_B70F			; guarda resultado en L_B70F		; 	LD (L_B70F), A       	; 7D44 32 0F B7   	; en L_B70F
	puls	a,cc,pc			; recupera registro A y flags		; 	POP AF          	; 7D47 F1      		; Recupera A y Flags (el resultado del CP $FF anterior)
					; y retorna				; 	RET          		; 7D48 C9      		; retorna
i_7D49	ldu	#SearchValidExitByName	; recupera SearchValidExitByName	; i_7D49: LD IY, SearchValidExitByName
	stu	<reg_IY			; actualkiza reg_IY			; 				; 7D49 FD 21 A0 9E   	; IY apunta a rutina SearchValidExitByName (para Localizaciones)
										; 							; No entiendo por qu no salta directamente a 7D33 y se ahorra esto ... PORQUE NO LO VIERON!
										; 							; Hay que tener en cuenta que ellos lo PROGRAMARON, no lo ANALIZARON! ... o es un PARCHE MAS!
	jsr	L_7D54			; llama L_7D54				; 	CALL L_7D54       	; 7D4D CD 54 7D   	; llama rutina L_7D54 (#152# --)
	cmpa	#$FF			; devuelve $FF?				; 	CP $FF          	; 7D50 FE FF      	; lleg a fin de tabla (no encontrado)?
	bra	i_7D38			; vuelve a i_7D38			; 	JR i_7D38       	; 7D52 18 E4      	; Salta a i_7D38
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;###NoName12:						; (#152# --)
L_7D54	ldx	#SecObj3WordPtrs	; apunta a SecObj3WordPtrs		; L_7D54: LD HL, SecObj3WordPtrs ; 7D54 21 48 79	; apunta a SecObj3WordPtrs
	jsr	SpecialExecute		; llama SpecialExecute			; 	CALL SpecialExecute	 ; 7D57 CD C9 7C	; llama SpecialExecute
	cmpa	#$FF			; devuelve $FF?				; 	CP $FF			 ; 7D5A FE FF		; lleg a fin de tabla (no encontrado)?
	beq	e7D54			; si, sale				; 	RET Z			 ; 7D5C C8		; si, retorna
	sta	SecondObject		; guarda resultado en SecondObject	; 	LD (SecondObject), A	 ; 7D5D 32 E9 B6	; guarda cdigo objeto secundario
	ldx	#L_793E			; apunta a L_793E			; 	LD HL, L_793E		 ; 7D60 21 3E 79	; apunta a L_793E
	ldb	,x			; toma 1 byte apuntado por X(HL)
	orb	#%00000010		; fuerza bit1 a 1
	stb	,x			; actualiza el byte			; 	SET 1, (HL)		 ; 7D63 CB CE		; Pone a 1 el bit 1 de L_793E
	jsr	ExecuteGetB6fb		; llama ExecuteGetB6fb			; 	CALL ExecuteGetB6fb	 ; 7D65 CD ED 7A	; llama ExecuteGetB6fb
	beq	L_7D54			; si devuelve 0, vuelve a L_7D54	; 	JR Z, L_7D54		 ; 7D68 28 EA		; si flag Z=1, vuelve a L_7D54
e7D54	rts				; retorna				; 	RET			 ; 7D6A C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SetB6FAto1									; SetB6FAto1:						; pone a 1 L_B6FA ; (-05-) 
	lda	#1			; pone 1				; 	LD A, $01		 ; 7D6B 3E 01		; pone 1
	sta	L_B6FA			; en L_B6FA				; 	LD (L_B6FA), A		 ; 7D6D 32 FA B6	; en L_B6FA
	sta	PrintAreaFlag		; y en PrintAreaFlag			; 	LD (PrintAreaFlag), A	 ; 7D70 32 01 B7	; y en PrintAreaFlag - indica Abajo
	rts				; retorna				; 	RET			 ; 7D73 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
CopyIYToB9C8									; CopyIYToB9C8: 		 			; llena bloque de trabajo de 24 bytes desde IY ; (#153# --)
	sta	L_B71A			; guarda A en L_B71A			; 	LD (L_B71A), A		 ; 7D74 32 1A B7	; guarda A en L_B71A
	ldx	<reg_IY			; pasa a X(HL) IY			; 	PUSH IY			 ; 7D77 FD E5		; pasa IY
	ldu	#L_B9C8			; apunta a L_B9C8			; 	POP HL			 ; 7D79 E1		; a HL
	stu	<reg_DE			; lo guarda en reg_DE			; 	LD DE, L_B9C8		 ; 7D7A 11 C8 B9	; apunta a L_B9C8 (bloque de trabajo de 24 bytes)
	ldb	#$18			; contador a $18			; 	LD BC, $0018		 ; 7D7D 01 18 00	; 24 bytes a copiar
	jsr	do_ldir			; realiza la copia			; 	LDIR			 ; 7D80 ED B0		; (DE+)=(HL+);BC-	; copia 24 bytes de IY en L_B9C8
	rts				; retorna				; 	RET			 ; 7D82 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7D83	lda	L_7954			; recupera L_7954			; L_7D83: LD A, (L_7954)	 ; 7D83 3A 54 79	; Carga A con (L_7954)
        ldx     MainObj3WordPtrs        ; gets 1st word from MainObj3WordPtrs  	; 	LD HL, (MainObj3WordPtrs) ; 7D86 2A 42 79	; recupera contenido de MainObj3WordPtrs
i_7D89	pshs	x			; guarda X(HL)				; i_7D89: PUSH HL		 ; 7D89 E5		; Guarda HL
	jsr	CopyIYToB9C8		; llama CopyIYToB9C8			; 	CALL CopyIYToB9C8	 ; 7D8A CD 74 7D	; llama CopyIYToB9C8
	ldx	#L_ADCC			; apunta a L_ADCC			; 	LD HL, L_ADCC		 ; 7D8D 21 CC AD	; apunta a mensaje "which[0x01] ? [0x16]"
L_7D90	jsr	SetB6FAto1		; llama SetB6FAto1			; L_7D90: CALL SetB6FAto1	 ; 7D90 CD 6B 7D	; Llama SetB6FAto1
	jsr	L_72D3			; llama L_72D3				; 	CALL L_72D3		 ; 7D93 CD D3 72	; Llama rutina L_72D3 (#146# --)	; Llama a L_72D3
	clra				; flag Z=1				; 	XOR A			 ; 7D96 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
e7D90	rts				; retorna				; 	RET			 ; 7D97 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7D98	ldx	#L_793E			; apunta a L_793E			; L_7D98: LD HL, L_793E		 ; 7D98 21 3E 79	; Carga HL con L_793E
	ldb	,x			; toma un byte
	bitb	#%00000001		; est a 1 el bit0?			; 	BIT 0, (HL)		 ; 7D9B CB 46		; Esta a 1 el bit 0 de (HL)?
	lbeq	L_7E4D			; no, salta a L_7E4D			; 	JP Z, L_7E4D		 ; 7D9D CA 4D 7E	; Si Z = 1, Salta a L_7E4D
	andb	#%00000010		; deja solo el bit1			; 	BIT 1, (HL)		 ; 7DA0 CB 4E		; Esta a 1 el bit 1 de (HL)?
	ldx	#SecObj3WordPtrs	; apunta a SecObj3WordPtrs		; 	LD HL, SecObj3WordPtrs	 ; 7DA2 21 48 79	; apunta a SecObj3WordPtrs
	ldu	#SecondObject		; apunta a SecondObject			; 	LD DE, SecondObject	 ; 7DA5 11 E9 B6	; apunta a SecondObject
	stu	<reg_DE			; lo guarda en reg_DE
	ldu	#IsSecObjLoc		; apunta a IsSecObjLoc			; 	LD BC, IsSecObjLoc	 ; 7DA8 01 FF B6	; apunta a IsSecObjLoc
	stu	<reg_BC			; guarda U(BC)
	tstb				; estaba el bit1 a 0?
	beq	L_7DFE			; si, salta a L_7DFE			; 	JR Z, L_7DFE		 ; 7DAB 28 51		; Si Z = 1, Salta a L_7DFE
	lda	L_7941			; recupera L_7941			; 	LD A, (L_7941)		 ; 7DAD 3A 41 79	; Carga A con (L_7941)
										; 	AND A			 ; 7DB0 A7		; A = A AND A	; Adecua flags
	beq	L_7DF5			; si es 0, salta a L_7DF5		; 	JP Z, L_7DF5		 ; 7DB1 CA F5 7D	; Si Z = 1, Salta a L_7DF5
					; no sirve de nada!!			; 	LD A, (L_7955)		 ; 7DB4 3A 55 79	; Carga A con (L_7955)
	lda	SecObj3WordPtrs		; recupera SecObj3WordPtrs		; 	LD A, (SecObj3WordPtrs)	 ; 7DB7 3A 48 79	; Carga A con (SecObj3WordPtrs) - byte bajo del 1er puntero
	bra	i_7D89			; salta a i_7D89			; 	JR i_7D89		 ; 7DBA 18 CD		; Salta a i_7D89
L_7DBC	lda	L_B71B			; recupera L_B71B			; L_7DBC: LD A, (L_B71B)	 ; 7DBC 3A 1B B7	; recupera L_B71B
	deca				; lo decrementa				; 	DEC A			 ; 7DBF 3D		; Decrementa A
	beq	e7D90			; si es 0, sale via e7D90		; 	RET Z			 ; 7DC0 C8		; si es cero, retorna
	lda	L_B71C			; recupera L_B71C			; 	LD A, (L_B71C)		 ; 7DC1 3A 1C B7	; recupera L_B71C
										; 	AND A			 ; 7DC4 A7		; adecua flags
	beq	i_7DCB			; si es 0, salta a i_7DCB		; 	JR Z, i_7DCB		 ; 7DC5 28 04		; si es cero, salta a i_7DCB
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7DC7 E1		; Recupera HL
	lbra	L_7994			; salta a L_7994			; 	JP L_7994		 ; 7DC8 C3 94 79	; Salta a L_7994
i_7DCB	lda	L_7940			; recupera L_7940			; i_7DCB: LD A, (L_7940)	 ; 7DCB 3A 40 79	; recupera L_7940
	cmpa	#1			; es 1?					; 	CP $01			 ; 7DCE FE 01		; es $01?
	beq	L_7D98			; si, salta a L_7D98			; 	JR Z, L_7D98		 ; 7DD0 28 C6		; si, salta a L_7D98
	ldx	#L_793D			; apunta a L_793D			; 	LD HL, L_793D		 ; 7DD2 21 3D 79	; apunta a inicio de tabla de datos (#D12#)
	ldb	,x			; toma 1 byte
	bitb	#%00000001		; est el bit0 a 1?			; 	BIT 0, (HL)		 ; 7DD5 CB 46		; Esta a 1 el bit 0 de L_793D?
	beq	L_7E30			; no, salta a L_7E30			; 	JP Z, L_7E30		 ; 7DD7 CA 30 7E	; no, salta a L_7E30
	andb	#%00000010		; deja solo el bit1			; 	BIT 1, (HL)		 ; 7DDA CB 4E		; Esta a 1 el bit 1 de L_793D?
	ldx	#MainObj3WordPtrs	; apunta a MainObj3WordPtrs		; 	LD HL, MainObj3WordPtrs	 ; 7DDC 21 42 79	; apunta a MainObj3WordPtrs
	ldu	#MainObject		; apunta a MainObject			; 	LD DE, MainObject	 ; 7DDF 11 E8 B6	; apunta a MainObject
	stu	<reg_DE			; lo guarda en reg_DE
	ldu	#IsMainObjLoc		; apunta a IsMainObjLoc			; 	LD BC, IsMainObjLoc	 ; 7DE2 01 FE B6	; apunta a IsMainObjLoc
	stu	<reg_BC			; lo guarda en reg_BC
	tstb				; estaba a 1 el bit1?
	beq	L_7DFE			; no, salta a L_7DFE			; 	JR Z, L_7DFE		 ; 7DE5 28 17		; si L_793D bit1 era cero, Salta a L_7DFE
	lda	L_793F			; recupera L_793F			; 	LD A, (L_793F)		 ; 7DE7 3A 3F 79	; recupera L_793F
										; 	AND A			 ; 7DEA A7		; es 0?
	beq	L_7DF5			; si es 0, salta a L_7DF5		; 	JR Z, L_7DF5		 ; 7DEB 28 08		; si, salta a L_7DF5
	deca				; decrementa A				; 	DEC A			 ; 7DED 3D		; Decrementa A
	bne	L_7D83			; si no es 0, vuelve a L_7D83		; 	JR NZ, L_7D83		 ; 7DEE 20 93		; si no es cero, salta a L_7D83
	jsr	AnalyzeActionFlags	; llama AnalyzeActionFlags		; 	CALL AnalyzeActionFlags	 ; 7DF0 CD D8 7A	; llama AnalyzeActionFlags
	bne	L_7D98			; si no da 0, salta a L_7D98		; 	JR NZ, L_7D98		 ; 7DF3 20 A3		; Si Z = 0, Salta a L_7D98

L_7DF5	jsr	SetB6FAto1		; llama SetB6FAto1			; L_7DF5: CALL SetB6FAto1	 ; 7DF5 CD 6B 7D	; llama SetB6FAto1
	jsr	ExecuteAction		; llama ExecuteAction			; 	CALL ExecuteAction	 ; 7DF8 CD 0F 95	; llama ExecuteAction
	lbra	L_798E			; vuelve a L_798E			; 	JP L_798E		 ; 7DFB C3 8E 79	; vuelve a L_798E
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7DFE	pshs	x			; guarda X(HL)				; L_7DFE: PUSH HL		 ; 7DFE E5		; Guarda HL
	jsr	GetLocExitPtr		; llama GetLocExitPtr			; 	CALL GetLocExitPtr	 ; 7DFF CD 95 9E	; llama GetLocExitPtr
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 7E02 3E 01		; Carga A con $01
	ldu	<reg_BC			; recupera reg_BC
	sta	,u			; pone a 1 (U)				; 	LD (BC), A		 ; 7E04 02		; Carga (BC) con A
	jsr	SearchValidExitByName	; llama SearchValidExitByName		; 	CALL SearchValidExitByName
										; 				 ; 7E05 CD A0 9E	; llama rutina SearchValidExitByName (#155# --)
	cmpa	#$FF			; es A = $FF (ninguna)?			; 	CP $FF			 ; 7E08 FE FF		; Compara A con $FF
	bne	i_7E20			; no, salta a i_7E20			; 	JR NZ, i_7E20		 ; 7E0A 20 14		; Si Z = 0, Salta a i_7E20
	puls	x			; recupera X(HL)			; 	POP HL			 ; 7E0C E1		; Recupera HL
	lda	#2			; pone 2				; 	LD A, $02		 ; 7E0D 3E 02		; Carga A con $02
	sta	L_B710			; en L_B710				; 	LD (L_B710), A		 ; 7E0F 32 10 B7	; Carga (L_B710) con A
	ldy	#ObjIndexTable-3	; apunta 3 bytes antes de ObjIndexTable	; 	LD IX, ObjIndexTable-$03 ; 7E12 DD 21 60 C0	; Carga IX con ObjIndexTable - $03
	sty	<reg_IX			; lo guarda en reg_IX
	clra				; valor 0				; 	XOR A			 ; 7E16 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	ldu	<reg_BC			; recupera reg_BC
	sta	,u			; pone 0 en (U)				; 	LD (BC), A		 ; 7E17 02		; Carga (BC) con A
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7E18 E5		; Guarda HL
	jsr	SearchValidObjectByName	; llama SearchValidObjectByName		; 	CALL SearchValidObjectByName
										; 				 ; 7E19 CD D9 9D	; llama SearchValidObjectByName
	cmpa	#$FF			; es A = $FF (ninguno)?			; 	CP $FF			 ; 7E1C FE FF		; Compara A con $FF
	beq	i_7E25			; si, salta a i_7E25			; 	JR Z, i_7E25		 ; 7E1E 28 05		; Si Z = 1, Salta a i_7E25
i_7E20	puls	x			; recupera X(HL)			; i_7E20: POP HL		 ; 7E20 E1		; Recupera HL
	ldu 	<reg_DE			; recupera U(DE)
	sta	,u			; toma un byte de (U)			; 	LD (DE), A		 ; 7E21 12		; Carga (DE) con A
	lbra	L_711A			; vuelve a L_711A			; 	JP L_711A		 ; 7E22 C3 1A 71	; Salta a L_711A
i_7E25	jsr	SetB6FAto1		; llama SetB6FAto1			; i_7E25: CALL SetB6FAto1	 ; 7E25 CD 6B 7D	; llama SetB6FAto1
	ldx	#L_ADD3			; apunta a L_ADD3			; 	LD HL, L_ADD3		 ; 7E28 21 D3 AD	; apunta a mensaje "i do not see[0x00] here[0x14]"
	jsr	L_72D3			; llama L_72D3				; 	CALL L_72D3		 ; 7E2B CD D3 72	; llama rutina L_72D3 (#146# --)
	clra				; flag Z=1				; 	XOR A			 ; 7E2E AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	rts				; retorna				; 	RET			 ; 7E2F C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7E30	jsr	L_7E7C			; llama L_7E7C				; L_7E30: CALL L_7E7C		 ; 7E30 CD 7C 7E	; llama rutina L_7E7C (#156# --)
	ldx	L_7958			; recupera L_7958			; 	LD HL, (L_7958)		 ; 7E33 2A 58 79	; Carga HL con (L_7958)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7E36 E5		; Guarda HL
	ldx	#L_ADE1			; apunta a L_ADE1			; 	LD HL, L_ADE1		 ; 7E37 21 E1 AD	; apunta a mensaje "[0x0b] D[0x01][0x01][0x14]"
	lda	L_7940			; recupera L_7940			; 	LD A, (L_7940)		 ; 7E3A 3A 40 79	; Carga A con (L_7940)
										; 	AND A			 ; 7E3D A7		; A = A AND A	; Adecua flags
	lbeq	L_7D90			; si es 0, salta a L_7D90		; 	JP Z, L_7D90		 ; 7E3E CA 90 7D	; Si Z = 1, Salta a L_7D90
	lda	L_7954			; recupera L_7954			; 	LD A, (L_7954)		 ; 7E41 3A 54 79	; Carga A con (L_7954)
	jsr	CopyIYToB9C8		; llama CopyIYToB9C8			; 	CALL CopyIYToB9C8	 ; 7E44 CD 74 7D	; llama CopyIYToB9C8
	ldx	#L_ADC4			; apunta a L_ADC4			; 	LD HL, L_ADC4		 ; 7E47 21 C4 AD	; Carga HL con L_ADC4
	lbra	L_7D90			; salta a L_7D90			; 	JP L_7D90		 ; 7E4A C3 90 7D	; Salta a L_7D90
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7E4D	jsr	L_7E78			; llama L_7E78				; L_7E4D: CALL L_7E78		 ; 7E4D CD 78 7E	; llama rutina L_7E78 (#157# --)
	ldx	#$0000			; pone 0 en X(HL)			; 	LD HL, $0000		 ; 7E50 21 00 00	; Carga HL con $0000
	pshs	x			; lo guarda				; 	PUSH HL			 ; 7E53 E5		; Guarda HL
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 7E54 3A E8 B6	; Carga cdigo objeto principal
	jsr	PointHLTo3WordsObj	; llama PointHLTo3WordsObj		; 	CALL PointHLTo3WordsObj	 ; 7E57 CD E2 71	; llama PointHLTo3WordsObj
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7E5A E5		; Guarda HL
	jsr	L_7E7C			; llama L_7E7C				; 	CALL L_7E7C		 ; 7E5B CD 7C 7E	; llama rutina L_7E7C (#156# --)
	ldx	L_7958			; recupera L_7958			; 	LD HL, (L_7958)		 ; 7E5E 2A 58 79	; Carga HL con (L_7958)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7E61 E5		; Guarda HL
	ldx	#L_ADE7			; apunta a L_ADE7			; 	LD HL, L_ADE7		 ; 7E62 21 E7 AD	; apunta a mensaje "[0x0b] Eat[0x01][0x01][0x00][0x01][0x01][0x01][0x14]"
	lda	L_7941			; recupera L_7941			; 	LD A, (L_7941)		 ; 7E65 3A 41 79	; Carga A con (L_7941)
										; 	AND A			 ; 7E68 A7		; A = A AND A	; Adecua flags
	lbeq	L_7D90			; si es 0, salta a L_7D90		; 	JP Z, L_7D90		 ; 7E69 CA 90 7D	; Si Z = 1, Salta a L_7D90
	lda	L_7955			; recupera L_7955			; 	LD A, (L_7955)		 ; 7E6C 3A 55 79	; Carga A con (L_7955)
	jsr	CopyIYToB9C8		; llama CopyIYToB9C8			; 	CALL CopyIYToB9C8	 ; 7E6F CD 74 7D	; llama CopyIYToB9C8
	ldx	#L_ADC0			; apunta a L_ADC0			; 	LD HL, L_ADC0		 ; 7E72 21 C0 AD	; apunta a mensaje "[0x01][0x01][0x01][0x00][0x01][0x01][0x01] what ? [0x16]"
	lbra	L_7D90			; salta a L_7D90			; 	JP L_7D90		 ; 7E75 C3 90 7D	; Salta a L_7D90
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#157# --) este cdigo se AUTOMODIFICA!!
L_7E78	ldd	#$2A27			; toma valor de opcodes BPL,BEQ		; L_7E78: LD A, $28		 ; 7E78 3E 28		; toma valor $28 = opcode JR Z  (cambia opcode)
	bra	i_7E7E			; salta a i_7E7E			; 	JR i_7E7E		 ; 7E7A 18 02		; salta siguiente instrucccin
										; 							; (#156# --)
L_7E7C	ldd	#$2B26			; toma valor de opcodes BMI,BNE		; L_7E7C: LD A, $20		 ; 7E7C 3E 20		; toma valor $20 = opcode JR NZ (repone opcode) 
i_7E7E	sta	i_7E92			; modifica cdigo en i_7E92		; i_7E7E: LD (i_7E92), A	 ; 7E7E 32 92 7E	; sobreescribe JR NZ de i_7E92
	stb	i_7EA1			; modifica cdigo en i_7EA1		; 	LD (i_7EA1), A		 ; 7E81 32 A1 7E	; sobreescribe JR NZ de i_7EA1
	ldy	L_795E			; recupera L_795E			; 	LD IX, (L_795E)		 ; 7E84 DD 2A 5E 79	; Carga IX con (L_795E)
	sty	<reg_IX			; lo guarda en reg_IX
	ldx	4,y			; recupera 2 bytes de (Y+4)		; 	LD L, (IX+$04)		 ; 7E88 DD 6E 04	; Carga L con (IX+$04)
										; 	LD H, (IX+$05)		 ; 7E8B DD 66 05	; Carga H con (IX+$05)
	tst	6,y			; est a 1 el bit7 de (Y+6)? --CAMBIO--	; 	BIT 7, (IX+$07)		 ; 7E8E DD CB 07 7E	; Esta a 1 el bit 7 de (IX+$07)?
i_7E92	bmi	i_7E97			; segun opcode salta a i_7E97		; i_7E92: JR NZ, i_7E97		 ; 7E92 20 03		; OJO! opcode puede ser JR NZ  o bien  JR Z
	ldx	#$0000			; pone 0 en X(HL)			; 	LD HL, $0000		 ; 7E94 21 00 00	; Carga HL con $0000
i_7E97	puls	u			; recupera 2 bytes del stack en U(HL)	; i_7E97: EX (SP), HL		 ; 7E97 E3		; Intercambia (SP) con HL
	pshs	x			; guarda X(HL) en su lugar
	pshs	u			; guarda U(HL)(los 2 bytes tomados)	; 	PUSH HL			 ; 7E98 E5		; Guarda HL
	ldd	2,y			; toma 2 bytes de (Y+2)			; 	LD L, (IX+$02)		 ; 7E99 DD 6E 02	; Carga L con (IX+$02)
										; 	LD H, (IX+$03)		 ; 7E9C DD 66 03	; Carga H con (IX+$03)
	bita	#%00100000		; est el bit5 a 1?			; 	BIT 5, H		 ; 7E9F CB 6C		; Esta a 1 el bit 5 de H?
i_7EA1	bne	i_7EA6			; no, salta siguiente			; i_7EA1: JR NZ, i_7EA6		 ; 7EA1 20 03		; OJO! opcode puede ser JR NZ  o bien  JR Z
	ldd	#$0000			; toma valor 0				; 	LD HL, $0000		 ; 7EA3 21 00 00	; Carga HL con $0000
i_7EA6	puls	x			; toma 2 bytes del stack en X(HL)	; i_7EA6: EX (SP), HL		 ; 7EA6 E3		; Intercambia (SP) con HL
	pshs	d			; guarda D (terico HL anterior)
	jmp	,x			; salta a direccin apuntada por X(HL)	; 	JP (HL)			 ; 7EA7 E9		; Salta a (HL)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_7EA8	ldx	L_795C			; recupera L_795C			; L_7EA8: LD HL, (L_795C)	 ; 7EA8 2A 5C 79	; HL = (L_795C)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7EAB E5		; Guarda HL
	ldx	L_795A			; recupera L_795A			; 	LD HL, (L_795A)		 ; 7EAC 2A 5A 79	; HL = (L_795A)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7EAF E5		; Guarda HL
	ldx	L_7958			; recupera L_7958			; 	LD HL, (L_7958)		 ; 7EB0 2A 58 79	; HL = (L_7958)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 7EB3 E5		; Guarda HL
	ldx	#L_ADB0			; apunta a L_ADB0			; 	LD HL, L_ADB0		 ; 7EB4 21 B0 AD	; HL = L_ADB0	; Toma la direccin de L_ADB0 TEXT MESSAGES Table ; i do not know the verb "[0x01][0x01][0x01] "[0x14]
	lbra	L_7D90			; vuelve a L_7D90			; 	JP L_7D90		 ; 7EB7 C3 90 7D	; Salta a L_7D90
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;  							; (#195# --)	
L_7EBA	ldu	<reg_BC			; get pseudo-registers			; L_7EBA: PUSH BC		 ; 7EBA C5		; Guarda BC
	ldy	<reg_IX								; 	PUSH IX			 ; 7EBB DD E5		; Guarda IX
	pshs	y,u			; save them				; 	PUSH DE			 ; 7EBD D5		; Guarda DE
	sta	<reg_B			; save A in reg_B			; 	LD B, A			 ; 7EBE 47		; Carga B con A
	lda	L_B737			; numlines copied to 8x25		; 	LD A, (L_B737)		 ; 7EBF 3A 37 B7	; Carga A con (L_B737)
	sta	<reg_C			; save at reg_C				; 	LD C, A			 ; 7EC2 4F		; Carga C con A
	cmpa	<reg_B			; greater than received random?		; 	CP B			 ; 7EC3 B8		; Compara A con B
	bcc	i_7EC7			; yes, skip next			; 	JR NC, i_7EC7		 ; 7EC4 30 01		; Si C = 0, Salta a i_7EC7
	sta	<reg_B			; put lower value in reg_B		; 	LD B, A			 ; 7EC6 47		; Carga B con A
i_7EC7	lda	<reg_C			; get numlines 8x25			; i_7EC7: LD A, C		 ; 7EC7 79		; Carga A con C
	suba	<reg_B			; deduct saved value (lower)		; 	SUB B			 ; 7EC8 90		; Resta B de A
	sta	<reg_C			; save result in reg_C			; 	LD C, A			 ; 7EC9 4F		; Carga C con A
	ldy	#L_B71F			; point to word-endings table		; 	LD IX, L_B71F		 ; 7ECA DD 21 1F B7	; Carga IX con L_B71F
	sty	<reg_IX			; save pointer				; 	LD DE, $0019		 ; 7ECE 11 19 00	; Carga DE con $0019
										; 	XOR A			 ; 7ED1 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	tst	<reg_B			; is 0 lower value?			; 	CP B			 ; 7ED2 B8		; Compara A con B
	beq	i_7EE6			; yes, skip section			; 	JR Z, i_7EE6		 ; 7ED3 28 11		; Si Z = 1, Salta a i_7EE6
i_7ED5	leay	25,y			; point to next bloc of 25		; i_7ED5: ADD IX, DE		 ; 7ED5 DD 19		; Adiciona DE en IX
	sty	<reg_IX			; update pseudoreg
	lda	,y			; get actor ID in bloc			; 	LD A, (IX+$00)		 ; 7ED7 DD 7E 00	; Carga A con (IX+$00)
	cmpa	#$ff			; is none?				; 	CP $FF			 ; 7EDA FE FF		; Compara A con $FF
	bne	i_7ED5			; no, search for a free one		; 	JR NZ, i_7ED5		 ; 7EDC 20 F7		; Si Z = 0, Salta a i_7ED5
	lda	MainObject		; get actor				; 	LD A, (MainObject)	 ; 7EDE 3A E8 B6	; Carga cdigo objeto principal
	sta	,y			; put in block				; 	LD (IX+$00), A		 ; 7EE1 DD 77 00	; Carga (IX+$00) con A
	dec	<reg_B			; decrement counter			; 	DJNZ i_7ED5		 ; 7EE4 10 EF		; Decrementa B y si no es cero vuelve a i_7ED5
	bne	i_7ED5			; if not done, loopback for more
i_7EE6	ldb	<reg_C			; pass reg_C				; i_7EE6: LD B, C		 ; 7EE6 41		; Carga B con C
	stb	<reg_B			; to reg_B				; 	XOR A			 ; 7EE7 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
										; 	CP B			 ; 7EE8 B8		; Compara A con B
	beq	i_7EFA			; if zero, exit				; 	JR Z, i_7EFA		 ; 7EE9 28 0F		; Si Z = 1, Salta a i_7EFA
i_7EEB	leay	25,y			; point to next bloc of 25		; i_7EEB: ADD IX, DE		 ; 7EEB DD 19		; Adiciona DE en IX
	sty	<reg_IX			; update pseudoreg
	lda	,y			; get actor ID in bloc			; 	LD A, (IX+$00)		 ; 7EED DD 7E 00	; Carga A con (IX+$00)
	cmpa	#$ff			; is no actor?				; 	CP $FF			 ; 7EF0 FE FF		; Compara A con $FF
	bne	i_7EEB			; no, loop back for another		; 	JR NZ, i_7EEB		 ; 7EF2 20 F7		; Si Z = 0, Salta a i_7EEB
	clr	,y			; clear block ID			; 	LD (IX+$00), $00	 ; 7EF4 DD 36 00 00	; Carga (IX+$00) con $00
	dec	<reg_B			; decrement counter			; 	DJNZ i_7EEB		 ; 7EF8 10 F1		; Decrementa B y si no es cero vuelve a i_7EEB
	bne	i_7EEB			; if not done, loopback
	andcc	#%11111011		; reset zero flag
i_7EFA	tfr	cc,b			; save flags				; i_7EFA: POP DE		 ; 7EFA D1		; Recupera DE
	puls	u,y			; restore registers			; 	POP IX			 ; 7EFB DD E1		; Recupera IX
	sty	<reg_IX			; update				; 	POP BC			 ; 7EFD C1		; Recupera BC
	stu	<reg_BC			; them					;
	tfr	b,cc			; restore flags				; 
	rts				; return				; 	RET			 ; 7EFE C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; recorre las 8 entradas de datos en UserTokenizedCommands de 25 en 25 buscando el que contenga al ActionActor
										; 							; devuelve Z=1 si encontrado, o bien Z=0 en caso contrario ; antes ; (#158# --)
PointActorIn8x25								; PointActorIn8x25:					; si encontrado adems HL apunta a inicio del bloque de 25, sin apunta fuera de la zona
	ldx	#UserTokenizedCommands	; point to table			; 	LD HL, UserTokenizedCommands
										; 				 ; 7EFF 21 38 B7	; apunta a 1a entrada del bloque de 8x25 bytes UserTokenizedCommands
										; 	LD DE, $0019		 ; 7F02 11 19 00	; longitud de 1 bloque
	lda	ActionActor		; get actor ID				; 	LD A, (ActionActor)	 ; 7F05 3A EA B6	; carga ActionActor
	ldb	#8			; number of blocks			; 	LD B, $08		 ; 7F08 06 08		; hay 8 entradas
i_7F0A	cmpa	,x			; is actor there?			; i_7F0A: CP (HL)		 ; 7F0A BE		; es ActionActor = primer byte del bloque actual?
	beq	e7F0A			; yes, exit				; 	RET Z			 ; 7F0B C8		; si, retorna con Z=1
	leax	25,x			; point to next block			; 	ADD HL, DE		 ; 7F0C 19		; pasa al siguiente bloque
	decb				; decrement counter
	bne	i_7F0A			; not yet done, loopback		; 	DJNZ i_7F0A		 ; 7F0D 10 FB		; decrementa contador, si no es cero va a comparar el siguiente bloque
	andcc	#%11111011		; set Z=0
e7F0A	rts				; return				; 	RET			 ; 7F0F C9		; retorna con Z=0
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
FindActorIn8x25									; FindActorIn8x25:					; devuelve resultado (Z) de PointActorIn8x25 preserva registros ; antes ; (#223# --)
	pshs	x			; save registerX			; 	PUSH HL			 ; 7F10 E5		; Guarda HL
	ldu	<reg_DE			; get pseudo-registers
	ldy	<reg_BC								; 	PUSH DE			 ; 7F11 D5		; Guarda DE
	pshs	y,u			; save them				; 	PUSH BC			 ; 7F12 C5		; Guarda BC
	jsr	PointActorIn8x25	; search actor				; 	CALL PointActorIn8x25	 ; 7F13 CD FF 7E	; llama PointActorIn8x25
	tfr	cc,b			; save flags
	puls	y,u			; retore registers
	sty	<reg_BC			; update them				; 	POP BC			 ; 7F16 C1		; Recupera BC
	stu	<reg_DE								; 	POP DE			 ; 7F17 D1		; Recupera DE
	puls	x			; restore X				; 	POP HL			 ; 7F18 E1		; Recupera HL
	tfr	b,cc			; restore flags
	rts				; return				; 	RET			 ; 7F19 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;###NoName11:						; (#224# --) Busca entrada del personaje actual en los bloques de 25
										; 							; Intenta ejecutarla y si puede devuelve Z=0. 
										; 							; Si no puede por alguna razn devuelve Z=1 y HL apuntando al 2 byte de la entrada 
										; 							; para que la intente ejecutar la rutina de scripts (si se ha llamado desde ah).
L_7F1A	ldu	<reg_IX			; get pseudo-registers			; L_7F1A: PUSH IX		 ; 7F1A DD E5		; Guarda IX
	ldy	<reg_IY
	pshs	y,u			; save them				; 	PUSH IY			 ; 7F1C FD E5		; Guarda IY
	ldu	<reg_BC			; get pseudo-registers			; 	PUSH BC			 ; 7F1E C5		; Guarda BC
	ldy	<reg_DE								; 	PUSH DE			 ; 7F1F D5		; Guarda DE
	pshs	x,y,u			; save them				; 	PUSH HL			 ; 7F20 E5		; Guarda HL
	sta	<reg_C			; copy regA to regC			; 	LD C, A			 ; 7F21 4F		; guarda personaje en C
										; 							; Obtenemos puntero al registro en 8x25, ponemos a 0 el primer byte e incrementamos puntero
	jsr	PointActorIn8x25	; search for actor			; 	CALL PointActorIn8x25	 ; 7F22 CD FF 7E	; llama PointActorIn8x25
	clra				; put value 0				; 	LD (HL), $00		 ; 7F25 36 00		; borra el cdigo de personaje en el 1er byte del bloque
	sta	,x+			; to the actor code in the block	; 	INC HL			 ; 7F27 23		; apunta al segundo byte del bloque de 25
					; point to next byte			; 	XOR A			 ; 7F28 AF		; borra A
	tst	<reg_C			; was received regA zero?		; 	CP C			 ; 7F29 B9		; era Bilbo el personaje recibido?
	bne	i_7F37			; no, go i_7F37				; 	JR NZ, i_7F37		 ; 7F2A 20 0B		; no, salta a i_7F37
	ora	#1			; set bit 0 in regA			; 	OR $01			 ; 7F2C F6 01		; Hace OR lgico de A con $01
	tfr	cc,b			; save flags
	ldu	,s			; get stacked address
	exg	u,x			; interchange with X(HL)
	stu	,s			; put old X(HL) value on top of stack	; 	EX (SP), HL		 ; 7F2E E3		; intercambia contenido apuntado por 1er parmetro del stack con HL actual
	tfr	b,cc			; restore flags
i_7F2F	tfr	cc,b			; save flags
	puls	x,y,u			; restore registers			; i_7F2F: POP HL		 ; 7F2F E1		; Recupera HL del stack
	sty	<reg_DE			; update them				; 	POP DE			 ; 7F30 D1		; Recupera DE
	stu	<reg_BC								; 	POP BC			 ; 7F31 C1		; Recupera BC
	puls	y,u			; restore pseudo-registers
	sty	<reg_IY			; update them				; 	POP IY			 ; 7F32 FD E1		; Recupera IY
	stu	<reg_IX								; 	POP IX			 ; 7F34 DD E1		; Recupera IX
	tfr	b,cc			; restore flags
	rts				; return				; 	RET			 ; 7F36 C9		; Retorna
										; 							; el personaje NO era Bilbo
i_7F37										; i_7F37: PUSH HL		 ; 7F37 E5		; pasa puntero a 2 byte del bloque de 25 donde estaba el cdigo de este personaje
	stx	<reg_IY			; copy X(HL) to reg_IY			; 	POP IY			 ; 7F38 FD E1		; a IY
	lda	#1			; put value 1				; 	LD A, $01		 ; 7F3A 3E 01		; pone valor $01
	sta	L_B71B			; in L_B71B				; 	LD (L_B71B), A		 ; 7F3C 32 1B B7	; en L_B71B
	lda	L_B71C			; get L_B71C				; 	LD A, (L_B71C)		 ; 7F3F 3A 1C B7	; recupera valor de L_B71C
	pshs	a,cc			; save it and flags			; 	PUSH AF			 ; 7F42 F5		; lo guarda junto con los flags
	jsr	AnalyzeUserCommand	; analyze command			; 	CALL AnalyzeUserCommand	 ; 7F43 CD B6 79	; llama AnalyzeUserCommand
	jsr	do_exAF_AF		; interchange AF with mirrors		; 	EX AF, AF'		 ; 7F46 08		; guarda AF en AF'
	clra				; put value zero			; 	XOR A			 ; 7F47 AF		; pone valor 0
	sta	L_B71B			; in L_B71B				; 	LD (L_B71B), A		 ; 7F48 32 1B B7	; en L_B71B
	puls	a,cc			; restore register, flags		; 	POP AF			 ; 7F4B F1		; Recupera AF
	sta	L_B71C			; restore value in L_B71C		; 	LD (L_B71C), A		 ; 7F4C 32 1C B7	; y lo devuelve a L_B71C
	jsr	do_exAF_AF		; interchange AF with mirrors		; 	EX AF, AF'		 ; 7F4F 08		; recupera AF de AF'
										; 							; Si AnalyzeUserCommand devolvi Z=0 llama a ExecuteGetB6fb 
										; 							; y si ste retorna Z=0 recupera registros
										; 							; y retorna con Z=0 (EXITO)
	beq	i_7F57			; if Z was 1, go i_7F57			; 	JR Z, i_7F57		 ; 7F50 28 05		; Si flag Z = 1, Salta a i_7F57
	jsr	ExecuteGetB6fb		; execute command			; 	CALL ExecuteGetB6fb	 ; 7F52 CD ED 7A	; llama ExecuteGetB6fb
	bne	i_7F2F			; if Z=0 goback i_7F2F			; 	JR NZ, i_7F2F		 ; 7F55 20 D8		; Si Z = 0, Salta a i_7F2F
										; 							; Si AnalyzeUserCommand devolvi Z=1 o ExecuteGetB6fb devolvi Z=1
										; 							; Llama a FreeActorEntries, pone Z=1 y recupera registros y retorna (FRACASO)
i_7F57	lda	ActionActor		; get actor				; i_7F57: LD A, (ActionActor)	 ; 7F57 3A EA B6	; Carga ActionActor
	jsr	FreeActorEntries	; free related entries			; 	CALL FreeActorEntries	 ; 7F5A CD 60 7F	; llama FreeActorEntries
	clra				; set Z=1				; 	XOR A			 ; 7F5D AF		; borra A, flag Z = 1
	bra	i_7F2F			; goback i_7F2F				; 	JR i_7F2F		 ; 7F5E 18 CF		; Sale via i_7F2F
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Busca entre las 8 entradas de la tabla 8x25 y marca como libres con $00
FreeActorEntries								; FreeActorEntries:					; todas las que coinciden con el ActionActor recibido en 'A' ; antes ; (#159# --)
	pshs	x			; save regX				; 	PUSH HL			 ; 7F60 E5		; Guarda HL
										; 	PUSH DE			 ; 7F61 D5		; Guarda DE
										; 	PUSH BC			 ; 7F62 C5		; Guarda BC
	ldx	#UserTokenizedCommands	; point to table			; 	LD HL, UserTokenizedCommands
										; 				 ; 7F63 21 38 B7	; apunta a inicio de bloques 8x25 UserTokenizedCommands
										; 	LD DE, $0019		 ; 7F66 11 19 00	; longitud de bloque
	ldb	#8			; number of blocks			; 	LD B, $08		 ; 7F69 06 08		; contador (numero de entradas)
i_7F6B	cmpa	,x			; is action in this block?		; i_7F6B: CP (HL)		 ; 7F6B BE		; primer byte del bloque es igual al ActionActor?
	bne	i_7F70			; no, skip next				; 	JR NZ, i_7F70		 ; 7F6C 20 02		; no, salta siguiente instruccin
	clr	,x			; clear actor ID in this block		; 	LD (HL), $00		 ; 7F6E 36 00		; si, pone $00 en cabecera bloque = no utilizado (libre)
i_7F70	leax	25,x			; point to next block			; i_7F70: ADD HL, DE		 ; 7F70 19		; apunta al siguiente bloque
	decb				; decrement counter			; 	DJNZ i_7F6B		 ; 7F71 10 F8		; Decrementa contador y si no es cero mira la siguiente entrada
	bne	i_7F6B			; not yet done, loopback		; 	POP BC			 ; 7F73 C1		; Recupera BC
										; 	POP DE			 ; 7F74 D1		; Recupera DE
	puls	x,pc			; restore regX and return			; 	POP HL			 ; 7F75 E1		; Recupera HL
										; 	RET			 ; 7F76 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#215# --)
L_7F78	pshs	a,cc			; guardar registro y flags		;L_7F78: PUSH AF		 ; 7F78 F5		; Guarda AF
	lda	L_B707			; flag mostrar grficos o no		;	LD A, (L_B707)		 ; 7F79 3A 07 B7	; Carga A con (L_B707)
	beq	e7F78			; si es 0 no mostrarlos			;	AND A			 ; 7F7C A7		; A = A AND A	; Adecua flags
										;							; Se pinta el Grfico de la Localizacin	
	jmp	DrawLocGfx		; ir a cargar pantalla			;	JR NZ, DrawLocGfx	 ; 7F7D 20 07		; Si Z = 0, Salta a DrawLocGfx
e7F78	lda	#$FF			; pone valor $FF			;	LD A, $FF		 ; 7F7F 3E FF		; Carga A con $FF
	sta	L_7F77			; en L_7F77 (ninguna pantalla)		;	LD (L_7F77), A		 ; 7F81 32 77 7F	; Carga (L_7F77) con A
	puls	a,cc,pc			; restuara registros y retorna		;	POP AF			 ; 7F84 F1		; Recupera AF
										;	RET			 ; 7F85 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DrawLocGfx									;DrawLocGfx: 						; Dibuja el grfico de la Localizacin
	lda	1,s			; recupera cdigo localizacin		;	POP AF		 	 ; 7F86 F1		; Recupera AF
	pshs	x			; guarda registro de trabajo		;	PUSH AF			 ; 7F87 F5		; Guarda AF
	ldx	#GFX_TABL		; apunta a tabla locs. con pantalla
DLG00	ldb	,x+			; toma primera
	cmpb	3,s			; es la actual?
	beq	DLG01			; si, sigue en DLG01
	cmpb	#$ff			; es fin de tabla?
	bne	DLG00			; no, mirar siguiente			;	PUSH HL			 ; 7F88 E5		; Guarda HL
	stb	L_7F77			; mark NO screen to load
	bra	DLG02			; si, salir sin hacer nada		;	PUSH BC			 ; 7F89 C5		; Guarda BC
DLG01	sta	L_7F77			; lo guarda en L_7F77			;	PUSH DE			 ; 7F8A D5		; Guarda DE
	cmpa	#$05			; es la localizacin 05?		;	PUSH IX			 ; 7F8B DD E5		; Guarda IX
	bne	draw01			; no, salta a draw01			
										;	LD IX, GFX_TABL		 ; 7F8D DD 21 00 CC	; Carga IX con GFX_TABL
	lda	3,s			; recupera localizacin del stack	;	CALL FindPointer	 ; 7F91 CD BD 9D	; Llama a FindPointer
	ldb	trlClr			; get flag day-night (day=$ff)		;	LD ($7F77), A		 ; 7F94 32 77 7F	; Carga ($7F77) con A
	bmi	draw01			; si bit 7 est a 1, salta siguiente	;	LD L, (IX+$01)		 ; 7F97 DD 6E 01	; Carga L con (IX+$01)
	ora	#$80			; $05 pasa a $85 (est oscuro!)		;	LD H, (IX+$02)		 ; 7F9A DD 66 02	; Carga H con (IX+$02)
draw01	jsr	convHexa		; convertir A en dos digitos hexa (D)	;	CALL NZ, DrawGfx	 ; 7F9D C4 A7 7F	; Si Z = 0, Llama a DrawGfx
	ldx	#NomLoc			; apunta a inicio nombre fichero	;	POP IX			 ; 7FA0 DD E1		; Recupera IX
	std	4,x			; pone numeros hexa en nombre		;	POP DE			 ; 7FA2 D1		; Recupera DE
	stx	FilePtr			; informa fichero a cargar		;	POP BC			 ; 7FA3 C1		; Recupera BC
	jsr	LdFClr			; carga grfico de la localizacin	;	POP HL			 ; 7FA4 E1		; Recupera HL
DLG02	puls	x			; restaura registro			;	POP AF			 ; 7FA5 F1		; Recupera AF
	puls	a,cc,pc			; restaura registros y retorna		;	RET			 ; 7FA6 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; offset 09 tabla L_75D2
										; 							; (#77# OK) en BC llega una 'palabra del diccionario', que es buscada en la tabla
L_8251	ldx	#L_8271			; apunta a L_8271			; L_8251: LD HL, L_8271		 ; 8251 21 71 82	; apunta a inicio de tabla datos L_8271
	ldd	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; 8254 D5		; guarda DE
	pshs	d			; guarda D(DE)				; 
	ldb	#$0D			; pone valor $0D			; 
	stb	<reg_D			; en reg_D				; 	LD D, $0D		 ; 8255 16 0D		; carga 13 en D (contador de entradas en la tabla)
i_8257	ldd	,x+			; toma dos bytes de X(HL)		; i_8257: LD A, (HL)		 ; 8257 7E		; A recibe valor del byte apuntado por HL (byte bajo)
										; 	INC HL			 ; 8258 23		; incrementa HL
	cmpd	<reg_BC			; compara con reg_BC			; 	CP C			 ; 8259 B9		; compara A con C, actualiza flags.
										; 	JR NZ, i_8260		 ; 825A 20 04		; si flag Z=0 (no son iguales) salta a i_8260
										; 	LD A, (HL)		 ; 825C 7E		; A recibe valor del byte apuntado por HL (byte alto)
										; 	CP B			 ; 825D B8		; compara A con B, actualiza flags. Ha comparado (HL)(HL+1) con BC. 
										; 				 ;			; EN 6809 COMPARAREMOS TODO A LA VEZ (BC), o sea los 16 bits de golpe.
	beq	i_8267			; si iguales, salta a i_8267		; 	JR Z, i_8267		 ; 825E 28 07		; si flag Z=1 (son iguales) salta a i_8267
i_8260	leax	1,x			; incrementa puntero			; i_8260: INC HL			 ; 8260 23		; incrementa HL (pasa a siguiente palabra)
	dec	<reg_D			; decrementa contador reg_D		; 	DEC D			 ; 8261 15		; decrementa contador entradas pendientes de revisar
	bne	i_8257			; si no es 0, vuelve a i_8257		; 	JR NZ, i_8257		 ; 8262 20 F3		; si todava no es cero, comparar BC con siguiente entrada de la tabla
	jmp	ClearAndJmpTable75D2	; salta a ClearAndJmpTable75D2		; 	JP ClearAndJmpTable75D2	 ; 8264 C3 A0 75	; NO encontrada, salta a ClearAndJmpTable75D2
										; 				 ;			; hemos encontrado la entrada buscada
i_8267										; i_8267: LD DE, $0019		 ; 8267 11 19 00	; carga DE con $19 (el bloque de datos tiene $1A bytes) HL est apuntando al segundo byte
										; 				 ;			; por ello solo hace falta aadir $19 para llegar al punto 'inicial' de la rutina necesaria
										; 	ADD HL, DE		 ; 826A 19		; lo aade a HL, ahora apunta a la direccin de la rutina a ejecutar
										; 	LD E, (HL)		 ; 826B 5E		; carga byte bajo
										; 	INC HL			 ; 826C 23		; incrementa puntero
										; 	LD D, (HL)		 ; 826D 56		; carga byta alto
	ldx	25,x			; apunta a 1er byte siguiente bloque	; 	EX DE, HL		 ; 826E EB		; lo pasa a HL
					; porque ya llega incrementado en 1	; 	
	puls	d			; recupera D(DE)			; 	POP DE			 ; 826F D1		; recupera DE
	std	<reg_DE			; guarda reg_DE				; 
	jmp	,x			; salta a rutina apuntada por X		; 	JP (HL)			 ; 8270 E9		; salta a la rutina encontrada, apuntada por HL
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#60# OK) CHECK_PRINTER
L_82A5	lda	$FF22			; lee puerto impresora			; L_82A5: IN A, ($FB)		 ; 82A5 DB FB		; lee puerto impresora
	anda	#1			; pin BUSY (P1PDRB / PB0)		; 	BIT 6, A		 ; 82A7 CB 77		; comprueba si esta en marcha
	bne	GetB6DEJmpTable75D2	; si es 1 NO est conectada		; 	JR NZ, GetB6DEJmpTable75D2 ; 82A9 20 08		; si flag Z=0, salta a GetB6DEJmpTable75D2
	lda	#1			; habilita Impresin			; 	LD A, $01		 ; 82AB 3E 01		; A = 1 = SI IMPRIMIR
	bra	i_82B0			; salta a i_82B0			; 	JR i_82B0		 ; 82AD 18 01		; salta a i_82B0
										; 
										; 							; (#61# OK) se aade etiqueta
L_82AF	clra				; deshabilita Impresin			; L_82AF: XOR A			 ; 82AF AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
i_82B0	sta	L_B6F2			; guarda estado en L_B6F2		; i_82B0: LD (L_B6F2), A	 ; 82B0 32 F2 B6	; pasa a 0 L_B6F2 = NO IMPRIMIR
										; 
GetB6DEJmpTable75D2								; GetB6DEJmpTable75D2:					; recupera B6DE y pasa a Tabla 75D2 (#21# OK)
	lda	L_B6DE			; recupera L_B6DE			; 	LD A, (L_B6DE)		 ; 82B3 3A DE B6	; A toma el valor de L_B6DE
	sta	<reg_D			; lo guarda en reg_D			; 	LD D, A			 ; 82B6 57		; y lo pasa a byte alto de DE
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 82B7 C3 B4 75	; pasa a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#58# OK)
L_82BA	lda	L_B719			; recupera L_B719			; L_82BA: LD A, (L_B719)	 ; 82BA 3A 19 B7	; carga A con el valor de L_B719
	cmpa	#1			; es 1?					; 	CP $01			 ; 82BD FE 01		; es A > 1?
	lbne	L_7929			; no, salta a L_7929			; 	JP NZ, L_7929		 ; 82BF C2 29 79	; si, salta a L_7929
	lda	#2			; pone valor 2				; 	LD A, $02		 ; 82C2 3E 02		; pone valor 2
	sta	L_B719			; en L_B719				; 	LD (L_B719), A		 ; 82C4 32 19 B7	; en L_B719
	ldy	<reg_IY			; recupera reg_IY
	lda	,y			; recupera (Y+0)     			; 	LD A, (IY+$01)		 ; 82C7 FD 7E 01	; A recibe valor del byte apuntado por IY+1
	ora	#$80			; pone bit7 a 1				; 	OR $80			 ; 82CA F6 80		; pone a 1 el bit7
	sta	,y			; lo guarda en (Y+0) 			; 	LD (IY+$01), A		 ; 82CC FD 77 01	; guarda el valor modificado en IY+1
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 82CF C3 B4 75	; pasa a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#57# OK) se aade la etiqueta
L_82D2	lda	L_B719			; recupera L_B719			; L_82D2: LD A, (L_B719)	 ; 82D2 3A 19 B7	; carga A con el valor de L_B719 
	cmpa	#2			; es 2?					; 	CP $02			 ; 82D5 FE 02		; es A = 2?
	lbeq	JmpTable75D2		; si, salta a JmpTable75D2		; 	JP Z, JmpTable75D2	 ; 82D7 CA B4 75	; si flag Z=1, pasa a JmpTable75D2
	lda	#1			; pone valor 1				; 	LD A, $01		 ; 82DA 3E 01		; pone valor 1 
	sta	L_B719			; en L_B719				; 	LD (L_B719), A		 ; 82DC 32 19 B7	; en L_B719
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 82DF C3 B4 75	; pasa a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#59# OK) se aade la etiqueta
L_82E2	ldu	<reg_DE			; recupera reg_DE
	pshs	u			; lo guarda				; L_82E2: PUSH DE		 ; 82E2 D5		; guarda DE
	ldx	#L_B6E0			; direccin origen datos		; 	LD HL, L_B6E0		 ; 82E3 21 E0 B6	; HL apunta a L_B6E0
	ldu	#L_757F			; destino donde copiarlos		; 	LD DE, L_757F		 ; 82E6 11 7F 75	; DE apunta a L_757F
	ldb	#6			; numero de bytes a copiar		; 	LD BC, $0006		 ; 82E9 01 06 00	; contador a 6
	jsr	do_ldir			; hacer la copia				; 	LDIR			 ; 82EC ED B0		; (DE+)=(HL+);BC-	; copia $6 bytes de HL en DE
	puls	u			; recupera U				; 	POP DE			 ; 82EE D1		; recupera DE
	tst	<reg_E			; es negativo reg_E?			; 	BIT 7, E		 ; 82EF CB 7B		; tiene a 1 el bit7 E?
	jsr	L_82F7			; llama L_82F7				; 	CALL L_82F7		 ; 82F1 CD F7 82	; llama rutina L_82F7 (#115# OK)
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 82F4 C3 B4 75	; pasa a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#115# OK)
L_82F7	lbpl	L_7838			; no es negativo, salta a L_7838	; L_82F7: JP Z, L_7838		 ; 82F7 CA 38 78	; si flag Z=1, salta a L_7838
	jmp	L_7850			; salta a L_7850			; 	JP L_7850		 ; 82FA C3 50 78	; salta a L_7850 (#114# OK)   
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
i_82FD	lda	<reg_D			; pasa reg_D				;i_82FD: LD A, D		 ; 82FD 7A		; Carga A con D
	sta	L_824F			; a L_824F				;	LD (L_824F), A		 ; 82FE 32 4F 82	; Carga (L_824F) con A
	ldu	<reg_DE			; recupera reg_DE			;	PUSH DE			 ; 8301 D5		; Guarda DE
	pshs	u			; guarda U(DE)
	ldu	<reg_BC			; recupera reg_BC			;	PUSH BC			 ; 8302 C5		; Guarda BC
	pshs	u			; guarda U(BC)
	ldy	<reg_IY			; recupera reg_IY			;	PUSH IY			 ; 8303 FD E5		; Guarda IY
	pshs	y			; guarda Y(IY)
	lda	L_B706			; copia L_B706				;	LD A, (L_B706)		 ; 8305 3A 06 B7	; Carga A con (L_B706)
	sta	L_8250			; en L_8250				;	LD (L_8250), A		 ; 8308 32 50 82	; Carga (L_8250) con A
	ldd	#$FFE8			; toma valor $FFE8 (-24)		;	LD DE, $FFE8		 ; 830B 11 E8 FF	; Carga DE con $FFE8
	std	<reg_DE			; lo guarda en reg_DE
	leay	d,y			; lo suma en Y(IY)			;	ADD IY, DE		 ; 830E FD 19		; Adiciona DE en IY
	sty	<reg_IY			; update pseudoreg
	lda	#1			; toma valor 1				;	LD A, $01		 ; 8310 3E 01		; Carga A con $01
	jmp	L_758A			; salta a L_758A			; 	JP L_758A		 ; 8312 C3 8A 75	; Salta a L_758A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; parametro IY apunta a L_B9E0 (LOCTABLE) que est 1 byte despus del final del bloque 
										; 							;              de 24 bytes con direccin inicial L_B9C8
CopyIYTo8x25									; CopyIYTo8x25:						; Copia IY a bloque de 25 bytes (#56# --)
	lda	L_B71B			; recupera L_B71B			; 	LD A, (L_B71B)		 ; 8315 3A 1B B7	; recupera L_B71B
										; 	AND A			 ; 8318 A7		; es 0?
	beq	i_82FD			; si es 0, salta  a i_82FD		; 	JR Z, i_82FD		 ; 8319 28 E2		; si, sale hacia i_82FD
	deca				; decrementa A				; 	DEC A			 ; 831B 3D		; no, decrementa A
	sta	L_B71B			; lo guarda en L_B71B			; 	LD (L_B71B), A		 ; 831C 32 1B B7	; actualiza L_B71B
	ldb	L_8250			; recupera L_8250			; 	LD A, (L_8250)		 ; 831F 3A 50 82	; recupera L_8250
	stb	<reg_B			; lo guarda en reg_B			; 	LD B, A			 ; 8322 47		; lo guarda en B
	lda	L_B706			; recupera L_B706			; 	LD A, (L_B706)		 ; 8323 3A 06 B7	; recupera L_B706
	clr	<reg_C			; pone reg_C a 0			; 	SUB B			 ; 8326 90		; le resta L_8250 (calcula nmero de bloques a copiar)
	suba	L_8250			; resta L_8250 de A			; 	AND A			 ; 8327 A7		; adecua flags
										; 	LD C, $00		 ; 8328 0E 00		; pone contador C a $00
	beq	i_8378			; si da 0, salta a i_8378 (iguales)	; 	JR Z, i_8378		 ; 832A 28 4C		; Si la resta es 0 (L_8250 == L_B706), sale via i_8378 (nada que copiar)
	ldy	,s			; toma Y del stack sin afectar puntero	; 	POP IY			 ; 832C FD E1		; Recupera IY
										; 	PUSH IY			 ; 832E FD E5		; lo vuelve a guardar
	leay	-24,y			; le resta 24				; 	LD DE, $FFE8		 ; 8330 11 E8 FF	; carga DE con -24 (Offset entre bloques, hacia atrs)
	sty	<reg_IY			; lo guarda en reg_IY			; 	ADD IY, DE		 ; 8333 FD 19		; IY apunta 24 bytes mas atrs (a L_B9C8)
	sta	<reg_B			; guarda A en reg_B			; 	LD B, A			 ; 8335 47		; guarda el resultado de (L_B706 - L_8250) en B (comandos/lineas a copiar)
i_8336	ldu	#UserTokenizedCommands	; U(IX) apunta a UserTokenizedCommands	; i_8336: LD IX, UserTokenizedCommands
										; 				 ; 8336 DD 21 38 B7	; apunta a UserTokenizedCommands (inicio del rea de 8x25 bytes)
										; 	PUSH DE			 ; 833A D5		; Guarda DE (-24)
										; 	PUSH BC			 ; 833B C5		; Guarda BC
										; 	LD DE, $0019		 ; 833C 11 19 00	; longitud de bloque = 25
	ldb	#8			; numero de bloques a buscar		; 	LD B, $08		 ; 833F 06 08		; nmero de bloques a revisar
i_8341	lda	,u			; recupera ID del bloque		; i_8341: LD A, (IX+$00)	 ; 8341 DD 7E 00	; recupera ID del bloque apuntado
										; 	AND A			 ; 8344 A7		; es 0 (est libre)?
	beq	i_834B			; si 0, salta a i_834B			; 	JR Z, i_834B		 ; 8345 28 04		; si, salta a i_834B (ya encontramos uno libre!)
	leau	25,u			; suma 25, apunta al siguiente bloque	; 	ADD IX, DE		 ; 8347 DD 19		; apunta al siguiente bloque
	decb				; decrementa contador
	bne	i_8341			; si no es cero, vuelve a i_8341	; 	DJNZ i_8341		 ; 8349 10 F6		; decrementa contador y si todava quedan bloques, mira el siguiente
	andcc	#$11111011	;20-3-15; fuerza flag Z=0 (no es cero)
i_834B	pshs	cc			; guarda flags
	ldb	#$FF			; pone $FF				; i_834B: LD (IX+$00), $FF	 ; 834B DD 36 00 FF	; pone ID = $FF en el bloque
	stb	,u+			; en el ID del bloque			; 	INC IX			 ; 834F DD 23		; apunta al primer byte de datos del bloque
					; e incrementa puntero			; 	POP BC			 ; 8351 C1		; Recupera BC
	puls    cc			; recupera flags			; 	POP DE			 ; 8352 D1		; Recupera DE (-24)
	bne	i_8378			; si flag Z=0, salta a i_8378 		; 	JR NZ, i_8378		 ; 8353 20 23		; si no encontr un bloque libre, sale via i_8378
e_834B	ldb	,y			; recupera (IY)
	andb	#%01000000		; est el bit6 a 1?			; 	BIT 6, (IY+$01)		 ; 8355 FD CB 01 76	; Est a 1 el bit 6 de (IY+$01)? es el byte alto de la primera palabra
	beq	i_8361			; no, salta a i_8361			; 	JR Z, i_8361		 ; 8359 28 06		; no, salta a i_8361
	clr	-1,u			; pone a 0 el ID			; 	LD (IX-$01), $00	 ; 835B DD 36 FF 00	; si, pone a 0 el ID del bloque apuntado (machacando el $FF anterior)
	bra	i_8373			; salta a i_8373			; 	JR i_8373		 ; 835F 18 12		; salta a i_8373 - NO copia nada y deja el bloque 'libre' e IY sin modificar
i_8361										; i_8361: PUSH BC		 ; 8361 C5		; Guarda BC
	ldb	#24			; 24 bytes de datos a copiar		; 	LD B, $18		 ; 8362 06 18		; longitud datos es 24 bytes
i_8364	lda	,y+			; toma 1 byte origen			; i_8364: LD A, (IY+$00)	 ; 8364 FD 7E 00	; copia datos apuntados por IY
	sta	,u+			; copia en destino			; 	LD (IX+$00), A		 ; 8367 DD 77 00	; en los 24 bytes del bloque elegido
										; 	INC IY			 ; 836A FD 23		; Incrementa IY
	decb				; decrementa contador			; 	INC IX			 ; 836C DD 23		; Incrementa IX
	bne	i_8364			; si no es 0, vuelve a i_8364		; 	DJNZ i_8364		 ; 836E 10 F4		; Decrementa contador B y si no es cero vuelve a i_8364 
										; 	POP BC			 ; 8370 C1		; Recupera BC
	leay	-24,y			; le resta 24 para recuperar valor	; 	ADD IY, DE		 ; 8371 FD 19		; le resta 24 al puntero IY (los avanzados) mas los prximos 24, por lo que
										; 							; IY acabar 24 bytes antes del valor que tena antes de copiar este bloque
i_8373	leay	-24,y			; le resta 24 (apunta a anterior)	; i_8373: ADD IY, DE		 ; 8373 FD 19		; le resta 24 al puntero IY (pasa al bloque de 24 bytes anterior)
	inc	<reg_C			; incrementa reg_C			; 	INC C			 ; 8375 0C		; incrementa contador C (lneas llenadas)
	dec	<reg_B			; decrementa reg_B
	bne	i_8336			; si no es 0, vuelve a i_8336		; 	DJNZ i_8336		 ; 8376 10 BE		; Decrementa B y si no es cero vuelve a i_8336 (B es el resultado anterior de L_B706 - L_8250)
										; 							; por este procedimiento, IY apunta cada vez 24 bytes mas atrs:
										; 							; tras el primer paso apunta a L_B980 que es un bloque de 8+10+6 bytes = 24 bytes (tambin)
										; 							; pero tras el segundo se mete dentro del rea NO referenciada L_B800 que es mltiplo
										; 							; de 24 bytes (18 bloques exactamente), curioso, no?
i_8378	clra				; pone 0				; i_8378: XOR A			 ; 8378 AF		; pone 0
	sta	L_B719			; en L_B719				; 	LD (L_B719), A		 ; 8379 32 19 B7	; en L_B719
	lda	<reg_C			; recupera reg_C			; 	LD A, C			 ; 837C 79		; guarda contador C (numero de bloques copiados)
	sta	L_B737			; lo guarda en L_B737			; 	LD (L_B737), A		 ; 837D 32 37 B7	; en L_B737
	puls	y			; recupera Y				; 	POP IY			 ; 8380 FD E1		; Recupera IY (L_B9E0 era su valor al entrar en CopyIYTo8x25)
	sty	<reg_IY			; lo guarda en reg_IY
	lda	L_8250			; recupera L_8250			; 	LD A, (L_8250)		 ; 8382 3A 50 82	; copia L_8250
	sta	L_B706			; lo pasa a L_B706			; 	LD (L_B706), A		 ; 8385 32 06 B7	; en L_B706 - para indicar que NO hay bloques pendientes de procesar
	puls	u			; recupera U
	stu	<reg_BC			; lo guarda en reg_BC			; 	POP BC			 ; 8388 C1		; Recupera BC
	puls	u			; recupera U
	stu	<reg_DE			; lo guarda en reg_DE			; 	POP DE			 ; 8389 D1		; Recupera DE
	lda	L_824F			; recupera L_824F			; 	LD A, (L_824F)		 ; 838A 3A 4F 82	; pasa L_824F
	sta	<reg_D			; lo pasa a reg_D			; 	LD D, A			 ; 838D 57		; a D
	jmp	JmpTable75D2		; salta a JmpTable75D2			; 	JP JmpTable75D2		 ; 838E C3 B4 75	; salta a JmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#64# OK)
L_8391	jsr	L_83F5			; llama a L_83F5			; L_8391: CALL L_83F5		 ; 8391 CD F5 83	; llama rutina L_83F5 (#105# OK)
i_8394	jsr	ReadKey			; lee teclado				; i_8394: XOR A			 ; 8394 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	beq	i_8394			; si ninguna tecla, sigue leyendo	; 	IN A, ($FE)		 ; 8395 DB FE		; lee teclado (Shift-Z-X-C-V)
	cmpa	#3			; Break pulsado?			; 	AND $1F			 ; 8397 E6 1F		; guarda los 5 bits bajos (uno por tecla)
	lbeq	OutToB			; si, salir al Basic			; 	CP $1F			 ; 8399 FE 1F		; compara con todo unos
										; 	JR Z, i_8394		 ; 839B 28 F7		; si iguales, ninguna tecla pulsada, vuelve a i_8394
	jmp	ReStart			; salta a ReStart			; 	JP ReStart		 ; 839D C3 27 6C	; salta a ReStart
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#65# OK)
L_83A0	lda	ActionActor		; recupera ActionActor			; L_83A0: LD A, (ActionActor)	 ; 83A0 3A EA B6	; carga ActionActor
										; 	AND A			 ; 83A3 A7		; A = A AND A	; Adecua flags
	lbne	JmpTable75D2		; si no es Bilbo salta a JmpTable75D2	; 	JP NZ, JmpTable75D2	 ; 83A4 C2 B4 75	; si no es cero, pasa a JmpTable75D2
	ldy	<reg_IX			; recupera reg_IX			; 	PUSH HL			 ; 83A7 E5		; salva HL
	pshs	x,y			; guarda X(HL) y Y(IX)			; 	PUSH IX			 ; 83A8 DD E5		; salva IX
	ldx	#L_B467			; apunta a L_B467			; 	LD HL, L_B467		 ; 83AA 21 67 B4	; apunta a mensaje "you're doing fine!" (por defecto)
	lda	L_C11B+16		; recupera Localizacin de Bilbo	; 	LD A, (L_C11B+$10)	 ; 83AD 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	ldy	#L_83CD			; apunta a L_83CD (tabla ayuda)		; 	LD IX, L_83CD		 ; 83B0 DD 21 CD 83	; apunta a la tabla Mensajes de Ayuda (Help Messages)
	sty	<reg_IX			; lo guarda en reg_IX
	jsr	FindPointer		; llama FindPointer			; 	CALL FindPointer	 ; 83B4 CD BD 9D	; busca puntero con cdigo A e inicio tabla en IX
	beq	i_83BF			; si da 0, salta a i_83BF		; 	JR Z, i_83BF		 ; 83B7 28 06		; si flag de cero, salta dos istrucciones (no recupera puntero)
	ldx	1,y			; recupera puntero encontrado		; 	LD L, (IX+$01)		 ; 83B9 DD 6E 01	; toma byte bajo del puntero
										; 	LD H, (IX+$02)		 ; 83BC DD 66 02	; toma el byte alto
i_83BF	lda	#1			; pone 1 (imprimir abajo)		; i_83BF: LD A, $01		 ; 83BF 3E 01		; pone 1
	sta	PrintAreaFlag		; en PrintAreaFlag			; 	LD (PrintAreaFlag), A	 ; 83C1 32 01 B7	; en PrintAreaFlag - indica Abajo
	jsr	PrintMsg		; llama PritMsg				; 	CALL PrintMsg		 ; 83C4 CD DD 72	; llama rutina imprimir texto apuntado por HL - PrintMsg 
	puls	x,y			; recupera registros			; 	POP IX			 ; 83C7 DD E1		; recupera IX
	sty	<reg_IX			; guarda Y en reg_IX			; 	POP HL			 ; 83C9 E1		; recupera HL
	jmp	GetB6DEJmpTable75D2	; salta a GetB6DEJmpTable75D2		; 	JP GetB6DEJmpTable75D2	 ; 83CA C3 B3 82	; pasa a GetB6DEJmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#66# OK) se aade la etiqueta
L_83EF	jsr	L_83F5			; llama a L_83F5			; L_83EF: CALL L_83F5		 ; 83EF CD F5 83	; llama rutina L_83F5 (#105# OK)
	jmp	GetB6DEJmpTable75D2	; salta a GetB6DEJmpTable75D2		; 	JP GetB6DEJmpTable75D2	 ; 83F2 C3 B3 82	; salta a GetB6DEJmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#105# OK)
L_83F5	ldu	<reg_DE			; recupera reg_DE			; L_83F5: PUSH HL		 ; 83F5 E5		; guarda HL
	pshs	x,u			; guarda registros			; 	PUSH DE			 ; 83F6 D5		; guarda DE
	clra				; pone 0 (imprimir arriba)		; 	XOR A			 ; 83F7 AF		; pone 0
	sta 	PrintAreaFlag		; en PrintAreaFlag			; 	LD (PrintAreaFlag), A	 ; 83F8 32 01 B7	; en PrintAreaFlag - indica Arriba
	ldx	#L_B454			; apunta a L_B454			; 	LD HL, L_B454		 ; 83FB 21 54 B4	; apunta a mensaje "you have mastered [0x16]"
	jsr	PrintMsg		; llama PrintMsg			; 	CALL PrintMsg		 ; 83FE CD DD 72	; llama rutina PrintMsg
	ldx	L_B6F7			; recupera L_B6F7			; 	LD HL, (L_B6F7)		 ; 8401 2A F7 B6	; recupera % aventura hecho. A confirmar (?)
	ldu	#$0064			; toma valor $64 (100)			; 	LD DE, $0064		 ; 8404 11 64 00	; DE=$64 (100 en decimal) carga mximo % posible
	bsr	L_842E			; llama L_842E				; 	CALL L_842E		 ; 8407 CD 2E 84	; llama rutina de calculo (#48# OK)
	beq	e_83F5			; si da 0, salta a e_83F5
	jsr	PutChar			; llama PutChar				; 	CALL NZ, PutChar	 ; 840A C4 8B 85	; si se actualiz A mas de 1 vez, llama la subrutina PutChar
e_83F5	ldu	#$000A			; toma valor 10				; 	LD DE, $000A		 ; 840D 11 0A 00	; DE=$0A (10 decimal) para calculos de decenas
	bsr	L_842E			; llama L_842E				; 	CALL L_842E		 ; 8410 CD 2E 84	; llama rutina de calculo (#48# OK)
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 8413 CD 8B 85	; llama rutina PutChar
	lda	#$2E			; toma valor $2E (punto)		; 	LD A, $2E		 ; 8416 3E 2E		; ASCII para '.'
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 8418 CD 8B 85	; llama rutina PutChar
	stx	<reg_HL			; first save full regX
	lda	<reg_L			; recupera reg_L			; 	LD A, L			 ; 841B 7D		; pasa byte bajo de HL a registro A (cifra calculada)
	adda	#$30			; lo pasa a numero			; 	ADD A, $30		 ; 841C C6 30		; le suma 30 para convertirlo en ASCII
	jsr	PutChar			; llama PutChar				; 	CALL PutChar		 ; 841E CD 8B 85	; llama rutina PutChar
	clra				; pone 0				; 	XOR A			 ; 8421 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	sta	L_B704			; en L_B704				; 	LD (L_B704), A		 ; 8422 32 04 B7	; L_B704
	ldx	#L_B462			; apunta a L_B462			; 	LD HL, L_B462		 ; 8425 21 62 B4	; apunta a mensaje "% of this adventure"
	jsr	PrintMsg		; llama PrintMsg			; 	CALL PrintMsg		 ; 8428 CD DD 72	; llama rutina PrintMsg
	puls	x,u			; recupera registros			; 	POP DE			 ; 842B D1		; recupera DE
	stu	<reg_DE			; guarda U en reg_DE			; 	POP HL			 ; 842C E1		; recupera HL
	rts				; retorna				; 	RET			 ; 842D C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#48# OK) Calcula % de aventura hecho
L_842E	lda	#$2F			; toma valor $2F			; L_842E: LD A, $2F		 ; 842E 3E 2F		; carga $2F (47 decimal)
i_8430	pshs	a,u			; guarda registros A,U
	tfr	x,d			; pasa X(HL) a D
e_8430	inc	,s			; incrementa A en stack			; i_8430: INC A			 ; 8430 3C		; $30 (ASCIII para 0) - contador de veces que se resta DE
										; 	AND A			 ; 8431 A7		; actualiza flags (flag C=0)
	subd	1,s			; le resta U(DE) en stack		; 	SBC HL, DE		 ; 8432 ED 52		; resta DE de HL y 1 si flag C=1
	bcc	e_8430			; si no hay carry, vuelve a e_8430	; 	JR NC, i_8430		 ; 8434 30 FA		; mientras sea positivo, seguir restando
	addd	1,s			; le suma U(DE) lo hace positivo	; 	ADD HL, DE		 ; 8436 19		; le suma DE para recuperar ltimo valor positivo
	tfr	d,x			; pasa resultado a X(HL)
	puls	a,u			; recupera registros
	cmpa	#$30			; se ha restado mas de 1 vez?		; 	CP $30			 ; 8437 FE 30		; solo se ha restado una vez? actualiza flags
	rts				; retorna				; 	RET			 ; 8439 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#67# --) se aade la etiqueta
L_843A										; L_843A: LD A, $04		 ; 843A 3E 04		; Carga A con $04
	bsr	ChangeColor		; change color set to warn PAUSE mode	; 	OUT ($FE), A		 ; 843C D3 FE		; el valor de A se escribe en el puerto $FE (borde = verde oscuro)
	jsr	GetAnyKey		; llama GetAnyKey			; 	CALL GetAnyKey		 ; 843E CD B9 84	; llama rutina GetAnyKey
										; i_8441: XOR A			 ; 8441 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
										; 	IN A, ($FE)		 ; 8442 DB FE		; lee teclado (Shift-Z-X-C-V)
										; 	AND $1F			 ; 8444 E6 1F		; Hace AND lgico de A con $1F
										; 	CP $1F			 ; 8446 FE 1F		; Compara A con $1F
										; 	JR NZ, i_8441		 ; 8448 20 F7		; Si Z = 0, Salta a i_8441
										; 	LD A, $07		 ; 844A 3E 07		; Carga A con $07
 	jsr	ChangeColor		; go back to old color set		; 	OUT ($FE), A		 ; 844C D3 FE		; el valor de A se escribe en el puerto $FE (borde = blanco/gris)
	jmp	GetB6DEJmpTable75D2	; salta a GetB6DEJmpTable75D2		; 	JP GetB6DEJmpTable75D2	 ; 844E C3 B3 82	; salta a GetB6DEJmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ChangeColor
	ldb	>$ff22			; get actual video mode
	eorb	#8			; switch CSS (color set)
	stb	>$ff22			; change to new color set
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; LoadGame					
										; 							; Carga los datos salvados de una partida
										; 							; (#62# OK)
LoadGame									; LoadGame: PUSH IX		 ; 8451 DD E5		; guarda IX
	pshs	d,x,u			; guarda registros			; 	PUSH DE			 ; 8453 D5		; guarda DE
	ldx	#LoadGam+1		; apunta a fichero para cargarlo	; 	LD A, $FF		 ; 8454 3E FF		; carga $FF en A, flag Z=0
	stx	FilePtr			; guarda puntero			; 	SCF			 ; 8456 37		; flag C=1
	jsr	WorkFileName		; mostrar nombre del Fichero		; 	LD IX, DATABLK1		 ; 8457 DD 21 EB B6	; apunta a DATABLK1
	ldx	#LoadGam		; apunta al texto std			; 	LD DE, $001D	 	 ; 845B 11 1D 00	; carga DE con $001D (29) numero bytes a copiar
	stx	FilePtr			; actualiza puntero a fichero		; 	CALL L_8498		 ; 845E CD 98 84	; llama rutina copia de la ROM - L_8498 (#116# OK)
	jsr	LdFileSG		; carga fichero de disco		; 	LD A, $FF		 ; 8461 3E FF		; carga $FF en A, flag Z=0
	ldx	#DATABLK1		; apunta a DATABLK1 (origen)		; 	SCF			 ; 8463 37		; flag C=1
	ldu	#D_C9E2			; apunta a D_C9E2 (destino)		; 	LD IX, OBJ_TABLE	 ; 8464 DD 21 1B C1	; apunta a Tabla de Objetos
	ldb	#3			; numero de bytes a copiar		; 	LD DE, $0615		 ; 8468 11 15 06	; carga DE con $0615 (1557) numero bytes a copiar
	jsr	do_ldir			; hacer la copia			; 	CALL L_8498		 ; 846B CD 98 84	; llama rutina copia de la ROM - L_8498 (#116# OK)
										; 	LD A, $FF		 ; 846E 3E FF		; carga $FF en A, flag Z=0
										; 	SCF			 ; 8470 37		; flag C=1
	ldx	ExitEnabler		; get enable pointer			; 	LD IX, DATABLK3		 ; 8471 DD 21 84 CA	; apunta a DATABLK3
	stx	D_A7CF+2		; put in program code			; 	LD DE, $00BF		 ; 8475 11 BF 00	; carga DE con $00BF (191) numero bytes a copiar
										; 	CALL L_8498		 ; 8478 CD 98 84	; llama rutina copia de la ROM - L_8498 (#116# OK)
										; 	LD A, $FF		 ; 847B 3E FF		; carga $FF en A, flag Z=0
	ldb	#$ff			; value to force			; 	SCF			 ; 847D 37		; flag C=1
	stb	L_B706			; LOOK command				; 	LD IX, LOCATION		 ; 847E DD 21 8A BA	; apunta a tabla localizaciones
										; 	LD DE, $05D9		 ; 8482 11 D9 05	; carga DE con $05D9 (1497) numero bytes a copiar
										; 	CALL L_8498		 ; 8485 CD 98 84	; llama rutina copia de la ROM - L_8498 (#116# OK)
	inc	loaded			; set loaded flag to ONE		; 	DI			 ; 8488 F3		; deshabilita interrupciones
										; 	LD HL, DATABLK1		 ; 8489 21 EB B6	; HL apunta a inicio de DATABLK1

	ldb	oldEB			; get saved value			; 	LD DE, D_C9E2		 ; 848C 11 E2 C9	; DE apunta a D_C9E2
	stb	<$eb			; restore it				; 	CALL L_84B3		 ; 848F CD B3 84	; llama rutina L_84B3 (#117# OK)

										; 	POP DE			 ; 8492 D1		; recupera DE
										; 	POP IX			 ; 8493 DD E1		; recupera IX
	puls	d,x,y,u			; get registers and get rid of RetAdrs	; 	POP IX			 ; 8493 DD E1		; recupera IX
	jmp	wFK01								; 	JP GetB6DEJmpTable75D2	 ; 8495 C3 B3 82	; salta a GetB6DEJmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; NO HACE FALTA				; 							; LD_BLOCK
										; 							; Carga de bloques en memoria
										; 							; Usa rutina carga RomLoad = $0556
										; 							; (#116# OK)
										; L_8498: CALL RomLoad		 ; 8498 CD 56 05	; llama rutina de la ROM en $0556
										; 	RET C			 ; 849B D8		; Retorna si hay Carry = C = 1
										; 							; Tratamiento de errores de Carga
										; 	LD A, $01		 ; 849C 3E 01		; pone $01
										; 	LD (PrintAreaFlag), A	 ; 849E 32 01 B7	; en PrintAreaFlag - indica Abajo
										; 	LD HL, L_B357		 ; 84A1 21 57 B3	; apunta a mensaje "tape error -     hit any key to restart program[0x15]"
										; 	CALL PrintMsg		 ; 84A4 CD DD 72	; Imprime mensaje - PrintMsg
										; i_84A7: XOR A			 ; 84A7 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
										; 	IN A, ($FE)		 ; 84A8 DB FE		; lee teclado (Shift-Z-X-C-V)
										; 	AND $1F			 ; 84AA E6 1F		; Hace AND lgico de A con $1F
										; 	CP $1F			 ; 84AC FE 1F		; Compara A con $1F
										; 	JR Z, i_84A7		 ; 84AE 28 F7		; Si Z = 1, Salta a i_84A7
										; 	JP ReStart		 ; 84B0 C3 27 6C	; Salta a ReStart
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; NO HACE FALTA				; 							; (#117# OK)
										; L_84B3: LD BC, $0003		 ; 84B3 01 03 00	; contador a 3
										; 	LDIR			 ; 84B6 ED B0		; (DE+)=(HL+);BC-	; copia $3 bytes de HL en DE
										; 	RET			 ; 84B8 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; revisa que no est presionada ninguna tecla y luego espera por una tecla
										; 							; (# sinNumero)
GetAnyKey				; espera teclado libre			; GetAnyKey: XOR A		 ; 84B9 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	jsr	ReadKey			; lee teclado				; 	IN A, ($FE)		 ; 84BA DB FE		; lee teclado (Shift-Z-X-C-V)
	bne	GetAnyKey		; si hay tecla pulsada, vuelve a leer	; 	AND $1F			 ; 84BC E6 1F		; Se queda con los 5 Bit Bajos
										; 	CP $1F			 ; 84BE FE 1F		; Los compara para ver si hay teclas
										; 	JR NZ, GetAnyKey	 ; 84C0 20 F7		; Si hay tecla Presionada repetir
					; espera una tecla pulsada		; 							; espera por una tecla
i_84C2	jsr	ReadKey			; lee teclado				; i_84C2: XOR A			 ; 84C2 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	beq	i_84C2			; si no hay tecla, vuelve a leer	; 	IN A, ($FE)		 ; 84C3 DB FE		; lee teclado (Shift-Z-X-C-V)
										; 	AND $1F			 ; 84C5 E6 1F		; Se queda con los 5 Bit Bajos
										; 	CP $1F			 ; 84C7 FE 1F		; Los compara para ver si hay teclas
										; 	JR Z, i_84C2		 ; 84C9 28 F7		; Si no hay tecla repetir
	rts				; retorna				; 	RET			 ; 84CB C9		; Retorna con un AND de todas las semifilas en "A" (Normalmente se descarta este valor)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; SaveGame					
										; 							; Salva la partida en su estado actual en 4 bloques
					; desde L_C11B hasta DataEnd+1		; 							; Guarda DATABLK1	   $1D bytes
					; o sea de: $720E - $7ED8		; 							; Guarda OBJ_TABLE $0615 bytes
					; OJO si se cambian de sitio!!!		; 							; Guarda DATABLK3	 $00BF bytes
										; 							; Guarda LOCATION	 $05D9 bytes
										; 							; antes ; (#63# --)	
SaveGame									; SaveGame: PUSH IX		 ; 84CC DD E5		; Guarda el valor de IX
	pshs	d,x,u			; guarda registros			; 	PUSH DE			 ; 84CE D5		; Guarda el valor de DE
	ldu	#DATABLK1		; apunta a DATABLK1 (destino)		; 	LD DE, DATABLK1		 ; 84CF 11 EB B6	; Carga DE con DATABLK1
	ldx	#D_C9E2			; apunta a D_C9E2 (origen)		; 	LD HL, D_C9E2		 ; 84D2 21 E2 C9	; apunta a D_C9E2
	ldb	#3			; numero de bytes a copiar		; 	CALL L_84B3		 ; 84D5 CD B3 84	; llama rutina L_84B3 (#117# OK) - Copia 3 Bytes desde DATABLK1 a D_C9E2
	jsr	do_ldir			; hacer la copia			; 	LD A, $01		 ; 84D8 3E 01		; pone 1
	ldx	#SaveGam+1		; apunta a fichero para tratarlo	; 	LD (PrintAreaFlag), A	 ; 84DA 32 01 B7	; en PrintAreaFlag - indica Abajo
	stx	FilePtr			; guarda puntero			; 	LD HL, L_B342		 ; 84DD 21 42 B3	; HL = $B342
	jsr	WorkFileName		; mostrar nombre del Fichero		; 	CALL PrintMsg		 ; 84E0 CD DD 72	; Muestra el mensaje "start tape then press any key" * llama rutina PrintMsg
										; 	CALL GetAnyKey	 	 ; 84E3 CD B9 84	; GetAnyKey	
										; 	LD A, $FF		 ; 84E6 3E FF		; Carga A con $FF
	ldx	D_A7CF+2		; get random Pointer			; 	LD IX, DATABLK1		 ; 84E8 DD 21 EB B6	; Carga IX con DATABLK1
	stx	ExitEnabler		; put in SaveData			; 	LD DE, $001D		 ; 84EC 11 1D 00	; Carga DE con $001D
										; 	CALL RomSave		 ; 84EF CD C2 04	; Rutina ROM 48K Save en Cinta
										; 							; Bloque 2 OBJ_TABLE	
	jsr	SvFile			; Guarda posicion en disco		; 	LD A, $FF		 ; 84F2 3E FF		; Carga A con $FF
										; 	LD IX, OBJ_TABLE	 ; 84F4 DD 21 1B C1	; Carga IX con OBJ_TABLE
										; 	LD DE, $0615		 ; 84F8 11 15 06	; Carga DE con $0615
										; 	CALL RomSave		 ; 84FB CD C2 04	; Rutina ROM 48K Save en Cinta
	ldb	oldEB			; get saved value			; 							; Bloque 3 DATABLK3	
	stb	<$eb			; and restore it			; 	LD A, $FF		 ; 84FE 3E FF		; Carga A con $FF
										; 	LD IX, DATABLK3		 ; 8500 DD 21 84 CA	; Carga IX con DATABLK3
										; 	LD DE, $00BF		 ; 8504 11 BF 00	; Carga DE con $00BF
i_8553	puls	d,x,u			; recupera registros			; 	CALL RomSave		 ; 8507 CD C2 04	; Rutina ROM 48K Save en Cinta
	jmp	GetB6DEJmpTable75D2	; salta a GetB6DEJmpTable75D2		; 							; Bloque 4 LOCATION
										; 	LD A, $FF		 ; 850A 3E FF		; Carga A con $FF
										; 	LD IX, LOCATION		 ; 850C DD 21 8A BA	; Carga IX con LOCATION
										; 	LD DE, $05D9		 ; 8510 11 D9 05	; Carga DE con $05D9
										; 	CALL RomSave		 ; 8513 CD C2 04	; Rutina ROM 48K Save en Cinta
										; 	LD HL, L_B3A4		 ; 8516 21 A4 B3	; apunta a mensaje "rewind and prepare tape for	    verification  -- then hit any key"
										; 	CALL PrintMsg		 ; 8519 CD DD 72	; Muestra "rewind and prepare tape for	   verification	 -- then hit any key" - PrintMsg
										; 	CALL GetAnyKey		 ; 851C CD B9 84	; llama rutina GetAnyKey
										; 	LD A, $FF		 ; 851F 3E FF		; Carga A con $FF
										; 	AND A			 ; 8521 A7		; A = A AND A	; Adecua flags
										; 	LD IX, DATABLK1		 ; 8522 DD 21 EB B6	; Carga IX con DATABLK1
										; 	LD DE, $001D		 ; 8526 11 1D 00	; Carga DE con $001D
										; 	CALL L_855A		 ; 8529 CD 5A 85	; llama rutina L_855A (#175# --)
										; 	LD A, $FF		 ; 852C 3E FF		; Carga A con $FF
										; 	AND A			 ; 852E A7		; A = A AND A	; Adecua flags
										; 	LD IX, OBJ_TABLE	 ; 852F DD 21 1B C1	; Carga IX con OBJ_TABLE
										; 	LD DE, $0615		 ; 8533 11 15 06	; Carga DE con $0615
										; 	CALL L_855A		 ; 8536 CD 5A 85	; llama rutina L_855A (#175# --)
										; 	LD A, $FF		 ; 8539 3E FF		; Carga A con $FF
										; 	AND A			 ; 853B A7		; A = A AND A	; Adecua flags
										; 	LD IX, DATABLK3		 ; 853C DD 21 84 CA	; Carga IX con DATABLK3
										; 	LD DE, $00BF		 ; 8540 11 BF 00	; Carga DE con $00BF
										; 	CALL L_855A		 ; 8543 CD 5A 85	; llama rutina L_855A (#175# --)
										; 	LD A, $FF		 ; 8546 3E FF		; Carga A con $FF
										; 	AND A			 ; 8548 A7		; A = A AND A	; Adecua flags
										; 	LD IX, LOCATION		 ; 8549 DD 21 8A BA	; Carga IX con LOCATION
										; 	LD DE, $05D9		 ; 854D 11 D9 05	; Carga DE con $05D9
										; 	CALL L_855A		 ; 8550 CD 5A 85	; llama rutina L_855A (#175# --)
										; i_8553: DI			 ; 8553 F3		; deshabilita interrupciones
										; 	POP DE			 ; 8554 D1		; Recupera DE
										; 	POP IX			 ; 8555 DD E1		; Recupera IX
										; 	JP GetB6DEJmpTable75D2	 ; 8557 C3 B3 82	; salta a GetB6DEJmpTable75D2
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
;					; NO HACE FALTA				; 							; (#175# --)
										; L_855A: CALL RomLoad		 ; 855A CD 56 05	; llama rutina RomLoad
										; 	RET C			 ; 855D D8		; Si C = 1, Retorna
										; 	LD A, $01		 ; 855E 3E 01		; pone $01
										; 	LD (PrintAreaFlag), A	 ; 8560 32 01 B7	; en PrintAreaFlag - indica Abajo
										; 	LD HL, L_B381		 ; 8563 21 81 B3	; apunta a mensaje "tape error -     hit any key to continue[0x15]"
										; 	CALL PrintMsg		 ; 8566 CD DD 72	; muestra mensaje; PrintMsg
										; i_8569: XOR A			 ; 8569 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
										; 	IN A, ($FE)		 ; 856A DB FE		; lee teclado (Shift-Z-X-C-V)
										; 	AND $1F			 ; 856C E6 1F		; Hace AND lgico de A con $1F
										; 	CP $1F			 ; 856E FE 1F		; Compara A con $1F
										; 	JR Z, i_8569		 ; 8570 28 F7		; Si Z = 1, Salta a i_8569
										; 	POP DE			 ; 8572 D1		; Recupera DE
										; 	JP i_8553		 ; 8573 C3 53 85	; Salta a i_8553
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: hace un AND entre L_B6FA y L_B702			      (#02# OK) ;
; Resultado: flag Z								;
;  Preserva: A									;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_8576	pshs	a			; guarda A				; L_8576: PUSH HL		 ; 8576 E5		; guarda HL
	lda	L_B6FA			; recupera L_B6FA 			; 	LD L, A			 ; 8577 6F		; guarda A
	anda	L_B702			; hace AND con L_B702			; 	LD A, (L_B6FA)		 ; 8578 3A FA B6	; recupera L_B6FA
	puls	a,pc			; recupera A y retorna			; 	LD H, A			 ; 857B 67		; lo guarda en H
										; 	LD A, (L_B702)		 ; 857C 3A 02 B7	; recupera L_B702
										; 	AND H			 ; 857F A4		; hace AND entre ellos
										; 	LD A, L			 ; 8580 7D		; recupera A
										; 	POP HL			 ; 8581 E1		; recupera HL
										; 	RET			 ; 8582 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Imprime un  Enter (cambio de lnea)		      (#12# OK) ;
;  Preserva: A	 								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PutEnter									; PutEnter:   						; Imprime Enter ; llamada desde MODE = (2,3,6)
	pshs	a,cc			; guarda registro y flags		;	PUSH AF			 ; 8583 F5		; Guarda A y Los flags
	lda	#$0D			; toma valor Enter			;	LD A, $0D		 ; 8584 3E 0D		; A = $0D;	; toma el cdigo ASCII del (ENTER)
	jsr	PutChar			; llama PutChar				;	CALL PutChar		 ; 8586 CD 8B 85	; llama rutina PutChar imprime char en A
	puls	a,cc,pc			; recupera registro, flags y retorna	;	POP AF			 ; 8589 F1		; Restaura A y Los flags
										;	RET			 ; 858A C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Imprime el char ASCII contenido en A     		  (# sinNumero)	;
; Parmetro: A  caracter a imprimir						;
;  Preserva: A									;
;   Utiliza: X(HL)								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PutChar							 			; PutChar:
	jsr	L_8576			; llama L_8576				; 	CALL L_8576		 ; 858B CD 76 85	; llama L_8576
	beq	ePChar			; si cero, sale via ePChar		; 	RET Z			 ; 858E C8		; si flag Z=1, retorna
	pshs	a			; guarda A				; 	PUSH AF			 ; 858F F5		; guarda A y los flags
	lda	PrintAreaFlag		; recupera PrintAreaFlag		; 	LD A, (PrintAreaFlag)	 ; 8590 3A 01 B7	; recupera PrintAreaFlag
										; 	AND A			 ; 8593 A7		; actualiza flags
	bne	L_85B7			; si no es 0, salta a L_85B7 (abajo)	; 	JR NZ, L_85B7		 ; 8594 20 21		; si no es cero, salta a L_85B7 (imprime en parte de abajo)
	puls	a			; recupera A				; 	POP AF			 ; 8596 F1		; recupera AF
	jsr	PrintInUpperWindow	; llama PrintInUpperWindow		; 	CALL PrintInUpperWindow	 ; 8597 CD A1 86	; llama PrintInUpperWindow
	pshs	a			; guarda A				; 	PUSH AF			 ; 859A F5		; guarda AF
	lda	L_B700			; recupera L_B700			; 	LD A, (L_B700)		 ; 859B 3A 00 B7	; recupera L_B700
										; 	AND A			 ; 859E A7		; actualiza flags
	bne	L_85A3			; si no es cero, salta a L_85A3		; 	JR NZ, L_85A3		 ; 859F 20 02		; si no es cero, salta a L_85A3
	puls	a			; recupera A				; 	POP AF			 ; 85A1 F1		; recupera A y los flags
ePChar	rts				; retorna				; 	RET			 ; 85A2 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Rutina para verificar si en A haba "S"  "s"
										; 							; y si es cierto, llama a PrintInUpperWindow con A = $48("H")
L_85A3	puls	a			; recupera A				; L_85A3: POP AF		 ; 85A3 F1		; recupera A y flags
	cmpa	#$53			; es A $53 ('S')?			; 	CP $53			 ; 85A4 FE 53		; es A $53("S")?
	beq	i_85AB			; si, salta a i_85AB			; 	JR Z, i_85AB		 ; 85A6 28 03		; si, salta a i_85AB
	cmpa	#$73			; es A $73 ('s')?			; 	CP $73			 ; 85A8 FE 73		; es A $73("s")?
	bne	ePChar			; no, sale via ePChar			; 	RET NZ			 ; 85AA C0		; no, retorna
i_85AB	pshs	a			; guarda A				; i_85AB: PUSH AF		 ; 85AB F5		; si, guarda A y flags
	lda	#$48			; carga $48 ('H')			; 	LD A, $48		 ; 85AC 3E 48		; toma valor $48("H")
	jsr	PrintInUpperWindow	; llama	PrintInUpperWindow		; 	CALL PrintInUpperWindow	 ; 85AE CD A1 86	; Llama PrintInUpperWindow
										; 	POP AF			 ; 85B1 F1		; recupera A y flags
	puls	a,pc			; recupera A y retorna			; 	RET			 ; 85B2 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
																	; (#03#) - imprime un byte en la parte de abajo
L_85B7	puls	a			; recupera A				; L_85B7: POP AF		 ; 85B7 F1		; recupera A y flags
L_85B8	pshs	a,x			; guarda registros			; L_85B8: PUSH HL		 ; 85B8 E5		; guarda HL
										; 	PUSH AF			 ; 85B9 F5		; guarda A y flags
	ldx	L_85B4			; recupera puntero a pantalla		; 	LD HL, (L_85B4)		 ; 85BA 2A B4 85	; recupera L_85B4-B5 (puntero area de pantalla donde escribir)
	cmpa	#$0D			; es Enter?				; 	CP $0D			 ; 85BD FE 0D		; es A $0D (Enter)?
	bne	i_85C8			; no, salta a i_85C8			; 	JR NZ, i_85C8		 ; 85BF 20 07		; no, salta a i_85C8
	lda	#$20			; si, carga un espacio			; 	LD A, $20		 ; 85C1 3E 20		; lo sustituye por un espacio $20(' ')
	jsr	DrawChar		; lo imprime en pantalla		; 	CALL DrawChar		 ; 85C3 CD 7A 86	; muestra un caracter (en este caso un espacio)
	bra	i_85DF			; salta a i_85DF			; 	JR i_85DF		 ; 85C6 18 17		; salta a i_85DF
i_85C8	cmpa	#$08			; es un 'espacio atrs'?		; i_85C8: CP $08		 ; 85C8 FE 08		; es A $08 (espacio atrs)?
	beq	L_85F5			; si, salta a L_85F5			; 	JR Z, L_85F5		 ; 85CA 28 29		; si, procesarlo en L_85F5
	cmpa	#$61			; es menor que 'a'			; 	CP $61			 ; 85CC FE 61		; compara A con $61(97) "a"
	bcs	i_85D6			; si, salta a i_85D6 (es mayscula)	; 	JR C, i_85D6		 ; 85CE 38 06		; si es menor, salta a i_85D6
	cmpa	#$7B			; es mayor o igual que 'z' 		; 	CP $7B			 ; 85D0 FE 7B		; compara A con $7B(123)="{" (122 es "z")
	bcc	i_85D6			; si, salta a i_85D6 (no es letra)	; 	JR NC, i_85D6		 ; 85D2 30 02		; si es igual o mayor, salta a i_85D6
	anda	#$5F			; convierte a mayscula			; 	AND $5F			 ; 85D4 E6 5F		; lo convierte a mayusculas
i_85D6	jsr	DrawChar		; imprime en pantalla			; i_85D6: CALL DrawChar		 ; 85D6 CD 7A 86	; muestra el caracter
	lda	L_85B3			; recupera L_85B3			; 	LD A, (L_85B3)		 ; 85D9 3A B3 85	; recupera contador L_85B3
	deca				; descuenta 1				; 	DEC A			 ; 85DC 3D		; lo decrementa
	bne	i_85E6			; si no es cero, salta a i_85E6		; 	JR NZ, i_85E6		 ; 85DD 20 07		; si no es cero, salta a i_85E6
i_85DF	ldx	#$2500			; apunta a principio de linea 24	; i_85DF: LD L, $E0		 ; 85DF 2E E0		; carga L con valor $E0
	jsr	L_860D			; llama Scroll 4 lineas 1 hacia arriba	; 	CALL L_860D		 ; 85E1 CD 0D 86	; llama L_860D (Scroll arriba 4 lineas parte de abajo)
	lda	#32			; pone 32 				; 	LD A, $20		 ; 85E4 3E 20		; pone 32 en A 
i_85E6	sta	L_85B3			; en L_85B3 (num chars en linea)	; i_85E6: LD (L_85B3), A	 ; 85E6 32 B3 85	; actualiza contador L_85B3 con A
	lda	L_85B6			; carga el signo '+'			; 	LD A, (L_85B6)		 ; 85E9 3A B6 85	; recupera signo '+'
	stx	L_85B4			; guarda puntero pantalla en L_85B4	; 	LD (L_85B4), HL		 ; 85EC 22 B4 85	; guarda puntero a pantalla en L_85B4
	jsr	DrawChar		; imprime el signo '+'			; 	CALL DrawChar		 ; 85EF CD 7A 86	; muestra el caracter
	puls	a,x,pc			; recupera A,X y retorna		; 	POP AF			 ; 85F2 F1		; recupera A y flags
										; 	POP HL			 ; 85F3 E1		; recupera HL
										; 	RET			 ; 85F4 C9		; retorna
					; proceso espacio atrs (BackSpace)	; 							; (#07# OK) procesa la 'tecla atrs'
L_85F5	lda	#$20			; carga espacio				; L_85F5: LD A, $20		 ; 85F5 3E 20		; toma valor de espacio
	jsr	DrawChar		; lo imprime				; 	CALL DrawChar		 ; 85F7 CD 7A 86	; lo imprime para borrar el ltimo caracter
	leax	-2,x			; puntero 2 posiciones atrs		; 	DEC L			 ; 85FA 2D		; decrementa L
					; al imprimir avanz una		; 	DEC L			 ; 85FB 2D		; dos veces, para apuntar al byte anterior al ahora borrado
										; 							; ya que al imprimir HL ha avanzado un espacio
	lda	L_85B3			; recupera bytes libres en la linea	; 	LD A, (L_85B3)		 ; 85FC 3A B3 85	; recupera contador L_85B3
	inca				; le suma 1				; 	INC A			 ; 85FF 3C		; lo incrementa (ahora cabe un caracter mas)
	cmpa	#33			; es igual a 33 (fuera de limites)?	; 	CP $21			 ; 8600 FE 21		; es mas all del fin de lnea (32 chars)?
	blo	i_85E6			; no, sale via i_85E6			; 	JR NZ, i_85E6		 ; 8602 20 E2		; no, bucle a i_85E6
	ldx	#$251F			; apunta a ltimo caracter linea 24	; 	LD L, $FF		 ; 8604 2E FF		; si, flag N = 1 y Z = 0
	jsr	L_864A			; hace bajar 4 lineas hacia abajo	; 	CALL L_864A		 ; 8606 CD 4A 86	; llama rutina ScrollDown para hacer bajar el texto una linea (#08# OK)
	lda	#1			; pone un 1 en columna a imprimir	; 	LD A, $01		 ; 8609 3E 01		; A = 1, reseteando indicadores de cero y negativo
	bra	i_85E6			; sale via i_85E6			; 	JR i_85E6		 ; 860B 18 D9		; bucle a i_85E6
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Scroll-UP 4 lineas de abajo, limpia la ltima	      (#06# OK) ;
;  Preserva: D, X, U 								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_860D	pshs	d,x,u			; guarda registros 			; L_860D: PUSH HL		 ; 860D E5		; Guarda HL
										; 	PUSH DE			 ; 860E D5		; Guarda DE
										; 	PUSH BC			 ; 860F C5		; Guarda BC
										; 	PUSH AF			 ; 8610 F5		; Guarda AF
	ldu	#$2100			; puntero destino linea 20		; 	LD HL, $5080		 ; 8611 21 80 50	; HL = $5080,	; HL apunta a la fila 21 de la pantalla
	ldx	#$2200			; puntero origen linea 21		; 	LD DE, $5060		 ; 8614 11 60 50	; DE = $5060,	; DE apunta a la fila 20 de la pantalla
ScrUp1	ldd	,x++			; lee 2 bytes				; 	LD A, $04		 ; 8617 3E 04		; A = 4,	; Contador de filas de chars a 4
	std	,u++			; los copia 1 linea mas arriba		; 	LD B, $00		 ; 8619 06 00		; B = 0
	cmpx	#$2600			; lleg a final linea 24?		; i_861B: PUSH HL		 ; 861B E5		; Guarda HL
	blo	ScrUp1			; no, seguir				; 	PUSH DE			 ; 861C D5		; Guarda DE
										; 	LD C, $08		 ; 861D 0E 08		; C = 8,	; contador de bytes por cada caracter a 8
										; i_861F: PUSH HL		 ; 861F E5		; Guarda HL
										; 	PUSH DE			 ; 8620 D5		; Guarda DE
										; 	PUSH BC			 ; 8621 C5		; Guarda BC
										; 	LD C, $20		 ; 8622 0E 20		; C = $20(32),	; Contador para repeticiones (LDIR) a 32 (bytes por cada fila de pixeles)
										; 	LDIR			 ; 8624 ED B0		; Copia 32 bytes desde HL=$5080 a DE=$5060, BC bytes = 32
										; 	POP BC			 ; 8626 C1		; Recupera BC
										; 	POP DE			 ; 8627 D1		; Recupera DE
										; 	POP HL			 ; 8628 E1		; Recupera HL
										; 	INC H			 ; 8629 24		; H = H + 1	; Incrementa H para apuntar al siguiente byte del mismo caracter (HL = HL + 256)(origen)
										; 	INC D			 ; 862A 14		; D = D + 1	; Incrementa D para apuntar al siguiente byte del mismo caracter (DE = DE + 256)(destino)
										; 	DEC C			 ; 862B 0D		; C = C - 1	; Decrementa contador de bytes por caractere
										; 	JR NZ, i_861F		 ; 862C 20 F1		; Si no es cero, bucle a i_861F (siguiente fila de pixels)
										; 	POP DE			 ; 862E D1		; Recupera DE
										; 	POP HL			 ; 862F E1		; Recupera HL
										; 	LD C, $20		 ; 8630 0E 20		; C = $20(32)	; BC = 32 bytes por fila
										; 	ADD HL, BC		 ; 8632 09		; HL = HL + BC(32); Ahora apunta una fila mas abajo
										; 	EX DE, HL		 ; 8633 EB		; DE <-> HL	; Intercambia punteros
										; 	ADD HL, BC		 ; 8634 09		; HL = HL + BC(32); Ahora apunta una fila mas abajo
										; 	EX DE, HL		 ; 8635 EB		; DE <-> HL	; Intercambia punteros, ahora ambos incrementados en 32 apuntando la siguente fila de chars
										; 	DEC A			 ; 8636 3D		; A = A - 1,	; Decrementa contador de filas, Lo hace 4 veces
										; 	JR NZ, i_861B		 ; 8637 20 E2		; Si no es cero, bucle a  i_861B
	ldd	#$FFFF			; todo 1's para blanquear		; 	LD B, $20		 ; 8639 06 20		; B = $20(32)	; B = 32 nmero de chars a imprimir
ScrUp2	std	,u++			; limpia 2 bytes			; 	LD HL, $50E0		 ; 863B 21 E0 50	; HL = $50E0	; HL apunta a la fila 24th de la pantalla (la ltimsima)
	cmpu	#$2600			; final linea 24?			; 	LD A, $20		 ; 863E 3E 20		; A = $20(32)	; A = espacio
	bne	ScrUp2			; no, seguir				; i_8640: CALL DrawChar		 ; 8640 CD 7A 86	; Imprime el espacio (para borrar la ltima fila)
										; 	DJNZ i_8640		 ; 8643 10 FB		; Bucle hasta hacer los 32
										; 	POP AF			 ; 8645 F1		; Recupera AF
										; 	POP BC			 ; 8646 C1		; Recupera BC
										; 	POP DE			 ; 8647 D1		; Recupera DE
										; 	POP HL			 ; 8648 E1		; Recupera HL
	puls	d,x,u,pc		; recupera registros y retorna		; 	RET			 ; 8649 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Scroll-DOWN 4 lineas de abajo, limpia la primera	      (#08# OK) ;
;  Preserva: D, X, U								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_864A	pshs	d,x,u			; guarda registros			; L_864A: PUSH HL		 ; 864A E5		; Guarda HL
										; 	PUSH DE			 ; 864B D5		; Guarda DE
										; 	PUSH BC			 ; 864C C5		; Guarda BC
										; 	PUSH AF			 ; 864D F5		; Guarda AF
	ldx	#$2500			; apunta final fila 23 + 2 bytes	; 	LD HL, $50C0		 ; 864E 21 C0 50	; HL = $50C0,	; HL apunta a la fila 23 de la pantalla
	ldu	#$2600			; apunta final fila 24 + 2 bytes	; 	LD DE, $50E0		 ; 8651 11 E0 50	; DE = $50E0,	; DE apunta a la fila 24 de la pantalla
ScrDwn1	ldd	,--x			; decrementa puntero y lee 2 bytes	; 	LD A, $05		 ; 8654 3E 05		; A = 5,	; Contador de filas de caracteres a 5
	std	,--u			; decrementa puntero y escribe 2 bytes	; i_8656: PUSH HL		 ; 8656 E5		; Guarda HL
	cmpx	#$2100			; lleg a inicio linea 20?		; 	PUSH DE			 ; 8657 D5		; Guarda DE
	bhi	ScrDwn1			; no, seguir				; 	LD B, $08		 ; 8658 06 08		; B = 8,	; Contador de bytes por caracter a 8
										; i_865A: PUSH HL		 ; 865A E5		; Guarda HL	========= Esta rutina copia 32 bytes desde [HL] a [DE] sin modificar registros =====
	ldd	#$FFFF			; todo 1's para blanquear		; 	PUSH DE			 ; 865B D5		; Guarda DE
ScrDwn2	std	,x++			; limpia 2 bytes			; 	PUSH BC			 ; 865C C5		; Guarda BC
	cmpx	#$2200			; lleg a final linea 20?		; 	LD BC, $0020		 ; 865D 01 20 00	; BC = 32	; Contador para repeticiones (LDIR) a 32 (bytes por fila)
	blo	ScrDwn2			; no, seguir				; 	LDIR			 ; 8660 ED B0		; Copia 32 bytes desde $50C0 a $50E0; [DE+] = [HL+]; BC- y repite hasta BC = 0
										; 	POP BC			 ; 8662 C1		; Recupera BC
										; 	POP DE			 ; 8663 D1		; Recupera DE
										; 	POP HL			 ; 8664 E1		; Recupera HL
										; 	INC H			 ; 8665 24		; H = H + 1,	 Incrementa H para apuntar al siguiente byte del mismo char (Origen) (HL = HL + 256)
										; 	INC D			 ; 8666 14		; D = D + 1,	 Incrementa D para apuntar al siguiente byte del mismo char (Destino) (HL = HL + 256)
										; 	DJNZ i_865A		 ; 8667 10 F1		; B = B - 1,	 Decrementa B y si no es cero (Z = 0) salta a i_865A
										; 	POP DE			 ; 8669 D1		; Recupera DE
										; 	POP HL			 ; 866A E1		; Recupera HL
										; 	LD BC, $FFE0		 ; 866B 01 E0 FF	; BC = $FFE0(-32); BC = 32
										; 	ADD HL, BC		 ; 866E 09		; HL=HL + BC(-32); (ahora hay que subir una linea para arriba los punteros)
										; 	EX DE, HL		 ; 866F EB		; DE <-> HL,	; Intercambia punteros
										; 	ADD HL, BC		 ; 8670 09		; HL=HL + BC(-32); Tambien le resta 32
										; 	EX DE, HL		 ; 8671 EB		; DE <-> HL,	; Intercambia punteros. Ahora ambos apuntan una fila mas arriba
										; 	DEC A			 ; 8672 3D		; A = A - 1,	; decrementa contador de filas
										; 	JR NZ, i_8656		 ; 8673 20 E1		; Z = 0?	; Si no es cero bucle a i_8656
										; 	POP AF			 ; 8675 F1		; Recupera AF
										; 	POP BC			 ; 8676 C1		; Recupera BC
										; 	POP DE			 ; 8677 D1		; Recupera DE
										; 	POP HL			 ; 8678 E1		; Recupera HL
	puls	d,x,u,pc		; recupera registros y retorna		; 	RET			 ; 8679 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Imprime un caracter				      (#05# OK) ;
; Parmetro: A  caracter a imprimir						;
;  Preserva: D, X, U								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DrawChar									; DrawChar:			 			; $867A
	pshs	d,x,u			; guarda registros			; 	PUSH AF		 	 ; 867A F5		; Guarda AF
										; 	PUSH BC			 ; 867B C5		; Guarda BC
										; 	PUSH DE			 ; 867C D5		; Guarda DE
										; 	PUSH HL			 ; 867D E5		; Guarda HL
	suba	#32			; resta 32 para adaptar indice a tabla	; 	SUB $20			 ; 867E D6 20		; A = A - 32,	; (el primer ASCII est en offset 0 espacio en blanco)
	ldb	#8			; 8 bytes cada caracter			; 	LD L, A			 ; 8680 6F		; L = A,	; L recibe el codigo a imprimir
	mul				; calcula el offset			; 	LD H, $00		 ; 8681 26 00		; H = 0,	; byte alto a cero (offset = HL)
	ldu	#ROMFONT		; apunta inicio fuentes			; 	ADD HL, HL		 ; 8683 29		; Multiplica
	leau	d,u			; aade offset del char a imprimir	; 	ADD HL, HL		 ; 8684 29		; HL por 8
										; 	ADD HL, HL		 ; 8685 29		; calculando el offset al inicio del caracter (cada uno ocupa 8 bytes)
										; 	LD DE, $3D00		 ; 8686 11 00 3D	; DE = $3D00,	; (inicio de la ROM - OJO, HABRA QUE CAMBIARLO!!!)
										; 	ADD HL, DE		 ; 8689 19		; HL = HL + $3D00,; apunta al inicio de datos para el caracter recibido
										; 	EX DE, HL		 ; 868A EB		; DE <-> HL	; Intercambia punteros, DE apunta a datos caracter
										; 	POP HL			 ; 868B E1		; Recupera HL,	; Zona de pantalla donde debe mostrarase el caracter
										; 	PUSH HL			 ; 868C E5		; Guarda HL	; Lo pone de nuevo en el stack
	ldb	#8			; numero de bytes a imprimir		; 	LD B, $08		 ; 868D 06 08		; B = 8		; Contador de bytes a 8
Draw1	lda	,u+			; lee un byte				; i_868F: LD A, (DE)		 ; 868F 1A		; A = (DE)	; lee un byte de la ROM en A
	coma				; invierte bits				;
	sta	,x			; lo muestra en pantalla		; 	LD (HL), A		 ; 8690 77		; (HL) = A	; Coloca el dato en (HL), que apunta a la pantalla donde el caracter sera mostrado 
	leax	32,x			; pasa a siguiente linea de pixels	; 	INC DE			 ; 8691 13		; DE = DE + 1	; Incrementa puntero a datos en ROM
	decb				; decrementa contador			; 	INC H			 ; 8692 24		; H = H + 1	; Incrementa H, Implica apuntar el byte de abajo en pantalla (HL = HL + 256)
	bne	Draw1			; si no finalido, seguir		; 	DJNZ i_868F		 ; 8693 10 FA		; B = B + 1	; Decrementa B y si no es cero, bucle a i_868F (siguiente byte)
										; 	POP HL			 ; 8695 E1		; Recupera HL
										; 	POP DE			 ; 8696 D1		; Recupera DE
										; 	POP BC			 ; 8697 C1		; Recupera BC
	puls	d,x,u			; recupera registros			; 	POP AF			 ; 8698 F1		; Recupera AF
	leax	1,x			; incrementa puntero a pantalla		; 	INC L			 ; 8699 2C		; L = L + 1	; Incrementa L para apuntar a la siguiente posicion de pantalla
	rts				; retorna				; 	RET			 ; 869A C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Imprime en la parte superior de la pantalla 	      (#04# --)	;
; Parmetro: A  caracter a imprimir						;
;  Preserva: CC, A, X(HL), reg_BC(U)						;
;   Utiliza: B									;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PrintInUpperWindow								; PrintInUpperWindow:					; 
	ldu	<reg_BC			; recupera reg_BC
	pshs	x,u			; guarda registros			; 	PUSH HL			 ; 86A1 E5		; guarda HL
										; 	PUSH BC			 ; 86A2 C5		; guarda BC
	pshs	a			; guarda A				; 	PUSH AF			 ; 86A3 F5		; guarda AF
	ldx	L_869C			; recupera L_869C			; 	LD HL, (L_869C)		 ; 86A4 2A 9C 86	; recupera puntero a pantalla de L_869C-9D
	lda	L_869E			; recupera L_869E			; 	LD A, (L_869E)		 ; 86A7 3A 9E 86	; recupera L_869E
	sta	<reg_C			; guarda A en reg_C			; 	LD C, A			 ; 86AA 4F		; lo guarda en C
	lda	L_86A0			; recupera L_86A0			; 	LD A, (L_86A0)		 ; 86AB 3A A0 86	; recupera L_$86A0
										; 	AND A			 ; 86AE A7		; adecua los flags
	bne	i_86C6			; si no es 0, salta a i_86C6		; 	JR NZ, i_86C6		 ; 86AF 20 15		; si no es cero, salta a i_86C6
	lda	L_869F			; recupera L_869F			; 	LD A, (L_869F)		 ; 86B1 3A 9F 86	; recupera L_869F
										; 	AND A			 ; 86B4 A7		; es cero?
	beq	i_86C6			; si es 0, salta a i_86C6		; 	JR Z, i_86C6		 ; 86B5 28 0F		; si, salta a i_86C6
	sta	<reg_B			; pasa A a reg_B			; 	LD B, A			 ; 86B7 47		; pasa A al contador B
i_86B8	lda	#$20			; carga 'espacio'			; i_86B8: LD A, $20		 ; 86B8 3E 20		; toma valor 'espacio'
	jsr	PrintCharUppWindow	; llama PrintCharUppWindow		; 	CALL PrintCharUppWindow	 ; 86BA CD C9 87	; llama PrintCharUppWindow
	dec	L_869B			; decrementa L_869B			; 	LD A, (L_869B)		 ; 86BD 3A 9B 86	; decrementa
										; 	DEC A			 ; 86C0 3D		; el contador
	dec	<reg_B			; decrementa reg_B			; 	LD (L_869B), A		 ; 86C1 32 9B 86	; L_869B
	bne	i_86B8			; si no es cero, vuelve a L_86B8	; 	DJNZ i_86B8		 ; 86C4 10 F2		; mientras B no sea cero, vuelve a i_86B8
i_86C6	lda	,s			; recupera A sin  tocar stack		; i_86C6: POP AF		 ; 86C6 F1		; recupera A y flags
										; 	PUSH AF			 ; 86C7 F5		; los guarda de nuevo
	cmpa	#$0d			; es A $0D?				; 	CP $0D			 ; 86C8 FE 0D		; es A $0D (Enter)?
	bne	i_870D			; no, salta a i_870D			; 	JR NZ, i_870D		 ; 86CA 20 41		; no, salta a i_870D
	jsr	L_8B22			; envia el Enter a la impresora
	lda	#1			; pone 1				; 	LD A, $01		 ; 86CC 3E 01		; pone valor 1
	sta	L_B704			; en L_B704				; 	LD (L_B704), A		 ; 86CE 32 04 B7	; en L_B704
										;							; se envia la linea a impresora si hay un Enter o se ha ocupado entera
i_86D1	clra				; pone 0				; i_86D1: XOR A			 ; 86D1 AF		; pone 0
	sta	L_86A0			; en L_86A0				; 	LD (L_86A0), A		 ; 86D2 32 A0 86	; en L_86A0
					; Aqu NO pinta nada x 6809		; 	CALL L_8B22		 ; 86D5 CD 22 8B	; llama L_8B22
										; 	PUSH BC			 ; 86D8 C5		; guarda BC
	lda	L_B716			; recupera L_B716			; 	LD A, (L_B716)		 ; 86D9 3A 16 B7	; recupera L_B716
										; 	AND A			 ; 86DC A7		; es cero?
	bne	i_86F3			; si no es cero, salta a i_86F3		; 	JR NZ, i_86F3		 ; 86DD 20 14		; no, salta a i_86F3
	ldu	#$7fff			; pone $7fff en U (U=BC)		; 	LD BC, $8000		 ; 86DF 01 00 80	; pone valor $8000 en BC
i_86E2	jsr 	ReadKey			; lee teclado				; i_86E2: XOR A			 ; 86E2 AF		; A=0 para leer todas las teclas
										; 	IN A, ($FE)		 ; 86E3 DB FE		; lee teclado
										; 	AND $1F			 ; 86E5 E6 1F		; guarda los 5 bits bajos
										; 	CP $1F			 ; 86E7 FE 1F		; alguna tecla detectada?
	bne	i_86F7			; si ha leido tecla, salta a i_86F7	; 	JR NZ, i_86F7		 ; 86E9 20 0C		; si, salta a i_86F7
	leau	-1,u			; decrementa contador U			; 	DEC BC			 ; 86EB 0B		; decrementa BC
										; 	LD A, B			 ; 86EC 78		; comprueba si
										; 	OR C			 ; 86ED B1		; contador BC es cero
	bne	i_86E2			; si no es cero, vuelve a i_86E2	; 	JR NZ, i_86E2		 ; 86EE 20 F2		; no, vuelve a i_86E2 (espera una tecla pulsada)
										; 	POP BC			 ; 86F0 C1		; Recupera BC
	bra	i_8701			; salta a i_8701			; 	JR i_8701		 ; 86F1 18 0E		; salta a i_8701
										;							; se llega aqu solo cuando L_B716 no es cero
i_86F3	deca				; decrementa A				; i_86F3: DEC A			 ; 86F3 3D		; decrementa A
	sta	L_B716			; lo guarda en L_B716			; 	LD (L_B716), A		 ; 86F4 32 16 B7	; lo guarda de nuevo en L_B716
i_86F7										; i_86F7: POP BC		 ; 86F7 C1		; recupera BC
i_86F8	jsr	ReadKey			; lee teclado				; i_86F8: XOR A			 ; 86F8 AF		; A=0 para leer todas las teclas
										; 	IN A, ($FE)		 ; 86F9 DB FE		; lee teclado
										; 	AND $1F			 ; 86FB E6 1F		; guarda los 5 bits bajos
										; 	CP $1F			 ; 86FD FE 1F		; alguna tecla detectada?
	bne	i_86F8			; si detecta tecla, vuelve a i_86F8	; 	JR NZ, i_86F8		 ; 86FF 20 F7		; si, vuelve a i_86F8 (espera que NO haya tecla pulsada)
i_8701	ldx	#$1F00			; apunta inicio fila 18 pantalla	; i_8701: LD HL, $5020		 ; 8701 21 20 50	; apunta a inicio de la fila 18 de pantalla
	ldb	#1			; pone 1					
	stb	<reg_C			; en reg_C				; 	LD C, $01		 ; 8704 0E 01		; carga C con $01
	jsr	L_876B			; llama L_876B	(ScrollUp 17 lineas)	; 	CALL L_876B		 ; 8706 CD 6B 87	; llama L_876B (scroll-up)
	lda	#$2A			; carga $2A (42) espacios libres	; 	LD A, $2A		 ; 8709 3E 2A		; carga A con $2A (42) '*'
	bra	i_8753			; sale via i_8753			; 	JR i_8753		 ; 870B 18 46		; Sale via i_8753
i_870D	cmpa	#8			; es A backspace?			; i_870D: CP $08		 ; 870D FE 08		; es A $08 (backspace)?
	bne	i_8722			; no, salta a i_8722			; 	JR NZ, i_8722		 ; 870F 20 11		; no, salta a i_8722
	jsr	L_8B22			; envia retroceso carro a la impresora
	jsr	L_8761			; llama L_8761 (calcula byte pantalla)	; 	CALL L_8761		 ; 8711 CD 61 87	; llama L_8761 (calcula byte en pantalla)
	lda	#$20			; carga espacio				; 	LD A, $20		 ; 8714 3E 20		; carga A con $20 (espacio)
	jsr	PrintCharUppWindow	; llama	PrintCharUppWindow		; 	CALL PrintCharUppWindow	 ; 8716 CD C9 87	; llama PrintCharUppWindow
	jsr	L_8761			; llama L_8761	(calcula byte pantala)	; 	CALL L_8761		 ; 8719 CD 61 87	; llama L_8761 (calcula byte en pantalla)
	lda	L_869B			; recupera L_869B			; 	LD A, (L_869B)		 ; 871C 3A 9B 86	; recupera L_869B (numero chars libres en linea actual)
	inca				; lo incrementa				; 	INC A			 ; 871F 3C		; lo incrementa
	bra	i_8753			; sale via i_8753			; 	JR i_8753		 ; 8720 18 31		; sale via i_8753
i_8722	cmpa	#$41			; es A menor que $41 ('A')?		; i_8722: CP $41		 ; 8722 FE 41		; compara A con $41 ('A')
	bcs	i_872C			; si, salta a i_872C			; 	JR C, i_872C		 ; 8724 38 06		; si menor, Salta a i_872C
	cmpa	#$5B			; es A mayor que $5B ('[')?		; 	CP $5B			 ; 8726 FE 5B		; compara A con $5B ('[')
	bcc	i_872C			; si, salta a i_872C			; 	JR NC, i_872C		 ; 8728 30 02		; si mayor o igual, salta a i_872C
	ora	#$20			; pasa a minsculas			; 	OR $20			 ; 872A F6 20		; pone bit5 a 1 = convierte a minsculas
i_872C	pshs	x			; guarda X				; i_872C: PUSH HL		 ; 872C E5		; guarda HL
	ldx	#L_B704			; apunta a L_B704			; 	LD HL, L_B704		 ; 872D 21 04 B7	; apunta a L_B704
	tst	,x			; es 0 L_B704?				; 	INC (HL)		 ; 8730 34		; incrementa L_B704
										; 	DEC (HL)		 ; 8731 35		; decrementa L_B704
	beq	i_8740			; si, salta a i_8740			; 	JR Z, i_8740		 ; 8732 28 0C		; si 0, salta a i_8740
	cmpa	#$61			; es A menor que $61 ('a')?		; 	CP $61			 ; 8734 FE 61		; compara A con 'a'
	bcs	i_8740			; si, salta a i_8740			; 	JR C, i_8740		 ; 8736 38 08		; si menor salta a i_8740
	cmpa	#$7B			; es A mayor que $7B ('{')?		; 	CP $7B			 ; 8738 FE 7B		; compara con '{'
	bcc	i_8740			; si, salta a i_8740			; 	JR NC, i_8740		 ; 873A 30 04		; si es igual o mayor salta a i_8740
	anda	#%11011111		; pone a 0 el bit 5 de A		; 	RES 5, A		 ; 873C CB AF		; pone bit5 a cero = convierte a maysculas
	clr	,x			; pone a 0 L_B704			; 	LD (HL), $00		 ; 873E 36 00		; pasa L_B704 a cero
i_8740	cmpa	#$2E			; es A $2E ('.')?			; i_8740: CP $2E		 ; 8740 FE 2E		; es A $2E ('.')?
	bne	i_8745			; no, salta a i_8745			; 	JR NZ, i_8745		 ; 8742 20 01		; no, salta a i_8745
	inc	,x			; incrementa L_B704			; 	INC (HL)		 ; 8744 34		; pone a 1 L_B704
i_8745	puls	x			; recupera X				; i_8745: POP HL		 ; 8745 E1		; recupera HL
	jsr	PrintCharUppWindow	; llama PrintCharUppWindow		; 	CALL PrintCharUppWindow	 ; 8746 CD C9 87	; llama PrintCharUppWindow
	sta	L_86A0			; guarda A en L_86A0			; 	LD (L_86A0), A		 ; 8749 32 A0 86	; guarda A en L_86A0 (ltimo char impreso)
	lda	L_869B			; recupera L_869B			; 	LD A, (L_869B)		 ; 874C 3A 9B 86	; recupera L_869B (nmero chars libres en linea actual)
	deca				; decrementa A				; 	DEC A			 ; 874F 3D		; lo decrementa
	beq	i_86D1			; si cero, vuelve a i_86D1		; 	JP Z, i_86D1		 ; 8750 CA D1 86	; si es cero, vuelve a i_86D1
i_8753	sta	L_869B			; guarda A en L_869B			; i_8753: LD (L_869B), A	 ; 8753 32 9B 86	; guarda A en L_869B (actualiza contador)
	stx	L_869C			; guarda X en L_869C			; 	LD (L_869C), HL		 ; 8756 22 9C 86	; guarda HL en L_869C (actualiza puntero)
	lda	<reg_C			; pasa reg_C a A			; 	LD A, C			 ; 8759 79		; guarda C
	sta	L_869E			; guarda B en L_869E			; 	LD (L_869E), A		 ; 875A 32 9E 86	; en L_869E
	puls	a			; recupera A				; 	POP AF			 ; 875D F1		; recupera AF
	puls	x,u			; recupera registros			; 	POP BC			 ; 875E C1		; recupera BC
	stu	<reg_BC			; pasa U a reg_BC			; 	POP HL			 ; 875F E1		; recupera HL
	rts				; retorna				; 	RET			 ; 8760 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Calcula el byte de pantalla donde poner el char 	     (#176# --) ;
; Parmetro: reg_C numero de bits libres en el byte de pantalla			;
;	     X     puntero pantalla (HL)					;
;   Utiliza: A									;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_8761	lda	<reg_C			; pasa reg_C a A			; L_8761: LD A, C		 ; 8761 79		; pasa C a A
	suba	#6			; resta 6 de A				; 	SUB $06			 ; 8762 D6 06		; le resta $06 (numero de bits por caracter)
										; 	LD C, A			 ; 8764 4F		; guarda resultado en C
	bcc	eCalc			; si no hay carry, sale via eCalc	; 	RET NC			 ; 8765 D0		; si A era mayor o igual a 6, retorna
	adda	#8			; aade 8 a A				; 	ADD A, $08		 ; 8766 C6 08		; le suma $08
	leax	-1,x			; decrementa puntero pantalla		; 	LD C, A			 ; 8768 4F		; guarda resultado en C
eCalc	sta	<reg_C			; pasa A a reg_C			; 	DEC L			 ; 8769 2D		; decrementa L (HL apunta a byte anterior)
	rts				; retorna				; 	RET			 ; 876A C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Hace Scroll-UP de 17 lineas parte alta, borra la 18     (#106# OK) ;
;  Preserva: CC, D, X, U							;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_876B	pshs	cc,d,x,u		; guarda registros			; L_876B: PUSH AF		 ; 876B F5		; guarda AF
										; 	PUSH BC			 ; 876C C5		; guarda BC
										; 	PUSH HL			 ; 876D E5		; guarda HL
										; 	PUSH DE			 ; 876E D5		; guarda DE
	ldx	#$0F00			; apunta inicio 2a linea pantalla	; 	LD HL, $4020		 ; 876F 21 20 40	; HL apunta a segunda linea de pantalla (origen)
	ldu	#$0E00			; apunta inicio 1a linea pantalla	; 	LD DE, $4000		 ; 8772 11 00 40	; DE apunta a primera linea de pantalla (destino)
ScrWUp	ldd	,x++			; lee dos bytes	origen			; 	LD A, $11		 ; 8775 3E 11		; carga A con 17, num. de lineas a mover para arriba
	std	,u++			; los graba en destino			; 	LD B, $00		 ; 8777 06 00		; B a cero
	cmpx	#$2000			; acabada linea 18?			; i_8779: PUSH HL		 ; 8779 E5		; guarda HL
	blo	ScrWUp			; no, seguir				; 	PUSH DE			 ; 877A D5		; guarda DE
	ldd	#$FFFF			; todo unos para borrar			; 	LD C, $08		 ; 877B 0E 08		; contador C a 8 (bytes por linea de texto)
Clean	std	,u++			; borra 2 bytes				; i_877D: PUSH HL		 ; 877D E5		; guarda HL
	cmpu	#$2000			; final linea 18?			; 	PUSH DE			 ; 877E D5		; guarda DE
	blo	Clean			; no, seguir				; 	PUSH BC			 ; 877F C5		; guarda BC
	puls	cc,d,x,u,pc		; recupera registros y retorna		; 	LD C, $20		 ; 8780 0E 20		; contador BC = 32 (bytes en una fila de pixels)
										; 	LDIR			 ; 8782 ED B0		; copia 32 bytes (una fila de pixels) de origen (HL) a destino (DE)
										; 	POP BC			 ; 8784 C1		; recupera BC
										; 	POP DE			 ; 8785 D1		; recupera DE 
										; 	POP HL			 ; 8786 E1		; recupera HL 
										; 	INC H			 ; 8787 24		; apunta a siguiente fila de pixels de la misma fila de texto (+256 bytes) 
										; 	INC D			 ; 8788 14		; apunta a siguiente fila de pixels de la misma fila de texto (+256 bytes)
										; 	DEC C			 ; 8789 0D		; decrementa contador de filas de pixels (8)
										; 	JR NZ, i_877D		 ; 878A 20 F1		; mientras no llegue a cero, bucle a copiar otra hilera de pixels
										; 	POP DE			 ; 878C D1		; recupera DE (apuntaba a primera fila de pixels)
										; 	POP HL			 ; 878D E1		; recupera HL (apuntaba a primera fila de pixels)
										; 	LD C, $20		 ; 878E 0E 20		; carga C con 32, de forma que ahora BC = $20 (32)
										; 	ADD HL, BC		 ; 8790 09		; HL apunta a siguente fila por debajo
										; 	EX DE, HL		 ; 8791 EB		; toma DE para operar con el
										; 	ADD HL, BC		 ; 8792 09		; apunta a siguiente fila por debajo
										; 	EX DE, HL		 ; 8793 EB		; la devuelve a DE y recupera su valor
										; 	PUSH AF			 ; 8794 F5		; guarda registro y flags
										; 	LD A, D			 ; 8795 7A		; pasa byte alto direccin destino a registro A
										; 	AND $07			 ; 8796 E6 07		; detecta si esta fila ya no est en el mismo bloque de 8 filas 
										; 	JR Z, i_879E		 ; 8798 28 04		; si flag Z=1 as es, salta a i_879E (no requiere correccin)
										; 	LD A, D			 ; 879A 7A		; pasa byte alto de DE a A
										; 	ADD A, $07		 ; 879B C6 07		; le aade $07 (si era $4100 pasa a $4800 = primera fila segundo bloque de 8!)
										; 	LD D, A			 ; 879D 57		; actualiza DE para que apunte a esta nueva fila
										; i_879E: LD A, H		 ; 879E 7C		; pasa byte alto HL a registro A
										; 	AND $07			 ; 879F E6 07		; mira si esta fila esta en el mismo bloque de 8 filas 
										; 	JR Z, i_87A7		 ; 87A1 28 04		; si flag Z=1 as es, salta a i_87A7 (no requiere correccin)
										; 	LD A, H			 ; 87A3 7C		; pasa byte alto de HL a A
										; 	ADD A, $07		 ; 87A4 C6 07		; le aade $07 (si era $4120 pasa a $4820 = segunda fila segundo bloque de 8!)
										; 	LD H, A			 ; 87A6 67		; actualiza HL para que apunte a esta nueva fila
										; i_87A7: POP AF		 ; 87A7 F1		; recupera registro y flags
										; 	DEC A			 ; 87A8 3D		; decrementa contador de lineas a copiar hacia arriba (17 al inicio)
										; 	JR NZ, i_8779		 ; 87A9 20 CE		; mientras no llegue a cero, bucle a i_8779 (otra linea mas)
										; 	LD HL, $5820		 ; 87AB 21 20 58	; apunta a inicio de datos de color en pantalla de la 2da fila
										; 	LD DE, $5800		 ; 87AE 11 00 58	; apunta a inicio de datos de color en pantalla de la 1ra fila
										; 	LD BC, $0220		 ; 87B1 01 20 02	; hemos movido 17filasx32bytes= 544 = $220 bytes de atributos a	 mover
										; 	LDIR			 ; 87B4 ED B0		; copia $220 bytes de HL a DE 	; los sube una fila para mantenerlos sincronizados
										; 	LD B, $2A		 ; 87B6 06 2A		; carga contador con 42 caracteres parte superior pantalla)
										; 	LD HL, $5020		 ; 87B8 21 20 50	; apunta al inicio de la linea 18 (la ltima de la parte superior de pantalla) 
										; 	LD C, $01		 ; 87BB 0E 01		; numero de bits a desplazar al mostrar en pantalla 
										; 	LD A, $20		 ; 87BD 3E 20		; carga espacio en blanco
										; i_87BF: CALL PrintCharUppWindow ; 87BF CD C9 87	; llama PrintCharUppWindow
										; 	DJNZ i_87BF		 ; 87C2 10 FB		; envia los 42 blancos para limpiar dicha linea
										; 	POP DE			 ; 87C4 D1		; recupera DE
										; 	POP HL			 ; 87C5 E1		; recupera HL
										; 	POP BC			 ; 87C6 C1		; recupera BC
										; 	POP AF			 ; 87C7 F1		; recupera AF
										; 	RET			 ; 87C8 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Gestiona la impresin en la parte alta de pantalla	      (#18# OK) ;
; Parmetro: A  caracter a imprimir						;
;	     X  puntero pantalla (HL)						;	
;  Preserva: CC, D, reg_BC(U), X(HL), reg_DE(Y)					;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
PrintCharUppWindow								; PrintCharUppWindow:					; Imprime un caracter en la parte alta de pantalla ; antes ; 
	jsr	L_8B22			; llama L_8B22 (imprimir)	
	ldu	<reg_BC			; recupera reg_BC			; 	PUSH AF			 ; 87C9 F5		; guarda AF
	pshs	cc,d			; guarda registros			; 	PUSH BC			 ; 87CA C5		; guarda BC
	pshs	u			; guarda U
	ldy	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; 87CB D5		; guarda DE
	pshs	y			; guarda Y (DE)
	pshs	x			; guarda X (HL)				; 	PUSH HL			 ; 87CC E5		; guarda HL
										; 	LD L, A			 ; 87CD 6F		; pasa A a L
	ldb	#8			; 8 bytes por caracter			; 	LD H, $00		 ; 87CE 26 00		; byte alto a cero
	mul				; calcula offset a MainFont		; 	ADD HL, HL		 ; 87D0 29		; multiplica el apuntador HL por 8
										; 	ADD HL, HL		 ; 87D1 29		; porque cada caracter
										; 	ADD HL, HL		 ; 87D2 29		; ocupa 8 bytes en MainFont
	ldy	#MAINFONT-256		; inicio de Mainfont-$100 ($20 * 8)	; 	LD DE, MAINFONT-$100	 ; 87D3 11 22 87	; esto est $100 antes del inicio del juego de chars de MainFont
	leay	d,y			; calcula inicio letra a imprimir	; 	ADD HL, DE		 ; 87D6 19		; obtiene el puntero + offset a MainFont (8 x char)
	sty	<reg_DE			; guarda resultado			; 	EX DE, HL		 ; 87D7 EB		; pasa HL a DE
										; 	POP HL			 ; 87D8 E1		; recupera HL original (el recibido al entrar)
										; 	PUSH HL			 ; 87D9 E5		; lo vuelve a guardar
	lda	#8			; numero de bytes a imprimir		; 	LD B, $08		 ; 87DA 06 08		; numero de bytes a imprimir (en 8 filas separadas 256 bytes en vertical)
	sta	<reg_B			; lo guarda en contador reg_B
i_87DC	lda	,y			; toma un byte de mainfont		; i_87DC: LD A, (DE)		 ; 87DC 1A		; lee un byte de MainFont
	coma				; invierte bits (original es negativo)
	ldu	<reg_BC  		; recupera reg_BC
	pshs	u			; lo guarda				; 	PUSH BC			 ; 87DD C5		; guarda BC (contadores)
	ldb	#$FF			; carga B con $FF			; 	DEC C			 ; 87DE 0D		; decrementa C
	stb	<reg_B			; lo guarda en reg_B			; 	INC C			 ; 87DF 0C		; lo incrementa, para adecuar flags
	tst	<reg_C			; es 0 reg_C?				; 	LD B, $FF		 ; 87E0 06 FF		; B=$FF	(mascara todo unos)
	beq	i_87EB			; si, salta a i_87EB			; 	JR Z, i_87EB		 ; 87E2 28 07		; si C es cero, salta a i_87EB
i_87E4	lsra				; desplaza A a derecha			; i_87E4: SRL A			 ; 87E4 CB 3F		; desplaza A a la derecha. Entra un cero por el b7 y el b0 va al carry
	lsr	<reg_B			; desplaza reg_B a derecha		; 	SRL B			 ; 87E6 CB 38		; desplaza B a la derecha. La secuencia de valores ser $7F, $3F, $1F, $0F, $07, $03, $01, $00
	dec	<reg_C			; decrementa reg_C			; 	DEC C			 ; 87E8 0D		; decrementa contador de bits a desplazar
	bne	i_87E4			; mientras no sea cero, vuelve a i_87E4	; 	JR NZ, i_87E4		 ; 87E9 20 F9		; mientras C no sea cero sigue moviendo los bits de A y B a la derecha
i_87EB	sta	<reg_C			; guarda A en reg_C			; i_87EB: LD C, A		 ; 87EB 4F		; guarda A tras shifts en C
	lda	<reg_B			; recupera reg_B			; 	LD A, B			 ; 87EC 78		; pasa B tras los shifts a A
	coma				; invierte bits				; 	CPL			 ; 87ED 2F		; invierte los bits de A = complemento a UNOs
	anda	,x			; aplica mascara al byte de pantalla	; 	AND (HL)		 ; 87EE A6		; aplica mscara (ver valores en SRL B) al contenido del byte actual de pantalla
	ora	<reg_C			; le aade los bits del char a imprimir	; 	OR C			 ; 87EF B1		; Le 'aade' los bits del caracter a imprimir
	sta	,x			; lo muestra en pantalla		; 	LD (HL), A		 ; 87F0 77		; (HL) = A	; Pasa a pantalla el valor calculado en estas operaciones
	puls 	u			; recupera U
	stu	<reg_BC			; lo guarda en reg_BC			; 	POP BC			 ; 87F1 C1		; recupera BC
	tst	<reg_C			; es 0 reg_C?				; 	DEC C			 ; 87F2 0D		; decrementa C
										; 	INC C			 ; 87F3 0C		; incrementa C, para adecuar indicadores
	beq	i_880E			; si, salta a i_880E			; 	JR Z, i_880E		 ; 87F4 28 18		; si C es cero, salta a i_880E
	pshs	u			; guarda BC (U)				; 	PUSH BC			 ; 87F6 C5		; guarda BC
	lda	#8			; num bits x byte			; 	LD A, $08		 ; 87F7 3E 08		; A=8 nmero de bits de 1 byte
	suba	<reg_C			; resta bits ocupados en byte pantalla	; 	SUB C			 ; 87F9 91		; A = 8 - C
	sta	<reg_C			; garda resultado en reg_C		; 	LD C, A			 ; 87FA 4F		; guarda en C el resultado de 8 - C (8 - bits desplazados)
	lda	,y			; lee byte de mainfont			; 	LD A, (DE)		 ; 87FB 1A		; lee el byte de MainFont
	coma				; invierte bits (original es negativo)
	ldb	#$FF			; mascara todo Unos			
	stb	<reg_B			; lo guarda en reg_B			; 	LD B, $FF		 ; 87FC 06 FF		; B = $FF	; Mascara todo unos
i_87FE	lsla				; rota A a izquierda			; i_87FE: SLA A			 ; 87FE CB 27		; rota A a la izquierda. Entra un cero por el b0 y el b7 va al carry
	lsl	<reg_B			; rota reg_B a izquierda		; 	SLA B			 ; 8800 CB 20		; rota B a la izquierda. La secuencia de valores ser $FE, $FC, $F8, $F0, $E0, $C0, $80, $00
	dec	<reg_C			; decrementa reg_C			; 	DEC C			 ; 8802 0D		; decrementa C contador de shifts a realizar
	bne	i_87FE			; si no es 0, vuelve a i_87FE		; 	JR NZ, i_87FE		 ; 8803 20 F9		; si no es cero vuelve a i_87FE
	sta	<reg_C			; guarda A en reg_C			; 	LD C, A			 ; 8805 4F		; guarda A tras los shifts en C
	lda	<reg_B			; recupera reg_B			; 	LD A, B			 ; 8806 78		; guarda B tras los shifts en A
	coma				; invierte bits				; 	CPL			 ; 8807 2F		; invierte los bits de A = complemento a UNOs
	leax	1,x			; incrementa puntero pantalla		; 	INC HL			 ; 8808 23		; Incrementa puntero a pantalla (byte siguiente)
	anda	,x			; aplica mscara			; 	AND (HL)		 ; 8809 A6		; aplica mscara (ver valores en SRL B) al contenido del byte actual de pantalla
	ora	<reg_C			; le aade bits del char a imprimir	; 	OR C			 ; 880A B1		; le 'aade' los bits de caracter a imprimir
	sta	,x			; muestra el byte			; 	LD (HL), A		 ; 880B 77		; actualiza valor de este byte de pantalla
	leax	-1,x			; decrementa puntero pantalla		; 	DEC HL			 ; 880C 2B		; apunta de nuevo al byte anterior
	puls	u			; recupera U					
	stu	<reg_BC			; lo guarda en reg_BC			; 	POP BC			 ; 880D C1		; recupera BC (contadores)
i_880E	leay	1,y			; incrementa puntero MainFont		; i_880E: INC DE		 ; 880E 13		; incrementa DE, apunta al siguiente byte de MainFont
	sty	<reg_DE			; lo guarda en reg_DE
	leax	32,x			; pasa a fila de pixels de abajo	; 	INC H			 ; 880F 24		; suma 256 a HL para apuntar al byte de debajo del recin procesado
	dec	<reg_B			; decrementa contador reg_B	
	bne	i_87DC			; si no es 0, vuelve a i_87DC		; 	DJNZ i_87DC		 ; 8810 10 CA		; decrementa contador B, y si no es cero, bucle a siguiente byte
	puls	x			; recupera X HL				; 	POP HL			 ; 8812 E1		; recupera HL
	puls	y			; recupera Y (DE)			; 	POP DE			 ; 8813 D1		; recupera DE
	sty	<reg_DE			; lo guarda en reg_DE
	puls	u			; recupera U (BC)			; 	POP BC			 ; 8814 C1		; recupera BC - en C est el contador de bits desplazados
	stu	<reg_BC			; lo guarda en reg_BC
	lda	<reg_C			; recupera reg_C			; 	LD A, C			 ; 8815 79		; lo pasa a A
	adda	#6			; le suma 6				; 	ADD A, $06		 ; 8816 C6 06		; le suma 6 (anchura de un caracter en pixels)
	cmpa	#8			; es mayor que 8?			; 	CP $08			 ; 8818 FE 08		; lo compara con 8 (pixels por byte)
	bcs	i_881F			; no, salta a i_881F			; 	JR C, i_881F		 ; 881A 38 03		; si A<8, salta a i_881F
	suba	#8			; le resta 8				; 	SUB $08			 ; 881C D6 08		; si A>=8, le resta 8
	leax	1,x			; incrementa X (HL)			; 	INC L			 ; 881E 2C		; HL apunta al siguiente byte de pantalla
i_881F	sta	<reg_C			; guarda A en reg_C			; i_881F: LD C, A		 ; 881F 4F		; guarda A calculado en C
	puls	cc,d,pc			; recupera registros y retorna		; 	POP AF			 ; 8820 F1		; recupera A y flags
										; 	RET			 ; 8821 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Envia a Impresora el caracter recibido en A	      (#24# --) ;
;  Preserva: D, X, U 								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_8B22	tst	L_B6F2			; recupera L_B6F2			; L_8B22: LD A,(L_B6F2)	 	 ; 8B22 3A F2 B6	; recupera L_B6F2 (flag imprimir o no)
	beq	e8B22			; si 0, sale via ePrint			; 	AND A			 ; 8B25	A7		; es 0?
										; 	RET Z			 ; 8B26 C8		; si, retorna (no imprime nada)
	pshs	d,x,u			; guarda registros			; 	PUSH HL			 ; 8B27 E5		; guarda HL
										; 	PUSH DE			 ; 8B28 D5		; guarda DE
	ldu	#1000			; carga 1000d (retardo)			; 	PUSH BC			 ; 8B29 C5		; guarda BC
WaitP	leau	-1,u			; decrementa retardo			; 	LD D, $01		 ; 8B2A 16 01		; pone 1 en D
	beq	ePrint			; si cero, sale via ePrint		; 	LD HL, $5020		 ; 8B2C 21 20 50	; apunta a inicio linea 18 de pantalla
	ldb	$FF22			; lee bit 'Busy'			; 	XOR A			 ; 8B2F AF		; pone 0 en A y
	rorb				; esta a 1?				; 	LD E, A			 ; 8B30 5F		; en E, DE = $0100
	bcs	WaitP			; si, espera				; i_8B31: OUT ($FB), A		 ; 8B31 D3 FB		; enva A a la impresora
										; i_8B33: IN A, ($FB)		 ; 8B33 DB FB		; Lee estado impresora
										; 	ADD A, A		 ; 8B35 87		; mueve A a la izquierda 1 bit, bit6 pasa al bit7
										; 	JP M, i_8B74		 ; 8B36 FA 74 8B	; si es negativo (apagada), sale via i_8B74
	jsr	$800F			; envia char a la impresora		; 	JR NC, i_8B33		 ; 8B39 30 F8		; si no ha habido Carry (ocupada), vuelve a i_8B33
										; 	PUSH HL			 ; 8B3B E5		; guarda HL
										; 	PUSH DE			 ; 8B3C D5		; guarda DE
ePrint	puls	d,x,u			; recupera registros			; 	LD A, D			 ; 8B3D 7A		; pasa D a A
e8B22	rts				; retorna				; 	CP $02			 ; 8B3E FE 02		; compara A con 2 (flag C=1 si A<2)
										; 	SBC A, A		 ; 8B40 9F		; A=A-A-Carry (A=0 si C=0, A=$FF si C=1)
										; 	AND E			 ; 8B41 A3		; A=A AND E
										; 	RLCA			 ; 8B42 07		; Rota a la izq. circular A (b7 pasa a b0 y al Carry)
										; 	AND E			 ; 8B43 A3		; A=A AND E
										; 	LD D, A			 ; 8B44 57		; guarda resultado en D
										; i_8B45: LD C, (HL)		 ; 8B45 4E		; recupera contenido byte de pantalla 
										; 	PUSH HL			 ; 8B46 E5		; Guarda HL
										; 	LD B, $08		 ; 8B47 06 08		; contador B=8
										; i_8B49: LD A, D		 ; 8B49 7A		; recupera A de D
										; 	RLC C			 ; 8B4A CB 01		; Rota a la Izq circular C (b7 pasa a b0 y al Carry)
										; 	RRA			 ; 8B4C 1F		; Rota a la Der circular A (b0 pasa al carry y Carry a b7)
										; 	LD H, A			 ; 8B4D 67		; guarda valor en H
										; i_8B4E: IN A, ($FB)		 ; 8B4E DB FB		; Lee estado impresora
										; 	RRA			 ; 8B50 1F		; Rota a la Derecha A
										; 	JR NC, i_8B4E		 ; 8B51 30 FB		; si no ha habido Carry (ocupada), vuelve a i_8B4E
										; 	LD A, H			 ; 8B53 7C		; recupera A
										; 	OUT ($FB), A		 ; 8B54 D3 FB		; enva A a la impresora
										; 	DJNZ i_8B49		 ; 8B56 10 F1		; decrementa contador B, si no es cero, vuelve a i_8B49
										; 	POP HL			 ; 8B58 E1		; Recupera HL
										; 	INC HL			 ; 8B59 23		; Incrementa HL
										; 	LD A, L			 ; 8B5A 7D		; pasa L a A
										; 	AND $1F			 ; 8B5B E6 1F		; se queda con los bits 4-3-2-1-0 (controla final de linea)
										; 	JR NZ, i_8B45		 ; 8B5D 20 E6		; si no es cero, vuelve a i_8B45 (siguiente caracter)
										; i_8B5F: IN A, ($FB)		 ; 8B5F DB FB		; Lee estado impresora
										; 	RRA			 ; 8B61 1F		; rota a la derecha A
										; 	JR NC, i_8B5F		 ; 8B62 30 FB		; si no ha habido Carry (ocupada), vuelve a i_8B5F
										; 	LD A, D			 ; 8B64 7A		; pasa D a A
										; 	RRCA			 ; 8B65 0F		; rota a la derecha circular a A (bit0 a b7 y al carry)
										; 	OUT ($FB), A		 ; 8B66 D3 FB		; enva A a la impresora
										; 	POP DE			 ; 8B68 D1		; recupera DE
										; 	POP HL			 ; 8B69 E1		; recupera HL
										; 	INC H			 ; 8B6A 24		; incrementa H (suma 256 a HL)
										; 	INC E			 ; 8B6B 1C		; incrementa E
										; 	BIT 3, E		 ; 8B6C CB 5B		; est a 1 el bit3 de E?
										; 	JR Z, i_8B31		 ; 8B6E 28 C1		; no, vuelve a i_8B31
										; 	LD A, $04		 ; 8B70 3E 04		; A = 4
										; 	OUT ($FB), A		 ; 8B72 D3 FB		; enva A a la impresora
										; i_8B74: POP BC		 ; 8B74 C1		; Recupera BC
										; 	POP DE			 ; 8B75 D1		; Recupera DE
										; 	POP HL			 ; 8B76 E1		; Recupera HL
										; 	RET			 ; 8B77 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; NO HACE FALTA				; 							; (-06-)	; Cuenta desde 1000 hasta 0 y retorna
										; L_8B78: LD BC, $03E8		 ; 8B78 01 E8 03	; BC = $03E8 (1000 decimal)
										; i_8B7B: DEC BC		 ; 8B7B 0B		; decrementa BC
										; 	LD A, B			 ; 8B7C 78		; pasa B a A
										; 	OR C			 ; 8B7D B1		; ha llegado BC a 0?
										; 	JR NZ, i_8B7B		 ; 8B7E 20 FB		; no, vuelve a i_8B7B
										; 	RET			 ; 8B80 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: lee teclado					  (# sinNumero)	;
; Resultado: A  tecla pulsada							;
;  Preserva: B, U(HL)								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
GetKey	pshs	b,u			; guarda registros			; GetKey: PUSH HL		 ; 8B93 E5		; guarda HL
	ldb	#$05			; bucle retardo primer nivel
	ldu	#$7000			; contador a $7000			; 	PUSH IX			 ; 8B94 DD E5		; guarda IX
GetK01	leau	-1,u			; decrementa contador segundo nivel	; 	PUSH BC			 ; 8B96 C5		; guarda BC
	bne	GetK02			; si no es cero, salta a GetK02		; 	CALL L_8B78		 ; 8B97 CD 78 8B	; llama L_8B78 (bucle espera), vuelve con BC=$0000
	decb				; decrementa contador primer nivel
	beq	eGetK			; si cero, sale via eGetK
GetK02	jsr	ReadKey			; lee teclado				; 	LD (L_8B89), BC		 ; 8B9A ED 43 89 8B	; pone a cero L_8B89-8A
	beq	GetK01			; ninguna tecla, vuelve a GetK01	; 	LD HL, L_8B8B		 ; 8B9E 21 8B 8B	; apunta a L_8B8B  (-D02-) Area1 de 8 bytes
eGetK	puls	b,u,pc			; recupera registros y retorna		; 	LD IX, L_8B81		 ; 8BA1 DD 21 81 8B	; apunta a L_8B81  (-D02-) Area2 de 8 bytes
										; 	LD BC, $FEFE		 ; 8BA5 01 FE FE	; carga BC con $FEFE
										; i_8BA8: IN A, (C)		 ; 8BA8 ED 78		; lee una semifila (de CAPS SHIFT a V, la primera vez)
										; 	AND $1F			 ; 8BAA E6 1F		; Deja solo los 5 Bits bajos
										; 	OR (IX+$00)		 ; 8BAC DD B6 00	; OR con byte del Area2
										; 	PUSH AF			 ; 8BAF F5		; Guarda A y flags
										; 	CPL			 ; 8BB0 2F		; invierte bits de A
										; 	AND (HL)		 ; 8BB1 A6		; AND con byte del Area1
										; 	CPL			 ; 8BB2 2F		; invierte bits de A
										; 	JR Z, i_8BBC		 ; 8BB3 28 07		; si es cero, salta a i_8BBC
										; 	LD (L_8B89), BC		 ; 8BB5 ED 43 89 8B	; guarda BC en L_8B89-8A
										; 	LD (L_8B89), A		 ; 8BB9 32 89 8B	; guarda A en L_8B89 (sobreescribe el byte bajo guardado de BC)
										; i_8BBC: POP AF		 ; 8BBC F1		; recupera A y flags
										; 	LD (HL), A		 ; 8BBD 77		; guarda A en Area1
										; 	INC HL			 ; 8BBE 23		; incrementa puntero Area1
										; 	INC IX			 ; 8BBF DD 23		; incrementa puntero Area2
										; 	RLC B			 ; 8BC1 CB 00		; rota circular Izq B (valores:$FE=>$FD,$FB,$F7,$EF,$DF,$BF,$7F) resto semifilas
										; 	JR C, i_8BA8		 ; 8BC3 38 E3		; si ha habido Carry, volver a i_8BA8 (siguiente semifila)
										; 	LD BC, (L_8B89)		 ; 8BC5 ED 4B 89 8B	; recupera L_8B89-8A
										; 	LD A, B			 ; 8BC9 78		; comprueba
										; 	OR C			 ; 8BCA B1		; si BC es 0
										; 	JR Z, i_8BF6		 ; 8BCB 28 29		; si, sale via i_8BF6
										; 	LD A, $FB		 ; 8BCD 3E FB		; A=$FB 
										; i_8BCF: ADD A, $05		 ; 8BCF C6 05		; A=A+5	esto dara 256 = $00 en A
										; 	RRC B			 ; 8BD1 CB 08		; rota circular a la derecha B (bit0 va a bit7 y al Carry)
										; 	JR C, i_8BCF		 ; 8BD3 38 FA		; si flag C=1, salta a i_8BCF (suma 5 y repite)
										; 	DEC A			 ; 8BD5 3D		; decrementa A
										; i_8BD6: INC A			 ; 8BD6 3C		; incrementa A (adecua flags)
										; 	RRC C			 ; 8BD7 CB 09		; rota circular a la derecha C (bit0 va a bit7 y al Carry)
										; 	JR C, i_8BD6		 ; 8BD9 38 FB		; si flag C=1, salta a i_8BD6 (Incrementa A y repite)
										; 	LD C, A			 ; 8BDB 4F		; guarda A en C
										; 	LD B, $00		 ; 8BDC 06 00		; B=0
										; 	LD HL, KEYBMAP1		 ; 8BDE 21 FB 8B	; apunta a KEYBMAP1
										; 	LD A, $FE		 ; 8BE1 3E FE		; A = $FE (semifila Shift-Z-X-C-V)
										; 	IN A, ($FE)		 ; 8BE3 DB FE		; lee el teclado $FEFE
										; 	AND $01			 ; 8BE5 E6 01		; est el bit0 a 1?
										; 	JR Z, i_8BF1		 ; 8BE7 28 08		; no, salta a i_8BF1
										; 	LD A, $7F		 ; 8BE9 3E 7F		; si, A = $7F (semifila B,N,M,SYMB,SPACE)
										; 	IN A, ($FE)		 ; 8BEB DB FE		; lee el teclado $7FFE
										; 	AND $02			 ; 8BED E6 02		; se puls "SYMB"?
										; 	JR NZ, i_8BF4		 ; 8BEF 20 03		; si, salta a i_8BF4
										; i_8BF1: LD HL, KEYBMAP2	 ; 8BF1 21 23 8C	; apunta a KEYBMAP2
										; i_8BF4: ADD HL, BC		 ; 8BF4 09		; aade offset a tabla
										; 	LD A, (HL)		 ; 8BF5 7E		; toma la letra
										; i_8BF6: POP BC		 ; 8BF6 C1		; recupera BC
										; 	POP IX			 ; 8BF7 DD E1		; recupera IX
										; 	POP HL			 ; 8BF9 E1		; recupera HL
										; 	RET			 ; 8BFA C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Look									;Action_Look:						; (-07-)
	jsr	BreakIfB6faNot1		; verificar si se puede seguir		;	CALL BreakIfB6faNot1	 ; 8C4B CD 44 9D	; llama BreakIfB6faNot1
	ldy	ObjectPointer		; recupera ObjectPointer		;	LD IX, (ObjectPointer)	 ; 8C4E DD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IX			; actualiza registro
	lda	1,y			; recupera codigo contenedor		;	LD A, (IX+$01)		 ; 8C52 DD 7E 01	; A = (IX+$01)	; A se carga con el primer byte de OBJ_TABLE
	cmpa	#$FF			; est dentro de otro objeto?		;	CP $FF			 ; 8C55 FE FF		; A = $FF? 	; est contenido en otro objeto?
	beq	i_8C95			; no, salir				;	JR Z, i_8C95		 ; 8C57 28 3C		; Z = 1?	; No, sale via i_8C95
	ldx	#$8000			; valor ninguna palabra			;	LD HL, $0080		 ; 8C59 21 80 00	; HL = $0080	; guardar $8000 en (L_AFFD) = palabra nula, NO imprimir nada
	stx	L_AFFC+1		; limpia dos bytes en el mensaje	;	LD (L_AFFC+$01), HL	 ; 8C5C 22 FD AF	; ($AFFD), HL	;  modifica 2 bytes del mensaje en L_AFFC con valor en HL
	ldx	#L_AFFC			; apunta a mensaje			;	LD HL, L_AFFC		 ; 8C5F 21 FC AF	; HL = L_AFFC	; Apunta a mensaje "You are [0x16]" ya modificado (ha perdido el 'in')
	jsr	PrintMsg		; lo imprime				;	CALL PrintMsg		 ; 8C62 CD DD 72	; llama rutina PrintMsg
	pshs	y			; guarda puntero objeto			;	PUSH IX			 ; 8C65 DD E5		; Guarda IX
	lda	1,y			; toma cdigo objeto contenedor		;	LD A, (IX+$01)		 ; 8C67 DD 7E 01	; A = (IX+$01)	;  A se carga con el primer byte de OBJ_TABLE
	jsr	GetObjPointer2IX	; obtiene puntero al objeto en Y	;	CALL GetObjPointer2IX	 ; 8C6A CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	jsr	L_A09D			; llama L_A09D				;	CALL L_A09D		 ; 8C6D CD 9D A0	; Llama a (-08-)
	ldd	8,y			; toma bytes 8-9			;	LD E, (IX+$08)		 ; 8C70 DD 5E 08	; E = (IX+$08)	; Carga el byte 8 E
	anda	#$0F			; elimina MODE del byte alto		;	LD A, (IX+$09)		 ; 8C73 DD 7E 09	; A = (IX+$09)	; Carga el byte 9 en A
	std	<reg_DE			; actualiza registro DE			;	AND $0F			 ; 8C76 E6 0F		; A = A AND $0F	; conserva el nibble bajo, 4 bits bajos, le quita bit7 y posibles atributos
					 					;	LD D, A			 ; 8C78 57		; D = A		; forma en DE la direccin de la palabra 1 sin el $6000
	jsr	PrintWord		; imprimir palabra			;	CALL PrintWord		 ; 8C79 CD C1 74	; llama rutina PrintWord
	lda	#$2E			; codigo ASCII de punto			;	LD A, $2E		 ; 8C7C 3E 2E		; A = $2E	; cdigo ASCII para '.'
	jsr	PutChar			; imprimir caracter			;	CALL PutChar		 ; 8C7E CD 8B 85	; llama rutina PutChar
	jsr	PutEnter		; imprimir Enter			;	CALL PutEnter		 ; 8C81 CD 83 85	; llama rutina PutEnter
	ldx	#L_B003			; apunta a mensaje			;	LD HL, L_B003		 ; 8C84 21 03 B0	; apunta a mensaje "You see :[0x14]"
	jsr	PrintMsg		; imprime mensaje			;	CALL PrintMsg		 ; 8C87 CD DD 72	; llama rutina PrintMsg
	puls	y			; recupera puntero objeto		;	POP IX			 ; 8C8A DD E1		; Recupera IX
	sty	<reg_IX			; actualiza registro
	lda	1,y			; toma codigo contenedor		;	LD A, (IX+$01)		 ; 8C8C DD 7E 01	; A = (IX+$01)	; Carga el byte 1 en A. Si no es $FF indica el ID del objeto donde est alojado
	ldb	16,y			; localizacin actual			;	LD B, (IX+$10)		 ; 8C8F DD 46 10	; B = (IX+$10)	; Carga el byte 16 en B. Contiene la localizacin donde se encuentra ahora
	stb	<reg_B			; al registro B					
	jmp	L_9FAF			; salta a L_9FAF			;	JP L_9FAF		 ; 8C92 C3 AF 9F	; Salta a L_9FAF Llama a (-09-)
i_8C95	lda	16,y			; toma localizacin			;i_8C95: LD A, (IX+$10)		 ; 8C95 DD 7E 10	; A = (IX+$10) 
	jmp	L_9630			; salta a L_9630			;	JP L_9630		 ; 8C98 C3 30 96	; Salta a L_9630
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (-19-)
L_8C9B	jsr	OwnsActorCurObject1	; is actor the owner?			; L_8C9B: CALL OwnsActorCurObject1 ; 8C9B CD 78 9C	; llama OwnsActorCurObject1
	bcs	e_8C9B			; yes, exit				; 	RET C			 ; 8C9E D8		; Si C = 1, Retorna
	puls	x			; restore X(HL)				; 	POP HL			 ; 8C9F E1		; Recupera HL
	ldx	#L_ADF1			; point to message			; 	LD HL, L_ADF1		 ; 8CA0 21 F1 AD	; apunta a mensaje "You are not carrying it[0x15]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; 8CA3 C3 DD 72	; salta a PrintMsg
e_8C9B	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Putdown									; Action_Putdown:					; (# sinNumero)
	jsr	L_8C9B			; call L_8C9B				; 	CALL L_8C9B		 ; 8CA6 CD 9B 8C	; llama rutina (-19-)
	jsr	BreakIfB6faNot1		; break if B6FA not 1			; 	CALL BreakIfB6faNot1	 ; 8CA9 CD 44 9D	; llama BreakIfB6faNot1
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; 8CAC DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	lda	1,y			; get container ID			; 	LD A, (IX+$01)		 ; 8CB0 DD 7E 01	; Carga A con (IX+$01)
	cmpa	#$12			; is it 'rope'?				; 	CP $12			 ; 8CB3 FE 12		; Compara A con $12
	bne	i_8CBB			; no,exit				; 	JR NZ, i_8CBB		 ; 8CB5 20 04		; Si Z = 0, Salta a i_8CBB
	ldy	#L_C366			; point to object 'rope'		; 	LD IX, L_C366		 ; 8CB7 DD 21 66 C3	; Carga IX con L_C366
	sty	<reg_IX			; save pointer
i_8CBB										; i_8CBB: PUSH IX		 ; 8CBB DD E5		; Guarda IX
	ldu	ObjectPointer		; get object pointer			; 	LD IX, (ObjectPointer)	 ; 8CBD DD 2A 0C B7	; recupera ObjectPointer
	lda	1,u			; get container				; 	LD A, (IX+$01)		 ; 8CC1 DD 7E 01	; Carga A con (IX+$01)
										; 	POP IX			 ; 8CC4 DD E1		; Recupera IX
	sta	1,y			; sustitute container in 1st object	; 	LD (IX+$01), A		 ; 8CC6 DD 77 01	; Carga (IX+$01) con A
	ldb	7,y			; get flags
	bitb	#%00000010		; is a fluid?				; 	BIT 1, (IX+$07)		 ; 8CC9 DD CB 07 4E	; Esta a 1 el bit 1 de (IX+$07)?
	beq	e_8CBB			; no, exit				; 	RET Z			 ; 8CCD C8		; Z = 1?	; Retorna si es cero
	clr	16,y			; clear actual location			; 	LD (IX+$10), $00	 ; 8CCE DD 36 10 00	; Carga (IX+$10) con $00
	ldx	#L_B142			; point to mesage			; 	LD HL, L_B142		 ; 8CD2 21 42 B1	; apunta a mensaje "[0x00] evaporate(s|d|ing|es)[0x15]"
										; 	LD DE, $0008		 ; 8CD5 11 08 00	; Carga DE con $0008
	leay	8,y			; adance pointer			; 	ADD IX, DE		 ; 8CD8 DD 19		; Adiciona DE en IX
	sty	<reg_IX			; update reg_IX
	pshs	y			; save it				; 	PUSH IX			 ; 8CDA DD E5		; Guarda IX
	jsr	PrintMsg		; print message				; 	CALL PrintMsg		 ; 8CDC CD DD 72	; LLama rutina PrintMsg
e_8CBB	rts				; return				; 	RET			 ; 8CDF C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#285# --)
L_8CE0	lda	MainObject		; get main object ID			; L_8CE0: LD A, (MainObject)	 ; 8CE0 3A E8 B6	; Carga cdigo objeto principal
	ldx	#SecondObject		; point to 2nd object			; 	LD HL, SecondObject	 ; 8CE3 21 E9 B6	; HL apunta a SecondObject
	jsr	IsObjectOwned		; is it owned?				; 	CALL IsObjectOwned	 ; 8CE6 CD 7E 9C	; llama IsObjectOwned
	tfr	cc,b			; save flags
	ldx	#L_AFB5			; point to message			; 	LD HL, L_AFB5		 ; 8CE9 21 B5 AF	; apunta a mensaje "is not in[0x09][0x15]"
	tfr	b,cc			; restore flags
	lbne	PrintMsg		; if not, show msg			; 	JP NZ, PrintMsg		 ; 8CEC C2 DD 72	; si no es cero, salta a PrintMsg
	bra	L_8D3C			; go to L_8D3C				; 	JR L_8D3C		 ; 8CEF 18 4B		; Salta a L_8D3C
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#182# --)
L_8CF1	ldy	MainObjectPtr		; get pointer				; L_8CF1: LD IX, (MainObjectPtr) ; 8CF1 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	lda	MainObject		; get object				; 	LD A, (MainObject)	 ; 8CF5 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_9CED			; call L_9CED				; 	CALL L_9CED		 ; 8CF8 CD ED 9C	; llama rutina L_9CED (#179# --)
	ldy	<reg_IX			; get pseudoreg
	adda	3,y			; add object mass			; 	ADD A, (IX+$03)		 ; 8CFB DD 86 03	; Adiciona (IX+$03) en A
	bcc	i_8D02			; if not overflow, skip next		; 	JR NC, i_8D02		 ; 8CFE 30 02		; Si C = 0, Salta a i_8D02
	lda	#$ff			; put value $ff				; 	LD A, $FF		 ; 8D00 3E FF		; Carga A con $FF
i_8D02	sta	<reg_B			; at reg_B				; i_8D02: LD B, A		 ; 8D02 47		; Carga B con A
	ldy	ObjectPointer		; get pointer				; 	LD IY, (ObjectPointer)	 ; 8D03 FD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IY			; save it
	lda	3,y			; get object mass			; 	LD A, (IY+$03)		 ; 8D07 FD 7E 03	; Carga A con (IY+$03)
	suba	<reg_B			; subtract saved value			; 	SUB B			 ; 8D0A 90		; Resta B de A
	ldx	#L_AE04			; point to message			; 	LD HL, L_AE04		 ; 8D0B 21 04 AE	; apunta a mensaje "[0x07] is too heavy to lift"
	bcs	i_8D20			; if carry set, exit			; 	JR C, i_8D20		 ; 8D0E 38 10		; Si C = 1, Salta a i_8D20
	pshs	a,cc			; save registers			; 	PUSH AF			 ; 8D10 F5		; Guarda AF
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 8D11 3A EA B6	; Carga ActionActor
	jsr	L_9CED			; call L_9CED				; 	CALL L_9CED		 ; 8D14 CD ED 9C	; llama rutina L_9CED (#179# --)
	sta	<reg_B			; save A in reg_B			; 	LD B, A			 ; 8D17 47		; Carga B con A
	puls	a,cc			; restore registers			; 	POP AF			 ; 8D18 F1		; Recupera AF
	suba	<reg_B			; subtract quantities			; 	SUB B			 ; 8D19 90		; Resta B de A
	bpl	L_8D25			; if positive, skip next		; 	JP P, L_8D25		 ; 8D1A F2 25 8D	; si resultado positivo (signo=0), salta a L_8D25 (#202# --)
	ldx	#L_AE0C			; point to message			; 	LD HL, L_AE0C		 ; 8D1D 21 0C AE	; apunta a mensaje "You are carrying too much"
i_8D20	leas	2,s			; get rid of return address		; i_8D20: EX (SP), HL		 ; 8D20 E3		; Intercambia (SP) con HL
										; 	POP HL			 ; 8D21 E1		; Recupera HL
	lbra	PrintMsg		; print message				; 	JP PrintMsg		 ; 8D22 C3 DD 72	; salta a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#202# --)
L_8D25	jsr	L_9246			; call L_9246				; L_8D25: CALL L_9246		 ; 8D25 CD 46 92	; llama rutina L_9246 (#180# --)
	bne	i_8D2F			; if Z=0 returned, exit			; 	JR NZ, i_8D2F		 ; 8D28 20 05		; Si Z = 0, Salta a i_8D2F
	ldu	<reg_IX			; get pseudo-register
	ldb	7,u			; get flags
	bitb	#%00000010		; is it fluid?				; 	BIT 1, (IX+$07)		 ; 8D2A DD CB 07 4E	; Esta a 1 el bit 1 de (IX+$07)?
	beq	e_8D2F			; no, exit				; 	RET Z			 ; 8D2E C8		; Z = 1?	; Retorna si es cero
i_8D2F	puls	x			; restore X(HL)				; i_8D2F: POP HL		 ; 8D2F E1		; Recupera HL
	lbra	IfB6FAis1DescAction	; describe action if B6FA is 1		; 	JP IfB6FAis1DescAction	 ; 8D30 C3 76 9F	; salta a IfB6FAis1DescAction
e_8D2F	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Pickup									; Action_Pickup:					; (# sinNumero)
	jsr	OwnsActorCurObject1	; is actor the owner?			; 	CALL OwnsActorCurObject1 ; 8D33 CD 78 9C	; llama OwnsActorCurObject1
	ldx	#L_AE11			; point to mesage			; 	LD HL, L_AE11		 ; 8D36 21 11 AE	; apunta a mensaje "You are already carrying[0x07][0x15]"
	lbcs	PrintMsg		; if owner, show message		; 	JP C, PrintMsg		 ; 8D39 DA DD 72	; Si flag C = 1, salta a PrintMsg
L_8D3C	jsr	L_8CF1			; call L_8CF1				; L_8D3C: CALL L_8CF1		 ; 8D3C CD F1 8C	; llama rutina L_8CF1 (#182# --)
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 8D3F 3A EA B6	; Carga ActionActor
i_8D42	jsr	GetObjPointer2IX	; get object pointer (to regY)		; i_8D42: CALL GetObjPointer2IX	 ; 8D42 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 8D45 3A E8 B6	; Carga cdigo objeto principal
	cmpa	1,y			; is main object the container?		; 	CP (IX+$01)		 ; 8D48 DD BE 01	; Compara A con (IX+$01)
	lbeq	IfB6FAis1DescAction	; show desc if B6FA is 1		; 	JP Z, IfB6FAis1DescAction ; 8D4B CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	lda	1,y			; get container				; 	LD A, (IX+$01)		 ; 8D4E DD 7E 01	; Carga A con (IX+$01)
	cmpa	#$ff			; any container?			; 	CP $FF			 ; 8D51 FE FF		; Compara A con $FF
	bne	i_8D42			; yes, loopback				; 	JR NZ, i_8D42		 ; 8D53 20 ED		; Si Z = 0, Salta a i_8D42
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; 8D55 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; 8D59 CD 44 9D	; llama BreakIfB6faNot1
	lda	1,y			; get container				; 	LD A, (IX+$01)		 ; 8D5C DD 7E 01	; Carga A con (IX+$01)
	cmpa	#$12			; is it 'rope'?				; 	CP $12			 ; 8D5F FE 12		; Compara A con $12
	tfr	cc,b			; save flags
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 8D61 3A EA B6	; Carga ActionActor
	tfr	b,cc			; restore flags
	beq	i_8D6A			; if it was 'rope' skip two		; 	JR Z, i_8D6A		 ; 8D64 28 04		; Si Z = 1, Salta a i_8D6A
	sta	1,y			; update container			; 	LD (IX+$01), A		 ; 8D66 DD 77 01	; Carga (IX+$01) con A
	rts				; return				; 	RET			 ; 8D69 C9		; Retorna
i_8D6A	sta	L_C366+1		; update container for rope		; i_8D6A: LD ($C367), A		 ; 8D6A 32 67 C3	; Carga ($C367) con A
	rts				; return				; 	RET			 ; 8D6D C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Dir									;Action_Dir:						; (# sinNumero)
	jsr	IsItDark		; llama IsItDark			;	CALL IsItDark		 ; 8D9D CD ED 95	; llama rutina IsItDark
	bcc	L_8DAB			; si no est oscuro va a L_8DA8		;	JR NC, L_8DAB		 ; 8DA0 30 09		; si flag C=0, salta a L_8DAB (#236# --)
	lda	#$09			; maximo valor admitido			;	LD A, $09		 ; 8DA2 3E 09		; Carga A con $09
	jsr	GetPosRandom		; genera un aleatorio (0-9)		;	CALL GetPosRandom	 ; 8DA4 CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	inca				; pasa a (1-10)				;	INC A			 ; 8DA7 3C		; Incrementa A
	sta	CurrentAction		; lo guarda como accin			;	LD (CurrentAction), A	 ; 8DA8 32 E7 B6	; guarda ID aleatoria de accin
										;							; (#236# --)
L_8DAB	ldu	ObjectPointer		; toma ObjectPointer (U=IY)		;L_8DAB: LD IY, (ObjectPointer)	 ; 8DAB FD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IY			; actualiza reg_IY
	lda	1,u			; lee posible contenedor		;	LD A, (IY+$01)		 ; 8DAF FD 7E 01	; Carga A con (IY+$01)
	cmpa	#$FF			; est en alguno?			;	CP $FF			 ; 8DB2 FE FF		; Compara A con $FF
	beq	i_8DC3			; no, pasa a i_8DC3			;	JR Z, i_8DC3		 ; 8DB4 28 0D		; Si Z = 1, Salta a i_8DC3
	jsr	GetObjPointer2IX	; obtiene puntero a contenedor		;	CALL GetObjPointer2IX	 ; 8DB6 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	ldb	7,y			; recupera sus indicadores (Y=IX)	;	BIT 6, (IX+$07)		 ; 8DB9 DD CB 07 76	; Esta a 1 el bit 6 de (IX+$07)?
	bitb	#%01000000		; es un animal-personaje?
	beq	i_8DD9			; no, pasa a i_8DD9			;	JR Z, i_8DD9		 ; 8DBD 28 1A		; Si Z = 1, Salta a i_8DD9
	ldb	#$FF			; marca como fuera del contenedor
	stb	1,u			; al objeto inicial			;	LD (IY+$01), $FF	 ; 8DBF FD 36 01 FF	; Carga (IY+$01) con $FF
					; GetObjPointer2IX has not changed regU
i_8DC3	lda	ActionActor		; toma ActionActor			;i_8DC3: LD A, (ActionActor)	 ; 8DC3 3A EA B6	; Carga ActionActor
	jsr	L_9CE8			; llama L_9CE8				;	CALL L_9CE8		 ; 8DC6 CD E8 9C	; llama rutina L_9CE8  (#183# --)
	ldu	<reg_IY			; because L_9CE8 has changed regU
	adda	2,u			; suma el volumen que ocupa el actor	;	ADD A, (IY+$02)		 ; 8DC9 FD 86 02	; Adiciona (IY+$02) en A
	sta	L_8D9C			; guarda total 				;	LD (L_8D9C), A		 ; 8DCC 32 9C 8D	; Carga (L_8D9C) con A
	lda	CurrentAction		; toma accin				;	LD A, (CurrentAction)	 ; 8DCF 3A E7 B6	; Carga A con ID de accin
	jsr	L_9F08			; llama L_9F08				;	CALL L_9F08		 ; 8DD2 CD 08 9F	; llama rutina L_9F08 (#184# --)
	cmpa	#$FF			; resultado = $FF?			;	CP $FF			 ; 8DD5 FE FF		; Compara A con $FF
	bne	i_8DFA			; no, pasa a i_8DFA			;	JR NZ, i_8DFA		 ; 8DD7 20 21		; Si Z = 0, Salta a i_8DFA
i_8DD9	jsr	IsItDark		; llama IsItDark			;i_8DD9: CALL IsItDark		 ; 8DD9 CD ED 95	; llama rutina IsItDark
	lbcc	IfB6FAis1DescAction	; si hay luz llama IfB6FAis1DescAction	;	JP NC, IfB6FAis1DescAction ; 8DDC D2 76 9F	; si flag C=0, salta a IfB6FAis1DescAction
	jsr	BreakIfB6faNot1		; llama BreakIfB6faNot1			;	CALL BreakIfB6faNot1	 ; 8DDF CD 44 9D	; llama BreakIfB6faNot1
	ldy	#OBJ_TABLE		; apunta a Bilbo			;	LD IX, OBJ_TABLE	 ; 8DE2 DD 21 1B C1	; Carga IX con OBJ_TABLE
	sty	<reg_IX			; actualiza reg_IX
	ldx	#L_AD7D			; apunta a mensaje			;	AND A			 ; 8DE6 A7		; A = A AND A	; Adecua flags
	ldb	5,y			; lee la fuerza de Bilbo		;	LD HL, L_AD7D		 ; 8DE7 21 7D AD	; Apunta a mensaje "but fall and hit your head[0x15]"
	lsrb				; lo divide por dos			;	RR (IX+$05)		 ; 8DEA DD CB 05 1E	; Rota circularmente con el Carry (IX+$05)	; el bit0 va al carry y el carry anterior va al bit7
	stb	5,y			; actualiza valor
	lbne	PrintMsg		; si no es cero, muestra mensaje	;	JP NZ, PrintMsg		 ; 8DEE C2 DD 72	; Si flag Z = 0, salta a PrintMsg
	ldx	#L_AD8A			; apunta a mensaje (fatal)		;	LD HL, L_AD8A		 ; 8DF1 21 8A AD	; Apunta a mensaje "but fall and smash your skull"
	jsr	PrintMsg		; muestra mensaje			;	CALL PrintMsg		 ; 8DF4 CD DD 72	; Llama rutina PrintMsg
	lbra	BilboIsDeadEndGame	; pasa a final de juego			;	JP BilboIsDeadEndGame	 ; 8DF7 C3 D2 90	; salta a BilboIsDeadEndGame

i_8DFA	ldy	<reg_IX			; recupera registro			;i_8DFA: LD A, (IX+$02)		 ; 8DFA DD 7E 02	; Carga A con (IX+$02)
	lda	2,y			; lee volumen ocupado			;	AND A			 ; 8DFD A7		; A = A AND A	; Adecua flags
	beq	i_8DD9			; si es cero vuelve a i_8DD9		;	JR Z, i_8DD9		 ; 8DFE 28 D9		; Si Z = 1, Salta a i_8DD9
	sta	L_8D9B			; lo guarda en L_8D9B			;	LD (L_8D9B), A		 ; 8E00 32 9B 8D	; Carga (L_8D9B) con A
	lda	1,y			; lee contenedor			;	LD A, (IX+$01)		 ; 8E03 DD 7E 01	; Carga A con (IX+$01)
	jsr	L_8E85			; llama L_8E85				;	CALL L_8E85		 ; 8E06 CD 85 8E	; llama rutina L_8E85 (#185# --)
	deca				; resultado igual a 1?			;	DEC A			 ; 8E09 3D		; Decrementa A
	beq	i_8DD9			; si, vuelve a i_8DD9			;	JR Z, i_8DD9		 ; 8E0A 28 CD		; Si Z = 1, Salta a i_8DD9
	deca				; resultado = 2?			;	DEC A			 ; 8E0C 3D		; Decrementa A
	beq	i_8E6D			; si, salta a i_8E6D			;	JR Z, i_8E6D		 ; 8E0D 28 5E		; Si Z = 1, Salta a i_8E6D
	deca				; resultado = 3?			;	DEC A			 ; 8E0F 3D		; Decrementa A
	beq	i_8E72			; si, salta a i_8E72			;	JR Z, i_8E72		 ; 8E10 28 60		; Si Z = 1, Salta a i_8E72
										;							; (#232# --)
L_8E12	jsr	BreakIfB6faNot1		; llama BreakIfB6faNot1			;L_8E12: CALL BreakIfB6faNot1	 ; 8E12 CD 44 9D	; llama BreakIfB6faNot1
	ldb	<reg_B			; toma valor de reg_B
	ldu	<reg_IY			; recupera reg_IY
	stb	16,u			; lo pone en localizacin actual	;	LD (IY+$10), B		 ; 8E15 FD 70 10	; actualiza la localizacin
	lda	ActionActor		; toma ActionActor			;	LD A, (ActionActor)	 ; 8E18 3A EA B6	; Carga ActionActor
	jsr	L_9BDD			; llama L_9BDD				;	CALL L_9BDD		 ; 8E1B CD DD 9B	; llama rutina L_9BDD (#186# --)
	lda	ActionActor		; toma ActionActor			;	LD A, (ActionActor)	 ; 8E1E 3A EA B6	; Carga ActionActor
	beq	e_8E12			; si es cero salta a e_8E12		;	CP $00			 ; 8E21 FE 00		; es Bilbo?
s_8E12	rts				; retorna				;	RET NZ			 ; 8E23 C0		; no, retorna
e_8E12	ldy	#LiveStatusChange	; apunta a tabla rutinas		;	LD IX, LiveStatusChange	 ; 8E24 DD 21 8E C7	; apunta a inicio tabla de rutinas LiveStatusChange
	sty	<reg_IX			; actualiza reg_IX
	lda	L_8D9B			; toma el volumen guardado (???)	;	LD A, (L_8D9B)		 ; 8E28 3A 9B 8D	; recupera L_8D9B
	jsr	FindPointer		; busca entrada en la tabla		;	CALL FindPointer	 ; 8E2B CD BD 9D	; busca rutina con cdigo A en tabla LiveStatusChange
	beq	L_8E39			; no encontrada, salta a L_8E39		;	JR Z, L_8E39		 ; 8E2E 28 09		; si no tiene rutina asignada, salta a L_8E39 (#244# --)
	ldx	1,y			; toma direccion rutina			;	LD L, (IX+$01)		 ; 8E30 DD 6E 01	; Carga byte bajo
										;	LD H, (IX+$02)		 ; 8E33 DD 66 02	; Carga byte alto. HL = direccin rutina a ejecutar
	jsr	CallSubrutineHL		; la ejecuta				;	CALL CallSubrutineHL	 ; 8E36 CD 6C 9B	; llama CallSubrutineHL
										;							; (#244# --)
L_8E39	jsr	IsItDark		; llama IsItDark			;L_8E39: CALL IsItDark		 ; 8E39 CD ED 95	; llama rutina IsItDark
	bcs	s_8E12			; si est oscuro, sale			;	RET C			 ; 8E3C D8		; Si C = 1, Retorna
	tst	ActionActor		; testea actor				;	LD A, (ActionActor)	 ; 8E3D 3A EA B6	; Carga ActionActor
	tfr	cc,b			; guarda flags				;	AND A			 ; 8E40 A7		; A = A AND A	; Adecua flags
	lda	L_8D9B			; toma valor guardado			;	LD A, (L_8D9B)		 ; 8E41 3A 9B 8D	; Carga A con (L_8D9B)
	tfr	b,cc			; restaura flags
	bne	i_8E6A			; si actor no es Bilbo, salta a i_8E6A	;	JR NZ, i_8E6A		 ; 8E44 20 24		; Si Z = 0, Salta a i_8E6A
	ldx	L_8D99			; recupera puntero a localizacin	;	LD HL, (L_8D99)		 ; 8E46 2A 99 8D	; Carga HL con (L_8D99)
	ldb	,x			; toma flags localizacin
	bitb	#%01000000		; est a 1 el bit 6?			;	BIT 6, (HL)		 ; 8E49 CB 76		; Esta a 1 el bit 6 de (HL)?
	lbne	L_96A8			; no, salta a L_96A8			;	JP NZ, L_96A8		 ; 8E4B C2 A8 96	; Si Z = 0, Salta a L_96A8
	orb	#%01000000		; pone a 1 el bit6			;	SET 6, (HL)		 ; 8E4E CB F6		; Pasa a 1 el bit 6 en (HL)
	stb	,x			; actualiza flags localizacin
	pshs	cc,a			; salva registros			;	PUSH AF			 ; 8E50 F5		; Guarda AF
	ldy	#L_8D6E			; apunta a datos puntuacin		;	LD IX, L_8D6E		 ; 8E51 DD 21 6E 8D	; Carga IX con L_8D6E
	sty	<reg_IX			; actualiza reg_IX
	jsr	FindPointer		; busca entrada en tabla		;	CALL FindPointer	 ; 8E55 CD BD 9D	; busca puntero con cdigo A e inicio tabla en IX
	beq	i_8E69			; si no encontrado, salta a i_8E69	;	JR Z, i_8E69		 ; 8E58 28 0F		; Si Z = 1, Salta a i_8E69
										;	PUSH DE			 ; 8E5A D5		; Guarda DE
	ldb	1,y			; recupera byte bajo			;	LD E, (IX+$01)		 ; 8E5B DD 5E 01	; Carga E con (IX+$01)
	lda	2,y			; y byte alto				;	LD D, (IX+$02)		 ; 8E5E DD 56 02	; Carga D con (IX+$02)
	ldx	L_B6F7			; recupera % avance			;	LD HL, (L_B6F7)		 ; 8E61 2A F7 B6	; Carga HL con (L_B6F7)
	leax	d,x			; le suma el encontrado en tabla	;	ADD HL, DE		 ; 8E64 19		; Adiciona DE en HL
	stx	L_B6F7			; actualiza variable			;	LD (L_B6F7), HL		 ; 8E65 22 F7 B6	; Carga (L_B6F7) con HL
										;	POP DE			 ; 8E68 D1		; Recupera DE
i_8E69	puls	cc,a			; restaura registros			;i_8E69: POP AF			 ; 8E69 F1		; Recupera AF
i_8E6A	lbra	L_9630			; salta a L_9630			;i_8E6A: JP L_9630		 ; 8E6A C3 30 96	; Salta a L_9630
i_8E6D	ldx	#L_AE23			; apunta a mensaje			;i_8E6D: LD HL, L_AE23		 ; 8E6D 21 23 AE	; apunta a mensaje "[0x04] is too small for you to enter"
	bra	i_8E79			; salta a i_8E79			;	JR i_8E79		 ; 8E70 18 07		; Salta a i_8E79
i_8E72	ldy	L_8D99			; recupera puntero localizacin		;i_8E72: LD IX, (L_8D99)	 ; 8E72 DD 2A 99 8D	; Carga IX con (L_8D99)
	sty	<reg_IX			; actualiza reg_IX
	ldx	#L_AE2E			; apunta a mensaje			;	LD HL, L_AE2E		 ; 8E76 21 2E AE	; apunta a mensaje "[0x04] is too full for you to{5} enter[0x15]"
i_8E79	pshs	x			; guarda registro			;i_8E79: PUSH HL		 ; 8E79 E5		; Guarda HL
	ldx	2,y			; apunta a description word		;	LD L, (IX+$02)		 ; 8E7A DD 6E 02	; Carga L con (IX+$02)
	ldu	,s			; toma word del stack			;	LD H, (IX+$03)		 ; 8E7D DD 66 03	; Carga H con (IX+$03)
	stx	,s			; lo sobreescribe con X			;	EX (SP), HL		 ; 8E80 E3		; Intercambia (SP) con HL
	leax	,u			; pasa el 'extraido' a X
	jsr	PrintMsg		; llama PrintMsg			;	CALL PrintMsg		 ; 8E81 CD DD 72	; llama rutina PrintMsg 
	rts				; retorna				;	RET			 ; 8E84 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#185# --)
L_8E85	tsta				; actualiza flags			;L_8E85: AND A			 ; 8E85 A7		; A = A AND A	; Adecua flags
	beq	i_8EA7			; si Z=1, salta a i_8EA7		;	JR Z, i_8EA7		 ; 8E86 28 1F		; Si Z = 1, Salta a i_8EA7
	jsr	GetObjPointer2IX	; llama	GetObjPointer2IX		;	CALL GetObjPointer2IX	 ; 8E88 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	lda	7,y			; lee flags objeto			;	LD A, (IX+$07)		 ; 8E8B DD 7E 07	; Carga A con (IX+$07)
	anda	#$28			; comprueba abierto y muerto		;	AND $28			 ; 8E8E E6 28		; Hace AND lgico de A con $28
	beq	i_8ECE			; si ambos 0, sale con valor 1		;	JR Z, i_8ECE		 ; 8E90 28 3C		; Si Z = 1, Salta a i_8ECE
	lda	ActionActor		; toma actor				;	LD A, (ActionActor)	 ; 8E92 3A EA B6	; Carga ActionActor
										;	AND A			 ; 8E95 A7		; A = A AND A	; Adecua flags
	bne	i_8E9E			; si no es 0, salta las dos siguientes	;	JR NZ, i_8E9E		 ; 8E96 20 06		; Si Z = 0, Salta a i_8E9E
	tst	4,y			; mira el byte 4 (desconocido)		;	BIT 7, (IX+$04)		 ; 8E98 DD CB 04 7E	; Esta a 1 el bit 7 de (IX+$04)?
	bmi	i_8ECE			; si negativo, sale con valor 1		;	JR NZ, i_8ECE		 ; 8E9C 20 30		; Si Z = 0, Salta a i_8ECE
i_8E9E	lda	L_8D9C			; toma total volumen			;i_8E9E: LD A, (L_8D9C)		 ; 8E9E 3A 9C 8D	; Carga A con (L_8D9C)
	suba	2,y			; le resta el del objeto		;	LD B, (IX+$02)		 ; 8EA1 DD 46 02	; Carga B con (IX+$02)
										;	SUB B			 ; 8EA4 90		; Resta B de A
	bcc	i_8ECA			; si no da negativo sale con valor 2	;	JR NC, i_8ECA		 ; 8EA5 30 23		; Si C = 0, Salta a i_8ECA
i_8EA7	lda	L_8D9B			; toma localizacin			;i_8EA7: LD A, (L_8D9B)		 ; 8EA7 3A 9B 8D	; Carga A con (L_8D9B)
	sta	<reg_B			; la guarda en reg_B			;	LD B, A			 ; 8EAA 47		; Carga B con A
	jsr	GetLocPointer2IX	; busca puntero a localizacion		;	CALL GetLocPointer2IX	 ; 8EAB CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	sty	L_8D99			; lo guarda en L_8D99			;	LD (L_8D99), IX		 ; 8EAE DD 22 99 8D	; Carga (L_8D99) con IX
	lda	#$FF			; valor a comparar			;	LD A, $FF		 ; 8EB2 3E FF		; Carga A con $FF
	cmpa	1,y			; es igual a flag localizacion?		;	CP (IX+$01)		 ; 8EB4 DD BE 01	; Compara A con (IX+$01)
	beq	i_8EC4			; si, sale con valor 0			;	JR Z, i_8EC4		 ; 8EB7 28 0B		; Si Z = 1, Salta a i_8EC4
	lda	<reg_B			; recupera localizacin			;	LD A, B			 ; 8EB9 78		; Carga A con B
	jsr	L_9C41			; llama L_9C41				;	CALL L_9C41		 ; 8EBA CD 41 9C	; llama rutina L_9C41 (#187# --)
	sta	<reg_C			; guarda valor recibido			;	LD C, A			 ; 8EBD 4F		; Carga C con A
	lda	L_8D9C			; recupera volumen			;	LD A, (L_8D9C)		 ; 8EBE 3A 9C 8D	; Carga A con (L_8D9C)
	suba	<reg_C			; le resta valor recibido		;	SUB C			 ; 8EC1 91		; Resta C de A
	bcc	i_8EC6			; si no da negativo sale con valor 3	;	JR NC, i_8EC6		 ; 8EC2 30 02		; Si C = 0, Salta a i_8EC6
i_8EC4	clra				; resultado cero			;i_8EC4: XOR A			 ; 8EC4 AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	rts				; retorna				;	RET			 ; 8EC5 C9		; Retorna
i_8EC6	lda	#$03			; resultado tres			;i_8EC6: LD A, $03		 ; 8EC6 3E 03		; Carga A con $03
										;	AND A			 ; 8EC8 A7		; A = A AND A	; Adecua flags
	rts				; retorna				;	RET			 ; 8EC9 C9		; Retorna
i_8ECA	lda	#$02			; resultado dos				;i_8ECA: LD A, $02		 ; 8ECA 3E 02		; Carga A con $02
										;	AND A			 ; 8ECC A7		; A = A AND A	; Adecua flags
	rts				; retorna				;	RET			 ; 8ECD C9		; Retorna
i_8ECE	lda	#$01			; resultado uno				;i_8ECE: LD A, $01		 ; 8ECE 3E 01		; Carga A con $01
										;	AND A			 ; 8ED0 A7		; A = A AND A	; Adecua flags
	rts				; retorna				;	RET			 ; 8ED1 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#189# --)
L_8ED2	ldy	<reg_IX			; get pseudoreg				; L_8ED2: PUSH IX		 ; 8ED2 DD E5		; Guarda IX
	pshs	y			; save it
	jsr	GetObjPointer2IX	; get pointer				; 	CALL GetObjPointer2IX	 ; 8ED4 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
i_8ED7	lda	1,y			; get container				; i_8ED7: LD A, (IX+$01)	 ; 8ED7 DD 7E 01	; Carga A con (IX+$01)
	cmpa	#$ff			; is none?				; 	CP $FF			 ; 8EDA FE FF		; Compara A con $FF
	beq	i_8EE9			; yes, exit via i_8EE9			; 	JR Z, i_8EE9		 ; 8EDC 28 0B		; Si Z = 1, Salta a i_8EE9
	jsr	GetObjPointer2IX	; get container pointer			; 	CALL GetObjPointer2IX	 ; 8EDE CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	ldb	7,y			; get flags
	bitb	#%00100000		; is it open?				; 	BIT 5, (IX+$07)		 ; 8EE1 DD CB 07 6E	; Esta a 1 el bit 5 de (IX+$07)?
	bne	i_8ED7			; yes, loop				; 	JR NZ, i_8ED7		 ; 8EE5 20 F0		; Si Z = 0, Salta a i_8ED7
	ora	#1			; set Z=0				; 	OR $01			 ; 8EE7 F6 01		; Hace OR lgico de A con $01
i_8EE9	tfr	cc,b			; save flags				; i_8EE9: POP IX		 ; 8EE9 DD E1		; Recupera IX
	puls	y			; restore pseudoreg
	sty	<reg_IX			; update it
	tfr	b,cc			; restore flags
	rts				; return				; 	RET			 ; 8EEB C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#248# --)
L_8EEC	lda	MainObject		; get main object ID			; L_8EEC: LD A, (MainObject)	 ; 8EEC 3A E8 B6	; Carga cdigo objeto principal
	jsr	GetObjPointer2IX	; get its pointer			; 	CALL GetObjPointer2IX	 ; 8EEF CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	jsr	TestOpenFlag		; is it open? 				; 	CALL TestOpenFlag	 ; 8EF2 CD CA A5	; llama TestOpenFlag
	lbeq	PrintObjStatus		; no, show status			; 	JP Z, PrintObjStatus	 ; 8EF5 CA 6C A1	; si cerrado, salta a PrintObjStatus con A=$05 (bit 5 a 0) closed
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#258# --)
L_8EF8	lda	ActionActor		; get actor ID				; L_8EF8: LD A, (ActionActor)	 ; 8EF8 3A EA B6	; Carga ActionActor
	jsr	L_8ED2			; call L_8ED2				; 	CALL L_8ED2		 ; 8EFB CD D2 8E	; llama rutina L_8ED2 (#189# --)
	bne	e_8F35			; if closed, show message		; 	RET NZ			 ; 8EFE C0		; Si Z = 0, Retorna
	jsr	L_9F25			; search for exits			; 	CALL L_9F25		 ; 8EFF CD 25 9F	; llama rutina L_9F25 (#190# --)
	cmpa	#$ff			; none found?				; 	CP $FF			 ; 8F02 FE FF		; Compara A con $FF
	lbeq	IfB6FAis1DescAction	; yes, desc action			; 	JP Z, IfB6FAis1DescAction ; 8F04 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	ldy	<reg_IX			; get pseudoreg				; 	LD A, (IX+$02)		 ; 8F07 DD 7E 02	; Carga A con (IX+$02)
	lda	2,y			; get 'dest' location			; 	CP $00			 ; 8F0A FE 00		; Compara A con $00
	lbeq	IfB6FAis1DescAction	; if zero, desc action			; 	JP Z, IfB6FAis1DescAction ; 8F0C CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	jsr	BreakIfB6faNot1		; exit if b6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 8F0F CD 44 9D	; llama BreakIfB6faNot1
	pshs	y			; save regY				; 	PUSH IX			 ; 8F12 DD E5		; Guarda IX
	jsr	GetLocPointer2IX	; get location pointer			; 	CALL GetLocPointer2IX	 ; 8F14 CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	ldb	,y			; get flags
	bitb	#%10000000		; is it lit?				; 	BIT 7, (IX+$00)		 ; 8F17 DD CB 00 7E	; Esta a 1 el bit 7 de (IX+$00)?
	tfr	cc,b			; save flags
	puls	y			; restore regY				; 	POP IX			 ; 8F1B DD E1		; Recupera IX
	sty	<reg_IX			; update pseudoreg
	tfr	b,cc			; restore flags
	beq	i_8F35			; no light, show it			; 	JR Z, i_8F35		 ; 8F1D 28 16		; Si Z = 1, Sale via i_8F35
	ldu	ObjectPointer		; point to object			; 	LD IY, (ObjectPointer)	 ; 8F1F FD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IY			; save it
	lda	16,u			; get location				; 	LD A, (IY+$10)		 ; 8F23 FD 7E 10	; Carga A con (IY+$10)
	pshs	a,cc			; save registers			; 	PUSH AF			 ; 8F26 F5		; Guarda AF
	lda	2,y			; get 'dest' location			; 	LD A, (IX+$02)		 ; 8F27 DD 7E 02	; Carga A con (IX+$02)
	sta	16,u			; update in object			; 	LD (IY+$10), A		 ; 8F2A FD 77 10	; Carga (IY+$10) con A
	jsr	L_962B			; explain new location			; 	CALL L_962B		 ; 8F2D CD 2B 96	; llama rutina L_962B (#191# --)
	puls	a,cc			; restore registers			; 	POP AF			 ; 8F30 F1		; Recupera AF
	ldu	<reg_IY			; get pseudoreg
	sta	16,u			; update location			; 	LD (IY+$10), A		 ; 8F31 FD 77 10	; Carga (IY+$10) con A
	rts				; return				; 	RET			 ; 8F34 C9		; Retorna
i_8F35	ldx	#L_AE1F			; point to message			; i_8F35: LD HL, L_AE1F		 ; 8F35 21 1F AE	; apunta a mensaje "it is dark"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; 8F38 C3 DD 72	; salta a PrintMsg
e_8F35	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#249# --)
L_8F3B	jsr	L_9F25			; call L_9F25				;  L_8F3B: CALL L_9F25		 ; 8F3B CD 25 9F	; llama rutina L_9F25 (#190# --)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_8F3E	cmpa	#$ff			; is it none?				; L_8F3E: CP $FF		 ; 8F3E FE FF		; Compara A con $FF
	lbeq	IfB6FAis1DescAction	; yes, desc action if B6FA is 1		;	JP Z, IfB6FAis1DescAction ; 8F40 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	ldy	<reg_IX			; get pseudo-register
	lda	2,y			; get volume				;	LD A, (IX+$02)		 ; 8F43 DD 7E 02	; Carga A con (IX+$02)
										;	CP $00			 ; 8F46 FE 00		; Compara A con $00
	lbeq	IfB6FAis1DescAction	; if zero, desc action if B6fa is 1	;	JP Z, IfB6FAis1DescAction ; 8F48 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	lda	1,y			; get container				;	LD A, (IX+$01)		 ; 8F4B DD 7E 01	; Carga A con (IX+$01)
	pshs	y			; save pointer				;	PUSH IX			 ; 8F4E DD E5		; Guarda IX
	jsr	L_8E85			; call L_8E85				;	CALL L_8E85		 ; 8F50 CD 85 8E	; llama rutina L_8E85 (#185# --)
	puls	y			; restore pointer			;	POP IX			 ; 8F53 DD E1		; Recupera IX
	tfr	cc,b			; save received flags
	sty	<reg_IX			; update pointer
	tfr	b,cc			; restore flags
	lbne	IfB6FAis1DescAction	; if Z=0 desc action if B6FA is 1	;	JP NZ, IfB6FAis1DescAction ; 8F55 C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			;	CALL BreakIfB6faNot1	 ; 8F58 CD 44 9D	; llama BreakIfB6faNot1
	lda	,y			; get action				;	LD A, (IX+$00)		 ; 8F5B DD 7E 00	; Carga A con (IX+$00)
	sta	CurrentAction		; save as current			;	LD (CurrentAction), A	 ; 8F5E 32 E7 B6	; guarda ID de accin
	lda	#$ff			; put none				;	LD A, $FF		 ; 8F61 3E FF		; Carga A con $FF
	sta	MainObject		; as main object			;	LD (MainObject), A	 ; 8F63 32 E8 B6	; guarda cdigo objeto principal
	lbra	L_8DAB			; go L_8DAB				;	JP L_8DAB		 ; 8F66 C3 AB 8D	; salta a L_8DAB (#236# --)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#274# --)
L_8F69	ldu	MainObjectPtr		; point to main object			; L_8F69: LD IX, (MainObjectPtr) ; 8F69 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; save ptr
	lda	SecondObject		; get 2nd object ID			; 	LD A, (SecondObject)	 ; 8F6D 3A E9 B6	; Carga cdigo objeto secundario
	cmpa	#$17			; is it 'water'?			; 	CP $17			 ; 8F70 FE 17		; Compara A con $17
	beq	i_8F92			; yes, skip section			; 	JR Z, i_8F92		 ; 8F72 28 1E		; Si Z = 1, Salta a i_8F92
	cmpa	#$18			; is it 'black water'?			; 	CP $18			 ; 8F74 FE 18		; Compara A con $18
	beq	i_8F9A			; yes, skip section			; 	JR Z, i_8F9A		 ; 8F76 28 22		; Si Z = 1, Salta a i_8F9A
i_8F78	ldy	SecndObjectPtr		; point to 2nd object			; i_8F78: LD IY, (SecndObjectPtr) ; 8F78 FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save ptr
	ldb	7,y			; get flags
	bitb	#%00000010		; is it fluid?				; 	BIT 1, (IY+$07)		 ; 8F7C FD CB 07 4E	; Esta a 1 el bit 1 de (IY+$07)?
	lbeq	IfB6FAis1DescAction	; no, desc action			; 	JP Z, IfB6FAis1DescAction ; 8F80 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	lda	#$82			; value true, 'full'			; 	BIT 2, (IX+$07)		 ; 8F83 DD CB 07 56	; Esta a 1 el bit 2 de (IX+$07)?
	bitb	#%00000100		; is it full?				; 	LD A, $82		 ; 8F87 3E 82		; Carga A con $82
	lbne	PrintObjStatus		; yes, show it				; 	JP NZ, PrintObjStatus	 ; 8F89 C2 6C A1	; si flag Z=0, salta a PrintObjStatus con A=$82 (bit 2 a 1) full
	ldx	#L_924F			; point to subroutine			; 	LD HL, L_924F		 ; 8F8C 21 4F 92	; apunta a inicio rutina (#273# --)
	lbra	L_9F4A			; to execute it				; 	JP L_9F4A		 ; 8F8F C3 4A 9F	; salta a L_9F4A (#193# --)
										; 
i_8F92	lda	#$15			; get ID for 'water'			; i_8F92: LD A, $15		 ; 8F92 3E 15		; Carga A con $15
	ldy	#L_C454			; point to 'water'			; 	LD IY, L_C454		 ; 8F94 FD 21 54 C4	; Carga IY con L_C454
	bra	i_8FA0			; skip two				; 	JR i_8FA0		 ; 8F98 18 06		; Salta a i_8FA0
i_8F9A	lda	#$16			; get ID for 'black water'		; i_8F9A: LD A, $16		 ; 8F9A 3E 16		; Carga A con $16
	ldy	#L_C469			; point to 'black water'		; 	LD IY, L_C469		 ; 8F9C FD 21 69 C4	; Carga IY con L_C469
i_8FA0	sty	<reg_IY			; update pointer			; i_8FA0: LD (SecondObject), A	 ; 8FA0 32 E9 B6	; guarda cdigo objeto secundario
	sta	SecondObject		; update 2nd object ID
	sty	SecndObjectPtr		; update 2nd obj ptr			; 	LD (SecndObjectPtr), IY	 ; 8FA3 FD 22 0A B7	; guarda SecndObjectPtr
	ldb	#$ff			; put NO container
	stb	1,y			; in 2nd object				; 	LD (IY+$01), $FF	 ; 8FA7 FD 36 01 FF	; Carga (IY+$01) con $FF
	bra	i_8F78			; go i_8F78				; 	JR i_8F78		 ; 8FAB 18 CB		; Salta a i_8F78
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Run									; Action_Run:						; (# sinNumero)
	lda	#10			; set maximum value to 10		; 	LD A, $0A		 ; 8FAD 3E 0A		; Carga A con $0A
	jsr	GetPosRandom		; get a random number (0-10)		; 	CALL GetPosRandom	 ; 8FAF CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	tsta				; was number equal 0?			; 	CP $00			 ; 8FB2 FE 00		; Compara A con $00
	beq	Action_Run		; yes, repeat				; 	JR Z, Action_Run	 ; 8FB4 28 F7		; Si Z = 1, Salta a Action_Run
i_8FB6	sta	<reg_B			; save random number			; i_8FB6: LD B, A		 ; 8FB6 47		; Carga B con A
	jsr	L_9F08			; call L_9F08				; 	CALL L_9F08		 ; 8FB7 CD 08 9F	; llama rutina L_9F08 (#184# --)
	cmpa	<reg_B			; is exit equal to random number?	; 	CP B			 ; 8FBA B8		; Compara A con B
	beq	i_8FC7			; yes, use it as action			; 	JR Z, i_8FC7		 ; 8FBB 28 0A		; Si Z = 1, Salta a i_8FC7
	lda	<reg_B			; get random number			; 	LD A, B			 ; 8FBD 78		; Carga A con B
	inca				; add 1					; 	INC A			 ; 8FBE 3C		; Incrementa A
	cmpa	#10			; past the maximum value?		; 	CP $0A			 ; 8FBF FE 0A		; Compara A con $0A
	bcs	i_8FB6			; no, loopback				; 	JR C, i_8FB6		 ; 8FC1 38 F3		; Si C = 1, Salta a i_8FB6
	lda	#1			; set minimum value			; 	LD A, $01		 ; 8FC3 3E 01		; Carga A con $01
	bra	i_8FB6			; loopback				; 	JR i_8FB6		 ; 8FC5 18 EF		; Salta a i_8FB6
i_8FC7	sta	CurrentAction		; set as current action			; i_8FC7: LD (CurrentAction), A	 ; 8FC7 32 E7 B6	; guarda ID de accin
	lbra	Action_Dir		; make move				; 	JP Action_Dir		 ; 8FCA C3 9D 8D	; Salta a Action_Dir
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Enter									; Action_Enter:						; (# sinNumero)
	lda	MainObject		; get actor				; 	LD A, (MainObject)	 ; 8FCD 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_9F2D			; call L_9f2d				; 	CALL L_9F2D		 ; 8FD0 CD 2D 9F	; llama rutina L_9F2D (#192# --)
	lbra	L_8F3E			; goto L_8f3e				; 	JP L_8F3E		 ; 8FD3 C3 3E 8F	; Salta a L_8F3E
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Follow									; Action_Follow:					; (# sinNumero)
	ldu	ObjectPointer		; get obj pointer			; 	LD IX, (ObjectPointer)	 ; 8FD6 DD 2A 0C B7	; recupera ObjectPointer
	ldy	MainObjectPtr		; get main obj pointer			; 	LD B, (IX+$10)		 ; 8FDA DD 46 10	; Carga B con (IX+$10)
	sty	<reg_IX			; save it				; 	LD IX, (MainObjectPtr)	 ; 8FDD DD 2A 08 B7	; Carga MainObjectPtr
	lda	16,y			; get location				; 	LD A, (IX+$10)		 ; 8FE1 DD 7E 10	; Carga A con (IX+$10)
	cmpa	16,u			; are the same?				; 	CP B			 ; 8FE4 B8		; Compara A con B
	beq	i_8FEF			; yes, exit				; 	JR Z, i_8FEF		 ; 8FE5 28 08		; Si Z = 1, Salta a i_8FEF
	jsr	L_9F2D			; call L_9F2D				; 	CALL L_9F2D		 ; 8FE7 CD 2D 9F	; llama rutina L_9F2D (#192# --)
	cmpa	#$ff			; found any exit?			; 	CP $FF			 ; 8FEA FE FF		; Compara A con $FF
	lbne	L_8F3E			; yes, go L_8F3E			; 	JP NZ, L_8F3E		 ; 8FEC C2 3E 8F	; Si Z = 0, Salta a L_8F3E
i_8FEF	ldx	#L_AFE9			; point to message			; i_8FEF: LD HL, L_AFE9		 ; 8FEF 21 E9 AF	; apunta a mensaje "i cannot follow[0x07] from here[0x15]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; 8FF2 C3 DD 72	; salta a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_ThrowAt									; Action_ThrowAt:					; (# sinNumero)
	jsr	L_8CF1			; call L_8CF1				; 	CALL L_8CF1		 ; 8FF5 CD F1 8C	; llama rutina L_8CF1 (#182# --)
	ldx	#Action_Attack		; point to routine Action_Attack	; 	LD HL, Action_Attack	 ; 8FF8 21 71 91	; Carga HL con Action_Attack
	lda	#$0f			; action 'attack with'			; 	LD A, $0F		 ; 8FFB 3E 0F		; Carga A con $0F
	ldy	SecndObjectPtr		; get second obj pointer		; 	LD IX, (SecndObjectPtr)	 ; 8FFD DD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IX			; save it
	ldb	7,y			; get flags
	bitb	#%01000000		; is it animal?				; 	BIT 6, (IX+$07)		 ; 9001 DD CB 07 76	; Esta a 1 el bit 6 de (IX+$07)?
	bne	i_900C			; yes, skip two				; 	JR NZ, i_900C		 ; 9005 20 05		; Si Z = 0, Salta a i_900C
	ldx	#L_92ED			; point to routine L_92ED		; 	LD HL, L_92ED		 ; 9007 21 ED 92	; apunta a inicio de rutina L_92ED (#245# --)
	lda	#$0b			; action 'strike with'			; 	LD A, $0B		 ; 900A 3E 0B		; Carga A con $0B
i_900C	sta	CurrentAction		; set as action				; i_900C: LD (CurrentAction), A	 ; 900C 32 E7 B6	; guarda ID de accin
	jsr	L_9F4A			; call L_9F4A				; 	CALL L_9F4A		 ; 900F CD 4A 9F	; llama rutina L_9F4A (#193# --)
	lda	#$2a			; action 'throw at'			; 	LD A, $2A		 ; 9012 3E 2A		; Carga A con $2A
	sta	CurrentAction		; set as action				; 	LD (CurrentAction), A	 ; 9014 32 E7 B6	; guarda ID de accin
	lda	L_B6FA			; get L_B6FA				; 	LD A, (L_B6FA)		 ; 9017 3A FA B6	; Carga A con (L_B6FA)
	cmpa	#1			; is it 1?				; 	CP $01			 ; 901A FE 01		; Compara A con $01
	bne	e_900C			; no, exit				; 	RET NZ			 ; 901C C0		; Si Z = 0, Retorna
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; 901D DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	ldb	#$ff			; put 'no container' 
	stb	1,y			; to abject				; 	LD (IX+$01), $FF	 ; 9021 DD 36 01 FF	; Carga (IX+$01) con $FF
	lda	#$0f			; action 'attack with'			; 	LD A, $0F		 ; 9025 3E 0F		; Carga A con $0F
	sta	CurrentAction		; set as action				; 	LD (CurrentAction), A	 ; 9027 32 E7 B6	; guarda ID de accin
	lda	MainObject		; get object				; 	LD A, (MainObject)	 ; 902A 3A E8 B6	; Carga cdigo objeto principal
	lbra	L_95DF			; goto L_95DF				; 	JP L_95DF		 ; 902D C3 DF 95	; salta a L_95DF (#210# --)
e_900C	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Talkto									; Action_Talkto:					; (# sinNumero)
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 9034 CD 44 9D	; llama BreakIfB6faNot1
	lda	MainObject		; get actor				; 	LD A, (MainObject)	 ; 9037 3A E8 B6	; Carga cdigo objeto principal
	jsr	S_GetPNJEntry		; get HLevelDir Entry			; 	CALL S_GetPNJEntry	 ; 903A CD 85 9A	; llama S_GetPNJEntry
	cmpa	#$ff			; is it end of HL dir?			; 	CP $FF			 ; 903D FE FF		; Compara A con $FF
	tfr	cc,b			; save flags
	clra				; get value 0				; 	LD A, $00		 ; 903F 3E 00		; Carga A con $00
	tfr	b,cc			; restore flags
	beq	i_9058			; if Z=1 exit via i_9058		; 	JR Z, i_9058		 ; 9041 28 15		; Si Z = 1, Salta a i_9058
	lda	L_B6F9			; get L_B6F9				; 	LD A, (L_B6F9)		 ; 9043 3A F9 B6	; Carga A con (L_B6F9)
	bne	i_9058			; if not 0, exit via i_9058		; 	CP $00			 ; 9046 FE 00		; Compara A con $00
	ldy	<reg_IY			; get pseudoreg				; 	JR NZ, i_9058		 ; 9048 20 0E		; Si Z = 0, Salta a i_9058
	lda	6,y			; unknown meaning byte			; 	LD A, (IY+$06)		 ; 904A FD 7E 06	; Carga A con (IY+$06)
										; 	CP $00			 ; 904D FE 00		; Compara A con $00
	beq	i_9058			; if zero, exit via i_9058		; 	JR Z, i_9058		 ; 904F 28 07		; Si Z = 1, Salta a i_9058
	jsr	GetPosRandom		; use value as random max		; 	CALL GetPosRandom	 ; 9051 CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	tsta				; is random eq zero?			; 	CP $00			 ; 9054 FE 00		; Compara A con $00
	beq	i_905C			; yes, exit via i_905c			; 	JR Z, i_905C		 ; 9056 28 04		; Si Z = 1, Salta a i_905C
i_9058	jsr	L_7EBA			; call L_7EBA				; i_9058: CALL L_7EBA		 ; 9058 CD BA 7E	; llama rutina L_7EBA (#195# --)
	rts				; return				; 	RET			 ; 905B C9		; Retorna
i_905C	ldx	#L_B1E3			; point to message			; i_905C: LD HL, L_B1E3		 ; 905C 21 E3 B1	; apunta a mensaje "[0x07] says " No "[0x14]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 905F CD DD 72	; llama rutina PrintMsg
	clra				; return Z=1				; 	SUB A			 ; 9062 97		; Resta A de A
	bra	i_9058			; go back to i_9058			; 	JR i_9058		 ; 9063 18 F3		; Salta a i_9058
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;  							; (#284# --)
L_9065	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_9065: CALL BreakIfB6faNot1	 ; 9065 CD 44 9D	; llama BreakIfB6faNot1
	ldu	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; 9068 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; save it
	ldb	7,u			; get flags
	bitb	#%00100000		; is it open?				; 	BIT 5, (IX+$07)		 ; 906C DD CB 07 6E	; Esta a 1 el bit 5 de (IX+$07)?
	lbeq	L_9117			; no, goto L_9117			; 	JP Z, L_9117		 ; 9070 CA 17 91	; Si Z = 1, Salta a L_9117
	lbra	L_9145			; yes, goto L_9145			; 	JP L_9145		 ; 9073 C3 45 91	; Salta a L_9145
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Shoot									; Action_Shoot:						; (# sinNumero)
	lda	#$19			; code for object 'bow'			; 	LD A, $19		 ; 9076 3E 19		; Carga A con $19
	jsr	OwnsActorObject		; owns it actor?			; 	CALL OwnsActorObject	 ; 9078 CD 7B 9C	; llama OwnsActorObject
	ldx	#L_B121			; point to message			; 	LD HL, L_B121		 ; 907B 21 21 B1	; apunta a mensaje "You are not carrying the bow"
	lbcc	PrintMsg		; if returned no carry, show msg	; 	JP NC, PrintMsg		 ; 907E D2 DD 72	; Si flag C = 0, salta a PrintMsg
	jsr	L_914A			; call L_914A				; 	CALL L_914A		 ; 9081 CD 4A 91	; llama rutina L_914A (#195# --)
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 9084 CD 44 9D	; llama BreakIfB6faNot1
	lda	#$0f			; action 'attack with'			; 	LD A, $0F		 ; 9087 3E 0F		; Carga A con $0F
	sta	CurrentAction		; set as action				; 	LD (CurrentAction), A	 ; 9089 32 E7 B6	; guarda ID de accin
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 908C 3A EA B6	; Carga ActionActor
	cmpa	#$46			; is it 'bard'?				; 	CP $46			 ; 908F FE 46		; Compara A con $46
	beq	i_90A8			; yes, skip section			; 	JR Z, i_90A8		 ; 9091 28 15		; Si Z = 1, Salta a i_90A8
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 9093 3A E8 B6	; Carga cdigo objeto principal
	ldx	#L_B127			; point to message			; 	CP $3C			 ; 9096 FE 3C		; Compara A con $3C
	cmpa	#$3c			; is 'red golden dragon'?		; 	LD HL, L_B127		 ; 9098 21 27 B1	; apunta a mensaje "the arrow misses[0x09] by a wide margin"
	lbeq	PrintMsg		; yes, show msg				; 	JP Z, PrintMsg		 ; 909B CA DD 72	; si flag Z = 1, salta a PrintMsg
	lda	#8			; max number				; 	LD A, $08		 ; 909E 3E 08		; Carga A con $08
	jsr	GetPosRandom		; get random number			; 	CALL GetPosRandom	 ; 90A0 CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	cmpa	#3			; is it 0-1-2?				; 	CP $03			 ; 90A3 FE 03		; Compara A con $03
	lbcs	PrintMsg		; yes, show msg				; 	JP C, PrintMsg		 ; 90A5 DA DD 72	; Si flag C = 1, salta a PrintMsg 
i_90A8	ldy	#L_C4EA			; point to 'strong arrow'		; i_90A8: LD IX, L_C4EA		 ; 90A8 DD 21 EA C4	; Carga IX con L_C4EA
	sty	<reg_IX			; save it
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 90AC 3A E8 B6	; Carga cdigo objeto principal
	cmpa	#$1a			; is it 'strong arrow'?			; 	CP $1A			 ; 90AF FE 1A		; Compara A con $1A
	beq	i_90B7			; yes, skip 2				; 	JR Z, i_90B7		 ; 90B1 28 04		; Si Z = 1, Salta a i_90B7
	ldb	#$ff			; put no container
	stb	1,y			; in it					; 	LD (IX+$01), $FF	 ; 90B3 DD 36 01 FF	; Carga (IX+$01) con $FF
i_90B7	ldx	#L_B136			; point to message			; i_90B7: LD HL, L_B136		 ; 90B7 21 36 B1	; apunta a mensaje "the arrow{5} hits[0x07][0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 90BA CD DD 72	; llama rutina PrintMsg 
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; 90BD DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	jsr	L_A1C8			; call L_A1C8				; 	CALL L_A1C8		 ; 90C1 CD C8 A1	; llama rutina L_A1C8 (#196# --)
	lbne	L_92ED			; if returns Z=0, goto L_92ED		; 	JP NZ, L_92ED		 ; 90C4 C2 ED 92	; si flag Z=0, salta a L_92ED (#245# --)
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 90C7 3A E8 B6	; Carga cdigo objeto principal
	jsr	ProcessDeadObject	; process its death			; 	CALL ProcessDeadObject	 ; 90CA CD 7F 97	; llama ProcessDeadObject
	lda	#6			; get value 6				; 	LD A, $06		 ; 90CD 3E 06		; Carga A con $06
	lbra	PrintObjStatus		; show status (true, bit 6=alive)	; 	JP PrintObjStatus	 ; 90CF C3 6C A1	; salta a PrintObjStatus con A=$06 (falso bit 6 a 0) dead
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
BilboIsDeadEndGame								;BilboIsDeadEndGame:					; Bilbo muere. Final de la partida (#246# --) 
	clra				; pone cero 				;	SUB A			 ; 90D2 97		; pone 0
	sta	ActionActor		; en actor				;	LD (ActionActor), A	 ; 90D3 32 EA B6	; en ActionActor
	ldx	#L_AFF1			; apunta a mensaje			;	LD HL, L_AFF1		 ; 90D6 21 F1 AF	; apunta a mensaje "You are dead"
	jsr	PrintMsg		; lo muestra				;	CALL PrintMsg		 ; 90D9 CD DD 72	; llama rutina PrintMsg 
	jsr	L_83F5			; llama L_83F5				;	CALL L_83F5		 ; 90DC CD F5 83	; llama rutina L_83F5 (#105# OK)
WaitKeyToRestart								;WaitKeyToRestart:					; espera que el usuario pulse una tecla para rearrancar el juego
	lbra	i_8394			; salta a i_8394			;	XOR A			 ; 90DF AF		; A=0, flag Z = 1
										;	IN A, ($FE)		 ; 90E0 DB FE		; Lee teclado (todas las filas)
										;	AND $1F			 ; 90E2 E6 1F		; Hace AND lgico de A con $1F
										;	CP $1F			 ; 90E4 FE 1F		; Compara A con $1F
										;	JR Z, WaitKeyToRestart	 ; 90E6 28 F7		; si ninguna tecla pulsada, vuelve a WaitKeyToRestart
										;	JP ReStart		 ; 90E8 C3 27 6C	; Salta a ReStart (empieza nueva partida)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Inventory								; Action_Inventory:					; (# sinNumero)
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; 90EB CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_ADF6			; point to message			; 	LD HL, L_ADF6		 ; 90EE 21 F6 AD	; apunta a mensaje "You are carrying[0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 90F1 CD DD 72	; llama rutina PrintMsg 
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 90F4 3A EA B6	; Carga ActionActor
	jsr	L_9D97			; call L_9D97				; 	CALL L_9D97		 ; 90F7 CD 97 9D	; llama rutina L_9D97 (#198# --)
	ldx	#L_B33B			; point to message			; 	AND A			 ; 90FA A7		; A = A AND A	; Adecua flags
	tsta				; test routine answer			; 	LD HL, L_B33B		 ; 90FB 21 3B B3	; apunta a mensaje "	  {6} nothing"
	lbeq	PrintMsg		; if Z=1 show message			; 	JP Z, PrintMsg		 ; 90FE CA DD 72	; si flag Z = 1, salta a PrintMsg
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 9101 3A EA B6	; Carga ActionActor
	ldy	ObjectPointer		; get pointer				; 	LD IX, (ObjectPointer)	 ; 9104 DD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IX			; save it
	ldb	16,y			; get location				; 	LD B, (IX+$10)		 ; 9108 DD 46 10	; Carga B con (IX+$10)
	stb	<reg_B			; save it
	lbra	L_9FAF			; go L_9FAF				; 	JP L_9FAF		 ; 910B C3 AF 9F	; salta a (-09-)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_910E	jsr	L_A1F9			; llama L_A1F9				; L_910E: CALL L_A1F9		 ; 910E CD F9 A1	; llama rutina L_A1F9 (#199# --)
	lbne	PrintObjStatus		; resultado no 0, llama PrintObjStatus	; 	JP NZ, PrintObjStatus	 ; 9111 C2 6C A1	; si flag Z=0, salta a PrintObjStatus con A=$85 (bit 5=1) open
	jsr	BreakIfB6faNot1		; llama BreakIfB6faNot1			; 	CALL BreakIfB6faNot1	 ; 9114 CD 44 9D	; llama BreakIfB6faNot1
										; 
L_9117	ldy	<reg_IX			; recupera reg_IX			; L_9117: SET 5, (IX+$07)	 ; 9117 DD CB 07 EE	; Pasa a 1 el bit 5 en (IX+$07)
	ldb	7,y			; toma flags del objeto
	orb	#%00100000		; pone el bit 5 a 1 (abierto)
	stb	7,y			; actualiza flags objeto
	lda	,y			; toma num de localizaciones		; 	LD A, (IX+$00)		 ; 911B DD 7E 00	; Carga A con (IX+$00)
	deca				; lo decrementa				; 	DEC A			 ; 911E 3D		; Decrementa A
	beq	e_9117			; si era 1 salta la siguiente		; 	RET NZ			 ; 911F C0		; Si Z = 0, Retorna
s_9117	rts				; retorna
e_9117	lda	MainObject		; recupera objeto principal		; 	LD A, (MainObject)	 ; 9120 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_9D97			; llama L_9D97				; 	CALL L_9D97		 ; 9123 CD 97 9D	; llama rutina L_9D97 (#198# --)
	tsta				; adecua flags				; 	AND A			 ; 9126 A7		; A = A AND A	; Adecua flags
	beq	s_9117			; si cero, sale				; 	RET Z			 ; 9127 C8		; Z = 1?	; Retorna si es cero
	lda	MainObject		; toma objeto principal			; 	LD A, (MainObject)	 ; 9128 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_A050			; llama L_A050				; 	CALL L_A050		 ; 912B CD 50 A0	; llama rutina L_A050 (#200# --)
	bcs	s_9117			; si devuelve carry, sale		; 	RET C			 ; 912E D8		; Si C = 1, Retorna
	ldb	16,y			; toma localizacin actual		; 	LD B, (IX+$10)		 ; 912F DD 46 10	; Carga B con (IX+$10)
	stb	<reg_B			; la guarda en reg_B
	lda	MainObject		; toma objeto principal			; 	LD A, (MainObject)	 ; 9132 3A E8 B6	; Carga cdigo objeto principal
	lbra	L_9FAF			; salta a L_9FAF			; 	JP L_9FAF		 ; 9135 C3 AF 9F	; salta a (-09-)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_9138	ldy	MainObjectPtr		; point to main object			; L_9138: LD IX, (MainObjectPtr) ; 9138 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; update pseudoregister
	jsr	TestOpenFlag		; verify openflag			; 	CALL TestOpenFlag	 ; 913C CD CA A5	; llama TestOpenFlag
	lbeq	PrintObjStatus		; if ok, print status			; 	JP Z, PrintObjStatus	 ; 913F CA 6C A1	; si flag Z=1, salta a PrintObjStatus con A=$05 (bit 5=0) closed
	jsr	BreakIfB6faNot1		; detect if should break		; 	CALL BreakIfB6faNot1	 ; 9142 CD 44 9D	; llama BreakIfB6faNot1
										; 
L_9145	ldy	<reg_IX			; point to object			; L_9145: RES 5, (IX+$07)	 ; 9145 DD CB 07 AE	; Pasa a 0 el bit 5 en (IX+$07)
	ldb	7,y			; get status byte
	andb	#%11011111		; reset bit 5
	stb	7,y			; update status
	rts				; return				;  	RET			 ; 9149 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#195# --)
L_914A	ldy	MainObjectPtr		; get pointer				; L_914A: LD IX, (MainObjectPtr) ; 914A DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 914E 3A EA B6	; Carga ActionActor
	bne	i_915E			; if not Bilbo, skip section		; 	AND A			 ; 9151 A7		; A = A AND A	; Adecua flags
	ldb	4,y			; another unknown byte			; 	JR NZ, i_915E		 ; 9152 20 0A		; Si Z = 0, Salta a i_915E
	bitb	#%00010000		; is bit4 set?				; 	BIT 4, (IX+$04)		 ; 9154 DD CB 04 66	; Esta a 1 el bit 4 de (IX+$04)?
	beq	i_915E			; no, skip two				; 	JR Z, i_915E		 ; 9158 28 04		; Si Z = 1, Salta a i_915E
	andb	#$11101111		; reset that bit			; 	RES 4, (IX+$04)		 ; 915A DD CB 04 A6	; Pasa a 0 el bit 4 en (IX+$04)
	stb	4,y			; update byte
i_915E	lda	4,y			; get byte				; i_915E: LD A, (IX+$04)	 ; 915E DD 7E 04	; Carga A con (IX+$04)
	anda	#%01110000		; use only bits 4-5-6			; 	AND $70			 ; 9161 E6 70		; Hace AND lgico de A con $70
	ldy	ObjectPointer		; get object pointer			; 	LD IX, (ObjectPointer)	 ; 9163 DD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IX			; save it
	anda	4,y			; do any bit (4-5-6) match to 'set'?	; 	AND (IX+$04)		 ; 9167 DD A6 04	; Hace AND lgico de A con (IX+$04)
	beq	e_915E			; no, exit				; 	RET Z			 ; 916A C8		; Z = 1?	; Retorna si es cero
	puls	x			; restore X(HL)				; 	POP HL			 ; 916B E1		; Recupera HL
	clra				; put 0 value				; 	XOR A			 ; 916C AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	sta	L_B6FB			; in L_B6FA				; 	LD (L_B6FB), A		 ; 916D 32 FB B6	; Carga (L_B6FB) con A
e_915E	rts				; return				; 	RET			 ; 9170 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Attack									; Action_Attack:					; (# sinNumero)
	jsr	L_914A			; call L_914A				; 	CALL L_914A		 ; 9171 CD 4A 91	; llama rutina L_914A (#195# --)
	lda	SecondObject		; get 2nd object			; 	LD A, (SecondObject)	 ; 9174 3A E9 B6	; Carga cdigo objeto secundario
	ldx	#L_626B-$6000		; point to word FIST			; 	LD HL, $026B		 ; 9177 21 6B 02	; Carga HL con $026B
	cmpa	#$ff			; was no object?			; 	CP $FF			 ; 917A FE FF		; Compara A con $FF
	beq	i_9188			; yes, skip two				; 	JR Z, i_9188		 ; 917C 28 0A		; Si Z = 1, Salta a i_9188
	ldy	SecndObjectPtr		; get pointer				; 	LD IX, (SecndObjectPtr)	 ; 917E DD 2A 0A B7	; Carga SecndObjectPtr
	ldx	8,y			; get 1st description word		; 	LD L, (IX+$08)		 ; 9182 DD 6E 08	; Carga L con (IX+$08)
										; 	LD H, (IX+$09)		 ; 9185 DD 66 09	; Carga H con (IX+$09)
i_9188	stx	L_B6FC			; save word pointer			; i_9188: LD (L_B6FC), HL	 ; 9188 22 FC B6	; Carga (L_B6FC) con HL
	ldy	ObjectPointer		; get object pointer			; 	LD IX, (ObjectPointer)	 ; 918B DD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IX			; update pseudoreg
	ldb	5,y			; get strength				; 	LD B, (IX+$05)		 ; 918F DD 46 05	; Carga B con (IX+$05)
	stb	<reg_B			; save it
	lda	SecondObject		; get 2nd object ID			; 	LD A, (SecondObject)	 ; 9192 3A E9 B6	; Carga cdigo objeto secundario
	inca				; is it no object?			; 	INC A			 ; 9195 3C		; Incrementa A
	beq	i_91AF			; yes, skip section			; 	JR Z, i_91AF		 ; 9196 28 17		; Si Z = 1, Salta a i_91AF
	ldu	SecndObjectPtr		; get pointer				; 	LD IY, (SecndObjectPtr)	 ; 9198 FD 2A 0A B7	; Carga SecndObjectPtr
	stu	<reg_IY			; update pseudoreg
	lda	,u			; get num visible locations		; 	LD A, (IY+$00)		 ; 919C FD 7E 00	; Carga A con (IY+$00)
	ldx	#L_AF5F			; point to message 			; 	DEC A			 ; 919F 3D		; Decrementa A
	deca				; was greater than 1?			; 	LD HL, L_AF5F		 ; 91A0 21 5F AF	; apunta a mensaje "you cannot kill with[0x09][0x15]"
	lbne	PrintMsg		; yes, show message			; 	JP NZ, PrintMsg		 ; 91A3 C2 DD 72	; si no es cero, salta a PrintMsg
	ldu	<reg_IY			; get pseudoreg
	lda	5,u			; get strength				; 	LD A, (IY+$05)		 ; 91A6 FD 7E 05	; Carga A con (IY+$05)
	adda	<reg_B			; add to 1st obj one			; 	ADD A, B		 ; 91A9 80		; Adiciona B en A
	bcc	i_91AE			; no overflow, skip one			; 	JR NC, i_91AE		 ; 91AA 30 02		; Si C = 0, Salta a i_91AE
	lda	#$ff			; set maximum				; 	LD A, $FF		 ; 91AC 3E FF		; Carga A con $FF
i_91AE	sta	<reg_B			; save total strength			; i_91AE: LD B, A		 ; 91AE 47		; Carga B con A
i_91AF	lda	<reg_B			; get strength				; i_91AF: LD A, B		 ; 91AF 78		; Carga A con B
	jsr	L_9213			; get a 'reworked' random		; 	CALL L_9213		 ; 91B0 CD 13 92	; llama rutina L_9213 (#201# --)
	sta	<reg_B			; save it				; 	LD B, A			 ; 91B3 47		; Carga B con A
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 91B4 CD 44 9D	; llama BreakIfB6faNot1
	ldy	MainObjectPtr		; get pointer to 1st obj		; 	LD IX, (MainObjectPtr)	 ; 91B7 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; update reg_IX
	lda	6,y			; get unknow meaning byte		; 	LD A, (IX+$06)		 ; 91BB DD 7E 06	; Carga A con (IX+$06)
	jsr	L_9213			; get a 'reworked' random		; 	CALL L_9213		 ; 91BE CD 13 92	; llama rutina L_9213 (#201# --)
	ldx	#L_AF50			; point to message			; 	CP B			 ; 91C1 B8		; Compara A con B
	cmpa	<reg_B			; is last one GT previous one?		; 	LD HL, L_AF50		 ; 91C2 21 50 AF	; apunta a mensaje "but the effort is wasted.[0x0e] defense is too strong"
	lbcc	PrintMsg		; yes, show message			; 	JP NC, PrintMsg		 ; 91C5 D2 DD 72	; si no hay acarreo, salta a PrintMsg
	sta	<reg_C			; save last random			; 	LD C, A			 ; 91C8 4F		; Carga C con A
	adda	#16			; add 16				; 	ADD A, $10		 ; 91C9 C6 10		; Adiciona $10 en A
	bcc	i_91CF			; if not overflow skip next		; 	JR NC, i_91CF		 ; 91CB 30 02		; Si C = 0, Salta a i_91CF
	lda	#$ff			; set max value				; 	LD A, $FF		 ; 91CD 3E FF		; Carga A con $FF
i_91CF	cmpa	<reg_B			; is now GT previous one?		; i_91CF: CP B			 ; 91CF B8		; Compara A con B
	bcs	i_91FE			; no, exit via i_91FE			; 	JR C, i_91FE		 ; 91D0 38 2C		; Si C = 1, Salta a i_91FE
	lda	<reg_B			; get previous random			; 	LD A, B			 ; 91D2 78		; Carga A con B
	suba	<reg_C			; subtract last one			; 	SUB C			 ; 91D3 91		; Resta C de A
	anda #$0f 			; <<<<<  BUGFIX
	asla				; multipy by 2				; 	RLCA			 ; 91D4 07		; Rota A a la izquierda circularmente (b7 entra en b0)
	tfr	a,b			; convert into				; 	LD E, A			 ; 91D5 5F		; Carga E con A
	clra				; 16 bits				; 	LD D, $00		 ; 91D6 16 00		; Carga D con $00
	ldu	#L_9226			; points to combat messages table 	; 	LD IY, L_9226		 ; 91D8 FD 21 26 92	; a punta a tabla mensajes de combate
	leau	d,u			; add offset				; 	ADD IY, DE		 ; 91DC FD 19		; Adiciona DE en IY
	stu	<reg_IY			; update reg_IY				; 	LD L, (IY+$00)		 ; 91DE FD 6E 00	; Carga L con (IY+$00)
	ldx	,u			; get pointer to message		; 	LD H, (IY+$01)		 ; 91E1 FD 66 01	; Carga H con (IY+$01)
	lsra				; divide				; 	RRCA			 ; 91E4 0F		; Rota A a la derecha circularmente (b0 entra en b7)
	lsra				; by 4 the offset			; 	RRCA			 ; 91E5 0F		; Rota A a la derecha circularmente (b0 entra en b7)
	sta	<reg_B			; save in reg_B				; 	LD B, A			 ; 91E6 47		; Carga B con A
	coma				; invert all bits			; 	CPL			 ; 91E7 2F		; Calcula el complemento a 1s de A
	ldy	<reg_IX			; get pseudoreg
	adda	5,y			; add strength				; 	ADD A, (IX+$05)		 ; 91E8 DD 86 05	; Adiciona (IX+$05) en A
	bcc	i_91F0			; is no carry, skip next		; 	JR NC, i_91F0		 ; 91EB 30 03		; Si C = 0, Salta a i_91F0
	sta	5,y			; update strength			; 	LD (IX+$05), A		 ; 91ED DD 77 05	; Carga (IX+$05) con A
i_91F0	lda	<reg_B			; get saved offset (/4)			; i_91F0: LD A, B		 ; 91F0 78		; Carga A con B
	lsra				; divide by 2 (=/8)			; 	RRCA			 ; 91F1 0F		; Rota A a la derecha circularmente (b0 entra en b7)
	coma				; invert all bits			; 	CPL			 ; 91F2 2F		; Calcula el complemento a 1s de A
	adda	6,y			; add unknown meaning byte		; 	ADD A, (IX+$06)		 ; 91F3 DD 86 06	; Adiciona (IX+$06) en A
	bcc	i_91FB			; if not overflow, skip next		; 	JR NC, i_91FB		 ; 91F6 30 03		; Si C = 0, Salta a i_91FB
	sta	6,y			; update unknown meaning byte		; 	LD (IX+$06), A		 ; 91F8 DD 77 06	; Carga (IX+$06) con A
i_91FB	lbra	PrintMsg		; show message				; i_91FB: JP PrintMsg		 ; 91FB C3 DD 72	; salta a PrintMsg
i_91FE	ldx	#L_AE3A			; point to message			; i_91FE: LD HL, L_AE3A		 ; 91FE 21 3A AE	; apunta a mensaje "with one well place(s|d|ing|es) blow you cleave[0x0e] skull"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 9201 CD DD 72	; llama rutina PrintMsg
	ldy	<reg_IX			; get pseudoreg
	ldb	7,y			; get flags
	orb	#%00001000		; set as dead
	stb	7,y			; update flags				; 	SET 3, (IX+$07)		 ; 9204 DD CB 07 DE	; Pasa a 1 el bit 3 en (IX+$07)
	lda	MainObject		; get object				; 	LD A, (MainObject)	 ; 9208 3A E8 B6	; Carga cdigo objeto principal
	jsr	ProcessDeadObject	; process its death			; 	CALL ProcessDeadObject	 ; 920B CD 7F 97	; llama ProcessDeadObject
	lda	#6			; get value 6				; 	LD A, $06		 ; 920E 3E 06		; Carga A con $06
	lbra	PrintObjStatus		; print status				; 	JP PrintObjStatus	 ; 9210 C3 6C A1	; salta a PrintObjStatus con A=$06 (falso bit 6 =0) dead
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#201# --)
L_9213	ldu	<reg_BC			; get pseudoreg				; L_9213: PUSH BC		 ; 9213 C5		; Guarda BC
	pshs	u			; save it
	sta	<reg_B			; pass A to reg_B			; 	LD B, A			 ; 9214 47		; Carga B con A
	lda	#10			; max random value			; 	LD A, $0A		 ; 9215 3E 0A		; Carga A con $0A
	jsr	GetRandom		; get a random				; 	CALL GetRandom		 ; 9217 CD A8 9C	; llama rutina GetRandom (envia A=valor mximo, recibe nuevo random en A)
	sta	<reg_C			; save at reg_C				; 	LD C, A			 ; 921A 4F		; Carga C con A
	adda	<reg_B			; add old regA				; 	ADD A, B		 ; 921B 80		; Adiciona B en A
	bcc	i_9224			; if not overflow exit			; 	JR NC, i_9224		 ; 921C 30 06		; Si C = 0, Salta a i_9224
	clra				; will return Z=1			; 	XOR A			 ; 921E AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	ldb	<reg_C			; get reg_C
	bitb	#%10000000		; is bit7 set?				; 	BIT 7, C		 ; 921F CB 79		; Esta a 1 el bit 7 de C?
	bne	i_9224			; yes, skip next			; 	JR NZ, i_9224		 ; 9221 20 01		; Si Z = 0, Salta a i_9224
	deca				; returns Z=0,N=1			; 	DEC A			 ; 9223 3D		; Decrementa A
i_9224	tfr	cc,b			; save flags				; i_9224: POP BC		 ; 9224 C1		; Recupera BC
	puls	u			; restore U(BC)
	stu	<reg_BC			; update pseudoreg
	tfr	b,cc			; restore flags
	rts				; return				; 	RET			 ; 9225 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#180# --)
L_9246	ldu	MainObjectPtr		; get pointer				; L_9246: LD IX, (MainObjectPtr) ; 9246 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; update reg_IX
	lda	,u			; number of visible locations		; 	LD A, (IX+$00)		 ; 924A DD 7E 00	; Carga A con (IX+$00)
	deca				; decrement it				; 	DEC A			 ; 924D 3D		; Decrementa A
	rts				; return				; 	RET			 ; 924E C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#273# --)
L_924F	jsr	L_8D25			; call L_8D25				; L_924F: CALL L_8D25		 ; 924F CD 25 8D	; llama rutina L_8D25 (#202# --)
	lda	SecondObject		; get 2nd object ID			; 	LD A, (SecondObject)	 ; 9252 3A E9 B6	; Carga cdigo objeto secundario
	ldu	<reg_IX			; get obj pointer
	cmpa	1,u			; is its container?			; 	CP (IX+$01)		 ; 9255 DD BE 01	; Compara A con (IX+$01)
	lbeq	L_72CE			; action is not allowed			; 	JP Z, L_72CE		 ; 9258 CA CE 72	; si flag Z=1, salta a L_72CE (#211# --)
	ldy	SecndObjectPtr		; point to 2nd object			; 	LD IY, (SecndObjectPtr)	 ; 925B FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save ptr
	lda	CurrentAction		; get action ID				; 	LD A, (CurrentAction)	 ; 925F 3A E7 B6	; Carga ID de accin
	cmpa	#$12			; is it 'put on'?			; 	CP $12			 ; 9262 FE 12		; Compara A con $12
	beq	i_926C			; yes, skip three			; 	JR Z, i_926C		 ; 9264 28 06		; Si Z = 1, Salta a i_926C
	ldb	7,y			; get 2nd obj flags
	bitb	#%00100000		; is it open?				; 	BIT 5, (IY+$07)		 ; 9266 FD CB 07 6E	; Esta a 1 el bit 5 de (IY+$07)?
	beq	i_9297			; no, exit				; 	JR Z, i_9297		 ; 926A 28 2B		; Si Z = 1, Salta a i_9297
i_926C	lda	2,y			; get 2nd obj volume			; i_926C: LD A, (IY+$02)	 ; 926C FD 7E 02	; Carga A con (IY+$02)
	suba	2,u			; subtract obj volume			; 	SUB (IX+$02)		 ; 926F DD 96 02	; Resta (IX+$02) de A
	bcs	i_927E			; if 2nd obj >= obj, skip section	; 	JR C, i_927E		 ; 9272 38 0A		; Si C = 1, Salta a i_927E
	pshs	a,cc			; save volume and flags			; 	PUSH AF			 ; 9274 F5		; Guarda AF
	lda	SecondObject		; get 2nd obj ID			; 	LD A, (SecondObject)	 ; 9275 3A E9 B6	; Carga cdigo objeto secundario
	jsr	L_9CE8			; call L_9CE8				; 	CALL L_9CE8		 ; 9278 CD E8 9C	; llama rutina L_9CE8  (#183# --)
	sta	<reg_B			; save calc volume into reg_B		; 	LD B, A			 ; 927B 47		; Carga B con A
	puls	a,cc			; restore volume and flags		; 	POP AF			 ; 927C F1		; Recupera AF
	suba	<reg_B			; subtract calc volume			; 	SUB B			 ; 927D 90		; Resta B de A
i_927E	tfr	cc,b			; save flags				; i_927E: LD HL, L_AE1A		 ; 927E 21 1A AE	; apunta a mensaje "[0x09] is too full"
	ldx	#L_AE1A			; point to message
	tfr	b,cc			; restore flags
	lbcs	PrintMsg		; if calc greater, show msg		; 	JP C, PrintMsg		 ; 9281 DA DD 72	; Si flag C = 1, salta a PrintMsg
	lbeq	PrintMsg		; if equal show msg			; 	JP Z, PrintMsg		 ; 9284 CA DD 72	; si flag Z = 1, salta a PrintMsg
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 9287 CD 44 9D	; llama BreakIfB6faNot1
	ldy	<reg_IY			; get 2nd obj pointer
	lda	16,y			; get location				; 	LD A, (IY+$10)		 ; 928A FD 7E 10	; Carga A con (IY+$10)
	ldu	<reg_IX			; get obj pointer
	sta	16,u			; update its location			; 	LD (IX+$10), A		 ; 928D DD 77 10	; Carga (IX+$10) con A
	lda	SecondObject		; get 2nd obj ID			; 	LD A, (SecondObject)	 ; 9290 3A E9 B6	; Carga cdigo objeto secundario
	sta	1,u			; put as container			; 	LD (IX+$01), A		 ; 9293 DD 77 01	; Carga (IX+$01) con A
	rts				; return				; 	RET			 ; 9296 C9		; Retorna
i_9297	lda	#5			; get flag bit value (open-closed)	; i_9297: LD A, $05		 ; 9297 3E 05		; Carga A con $05
	lbra	L_A164			; goto L_A164				; 	JP L_A164		 ; 9299 C3 64 A1	; Salta a L_A164
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#278# --)
L_929C	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_929C: CALL BreakIfB6faNot1	 ; 929C CD 44 9D	; llama BreakIfB6faNot1
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; 929F DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	lda	1,y			; get container				; 	LD A, (IX+$01)		 ; 92A3 DD 7E 01	; Carga A con (IX+$01)
	cmpa	#$ff			; is it none?				; 	CP $FF			 ; 92A6 FE FF		; Compara A con $FF
	beq	L_92B5			; yes, skip section			; 	JR Z, L_92B5		 ; 92A8 28 0B		; si flag Z=1, salta a (#242# --)
	jsr	GetObjPointer2IX	; get its pointer			; 	CALL GetObjPointer2IX	 ; 92AA CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	ldb	7,y			; get flags
	andb	#%11111011		; set to empty		
	stb	7,y			; update flags				; 	RES 2, (IX+$07)		 ; 92AD DD CB 07 96	; Pasa a 0 el bit 2 en (IX+$07)
	lda	#1			; get value 1				; 	LD A, $01		 ; 92B1 3E 01		; Carga A con $01
	bra	i_92BA			; skip next two				; 	JR i_92BA		 ; 92B3 18 05		; Salta a i_92BA
										; 							; (#242# --)
L_92B5	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_92B5: CALL BreakIfB6faNot1	 ; 92B5 CD 44 9D	; llama BreakIfB6faNot1
	lda	#$0a			; get value 10				; 	LD A, $0A		 ; 92B8 3E 0A		; Carga A con $0A
i_92BA	ldy	ObjectPointer		; get object pointer			; i_92BA: LD IX, (ObjectPointer) ; 92BA DD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IX			; save it
	adda	5,y			; add strength	 			; 	ADD A, (IX+$05)		 ; 92BE DD 86 05	; Adiciona (IX+$05) en A
	cmpa	#$80			; is it still positive?			; 	CP $80			 ; 92C1 FE 80		; Compara A con $80
	bcc	i_92DC			; no, send message			; 	JR NC, i_92DC		 ; 92C3 30 17		; Si C = 0, Salta a i_92DC
	sta	5,y			; update strength			; 	LD (IX+$05), A		 ; 92C5 DD 77 05	; Carga (IX+$05) con A
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; 92C8 DD 2A 08 B7	; Carga MainObjectPtr
	ldb	#$ff			; get 'no container' value
	stb	1,y			; update container value		; 	LD (IX+$01), $FF	 ; 92CC DD 36 01 FF	; Carga (IX+$01) con $FF
	ldb	,y			; get numr of visible locations		; 	LD B, (IX+$00)		 ; 92D0 DD 46 00	; Carga B con (IX+$00)
	stb	<reg_B			; put in reg_B
i_92D3	clr	16,y			; clear one location			; i_92D3: LD (IX+$10), $00	 ; 92D3 DD 36 10 00	; Carga (IX+$10) con $00
	leay	1,y			; increment pointer			; 	INC IX			 ; 92D7 DD 23		; Incrementa IX
	dec 	<reg_B			; decrement counter			; 	DJNZ i_92D3		 ; 92D9 10 F8		; Decrementa B y si no es cero vuelve a i_92D3
	bne	i_92D3			; not yet done, loopback
	sty	<reg_IX			; update reg_IX and make Z=0
	rts				; return				; 	RET			 ; 92DB C9		; Retorna
i_92DC	ldx	#L_B146			; point to message			; i_92DC: LD HL, L_B146		 ; 92DC 21 46 B1	; apunta a mensaje "[0x0c] foul gluttony has{5} killed you[0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 92DF CD DD 72	; llama rutina PrintMsg 
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 92E2 3A EA B6	; Carga ActionActor
	lbra	ProcessDeadObject	; process its death			; 	JP ProcessDeadObject	 ; 92E5 C3 7F 97	; salta a ProcessDeadObject
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#245# --)
L_92ED	ldy	MainObjectPtr		; get pointer				; L_92ED: LD IX, (MainObjectPtr) ; 92ED DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	ldb	7,y			; get flags
	bitb	#%00000010		; is it 'fluid'?			; 	BIT 1, (IX+$07)		 ; 92F1 DD CB 07 4E	; Esta a 1 el bit 1 de (IX+$07)?
	lbne	IfB6FAis1DescAction	; yes, desc Action			; 	JP NZ, IfB6FAis1DescAction ; 92F5 C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	bitb	#%00001000		; is it dead?				; 	BIT 3, (IX+$07)		 ; 92F8 DD CB 07 5E	; Esta a 1 el bit 3 de (IX+$07)?
	lbne	i_9399			; no, exit				; 	JP NZ, i_9399		 ; 92FC C2 99 93	; Si Z = 0, Salta a i_9399
	clra				; get zero				; 	SUB A			 ; 92FF 97		; Resta A de A
	cmpa	6,y			; is unknown meaning byte eq. zero?	; 	CP (IX+$06)		 ; 9300 DD BE 06	; Compara A con (IX+$06)
	lbeq	IfB6FAis1DescAction	; yes, desc action			; 	JP Z, IfB6FAis1DescAction ; 9303 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	sta	<reg_B			; set reg_B to zero			; 	LD B, A			 ; 9306 47		; Carga B con A
	lda	SecondObject		; get 2nd object			; 	LD A, (SecondObject)	 ; 9307 3A E9 B6	; Carga cdigo objeto secundario
	inca				; increment ID				; 	INC A			 ; 930A 3C		; Incrementa A
	beq	i_932C			; if it was $ff, skip section		; 	JR Z, i_932C		 ; 930B 28 1F		; Si Z = 1, Salta a i_932C
	ldy	SecndObjectPtr		; get ointer				; 	LD IY, (SecndObjectPtr)	 ; 930D FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save it				; 	LD A, (IY+$05)		 ; 9311 FD 7E 05	; Carga A con (IY+$05)
	lda	5,y			; get strength				; 	AND A			 ; 9314 A7		; A = A AND A	; Adecua flags
	lbeq	IfB6FAis1DescAction	; if 0, desc action			; 	JP Z, IfB6FAis1DescAction ; 9315 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	ldy	<reg_IX			; get pseudoreg				; 	PUSH IX			 ; 9318 DD E5		; Guarda IX
	pshs	y			; save it
	ldy	SecndObjectPtr		; get 2nd obj pointer			; 	LD IX, (SecndObjectPtr)	 ; 931A DD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IX			; save it
	lda	#$0b			; get action 'strike with'		; 	LD A, $0B		 ; 931E 3E 0B		; Carga A con $0B
	jsr	SearchActionInObj	; is action inside Object?		; 	CALL SearchActionInObj	 ; 9320 CD 81 9B	; llama SearchActionInObj
	puls	y			; restore register			; 	POP IX			 ; 9323 DD E1		; Recupera IX
	sty	<reg_IX			; update reg_IX
	inca				; increment value			; 	INC A			 ; 9325 3C		; Incrementa A
	lbeq	IfB6FAis1DescAction	; if it was $ff, desc action		; 	JP Z, IfB6FAis1DescAction ; 9326 CA 76 9F	; si no encontrada en la tabla, salta a IfB6FAis1DescAction
	ldu	<reg_IY			; get pseudoreg
	ldb	5,u			; get strength
	stb	<reg_B			; into reg_B				; 	LD B, (IY+$05)		 ; 9329 FD 46 05	; Carga B con (IY+$05)
i_932C	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; i_932C: CALL BreakIfB6faNot1	 ; 932C CD 44 9D	; llama BreakIfB6faNot1
	lda	#$15			; max value 				; 	LD A, $15		 ; 932F 3E 15		; Carga A con $15
	jsr	GetRandom		; get random number			; 	CALL GetRandom		 ; 9331 CD A8 9C	; llama rutina GetRandom (envia A=valor mximo, recibe nuevo random en A)
	adda 	<reg_B			; add to strength			; 	ADD A, B		 ; 9334 80		; Adiciona B en A
	ldu	ObjectPointer		; get pointer				; 	LD IY, (ObjectPointer)	 ; 9335 FD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IY			; save it
	adda	5,u			; add strength				; 	ADD A, (IY+$05)		 ; 9339 FD 86 05	; Adiciona (IY+$05) en A
	bcc	i_9340			; if not overflow skip next		; 	JR NC, i_9340		 ; 933C 30 02		; Si C = 0, Salta a i_9340
	lda	#$ff			; get max value				; 	LD A, $FF		 ; 933E 3E FF		; Carga A con $FF
i_9340	suba	6,y			; subtract unknown meaning byte		; i_9340: SUB (IX+$06)		 ; 9340 DD 96 06	; Resta (IX+$06) de A
	bcs	i_9360			; if it was lower, skip section		; 	JR C, i_9360		 ; 9343 38 1B		; Si C = 1, Salta a i_9360
	ldb	7,y			; get flags
	orb	#%00001000		; set as dead
	stb	7,y			; update flags				; 	SET 3, (IX+$07)		 ; 9345 DD CB 07 DE	; Pasa a 1 el bit 3 en (IX+$07)
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 9349 3A E8 B6	; Carga cdigo objeto principal
	jsr	UpdateDeadObject	; process its death			; 	CALL UpdateDeadObject	 ; 934C CD 8C A1	; llama UpdateDeadObject
	ldy	<reg_IX			; get pseudoreg
	asr	5,y			; set to half value			; 	SRA (IX+$05)		 ; 934F DD CB 05 2E	; Rota aritmticamente a la derecha (IX+$05)
	lda	4,y			; get the other unknown meaning byte	; 	LD A, (IX+$04)		 ; 9353 DD 7E 04	; Carga A con (IX+$04)
	cmpa	#2			; is it 2 or greater?			; 	CP $02			 ; 9356 FE 02		; Compara A con $02
	bcc	1f			; yes, skip next
	jsr	L_9D50			; call L_9D50				; 	CALL C, L_9D50		 ; 9358 DC 50 9D	; si flag C=1, llama rutina L_9D50 (#204# --)
1	lda	#$83			; get value $83				; 	LD A, $83		 ; 935B 3E 83		; Carga A con $83
	jsr	PrintObjStatus		; show status (false, of bit3=broken)	; 	CALL PrintObjStatus	 ; 935D CD 6C A1	; llama PrintObjStatus con A=$83 (bit3=1) dead/broken
i_9360	lda	SecondObject		; get 2nd object			; i_9360: LD A, (SecondObject)	 ; 9360 3A E9 B6	; Carga cdigo objeto secundario
	cmpa	#$ff			; is it none?				; 	CP $FF			 ; 9363 FE FF		; Compara A con $FF
	beq	e_9399			; yes, exit				; 	RET Z			 ; 9365 C8		; Z = 1?	; Retorna si es cero
	ldy	SecndObjectPtr		; get pointer				; 	LD IY, (SecndObjectPtr)	 ; 9366 FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save it
	ldb	7,y			; get flags
	bitb	#%00001000		; is it dead?				; 	BIT 3, (IY+$07)		 ; 936A FD CB 07 5E	; Esta a 1 el bit 3 de (IY+$07)?
	bne	e_9399			; yes, exit				; 	RET NZ			 ; 936E C0		; Si Z = 0, Retorna
	ldb	6,y			; get unknown meaning byte
	stb	<reg_B			; into reg_B				; 	LD B, (IY+$06)		 ; 936F FD 46 06	; Carga B con (IY+$06)
	lda	#$15			; max value				; 	LD A, $15		 ; 9372 3E 15		; Carga A con $15
	jsr	GetRandom		; get random number			; 	CALL GetRandom		 ; 9374 CD A8 9C	; llama rutina GetRandom (envia A=valor mximo, recibe nuevo random en A)
	adda	<reg_B			; add reg_B				; 	ADD A, B		 ; 9377 80		; Adiciona B en A
	bcc	i_937C			; if not overflow, skip next		; 	JR NC, i_937C		 ; 9378 30 02		; Si C = 0, Salta a i_937C
	lda	#$ff			; get max value				; 	LD A, $FF		 ; 937A 3E FF		; Carga A con $FF
i_937C	ldu	<reg_IX			; get pseudoreg				; i_937C: SUB (IX+$06)		 ; 937C DD 96 06	; Resta (IX+$06) de A
	suba	6,u			; subtract unknown meaning byte
	bcs	e_9399			; if was lower, exit			; 	RET C			 ; 937F D8		; Si C = 1, Retorna
	ldb	7,y			; get flags
	orb	#%00001000		; set as dead				; 	SET 3, (IY+$07)		 ; 9380 FD CB 07 DE	; Pasa a 1 el bit 3 en (IY+$07)
	stb	7,y			; update flags
	lda	SecondObject		; get 2nd object			; 	LD A, (SecondObject)	 ; 9384 3A E9 B6	; Carga cdigo objeto secundario
	jsr	UpdateDeadObject	; process its death			; 	CALL UpdateDeadObject	 ; 9387 CD 8C A1	; llama UpdateDeadObject
	ldy	<reg_IY			; get pseudoreg
	lda	5,y			; get strength				; 	LD A, (IY+$05)		 ; 938A FD 7E 05	; Carga A con (IY+$05)
	asra				; set to half value			; 	SRA A			 ; 938D CB 2F		; Rota aritmticamente a la derecha A
	sta	5,y			; update value				; 	LD (IY+$05), A		 ; 938F FD 77 05	; Carga (IY+$05) con A
	jsr	L_9D50			; call L_95D0				; 	CALL L_9D50		 ; 9392 CD 50 9D	; llama rutina L_9D50 (#204# --)
					; L_9D50 returns IY into register 'U'
	stu	<reg_IX			; pass register to reg_IX		; 	PUSH IY			 ; 9395 FD E5		; Guarda IY
										; 	POP IX			 ; 9397 DD E1		; Recupera IX
i_9399	lda	#$83			; get value $83				; i_9399: LD A, $83		 ; 9399 3E 83		; Carga A con $83
	lbra	PrintObjStatus		; show status (false, of bit3=broken)	; 	JP PrintObjStatus	 ; 939B C3 6C A1	; salta a PrintObjStatus con A=$83 (bit3=1) dead/broken
e_9399	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Give									; Action_Give:						
	ldy	SecndObjectPtr		; get pointer				; 	LD IY, (SecndObjectPtr)	 ; 939E FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save it
	jsr	OwnsActorCurObject1	; is actor the owner?			; 	CALL OwnsActorCurObject1 ; 93A2 CD 78 9C	; llama OwnsActorCurObject1
	ldx	#L_ADF1			; point to message			; 	LD HL, L_ADF1		 ; 93A5 21 F1 AD	; apunta a mensaje "You are not carrying it[0x15]"
	lbcc	PrintMsg		; if carry clear show it		; 	JP NC, PrintMsg		 ; 93A8 D2 DD 72	; si no hay acarreo, salta a PrintMsg
	lda	SecondObject		; get 2nd object			; 	LD A, (SecondObject)	 ; 93AB 3A E9 B6	; Carga cdigo objeto secundario
	jsr	L_9CED			; return mass				; 	CALL L_9CED		 ; 93AE CD ED 9C	; llama rutina L_9CED (#179# --)
	ldu	MainObjectPtr		; get pointer to main object		; 	LD IX, (MainObjectPtr)	 ; 93B1 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; save it
	adda	3,u			; add mass				; 	ADD A, (IX+$03)		 ; 93B5 DD 86 03	; Adiciona (IX+$03) en A
	sta	<reg_B			; save at reg_B				; 	PUSH AF			 ; 93B8 F5		; Guarda AF
	ldy	<reg_IY			; get pseudo-register			; 	POP BC			 ; 93B9 C1		; Recupera BC
	lda	3,y			; get its mass				; 	LD A, (IY+$03)		 ; 93BA FD 7E 03	; Carga A con (IY+$03)
	suba	<reg_B			; subtract from calculated		; 	SUB B			 ; 93BD 90		; Resta B de A
	ldx	#L_AE0C			; point to message			; 	LD HL, L_AE0C		 ; 93BE 21 0C AE	; apunta a mensaje "You are carrying too much"
	lbcs	PrintMsg		; if carry (excess), show message	; 	JP C, PrintMsg		 ; 93C1 DA DD 72	; Si flag C = 1, salta a PrintMsg
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; 93C4 CD 44 9D	; llama BreakIfB6faNot1
	lda	SecondObject		; get 2nd object			; 	LD A, (SecondObject)	 ; 93C7 3A E9 B6	; Carga cdigo objeto secundario
	sta	1,u			; put as container			; 	LD (IX+$01), A		 ; 93CA DD 77 01	; Carga (IX+$01) con A
	lda	16,y			; get location				; 	LD A, (IY+$10)		 ; 93CD FD 7E 10	; Carga A con (IY+$10)
	sta	16,u			; set as location of contained object	; 	LD (IX+$10), A		 ; 93D0 DD 77 10	; Carga (IX+$10) con A
	sta	<reg_B			; save at reg_B				; 	LD B, A			 ; 93D3 47		; Carga B con A
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 93D4 3A E8 B6	; Carga cdigo objeto principal
	lbra	L_9BDD			; go L_9BDD				; 	JP L_9BDD		 ; 93D7 C3 DD 9B	; salta a L_9BDD (#186# --)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Examine									; Action_Examine:					; (# sinNumero)
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 93DA CD 44 9D	; llama BreakIfB6faNot1
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 93DD 3A E8 B6	; Carga cdigo objeto principal
	jsr	GetObjPointer2IX	; and its pointer			; 	CALL GetObjPointer2IX	 ; 93E0 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	ldx	14,y			; get message pointer			; 	LD L, (IX+$0E)		 ; 93E3 DD 6E 0E	; Carga L con (IX+$0E)
										; 	LD H, (IX+$0F)		 ; 93E6 DD 66 0F	; Carga H con (IX+$0F). HL apunta a descripcin del Objeto
										; 	LD A, H			 ; 93E9 7C		; Carga A con H
										; 	OR L			 ; 93EA B5		; Hace OR lgico de A con L
	lbne	PrintMsg		; if not null, show it			; 	JP NZ, PrintMsg		 ; 93EB C2 DD 72	; si no es cero, salta a PrintMsg
	ldx	#L_B000			; point to message			; 	LD HL, L_B000		 ; 93EE 21 00 B0	; apunta a menaje "You see[0x16]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 93F1 CD DD 72	; llama rutina PrintMsg 
	ldy	<reg_IX			; pass IX				; 	PUSH IX			 ; 93F4 DD E5		; Guarda IX
	sty	<reg_IY			; to IY					; 	POP IY			 ; 93F6 FD E1		; Recupera IY
	jsr	ShowObjDescription	; show description			; 	CALL ShowObjDescription	 ; 93F8 CD C7 9E	; llama ShowObjDescription
	lda	#$2e			; get '.'				; 	LD A, $2E		 ; 93FB 3E 2E		; Carga A con $2E
	jsr	PutChar			; showit				; 	CALL PutChar		 ; 93FD CD 8B 85	; llama rutina PutChar
	jsr	PutEnter		; put an enter				; 	CALL PutEnter		 ; 9400 CD 83 85	; llama rutina PutEnter
	rts				; return				; 	RET			 ; 9403 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#275# --)
L_9404	ldy	MainObjectPtr		; point to main object			; L_9404: LD IX, (MainObjectPtr) ; 9404 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save ptr
	jsr	TestOpenFlag		; is it open?				; 	CALL TestOpenFlag	 ; 9408 CD CA A5	; llama TestOpenFlag
	lbeq	PrintObjStatus		; no, show status			; 	JP Z, PrintObjStatus	 ; 940B CA 6C A1	; si flag Z=1, salta a PrintObjStatus con A=$05 (bit5=0) closed
	lda	MainObject		; get main obj ID			; 	LD A, (MainObject)	 ; 940E 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_9D97			; call L_9D97				; 	CALL L_9D97		 ; 9411 CD 97 9D	; llama rutina L_9D97 (#198# --)
	tsta				; is it Bilbo?				; 	CP $00			 ; 9414 FE 00		; Compara A con $00
	beq	i_9423			; yes, exit 				; 	JR Z, i_9423		 ; 9416 28 0B		; Si Z = 1, Salta a i_9423
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 9418 CD 44 9D	; llama BreakIfB6faNot1
	jsr	L_9D50			; call L_9D50				; 	CALL L_9D50		 ; 941B CD 50 9D	; llama rutina L_9D50 (#204# --)
	ldu	<reg_IX			; get obj pointer
	ldb	7,u			; get flags
	andb	#%11111011		; set to empty
	stb	7,u			; update flags				; 	RES 2, (IX+$07)		 ; 941E DD CB 07 96	; Pasa a 0 el bit 2 en (IX+$07)
	rts				; return				; 	RET			 ; 9422 C9		; Retorna
i_9423	lda	#2			; bit value for empty			; i_9423: LD A, $02		 ; 9423 3E 02		; Carga A con $02
	lbra	PrintObjStatus		; show status				; 	JP PrintObjStatus	 ; 9425 C3 6C A1	; salta a PrintObjStatus con A=$02 (bit2=0) empty
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#257# --)
L_9428	jsr	L_8D25			; call L_8D25				; L_9428: CALL L_8D25		 ; 9428 CD 25 8D	; llama rutina L_8D25 (#202# --)
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 942B CD 44 9D	; llama BreakIfB6faNot1
	lda	ObjectLocation		; get location ID			; 	LD A, (ObjectLocation)	 ; 942E 3A F6 B6	; recupera ObjectLocation
	ldu	SecndObjectPtr		; get 2nd obj pointer			; 	LD IX, (SecndObjectPtr)	 ; 9431 DD 2A 0A B7	; Carga SecndObjectPtr
	stu	<reg_IX			; save it
	ldb	,u			; get visible numLocs			; 	LD B, (IX+$00)		 ; 9435 DD 46 00	; Carga B con (IX+$00)
	stb	<reg_B			; in reg_B
i_9438	cmpa	16,u			; is the 1st one?			; i_9438: CP (IX+$10)		 ; 9438 DD BE 10	; Compara A con (IX+$10)
	beq	i_9444			; yes, exit loop			; 	JR Z, i_9444		 ; 943B 28 07		; Si Z = 1, Salta a i_9444
	leau	1,u			; point to next location		; 	INC IX			 ; 943D DD 23		; Incrementa IX
	stu	<reg_IX			; update pseudoreg
	dec	<reg_B			; decrement counter
	bne	i_9438			; if not done, loopback			; 	DJNZ i_9438		 ; 943F 10 F7		; Decrementa B y si no es cero vuelve a i_9438
	lbra	L_72CE			; none, goto L_72CE			; 	JP L_72CE		 ; 9441 C3 CE 72	; salta a L_72CE (#211# --)
i_9444	lda	17,u			; get next byte after location		; i_9444: LD A, (IX+$11)	 ; 9444 DD 7E 11	; Carga A con (IX+$11)
	dec	<reg_B			; decrement counter			; 	DEC B			 ; 9447 05		; Decrementa B
	bne	i_944B			; if not zero, skip next		; 	JR NZ, i_944B		 ; 9448 20 01		; Si Z = 0, Salta a i_944B
	clra				; get value zero			; 	XOR A			 ; 944A AF		; Exorea A con A
i_944B	pshs	a,cc			; save registers			; i_944B: PUSH AF		 ; 944B F5		; Guarda AF
	ldx	#L_ADFC			; point to message			; 	LD HL, L_ADFC		 ; 944C 21 FC AD	; apunta a mensaje "and it get(s|d|ing|es) swept away"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 944F CD DD 72	; llama rutina PrintMsg 
	puls	a,cc			; restore registers			; 	POP AF			 ; 9452 F1		; Recupera AF
	ldu	MainObjectPtr		; point to main obj 			; 	LD IX, (MainObjectPtr)	 ; 9453 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; save it
	sta	16,u			; get location				; 	LD (IX+$10), A		 ; 9457 DD 77 10	; Carga (IX+$10) con A
	ldb	#$ff			; put NO container
	stb	1,u			; in it					; 	LD (IX+$01), $FF	 ; 945A DD 36 01 FF	; Carga (IX+$01) con $FF
	sta	<reg_B			; save location				; 	LD B, A			 ; 945E 47		; Carga B con A
	lda	MainObject		; get mainObject ID			; 	LD A, (MainObject)	 ; 945F 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_9BDD			; call L_9BDD				; 	CALL L_9BDD		 ; 9462 CD DD 9B	; llama rutina L_9BDD (#186# --)
	lda	L_C11B+16		; get Bilbo's location			; 	LD A, (L_C11B + $10)	 ; 9465 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
										; 	AND A			 ; 9468 A7		; adecua flags
	lbeq	BilboIsDeadEndGame	; if none, end game			; 	JP Z, BilboIsDeadEndGame ; 9469 CA D2 90	; si flag Z=1, salta a BilboIsDeadEndGame
	rts				; return				; 	RET			 ; 946C C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_946D	jsr	L_A1F9			; call L_A1F9				; L_946D: CALL L_A1F9		 ; 946D CD F9 A1	; llama rutina L_A1F9 (#199# --)
	lbne	PrintObjStatus		; if return not zero, show status	; 	JP NZ, PrintObjStatus	 ; 9470 C2 6C A1	; si flag Z=0, salta a PrintObjStatus A=$80  $85 segn L_A1F9 (bits 0  5 = 1) locked/open
	ldd	#$ca01			; set opcode for ORB #$01		; 	LD A, $C6		 ; 9473 3E C6		; Carga A con $C6
L_9475	std	D_9488			; overwrite code			; L_9475: LD (D_9488+$03), A	 ; 9475 32 8B 94	; pone 'A' en D_948B
	ldy	SecndObjectPtr		; get pointer				; 	LD IY, (SecndObjectPtr)	 ; 9478 FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save it
	ldb	7,y			; get flags
	lda	#$83			; show broken status			; 	BIT 3, (IY+$07)		 ; 947C FD CB 07 5E	; Esta a 1 el bit3 de (IY+$07) (lleno)?
	bitb	#%00001000		; is it dead/broken?			; 	LD A, $83		 ; 9480 3E 83		; Carga A con $83
	lbne	L_A164			; no, show object name			; 	JP NZ, L_A164		 ; 9482 C2 64 A1	; Si Z = 0, Salta a L_A164
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 9485 CD 44 9D	; llama BreakIfB6faNot1
	ldy	<reg_IX			; get pseudoreg
	ldb	7,y			; get flags
D_9488	orb	#%00000001		; CA 01	 - set locked			; D_9488: SET 0, (IX+$07)	 ; 9488 DD CB 07 C6	; Pasa a 1 el bit0 en (IX+7) (bloqueado), si viene de L_946D
	;andb	#%11111110		; C4 FE	 - set unlocked		 	;	; RES 0, (IX+$07)	 ; (alternate)		; pasa a 0 el bit0 de (IX+7) (desbloqueado), si viene de $94A2, queda as: DD CB 07 86 
	stb	7,y			; update flags
	rts				; return				; 	RET			 ; 948C C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_948D	ldy	MainObjectPtr		; get pointer				; L_948D: LD IX, (MainObjectPtr) ; 948D DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	ldb	7,y			; get flags
	clra				; get value zero			; 	BIT 0, (IX+$07)		 ; 9491 DD CB 07 46	; Esta a 1 el bit 0 de (IX+$07)?
	bitb	#%00000001		; is it locked?				; 	LD A, $00		 ; 9495 3E 00		; Carga A con $00
	lbeq	PrintObjStatus		; no, show status			; 	JP Z, PrintObjStatus	 ; 9497 CA 6C A1	; si flag Z=1, salta a PrintObjStatus con A=$00 (bit0=0) unlocked
	jsr	L_A204			; prepare for bit 5 (open)		; 	CALL L_A204		 ; 949A CD 04 A2	; Llama a L_A204
	lbne	PrintObjStatus		; show status if open			; 	JP NZ, PrintObjStatus	 ; 949D C2 6C A1	; si flag Z=0, salta a PrintObjStatus con A=$85 (bit5=1) open
	ldd	#$c4fe			; opcode for ANDB #$fe			; 	LD A, $86		 ; 94A0 3E 86		; Carga A con $86
	bra	L_9475			; go back to change code 		; 	JR L_9475		 ; 94A2 18 D1		; Salta a L_9475
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#251# --)
L_94A4	jsr	L_8C9B			; detect if actor has object		; L_94A4: CALL L_8C9B		 ; 94A4 CD 9B 8C	; llama rutina (-19-)
	lda	SecondObject		; get second object			; 	LD A, (SecondObject)	 ; 94A7 3A E9 B6	; Carga cdigo objeto secundario
	jsr	L_9F28			; modif code				; 	CALL L_9F28		 ; 94AA CD 28 9F	; llama rutina L_9F28 (#207# --)
	cmpa	#$ff			; end of obj table?			; 	CP $FF			 ; 94AD FE FF		; Compara A con $FF
	lbeq	IfB6FAis1DescAction	; yes, desc action			; 	JP Z, IfB6FAis1DescAction ; 94AF CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	ldy	SecndObjectPtr		; get 2nd obj pointer			; 	LD IY, (SecndObjectPtr)	 ; 94B2 FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save it
	ldb	7,y			; get flags
	lda	#5			; set value 5				; 	BIT 5, (IY+$07)		 ; 94B6 FD CB 07 6E	; Esta a 1 el bit 5 de (IY+$07)?
	bitb	#%00100000		; is it open?				; 	LD A, $05		 ; 94BA 3E 05		; Carga A con $05
	lbeq	L_A164			; show obj name				; 	JP Z, L_A164		 ; 94BC CA 64 A1	; Si Z = 1, Salta a L_A164
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; 94BF CD 44 9D	; llama BreakIfB6faNot1
	ldu	<reg_IX			; get pseudoreg
	ldb	2,u			; get data byte
	stb	<reg_B			; save in reg_B				; 	LD B, (IX+$02)		 ; 94C2 DD 46 02	; Carga B con (IX+$02)
	ldy	MainObjectPtr		; get main obj pointer			; 	LD IX, (MainObjectPtr)	 ; 94C5 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	ldb	#$ff			; put NO container
	stb	1,y			; in object				; 	LD (IX+$01), $FF	 ; 94C9 DD 36 01 FF	; Carga (IX+$01) con $FF
	ldb	<reg_B			; set saved data byte 
	stb	16,y			; as new location			; 	LD (IX+$10), B		 ; 94CD DD 70 10	; Carga (IX+$10) con B
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; 94D0 3A E8 B6	; Carga cdigo objeto principal
	lbra	L_9BDD			; affected owned objects		; 	JP L_9BDD		 ; 94D3 C3 DD 9B	; salta a L_9BDD (#186# --)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; sirve para buscar si la accin est contemplada como vlida, devolviendo 
										; 							; o bien Z=0 si encontrada o Z=1 si no.   
										; 							; Busca la accin en las tablas y en el objeto ; antes ; (#151# --)
										; 							; devuelve A=0 si action no factible o bien Action no encontrada
IsActionInTables								; IsActionInTables:					; devuelve A=1 si la accin est en una de las tablas o en el Objeto
	ldu	<reg_IX			; recupera reg_IX			; 	PUSH IX			 ; 94D6 DD E5		; Guarda IX
	pshs	x,u			; guarda X(HL), U(IX)			; 	PUSH HL			 ; 94D8 E5		; Guarda HL
	jsr	IsActionFeasible	; llama IsActionFeasible		; 	CALL IsActionFeasible	 ; 94D9 CD 44 9B	; llama IsActionFeasible(MainObject, SecondObject) - devuelve Z=0 si se puede efectuar
	tfr	cc,b			; guarda flags en B
	clra				; toma valor 0				; 	LD A, $00		 ; 94DC 3E 00		; A=$00
	tfr	b,cc			; recupera flags de B
	beq	i_9508			; si devolvi 0, salta a i_9508		; 	JR Z, i_9508		 ; 94DE 28 28		; si NO se puede efectuar, sale via i_9508 con A=0
	lda	CurrentAction		; recupera CurrentAction		; 	LD A, (CurrentAction)	 ; 94E0 3A E7 B6	; recupera cdigo de accin a ejecutar
	ldu	#ActionTable		; apunta a ActionTable			; 	LD IX, ActionTable	 ; 94E3 DD 21 30 C7	; apunta a ActionTable
	stu	<reg_IX			; lo guarda en reg_IX
	jsr	FindPointer		; llama FindPointer			; 	CALL FindPointer	 ; 94E7 CD BD 9D	; busca puntero con CurrentAction en ActionTable
	cmpa	#$FF			; devolvi $FF?				; 	CP $FF			 ; 94EA FE FF		; llegado a final de tabla? (no encontrado)
	tfr	cc,b			; guarda flags en B							
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 94EC 3E 01		; A=$01
	tfr	b,cc			; recupera flags de B
	bne	i_9508			; si no era $FF, salta a i_9508		; 	JR NZ, i_9508		 ; 94EE 20 18		; si encontrado, sale via i_9508 con A=1
	jsr	IsActionInTableA20b	; llama IsActionInTableA20b		; 	CALL IsActionInTableA20b ; 94F0 CD D0 A1	; llama IsActionInTableA20b (si encontrado Z=1)
	tfr	cc,b			; guarda flags en B							
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 94F3 3E 01		; Carga A con $01
	tfr	b,cc			; recupera flags de B
	beq	i_9508			; si devolvi 0, salta a i_9508		; 	JR Z, i_9508		 ; 94F5 28 11		; si encontrado, sale via i_9508 con A=1
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 94F7 3A E8 B6	; recupera cdigo objeto principal
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX	 ; 94FA CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	lda	CurrentAction		; recupera CurrentAction		; 	LD A, (CurrentAction)	 ; 94FD 3A E7 B6	; recupera accin a efectuar
	jsr	SearchActionInObj	; llama SearchActionInObj		; 	CALL SearchActionInObj	 ; 9500 CD 81 9B	; llama SearchActionInObj (encontrado implica C=1)
	tfr	cc,b			; guarda flags en B							
	lda	#1			; toma valor 1				; 	LD A, $01		 ; 9503 3E 01		; A=$01
	tfr	b,cc			; recupera flags de B
	bcs	i_9508			; si devolvi carry, salta a i_9508	; 	JR C, i_9508		 ; 9505 38 01		; si encontrado, sale via i_9508 con A=1
	clra				; toma valor 0				; 	SUB A			 ; 9507 97		; A=$00 (no encontrado)
i_9508	sta	L_B6FB			; guarda valor de A en L_B6FB		; i_9508: LD (L_B6FB), A	 ; 9508 32 FB B6	; guarda A en L_B6FB
	puls	u,x			; recupera U(IX),X(HL)			; 	POP HL			 ; 950B E1		; Recupera HL
	stu	<reg_IX			; actualiza reg_IX			; 	POP IX			 ; 950C DD E1		; Recupera IX
	rts				; retorna				; 	RET			 ; 950E C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Recibe la accin a realizar en b6e7 y los objetos utilizados en b6e8 y b6e9. 
										; 							; Si un objeto no se utiliza, llega a $ff.
										; 							; Efectos laterales, al acabar quedan modificadas:
										; 							; b708/9 Puntero al objeto primario
										; 							; b70a/b Puntero al objeto secundario
ExecuteAction									; ExecuteAction:					; antes	; (#95# --)
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; 950F E5		; Guarda HL
	ldu	<reg_IX			; recupera reg_IX
	ldy	<reg_BC			; recupera reg_BC			; 	PUSH IX			 ; 9510 DD E5		; Guarda IX
	pshs	u,y			; guarda U(IX),Y(BC)			; 	PUSH BC			 ; 9512 C5		; Guarda BC
										; 							; Comprueba si la accin puede efectuarse con los dos objetos
	jsr	IsActionFeasible	; llama IsActionFeasible		; 	CALL IsActionFeasible	 ; 9513 CD 44 9B	; llama IsActionFeasible ; Devuelve Z=1 si no es el caso
	lbeq	i_95DA			; si devuelve 0, salta a i_95DA		; 	JP Z, i_95DA		 ; 9516 CA DA 95	; si no puede efectuarse, Salta a i_95DA que imprime "I cannot do that" y sale por 95c7
										; 							; Es una accin que puede efectuarse, lo primero miramos si est oscuro:
	jsr	IsItDark		; llama IsItDark			; 	CALL IsItDark		 ; 9519 CD ED 95	; llama rutina IsItDark
	bcc	i_9539			; si no devuelve carry, salta a i_9539	; 	JR NC, i_9539		 ; 951C 30 1B		; Si C = 0, Salta a i_9539 (no est oscuro)
										; 							; si est oscuro, hacemos:
	lda	L_B711			; recupera L_B711			; 	LD A, (L_B711)		 ; 951E 3A 11 B7	; Carga L_B711
										; 	AND A			 ; 9521 A7		; es 0?
	bne	i_9531			; si no es 0, salta a i_9531		; 	JR NZ, i_9531		 ; 9522 20 0D		; no, salta a i_9531
	jsr	OwnsActorCurObject1	; llama OwnsActorCurObject1		; 	CALL OwnsActorCurObject1 ; 9524 CD 78 9C	; llama OwnsActorCurObject1
	bcc	i_9531			; si no devuelve carry, salta a i_9531	; 	JR NC, i_9531		 ; 9527 30 08		; Si C = 0, Salta a i_9531
	lda	SecondObject		; recupera SecondObject			; 	LD A, (SecondObject)	 ; 9529 3A E9 B6	; Carga cdigo objeto secundario
	jsr	OwnsActorObject		; llama OwnsActorObject			; 	CALL OwnsActorObject	 ; 952C CD 7B 9C	; llama OwnsActorObject
	bcs	i_9539			; si devuelve carry, salta a i_9539	; 	JR C, i_9539		 ; 952F 38 08		; Si C = 1, Salta a i_9539
i_9531	ldx	#L_AFC4			; apunta a L_AFC4			; i_9531: LD HL, L_AFC4		 ; 9531 21 C4 AF	; apunta a mensaje "i see nothing here"
	jsr	PrintMsg		; llama PrintMsg			; 	CALL PrintMsg		 ; 9534 CD DD 72	; llama rutina PrintMsg 
	bra	i_959B			; salta a i_959B			; 	JR i_959B		 ; 9537 18 62		; Salta a i_959B
										; 							; si hay luz, hacemos:
i_9539	lda	IsMainObjLoc		; recupera IsMainObjLoc			; i_9539: LD A, (IsMainObjLoc)	 ; 9539 3A FE B6	; recupera IsMainObjLoc
	cmpa	#1			; es 1?					; 	CP $01			 ; 953C FE 01		; Compara A con $01
	lbeq	i_95CC			; si, salta a i_95CC			; 	JP Z, i_95CC		 ; 953E CA CC 95	; Si Z = 1, Salta a i_95CC - procesar por tabla de acciones
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 9541 3A E8 B6	; Carga cdigo objeto principal
	cmpa	#$FF			; es $FF?				; 	CP $FF			 ; 9544 FE FF		; es $FF (ningn objeto)?
	lbeq	i_95CC			; si, salta a i_95CC			; 	JP Z, i_95CC		 ; 9546 CA CC 95	; si, Salta a i_95CC - procesar por tabla de acciones
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX	 ; 9549 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	sty	MainObjectPtr		; guarda MainObjectPtr			; 	LD (MainObjectPtr), IX	 ; 954C DD 22 08 B7	; guarda MainObjectPtr
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 9550 3A E8 B6	; Carga cdigo objeto principal
	jsr	OwnsObjAnotherPNJ	; llama OwnsObjAnotherPNJ		; 	CALL OwnsObjAnotherPNJ	 ; 9553 CD 28 97	; llama OwnsObjAnotherPNJ
	bne	i_959B			; si no devuelve 0, salta a i_959B	; 	JR NZ, i_959B		 ; 9556 20 43		; si lo tiene otro PNJ, salta a i_959B
	lda	SecondObject		; recupera SecondObject			; 	LD A, (SecondObject)	 ; 9558 3A E9 B6	; Carga cdigo objeto secundario
	cmpa	#$FF			; es $FF?				; 	CP $FF			 ; 955B FE FF		; es nulo?
	beq	i_957A			; si, salta a i_957A			; 	JR Z, i_957A		 ; 955D 28 1B		; si, salta a i_957A
	lda	IsSecObjLoc		; recupera IsSecObjLoc			; 	LD A, (IsSecObjLoc)	 ; 955F 3A FF B6	; recupera IsSecObjLoc
	cmpa	#1			; es 1?					; 	CP $01			 ; 9562 FE 01		; es $01?
	beq	i_95CC			; si, salta a i_95CC			; 	JR Z, i_95CC		 ; 9564 28 66		; si, salta a i_95CC - procesar por tabla de acciones
	lda	SecondObject		; recupera SecondObject			; 	LD A, (SecondObject)	 ; 9566 3A E9 B6	; Carga cdigo objeto secundario
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX	 ; 9569 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto secundario en IX
	sty	SecndObjectPtr		; guarda SecndObjectPtr			; 	LD (SecndObjectPtr), IX	 ; 956C DD 22 0A B7	; guarda SecndObjectPtr
	jsr	OwnsObjAnotherPNJ	; llama OwnsObjAnotherPNJ		; 	CALL OwnsObjAnotherPNJ	 ; 9570 CD 28 97	; llama OwnsObjAnotherPNJ
	bne	i_959B			; si no devuelve 0, salta a i_959B	; 	JR NZ, i_959B		 ; 9573 20 26		; si lo tiene otro PNJ, salta a i_959B a procesar accin del PNJ
										; 							; Llamamos a IsActionInTableA20b. 
										; 							; Esta rutina busca el cdigo del ActionActor en una tabla de 5 bytes
										; 							; Devuelve Z=1 si lo encuentra.
										; 							; Si no se encuentra se pone IX al valor almacenado en *b708 (el puntero al 
										; 							; objeto principal). En otro caso se quedara con el puntero al objeto secundario.
										; 							; Esto sirve para determinar en los datos de qu objeto hay que buscar las rutinas
										; 							; a ejecutar para la accin.
	jsr	IsActionInTableA20b	; llama IsActionInTableA20b		; 	CALL IsActionInTableA20b ; 9575 CD D0 A1	; llama IsActionInTableA20b
	beq	i_957E			; si devuelve 0, salta a i_957E		; 	JR Z, i_957E		 ; 9578 28 04		; si encontrado, salta siguiente instruccin
i_957A	ldy	MainObjectPtr		; recupera MainObjectPtr		; i_957A: LD IX, (MainObjectPtr) ; 957A DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; actualiza reg_IX
i_957E	lda	CurrentAction		; recupera CurrentAction		; i_957E: LD A, (CurrentAction)	 ; 957E 3A E7 B6	; Carga ID de accin
	jsr	SearchActionInObj	; llama SearchActionInObj		; 	CALL SearchActionInObj	 ; 9581 CD 81 9B	; llama SearchActionInObj
	bcc	i_95CC			; si no devuelve carry, salta a i_95CC	; 	JR NC, i_95CC		 ; 9584 30 46		; si no encontrado, salta a i_95CC - procesar por tabla de acciones
										; 							; recuperar puntero a la accin encontrada en el Objeto
i_9586	ldu	<reg_IX			; recupera reg_IX			; i_9586: LD L, (IX+$01)	 ; 9586 DD 6E 01	; Carga L con (IX+$01)
	ldx	1,u			; toma dos bytes			; 	LD H, (IX+$02)		 ; 9589 DD 66 02	; Carga H con (IX+$02) HL apunta a la rutina que ejecuta la accin
	jsr	CallSubrutineHL		; llama CallSubrutineHL			; 	CALL CallSubrutineHL	 ; 958C CD 6C 9B	; llama CallSubrutineHL
	ldu	<reg_IX			; recupera reg_IX			; 	INC IX			 ; 958F DD 23		; Incrementa IX
	leau	3,u			; le suma 3				; 	INC IX			 ; 9591 DD 23		; tres veces
	stu	<reg_IX			; actualiza reg_IX			; 	INC IX			 ; 9593 DD 23		; para apuntar a la siguiente accin de la subtabla del Objeto
										; 	SUB A			 ; 9595 97		; borra A
	tst	,u			; es 0 el byte apuntado por U(IX)?	; 	CP (IX+$00)		 ; 9596 DD BE 00	; es la siguiente accin $00?
	beq	i_9586			; si, vuelve a i_9586			; 	JR Z, i_9586		 ; 9599 28 EB		; si, procesar dicha entrada tambin
i_959B	lda	L_B6FA			; recupera L_B6FA			; i_959B: LD A, (L_B6FA)	 ; 959B 3A FA B6	; Carga A con (L_B6FA)
	cmpa	#1			; es 1?					; 	CP $01			 ; 959E FE 01		; es $01?
	bne	i_95C7			; no, salta a i_95C7			; 	JR NZ, i_95C7		 ; 95A0 20 25		; no, sale via i_95C7
	lda	ActionActor		; recupera ActionActor			; 	LD A, (ActionActor)	 ; 95A2 3A EA B6	; Carga ActionActor
										; 	CP $00			 ; 95A5 FE 00		; es $00 Bilbo?
	bne	i_95AF			; si no es 0, salta a i_95AF		; 	JR NZ, i_95AF		 ; 95A7 20 06		; no, salta siguiente instruccin
	jsr	IsItDark		; llama IsItDark			; 	CALL IsItDark		 ; 95A9 CD ED 95	; llama rutina IsItDark
	bcc	i_95AF			; si no devuelve carry, salta a i_95AF	; 	CALL C, PrintMsg	 ; 95AC DC DD 72	; si flag C=1, llama rutina PrintMsg
	jsr	PrintMsg		; llama PrintMsg
i_95AF	lda	CurrentAction		; recupera CurrentAction		; i_95AF: LD A, (CurrentAction)	 ; 95AF 3A E7 B6	; Carga ID de accin
	sta	<reg_B			; la guarda en reg_B			; 	LD B, A			 ; 95B2 47		; en B
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 95B3 3A E8 B6	; Carga cdigo objeto principal
	ldy	MainObjectPtr		; recupera MainObjectPtr		; 	LD IX, (MainObjectPtr)	 ; 95B6 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; actualiza reg_IX			; 	CALL L_95DF		 ; 95BA CD DF 95	; llama rutina L_95DF (#210# --)
	jsr	L_95DF			; llama L_95DF				; 							; Se repite lo anterior con el objeto secundario
	lda	SecondObject		; recupera SecondObject			; 	LD A, (SecondObject)	 ; 95BD 3A E9 B6	; Carga cdigo objeto secundario
	ldy	SecndObjectPtr		; recupera SecndObjectPtr		; 	LD IX, (SecndObjectPtr)	 ; 95C0 DD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IX			; actualiza reg_IX
	jsr	L_95DF			; llama L_95DF				; 	CALL L_95DF		 ; 95C4 CD DF 95	; llama rutina L_95DF (#210# --)
i_95C7	puls	u,y			; recupera U(IX),Y(BC)			; i_95C7: POP BC		 ; 95C7 C1		; Recupera BC
	sty	<reg_BC			; actualiza reg_BC
	stu	<reg_IX			; actualiza reg_IX			; 	POP IX			 ; 95C8 DD E1		; Recupera IX
	puls	x,pc			; recupera X y retorna			; 	POP HL			 ; 95CA E1		; Recupera HL
										; 	RET			 ; 95CB C9		; Retorna
										; 							; Busca la accin en la tabla de acciones
i_95CC	lda	CurrentAction		; recupera CurrentAction		; i_95CC: LD A, (CurrentAction)	 ; 95CC 3A E7 B6	; Carga cdigo de accin
	ldy	#ActionTable		; apunta a ActionTable			; 	LD IX, ActionTable	 ; 95CF DD 21 30 C7	; apunta a ActionTable
	sty	<reg_IX			; actualiza reg_IX
	jsr	FindPointer		; llama FindPointer			; 	CALL FindPointer	 ; 95D3 CD BD 9D	; llama FindPointer - busca puntero con el cdigo de accin en ActionTable
	cmpa	#$FF			; devolvi $FF?				; 	CP $FF			 ; 95D6 FE FF		; se lleg a fin de tabla?
	bne	i_9586			; no, vuelve a i_9586			; 	JR NZ, i_9586		 ; 95D8 20 AC		; si encontrado, salta a i_9586 a procesar la accin(ones)
i_95DA	jsr	L_72CE			; llama L_72CE				; i_95DA: CALL L_72CE		 ; 95DA CD CE 72	; no encontrado, llama rutina L_72CE (#211# --) imprime "I cannot do that"
	bra	i_95C7			; vuelve a i_95C7			; 	JR i_95C7		 ; 95DD 18 E8		; Sale via i_95C7
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Parametros A=objeto, B=Accion, IX=puntero a objeto ; (#210# --)
										; 							; Comprueba si el objeto pasado en IX es un animal y est vivo, para llamar a la rutina S_RewindAndSetEntry.
										; 							; Busca en su directorio la entrada de accin B y pone WORD1 a esa entrada para que el PNJ reaccione.
L_95DF	ldu	<reg_IX			; recupera reg_IX
	ldb	7,u			; recupera status byte
	bitb	#%01000000		; tiene el bit6 a 1?			; L_95DF: BIT 6, (IX+$07)	 ; 95DF DD CB 07 76	; Es animal el objeto?
	beq	e95DF			; no, sale				; 	RET Z			 ; 95E3 C8		; es cosa, salir
	bitb	#%00001000		; tiene el bit3 a 1?			; 	BIT 3, (IX+$07)		 ; 95E4 DD CB 07 5E	; Est muerto?
	bne	e95DF			; si, sale				; 	RET NZ			 ; 95E8 C0		; si, salir
	jsr	S_RewindAndSetEntry	; llama S_RewindAndSetEntry		; 	CALL S_RewindAndSetEntry ; 95E9 CD A0 9A	; llama S_RewindAndSetEntry
e95DF	rts				; retorna				; 	RET			 ; 95EC C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Devuelve Carry a 1 si est oscuro y HL apuntando a mensaje ; antes ; (#167# --)
IsItDark									; IsItDark:						;          Carry a 0 si hay visibilidad
	lda	ActionActor		; recupera ActionActor			; 	LD A, (ActionActor)	 ; 95ED 3A EA B6	; Carga ActionActor
	andcc	#%11111110		; reset carry flag			; 	AND A			 ; 95F0 A7		; Adecua flags
	bne	e_9624			; si no es 0, sale via e_9624		; 	RET NZ			 ; 95F1 C0		; Si ActionActor no es 0, Retorna con Carry = 0
	ldy	<reg_IX			; recupera reg_IX
	pshs	y			; lo guarda				; 	PUSH IX			 ; 95F2 DD E5		; Guarda IX
	ldu	<reg_BC			; recupera reg_BC
	pshs	u			; lo guarda				; 	PUSH BC			 ; 95F4 C5		; Guarda BC
	ldy	#OBJ_TABLE		; apunta a OBJ_TABLE			; 	LD IX, OBJ_TABLE	 ; 95F5 DD 21 1B C1	; Carga IX con el inicio del Objeto 0 = Bilbo (jugador)
	sty	<reg_IX			; actualiza reg_IX
	jsr	GetTopContainerID	; llama GetTopContainerID		; 	CALL GetTopContainerID	 ; 95F9 CD 7A 9E	; Llama a GetTopContainerID busca contenedor mas externo (recibido en A)
	inca				; para detectar 'no contenido' ($FF)	; 	INC A			 ; 95FC 3C		; Incrementa A. Est Bilbo contenido en otro objeto o llevado a cuestas?
										; 							; si no lo est, se recibe un $FF, que al incrementarlo pasara a cero
	bne	i_9608			; si no era $FF, salta a i_9608		; 	JR NZ, i_9608		 ; 95FD 20 09		; Si, Salta a i_9608
	jsr	GetLocPtrFromObjPtr	; llama GetLocPtrFromObjPtr		; 	CALL GetLocPtrFromObjPtr ; 95FF CD 37 9D	; llama la rutina GetLocPtrFromObjPtr
	tst	,y			; esta a 1 el bit7 de (Y+0)?		; 	BIT 7, (IX+$00)		 ; 9602 DD CB 00 7E	; Esta a 1 el bit7 del byte0 de la localizacin?
	bmi	i_9624			; si, salir				; 	JR NZ, i_9624		 ; 9606 20 1C		; Si, Salir
i_9608	ldy	<reg_IY			; recupera reg_IY			; i_9608: PUSH IY		 ; 9608 FD E5		; No, Guarda IY
	pshs	y			; lo guarda
	lda	#$0E			; cdigo objeto				; 	LD A, $0E		 ; 960A 3E 0E		; Carga A con cdigo de objeto $0e
	ldy	#L_C305			; apunta a Objeto			; 	LD IY, L_C305		 ; 960C FD 21 05 C3	; IY apunta a Objeto: $0e = sword short strong
	sty	<reg_IY			; lo guarda
	jsr	ReachesItBilbo		; llama ReachesItBilbo			; 	CALL ReachesItBilbo	 ; 9610 CD 34 9E	; Llama a ReachesItBilbo(IX=Bilbo; IY=Sword)	
	tfr	cc,b			; pasa flags a B
	puls	y			; recupera Y(IY)			; 	POP IY			 ; 9613 FD E1		; Recupera IY
	sty	<reg_IY			; lo guarda en reg_IY
	tfr	b,cc			; devolvi 0 la funcin?
	beq	i_9620			; si, salta a i_9620			; 	JR Z, i_9620		 ; 9615 28 09		; Si Sword no alcanzable, Salta a i_9620
	lda	L_C305+7		; recupera byte de flags del objeto	; 	LD A, (L_C305+$07)	 ; 9617 3A 0C C3	; accede al byte de flags del objeto $0e sword
	eora	#%11110111		; invierte todos los bits menos el 3	; 	XOR $F7			 ; 961A EE F7		; Exorea A con %11110111 (invierte todos los bits menos el 3)
	anda	#%00011100		; se queda solo con los bits2-3-4	; 	AND $1C			 ; 961C E6 1C		; AND con %00011100 (testea bits 4,3,2 = Light,Broken,Full)
	beq	i_9624			; si da 0, salta a i_9624		; 	JR Z, i_9628		 ; 961E 28 08		; Si todos son cero, Salta a i_9628
i_9620	ldx	#L_AE1F			; apunta a L_AE1F			; i_9620: LD HL, L_AE1F		 ; 9620 21 1F AE	; apunta a mensaje "it is dark" (bit4 era 0 y se invirti con el XOR o sword no accesible (?))
	orcc	#%00000001		; pone a 1 el flag de carry		; 	SCF			 ; 9623 37		; flag C = 1
i_9624	tfr	cc,b			; guarda los flags
	puls	u			; recupera U(BC)			; i_9624: POP BC		 ; 9624 C1		; Recupera BC
	stu	<reg_BC			; lo guarda en reg_BC
	puls	y			; recupera Y(IX)			; 	POP IX			 ; 9625 DD E1		; Recupera IX
	sty	<reg_IX			; lo guarda en reg_IX
	tfr	b,cc			; recupera los flags
e_9624	rts				; retorna				; 	RET			 ; 9627 C9		; Retorna
										; i_9628: AND A			 ; 9628 A7		; Adecua flags, Carry = 0
										; 	JR i_9624		 ; 9629 18 F9		; Salta a i_9624
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#191# --)
L_962B	ldx	#L_B000			; point to message			; L_962B: LD HL, L_B000		 ; 962B 21 00 B0	; apunta a menaje "You see[0x16]"
	bra	L_964D			; goto L_964D				; 	JR L_964D		 ; 962E 18 1D		; Salta a L_964D
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_9630	pshs	a,cc			; guarda registro y flags		;L_9630: PUSH AF		 ; 9630 F5		; guarda registro y flags
	jsr	GetLocPointer2IX	; obtiene puntero a Localizacin en Y	;	CALL GetLocPointer2IX	 ; 9631 CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	ldb	,y			; bit7=light, low nibble=preposicion	;	LD A, (IX+$00)		 ; 9634 DD 7E 00	; recupera la preposicin (del objeto)
	andb	#$0E			; guarda solo la preposicion		;	AND $0E			 ; 9637 E6 0E		; pone a cero el bit0 y el nibble alto (directamente mltiplo de 2)
										;	LD E, A			 ; 9639 5F		; lo pasa a E
										;	LD D, $00		 ; 963A 16 00		; byte alto a cero
	ldx	#PREP_TABLE		; apunta a tabla preposiciones		;	LD HL, PREP_TABLE	 ; 963C 21 80 BA	; apunta al inicio de la tabla de preposiciones
										;	ADD HL, DE		 ; 963F 19		; apunta al principio de la preposicin
	ldx	b,x			; toma preposicion del offset		;	LD E, (HL)		 ; 9640 5E		; toma la direccin de
										;	INC HL			 ; 9641 23		; la preposicin
										;	LD D, (HL)		 ; 9642 56		; en DE
	stx	L_AFFC+1		; pone la preposicion en el mensaje	;	LD HL, L_AFFC + $01	 ; 9643 21 FD AF	; apunta al segundo byte del mensaje L_AFFC = "You are in [0x16]", o sea a la preposicin (2 bytes)
										;	LD (HL), D		 ; 9646 72		; la  sustituye por la 
										;	INC HL			 ; 9647 23		; direccin obtenida de
										;	LD (HL), E		 ; 9648 73		; la preposicin buscada
	puls	a,cc			; recupera registro y flags		;	POP AF			 ; 9649 F1		; recupera registro y flags
	ldx	#L_AFFC			; apunta al mensaje			;	LD HL, L_AFFC		 ; 964A 21 FC AF	; apunta al mensaje "You are xxx[0x16]" siendo xxx la preposicin puesta
L_964D	ldu	<reg_IX			; guarda 				;L_964D: PUSH IX		 ; 964D DD E5		; Guarda IX
	pshs	u			; los tres
	ldu	<reg_IY			; registros 				;	PUSH IY			 ; 964F FD E5		; Guarda IY
	ldy	<reg_BC			; en el					;	PUSH BC			 ; 9651 C5		; Guarda BC
	pshs	y,u			; stack
	jsr	L_965B			; llama L_965B				;	CALL L_965B		 ; 9652 CD 5B 96	; llama rutina L_965B (#213# --)
	puls	y,u			; recupera
	sty	<reg_BC			; los tres				;	POP BC			 ; 9655 C1		; Recupera BC
	stu	<reg_IY			; registros				;	POP IY			 ; 9656 FD E1		; Recupera IY
	puls	y			; del					;	POP IX			 ; 9658 DD E1		; Recupera IX
	sty	<reg_IX			; stack
	rts				; retorna				;	RET			 ; 965A C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#213# --)
L_965B	sta	<reg_B			; guarda A en reg_B			;L_965B: LD B, A		 ; 965B 47		; Carga B con A
	jsr	GetLocPointer2IX	; obtiene puntero Localizacin en Y	;	CALL GetLocPointer2IX	 ; 965C CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	jsr	PrintMsg		; imprime menssaje			;	CALL PrintMsg		 ; 965F CD DD 72	; llama rutina PrintMsg
	ldx	8,y			; apunta a descripcin localizacion	;	LD L, (IX+$08)		 ; 9662 DD 6E 08	; recupera el puntero
										;	LD H, (IX+$09)		 ; 9665 DD 66 09	; a la primera palabra descriptiva de la localizacin
										;	LD A, H			 ; 9668 7C		; pasa byte alto a A
										;	OR L			 ; 9669 B5		; hace or con byte bajo para detectar direcciones CERO
	jsr	L_9686			; llama L_9686				;	CALL L_9686		 ; 966A CD 86 96	; llama rutina L_9686 (#214# --)
	lda	<reg_B			; recupera A de reg_B			;	LD A, B			 ; 966D 78		; Carga A con B
	jsr	L_7F78			; llama L_7F78				;	CALL L_7F78		 ; 966E CD 78 7F	; llama rutina L_7F78 (#215# --)
	lda	L_7F77			; recupera codigo localizacion		;	LD A, (L_7F77)		 ; 9671 3A 77 7F	; Carga A con (L_7F77)
	inca				; era $FF?				;	INC A			 ; 9674 3C		; Incrementa A
	beq	e965B			; si, salta la siguiente
	jsr	L_969A			; llama L_969A				;	CALL NZ, L_969A		 ; 9675 C4 9A 96	; llama rutina L_969A (#216# --)
e965B	jsr	PutEnter		; imprime Enter				;	CALL PutEnter		 ; 9678 CD 83 85	; llama rutina PutEnter
	lda	<reg_B			; recupera A de reg_B			;	LD A, B			 ; 967B 78		; Carga A con B
	jsr	L_A0C8			; llama L_A0C8				;	CALL L_A0C8		 ; 967C CD C8 A0	; llama rutina L_A0C8 (#217# --)
L_967F	lda	<reg_B			; recupera A de reg_B			;L_967F: LD A, B		 ; 967F 78		; Carga A con B
	jsr	L_A138			; llama L_A138				;	CALL L_A138		 ; 9680 CD 38 A1	; llama rutina L_A138 (#218# --)
	jmp	L_9F94			; salta a L_9F94			;	JP L_9F94		 ; 9683 C3 94 9F	; Salta a L_9F94
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#214# --)
L_9686	beq	L_9689			; si 0, salta siguiente			;L_9686: JP NZ, PrintMsg	 ; 9686 C2 DD 72	; si no es cero, salta a PrintMsg 
	jmp	PrintMsg		; imprime mensaje			;							; (#219# --)
L_9689	ldu	<reg_IY			; guarda reg_IY				;L_9689: LD DE, $0002		 ; 9689 11 02 00	; Carga DE con $0002
	pshs	u			; en el stack				;	PUSH IY			 ; 968C FD E5		; Guarda IY
	ldy	<reg_IX			; toma reg_IX				;	PUSH IX			 ; 968E DD E5		; Guarda IX
	leay	2,y			; le suma 2				;	POP IY			 ; 9690 FD E1		; Recupera IY
	sty	<reg_IY			; actualiza reg_IY			;	ADD IY, DE		 ; 9692 FD 19		; Adiciona DE en IY
	jsr	PrintDescriptionIY	; muestra descripcion			;	CALL PrintDescriptionIY	 ; 9694 CD D6 9E	; llama PrintDescriptionIY
	puls	y			; recupera				;	POP IY			 ; 9697 FD E1		; Recupera IY
	sty	<reg_IY			; reg_IY
	rts				; retorna				;	RET			 ; 9699 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#216# --)
L_969A	 									;L_969A: XOR A			 ; 969A AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	ldb	#1			; to make only one beep
	jsr	Beeps			; warns user to press a key
	jsr	i_84C2			; espera una tecla			;	IN A, ($FE)		 ; 969B DB FE		; Lee teclado (todas las filas)
										;	AND $1F			 ; 969D E6 1F		; Hace AND lgico de A con $1F
										;	CP $1F			 ; 969F FE 1F		; Compara A con $1F
					; Ver que se puede hacer !?		;	JR Z, L_969A		 ; 96A1 28 F7		; si flag Z=1, bucle atrs
					; color blanco/gris			;	LD A, $07		 ; 96A3 3E 07		; Carga A con $07
					; lo pone como color de borde		;	OUT ($FE), A		 ; 96A5 D3 FE		; el valor de A se escribe en el puerto $FE
	rts									;	RET			 ; 96A7 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_96A8	jsr	GetLocPointer2IX	; obtiene puntero a Localizacion	;L_96A8: CALL GetLocPointer2IX	 ; 96A8 CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	jsr	L_9689			; llama L_9689				;	CALL L_9689		 ; 96AB CD 89 96	; llama rutina L_9689 (#219# --)
	jsr	PutEnter		; imprime Enter				;	CALL PutEnter		 ; 96AE CD 83 85	; llama rutina PutEnter
	bra	L_967F			; salta a L_967F			;	JR L_967F		 ; 96B1 18 CC		; Salta a L_967F
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;  							; Procesa los 10 posibles casos para Bilbo ; antes ; (#96# OK) 
ProcessBilboEvents								; ProcessBilboEvents:					; estan en los bloques de 7 bytes de BilboEvents que contienen llamadas a subrutinas
	pshs	x			; save register				; 	PUSH HL			 ; 96B3 E5		; guarda HL
	ldu	<reg_IX			; get pseudo-registers
	ldy	<reg_IY								; 	PUSH IX			 ; 96B4 DD E5		; guarda IX
	pshs	y,u			; save them				; 	PUSH IY			 ; 96B6 FD E5		; guarda IY
	ldu	<reg_BC			; get pseudo-registers
	ldy	<reg_DE								; 	PUSH BC			 ; 96B8 C5		; guarda BC
	pshs	y,u			; save them 				; 	PUSH DE			 ; 96B9 D5		; guarda DE
	jsr	HasPlayerWon		; test for end of game			; 	CALL HasPlayerWon	 ; 96BA CD D6 A9	; llama rutina HasPlayerWon
	jsr	L_980E			; call L_980E				; 	CALL L_980E		 ; 96BD CD 0E 98	; llama rutina L_980E (#221# --) - solo llamada desde aqu!
	clra				; put value 0				; 	SUB A			 ; 96C0 97		; pone a 0
	sta	L_B6F0			; in L_B6F0				; 	LD (L_B6F0), A		 ; 96C1 32 F0 B6	; L_B6F0
	inca				; put value 1				; 	INC A			 ; 96C4 3C		; pone a 1
	sta	L_B6FB			; in L_B6FB				; 	LD (L_B6FB), A		 ; 96C5 32 FB B6	; L_B6FB
	sta	L_B6FA			; and in L_B6FA				; 	LD (L_B6FA), A		 ; 96C8 32 FA B6	; y L_B6FA
	ldy	#BilboEvents		; point to BilboEvents
	sty	<reg_IY			; update reg_IY				; 	LD IY, BilboEvents	 ; 96CB FD 21 84 CA	; apunta al inicio de BilboEvents
i_96CF	lda	,y			; get 1st byte				; i_96CF: LD A, (IY+$00)	 ; 96CF FD 7E 00	; recupera el primer byte (del bloque de 7 bytes)
	cmpa	#$ff			; is end of table?			; 	CP $FF			 ; 96D2 FE FF		; es $FF? (detecta final de tabla)
	beq	i_971B			; yes, exit				; 	JR Z, i_971B		 ; 96D4 28 45		; si, sale via i_971B
	lda	1,y			; get block's counter			; 	LD A, (IY+$01)		 ; 96D6 FD 7E 01	; lee contador1 de este bloque
										; 	CP $00			 ; 96D9 FE 00		; es cero?
	beq	i_9713			; if zero skip to next block		; 	JR Z, i_9713		 ; 96DB 28 36		; si, pasa al siguiente grupo de 7 bytes
	deca				; decrement counter			; 	DEC A			 ; 96DD 3D		; no, decrementa contador1
	sta	1,y			; update it				; 	LD (IY+$01), A		 ; 96DE FD 77 01	; lo guarda
										; 	CP $00			 ; 96E1 FE 00		; es cero ahora?
	bne	i_96FE			; if not zero go to 2nd part		; 	JR NZ, i_96FE		 ; 96E3 20 19		; no, pasa a la segunda parte del bloque
	lda	L_B6F0			; get L_B6F0				; 	LD A, (L_B6F0)		 ; 96E5 3A F0 B6	; si, recupera valor de L_B6F0
	sta	1,y			; update counter			; 	CP $01			 ; 96E8 FE 01		; es igual a 1?
	cmpa	#1			; has value 1?				; 	LD (IY+$01), A		 ; 96EA FD 77 01	; guarda valor de L_B6F0 en contador1
	beq	i_96FE			; yes, go to 2nd part			; 	JR Z, i_96FE		 ; 96ED 28 0F		; si L_B6F0 era 1, pasa a la segunda parte del bloque
	inca				; increment counter			; 	INC A			 ; 96EF 3C		; incrementa contador de L_B6F0
	sta	L_B6F0			; update L_B6F0				; 	LD (L_B6F0), A		 ; 96F0 32 F0 B6	; lo guarda
	ldx	2,y			; get 1st routine address		; 	LD L, (IY+$02)		 ; 96F3 FD 6E 02	; carga HL
										; 	LD H, (IY+$03)		 ; 96F6 FD 66 03	; con direccin de la primera rutina
	jsr	CallSubrutineHL		; call it				; 	CALL CallSubrutineHL	 ; 96F9 CD 6C 9B	; llama CallSubrutineHL
	bra	i_9713			; go to next block			; 	JR i_9713		 ; 96FC 18 15		; pasa al siguiente grupo de 7 bytes
i_96FE	lda	4,y			; get 2nd part counter			; i_96FE: LD A, (IY+$04)	 ; 96FE FD 7E 04	; lee contador2
										; 	CP $00			 ; 9701 FE 00		; es cero?
	beq	i_9713			; if zero goto next block		; 	JR Z, i_9713		 ; 9703 28 0E		, si, pasa al siguiente grupo de 7 bytes
	cmpa	1,y			; compare to first counter		; 	CP (IY+$01)		 ; 9705 FD BE 01	; no, lo compara con contador1
	bcs	i_9713			; if 1st counter > goto next block	; 	JR C, i_9713		 ; 9708 38 09		; si contador1 > contador2, pasa al siguiente grupo de 7 bytes
	ldx	5,y			; get 2nd routine address		; 	LD L, (IY+$05)		 ; 970A FD 6E 05	; sino, carga HL
										; 	LD H, (IY+$06)		 ; 970D FD 66 06	; con direccin de la segunda rutina
	jsr	CallSubrutineHL		; call it				; 	CALL CallSubrutineHL	 ; 9710 CD 6C 9B	; llama CallSubrutineHL
i_9713	leay	7,y			; point to next block			; i_9713: LD DE, $0007		 ; 9713 11 07 00	; offset 7 (grupos de 7 bytes)
	sty	<reg_IY			; update reg_IY				; 	ADD IY, DE		 ; 9716 FD 19		; apunta al siguiente grupo de 7 bytes
	bra	i_96CF			; go process new block			; 	JP i_96CF		 ; 9718 C3 CF 96	; vuelve para procesar el nuevo grupo
i_971B	lda	#1			; put value 1				; i_971B: LD A, $01		 ; 971B 3E 01		; pone 1
	sta	L_B702			; in L_B702				; 	LD (L_B702), A		 ; 971D 32 02 B7	; en L_B702
	puls 	y,u			; restore
	sty	<reg_DE			; two pseudo-registers			; 	POP DE			 ; 9720 D1		; recupera DE
	stu	<reg_BC								; 	POP BC			 ; 9721 C1		; recupera BC
	puls	y,u			; restore
	sty	<reg_IY			; two more				; 	POP IY			 ; 9722 FD E1		; recuepra IY
	stu	<reg_IX								; 	POP IX			 ; 9724 DD E1		; recupera IX
	puls	x,pc			; restore x and return			; 	POP HL			 ; 9726 E1		; recupera HL
										; 	RET			 ; 9727 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; mira si otro PNJ tiene el objeto e imprime mensaje indicndolo - antes ; (#209# --)
										; 							; en este caso devuelve Z=0, si est disponible para Bilbo devuelve Z=1
OwnsObjAnotherPNJ								; OwnsObjAnotherPNJ:					; parametro A: cdigo de objeto
	cmpa	#$FF			; es A = $FF?				; 	CP $FF			 ; 9728 FE FF		; es objeto nulo?
	beq	e9776			; si, sale				; 	RET Z			 ; 972A C8		; si, salir
	ldu	<reg_IX			; recupera reg_IX
	pshs	u			; guarda U(IX)				; 	PUSH IX			 ; 972B DD E5		; Guarda IX
	ldu	<reg_IY			; recupera reg_IY
	ldy	<reg_BC			; recupera reg_BC			; 	PUSH IY			 ; 972D FD E5		; Guarda IY
	pshs	u,y			; guarda U(IY),Y(BC)			; 	PUSH BC			 ; 972F C5		; Guarda BC
	sta	<reg_B			; guarda A en reg_B			; 	LD B, A			 ; 9730 47		; guarda cdigo Objeto en B
	lda	ActionActor		; recupera ActionActor			; 	LD A, (ActionActor)	 ; 9731 3A EA B6	; Carga ActionActor
										; 	CP $00			 ; 9734 FE 00		; es $00 (Bilbo)?
	beq	i_973B			; si es 0, salta a i_973B		; 	JR Z, i_973B		 ; 9736 28 03		; si, sigue en i_973B
	clra				; toma valor 0, flag Z=1		; 	XOR A			 ; 9738 AF		; no, A = 0, flag Z=1
	bra	i_9776			; salta a i_9776			; 	JR i_9776		 ; 9739 18 3B		; sale via i_9776
i_973B	lda	<reg_B			; recupera A de reg_B			; i_973B: LD A, B		 ; 973B 78		; recupera cdigo de Objeto
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX	 ; 973C CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	lda	1,y			; recupera 'contenedor'			; 	LD A, (IX+$01)		 ; 973F DD 7E 01	; recupera indicador de "contenido en"
	cmpa	#$FF			; es $FF?				; 	CP $FF			 ; 9742 FE FF		; es $FF (sin contenedor)?
	beq	i_9776			; si, salta a i_9776			; 	JR Z, i_9776		 ; 9744 28 30		; si, sale via i_9776 con Z=1
	lda	<reg_B			; recupera A de reg_B			; 	LD A, B			 ; 9746 78		; recupera cdigo de Objeto
										; 	PUSH IX			 ; 9747 DD E5		; pasa puntero al objeto
	sty	<reg_IY			; pasa reg_IX a reg_IY			; 	POP IY			 ; 9749 FD E1		; a IY
	jsr	OwnsActorObject		; llama OwnsActorObject			; 	CALL OwnsActorObject	 ; 974B CD 7B 9C	; llama OwnsActorObject (devuelve en A cdigo de contenedor si existe)
	bcs	i_9776			; si devuelve carry, salta a i_9776	; 	JR C, i_9776		 ; 974E 38 26		; Si C = 1, sale via i_9776
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX	 ; 9750 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto contenedor en IX
	ldb	7,y			; recupera status byte
	bitb	#%01000000		; tiene el bit6 a 1?			; 	BIT 6, (IX+$07)		 ; 9753 DD CB 07 76	; es animal el objeto?
	beq	i_9776			; no, salta a i_9776			; 	JR Z, i_9776		 ; 9757 28 1D		; no, sale via i_9776 con Z=1
										; 							; es un personaje distinto de Bilbo
	lda	L_C11B+7		; recupera status byte de Bilbo		; 	LD A, (L_C11B+$07)	 ; 9759 3A 22 C1	; apunta al byte 7 (flags) del objeto $00 - Bilbo
	bpl	i_9776			; si el bit7 esta a 0, salta a i_9776	; 	BIT 7, A		 ; 975C CB 7F		; Es visible Bilbo?
	ldu	<reg_IY			; recupera reg_IY			; 	JR Z, i_9776		 ; 975E 28 16		; no, sale via i_9776 con Z=1
	ldx	8,u			; toma 2 bytes de (U+8)			; 	LD L, (IY+$08)		 ; 9760 FD 6E 08	; Carga L con (IY+$08)
										; 	LD H, (IY+$09)		 ; 9763 FD 66 09	; Carga H con (IY+$09), HL apunta a sustantivo descriptor Objeto (parmetro)
	pshs	x			; pasa X(HL) al stack			; 	PUSH HL			 ; 9766 E5		; pasa HL como parmetro al stack
	ldx	8,y			; toma 2 bytes de (Y+8)			; 	LD L, (IX+$08)		 ; 9767 DD 6E 08	; Carga L con (IX+$08)
										; 	LD H, (IX+$09)		 ; 976A DD 66 09	; Carga H con (IX+$09), HL apunta a sustantivo descriptor Contenedor
	pshs	x			; pasa X(HL) al stack			; 	PUSH HL			 ; 976D E5		; pasa HL como parmetro al stack
	ldx	#L_AFE4			; apunta a L_AFE4			; 	LD HL, L_AFE4		 ; 976E 21 E4 AF	; apunta a mensaje "[0x04] is carrying[0x04][0x15]"
	jsr	PrintMsg		; llama PrintMsg			; 	CALL PrintMsg		 ; 9771 CD DD 72	; llama rutina PrintMsg (parmetros los dos HL enviados al stack)
	ora	#1			; fuerza bit0 a 1, flag Z=0		; 	OR $01			 ; 9774 F6 01		; Hace OR lgico de A con $01, flag Z=0
i_9776	tfr	cc,b			; guarda flags en B						
	puls	y,u			; recupera Y(BC),U(IY)					
	sty	<reg_BC			; actualiza reg_BC			; i_9776: POP BC		 ; 9776 C1		; Recupera BC
	stu	<reg_IY			; actualiza reg_IY			; 	POP IY			 ; 9777 FD E1		; Recupera IY
	puls	u			; recupera U(IX)			; 	POP IX			 ; 9779 DD E1		; Recupera IX
	stu	<reg_IX			; actualiza reg_IX
	tfr	b,cc			; recupera flags de B
e9776	rts				; retorna				; 	RET			 ; 977B C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_977C	lda	MainObject		; get main object			; L_977C: LD A, (MainObject)	 ; 977C 3A E8 B6	; Carga cdigo objeto principal
ProcessDeadObject								; ProcessDeadObject:					; proceso de objetos rotos/muertos ; (#197# --)
	tsta				; needed when entering here		; 	AND A			 ; 977F A7		; es Bilbo el objeto muerto/roto?
	lbeq	BilboIsDeadEndGame	; if it is Bilbo, end the game		; 	JP Z, BilboIsDeadEndGame ; 9780 CA D2 90	; si, salta a BilboIsDeadEndGame
	ldu	<reg_BC			; get pseudoreg
	pshs	u			; save it				; 	PUSH BC			 ; 9783 C5		; Guarda BC
	ldu	<reg_IY			; get pseudoregs
	ldy	<reg_IX								; 	PUSH IY			 ; 9784 FD E5		; Guarda IY
	pshs	y,u			; save them				; 	PUSH IX			 ; 9786 DD E5		; Guarda IX
	sta	<reg_C			; save ID in reg_C			; 	LD C, A			 ; 9788 4F		; guarda A
	jsr	GetObjPointer2IX	; get object pointer (mods regA)	; 	CALL GetObjPointer2IX	 ; 9789 CD CA 9B	; llama GetObjPointer2IX
	ldb	7,y			; get flags
	orb	#%00001000		; set it as dead			; 	SET 3, (IX+$07)		 ; 978C DD CB 07 DE	; Pasa a 1 el bit3 en (IX+$07), lo marca como muerto (o roto)
	stb	7,y			; update flags
	jsr	AnalyzeObjContents	; see its contents (owned objects)	; 	CALL AnalyzeObjContents	 ; 9790 CD 53 9D	; llama AnalyzeObjContents
	lda	<reg_C			; restore received ID			; 	LD A, C			 ; 9793 79		; recupera A
	jsr	S_GetPNJEntry		; set HL_dir entry			; 	CALL S_GetPNJEntry	 ; 9794 CD 85 9A	; llama S_GetPNJEntry
	cmpa	#$ff			; is end of dirs?			; 	CP $FF			 ; 9797 FE FF		; fin de directorio?
	tfr	cc,b			; save flags
	lda	<reg_C			; get received ID			; 	LD A, C			 ; 9799 79		; recupera A
	tfr	b,cc			; restore flags
	beq	i_97A0			; if end of dirs skip two		; 	JR Z, i_97A0		 ; 979A 28 04		; si era fin de directorio, salta a i_97A0
	ldy	<reg_IY			; get pointer
	clr	,y			; set object as NO accesible		; 	LD (IY+$00), $00	 ; 979C FD 36 00 00	; 0 localizaciones equivale a muerto/roto
i_97A0	jsr	UpdateDeadObject	; process its 'death'			; i_97A0: CALL UpdateDeadObject	 ; 97A0 CD 8C A1	; llama UpdateDeadObject
	lda	<reg_C			; get received ID			; 	LD A, C			 ; 97A3 79		; recupera A
	jsr	FreeActorEntries	; free entries in 8x25			; 	CALL FreeActorEntries	 ; 97A4 CD 60 7F	; llama FreeActorEntries
	puls	y,u			; restore registers			; 	POP IX			 ; 97A7 DD E1		; Recupera IX
	sty	<reg_IX			; update them
	stu	<reg_IY								; 	POP IY			 ; 97A9 FD E1		; Recupera IY
	puls	u			; retore regiser
	stu	<reg_BC			; update it				; 	POP BC			 ; 97AB C1		; Recupera BC
	rts				; return				; 	RET			 ; 97AC C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Parte de la inicializacin de partida		      (#86# OK) ;
; Resultado: Bloquea una salida de una Localizacin y elige una frase x Gollum	;
;            y modifica cdigo de la rutina (#253#)				;
;   Utiliza: A, B, X(HL), Y(IY)							;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_97AD	clra				; pone 0				; L_97AD: SUB A			 ; 97AD 97		; Pone a 0
	sta	ActionActor		; en actionActor			; 	LD (ActionActor), A	 ; 97AE 32 EA B6	; ActionActor
	sta	L_B6F1			; en L_B6F1				; 	LD (L_B6F1), A		 ; 97B1 32 F1 B6	; L_B6F1
	sta	L_B6F9			; y en L_B6F9				; 	LD (L_B6F9), A		 ; 97B4 32 F9 B6	; y L_B6F9
	ldx	#OBJ_TABLE		; apunta a OBJ_TABLE			; 	LD HL, OBJ_TABLE	 ; 97B7 21 1B C1	; apunta a Objeto Bilbo (jugador)
	stx	ObjectPointer		; guarda direccin en ObjectPointer	; 	LD (ObjectPointer), HL	 ; 97BA 22 0C B7	; Guarda esta direccin de Bilbo en ObjectPointer
	lda	#4			; valor mximo aleatorio = 4		; 	LD A, $04		 ; 97BD 3E 04		; valor mximo = 4
	jsr	GetPosRandom		; genera una cifra aleatoria (0-4)	; 	CALL GetPosRandom	 ; 97BF CD 9F 9C	; llama rutina GetPosRandom (retorna en A de 0 a 4 y Carry a 1 si sali negativo)
	inca				; ahora ser (1-5)			; 	INC A			 ; 97C2 3C		; incrementa A (ahora entre 1 y 5)
										; 	LD B, A			 ; 97C3 47		; Guarda A en B
	ldy	#L_C80E-6		; apunta a zona salidas bloqueables	; 	LD IY, L_C80E-$06	 ; 97C4 FD 21 08 C8	; apunta 6 bytes antes del inicio de "Datos en Bloques de 6 bytes"
i_97CB	leay	6,y			; incrementa en 6			; 	LD DE, $0006		 ; 97C8 11 06 00	; numero de bytes x bloque
	deca				; decrementa contador (num aleatorio)	; i_97CB: ADD IY, DE		 ; 97CB FD 19		; salta al siguiente inicio de bloque (siempre empieza en L_C80E que es el Bloque001)
	bne	i_97CB			; si no es cero, vuelve atrs		; 	DJNZ i_97CB		 ; 97CD 10 FC		; hasta que B no sea cero sigue pasando a otro bloque (si era 1 ya se queda aqu)
	sty	D_A7CF+2		; pone Y en el cdigo de (#253#)	; 	LD (D_A7CF+$02), IY	 ; 97CF FD 22 D1 A7	; ($A7D1-D2) = IY, modifica cdigo en (#253#)
										; 							; para insertar la direccin desde donde se deben tomar los datos
										; 	LD L, (IY+$01)		 ; 97D3 FD 6E 01	; carga en HL la direccin contenida en offsets 1-2 del grupo de 6 apuntado
	ldx	1,y			; recupera direccin del bloque		; 	LD H, (IY+$02)		 ; 97D6 FD 66 02	; que es la 'salida' que va a ser bloqueada a continuacin
	ldd	#$0003			; cero y numero de bytes a borrar	; 	LD B, $03		 ; 97D9 06 03		; para pasar a cero los 3 bytes siguientes a la direccin recuperada
i_97DB	sta	,x+			; borra 1 byte e incrementa puntero	; i_97DB: LD (HL), $00		 ; 97DB 36 00		; coloca un 0 en la direccin recien tomada de la tabla
	decb				; decrementa contador			; 	INC HL			 ; 97DD 23		; incrementa puntero
	bne	i_97DB			; si no es cero sigue			; 	DJNZ i_97DB		 ; 97DE 10 FB		; Decrementa contador B y si no es cero sigue poniendo ceros
	lda	#3			; valor mximo aleatorio = 3		; 	LD A, $03		 ; 97E0 3E 03		; valor mximo = 3
	jsr	GetPosRandom		; genera una cifra aleatoria (0-4)	; 	CALL GetPosRandom	 ; 97E2 CD 9F 9C	; llama rutina GetPosRandom (retorna en A de 0 a 3 y Carry a 1 si sali negativo)
	tfr	a,b			; guarda la cifra en B			; 	LD E, A			 ; 97E5 5F		; guarda random en E (0 - 3)
	clra				; byte alto a 0				; 	LD D, $00		 ; 97E6 16 00		; byte alto a 0, ahora DE = offset (aleatorio) entre $0000 y $0003
	aslb				; multiplica D (AB)			; 	SLA E			 ; 97E8 CB 23		; se multiplica por 4
	aslb				; por 4					; 	SLA E			 ; 97EA CB 23		; ya que cada bloque es de 4 bytes. Nuevo offset entre $0000 y $000C
	ldx	#L_C7FC			; apunta a frases Gollum		; 	LD HL, L_C7FC		 ; 97EC 21 FC C7	; apunta a inicio bloque de frases de Gollum (4 bloques de 4 bytes)
	leax	d,x			; le suma el offset aleatorio		; 	ADD HL, DE		 ; 97EF 19		; aade el offset al bloque (elegido aleatoriamente)
	stx	GollumMsgPtr		; guarda puntero calculado		; 	LD (GollumMsgPtr), HL	 ; 97F0 22 EE B6	; guarda la direccin inicial del mensaje elegido al azar en GollumMsgPtr
	rts				; retorna				; 	RET			 ; 97F3 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_97F4	jsr	PrintMsg		; show message				; L_97F4: CALL PrintMsg		 ; 97F4 CD DD 72	; llama rutina PrintMsg 
	lda	#$2e			; get char '.'				; 	LD A, $2E		 ; 97F7 3E 2E		; cdigo ASCII de '.'
	jsr	PutChar			; print it				; 	CALL PutChar		 ; 97F9 CD 8B 85	; llama rutina PutChar 
	lbra	PutEnter		; print CR				; 	JP PutEnter		 ; 97FC C3 83 85	; salta a PutEnter
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
BreakIfB6faAndfbZero								; BreakIfB6faAndfbZero:					; Aborta rutina que le llam si L_B6FA-FB contienen cero	; antes ; (#237# OK)
										; 	PUSH BC			 ; 97FF C5		; guarda registro BC
	lda	L_B6FA			; get first byte			; 	LD BC, (L_B6FA)		 ; 9800 ED 4B FA B6	; recupera BC de L_B6FA-FB
	anda	L_B6FB			; both must be zero!			; 	LD A, C			 ; 9804 79		; pasa byte BAjo a A
					; to avoid exiting subroutine		; 	AND B			 ; 9805 A0		; es nulo BC?
	bne	i_9809			; if not zero, exit			; 	JR NZ, i_9809		 ; 9806 20 01		; no, salta la siguiente (no toca el stack)
	leas	2,s			; get rid of last return address	; 	POP BC          	 ; 9808 C1      	; elimina direccin de retorno
i_9809	rts				; return				; i_9809: POP BC          	 ; 9809 C1      	; recupera BC
										; 	RET			 ; 980A C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Ejecuta scripts (#221# --)
										;ProcessAllPendingCommands				; va recorriendo los personajes y ejecutando las acciones necesarias para cada uno.
L_980E	jsr	Action_None		; call no_action			; L_980E: CALL Action_None	 ; 980E CD 02 9B	; llama Action_None
	ldy	#HighLevel_Dirs		; point to HighLevelDirs
	sty	<reg_IY			; update reg_IY				; 	LD IY, HighLevel_Dirs	 ; 9811 FD 21 CB CA	; IY apunta HighLevel_Dirs
i_9815	clra				; put value zero			; i_9815: XOR A			 ; 9815 AF		; pone a 0
	sta	S_ActionsCounter	; in actionsCounter			; 	LD (S_ActionsCounter), A ; 9816 32 0B 98	; S_ActionsCounter
	lda	,y			; get actor ID				; 	LD A, (IY+$00)		 ; 9819 FD 7E 00	; recupera ID de personaje del directorio
	cmpa	#$ff			; is end of table?			; 	CP $FF			 ; 981C FE FF		; es fin de tabla?
	lbeq	i_9909			; yes, exit				; 	JP Z, i_9909		 ; 981E CA 09 99	; si, sale via L_9909
	tsta				; is it disabled?			; 	CP $00			 ; 9821 FE 00		; es 0 el ID? (implica deshabilitado)
	lbeq	GetNextActor		; yes, getnextactor			; 	JP Z, GetNextActor	 ; 9823 CA 01 99	; si, pasa a GetNextActor
	sta	ActionActor		; save actor ID				; 	LD (ActionActor), A	 ; 9826 32 EA B6	; guarda personaje en L_B6EA
	jsr	GetObjectLocation	; get location of actor			; 	CALL GetObjectLocation	 ; 9829 CD 82 9F	; llama GetObjectLocation recibe cdigo Localizacin en A
	ldu	<reg_IX			; get objPointer
	stu	ObjectPointer		; update variable			; 	LD (ObjectPointer), IX	 ; 982C DD 22 0C B7	; guarda puntero al Objeto-Personaje en ObjectPointer
	sta	ObjectLocation		; save ID location object		; 	LD (ObjectLocation), A	 ; 9830 32 F6 B6	; guarda ID Localizacin del objeto en ObjectLocation
	clra				; put value 0				; 	SUB A			 ; 9833 97		; pone a 0
	sta	L_B702			; in L_B702				; 	LD (L_B702), A		 ; 9834 32 02 B7	; L_B702
	ldy	<reg_IY
	lda	,y			; get actor ID				; 	LD A, (IY+$00)		 ; 9837 FD 7E 00	; recupera ID del personaje
	pshs	y			; save pointer to HLevelDirs		; 	PUSH IY			 ; 983A FD E5		; Guarda IY (puntero al registro en HighLevel_Dirs)
										; 				 			; Cuando Bilbo est en la misma loc que el personaje y si no hemos entrado nunca en el 'si interno', se pone L_B702=1. 
										; 				 			; No se entra en el 'si interno' hasta que alguien no ponga S_LightDark a 1. Luego se entra slo una vez, para imprimir "You hear a noise".
										; 				 			; cuando se entra se pone L_B702=0 y S_LightDark a 2, con lo que no vuelve a entrar en el si externo hasta que alguien lo ponga a algo 
										; 				 			; distinto de 2, S_LightDark se pone a 0 (no est oscuro) o a 1 (est oscuro) en ActionNone. No se modifica en otro sitio (aparentemente)
										; 				 			; Parece que si un personaje hace algo y est en la localizacion de Bilbo y est Oscuro, imprime "You hear a noise"
										; 							; llama a 9e25 con IX=Entrada del Personaje en la tabla de objetos
	ldy	#OBJ_TABLE		; point to Objects table		; 							; 9e25 Intercambia IX e IY y llama a ObjectsSameLoc. Z=0 si estan en la misma localizacin
	sty	<reg_IY			; update reg_IY				; 	LD IY, OBJ_TABLE    	 ; 983C FD 21 1B C1   	; apunta a OBJ_TABLE (Entrada 0 es Bilbo)
	jsr	L_9E25			; call L_9E25 (same Loc?)		; 	CALL L_9E25       	 ; 9840 CD 25 9E   	; llama rutina L_9E25 (#161# --)
	tfr	cc,b			; save flags
	puls	y			; get HLevelDir pointer			; 							; Ahora IX apunta a OBJ_TABLE (con la inversin que hizo SwapIXwithIY)
	sty	<reg_IY			; update reg_IY				; 	POP IY          	 ; 9843 FD E1      	; Recupera IY (apunta a la entrada del directorio de scripts en curso)
	tfr	b,cc			; restore flags
	beq	i_9868			; if not in same Loc. go i_9868		; 	JR Z, i_9868       	 ; 9845 28 21      	; si no estn en la misma Localizacin, salta a i_9868
	lda	S_LightDark		; get dark flag				; 	LD A, (S_LightDark)    	 ; 9847 3A 0C 98   	; recupera S_LightDark
	cmpa	#2			; already noticed?			; 	CP $02          	 ; 984A FE 02      	; es $02?
	beq	i_9868			; yes goto i_9868			; 	JR Z, i_9868       	 ; 984C 28 1A      	; si, Salta a i_9868
										; 							; Estn en la misma localizacin
	lda	#1			; put value 1				; 	LD A, $01       	 ; 984E 3E 01      	; pone 1
	sta	L_B702			; in L_B702				; 	LD (L_B702), A       	 ; 9850 32 02 B7   	; en L_B702
										; 							; Si *S_LightDark==1 (Est oscuro, puesto en ActionNone) entonces
	lda	S_LightDark		; get dark flag				; 	LD A, (S_LightDark)    	 ; 9853 3A 0C 98   	; recupera S_LightDark
	cmpa	#1			; is it dark?				; 	CP $01          	 ; 9856 FE 01      	; es 1 (est oscuro)?
	bne	i_9868			; no, it was 0 (light) go i_9868	; 	JR NZ, i_9868       	 ; 9858 20 0E      	; no, salta a i_9868
	inca				; it was 1, pass to 2			; 	INC A			 ; 985A 3C		; si, lo pasa a 2
	sta	S_LightDark		; update flag				; 	LD (S_LightDark), A	 ; 985B 32 0C 98	; y lo guarda en S_LightDark
	ldx	#L_B027			; point to message			; 	LD HL, L_B027		 ; 985E 21 27 B0	; apunta a mensaje "you{5} hear a noise"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 9861 CD DD 72	; llama rutina PrintMsg
	clra				; put value zero			; 	SUB A			 ; 9864 97		; pone a 0
	sta	L_B702			; in L_B702				; 	LD (L_B702), A		 ; 9865 32 02 B7	; L_B702
										; 							; Si Bilbo est contenido en otro objeto Salta a L_9b16
i_9868	lda	#$ff			; get value for no container 		; i_9868: LD A, $FF       	 ; 9868 3E FF      	; Carga A con $FF
	ldy	<reg_IX			; get reg_IX							
	cmpa	1,y			; is Bilbo in 'no' container?		; 	CP (IX+$01)       	 ; 986A DD BE 01   	; es $FF el contenedor de Bilbo (ninguno)?
	lbne	L_9B16			; no, process container			; 	JP NZ, L_9B16       	 ; 986D C2 16 9B   	; no, salta a L_9B16 (est dentro de otro objeto)
										; 							; Bilbo no est contenido en otro objeto
L_9870	ldy	ObjectPointer		; get objPointer			; L_9870: LD IX, (ObjectPointer) ; 9870 DD 2A 0C B7   	; recupera ObjectPointer
	sty	<reg_IX			; update reg_IX
	jsr	FindActorIn8x25		; search actor in commands blocks	; 	CALL FindActorIn8x25   	 ; 9874 CD 10 7F   	; llama FindActorIn8x25. Retorna Z=1 si lo encuentra, Z=0 sino.
	tfr	cc,b			; save flags
	clra				; set value to zero			; 	LD A, $00       	 ; 9877 3E 00      	; A=0 (resultado para no encontrado)
	tfr	b,cc			; restore flags
	bne	i_987C			; if not found, skip next		; 	JR NZ, i_987C       	 ; 9879 20 01   	; si no encontrado, salta la siguiente instruccin
	inca				; set value to 1			; 	INC A          		 ; 987B 3C      	; A=1 (resultado para si encontrado)
i_987C	sta	FoundIn8x25		; update flag				; i_987C: LD (FoundIn8x25), A    ; 987C 32 F4 B6 	; guarda FoundIn8x25
										; 							; Toma bytes 2-3 (WORD1) de entrada en HighLevel_Dirs que procesamos como un puntero
L_987F	ldy	<reg_IY			; get HLevelDirs pointer		; L_987F: LD L, (IY+$02)       	 ; 987F FD 6E 02   	; Carga byte bajo
	ldx	2,y			; get 1st word (2 bytes)		; 	LD H, (IY+$03)       	 ; 9882 FD 66 03   	; Carga byte alto. HL = Word1
										; 							; si *980b==6 salta a obtener siguiente personaje (se pone a 0 al inicio de esta rutina
										; 							; y se incrementa en S_ExtraJump dentro de S_DoActionFullCall que procesa comandos DoAction y Call)
L_9885	lda	S_ActionsCounter	; get consecutive actionsCounter	; L_9885: LD A, (S_ActionsCounter); 9885 3A 0B 98   	; recupera S_ActionsCounter
	cmpa	#6			; is it 6?				; 	CP $06          	 ; 9888 FE 06      	; es $06?
	lbeq	GetNextActor		; yes, goto next actor			; 	JR Z, GetNextActor     	 ; 988A 28 75      	; si, pasa a GetNextActor
	lda	,x			; get a byte				; 	LD A, (HL)		 ; 988C 7E		; recupera byte apuntado por el puntero guardado en Word2-3
	ldu	#$0004			; put value 4
	stu	<reg_DE			; in reg_DE				; 	LD DE, $0004		 ; 988D 11 04 00	; Carga DE con $0004
										; 	PUSH HL			 ; 9890 E5		; pasa HL
	stx	<reg_IX			; pass X(HL) to reg_IX			; 	POP IX			 ; 9891 DD E1		; a IX (Word2-3)
										; 							; Analizamos el comando del script (que est en A)
										; 							; Si (A & 0xf <= 5)
	anda	#$0f			; use 4 lower bits			; 	AND $0F          	 ; 9893 E6 0F      	; se queda con los 4 bits bajos del byte recin ledo
	cmpa	#5			; is >= 5?				; 	CP $05          	 ; 9895 FE 05      	; es mayor o igual a 5?
	bcc	i_98CB			; yes,  go process commands		; 	JR NC, i_98CB       	 ; 9897 30 32      	; si, Salta a i_98CB (proceso de comandos >=5)
										; 							; TRATAMIENTO COMANDOS 0-1-2-3-4
	lda	FoundIn8x25		; get flag				; 	LD A, (FoundIn8x25)    	; 9899 3A F4 B6   	; recupera FoundIn8x25
	cmpa	#1			; found it?				; 	CP $01          	; 989C FE 01      	; es 1 (encontrado)?
	bne	i_98BF			; no,go i_98BF				; 	JR NZ, i_98BF       	; 989E 20 1F      	; no, salta a i_98BF
										; 							; el bit 6 del comando indica si la accin tiene prioridad 
										; 							; sobre las del rea de 8x25 (hay varios comandos $4x en los scripts) 
										; 							; Si est a 0 y el personaje tiene entrada en 8x25, se intenta procesar dicha entrada 
	ldb	,x			; get command				; 							; a travs de L_7f1a. Si est a 1 se salta a L_98bf para procesar el comando normalmente
	bitb	#%01000000		; has bit6 set?				; 	BIT 6, (HL)       	; 98A0 CB 76      	; Est a 1 el bit 6 del comando a ejecutar?
	bne	i_98BF			; yes, go i_98BF			; 	JR NZ, i_98BF       	; 98A2 20 1B      	; si, salta a i_98BF
	clra				; set flag				; 	SUB A          		; 98A4 97      		; pone 0
	sta	FoundIn8x25		; to not found				; 	LD (FoundIn8x25), A    	; 98A5 32 F4 B6   	; en FoundIn8x25
	inca				; set value 1				; 	INC A          		; 98A8 3C      		; A=1 ID de personaje a buscar en bloque 8x25 UserTokenizedCommands
	jsr	L_7F1A			; in L_7F1A				; 	CALL L_7F1A       	; 98A9 CD 1A 7F   	; llama rutina L_7F1A (#224# --)
										; 							; si dicho proceso se ha podido realizar, se pasa al siguiente personaje. 
										; 							; Si no, se salta a L_98BF que procesa los comandos del 0 al 4 de los scripts 
										; 							; con HL apuntando al segundo byte de la entrada en 8x25 en algunos casos
										; 							; en otros al valor que tena, es decir, a la entrada del script 
										; 							; En dichas entradas puede haer tanto comandos normales como comandos de scripts de tipo ACCION o JUMP. 
	beq	i_98BF			; if Z=1 returned, go i_98BF		; 	JR Z, i_98BF       	; 98AC 28 11      	; si devuelve Z=1, salta a i_98BF (con HL apuntando al bloque de 25 hallado)
	lda	#1			; put value 1				; 	LD A, $01       	; 98AE 3E 01      	; pone 1 
	sta	L_B6FA			; in L_B6FA				; 	LD (L_B6FA), A       	; 98B0 32 FA B6   	; en L_B6FA
	sta	L_B6FB			; and L_B6FB				; 	LD (L_B6FB), A       	; 98B3 32 FB B6   	; y en L_B6FB
	ldx	#GetNextActor		; point to GetNextActor			; 	LD HL, GetNextActor    	; 98B6 21 01 99   	; apunta a GetNextActor (bsqueda siguiente personaje en el directorio de alto nivel)
	pshs	x			; pass to stack				; 	PUSH HL          	; 98B9 E5      		; guarda HL (para ser usada como Direccin de Retorno)
	ldy	<reg_IX			; get reg_IX
	pshs	y			; pass to stack				; 	PUSH IX          	; 98BA DD E5      	; guarda IX (apunta al script a ejecutar para este personaje)
	lbra	L_99CE			; go L_99CE				; 	JP L_99CE       	; 98BC C3 CE 99   	; Salta a L_99CE
										; 							; Si comando <4 salta a S_DoActionFullCall (Determina, dentro, mirando el bit 0 si hay que ejecutar 
										; 							;   una accin o saltar a una rutina) es decir, comandos DoAction y JP. 
										; 							;   Parece que no existe comando con cdigo 1
										; 							; Sino, es >4 (y esto es IMPOSIBLE!) No hace nada y salta a siguiente entrada Se usa esto?
i_98BF	lda	,x			; get command				; i_98BF: LD A, (HL)       	; 98BF 7E      		; recupera comando
	anda	#$0f			; save lower 4 bits			; 	AND $0F          	; 98C0 E6 0F      	; guarda 4 bits bajos
	cmpa	#4			; is it 4?				; 	CP $04          	; 98C2 FE 04      	; Compara A con $04
	lbeq	S_DoAction		; yes, doAction				; 	JP Z, S_DoAction       	; 98C4 CA 74 99   	; si es igual a 4, salta a S_DoAction
	bcs	S_DoActionFullCall	; if <= doAction and CallFunction	; 	JR C, S_DoActionFullCall ; 98C7 38 5F      	; si A est entre 0 y 4, Salta a S_DoActionFullCall
	bra	GetNextActor		; else getNextActor			; 	JR GetNextActor       	; 98C9 18 36      	; si es mayor que 4, salta a GetNextActor
										; 							; NUNCA debera pasar esto. Por si acaso ira a 'buscar siguiente personaje' en dir. alto nivel.
										; 							; Aqu traemos A=nibble bajo de la accin del script, IX=Direccin del script ejecutndose
										; 							; IY es el puntero al registro de HighLevels_Dir en curso
i_98CB										; i_98CB:							; TRATAMIENTO COMANDOS >= 5
	cmpa	#$0e			; was command Jump?			; 	CP $0E          	; 98CB FE 0E      	; es $0E (comando jump (JP))?
	bne	i_98DD			; no, go next command			; 	JR NZ, i_98DD       	; 98CD 20 0E      	; no, salta a i_98DD, siguiente comparacin
	ldu	<reg_IX			; point to script in use		; 	LD E, (IX+$01)       	; 98CF DD 5E 01   	; guarda la direccin del script en ejecucin
	ldy	<reg_IY			; point to actor directory		; 	LD (IY+$02), E       	; 98D2 FD 73 02   	; en la entrada E01 del directorio del personaje
	ldd	1,u			; get script address			; 	LD E, (IX+$02)       	; 98D5 DD 5E 02   	; ...
	std	2,y			; put in actor directory		; 	LD (IY+$03), E       	; 98D8 FD 73 03   	; ...
	bra	L_987F			; go L_987F				; 	JR L_987F       	; 98DB 18 A2      	; vuelve a L_987F y procesa el comando
										; 							; Llamamos a S_RewindAndSetEntry con B=(IX+1) accin y A=(IY) (Personaje)
										; 							; busca en HighLevel_Dirs la entrada del personaje (en reg A)
										; 							; Luego busca en su directorio una entrada del tipo pasado en B y la graba en Word1
i_98DD	cmpa	#$0c			; was command rewind and setEntry?	; i_98DD: CP $0C          	; 98DD FE 0C      	; es $0C (comando REWIND_AND_SET_ENTRY)?
	bne	i_98EC			; no, goto next command			; 	JR NZ, i_98EC       	; 98DF 20 0B      	; no, salta a i_98EC, siguiente comparacin
	ldu	<reg_IX			; get reg_IX
	ldb	1,u			; get action parameter
	stb	<reg_B			; save in reg_B				; 	LD B, (IX+$01)       	; 98E1 DD 46 01   	; recupera parmetro para accin $0C
	ldy	<reg_IY			; point to HLevelDirs
	lda	,y			; get actor ID				; 	LD A, (IY+$00)       	; 98E4 FD 7E 00   	; recupera ID del personaje de HighLevel_Dirs
	jsr	S_RewindAndSetEntry	; call requested command		; 	CALL S_RewindAndSetEntry ; 98E7 CD A0 9A   	; llama S_RewindAndSetEntry
	bra	L_987F			; go L_987F				; 	JR L_987F       	; 98EA 18 93      	; vuelve a L_987F y procesa el comando
										; 							; Salta a una entrada aleatoria del directorio
										; 							; Llamamos a 9a59 elige una rutina aleatoriamente
i_98EC	cmpa	#$0f			; was command JumpRandom?		; i_98EC: CP $0F          	; 98EC FE 0F      	; es $0F (Comando JUMP_RANDOM)?
	bne	i_98F5			; no, go  i_98F5			; 	JR NZ, i_98F5       	; 98EE 20 05      	; no, salta a i_98F5, siguiente comparacin
	jsr	S_JumpRandom		; call req. command			; 	CALL S_JumpRandom      	; 98F0 CD 59 9A   	; llama S_JumpRandom
	lbra	L_987F			; go L_987F				; 	JR L_987F       	; 98F3 18 8A      	; vuelve a L_987F y procesa el comando
										; 							; si es 0 ... Si aqu SOLO llegan cuando A>=5, Qu pinta el CERO?
										; 							; Sumamos DE a HL. HL+=4 y saltamos a 9885. Dnde apunta con +=4? Al inicio de su directorio?
										; 							; sera como ir al primer comando del directorio ...
										; 							; Es 987f, pero con HL ya cargado
i_98F5	tsta				; was zero?				; i_98F5: CP $00          	; 98F5 FE 00      	; es $00?
	bne	i_98FC			; no, go i_98FC				; 	JR NZ, i_98FC       	; 98F7 20 03      	; no, salta a i_98FC
	ldd	<reg_DE			; get reg_DE
	leax	d,x			; add to X(HL)				; 	ADD HL, DE       	; 98F9 19      		; suma DE en HL
	lbra	L_9885			; go L_9885				; 	JR L_9885       	; 98FA 18 89      	; Salta a L_9885 y procesa el comando
										; 							; Si no es ninguno de los anteriores
										; 							; A=E=0; Llamar a 9a68 Resetea a su entrada inicial indicada en el HighLevel_Dirs
										; 							; que no siempre es la primera de su propio directorio ...
i_98FC	clra				; put value 0				; i_98FC: SUB A          	; 98FC 97      		; A=0
	sta	<reg_E			; in reg_E				; 	LD E, A          	; 98FD 5F      		; E=0
	jsr	S_ResetToE		; call command				; 	CALL S_ResetToE       	; 98FE CD 68 9A   	; llama S_ResetToE. Actualiza Word1 pero no hace nada mas
GetNextActor									; GetNextActor:						; Obtener siguiente personaje en el directorio de alto nivel
	ldy	<reg_IY			; get HLevelDirs pointer		; 	LD DE, $0007       	; 9901 11 07 00   	; longitud del registro
	leay	7,y			; point to next register		; 	ADD IY, DE       	; 9904 FD 19      	; IY apunta al siguiente
	sty	<reg_IY			; update reg_IY
	lbra	i_9815			; go i_9815				; 	JP i_9815       	; 9906 C3 15 98   	; vuelve al principio a procesarlo
i_9909	clra				; put value zero			; i_9909: SUB A          	; 9909 97      		; pone a 0
	sta	ActionActor		; in ActionActor			; 	LD (ActionActor), A     ; 990A 32 EA B6   	; ActionActor
	inca				; put value 1				; 	INC A          		; 990D 3C      		; Pone a 1
	sta	L_B702			; in L_B702				; 	LD (L_B702), A       	; 990E 32 02 B7   	; L_B702
	ldx	#OBJ_TABLE		; get ObjTable address			; 	LD HL, OBJ_TABLE    	; 9911 21 1B C1   	; guarda puntero a Bilbo
	stx	ObjectPointer		; save as ObjectPointer			; 	LD (ObjectPointer), HL 	; 9914 22 0C B7   	; en ObjectPointer
	rts				; return				; 	RET          		; 9917 C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Auxiliar que pone en WORD1 la siguiente instruccin del script ; antes ; (#227# --)
										; 							; Los bytes a saltar vienen en DE (4 si viene de S_DoActionFullCall  2 si viene de S_DoAction)
										; 							; OJO! Los directorios son estructuras de 3 bytes, no hay nada de 4 bytes  de 2
										; 							; Qu se supone que hace esta suma en realidad?
S_SetNextStep									; S_SetNextStep:						; Si la actual tiene el bit 4 a 1 contempla que tiene un parmetro extra.
	ldd	<reg_DE			; get reg_DE				; 	ADD HL, DE       	; 9918 19      		; Aade DE en HL
	leax	d,x			; add to X(HL)				; 
	ldy	<reg_IX			; get reg_IX				; 							; Si el bit 4 de la instruccin est a 1   
	ldb	,y			; get action (command)			; 	BIT 4, (IX+$00)       	; 9919 DD CB 00 66   	; Est a 1 el bit 4 del comando?
	bitb	#%00010000		; is bit4 set (extra parameter)?	; 	JR Z, i_9921       	; 991D 28 02      	; no, se salta correcin del puntero
	beq	i_9921			; no, go i_9221				; 
										; 	INC HL          	; 991F 23      		; Incrementa HL en 2 
	leax	2,x			; skip that extra parameter		; 	INC HL          	; 9920 23      		; para saltar el parmetro adicional (direccin de salto)
										; 
										; 							; Carga en Word1 la direccin siguiente a ejecutar en el script
i_9921	ldu	<reg_IY			; get reg_IY				; i_9921: LD (IY+$02), L      	; 9921 FD 75 02   	; Carga (IY+$02) con L
	stx	2,u			; update pointer			; 	LD (IY+$03), H       	; 9924 FD 74 03   	; Carga (IY+$03) con H
	rts				; return				; 	RET          		; 9927 C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Funcin que implementa los comandos de script DoAction (2) y Call (3)
S_DoActionFullCall								; S_DoActionFullCall:					; Se llega slo si el comando es 1, 2  3 (y se puede colar el CERO)
	jsr	S_SetNextStep		; setNextStep				; 	CALL S_SetNextStep     	; 9928 CD 18 99   	; llama S_SetNextStep. Pone siguiente instruccin en WORD1 
	ldy	<reg_IX			; get reg_IX				; 
	ldb	,y			; get action (command)			; 							; Si la instruccin actual tiene el bit 0 a 0 entonces
	bitb	#%00000001		; has bit0 set?				; 	BIT 0, (IX+$00)       	; 992B DD CB 00 46   	; Est a 1 el bit 0 de (IX+$00)?
	bne	i_994A			; yes, go i_994A			; 	JR NZ, i_994A       	; 992F 20 19      	; no, Salta a i_994A
										; 
										; 							; Es un comando 2, ponemos las variables y llamamos a ExecuteAction (99c6)
	lda	1,y			; put action to do			; 	LD A, (IX+$01)       	; 9931 DD 7E 01   	; pone primer parmetro
	sta	CurrentAction		; in currentAction			; 	LD (CurrentAction), A   ; 9934 32 E7 B6   	; como ID de accin
	lda	2,y			; put object				; 	LD A, (IX+$02)       	; 9937 DD 7E 02   	; pone segundo parmetro
	sta	MainObject		; in mainObject				; 	LD (MainObject), A    	; 993A 32 E8 B6   	; como objeto principal
	lda	3,y			; put 2nd object			; 	LD A, (IX+$03)       	; 993D DD 7E 03   	; pone tercer parmetro
	sta	SecondObject		; in secondObject			; 	LD (SecondObject), A    ; 9940 32 E9 B6   	; como objeto secundario
	jsr	L_99C6			; call L_99C6				; 	CALL L_99C6       	; 9943 CD C6 99   	; llama rutina L_99C6 (#228# --) ExecuteAction
										; 
	beq	S_ExtraJump		; if returns Z=1, do extraJump		; 	JR Z, S_ExtraJump      	; 9946 28 62      	; si devuelve Z=1, va a S_ExtraJump a comprobar si hay salto extra (bit 4 a 1 en comando)
	bra	i_9967			; go i_9967				; 	JR i_9967       	; 9948 18 1D      	; si devuelve cero, salta a i_9967
										; 
i_994A										; i_994A: 						; Llegamos aqu si la instruccin actual es 1 o 3 (Call)
	ldy	<reg_IX			; get reg_IX				; 	LD L, (IX+$01)       	; 994A DD 6E 01   	; byte bajo en L
	ldx	1,y			; get routine to be called		; 	LD H, (IX+$02)       	; 994D DD 66 02   	; byte alto en H - HL = puntero a la rutina a llamar
	clra				; put value zero			; 	SUB A          		; 9950 97      		; pone a 0
	sta	L_B6FA			; in L_B6FA				; 	LD (L_B6FA), A       	; 9951 32 FA B6   	; L_B6FA
	sta	L_B6FB			; and L_B6FB				; 	LD (L_B6FB), A       	; 9954 32 FB B6   	; y L_B6FB
	jsr	CallSubrutineHL		; execute subroutine			; 	CALL CallSubrutineHL    ; 9957 CD 6C 9B   	; llama CallSubrutineHL
										; 
	lda	L_B6FB			; get L_B6FB				; 	LD A, (L_B6FB)       	; 995A 3A FB B6   	; recupera L_B6FB
	cmpa	#1			; is it 1?				; 	CP $01          	; 995D FE 01      	; es $01?
	bne	S_ExtraJump		; no, do extraJump			; 	JR NZ, S_ExtraJump     	; 995F 20 49      	; no, Salta a S_ExtraJump a comprobar si hay salto extra (bit 4 a 1 en comando)
	sta	L_B6FA			; copy to L_B6FA			; 	LD (L_B6FA), A       	; 9961 32 FA B6   	; pone a 1 L_B6FA
	jsr	CallSubrutineHL		; execute subroutine			; 	CALL CallSubrutineHL    ; 9964 CD 6C 9B   	; llama de nuevo CallSubrutineHL
										; 
i_9967										; i_9967: 						; Comn para los comandos (1-2-3)
	ldy	<reg_IX			; get reg_IX				; 							; Si el bit 5 del comando est a 1 (es un RunOnce)
	ldb	,y			; get action (command)			; 							; se pone a 0 el cdigo de instruccin para no volver a ejecutarla.
	bitb	#%00100000		; is bit5 set (run once)?		; 	BIT 5, (IX+$00)       	; 9967 DD CB 00 6E   	; Est a 1 el bit 5 del comando?
	beq	GetNextActor		; no, go nextActor			; 	JP Z, GetNextActor     	; 996B CA 01 99   	; no, salta a GetNextActor
	clr	,y			; clear action				; 	LD (IX+$00), $00    	; 996E DD 36 00 00   	; deshabilita el comando ponindolo a cero
	bra	GetNextActor		; go nextActor				; 	JR GetNextActor       	; 9972 18 8D      	; Salta a GetNextActor
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Rutina que implementa el comando 4 (DoAction sin parmetros)
										; 							; Prepara WORD1 con la siguiente instruccin a ejecutar 
S_DoAction									; S_DoAction:						; dos bytes ms adelante, si no tenemos el bit 4 a 1 (entonces seran 4)
	ldu	#$0002			; put value 2
	stu	<reg_DE			; in reg_DE				; 	LD DE, $0002       	; 9974 11 02 00   	; Carga DE con $0002
	jsr	S_SetNextStep		; call set next script step		; 	CALL S_SetNextStep     	; 9977 CD 18 99   	; llama S_SetNextStep
	ldy	<reg_IX			; get reg_IX				; 
	lda	1,y			; get action				; 	LD A, (IX+$01)       	; 997A DD 7E 01   	; recupera la accin a ejecutar
	cmpa	#$ff			; is it none?				; 	CP $FF          	; 997D FE FF      	; es $FF (ninguna)?
	beq	i_9994			; yes, go i_9994			; 	JR Z, i_9994       	; 997F 28 13      	; si, salta a i_9994
										; 
	sta	CurrentAction		; save action				; 	LD (CurrentAction), A   ; 9981 32 E7 B6   	; guarda ID de accin
	lda	#$ff			; put no object				; 	LD A, $FF       	; 9984 3E FF      	; pone $FF (valor nulo)
	sta	MainObject		; in mainObject				; 	LD (MainObject), A    	; 9986 32 E8 B6   	; en objeto principal
	sta	SecondObject		; and secondaryObject			; 	LD (SecondObject), A    ; 9989 32 E9 B6   	; y en objeto secundario
										; 
	jsr	L_99C6			; call L_99C6				; 	CALL L_99C6       	; 998C CD C6 99   	; llama rutina L_99C6 (#228# --)
	beq	S_ExtraJump		; if returns Z=1, go extrajump		; 	JR Z, S_ExtraJump      	; 998F 28 19      	; Si devuelve Z=1, salta a S_ExtraJump
	lbra	GetNextActor		; go nextActor				; 	JP GetNextActor       	; 9991 C3 01 99   	; Salta a GetNextActor
										; 							; la accin era $FF, no hacemos nada, pero si tiene opcin de salto, la tratamos
										; 							; Comprobamos el bit 4, si no es cero, ponemos en WORD1 al parmetro
										; 							; No se hace a travs de S_ExtraJump porque 980b no se incrementa en este caso ni se 
										; 							; contina procesando el script actual
i_9994	ldy	<reg_IX			; get reg_IX				; i_9994: BIT 4, (IX+$00)       ; 9994 DD CB 00 66   	; Est a 1 el bit 4 del comando (exige salto)?
	ldb	,y			; get action (command)						
	bitb	#%00010000		; is bit4 set (needs jump)?							
	lbeq	GetNextActor		; no, go nextActor			; 	JP Z, GetNextActor     	; 9998 CA 01 99   	; no, salta a GetNextActor
	ldx	2,y			; get next address			; 	LD L, (IX+$02)       	; 999B DD 6E 02   	; Carga byte bajo
										; 	LD H, (IX+$03)       	; 999E DD 66 03   	; Carga byte alto. Nueva direccin en HL
	ldy	<reg_IY			; get reg_IY				; 	LD (IY+$02), L       	; 99A1 FD 75 02   	; la pasa al Word1
	stx	2,y			; update address 			; 	LD (IY+$03), H       	; 99A4 FD 74 03   	; del directorio de alto nivel del personaje
	lbra	GetNextActor		; go nextActor				; 	JP GetNextActor       	; 99A7 C3 01 99   	; Salta a GetNextActor
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Auxiliar que comprueba si hay salto extra en una instruccin para ponerlo en WORD1
										; 							; y continuar ejecutando este script desde ese punto.
										; 							; Adems incrementa 980b (aunque no haya salto). Si llega a 6 la rutina principal #221#
S_ExtraJump									; S_ExtraJump:						; para la ejecucin de este script y pasa al del siguiente personaje
	ldx	#S_ActionsCounter	; point to counter			; 	LD HL, S_ActionsCounter	; 99AA 21 0B 98   	; apunta a S_ActionsCounter
	inc	,x			; increment it				; 	INC (HL)       		; 99AD 34      		; lo incrementa
										; 
	ldy	<reg_IX			; get reg_IX 				; 							; Si el bit 4 de la instruccin es 0 salta a 987f 
	ldb	,y			; get action (command)			; 							; que procesa la siguiente instruccin de este script
	bitb	#%00010000		; is bit4 set?				; 	BIT 4, (IX+$00)       	; 99AE DD CB 00 66   	; Est a 1 el bit 4 del comando?
	lbeq	L_987F			; no, go L_987F				; 	JP Z, L_987F       	; 99B2 CA 7F 98   	; no, salta a L_987F
										; 
										; 							; Si est a 1 pone el parmetro extra en WORD1 y salta a 9885, que es igual que 987f, pero 
	ldd	<reg_DE			; get reg_DE 				; 							; se ahorra poner el registro HL, porque ya viene cargado a WORD1
	leay	d,y			; add to reg_IX				; 	ADD IX, DE       	; 99B5 DD 19      	; suma DE en IX, para 'saltar' el comando
	sty	<reg_IX			; update reg_IX
	ldx	,y			; get new address			; 	LD H, (IX+$01)       	; 99B7 DD 66 01   	; carga byte alto
										; 	LD L, (IX+$00)       	; 99BA DD 6E 00   	; Carga byte bajo. Nueva direccin en HL
	ldu	<reg_IY			; get reg_IY				; 	LD (IY+$02), L       	; 99BD FD 75 02   	; lo pasa al Word1
	stx	2,u			; put new address in HLevelDir		; 	LD (IY+$03), H       	; 99C0 FD 74 03   	; del directorio de alto nivel del personaje
	lbra	L_9885			; go L_9885				; 	JP L_9885       	; 99C3 C3 85 98   	; Salta a L_9885
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#228# --)
L_99C6	ldu	<reg_IX			; get pseudo-register			; L_99C6: PUSH IX		 ; 99C6 DD E5		; Guarda IX
	pshs	u			; save it
	jsr	L_7AF5			; call L_7AF5				; 	CALL L_7AF5		 ; 99C8 CD F5 7A	; llama rutina L_7AF5 (#229# --)
	lbeq	i_9A56			; if returned Z=1, go i_9A56		; 	JP Z, i_9A56		 ; 99CB CA 56 9A	; Si Z = 1, Salta a i_9A56
L_99CE	lda	IsMainObjLoc		; get flag				; L_99CE: LD A, (IsMainObjLoc)	 ; 99CE 3A FE B6	; recupera IsMainObjLoc
	cmpa	#1			; is it a location?			; 	CP $01			 ; 99D1 FE 01		; Compara A con $01
	beq	i_9A32			; yes, go i_9A32			; 	JR Z, i_9A32		 ; 99D3 28 5D		; Si Z = 1, Salta a i_9A32
	lda	CurrentAction		; get action				; 	LD A, (CurrentAction)	 ; 99D5 3A E7 B6	; Carga ID de accin
	cmpa	#$1e			; is it $1E?				; 	CP $1E			 ; 99D8 FE 1E		; Compara A con $1E
	bne	i_99E5			; no, go i_99E5				; 	JR NZ, i_99E5		 ; 99DA 20 09		; Si Z = 0, Salta a i_99E5
	lda	ObjectLocation		; get objLocation			; 	LD A, (ObjectLocation)	 ; 99DC 3A F6 B6	; recupera ObjectLocation
	ldx	#L_C11B+16		; point to Bilbo location		; 	LD HL, L_C11B + $10	 ; 99DF 21 2B C1	; HL apunta a la localizacin del objeto $00 - Bilbo
	cmpa	,x			; is the same?				; 	CP (HL)			 ; 99E2 BE		; Compara A con (HL)
	bne	i_9A32			; no, go i_9A32				; 	JR NZ, i_9A32		 ; 99E3 20 4D		; Si Z = 0, Salta a i_9A32
i_99E5	lda	MainObject		; get main object			; i_99E5: LD A, (MainObject)	 ; 99E5 3A E8 B6	; Carga cdigo objeto principal
	cmpa	#$ff			; any main object?			; 	CP $FF			 ; 99E8 FE FF		; Compara A con $FF
	beq	i_9A2B			; no, go i_9A2B				; 	JR Z, i_9A2B		 ; 99EA 28 3F		; Si Z = 1, Salta a i_9A2B
	jsr	GetObjectLocation	; get ObjLocation			; 	CALL GetObjectLocation	 ; 99EC CD 82 9F	; llama GetObjectLocation
	sta	S_MainObjLocCpy		; save it				; 	LD (S_MainObjLocCpy), A	 ; 99EF 32 0D 98	; la guarda en S_MainObjLocCpy
	cmpa	#$ff			; any ObjLocation?			; 	CP $FF			 ; 99F2 FE FF		; Compara A con $FF
	bne	i_9A2B			; yes, go i_9A2B			; 	JR NZ, i_9A2B		 ; 99F4 20 35		; Si Z = 0, Salta a i_9A2B
	ldd	BilboLocation		; b gets ObjectLocation			; 	LD BC, (BilboLocation)	 ; 99F6 ED 4B F5 B6	; recupera BilboLocation y ObjectLocation
	std	<reg_BC			; pass data ro reg_BC			; 	LD A, C			 ; 99FA 79		; Carga A con C
	cmpa	ObjectLocation		; is Bilbo at the ObjLocation?		; 	CP B			 ; 99FB B8		; Compara A con B
	beq	i_9A2B			; yes, go i_9A2B			; 	JR Z, i_9A2B		 ; 99FC 28 2D		; Si Z = 1, Salta a i_9A2B
	ldy	<reg_IX			; get reg_IX
	ldb	,y			; get number of possible locations	; 	LD B, (IX+$00)		 ; 99FE DD 46 00	; Carga B con (IX+$00)
i_9A01	cmpa	16,y			; is Bilbo at this one?			; i_9A01: CP (IX+$10)		 ; 9A01 DD BE 10	; Compara A con (IX+$10)
	beq	i_9A0C			; yes, go i_9A0C			; 	JR Z, i_9A0C		 ; 9A04 28 06		; Si Z = 1, Salta a i_9A0C
	leay	1,y			; to point to next possible location	; 	INC IX			 ; 9A06 DD 23		; Incrementa IX
	sty	<reg_IX			; update reg_IY
	decb				; decrement counter
	bne	i_9A01			; not yet done, loopback		; 	DJNZ i_9A01		 ; 9A08 10 F7		; Decrementa B y si no es cero vuelve a i_9A01
	andcc	#%11111011		; force Z=0
	bra	i_9A2B			; go i_9A2B				; 	JR i_9A2B		 ; 9A0A 18 1F		; Salta a i_9A2B
i_9A0C	lda	ActionActor		; get actor				; i_9A0C: LD A, (ActionActor)	 ; 9A0C 3A EA B6	; Carga ActionActor
	sta	<reg_B			; pass to reg_B				; 	LD B, A			 ; 9A0F 47		; Carga B con A
	lda	#$ff			; get value for no actor		; 	LD A, $FF		 ; 9A10 3E FF		; Carga A con $FF
	sta	ActionActor		; update variable			; 	LD (ActionActor), A	 ; 9A12 32 EA B6	; guarda ActionActor
	lda	#1			; put value 1				; 	LD A, $01		 ; 9A15 3E 01		; Carga A con $01
	sta	L_B702			; in L_B702				; 	LD (L_B702), A		 ; 9A17 32 02 B7	; Carga (L_B702) con A
	ldy	<reg_IY			; get pseudo-register			; 	PUSH IY			 ; 9A1A FD E5		; Guarda IY
	pshs	y			; pass onto stack
	jsr	DescribeActionOnScreen	; show action description		; 	CALL DescribeActionOnScreen
										; 				 ; 9A1C CD 2B 71	; llama DescribeActionOnScreen
	puls	y			; restore reg_IY			; 	POP IY			 ; 9A1F FD E1		; Recupera IY
	sty	<reg_IY			; update it
	clra				; put value zero			; 	SUB A			 ; 9A21 97		; Resta A de A
	sta	L_B702			; to L_B702				; 	LD (L_B702), A		 ; 9A22 32 02 B7	; Carga (L_B702) con A
	lda	<reg_B			; get saved actor			; 	LD A, B			 ; 9A25 78		; Carga A con B
	sta	ActionActor		; update variable			; 	LD (ActionActor), A	 ; 9A26 32 EA B6	; guarda ActionActor
	bra	i_9A32			; go i_9A32				; 	JR i_9A32		 ; 9A29 18 07		; Salta a i_9A32
i_9A2B	ldy	<reg_IY			; get pseudo-register			; i_9A2B: PUSH IY		 ; 9A2B FD E5		; Guarda IY
	pshs	y			; save it
	jsr	DescribeActionOnScreen	; show action description		; 	CALL DescribeActionOnScreen
	puls	y			; restore reg_IY			; 				 ; 9A2D CD 2B 71	; llama DescribeActionOnScreen
	sty	<reg_IY			; update it				; 	POP IY			 ; 9A30 FD E1		; Recupera IY
i_9A32	jsr	ExecuteAction		; execute action			; i_9A32: CALL ExecuteAction	 ; 9A32 CD 0F 95	; llama ExecuteAction
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; 9A35 3A EA B6	; Carga ActionActor
	ldx	#ObjectLocation		; point to ObjLocation			; 	LD HL, ObjectLocation	 ; 9A38 21 F6 B6	; apunta a ObjectLocation
	ldu	#L_B017			; point to message 
	stu	<reg_DE			; pass to reg_DE			; 	LD DE, L_B017		 ; 9A3B 11 17 B0	; apunta a mensaje "[0x00] enter(s|d|ing|es).[0x14]"
	jsr	L_9ACD			; call L_9ACD				; 	CALL L_9ACD		 ; 9A3E CD CD 9A	; llama rutina L_9ACD (#230# --)
	lda	IsMainObjLoc		; get flag				; 	LD A, (IsMainObjLoc)	 ; 9A41 3A FE B6	; recupera IsMainObjLoc
	cmpa	#1			; is it a location?			; 	CP $01			 ; 9A44 FE 01		; Compara A con $01
	beq	i_9A54			; yes, go i_9A54			; 	JR Z, i_9A54		 ; 9A46 28 0C		; Si Z = 1, Salta a i_9A54
	lda	MainObject		; get mainObject			; 	LD A, (MainObject)	 ; 9A48 3A E8 B6	; Carga cdigo objeto principal
	ldx	#S_MainObjLocCpy	; point to copy of location		; 	LD HL, S_MainObjLocCpy	 ; 9A4B 21 0D 98	; apunta a S_MainObjLocCpy
	ldu	#L_B01C			; point to message
	stu	<reg_DE			; pass to reg_DE			; 	LD DE, L_B01C		 ; 9A4E 11 1C B0	; apunta a mensaje "[0x00] appear(s|d|ing|es)[0x15]"
	jsr	L_9ACD			; call L_9ACD				; 	CALL L_9ACD		 ; 9A51 CD CD 9A	; llama rutina L_9ACD (#230# --)
i_9A54	ora	#1			; set Z=0				; i_9A54: OR $01		 ; 9A54 F6 01		; Hace OR lgico de A con $01
i_9A56	puls	y			; restore reg_IX			; i_9A56: POP IX		 ; 9A56 DD E1		; Recupera IX
	pshs	cc			; save flags
	sty	<reg_IX			; update it
	puls	cc,pc			; restore flags and return		; 	RET			 ; 9A58 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Rutina que implementa el comando de script JumpRandom comando 15 (0xf) ; antes ; (#225# --)
										; 							; Prepara un aleatorio adecuado y sigue la ejecucin en la rutina 226
S_JumpRandom									; S_JumpRandom:						; A=min(parametro, tamao de directorio)
	ldy	<reg_IX			; get reg_IX
	lda	1,y			; get 1st param				; 	LD A, (IX+$01)       	; 9A59 DD 7E 01   	; Carga A con parametro
	ldy	<reg_IY			; get reg_IY
	cmpa	1,y			; is regA lower than directory size?	; 	CP (IY+$01)       	; 9A5C FD BE 01   	; Compara A con tamao del directorio
	bcs	i_9A64			; yes, go i_9A64			; 	JR C, i_9A64       	; 9A5F 38 03      	; Si parametro < tamao directorio, salta a i_9A64
	lda	1,y			; get directory size			; 	LD A, (IY+$01)       	; 9A61 FD 7E 01   	; Carga A con tamao directorio
i_9A64	jsr	GetPosRandom		; get a random number			; i_9A64: CALL GetPosRandom    	; 9A64 CD 9F 9C   	; llama GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	sta	<reg_E			; save it in reg_E			; 	LD E, A          	; 9A67 5F      		; guarda A en E
										; 							; Esta rutina implementa la activacin de un script del directorio del personaje actual ; antes ; (#226# --)
										; 							; Se pasa en E el Nmero de entrada a la que se salta.
										; 							; Se llama cuando el comando es >4 pero no se reconoce
S_ResetToE									; S_ResetToE:						; A=min(E,tamao de directorio)
	ldy	<reg_IY			; get reg_IY
	lda	1,y			; get directory size			; 	LD A, (IY+$01)       	; 9A68 FD 7E 01   	; Carga A con tamao del directorio
	cmpa	<reg_E			; compare to random generated one	; 	CP E          		; 9A6B BB      		; lo compara con E
	bcc	i_9A6F			; is lower or same, go i_9A6F		; 	JR NC, i_9A6F       	; 9A6C 30 01      	; Si tamao directorio >= E, Salta a i_9A6F
	sta	<reg_E			; update reg_E	(lowest value)		; 	LD E, A          	; 9A6E 5F      		; pasa tamao directorio a E
										; 							; Tomamos WORD2 (direccin del directorio) en HL y avanzamos E entradas: HL+=E*3
i_9A6F					  					; i_9A6F: LD L, (IY+$04)       	; 9A6F FD 6E 04   	; Carga byte bajo
	ldx	4,y			; get actor directory address		; 	LD H, (IY+$05)       	; 9A72 FD 66 05   	; Carga byte alto. HL apunta a inicio del directorio del personaje
	clra				; high byte zero			; 	LD D, $00       	; 9A75 16 00      	; byte alto = 0
	ldb	<reg_E			; now regD is reg_DE
	leax	d,x			; add DE to X(HL)			; 	ADD HL, DE       	; 9A77 19      		; suma DE
	leax	d,x			; add DE to X(HL)			; 	ADD HL, DE       	; 9A78 19      		; tres veces 
	leax	d,x			; add DE to X(HL)			; 	ADD HL, DE       	; 9A79 19      		; para avanzar E entradas
	leax	1,x			; increment pointer			; 	INC HL          	; 9A7A 23      		; Incrementa HL para apuntar al puntero al script de esa entrada
										; 							; Tomamos la direccin y la ponemos en WORD1
	ldu	,x+			; get script pointer			; 	LD E, (HL)       	; 9A7B 5E      		; Carga byte bajo
	stu	<reg_DE			; update reg_DE				; 	INC HL          	; 9A7C 23      		; Incrementa HL
										; 	LD D, (HL)       	; 9A7D 56      		; Carga byte alto. HL = direccin script a ejecutar
	stu	2,y			; put in its hLevelDir			; 	LD (IY+$02), E       	; 9A7E FD 73 02   	; lo pasa al Word1
										; 	LD (IY+$03), D       	; 9A81 FD 72 03   	; del directorio de alto nivel del personaje
	rts				; return				; 	RET          		; 9A84 C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Auxiliar que toma la entrada en HighLevel_Dirs para un personaje determinado pasado en A ; antes ; (#194# --)
S_GetPNJEntry									; S_GetPNJEntry:					; Devuelve A=$ff si no lo encuentra, A=Personaje si lo encuentra.
					; no se usan				; 	PUSH DE          	; 9A85 D5      		; Guarda DE
										; 	PUSH BC          	; 9A86 C5      		; Guarda BC
										; 							; Buscamos en HighLevel_Dirs la entrada para el personaje pasado en A
	pshs 	a			; guarda A en el stack			; 	LD B, A          	; 9A87 47      		; guarda A
	ldx	#HighLevel_Dirs		; apunta a HighLevel_Dirs		; 	LD HL, HighLevel_Dirs   ; 9A88 21 CB CA   	; HL apunta a HighLevel_Dirs
										; 	LD DE, $0007       	; 9A8B 11 07 00   	; offset entre bloques
i_9A8E	lda	,x			; toma byte apuntado por X(HL)		; i_9A8E: LD A, (HL)       	; 9A8E 7E      		; recupera ID de personaje
	cmpa	,s			; es igual a valor A recibido?		; 	CP B          		; 9A8F B8      		; es el solicitado?
	beq	i_9A9A			; si, sale via i_9A9A			; 	JR Z, i_9A9A       	; 9A90 28 08      	; si, Salta a i_9A9A
	cmpa	#$FF			; es $FF?				; 	CP $FF          	; 9A92 FE FF      	; es $FF (fin de directorio)?
	beq	i_9A9A			; si, sale via i_9A9A			; 	JR Z, i_9A9A       	; 9A94 28 04      	; si, salta a i_9A9A
	leax	7,x			; suma 7 a X(HL)			; 	ADD HL, DE       	; 9A96 19      		; suma DE en HL, pasa al siguiente personaje del directorio de alto nivel
	bra	i_9A8E			; vuelve a i_9A8E			; 	JP i_9A8E       	; 9A97 C3 8E 9A   	; vuelve a i_9A8E
										; 							; O bien lo encontramos, A=Personaje, o bien no, A=$ff
i_9A9A	puls	b			; recupera A del stack			; i_9A9A: POP BC          	; 9A9A C1      		; Recupera BC
					; no se utilizaron			; 	POP DE          	; 9A9B D1      		; Recupera DE
	stx	<reg_IY			; guarda X(HL) en reg_IY		; 	PUSH HL          	; 9A9C E5      		; pasa HL
										; 	POP IY          	; 9A9D FD E1      	; a IY
	rts				; retorna				; 	RET          		; 9A9F C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Rutina que implementa el comando REWIND_AND_SET_ENTRY (comando 12 o 0x0c) ; antes ; (#212# --)
										; 							; En B viene el parmetro y en A el cdigo del personaje
S_RewindAndSetEntry								; S_RewindAndSetEntry:					; El parmetro es el tipo de entrada del directorio (3 bytes <tipo><puntero>)
	ldu	<reg_IY			; recupera reg_IY			; 	PUSH IY          	; 9AA0 FD E5      	; Guarda IY
	ldy	<reg_IX			; recupera reg_IX			; 	PUSH IX          	; 9AA2 DD E5      	; Guarda IX
	pshs	u,y			; guarda U(IY),Y(IX)			; 
	jsr	S_GetPNJEntry		; llama S_GetPNJEntry			; 	CALL S_GetPNJEntry     	; 9AA4 CD 85 9A   	; llama S_GetPNJEntry
										; 
	cmpa	#$FF			; devolvi $FF?				; 	CP $FF          	; 9AA7 FE FF      	; lleg a final de directorio?
	beq	i_9AC8			; si, salta a i_9AC8			; 	JR Z, i_9AC8       	; 9AA9 28 1D      	; si, sale via i_9AC8
										; 
	ldu	<reg_IY			; recupera reg_IY			; 	LD L, (IY+$04)       	; 9AAB FD 6E 04   	; Carga byte bajo de Word2
	ldx	4,u			; toma 2 bytes de (U+4)			; 	LD H, (IY+$05)       	; 9AAE FD 66 05   	; Carga byte alto. HL apunta a inicio directorio del personaje
										; 	PUSH HL          	; 9AB1 E5      		; lo pasa
	stx	<reg_IX			; actualiza reg_IX			; 	POP IX          	; 9AB2 DD E1      	; a IX
	lda	<reg_B			; pasa B a A				; 	LD A, B          	; 9AB4 78      		; pasa parmetro (B) a registro A
	jsr	FindPointer		; llama FindPointer			; 	CALL FindPointer    	; 9AB5 CD BD 9D   	; busca puntero con cdigo A e inicio tabla en IX
										; 
										; 							; Si no lo encontramos salimos
	cmpa	#$FF			; devolvi $FF?				; 	CP $FF          	; 9AB8 FE FF      	; lleg a final de tabla?
	beq	i_9AC8			; si, sale via i_9AC8			; 	JR Z, i_9AC8       	; 9ABA 28 0C      	; si, sale via i_9AC8
										; 
										; 							; Si lo encontramos guardamos el puntero en WORD1
	ldu	<reg_IX			; recupera reg_IX			; 	LD L, (IX+$01)       	; 9ABC DD 6E 01   	; Carga byte bajo direccin apuntada por esta entrada
	ldx	1,u			; toma 2 bytes de (U+1)			; 	LD H, (IX+$02)       	; 9ABF DD 66 02   	; Carga byte alto. HL apunta proximo script a ejecutar
	ldu	<reg_IY			; recupera reg_IY			; 	LD (IY+$02), L       	; 9AC2 FD 75 02   	; lo pasa a Word1
	stx	2,u			; guarda los 2 bytes en (U+2)		; 	LD (IY+$03), H       	; 9AC5 FD 74 03   	; del directorio de alto nivel del personaje
i_9AC8	puls	y,u			; recupera Y(IX),U(IY)			; i_9AC8: POP IX          	; 9AC8 DD E1      	; Recupera IX
	sty	<reg_IX			; actualiza reg_IX
	stu	<reg_IY			; actualiza reg_IY			; 	POP IY          	; 9ACA FD E1      	; Recupera IY
	rts				; retorna				; 	RET          		; 9ACC C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Parmetros: HL=puntero a un byte con un cdigo de localizacin de algo.
										; 							; DE=puntero al mensaje a imprimir (bien 0x00 enters o 0x00 appears...)
										; 							; A=ID de objeto
										; 							; (#230# --)
L_9ACD	cmpa	#$ff			; is 'no' object?			; L_9ACD: CP $FF		 ; 9ACD FE FF		; objeto = $FF?
	beq	e9ACD			; yes, exit				; 	RET Z			 ; 9ACF C8		; si, salir
	tsta				; is object 0?				; 	AND A			 ; 9AD0 A7		; objeto = $00?
	beq	e9ACD			; yes, exit				; 	RET Z			 ; 9AD1 C8		; si, salir
	sta	<reg_B			; pass object ID to reg_B		; 	LD B, A			 ; 9AD2 47		; guarda A en B
	lda	S_LightDark		; get flag				; 	LD A, (S_LightDark)	 ; 9AD3 3A 0C 98	; recupera S_LightDark
	cmpa	#2			; already notified?			; 	CP $02			 ; 9AD6 FE 02		; es igual a 2?
	beq	e9ACD			; yes, exit				; 	RET Z			 ; 9AD8 C8		; si, salir
	lda	<reg_B			; restore object ID			; 	LD A, B			 ; 9AD9 78		; recupera A
	jsr	GetObjectLocation	; get its location			; 	CALL GetObjectLocation	 ; 9ADA CD 82 9F	; llama GetObjectLocation
	sta	<reg_C			; save to reg_C				; 	LD C, A			 ; 9ADD 4F		; guarda en C resultado rutina anterior (Localizacin - $FF)
	cmpa	,x			; are locations equal?			; 	CP (HL)			 ; 9ADE BE		; compara resultado con valor apuntado por HL
	beq	e9ACD			; yes, exit				; 	RET Z			 ; 9ADF C8		; si son iguales, salir
	lda	BilboLocation		; get Bilbo location			; 	LD A, (BilboLocation)	 ; 9AE0 3A F5 B6	; recupera BilboLocation
	cmpa	<reg_C			; is the same of the object?		; 	CP C			 ; 9AE3 B9		; est el objeto en la misma localizacin que Bilbo?
	bne	e9ACD			; no, exit				; 	RET NZ			 ; 9AE4 C0		; no, salir
	lda	L_9BDC			; get L_9BCD				; 	LD A, (L_9BDC)		 ; 9AE5 3A DC 9B	; recupera valor de L_9BDC
										; 	AND A			 ; 9AE8 A7		; es igual a cero?
	beq	e9ACD			; if zero, exit				; 	RET Z			 ; 9AE9 C8		; si, salir
	lda	#1			; put value 1				; 	LD A, $01		 ; 9AEA 3E 01		; pone valor 1
	sta	L_B702			; in L_B702				; 	LD (L_B702), A		 ; 9AEC 32 02 B7	; en L_B702
										; 	PUSH DE			 ; 9AEF D5		; pasa DE
	ldx	<reg_DE			; pass reg_DE to X(HL)			; 	POP HL			 ; 9AF0 E1		; a HL (puntero a mensaje a imprimir)
	lda	<reg_B			; get original ID object		; 	LD A, B			 ; 9AF1 78		; recupera cdigo objeto inicial de A
	jsr	GetObjPointer2IX	; get its pointer			; 	CALL GetObjPointer2IX	 ; 9AF2 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
										; 	PUSH DE			 ; 9AF5 D5		; guarda DE
	leay	8,y			; skip 8 bytes				; 	LD DE, $0008		 ; 9AF6 11 08 00	; ofset de 8 bytes
	sty	<reg_IX			; update reg_IY				; 	ADD IX, DE		 ; 9AF9 DD 19		; lo suma a puntero al Objeto para apuntar al sustantivo (las otras dos suelen ser adjetivos ...)
										; 	POP DE			 ; 9AFB D1		; recupera DE (el puntero a mensaje)
	pshs	y			; pass onto stack			; 	PUSH IX			 ; 9AFC DD E5		; pasa IX como parmetro
	jsr	PrintMsg		; print message				; 	CALL PrintMsg		 ; 9AFE CD DD 72	; llama rutina PrintMsg
e9ACD	rts				; return				; 	RET			 ; 9B01 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_None									;Action_None:						; (# sinNumero)
	clra				; valor 0 (Bilbo)			;	LD A, $00		 ; 9B02 3E 00		; Carga A con $00
	jsr	GetObjectLocation	; busca su localizacin			;	CALL GetObjectLocation	 ; 9B04 CD 82 9F	; llama GetObjectLocation
	sta	BilboLocation		; la guarda				;	LD (BilboLocation), A	 ; 9B07 32 F5 B6	; la guarda en BilboLocation
	clra				; resultado cero
	pshs	a			; lo guarda
	jsr	IsItDark		; est oscuro?				;	CALL IsItDark		 ; 9B0A CD ED 95	; llama rutina IsItDark
	puls	a			; retoma resultado			;	LD A, $00		 ; 9B0D 3E 00		; A=0 (hay luz)
	bcc	i_9B12			; si hay luz, salta la siguiente	;	JR NC, i_9B12		 ; 9B0F 30 01		; Si C=0 (hay luz), salta a i_9B12
	inca				; resultado uno				;	INC A			 ; 9B11 3C		; A=1 (est oscuro)
i_9B12	sta	S_LightDark		; guarda resultado			;i_9B12: LD (S_LightDark), A	 ; 9B12 32 0C 98	; lo guarda en S_LightDark
	rts				; retorna				;	RET			 ; 9B15 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_9B16	lda	#$ff			; put value for no object		; L_9B16: LD A, $FF		 ; 9B16 3E FF		; pone valor $FF
	sta	SecondObject		; in secondObject			; 	LD (SecondObject), A	 ; 9B18 32 E9 B6	; en SecondObject (ninguno)
	ldy	<reg_IX			; get reg_IY
	lda	1,y			; puts container ID			; 	LD A, (IX+$01)		 ; 9B1B DD 7E 01	; pone byte de (IX+$01) = cdigo de objeto contenedor (0 $FF)
	sta	MainObject		; as mainObject				; 	LD (MainObject), A	 ; 9B1E 32 E8 B6	; como cdigo objeto principal
	jsr	GetObjPointer2IX	; ask for pointer to it			; 	CALL GetObjPointer2IX	 ; 9B21 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	ldb	7,y			; get flags
	bitb	#%00001000		; is it broken-dead?			; 	BIT 3, (IX+$07)		 ; 9B24 DD CB 07 5E	; Esta a 1 el bit 3 de (IX+$07)? (1= roto - muerto)
	lbne	L_9870			; yes, go L_9870			; 	JP NZ, L_9870		 ; 9B28 C2 70 98	; Si Z = 0, Salta a L_9870
	bitb	#%01000000		; is it an animal?			; 	BIT 6, (IX+$07)		 ; 9B2B DD CB 07 76	; Esta a 1 el bit 6 de (IX+$07) es un  animal? (0=cosa) 
	lbne	L_9870			; yes, go L_9870			; 	JP NZ, L_9870		 ; 9B2F C2 70 98	; Si Z = 0, Salta a L_9870
	bitb	#%00100000		; is it open?				; 	BIT 5, (IX+$07)		 ; 9B32 DD CB 07 6E	; Esta a 1 el bit 5 de (IX+$07) est abierto? (0=cerrado)
	lbeq	GetNextActor		; no, go nextactor			; 	JP Z, GetNextActor	 ; 9B36 CA 01 99	; Si Z = 1, Salta a GetNextActor
	lda	#$37			; set action ClimbOutOf			; 	LD A, $37		 ; 9B39 3E 37		; pone valor $37 = accion "climb out of"
	sta	CurrentAction		; in current action			; 	LD (CurrentAction), A	 ; 9B3B 32 E7 B6	; como ID de accin 
	jsr	L_99C6			; call L_99C6				; 	CALL L_99C6		 ; 9B3E CD C6 99	; llama rutina L_99C6 (#228# --)
	lbra	GetNextActor		; go nextActor				; 	JP GetNextActor		 ; 9B41 C3 01 99	; Salta a GetNextActor
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Comprueba si la accin puede efectuarse con los objetos y parmetros recibidos
										; 							; parmetros: cdigos de objeto en MainObject, SecondObject
										; 							; variables (0-1) IsMainObjLoc y IsSecObjLoc
										; 							; devuelve Z=1 si no se puede efectuar - Z=0 si se puede
IsActionFeasible								; IsActionFeasible:					; antes ; (#208# --)
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 9B44 3A E8 B6	; recupera cdigo objeto principal
	inca				; lo incrementa				; 	INC A			 ; 9B47 3C		; lo incrementa
	bne	i_9B4C			; si no es 0, salta a i_9B4C		; 	JR NZ, i_9B4C		 ; 9B48 20 02		; si no era $FF, sigue en i_9B4C
	inca				; incrementa A (era $FF)		; 	INC A			 ; 9B4A 3C		; era $FF, pasa A a 1
	rts				; retorna con flag Z=1			; 	RET			 ; 9B4B C9		; retorna con flag Z=1
i_9B4C	lda	IsMainObjLoc		; recupera IsMainObjLoc			; i_9B4C: LD A, (IsMainObjLoc)	 ; 9B4C 3A FE B6	; recupera IsMainObjLoc
										; 	AND A			 ; 9B4F A7		; actualiza flags
	bne	i_9B5F			; si no es 0, salta a i_9B5F		; 	JR NZ, i_9B5F		 ; 9B50 20 0D		; no es cero, salta a i_9B5F
	ldx	#MainObject		; apunta a MainObject			; 	LD HL, MainObject	 ; 9B52 21 E8 B6	; es cero. HL apunta a cdigo objeto principal
	lda	ActionActor		; recupera ActionActor			; 	LD A, (ActionActor)	 ; 9B55 3A EA B6	; Carga ActionActor
	cmpa	,x			; coincide con byte apuntado por X?	; 	CP (HL)			 ; 9B58 BE		; es el mismo objeto que el MainObject?
	beq	e9B5F			; si, sale				; 	RET Z			 ; 9B59 C8		; si, retorna con Z=1 (actor y objeto1 iguales)
	lda	SecondObject		; recupera SecondObject			; 	LD A, (SecondObject)	 ; 9B5A 3A E9 B6	; no, Carga cdigo objeto secundario
	cmpa	,x			; coincide con byte apuntado por X?	; 	CP (HL)			 ; 9B5D BE		; es igual al MainObject?
	beq	e9B5F			; si, sale				; 	RET Z			 ; 9B5E C8		; si, retorna con Z=1 (objeto1 y objeto2 iguales)
i_9B5F	lda	IsSecObjLoc		; recupera IsSecObjLoc			; i_9B5F: LD A, (IsSecObjLoc)	 ; 9B5F 3A FF B6	; recupera IsSecObjLoc
										; 	AND A			 ; 9B62 A7		; actualiza flags
	bne	e9B5F			; si no es 0, sale			; 	RET NZ			 ; 9B63 C0		; no es cero, retorna con Z=0
	lda	SecondObject		; recupera SecondObject			; 	LD A, (SecondObject)	 ; 9B64 3A E9 B6	; Carga cdigo objeto secundario
	ldx	#ActionActor		; apunta a ActionActor			; 	LD HL, ActionActor	 ; 9B67 21 EA B6	; HL apunta a ActionActor
	cmpa	,x			; coincide con byte apuntado por X?	; 	CP (HL)			 ; 9B6A BE		; ActionActor = Objeto2?
e9B5F	rts				; retorna				; 	RET			 ; 9B6B C9		; retorna con el resultado de la comparacin
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							;  antes ; (#118# OK)
CallSubrutineHL									; CallSubrutineHL:					; llama a subrutina apuntada por HL,
	ldu	<reg_IX			; recupera reg_IX			; 	PUSH IX			 ; 9B6C DD E5		; guarda IX
	ldy	<reg_IY			; recupera reg_IY			; 	PUSH IY			 ; 9B6E FD E5		; guarda IY
	pshs	u,y			; guarda U(IX),Y(IY)
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; 9B70 D5		; guarda DE
	ldy	<reg_BC			; recupera reg_BC			; 	PUSH BC			 ; 9B71 C5		; guarda BC
	pshs	u,y,x			; guarda X(HL),Y(BC),U(DE)		; 	PUSH HL			 ; 9B72 E5		; guarda HL
	cmpx	#$0000			; es X = 0?				; 	LD A, L			 ; 9B73 7D		; pasa L a A
	beq	cCsHL			; si, salta la siguiente		; 	OR H			 ; 9B74 B4		; mira si hay algun bit a 1
	jsr	i_9B80			; llama i_9B80				; 	CALL NZ, i_9B80		 ; 9B75 C4 80 9B	; si, llama rutina i_9B80 (#119# OK)
cCsHL	tfr	cc,b			; guarda flags en B
	puls	x,y,u			; recupera X(HL),Y(BC),U(DE)		; 	POP HL			 ; 9B78 E1		; recupera HL
	sty	<reg_BC			; actualiza reg_BC			; 	POP BC			 ; 9B79 C1		; recupera BC
	stu	<reg_DE			; actualiza reg_DE			; 	POP DE			 ; 9B7A D1		; recupera DE
	puls	y,u			; recupera Y(IY),U(IX)
	sty	<reg_IY			; actualiza reg_IY			; 	POP IY			 ; 9B7B FD E1		; recupera IY
	stu	<reg_IX			; actualiza reg_IX			; 	POP IX			 ; 9B7D DD E1		; recupera Ix
	tfr	b,cc			; recupera flags de B
	rts				; retorna				; 	RET			 ; 9B7F C9		; retorna
i_9B80	jmp	,x			; salta a la rutina solicitada		; i_9B80: JP (HL)		 ; 9B80 E9		; salta a direccin apuntada por HL
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Busca una accin en la subtabla de un Objeto - antes ; (#121# OK) 
										; 							; recibe puntero al objeto en IX, cdigo de la accin en A
										; 							; si encontrado devuelve C=1
SearchActionInObj								; SearchActionInObj:					; devuelve en IX puntero a rutina a ejecutar. Si no encontrado Z=1 (de FindPointer) 
					; no se utiliza				; 	PUSH DE			 ; 9B81 D5		; guarda DE
	ldu	<reg_IX			; recupera reg_IX			; 	LD D, A			 ; 9B82 57		; guarda accin en D
	ldb	,u			; toma un byte de (U)			; 	LD A, (IX+$00)		 ; 9B83 DD 7E 00	; toma primer byte apuntado por IX (nmero de ubicaciones)
	addb	#$10			; le suma 16				; 	ADD A, $10		 ; 9B86 C6 10		; le suma $10 (tiene que saltarse 16 bytes)
										; 	LD E, A			 ; 9B88 5F		; lo pone como byte bajo
										; 	LD A, D			 ; 9B89 7A		; recupera accin
	leau	b,u			; suma resultado a U			; 	LD D, $00		 ; 9B8A 16 00		; byte alto a cero (DE=offset a acciones dentro del objeto)
	stu	<reg_IX			; actualiza reg_IX			; 	ADD IX, DE		 ; 9B8C DD 19		; IX apunta a sub-tabla en Objeto tipo (ID-direccion)
	jsr	FindPointer		; llama FindPointer			; 	CALL FindPointer	 ; 9B8E CD BD 9D	; busca puntero con cdigo A e inicio tabla en IX  (encontrado hace C=1)
										; 	POP DE			 ; 9B91 D1		; recupera DE 
	rts				; retorna				; 	RET			 ; 9B92 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Devuelve siguiente entrada de la tabla y el ID
										; 							; Parmetro: IX - posicin puntero a la tabla
										; 							; resultado: IX - apunta a siguiente entrada de la tabla 
										; 							;	     IY - direccin del objeto de la siguiente entrada
										; 							;             A - ID del objeto  $FF
										; 							;          flag Z=1 si llegado a fin de tabla
GetNextObjAndID									; GetNextObjAndID:					; antes ; (-12-)
	jsr	do_exx			; intercambia registros con espejos	; 	EXX			 ; 9B93 D9		; Intercambia registros (menos AF) con sus 'sombras' rr<->rr'
	ldy	<reg_IX			; recupera reg_IX			; 	LD DE, $0003		 ; 9B94 11 03 00	; DE = $0003
	leay	3,y			; le aade 3				; 	ADD IX, DE		 ; 9B97 DD 19		; Incrementa IX en 3, pasa a siguiente entrada en la tabla
	sty	<reg_IX			; actualiza reg_IX			; 	LD D, (IX+$02)		 ; 9B99 DD 56 02	; carga byte alto direccin
	ldu	1,y			; recupera direccin de (Y+1)		; 	LD E, (IX+$01)		 ; 9B9C DD 5E 01	; carga byte bajo. DE = puntero al objeto
										; 	PUSH DE			 ; 9B9F D5		; pasa puntero DE
	stu	<reg_IY			; lo guarda en reg_IY			; 	POP IY			 ; 9BA0 FD E1		; a IY 
	lda	,y			; toma ID objeto			; 	LD A, (IX+$00)		 ; 9BA2 DD 7E 00	; Toma el cdigo del objeto (ID)
	jsr	do_exx			; intercambia registros con espejos	; 	CP $FF			 ; 9BA5 FE FF		; era fin de tabla?
	cmpa	#$FF			; era A=$FF (fin de tabla)?		; 	EXX			 ; 9BA7 D9		; Intercambia los registros (menos AF)con sus sombras rr<->rr'
	rts				; retorna				; 	RET			 ; 9BA8 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; Devuelve siguiente entrada de la tabla 
										;							; Parmetro: IX - direccin actual
										;							; resultado: IY - direccin al objeto de la siguiente entrada
										;							; antes ; (-11-)
GetNextObj									;GetNextObj:						
	ldu	<reg_BC			; guarda registro			;	PUSH BC			 ; 9BA9 C5		; Guarda BC
	pshs	u			; en el stack  
	sta	<reg_B			; guarda A en reg_B			;	LD B, A			 ; 9BAA 47		; guarda A en B
	jsr	GetNextObjAndID		; recupera siguiente objeto		;	CALL GetNextObjAndID	 ; 9BAB CD 93 9B	; llama a GetNextObjAndID
	tfr	cc,b
	lda	<reg_B			; recupera A de reg_B			;	LD A, B			 ; 9BAE 78		; recupera A
	puls	u			; recupera registro			;	POP BC			 ; 9BAF C1		; Recupera BC
	stu	<reg_BC			; del stack
	tfr	b,cc
	rts				; retorna				;	RET			 ; 9BB0 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
																	; antes ; (#22# OK)
GetLocPointer2IX								; GetLocPointer2IX:					; recibe num localizacin en A - devuelve puntero a localizacin en IX
	cmpa	#$50			; es A menor que $50?			; 	CP $50			 ; 9BB1 FE 50		; es A > 79? (la tabla tiene 80 entradas de 00 hasta 79)
	bcs	i_9BB7			; si, salta a i_9BB7			; 	JR C, i_9BB7		 ; 9BB3 38 02		; no, salta a siguiente parte
	clra				; pone A a 0, flag Z=1			; 	XOR A			 ; 9BB5 AF		; A = 0, flag Z = 1 (error)
	rts				; retorna				; 	RET			 ; 9BB6 C9		; retorna
i_9BB7	ldy	#LOCTABLE		; apunta a LOCTABLE			; i_9BB7: PUSH DE			 ; 9BB7 D5		; guarda DE
										; 	LD DE, LOCTABLE		 ; 9BB8 11 E0 B9	; DE apunta al inicio de la tabla de punteros a localizaciones
										; 	PUSH HL			 ; 9BBB E5		; guarda HL
	ldb	#2			; factor				; 	LD L, A			 ; 9BBC 6F		; byte bajo = codigo de localizacin
	mul				; D = 2 * A				; 	LD H, $00		 ; 9BBD 26 00		; byte alto igual a cero
										; 	ADD HL, HL		 ; 9BBF 29		; duplica valor (entradas son 2 bytes)
										; 	ADD HL, DE		 ; 9BC0 19		; lo suma a DE y HL apunta al 'puntero' a la localizacin deseada
										; 	LD E, (HL)		 ; 9BC1 5E		; carga el byte bajo
										; 	INC HL			 ; 9BC2 23		; incrementa puntero
	ldy	d,y			; recupera puntero de (Y+D)		; 	LD D, (HL)		 ; 9BC3 56		; carga el byte alto del puntero a la localizacin solicitada
	sty	<reg_IX			; actualiza reg_IX			; 	PUSH DE			 ; 9BC4 D5		; lo pasa
										; 	POP IX			 ; 9BC5 DD E1		; al indice IX
										; 	POP HL			 ; 9BC7 E1		; recupera HL
										; 	POP DE			 ; 9BC8 D1		; recupera DE
	rts				; retorna				; 	RET			 ; 9BC9 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; antes ; (#23# OK)
GetObjPointer2IX								; GetObjPointer2IX:					; en A llega el cdigo del objeto - devuelve puntero al objeto en IX
	ldy	#ObjIndexTable		; apunta a ObjIndexTable		; 	LD IX, ObjIndexTable	 ; 9BCA DD 21 63 C0	; IX apunta a ObjIndexTable
	sty	<reg_IX			; actualiza reg_IX
	jsr	FindPointer		; llama FindPointer			; 	CALL FindPointer	 ; 9BCE CD BD 9D	; busca puntero con cdigo A e inicio tabla en IX
										; 	PUSH HL			 ; 9BD1 E5		; guarda HL
	ldy	1,y			; recupera puntero encontrado		; 	LD L, (IX+$01)		 ; 9BD2 DD 6E 01	; carga HL con los dos bytes apuntados por IX
										; 	LD H, (IX+$02)		 ; 9BD5 DD 66 02	; IX apuntaba al cdigo del objeto!
										; 	EX (SP), HL		 ; 9BD8 E3		; recupera HL anterior y pasa el nuevo puntero 
	sty	<reg_IX			; lo guarda en reg_IX			; 	POP IX			 ; 9BD9 DD E1		; a IX
	rts				; retorna				; 	RET			 ; 9BDB C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#186# --)
L_9BDD	ldx	#L_9BDC			; apunta a ID de objeto actual		;L_9BDD: LD HL, L_9BDC		 ; 9BDD 21 DC 9B	; apunta a L_9BDC
	ldb	#1			; pone valor 1
	stb	,x			; como ID de localizacion		;	LD (HL), $01		 ; 9BE0 36 01		; pone a 1 L_9BDC
	jsr	MoveContainedObjects	; llama MoveContainedObjects		;	CALL MoveContainedObjects ; 9BE2 CD 17 9C	; llama rutina MoveContainedObjects
	lda	,x			; mira ID objeto			;	LD A, (HL)		 ; 9BE5 7E		; recupera L_9BDC
										;	AND A			 ; 9BE6 A7		; es 0?
	bne	s_9C13			; si no es 0, sale			;	RET NZ			 ; 9BE7 C0		; si, retorna
	pshs	x			; pasa puntero al stack			;	PUSH HL			 ; 9BE8 E5		; Guarda HL
	lda	L_C11B+16		; toma localizacin de Bilbo		;	LD A, (L_C11B + $10)	 ; 9BE9 3A 2B C1	; recupera localizacin de Bilbo (objeto $00)
										;	AND A			 ; 9BEC A7		; es 0?
	beq	i_9C13			; si es 0, sale via i_9C13		;	JR Z, i_9C13		 ; 9BED 28 24		; si, sale via i_9C13
	lda	ActionActor		; toma actor				;	LD A, (ActionActor)	 ; 9BEF 3A EA B6	; recupera ActionActor
	pshs	cc,a			; guarda registros			;	PUSH AF			 ; 9BF2 F5		; Guarda AF
	ldx	ObjectPointer		; toma puntero				;	LD HL, (ObjectPointer)	 ; 9BF3 2A 0C B7	; recupera ObjectPointer
	pshs	x			; lo pasa al stack			;	PUSH HL			 ; 9BF6 E5		; Guarda HL
	ldx	#OBJ_TABLE		; apunta a tabla de objetos		;	LD HL, OBJ_TABLE	 ; 9BF7 21 1B C1	; apunta a OBJ_TABLE
	stx	ObjectPointer		; guarda valor				;	LD (ObjectPointer), HL	 ; 9BFA 22 0C B7	; lo guarda en ObjectPointer
	clra				; pone valor 0				;	XOR A			 ; 9BFD AF		; pone 0
	sta	ActionActor		; como actor (Bilbo)			;	LD (ActionActor), A	 ; 9BFE 32 EA B6	; en ActionActor
	lda	<reg_B			; toma valor guardado en reg_B		;	LD A, B			 ; 9C01 78		; pasa B
	sta	L_8D9B			; lo guarda en L_8D9B (localizacion)	;	LD (L_8D9B), A		 ; 9C02 32 9B 8D	; a L_8D9B (localizacin)
	jsr	L_8E12			; llama L_8E12				;	CALL L_8E12		 ; 9C05 CD 12 8E	; llama rutina L_8E12 (#232# --)
	jsr	Action_None		; llama Action_None			;	CALL Action_None	 ; 9C08 CD 02 9B	; llama Action_None
	puls	x			; recupera ObjectPointer		;	POP HL			 ; 9C0B E1		; recupera HL
	stx	ObjectPointer		; actualiza variable			;	LD (ObjectPointer), HL	 ; 9C0C 22 0C B7	; lo guarda en ObjectPointer
	puls	cc,a			; recupera registros guardados		;	POP AF			 ; 9C0F F1		; Recupera AF
	sta	ActionActor		; guarda actor				;	LD (ActionActor), A	 ; 9C10 32 EA B6	; guarda ActionActor
i_9C13	puls	x			; recupera puntero inicial		;i_9C13: POP HL			 ; 9C13 E1		; Recupera HL
	clra				; pone cero				;	XOR A			 ; 9C14 AF		; pone 0
	sta	,x			; en byte apuntado por X		;	LD (HL), A		 ; 9C15 77		; en L_9BDC
s_9C13	rts				; retorna				;	RET			 ; 9C16 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; Actualiza la localizacin de los objetos contenidos en el objeto que se ha movido
										;							; parametros:
										;							; A = ID del objeto que se mueve (contenedor)
										;							; B = localizacin donde se deben poner los objetos contenidos 
										;							; antes ; (#231# --)
MoveContainedObjects								;MoveContainedObjects:					
	ldu	<reg_IY			; toma reg_IY				;	PUSH IY			 ; 9C17 FD E5		; guarda IY
	ldy	<reg_IX			; y reg_IX				;	PUSH IX			 ; 9C19 DD E5		; guarda IX
	pshs	u,y			; los guarda en el stack
	ldy	#ObjIndexTable-3	; apunta 3 bytes antes de tabla objetos	;	LD IX, ObjIndexTable-$03 ; 9C1B DD 21 60 C0	; IX apunta 3 bytes antes de ObjIndexTable
	sty	<reg_IX			; actualiza reg_IX
i_9C1F	jsr	GetNextObj		; busca siguiente objeto		;i_9C1F: CALL GetNextObj	 ; 9C1F CD A9 9B	; IY recibe puntero a siguiente objeto desde GetNextObj
	beq	i_9C3C			; si no encontrado, salir		;	JR Z, i_9C3C		 ; 9C22 28 18		; si llegado a final de tabla, salir
	ldu	<reg_IY			; toma reg_IY
	cmpa	1,u			; coincide con contenedor?		;	CP (IY+$01)		 ; 9C24 FD BE 01	; es A = posible contenedor del objeto al que apunta IX?
	bne	i_9C1F			; no, mirar siguiente objeto		;	JR NZ, i_9C1F		 ; 9C27 20 F6		; no, mirar siguiente objeto
					; regB is modif in GetNextObject
	ldb	<reg_B
	stb	16,u			; actualizar localizacion		;	LD (IY+$10), B		 ; 9C29 FD 70 10	; si, poner ubicacin recibida en B al objeto apuntado ahora
	pshs	cc,a			; guarda registros			;	PUSH AF			 ; 9C2C F5		; guarda AF
	lda	,y			; toma ID objeto			;	LD A, (IX+$00)		 ; 9C2D DD 7E 00	; recupera ID del objeto actual
										;	AND A			 ; 9C30 A7		; es 0?
	bne	i_9C36			; si no es 0, salta la siguiente	;	JR NZ, i_9C36		 ; 9C31 20 03		; no, salta la siguiente instruccin
	sta	L_9BDC			; actualiza L_9BDC			;	LD (L_9BDC), A		 ; 9C33 32 DC 9B	; pone 0 en L_9BDC
i_9C36	jsr	MoveContainedObjects	; llamada recursiva			;i_9C36: CALL MoveContainedObjects ; 9C36 CD 17 9C	; llamada recursiva a esta funcin por si el objeto contiene otro
	puls	cc,a			; recupera registros			;	POP AF			 ; 9C39 F1		; recupera AF
	bra	i_9C1F			; vuelve a i_9C1F			;	JR i_9C1F		 ; 9C3A 18 E3		; mira siguiente objeto
i_9C3C	puls	y,u			; recupera registros			;i_9C3C: POP IX			 ; 9C3C DD E1		; recupera IX
	sty	<reg_IX			; actualiza reg_IX			;	POP IY			 ; 9C3E FD E1		; recupera IY
	stu	<reg_IY			; y reg_IY
	rts				; retorna				;	RET			 ; 9C40 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#187# --)
L_9C41	ldu	<reg_IX			; toma reg_IX				;L_9C41: PUSH IX		 ; 9C41 DD E5		; Guarda IX
	ldy	<reg_IY			; y reg_IY				;	PUSH IY			 ; 9C43 FD E5		; Guarda IY
	pshs	u,y			; los guarda en el stack
	ldu	<reg_BC			; toma reg_BC				;	PUSH BC			 ; 9C45 C5		; Guarda BC
	pshs	u			; lo guarda en el stack
	sta	<reg_B			; guarda A en reg_B			;	LD B, A			 ; 9C46 47		; Carga B con A
	jsr	GetLocPointer2IX	; busca puntero a localizacion		;	CALL GetLocPointer2IX	 ; 9C47 CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	lda	1,y			; lee atributo				;	LD A, (IX+$01)		 ; 9C4A DD 7E 01	; Carga A con (IX+$01)
	sta	<reg_C			; lo guarda en reg_C			;	LD C, A			 ; 9C4D 4F		; Carga C con A
	ldy	#ObjIndexTable-3	; apunta 3 bytes antes de tabla		;	LD IX, ObjIndexTable-$03 ; 9C4E DD 21 60 C0	; Carga IX con ObjIndexTable - $03
	sty	<reg_IX			; actualiza reg_IX
i_9C52	jsr	GetNextObjAndID		; llama	GetNextObjAndID			;i_9C52: CALL GetNextObjAndID	 ; 9C52 CD 93 9B	; Llama a GetNextObjAndID
	beq	i_9C6D			; no hay mas, sale via i_9C6D		;	JR Z, i_9C6D		 ; 9C55 28 16		; Si Z = 1, Salta a i_9C6D
	lda	,u			; toma num localizaciones es visible	;	LD A, (IY+$00)		 ; 9C57 FD 7E 00	; Carga A con (IY+$00)
	cmpa	#1			; es 1?					;	CP $01			 ; 9C5A FE 01		; Compara A con $01
	bne	i_9C52			; no, vuelve a i_9C52			;	JR NZ, i_9C52		 ; 9C5C 20 F4		; Si Z = 0, Salta a i_9C52
	lda	<reg_B			; recupera reg_B			;	LD A, B			 ; 9C5E 78		; Carga A con B
	cmpa	16,u			; es igual a localizacion actual?	;	CP (IY+$10)		 ; 9C5F FD BE 10	; Compara A con (IY+$10)
	bne	i_9C52			; no, vuelve a i_9C52			;	JR NZ, i_9C52		 ; 9C62 20 EE		; Si Z = 0, Salta a i_9C52
	lda	<reg_C			; recupera reg_C			;	LD A, C			 ; 9C64 79		; Carga A con C
	suba	2,u			; le resta volumen			;	SUB (IY+$02)		 ; 9C65 FD 96 02	; Resta (IY+$02) de A
	bcs	i_9C74			; si da negativo sale via i_9C74	;	JR C, i_9C74		 ; 9C68 38 0A		; Si C = 1, Salta a i_9C74
	sta	<reg_C			; actualiza reg_C			;	LD C, A			 ; 9C6A 4F		; Carga C con A
	bra	i_9C52			; vuelve a i_9C52			;	JR i_9C52		 ; 9C6B 18 E5		; Salta a i_9C52
i_9C6D	lda	<reg_C			; recupera reg_C			;i_9C6D: LD A, C		 ; 9C6D 79		; Carga A con C
	puls	u			; recupera registro			;	POP BC			 ; 9C6E C1		; Recupera BC
	stu	<reg_BC			; actualiza reg_BC
	puls	u,y			; recupera registros			;	POP IY			 ; 9C6F FD E1		; Recupera IY
	sty	<reg_IY			; actualiza reg_IY			;	POP IX			 ; 9C71 DD E1		; Recupera IX
	stu	<reg_IX			; y reg_IX
	rts				; retorna				;	RET			 ; 9C73 C9		; Retorna
i_9C74	clr	<reg_C			; pone a cero reg_C			;i_9C74: LD C, $00		 ; 9C74 0E 00		; Carga C con $00
	bra	i_9C6D			; sale via i_9C6D			;	JR i_9C6D		 ; 9C76 18 F5		; Salta a i_9C6D
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
OwnsActorCurObject1								; OwnsActorCurObject1:					; devuelve C=1 si Objeto=$FF o lo lleva el ActionActor ; antes (#177# --)
	lda	MainObject		; recupera MainObject			; 	LD A, (MainObject)	 ; 9C78 3A E8 B6	; Carga cdigo objeto principal
OwnsActorObject									; OwnsActorObject:					; esta entrada no fuerza objeto principal como parmetro ; antes (#196# --) 
	ldx	#ActionActor		; apunta a ActionActor			; 	LD HL, ActionActor	 ; 9C7B 21 EA B6	; HL apunta a ActionActor
										; 							; esta entrada no fuerza ni objeto principal ni ActionActor ; antes (#178# --) 
										; 							; parmetros A: objeto
IsObjectOwned									; IsObjectOwned:					;           HL: puntero a personaje
	cmpa	#$FF			; es A = $FF?				; 	CP $FF			 ; 9C7E FE FF		; es nulo el objeto principal?
	orcc	#%00000001		; pone a 1 el flag de Carry		; 	SCF			 ; 9C80 37		; Pone flag C=1
	beq	eIoO			; si era $FF, sale			; 	RET Z			 ; 9C81 C8		; si es nulo, retorna con C=1
	ldu	<reg_IX			; recupera reg_IX					
	pshs	u			; guarda U(IX)				; 	PUSH IX			 ; 9C82 DD E5		; Guarda IX
	jsr	IsObjyInObjx		; llama IsObjyInObjx			; 	CALL IsObjyInObjx	 ; 9C84 CD 8A 9C	; llama IsObjyInObjx
	tfr	cc,b			; save flags
	puls	u			; recupera U(IX)			; 	POP IX			 ; 9C87 DD E1		; Recupera IX
	stu	<reg_IX			; actualiza reg_IX
	tfr	b,cc			; restore flags
eIoO	rts				; retorna				; 	RET			 ; 9C89 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Verifica si ObjetoX contiene el ObjetoY
										; 							; parametro A: cdigo ObjetoY
										; 							;           HL: puntero a ObjetoX
										; 							; si lo contiene devuelve el cdigo del contenedor en A
IsObjyInObjx									; IsObjyInObjx:						; antes; (#233# --)
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX	 ; 9C8A CD CA 9B	; llama GetObjPointer2IX con cdigo de ObjetoY
	pshs	a,cc			; guarda A y flags			; 	PUSH AF			 ; 9C8D F5		; Guarda cdigo del objetoY y flags
	ldu	<reg_IX			; recupera reg_IX
	lda	1,u			; toma 2 byte de (U+1)			; 	LD A, (IX+$01)		 ; 9C8E DD 7E 01	; Carga byte indicador de "contenido en" del objeto principal
	cmpa	#$FF			; es $FF?				; 	CP $FF			 ; 9C91 FE FF		; est contenido en otro objeto?
	beq	i_9C9C			; si, sale via i_9C9C			; 	JR Z, i_9C9C		 ; 9C93 28 07		; no, sale via i_9C9C con C=0
	leas	2,s			; quita A y flags del stack		; 	POP IX			 ; 9C95 DD E1		; descarta AF del stack
	cmpa	,x			; es A = byte apuntado por(X)?		; 	CP (HL)			 ; 9C97 BE		; El contenedor del objetoY es el ObjetoX?
	bne	IsObjyInObjx		; no, vuelve a IsObjyInObjx		; 	JR NZ, IsObjyInObjx 	 ; 9C98 20 F0		; no, mira si este objeto contendor est dentro de ObjetoX
	orcc	#%00000001		; pone flag de Carry a 1		; 	SCF			 ; 9C9A 37		; si, pone C=1
	rts				; retorna con carry=1			; 	RET			 ; 9C9B C9		; Retorna con C=1
i_9C9C	puls	a,cc			; quita A y flags del stack		; i_9C9C: POP AF		 ; 9C9C F1		; Recupera AF
	cmpa	#$00			; actualiza flags segun valor de A	; 	AND A			 ; 9C9D A7		; actualiza flags
				        ; y fuerza flag de carry a 0
	rts				; retorna con carry = 0			; 	RET			 ; 9C9E C9		; Retorna con C=0
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Genera un numero aleatorio positivo		  (# sinNumero)	;
; Resultado: A  resultado 							;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
GetPosRandom									; GetPosRandom:						; Rutina de random menor de 128 = POSITIVO - Retorna el valor en A
	jsr	GetRandom		; solicita un numero aleatorio (0-A)	; 	CALL GetRandom		 ; 9C9F CD A8 9C	; llama rutina GetRandom (envia A=valor mximo, recibe nuevo random en A)
	tsta				; es negativo el numero generado (>127)	; 	BIT 7, A		 ; 9CA2 CB 7F		; Prueba el Bit 7 de A
	bpl	eGPR			; no, salta siguiente instruccin	; 	RET Z			 ; 9CA4 C8		; bit7=0?	; Retorna si es cero, con flag C=0
	nega				; lo hace positivo			; 	NEG			 ; 9CA5 ED 44		; Negar A, desactiva el bit 7 de A al hacerlo positivo
eGPR	rts				; retorna				; 	RET			 ; 9CA7 C9		; Retorna con flag C=1 al haber hecho A=0-A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Genera una cifra aleatoria (entre +127 y -128)	  (# sinNumero)	;
; Parmetro: A  valor mximo admitido para la cifra aleatoria			;
; Resultado: A  cifra generada							;
;  Preserva: X, reg_IX(X), reg_BC(U)						;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
GetRandom									; GetRandom:						; devuelve en A el nuevo random (y el carry para indicar si el resultado es negativo)
	pshs	x			; to preserve this pointer X(HL)
	ldx	<reg_IX			; recupera reg_IX
	ldu	<reg_BC			; recupera reg_BC
	pshs	x			; guarda registro			; 	PUSH IX			 ; 9CA8 DD E5		; Guarda IX
	pshs	u			; guarda registro			; 	PUSH BC			 ; 9CAA C5		; Guarda BC
	sta	<reg_C			; hace de C en el stack			; 	LD C, A			 ; 9CAB 4F		; C = A, El valor lmite se guarda en C
	asla				; para detectar si es negativo		; 	SLA A			 ; 9CAC CB 27		; se duplica A (para provocar Carry si el valor tiene el bit7 a 1, o sea mayor que 127)
	bcc	i_9CB2			; no lo es, salta siguiente		; 	JR NC, i_9CB2		 ; 9CAE 30 02		; Si no hay carry salta a i_9CB2, saltandose la proxima instruccin (admite de 0 a 127)
	lda	#$FF			; toma valor mximo			; 	LD A, $FF		 ; 9CB0 3E FF		; Si mayor de $7F (negativo) coloca A = $FF, Se coloca el maximo
i_9CB2	sta	<reg_B			; hace de B en el stack			; i_9CB2: LD B, A		 ; 9CB2 47		; se guarda en B el valor de A corregido
										; 							; Puntero de 16 Bits. Este puntero empieza en cero y se va incrementando cada vez
i_9CB3	ldx	#CounterForRandom	; apunta a variable			; i_9CB3: LD IX, CounterForRandom ; 9CB3 DD 21 12 B7	; apunta a CounterForRandom
	inc	,x			; incrementa byte alto			; 	INC (IX+$01)		 ; 9CB7 DD 34 01	; (IX+1) = (IX+1) + 1, Incrementa el segundo byte de CounterForRandom
	bne	i_9CBF			; si no es cero, salta siguiente	; 	JR NZ, i_9CBF		 ; 9CBA 20 03		; Si no es cero salta a i_9CBF, se salta la proxima instruccin
	inc	1,x			; incrementa byte bajo			; 	INC (IX+$00)		 ; 9CBC DD 34 00	; (IX) = (IX) + 1, Incrementa el primer byte de CounterForRandom
i_9CBF	ldx	CounterForRandom	; recupera la variable			; i_9CBF: LD IX, (CounterForRandom); 9CBF DD 2A 12 B7	; recupera valor 16 bits de CounterForRandom
	lda	InitRandomSeed		; recupera semilla			; 	LD A, (InitRandomSeed)	 ; 9CC3 3A 0E B7	; recupera InitRandomSeed. Toma la semilla a partir de la cual debe generar el siguiente aleatorio
	adca	1,x			; le suma el byte bajo			; 	ADC A, (IX+$00)		 ; 9CC6 DD 8E 00	; suma en A el byte apuntado por el puntero antes incrementado mas el carry
	leax	d,x			; le suma D (cualquier cifra)		; 	ADD IX, DE		 ; 9CC9 DD 19		; suma al puntero IX el valor de DE (aleatorio), no importa, la cuestin es que 
										; 							; IX pasa a apuntar a un byte cualquiera de memoria ($0000 - $FFFF)
	eora	,x			; XOR con byte aleatorio		; 	XOR (IX+$01)		 ; 9CCB DD AE 01	; A = A XOR (IX+$01), lo exorea con el byte siguiente al apuntado por IX (mas aleatorio todava)
										; 	PUSH HL			 ; 9CCE E5		; Guarda HL
										; 	LD HL, InitRandomSeed	 ; 9CCF 21 0E B7	; apunta a InitRandomSeed. Toma de nuevo la direccin de la semilla original
	cmpa	InitRandomSeed		; A=semilla?				; 	CP (HL)			 ; 9CD2 BE		; compara el resultado calculado (nuevo random) con la semilla
										; 	POP HL			 ; 9CD3 E1		; Recupera HL
	beq	i_9CB3			; si, vuelve a generar otro		; 	JR Z, i_9CB3		 ; 9CD4 28 DD		; Si eran iguales, repite proceso para no dar dos veces seguidas la misma cifra
	sta	InitRandomSeed		; lo guarda como nueva semilla		; 	LD (InitRandomSeed), A	 ; 9CD6 32 0E B7	; Si no, guarda el valor calculado en InitRandomSeed (como semilla para el prximo clculo)
i_9CD9	cmpa	<reg_B			; A=B(del stack)?			; i_9CD9: CP B			 ; 9CD9 B8		; Compara nuevo random con el valor recibido en A (pero corregido si negativo)
	bcs	i_9CE3			; si A<B, sale				; 	JR C, i_9CE3		 ; 9CDA 38 07		; Si nuevo random es menor que valor recibido (flag C=1) se acepta, sale de la rutina
	beq	i_9CE3			; si son iguales, sale			; 	JR Z, i_9CE3		 ; 9CDC 28 05		; Si son iguales tambin se acepta y sale
	lsra				; divide por 2				; 	SRL A			 ; 9CDE CB 3F		; El resultado exceda del valor mximo, se divide el nuevo random por 2
	bra	i_9CD9			; mira si ahora cumple			; 	JP i_9CD9		 ; 9CE0 C3 D9 9C	; Repetir comparacin hasta que cumpla la condicin de ser igual o menor al mximo solicitado
i_9CE3	suba	<reg_C			; A = A-C (del stack)			; i_9CE3: SUB C			 ; 9CE3 91		; A = A - C, resta al valor calculado el valor inicialmente recibido en A
										; 							; esto dar cero  negativo. Si recibi 4 dar como posibles resultados 0,-1,-2,-3,-4
	puls	u			; quitar BC del stack			; 							; cabe recordar que esto en hexa significa: $00, $FF, $FE, $FD, $FC
	stu	<reg_BC			; guardar en reg_BC			; 	POP BC			 ; 9CE4 C1		; Recupera BC
										; 	POP IX			 ; 9CE5 DD E1		; Recupera IX
	puls	x			; recupera registro			; 	RET			 ; 9CE7 C9		; Retorna
	stx	<reg_IX			; update reg_IX
	puls	x,pc			; restore X(HL) and return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#183# --)
L_9CE8	ldu	<reg_BC			; toma reg_BC				;L_9CE8: PUSH BC		 ; 9CE8 C5		; Guarda BC
	pshs	u			; guarda registro
	ldb	#1			; pone valor 1	(control VOLUMEN)	;	LD B, $01		 ; 9CE9 06 01		; Carga B con $01
	stb	<reg_B			; en reg_B
	bra	i_9CF0			; salta a i_9CF0			;	JR i_9CF0		 ; 9CEB 18 03		; Salta a i_9CF0
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_9CED	ldu	<reg_BC			; toma reg_BC				;L_9CED: PUSH BC		 ; 9CED C5		; Guarda BC
	pshs	u			; lo guarda
	clr	<reg_B			; pone reg_B a cero (control MASA)	;	LD B, $00		 ; 9CEE 06 00		; Carga B con $00
i_9CF0	ldu	<reg_IX			; toma reg_IX				;i_9CF0: PUSH IX		 ; 9CF0 DD E5		; Guarda IX
	ldy	<reg_IY			; y reg_IY				;	PUSH IY			 ; 9CF2 FD E5		; Guarda IY
	pshs	u,y			; los guarda en el stack
	clr	<reg_C			; pone reg_C a cero			;	LD C, $00		 ; 9CF4 0E 00		; Carga C con $00
	jsr	L_9D00			; llama L_9D00				;	CALL L_9D00		 ; 9CF6 CD 00 9D	; llama rutina L_9D00 (#234# --)
	lda	<reg_C			; recupera reg_C			;	LD A, C			 ; 9CF9 79		; Carga A con C
	puls	y,u			; recupera registros
	sty	<reg_IY			; actualiza reg_IY			;	POP IY			 ; 9CFA FD E1		; Recupera IY
	stu	<reg_IX			; y reg_IX				;	POP IX			 ; 9CFC DD E1		; Recupera IX
	puls	u			; recupera registro
	stu	<reg_BC			; actualiza reg_BC			;	POP BC			 ; 9CFE C1		; Recupera BC
	rts				; retorna				;	RET			 ; 9CFF C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#234# --)
										;							; Igual compara Volumen - Masa
L_9D00	ldu	<reg_IX			; recupera reg_IX			;L_9D00: PUSH IX		 ; 9D00 DD E5		; Guarda IX
	pshs	u			; lo guarda
	ldu	#ObjIndexTable		; apunta a ObjIndexTable		;	LD IX, ObjIndexTable	 ; 9D02 DD 21 63 C0	; Carga IX con ObjIndexTable
	stu	<reg_IX			; actualiza reg_IX
i_9D06	jsr	GetNextObj		; busca siguiente objeto		;i_9D06: CALL GetNextObj	 ; 9D06 CD A9 9B	; Llama a GetNextObj
	beq	i_9D2F			; no hay mas, sale via i_9D2F		;	JR Z, i_9D2F		 ; 9D09 28 24		; Si Z = 1, Salta a i_9D2F
	ldy	<reg_IY			; toma puntero a Objeto
	cmpa	1,y			; es A el contenedor?			;	CP (IY+$01)		 ; 9D0B FD BE 01	; Compara A con (IY+$01)
	bne	i_9D06			; no, vuelve a i_9D06			;	JR NZ, i_9D06		 ; 9D0E 20 F6		; Si Z = 0, Salta a i_9D06
	pshs	cc,a			; guarda registros			;	PUSH AF			 ; 9D10 F5		; Guarda AF
										;	SUB A			 ; 9D11 97		; Resta A de A
	lda	<reg_C			; toma reg_C				;	CP B			 ; 9D12 B8		; Compara A con B
	tst	<reg_B			; es reg_B cero?			;	LD A, C			 ; 9D13 79		; Carga A con C
	beq	i_9D1F			; si, salta a i_9D1F			;	JR Z, i_9D1F		 ; 9D14 28 09		; Si Z = 1, Salta a i_9D1F
	adda	2,y			; le aade el volumen			;	ADD A, (IY+$02)		 ; 9D16 FD 86 02	; Adiciona (IY+$02) en A
	bvs	i_9D32			; si overflow salta a i_9D32		;	JP PE, i_9D32		 ; 9D19 EA 32 9D	; Si P = 1, Salta a i_9D32
	sta	<reg_C			; actualiza reg_C			;	LD C, A			 ; 9D1C 4F		; Carga C con A
	bra	i_9D2C			; salta a i_9D2C			;	JR i_9D2C		 ; 9D1D 18 0D		; Salta a i_9D2C
i_9D1F	adda	3,y			; le suma la masa			;i_9D1F: ADD A, (IY+$03)	 ; 9D1F FD 86 03	; Adiciona (IY+$03) en A
	bvs	i_9D32			; si overflow salta a i_9D32		;	JP PE, i_9D32		 ; 9D22 EA 32 9D	; Si P = 1, Salta a i_9D32
	sta	<reg_C			; actualiza reg_C			;	LD C, A			 ; 9D25 4F		; Carga C con A
	ldu	<reg_IX			; recupera puntero a tabla objetos
	lda	,u			; toma codigo objeto			;	LD A, (IX+$00)		 ; 9D26 DD 7E 00	; Carga A con (IX+$00)
	jsr	L_9D00			; llamada recursiva			;	CALL L_9D00		 ; 9D29 CD 00 9D	; se llama recursivamente a L_9D00 (#234# --)
i_9D2C	puls	cc,a			; recupera registros			;i_9D2C: POP AF			 ; 9D2C F1		; Recupera AF
	bra	i_9D06			; vuelve a i_9D06			;	JR i_9D06		 ; 9D2D 18 D7		; Salta a i_9D06
i_9D2F	puls	u			; recupera registro			;i_9D2F: POP IX			 ; 9D2F DD E1		; Recupera IX
	stu	<reg_IX			; actualiza reg_IX
	rts				; retorna				;	RET			 ; 9D31 C9		; Retorna
i_9D32	puls	cc,a			; recupera registros			;i_9D32: POP AF			 ; 9D32 F1		; Recupera AF
	ldb	#$FF			; pone valor $FF			;	LD C, $FF		 ; 9D33 0E FF		; Carga C con $FF
	stb	<reg_C			; en reg_C
	bra	i_9D2F			; salta a i_9D2F			;	JR i_9D2F		 ; 9D35 18 F8		; Salta a i_9D2F
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; antes ; (-18-) Recibe en ObjectPointer el puntero a un objeto. Carga en A su localizacin (byte $10=16)
GetLocPtrFromObjPtr								; GetLocPtrFromObjPtr:					; devuelve en IX el puntero a la localizacin de dicho objeto
	pshs	a,cc			; guarda registros			; 	PUSH AF			 ; 9D37 F5		; Guarda AF
	ldy	ObjectPointer		; recupera ObjectPointer		; 	LD IX, (ObjectPointer)	 ; 9D38 DD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IX			; lo guarda en reg_IX
	lda	16,y			; toma byte de (Y+16) = localizacin	; 	LD A, (IX+$10)		 ; 9D3C DD 7E 10	; recupera localizacin de dicho objeto
	jsr	GetLocPointer2IX	; llama GetLocPointer2IX		; 	CALL GetLocPointer2IX	 ; 9D3F CD B1 9B	; recibe puntero a la Localizacin en IX de la rutina GetLocPointer2IX
	puls	a,cc,pc			; recupera registros y retorna		; 	POP AF			 ; 9D42 F1		; Recupera AF
										; 	RET			 ; 9D43 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
BreakIfB6faNot1									;BreakIfB6faNot1:					; Chequea byte L_B6FA y elimina una DireccionRetorno si NO es = 1 ; antes ; (#81# OK)
	lda	L_B6FA			; toma valor flag			;	LD A, (L_B6FA)		 ; 9D44 3A FA B6	; Toma valor de L_B6FA
	cmpa	#1			; es 1?					;	CP $01			 ; 9D47 FE 01		; Es 1?
	beq	eBifN1			; si, salir				;	RET Z			 ; 9D49 C8		; Si, retorna
	inca				; no, incrementa A			;	INC A			 ; 9D4A 3C		; Incrementa A
	sta	L_B6FB			; lo guarda en L_B6FB			;	LD (L_B6FB), A		 ; 9D4B 32 FB B6	; guarda valor incrementado en L_B6FB
	leas	2,s			; elimina direc. retorno del stack	;	POP BC			 ; 9D4E C1		; elimina direccin de retorno
eBifN1	rts				; aborta la rutina que le ha llamado	;	RET			 ; 9D4F C9		; Retorna al nivel anterior al que llam aqu
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#204# --)
L_9D50	lda	MainObject		; get main object			; L_9D50: LD A, (MainObject)	 ; 9D50 3A E8 B6	; Carga cdigo objeto principal
										; 
										; 							; Analiza objetos contenidos en Objeto en 'A' ; (#222# --)
AnalyzeObjContents								; AnalyzeObjContents:					; parmetros  A - ID de objeto a tratar
	ldu	<reg_IY			; get pseudoregs			; 	PUSH IY			 ; 9D53 FD E5		; Guarda IY
	ldy	<reg_IX								; 	PUSH IX			 ; 9D55 DD E5		; Guarda IX
	pshs	x,y,u			; save them				; 	PUSH HL			 ; 9D57 E5		; Guarda HL
	jsr	GetObjPointer2IX	; get object pointer (character)	; 	CALL GetObjPointer2IX	 ; 9D58 CD CA 9B	; llama GetObjPointer2IX(A)
	ldb	1,y			; get char container
	stb	<reg_B			; save it in reg_B			; 	LD B, (IX+$01)		 ; 9D5B DD 46 01	; recupera ID del contenedor del objeto ( $FF)
	ldy	#ObjIndexTable-3	; get obj table pointer			; 	LD IX, ObjIndexTable-$03 ; 9D5E DD 21 60 C0	; apunta a ObjIndexTable-$03
	sty	<reg_IX			; save it
i_9D62	jsr	GetNextObj		; get next object from table		; i_9D62: CALL GetNextObj	 ; 9D62 CD A9 9B	; Llama GetNextObj devuelve puntero al Obj en IY
	beq	i_9D91			; if end of table, exit			; 	JR Z, i_9D91		 ; 9D65 28 2A		; si fin de tabla, sale via i_9D91 (la nica salida de la rutina!)
	ldy	<reg_IY			; get pointer
	cmpa	1,y			; is contained in received object?	; 	CP (IY+$01)		 ; 9D67 FD BE 01	; est este objeto contenido dentro del objeto recibido como parmetro?
	bne	i_9D62			; no, see nect object			; 	JR NZ, i_9D62		 ; 9D6A 20 F6		; no, vuelve a i_9D62, siguiente objeto
	ldb	7,y			; get flags
	bitb	#%00000010		; is it a fluid?			; 	BIT 1, (IY+$07)		 ; 9D6C FD CB 07 4E	; es un fluido?
	beq	i_9D8B			; no, go i_9D8B				; 	JR Z, i_9D8B		 ; 9D70 28 19		; no, salta a i_9D8B
	pshs	a,cc			; save registers			; 	PUSH AF			 ; 9D72 F5		; Guarda AF
	clrb				; 
	stb	16,y			; put NO location			; 	LD (IY+$10), $00	 ; 9D73 FD 36 10 00	; pone 0 en localizacin actual del objeto
	decb				;
	stb	1,y			; put NO container			; 	LD (IY+$01), $FF	 ; 9D77 FD 36 01 FF	; pone $FF en contenedor a dicho objeto
	ldb	7,y			; get flags
	andb	#%01111111		;
	stb	7,y			; set to NO visible			; 	RES 7, (IY+$07)		 ; 9D7B FD CB 07 BE	; Pasa a 0 el bit7 en (IY+$07), lo marca como invisible
	jsr	ShowObjDescription	; show description			; 	CALL ShowObjDescription	 ; 9D7F CD C7 9E	; llama ShowObjDescription
	ldx	#L_B143			; point to message			; 	LD HL, L_B143		 ; 9D82 21 43 B1	; apunta dentro del mensaje"[0x00] evaporate(s|d|ing|es)[0x15]", saltndose el primer cdigo
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; 9D85 CD DD 72	; llama rutina PrintMsg
	puls	a,cc			; restore registers			; 	POP AF			 ; 9D88 F1		; Recupera AF
	bra	i_9D62			; back to next object			; 	JR i_9D62		 ; 9D89 18 D7		; vuelve a i_9D62, otro objeto
i_9D8B	ldb	<reg_B			; get char container			; i_9D8B: LD (IY+$01), B	 ; 9D8B FD 70 01	; le graba como contenedor la ID del contenedor del objeto parmetro
	stb	1,y			; update obj container
	bra	i_9D62			; back to next object			; 	JP i_9D62		 ; 9D8E C3 62 9D	; vuelve a i_9D62
i_9D91	puls	x,y,u			; restore registers			; i_9D91: POP HL		 ; 9D91 E1		; Recupera HL
	sty	<reg_IX								; 	POP IX			 ; 9D92 DD E1		; Recupera IX
	stu	<reg_IY			; update them				; 	POP IY			 ; 9D94 FD E1		; Recupera IY
	clrb				; set Z=1
	rts				; return				; 	RET			 ; 9D96 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#198# --)
L_9D97	ldu	<reg_IX			; guarda				;L_9D97: PUSH IX		 ; 9D97 DD E5		; Guarda IX
	pshs	u			; los tres
	ldu	<reg_IY			; registros				;	PUSH IY			 ; 9D99 FD E5		; Guarda IY
	ldy	<reg_BC			; en el					;	PUSH BC			 ; 9D9B C5		; Guarda BC
	pshs	y,u			; stack
	clr	<reg_B			; limpia reg_B				;	LD B, $00		 ; 9D9C 06 00		; Carga B con $00
	ldy	#ObjIndexTable-3	; apunta 3 antes de ObjIndexTable	;	LD IX, ObjIndexTable-$03 ; 9D9E DD 21 60 C0	; Carga IX con ObjIndexTable - $03
	sty	<reg_IX			; actualiza reg_IX
i_9DA2	jsr	GetNextObj		; recupera siguiente Objeto		;i_9DA2: CALL GetNextObj	 ; 9DA2 CD A9 9B	; Llama a GetNextObj
	beq	i_9DB6			; si fin de tabla, salir via i_9DB6	;	JR Z, i_9DB6		 ; 9DA5 28 0F		; Si Z = 1, Salta a i_9DB6
	ldy	<reg_IY			; recupera reg_IY
	cmpa	1,y			; es A = cdigo del contenedor?		;	CP (IY+$01)		 ; 9DA7 FD BE 01	; Compara A con (IY+$01)
	bne	i_9DA2			; no, vuelve a i_9DA2			;	JR NZ, i_9DA2		 ; 9DAA 20 F6		; Si Z = 0, Salta a i_9DA2
	tst	7,y			; es visible?				;	BIT 7, (IY+$07)		 ; 9DAC FD CB 07 7E	; Esta a 1 el bit 7 de (IY+$07)?
	bpl	i_9DA2			; no, vuelve a i_9DA2			;	JR Z, i_9DA2		 ; 9DB0 28 F0		; Si Z = 1, Salta a i_9DA2
	inc	<reg_B			; incrementa contador			;	INC B			 ; 9DB2 04		; Incrementa B
	bra	i_9DA2			; vuelve a i_9DA2			;	JP i_9DA2		 ; 9DB3 C3 A2 9D	; Salta a i_9DA2
i_9DB6	lda	<reg_B			; recupera contador			;i_9DB6: LD A, B		 ; 9DB6 78		; Carga A con B
	puls	u,y			; recupera				;	POP BC			 ; 9DB7 C1		; Recupera BC
	sty	<reg_BC			; los tres
	stu	<reg_IY			; registros				;	POP IY			 ; 9DB8 FD E1		; Recupera IY
	puls	y			; del					;	POP IX			 ; 9DBA DD E1		; Recupera IX
	sty	<reg_IX			; stack
	rts				; retorna				;	RET			 ; 9DBC C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; FindPointer						
										; 							;	Descripcin
										; 							;		Bsqueda de un puntero en una tabla, de acuerdo al cdigo introducido
										; 							;		Esta rutina es genrica y sirve para explorar tablas cuyos elementos tienen
										; 							;		3 bytes
										; 							;			Byte 0 - Cdigo del puntero
										; 							;			Byte 1 - Byte bajo del puntero
										; 							;			Byte 2 - Byte alto del puntero
										; 							;		Las tablas deben terminar con $FF
										; 							;	Parmetros de Entrada
										; 							;		A - Cdigo de bsqueda
										; 							;		IX - Inicio de la Tabla
										; 							;	Parmetros de Salida
										; 							;		IX - Direcin del Byte bajo del puntero
										; 							;		Z = 1 si no se encontro el valor (se lleg al $FF fin de tabla)
										; 							;------------------------------------------------------------------------------------
										; 							; antes ; (#82# OK)
FindPointer									; FindPointer: 						; si encontrado devuelve C=1
										; 	EXX			 ; 9DBD D9		; Intercambia BC, DE, HL con BC', DE', HL'
										; 	PUSH IX			 ; 9DBE DD E5		; pasa IX
										; 	POP HL			 ; 9DC0 E1		; a HL
	pshs	a			; pone A en el stack			; 	LD B, A			 ; 9DC1 47		; B = A, Pasa el cdigo a buscar a B
										; 	LD E, $03		 ; 9DC2 1E 03		; E = 3, busca de 3 en 3 bytes
	ldy	<reg_IX								; 	LD D, $00		 ; 9DC4 16 00		; D = 0, byte alto a cero, DE=$0003
i_9DC6	lda	,y			; lee un cdigo de la tabla		; i_9DC6: LD A, (HL)		 ; 9DC6 7E		; A = (HL), lee un cdigo de la tabla
	cmpa	,s			; es el buscado?			; 	CP B			 ; 9DC7 B8		; Compara con B, Es el buscado?
	beq	i_9DD2			; si, sale via i_9DD2			; 	JR Z, i_9DD2		 ; 9DC8 28 08		; Si es igual salta mas abajo a LOOP_9DD2, Cdigo encontrado
	cmpa	#$FF			; es fin de tabla?			; 	CP $FF			 ; 9DCA FE FF		; Si no, Cdigo an no encontrado, Compara el cdigo leido en A con $FF, fin de tabla
	beq	i_9DD2			; si, sale via i_9DD2			; 	JR Z, i_9DD2		 ; 9DCC 28 04		; Si es igual salta mas abajo a LOOP_9DD2, Cdigo NO encontrado, Fin de la tabla
	leay	3,y			; pasa a siguiente entrada		; 	ADD HL, DE		 ; 9DCE 19		; Si no, adiciona 3 bytes al apuntador
	bra	i_9DC6			; vuelve a i_9DC6			; 	JP i_9DC6		 ; 9DCF C3 C6 9D	; bucle a leer siguiente entrada
i_9DD2	leas	1,s			; quita A del stack			; i_9DD2: PUSH HL		 ; 9DD2 E5		; pasa HL
	sty	<reg_IX			; guarda puntero en reg_IX		; 	POP IX			 ; 9DD3 DD E1		; a IX (resultado)
	cmpa	#$FF			; es final de tabla? actualiza flags	; 	CP $FF			 ; 9DD5 FE FF		; Compara A con $FF (Nuevamente, para activar Z = 1 => fin de tabla)
										; 							; adems si encontrado provoca desbordamiento, luega sale con C=1
										; 	EXX			 ; 9DD7 D9		; Intercambia BC, DE, HL con BC', DE', HL'
ePWord	rts				; retorna				; 	RET			 ; 9DD8 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SearchValidObjectByName								; SearchValidObjectByName:				; devuelve cdigo de Objeto o bien $FF (fin de tabla) ; (#140# --)
	ldu	<reg_BC			; recupera reg_BC			; 	PUSH BC			 ; 9DD9 C5		; Guarda BC
	pshs	u			; guarda U(BC)
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; 9DDA D5		; Guarda DE
	ldy	<reg_IY			; recupera reg_IY
	pshs	y,u			; guarda U(DE),Y(IY)			; 	PUSH IY			 ; 9DDB FD E5		; Guarda IY
	ldy	ObjectPointer		; recupera ObjectPointer		; 	LD IY, (ObjectPointer)	 ; 9DDD FD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IY			; actualiza reg_IY
	lda	16,y			; recupera localizacin del objeto	; 	LD D, (IY+$10)		 ; 9DE1 FD 56 10	; recupera localizacin del Objeto
	ldb	L_B710			; recupera L_B710			; 	LD A, (L_B710)		 ; 9DE4 3A 10 B7	; recupera L_B710 (bits 2 y 3 de ActionFlags2)
	std	<reg_DE			; guarda A:B en reg_DE			; 	LD E, A			 ; 9DE7 5F		; lo guarda en E
i_9DE8	jsr	GetNextObjAndID		; llama GetNextObjAndID			; i_9DE8: CALL GetNextObjAndID	 ; 9DE8 CD 93 9B	; Llama a GetNextObjAndID(IX), puntero en IY, ID en A
	beq	i_9E1D			; si devuelve 0, salta a L_9E1D		; 	JR Z, i_9E1D		 ; 9DEB 28 30		; si fin de tabla, sale via i_9E1D con Z=1
	lda	#2			; toma valor 2				; 	LD A, $02		 ; 9DED 3E 02		; Carga A con $02
	cmpa	<reg_E			; es reg_E = 2?				; 	CP E			 ; 9DEF BB		; L_B710 = 2? Esto es falso si la accin no es drop, untie o carry
	beq	i_9E01			; si, salta a i_9E01			; 	JR Z, i_9E01		 ; 9DF0 28 0F		; si, salta a i_9E01
	ldy	<reg_IY			; recupera reg_IY
	lda	7,y			; recupera flags			; 	LD A, (IY+$07)		 ; 9DF2 FD 7E 07	; recupera byte 7 (flags)
	anda	#%01001000		; deja bits 6 y 3 (animal, muerto resp) ; 	AND $48			 ; 9DF5 E6 48		; %0100 1000 = bits 6(animal) y 3(muerto)
	cmpa	#%01000000		; es animal?				; 	CP $40			 ; 9DF7 FE 40		; es animal?
	pshs	cc			; guarda flags
	clra				; A=0					; 	LD A, $00		 ; 9DF9 3E 00		; A = 0
	puls	cc			; recupera flags
	bne	i_9DFE			; si es animal, salta siguiente		; 	JR NZ, i_9DFE		 ; 9DFB 20 01		; si es animal, se salta instruccin siguiente
	inca				; A=1					; 	INC A			 ; 9DFD 3C		; A = 1
i_9DFE	cmpa	<reg_E			; es reg_E = A?				; i_9DFE: CP E			 ; 9DFE BB		; L_B710 = A?
										; 							; Bsicamente si estamos haciendo attack, follow, throw through (?), capture, talk to o shoot
										; 							; hablamos de un animal que est vivo o no nos vale
	bne	i_9DE8			; no, vuelve a i_9DE8			; 	JR NZ, i_9DE8		 ; 9DFF 20 E7		; no, vuelve a i_9DE8 (siguiente objeto)
i_9E01	ldy	<reg_IY			; recupera reg_IY			; i_9E01: LD BC, $0008		 ; 9E01 01 08 00	; Carga BC con $0008
	pshs	y			; guarda Y(IY)				; 	PUSH IY			 ; 9E04 FD E5		; Guarda IY
	leay	8,y			; le suma 8				; 	ADD IY, BC		 ; 9E06 FD 09		; apunta a sustantivo descripcin objeto (primera palabra)
	sty	<reg_IY			; actualiza reg_IY
	jsr	DoesActionMatch		; llama DoesActionMatch			; 	CALL DoesActionMatch	 ; 9E08 CD F3 71	; llama DoesActionMatch (Valida sustantivo y adjetivos)
	tfr	cc,b			; guarda flags resultado en B
	puls	y			; recupera Y(IY)			; 	POP IY			 ; 9E0B FD E1		; Recupera IY
	sty	<reg_IY			; lo guarda en reg_IY
	tfr	b,cc			; recupera flags de B
	bne	i_9DE8			; si no es 0, vuelve a i_9DE8		; 	JR NZ, i_9DE8		 ; 9E0D 20 D9		; si no cuadraron las palabras, vuelve a i_9DE8 (siguiente objeto)
	ldy	<reg_IX			; recupera reg_IX
	lda	L_B70F			; recupera L_B70F			; 	LD A, (L_B70F)		 ; 9E0F 3A 0F B7	; recupera L_B70F
										; 	AND A			 ; 9E12 A7		; es 0?
	bne	i_9E1D			; si no es 0, salta a i_9E1D		; 	JR NZ, i_9E1D		 ; 9E13 20 08		; no, sale via i_9E1D con Z=0
	lda	,y			; recupera ID objeto			; 	LD A, (IX+$00)		 ; 9E15 DD 7E 00	; recupera cdigo del objeto
	jsr	ReachesItBilbo		; llama ReachesItBilbo			; 	CALL ReachesItBilbo	 ; 9E18 CD 34 9E	; Llama ReachesItBilbo
	beq	i_9DE8			; si devuelve 0, vuelve a i_9DE8	; 	JR Z, i_9DE8		 ; 9E1B 28 CB		; si no alcanzable, vuelve a i_9DE8 (siguiente objeto)
i_9E1D	lda	,y			; recupera ID ojeto			; i_9E1D: LD A, (IX+$00)	 ; 9E1D DD 7E 00	; recupera cdigo del objeto  $FF
	puls	y,u			; recupera Y(IY),U(DE)			; 	POP IY			 ; 9E20 FD E1		; Recupera IY
	sty	<reg_IY			; actualiza reg_IY			; 	POP DE			 ; 9E22 D1		; Recupera DE
	stu	<reg_DE			; actualiza reg_DE			
	puls	u			; recupera U(BC)			; 	POP BC			 ; 9E23 C1		; Recupera BC
	stu	<reg_BC			; actualiza reg_BC
	rts				; retorna				; 	RET			 ; 9E24 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#161# --)
L_9E25	jsr	SwapIXwithIY		; swap pointers				; L_9E25: CALL SwapIXwithIY	 ; 9E25 CD 2B 9E	; llama SwapIXwithIY
	jsr	ObjectsSameLoc		; test if are in same location		; 	CALL ObjectsSameLoc	 ; 9E28 CD 40 9E	; Llama a ObjectsSameLoc
	pshs	cc			; preserve flags (result)
	jsr	SwapIXwithIY		; swap pointers	
	puls	cc,pc			; restore flags and return
SwapIXwithIY									; SwapIXwithIY:						; Intercambia IX con IY ; antes ; (#235# --)
	ldu	<reg_IX			; get reg_IX				; 	PUSH IX			 ; 9E2B DD E5		; Guarda IX
	ldy	<reg_IY			; get reg_IY				; 	PUSH IY			 ; 9E2D FD E5		; Guarda IY
	sty	<reg_IX			; put IY into IX			; 	POP IX			 ; 9E2F DD E1		; Recupera IX
	stu	<reg_IY			; put IX into IY			; 	POP IY			 ; 9E31 FD E1		; Recupera IY
	rts				; return				; 	RET			 ; 9E33 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Detecta si un objeto es alcanzable por Bilbo ; antes ; (-13-)
										; 							; params entrada: IX puntero a objeto - A = cdigo de dicho objeto
ReachesItBilbo									; ReachesItBilbo: 					; retorna flag Z=0 si es alcanzable
	ldy	<reg_IX			; recupera reg_IX
	pshs	y			; lo guarda				; 	PUSH IX			 ; 9E34 DD E5		; Guarda IX
	ldy	ObjectPointer		; recupera ObjectPointer		; 	LD IX, (ObjectPointer)	 ; 9E36 DD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IX			; actualiza reg_IX
	jsr	ObjectsSameLoc		; llama ObjectsSameLoc			; 	CALL ObjectsSameLoc	 ; 9E3A CD 40 9E	; Llama a ObjectsSameLoc
	tfr	cc,b
	puls	y			; recupera Y(IX)			; 	POP IX			 ; 9E3D DD E1		; Recupera IX
	sty	<reg_IX			; lo guarda en reg_IX
	tfr	b,cc
eRB	rts				; retorna				; 	RET			 ; 9E3F C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; verifica si dos objetos estan en la misma localizacin  ; antes ; (-14-)
										; 							; Params entrada: punteros a objetos = IX, IY. A contiene codigo objeto de IX
ObjectsSameLoc									; ObjectsSameLoc:					; Retorna flag Z=0 si estan en la misma localizacin
	ldy	<reg_IY			; recupera reg_IY
	ldb	7,y			; get (Y+7)
	bitb	#%10000000		; has bit7 set?				; 	BIT 7, (IY+$07)		 ; 9E40 FD CB 07 7E	; est a 1 el bit 7 de (IY+7)?
	beq	eRB			; no, exit				; 	RET Z			 ; 9E44 C8		; no, retorna con Z=1
	pshs	y			; guarda Y(IY)				; 	PUSH IY			 ; 9E45 FD E5		; Guarda IY
	ldy	<reg_IX			; recupera reg_IX
	pshs	y			; guarda Y(IX)				; 	PUSH IX			 ; 9E47 DD E5		; Guarda IX
	ldu	<reg_BC			; recupera reg_BC
	pshs	u			; guarda U(BC)				; 	PUSH BC			 ; 9E49 C5		; Guarda BC
	sta	<reg_B			; guarda A en reg_B			; 	LD B, A			 ; 9E4A 47		; guarda A en B
	ldb	16,y			; pone byte (Y+16) - localizacin
	stb	<reg_C			; en reg_C				; 	LD C, (IX+$10)		 ; 9E4B DD 4E 10	; C = localizacin actual del objeto
	ldy	<reg_IY			; recupera reg_IY
	pshs	y			; lo guarda				; 	PUSH IY			 ; 9E4E FD E5		; Guarda IY
	jsr	GetTopContainerID	; llama	GetTopContainerID		; 	CALL GetTopContainerID	 ; 9E50 CD 7A 9E	; llama GetTopContainerID devuelve en A el contenedor mas externo
	cmpa	<reg_B			; es A = reg_B?				; 	CP B			 ; 9E53 B8		; es el mismo objeto recibido en A como parametro?
	tfr	cc,b			; guarda flags en B
	sta	<reg_B			; guarda A en reg_B			; 	LD B, A			 ; 9E54 47		; guarda contenedor mas alto nivel en B
	puls	y			; recupera Y/IX)			; 	POP IX			 ; 9E55 DD E1		; Recupera IY en IX
	sty	<reg_IX			; lo guarda en reg_IX
	tfr	b,cc			; estaba flag Z=1?
	beq	i_9E72			; si, salta a i_9E72			; 	JR Z, i_9E72		 ; 9E57 28 19		; si eran iguales, Salta a i_9E72 con Z=1
	jsr	GetTopContainerID	; llama	GetTopContainerID		; 	CALL GetTopContainerID	 ; 9E59 CD 7A 9E	; llama GetTopContainerID devuelve en A el contenedor mas externo
	cmpa	<reg_B			; es A = reg_B?				; 	CP B			 ; 9E5C B8		; tienen ambos (IX, IY) el mismo contenedor de mas alto nivel? 
	bne	i_9E6F			; no, salta a i_9E6F			; 	JR NZ, i_9E6F		 ; 9E5D 20 10		; no, Salir via i_9E6F
	inca				; incrementa A				; 	INC A			 ; 9E5F 3C		; Incrementa ltimo contenedor recibido. Si era $FF ahora sera $00
	bne	i_9E72			; si no es 0, salta a i_9E72		; 	JR NZ, i_9E72		 ; 9E60 20 10		; si antes NO era $FF, Salta a i_9E72 con Z=0
	ldy	<reg_IY			; recupera reg_IY
	ldb	,y			; toma byte (Y+0)			; 	LD B, (IY+$00)		 ; 9E62 FD 46 00	; Carga en B el numero de ubicaciones donde puede accederse al objeto
	lda	<reg_C			; recupera reg_C			; 	LD A, C			 ; 9E65 79		; guarda ubicacin actual en A
i_9E66	cmpa	16,y			; es A = ubicacion objeto?		; i_9E66: CP (IY+$10)		 ; 9E66 FD BE 10	; esta posible ubicacin es la misma actual del objeto?
	beq	i_9E72			; si, salta a i_9E72			; 	JR Z, i_9E72		 ; 9E69 28 07		; Si, Salta a i_9E72 con Z=1
	leay	1,y			; incremeta puntero			; 	INC IY			 ; 9E6B FD 23		; Incrementa IY para acceder a la siguiente ubicacin posible
	sty	<reg_IY			; actualiza reg_IY
	decb				; decrementa contador bucle
	bne	i_9E66			; si no es 0, seguir			; 	DJNZ i_9E66		 ; 9E6D 10 F7		; mientras no sea cero el contador de ubicaciones posibles, repetir comparacin
i_9E6F	clra				; flag Z=1				; i_9E6F: XOR A			 ; 9E6F AF		; A = 0, flag Z = 1
	bra	i_9E74			; salta a i_9E74			; 	JR i_9E74		 ; 9E70 18 02		; se salta la siguiente instruccin
i_9E72	ora	#1			; flag Z=0				; i_9E72: OR $01		 ; 9E72 F6 01		; asegura que bit0 sea 1, flag Z=0
i_9E74	tfr	cc,b			; guarda flags en B
	puls	u			; recupera U(BC)			; i_9E74: POP BC		 ; 9E74 C1		; Recupera BC
	stu	<reg_BC			; lo guarda en reg_BC
	puls	y			; recupera Y(IX)
	sty	<reg_IX			; lo guarda en reg_IX			; 	POP IX			 ; 9E75 DD E1		; Recupera IX
	puls	y			; recupera Y(IY)
	sty	<reg_IY			; lo guarda en reg_IY			; 	POP IY			 ; 9E77 FD E1		; Recupera IY
	tfr	b,cc			; devuelve B a flags
	rts				; retorna				; 	RET			 ; 9E79 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
GetTopContainerID								; GetTopContainerID:					; o devuelve $FF como no contenido en otro objeto. Antes ; (-15-)
	ldy	<reg_IX			; recupera reg_IX
	pshs	y			; lo guarda				; 	PUSH IX			 ; 9E7A DD E5		; Guarda IX
i_9E7C	lda	1,y			; toma byte (Y+1)			; i_9E7C: LD A, (IX+$01)	 ; 9E7C DD 7E 01	; A = (IX+$01)	; Carga el byte 1
	cmpa	#$FF			; es $FF?				; 	CP $FF			 ; 9E7F FE FF		; A = $FF?	; Est contenido en otro objeto? (si = $FF no lo est)
	beq	i_9E92			; si, salta a i_9E92			; 	JR Z, i_9E92		 ; 9E81 28 0F		; Z = 1?	; NO, salir sin recuperar AF'
	jsr	do_exAF_AF		; intercambia AF con AF'		; 	EX AF, AF'		 ; 9E83 08		; AF <-> AF'	; SI, Intercambia el registro AF con su sombra AF'
	lda	1,y			; toma byte (Y+1)			; 	LD A, (IX+$01)		 ; 9E84 DD 7E 01	; A = (IX+$01)	; Carga el byte 1, es el ID del 'contenedor'
	jsr	GetObjPointer2IX	; llama GetObjPointer2IX		; 	CALL GetObjPointer2IX	 ; 9E87 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX (contenedor)
	lda	7,y			; toma byte (IX+7) - flags		; 	LD A, (IX+$07)		 ; 9E8A DD 7E 07	; A = (IX+$07)	; Carga el byte 7 (flags)
	anda	#%00101000		; verifica bits3 y 5			; 	AND $28			 ; 9E8D E6 28		; A = A AND $28	; 00101000b verifica estado bits 3 y 5
	bne	i_9E7C			; si no son 0 ambos, salta a i_9E7C	; 	JR NZ, i_9E7C		 ; 9E8F 20 EB		; Z = 0?	; Si alguno de los dos est a 1, mira si est contenido en otro objeto
	jsr	do_exAF_AF		; intercambia AF con AF'		; 	EX AF, AF'		 ; 9E91 08		; AF <-> AF'	; sino, recupera AF desde su sombra AF'
i_9E92	puls	y			; recupera Y(IX)			; i_9E92: POP IX		 ; 9E92 DD E1		; Recupera IX
	sty	<reg_IX			; lo guarda en reg_IX 
	rts				; retorna				; 	RET			 ; 9E94 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Devuelve puntero 3 bytes antes de la primera salida de la localizacin ; antes ; (-16-)
GetLocExitPtr									; GetLocExitPtr:					; recibe en ObjectPointer el puntero al Objeto 
					; no se usa				; 	PUSH DE			 ; 9E95 D5		; Guarda DE
	jsr	GetLocPtrFromObjPtr	; llama GetLocPtrFromObjPtr		; 	CALL GetLocPtrFromObjPtr ; 9E96 CD 37 9D	; Llama GetLocPtrFromObjPtr(IX)
	ldy	<reg_IX			; recupera reg_IX			; 	LD DE, $0007		 ; 9E99 11 07 00	; con 7 bytes 
	leay	7,y			; le suma 7				; 	ADD IX, DE		 ; 9E9C DD 19		; reposiciona puntero 3 bytes antes de la primera salida
	sty	<reg_IX			; actualiza reg_IX			; 	POP DE			 ; 9E9E D1		; Recupera DE
	rts				; retorna				; 	RET			 ; 9E9F C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; devuelve A con el cdigo de localizacin destino si es vlido o $ff si no se encuentra ; antes ; (#155# --)
										; 							; parametros IX llega apuntando dentro del objeto a subtabla 'exits'
										; 							;            HL apuntando a la zona de la tablaD21 con los punteros a las tres palabras 
SearchValidExitByName								; SearchValidExitByName:				;               de la descripcin (nombre del objeto o localizacin).
	ldu	<reg_IY			; recupera reg_IY 
	pshs	u			; guarda U(IY)				; 	PUSH IY			 ; 9EA0 FD E5		; Guarda IY
					; no se utiliza				; 	PUSH DE			 ; 9EA2 D5		; Guarda DE
										; 	LD DE, $0002		 ; 9EA3 11 02 00	; DE = $0002 (offset de la localizacin de destino en el registro)
i_9EA6	jsr	GetNextObjAndID		; llama GetNextObjAndID			; i_9EA6: CALL GetNextObjAndID	 ; 9EA6 CD 93 9B	; Llama a GetNextObjAndID(IX) - resultados en IY,A. IX+=3 
	beq	i_9EC3			; si da 0, salta a i_9EC3		; 	JR Z, i_9EC3		 ; 9EA9 28 18		; si fin de tabla, sale via i_9EC3 con Z=1
	ldu	<reg_IX			; recupera reg_IX
	lda	2,u			; recupera localizacin de destino	; 	LD A, (IX+$02)		 ; 9EAB DD 7E 02	; recupera (IX+$02) ID de Localizacin de destino 
	pshs	u			; guarda U(IX)				; 	PUSH IX			 ; 9EAE DD E5		; Guarda IX (puntero a registro de la subtabla dentro del Objeto)
	jsr	GetLocPointer2IX	; llama GetLocPointer2IX		; 	CALL GetLocPointer2IX	 ; 9EB0 CD B1 9B	; llama rutina GetLocPointer2IX(A) de la localizacin leida
	ldu	<reg_IX			; recupera reg_IX			; 	PUSH IX			 ; 9EB3 DD E5		; pasa IX (puntero a Ubicacion encontrada)
					; como reg_IY				; 	POP IY			 ; 9EB5 FD E1		; a IY
	puls	y			; recupera Y(IX)			; 	POP IX			 ; 9EB7 DD E1		; Recupera IX (puntero incrementado a la tabla de salidas)
	sty	<reg_IX			; actualiza reg_IX
	leau	2,u			; le suma 2 a U(IY)			; 	ADD IY, DE		 ; 9EB9 FD 19		; IY apunta a sustantivo descriptor Ubicacin
	stu	<reg_IY			; actualiza reg_IY
	jsr	DoesActionMatch		; llama DoesActionMatch			; 	CALL DoesActionMatch	 ; 9EBB CD F3 71	; llama DoesActionMatch (Valida sustantivo y adjetivos) 
	bne	i_9EA6			; si no da 0, vuelve a i_9EA6		; 	JR NZ, i_9EA6		 ; 9EBE 20 E6		; si no cuadran las palabras de la orden, vuelve a i_9EA6 (siguiente objeto)
	ldy	<reg_IX			; recupera reg_IX
	lda	2,y			; toma ID localizacin			; 	LD A, (IX+$02)		 ; 9EC0 DD 7E 02	; Carga A con (IX+$02) recupera ID de localizacin
i_9EC3	puls	u			; recupera U(IY) - DE no se ha usado	; i_9EC3: POP DE		 ; 9EC3 D1		; Recupera DE
	stu	<reg_IY			; actualiza reg_IY			; 	POP IY			 ; 9EC4 FD E1		; Recupera IY
	rts				; retorna				; 	RET			 ; 9EC6 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ShowObjDescription								;ShowObjDescription:					; muestra la descripcin del objeto ; (#206# --)
	ldy	<reg_IY			; guarda reg_IY				;	PUSH IY			 ; 9EC7 FD E5		; Guarda IY
	pshs	y			; en el stack				;	PUSH DE			 ; 9EC9 D5		; Guarda DE
	leay	8,y			; apunta a 1ra palabra desc. objeto	;	LD DE, $0008		 ; 9ECA 11 08 00	; offset a primera palabra descripcin
	sty	<reg_IY			; actualiza reg_IY			;	ADD IY, DE		 ; 9ECD FD 19		; apunta a dicha palabra
	jsr	PrintDescriptionIY	; la imprime				;	CALL PrintDescriptionIY	 ; 9ECF CD D6 9E	; llama PrintDescriptionIY
	puls	y			; recupera reg_IY			;	POP DE			 ; 9ED2 D1		; Recupera DE
	sty	<reg_IY			; del stack				;	POP IY			 ; 9ED3 FD E1		; Recupera IY
	rts				; retorna				;	RET			 ; 9ED5 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; parametro IY apunta a primera palabra del objeto/localizacin (sustantivo)
										; 							; o a la descripcin completa asociada, segn L_B703
PrintDescriptionIY								; PrintDescriptionIY:					; imprime descripcin apuntada por IY ; antes ; (#19# OK) 
	pshs	cc,a			; guarda A y flags			; 	PUSH AF			 ; 9ED6 F5		; guarda AF
	ldu	<reg_DE			; recupera reg_DE
	pshs	u			; guarda U(DE)				; 	PUSH DE			 ; 9ED7 D5		; guarda DE
	lda	L_B703			; recupera L_B703			; 	LD A, (L_B703)		 ; 9ED8 3A 03 B7	; recupera L_B703
										; 	CP $00			 ; 9EDB FE 00		; es 0?
	bne	i_9EFA			; si no es 0, salta a i_9EFA		; 	JR NZ, i_9EFA		 ; 9EDD 20 1B		; no, salta a i_9EFA
	ldy	<reg_IY			; recupera reg_IY			; 	LD D, (IY+$01)		 ; 9EDF FD 56 01	; carga DE 
	ldu	,y			; recupera dos bytes de Y(IY)		; 	LD E, (IY+$00)		 ; 9EE2 FD 5E 00	; con la direccion apuntada por IY 
	stu	<reg_DE			; lo guarda en reg_DE
	jsr	IsDEequalYou		; llama IsDEequalYou			; 	CALL IsDEequalYou	 ; 9EE5 CD 3F 74	; llama IsDEequalYou
	ldy	<reg_IY
	ldu	2,y			; lee 2 bytes siguientes		; 	LD E, (IY+$02)		 ; 9EE8 FD 5E 02	; carga DE 
	stu	<reg_DE			; lo guarda en reg_DE			; 	LD D, (IY+$03)		 ; 9EEB FD 56 03	; con la direccion apuntada por IY+2 
	jsr	PrintWord		; llama PrintWord			; 	CALL PrintWord		 ; 9EEE CD C1 74	; imprime palabra apuntada por DE
	ldy	<reg_IY
	ldu	4,y			; lee 2 bytes siguientes		; 	LD E, (IY+$04)		 ; 9EF1 FD 5E 04	; carga DE 
	stu	<reg_DE			; lo guarda en reg_DE			; 	LD D, (IY+$05)		 ; 9EF4 FD 56 05	; con la direccion apuntada por IY+4 
	jsr	PrintWord		; llama PrintWord			; 	CALL PrintWord		 ; 9EF7 CD C1 74	; imprime palabra apuntada por DE
i_9EFA	ldy	<reg_IY
	ldu	,y			; vuelve a leer los 2 primeros		; i_9EFA: LD E, (IY+$00)	 ; 9EFA FD 5E 00	; carga DE 
	stu	<reg_DE			; lo guarda en reg_DE			; 	LD D, (IY+$01)		 ; 9EFD FD 56 01	; con la direccion apuntada por IY 
	cmpu	#0			; es valor 0?				; 	LD A, D			 ; 9F00 7A		; A recibe el byte alto de la direccion en DE
	beq	a9EFA			; no, salta siguiente			; 	OR E			 ; 9F01 B3		; hace un OR con el byte bajo de la direccion en DE
	jsr	IfNotB703BypassAttr	; llama IfNotB703BypassAttr		; 	CALL NZ, IfNotB703BypassAttr
										; 				 ; 9F02 C4 78 74	; si no es nula la palabra, llama IfNotB703BypassAttr
a9EFA	puls	u			; recupera U(DE)			; 	POP DE			 ; 9F05 D1		; recupera DE
	stu	<reg_DE			; lo guarda en reg_DE
	puls	cc,a,pc			; recupera A, flags y retorna		; 	POP AF			 ; 9F06 F1		; recupera AF
										; 	RET			 ; 9F07 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; busca posibles salidas de la Localizacin ; antes ; (#184# --)
L_9F08	ldu	<reg_BC			; toma reg_BC				;L_9F08: PUSH BC		 ; 9F08 C5		; Guarda BC
	ldy	<reg_IY			; y reg_IY				;	PUSH IY			 ; 9F09 FD E5		; Guarda IY
	pshs	u,y			; los guarda en el stack
	sta	<reg_B			; guarda A en reg_B			;	LD B, A			 ; 9F0B 47		; Carga B con A
	jsr	GetLocExitPtr		; llama GetLocExitPtr			;	CALL GetLocExitPtr	 ; 9F0C CD 95 9E	; llama GetLocExitPtr
i_9F0F	jsr	GetNextObjAndID		; llama	GetNextObjAndID			;i_9F0F: CALL GetNextObjAndID	 ; 9F0F CD 93 9B	; Llama a GetNextObjAndID
	beq	i_9F21			; no hay mas, sale via i_9F21		;	JR Z, i_9F21		 ; 9F12 28 0D		; Si Z = 1, Salta a i_9F21
	ldy	<reg_IX			; apunta a salida
	lda	2,y			; toma localizacion destino		;	LD A, (IX+$02)		 ; 9F14 DD 7E 02	; Carga A con (IX+$02)
										;	AND A			 ; 9F17 A7		; A = A AND A	; Adecua flags
	beq	i_9F0F			; si cero, vuelve a i_9F0F		;	JR Z, i_9F0F		 ; 9F18 28 F5		; Si Z = 1, Salta a i_9F0F
	lda	,y			; toma localizacion origen		;	LD A, (IX+$00)		 ; 9F1A DD 7E 00	; Carga A con (IX+$00)
	cmpa	<reg_B			; es igual a reg_B?			;	CP B			 ; 9F1D B8		; Compara A con B
	bne	i_9F0F			; no, vuelve a i_9F0F			;	JP NZ, i_9F0F		 ; 9F1E C2 0F 9F	; Si Z = 0, Salta a i_9F0F
i_9F21	puls	y,u			; recupera registros			;i_9F21: POP IY			 ; 9F21 FD E1		; Recupera IY
	sty	<reg_IY			; actualiza reg_IY
	stu	<reg_BC			; y reg_BC				;	POP BC			 ; 9F23 C1		; Recupera BC
	rts				; retorna				;	RET			 ; 9F24 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#190# --)
L_9F25	lda	MainObject		; get main object			; L_9F25: LD A, (MainObject)	 ; 9F25 3A E8 B6	; Carga cdigo objeto principal
										; 
										;							; (#207# --)
L_9F28	pshs	a,cc			; save registers			; L_9F28: PUSH AF		 ; 9F28 F5		; Guarda AF
	lda	#$41			; get hexa value to build "lda 1,u"	;	LD A, $01		 ; 9F29 3E 01		; Carga A con $01
	bra	i_9F30			; go modify code			;	JR i_9F30		 ; 9F2B 18 03		; Salta a i_9F30
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#192# --) parece buscar posibles salidas de la Localizacin
										; 							; OJO! Contiene una sentencia que es MODIFICADA
L_9F2D	pshs	a,cc			; save registers			; L_9F2D: PUSH AF		 ; 9F2D F5		; Guarda AF
	lda	#$42			; get hexa value to build "lda 2,u"	; 	LD A, $02		 ; 9F2E 3E 02		; Carga A con $02
i_9F30	sta	D_9F40+$01		; modify code				; i_9F30: LD (D_9F40+$02), A	 ; 9F30 32 42 9F	; pone 'A' como offset en D_9F42
	puls	a,cc			; restore registers			; 	POP AF			 ; 9F33 F1		; Recupera AF
	ldu	<reg_BC			; get pseudo-registers
	ldy	<reg_IY								; 	PUSH BC			 ; 9F34 C5		; Guarda BC
	pshs	y,u			; save them				; 	PUSH IY			 ; 9F35 FD E5		; Guarda IY
	sta	reg_B			; save A to reg_B			; 	LD B, A			 ; 9F37 47		; Carga B con A
	jsr	GetLocExitPtr		; get pointer to exit from Location	; 	CALL GetLocExitPtr	 ; 9F38 CD 95 9E	; llama GetLocExitPtr
i_9F3B	jsr	GetNextObjAndID		; get next object and its ID		; i_9F3B: CALL GetNextObjAndID	 ; 9F3B CD 93 9B	; Llama a GetNextObjAndID
	beq	i_9F46			; if end of table, exit 		; 	JR Z, i_9F46		 ; 9F3E 28 06		; Si Z = 1, Salta a i_9F46
	ldu	<reg_IX			; get pseudo-register
D_9F40	lda	2,u			; get container or volume		; D_9F40: LD A, (IX+$02)	 ; 9F40 DD 7E 02	; recupera (IX+$02) si viene de L_9F2D
										;	; LD A, (IX+$01)				; recupera (IX+$01) si viene de L_9F28
	cmpa	<reg_B			; compare to received value		; 	CP B			 ; 9F43 B8		; Compara A con B
	bne	i_9F3B			; not equal, loopback			; 	JR NZ, i_9F3B		 ; 9F44 20 F5		; Si Z = 0, Salta a i_9F3B
i_9F46	puls	u,y			; restore registers			; i_9F46: POP IY		 ; 9F46 FD E1		; Recupera IY
	sty	<reg_IY			; update them
	stu	<reg_BC								; 	POP BC			 ; 9F48 C1		; Recupera BC
	orcc	#%00000100		; set flag Z=1
	rts				; return				; 	RET			 ; 9F49 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#193# --)
L_9F4A	ldu	MainObjectPtr		; get pointer				; L_9F4A: LD DE, (MainObjectPtr) ; 9F4A ED 5B 08 B7	; Carga MainObjectPtr
	stu	<reg_DE			; save it
	ldy	SecndObjectPtr		; get pointer				; 	LD IY, (SecndObjectPtr)	 ; 9F4E FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save it
	sty	MainObjectPtr		; interchange those			; 	LD (MainObjectPtr), IY	 ; 9F52 FD 22 08 B7	; guarda MainObjectPtr
	stu	SecndObjectPtr		; pointers				; 	LD (SecndObjectPtr), DE	 ; 9F56 ED 53 0A B7	; guarda SecndObjectPtr
	ldd	MainObject		; A=main - B=2nd			; 	LD BC, (MainObject)	 ; 9F5A ED 4B E8 B6	; Carga cdigos objeto principal y objeto secundario
	std	<reg_BC			; save both
	exg	a,b			; interchange them			; 	LD A, B			 ; 9F5E 78		; Carga A con B
	std	MainObject		; in variables 				; 	LD (MainObject), A	 ; 9F5F 32 E8 B6	; guarda cdigo objeto principal
										; 	LD A, C			 ; 9F62 79		; Carga A con C
										; 	LD (SecondObject), A	 ; 9F63 32 E9 B6	; guarda cdigo objeto secundario
	jsr	CallSubrutineHL		; call routine inX(HL)			; 	CALL CallSubrutineHL	 ; 9F66 CD 6C 9B	; llama CallSubrutineHL
	ldd	<reg_BC			; restore registers
	std	MainObject							; 	LD (MainObject), BC	 ; 9F69 ED 43 E8 B6	; recupera cdigos objeto principal y objeto secundario
	ldu	<reg_DE			; restore pointer
	stu	MainObjectPtr							; 	LD (MainObjectPtr), DE	 ; 9F6D ED 53 08 B7	; guarda MainObjectPtr
	ldy	<reg_IY			; restore pointer
	sty	SecndObjectPtr							; 	LD (SecndObjectPtr), IY	 ; 9F71 FD 22 0A B7	; guarda SecndObjectPtr
	rts				; return				; 	RET			 ; 9F75 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
IfB6FAis1DescAction								;IfB6FAis1DescAction:					; Describe la Accin si L_B6FA es 1 ; antes ; (#241# OK) 
	lda	L_B6FA			; recupera L_B6FA			;	LD A, (L_B6FA)		 ; 9F76 3A FA B6	; recupera valor de L_B6FA
	deca				; lo decrementa				;	DEC A			 ; 9F79 3D		; lo decrementa
	lbeq	DescribeActionOnScreen	; si es 0 describe accion		;	JP Z, DescribeActionOnScreen
										;				 ; 9F7A CA 2B 71	; si antes era 1, salta a DescribeActionOnScreen
	clra				; pone valor 0				;	SUB A			 ; 9F7D 97		; pone valor 0
	sta	L_B6FB			; en L_B6FB				;	LD (L_B6FB), A		 ; 9F7E 32 FB B6	; a L_B6FB
	rts				; retorna				;	RET			 ; 9F81 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; recibe en A el cdigo del objeto al que buscar su ubicacin
										;							; Devuelve IX: puntero al Objeto
										;							;           A: Localizacin del objeto, si byte1 del objeto = $01 sin devuelve $FF
GetObjectLocation								;GetObjectLocation:					; antes ; (#160# --)
	cmpa	#$FF			; es $FF el codigo de objeto?		;	CP $FF			 ; 9F82 FE FF		; el objeto es $FF?
	beq	s_gol			; si, sale				;	RET Z			 ; 9F84 C8		; si, salir
	jsr	GetObjPointer2IX	; obtiene puntero a objeto		;	CALL GetObjPointer2IX	 ; 9F85 CD CA 9B	; llama GetObjPointer2IX que devuelve puntero al objeto en IX
	ldd	#$FF01			; A=$FF (no localizacion)		;	LD A, $01		 ; 9F88 3E 01		; valor 1
					; B=num localizaciones esperadas	;	CP (IX+$00)		 ; 9F8A DD BE 00	; tiene un uno en el primer byte el objeto?
	cmpb	,y			; esta en una localizacin?		;	LD A, $FF		 ; 9F8D 3E FF		; valor para devolver "localizacin no encontrada"
	bne	s_gol			; no, sale				;	RET NZ			 ; 9F8F C0		; no tiene un 1, salir
	lda	16,y			; recupera ID de localizacion		;	LD A, (IX+$10)		 ; 9F90 DD 7E 10	; recupera la ubicacin actual del objeto
s_gol	rts				; retorna				;	RET			 ; 9F93 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_9F94	ldu	<reg_IY			; guarda 3 registros			;L_9F94: PUSH IY		 ; 9F94 FD E5		; Guarda IY
	pshs	cc,a,u			; y flags
	ldu	<reg_BC			; en el					;	PUSH AF			 ; 9F96 F5		; Guarda AF
	pshs	u			; stack					;	PUSH BC			 ; 9F97 C5		; Guarda BC
	ldx	#L_B003			; apunta a mensaje			;	LD HL, L_B003		 ; 9F98 21 03 B0	; apunta a mensaje "You see :[0x14]"
	jsr	PrintMsg		; lo imprime				;	CALL PrintMsg		 ; 9F9B CD DD 72	; llama rutina PrintMsg
	lda	#$FF			; toma valor $FF			;	LD A, $FF		 ; 9F9E 3E FF		; Carga A con $FF
	ldy	ObjectPointer		; recupera puntero a objeto		;	LD IY, (ObjectPointer)	 ; 9FA0 FD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IY			; actualiza reg_IY
	ldb	16,y			; recupera localizacin actual		;	LD B, (IY+$10)		 ; 9FA4 FD 46 10	; Carga B con (IY+$10)
	jsr	L_9FAF			; llama L_9FAF				;	CALL L_9FAF		 ; 9FA7 CD AF 9F	; Llama a (-09-)
	puls	u			; recupera los 3 			;	POP BC			 ; 9FAA C1		; Recupera BC
	stu	<reg_BC			; registros				;	POP AF			 ; 9FAB F1		; Recupera AF
	puls	cc,a,y			; y flags
	sty	<reg_IY			; del stack				;	POP IY			 ; 9FAC FD E1		; Recupera IY
	rts				; retorna				;	RET			 ; 9FAE C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (-09-) 
L_9FAF	ldu	<reg_IY			; guarda				;L_9FAF: PUSH IY		 ; 9FAF FD E5		; Guarda IY
	pshs	u			; tres
	ldu	<reg_DE			; registros				;	PUSH DE			 ; 9FB1 D5		; Guarda DE
	ldy	<reg_BC			; en el					;	PUSH BC			 ; 9FB2 C5		; Guarda BC
	pshs	y,u			; stack
	clr	<reg_C			; a 0 reg_C				;	LD C, $00		 ; 9FB3 0E 00		; C = 0
	ldb	#4			; pone valor 4				;	LD D, $04		 ; 9FB5 16 04		; D = 4
	stb	<reg_D			; en reg_D
	jsr	L_9FC7			; llama L_9FC7				;	CALL L_9FC7		 ; 9FB7 CD C7 9F	; Llama a (-10-)
	ldx	#L_B33B			; apunta a mensaje			;	SUB A			 ; 9FBA 97		; A = A - A	; Borra A ?
	tst	<reg_C			; mira estado reg_C			;	CP C			 ; 9FBB B9		; A = C?
	bne	e9FAF			; si reg_C no es 0, salta siguiente	;	LD HL, L_B33B		 ; 9FBC 21 3B B3	; HL = L_B33B	; apunta a mensaje "      {6} nothing"
	jsr	PrintMsg		; imprime mensaje			;	CALL Z, PrintMsg	 ; 9FBF CC DD 72	; si es cero, llama rutina PrintMsg
e9FAF	puls	y,u			; recupera				;	POP BC			 ; 9FC2 C1		; Recupera BC
	sty	<reg_BC			; tres
	stu	<reg_DE			; registros				;	POP DE			 ; 9FC3 D1		; Recupera DE
	puls	y			; del					;	POP IY			 ; 9FC4 FD E1		; Recupera IY
	sty	<reg_IY			; stack
	rts				; retorna				;	RET			 ; 9FC6 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (-10-)
L_9FC7	pshs	x			; guarda registro			;L_9FC7: PUSH HL		 ; 9FC7 E5		; Guarda HL
	sta	<reg_L			; guarda A en reg_L			;	LD L, A			 ; 9FC8 6F		; L = A		; Guarda A en L
	lda	L_869F			; pasa L_869F				;	LD A, (L_869F)		 ; 9FC9 3A 9F 86	; A = (L_869F)	; Zona de datos temporal (-D03-)
	sta	<reg_H			; a reg_H				;	LD H, A			 ; 9FCC 67		; H = A
	lda	<reg_D			; pasa reg_D				;	LD A, D			 ; 9FCD 7A		; A = D
	sta	L_869F			; a L_869F				;	LD (L_869F), A		 ; 9FCE 32 9F 86	; (L_869F) = A	; Zona de datos temporal (-D03-)
	lda	<reg_L			; recupera A de reg_L			;	LD A, L			 ; 9FD1 7D		; A = L
	ldx	<reg_HL			; recupera reg_HL
	ldu	,s			; recupera valor del stack (X recibido)
	exg	u,x			; lo intercambia con X actual
	stu	,s			; pasa valor actual de X(HL) al stack  	;	EX (SP), HL		 ; 9FD2 E3		; (SP) <-> HL	; Intercambia el contenido de (SP) <-> HL
	ldy	<reg_IX			; guarda reg_IX
	pshs	y			; en el stack				;	PUSH IX			 ; 9FD3 DD E5		; Guarda IX
	ldy	#ObjIndexTable-3	; apunta 3 bytes antes de ObjIndexTable	;	LD IX, ObjIndexTable-$03 ; 9FD5 DD 21 60 C0	; IX = $C060
	sty	<reg_IX			; actualiza reg_IX
i_9FD9	jsr	GetNextObj		; obtiene siguiente objeto		;i_9FD9: CALL GetNextObj	 ; 9FD9 CD A9 9B	; llama a GetNextObj
	lbeq	L_A046			; si OK, sale via L_A046		;	JR Z, L_A046		 ; 9FDC 28 68		; Z = 1?	; Si, Salta a L_A046  llama a (-17-)
	ldy	<reg_IY			; recupera reg_IY
	cmpa	1,y			; es A = cdigo del contenedor?		;	CP (IY+$01)		 ; 9FDE FD BE 01	; A = (IY)?
	bne	i_9FD9			; no, volver a i_9FD9			;	JR NZ, i_9FD9		 ; 9FE1 20 F6		; Z = 0?	; Si, Salta a i_9FD9 (repite)
	pshs	cc,a			; guarda A y flags			;	PUSH AF			 ; 9FE3 F5		; Guarda AF
	ldb	,y			; numero de localizaciones objeto	;	INC A			 ; 9FE4 3C		; A = A + 1	; Incrementa A
	stb	<reg_E			; lo guarda en reg_E			
	inca				; incrementa A				;	LD E, (IY+$00)		 ; 9FE5 FD 5E 00	; E = (IY+$00)
	bne	i_9FEF			; si no es 0, salta a i_9FEF		;	JR NZ, i_9FEF		 ; 9FE8 20 05		; Z = 0?	; Si a no es cero, Salta a i_9FEF
	lda	#1			; toma valor 1				;	LD A, $01		 ; 9FEA 3E 01		; A = 1
	cmpa	<reg_E			; es 1 reg_E?				;	CP E			 ; 9FEC BB		; A = E?	; E es igual a 1?
	bne	i_A03D			; no, salta a i_A03D			;	JR NZ, i_A03D		 ; 9FED 20 4E		; Z = 0?	; Si E no es 1, Salta a i_A03D (Salir)
i_9FEF	lda	16,y			; toma localizacin actual		;i_9FEF: LD A, (IY+$10)		 ; 9FEF FD 7E 10	; A = (IY+$10)	; A = al objeto 10
	cmpa	<reg_B			; es igual a reg_B?			;	CP B			 ; 9FF2 B8		; A = B?
	beq	i_9FFE			; si, salta a i_9FFE			;	JR Z, i_9FFE		 ; 9FF3 28 09		; Z = 1?	; Si son distintos, Salta a i_9FFE
	dec	<reg_E			; decrementa reg_E			;	DEC E			 ; 9FF5 1D		; E = E - 1
	beq	i_A03D			; si es 0, salta a i_A03D		;	JR Z, i_A03D		 ; 9FF6 28 45		; Z = 1?	; Si E = 0?, Salta a i_A03D (Salir)
	lda	17,y			; toma siguiente localizacin		;	LD A, (IY+$11)		 ; 9FF8 FD 7E 11	; A = (IY+$11)	; A = al objeto 11
	cmpa	<reg_B			; es igual a reg_B?			;	CP B			 ; 9FFB B8		; A = B?
	bne	i_A03D			; no, salta a i_A03D			;	JR NZ, i_A03D		 ; 9FFC 20 3F		; Z = 0?	; Si son distintos, Salta a i_A03D (Salir)
i_9FFE	lda	ActionActor		; toma ActionActor			;i_9FFE: LD A, (ActionActor)	 ; 9FFE 3A EA B6	; carga ActionActor
	ldy	<reg_IX			; recupera reg_IX
	cmpa	,y			; es A igual a cdigo objeto		;	CP (IX+$00)		 ; A001 DD BE 00	; A = (IX+$00)?
	bne	i_A00B			; no, salta a i_A008			;	JR NZ, i_A00B		 ; A004 20 05		; Z = 0?	; Si, Salta a i_A00B
	lda	#4			; toma valor 4				;	LD A, $04		 ; A006 3E 04		; A = 4
	cmpa	<reg_D			; es reg_D igual a 4?			;	CP D			 ; A008 BA		; A(4) = D?	; D = 4?
	beq	i_A03D			; si, salta a i_A03D			;	JR Z, i_A03D		 ; A009 28 32		; Z = 1?	; Si, Salta a i_A03D (Salir)
i_A00B	lda	,y			; recupera cdigo objeto		;i_A00B: LD A, (IX+$00)		 ; A00B DD 7E 00	; A = (IX+$00)
	jsr	ReachesItBilbo		; puede tomarlo Bilbo?			;	CALL ReachesItBilbo	 ; A00E CD 34 9E	; Llama a ReachesItBilbo
	beq	i_A03D			; no, salta a i_A03D			;	JR Z, i_A03D		 ; A011 28 2A		; Si Z = 1, Salta a i_A03D
	inc	<reg_C			; incrementa reg_C			;	INC C			 ; A013 0C		; Incrementa C
	clra				; pone valor 0				;	SUB A			 ; A014 97		; Resta A de A
	sta	L_B704			; en L_B704				;	LD (L_B704), A		 ; A015 32 04 B7	; Carga (L_B704) con A
	sta	L_B703			; y en L_B703				;	LD (L_B703), A		 ; A018 32 03 B7	; Carga (L_B703) con A
	jsr	ShowObjDescription	; muestra descripcin objeto		;	CALL ShowObjDescription	 ; A01B CD C7 9E	; llama ShowObjDescription
	ldy	<reg_IX
	lda	ActionActor		; toma ActionActor			;	LD A, (ActionActor)	 ; A01E 3A EA B6	; Carga ActionActor
	cmpa	,y			; coincide con el objeto?		;	CP (IX+$00)		 ; A021 DD BE 00	; Compara A con (IX+$00)
	beq	i_A041			; si, sale via i_A041			;	JR Z, i_A041		 ; A024 28 1B		; Si Z = 1, Salta a i_A041
	lda	#$2E			; toma ASCII de '.'			;	LD A, $2E		 ; A026 3E 2E		; Carga A con $2E
	jsr	PutChar			; lo imprime				;	CALL PutChar		 ; A028 CD 8B 85	; llama rutina PutChar
	ldy	<reg_IX
	lda	,y			; toma cdigo objeto			;	LD A, (IX+$00)		 ; A02B DD 7E 00	; Carga A con (IX+$00)
	jsr	L_A050			; llama L_A050				;	CALL L_A050		 ; A02E CD 50 A0	; llama rutina L_A050 (#200# --)
	bcs	i_A03D			; si error, salta a i_A03D		;	JR C, i_A03D		 ; A031 38 0A		; Si C = 1, Salta a i_A03D
	ldy	<reg_IX
	lda	,y			; toma cdigo objeto			;	LD A, (IX+$00)		 ; A033 DD 7E 00	; Carga A con (IX+$00)
	ldu	<reg_DE			; guarda reg_DE							
	pshs	u			; en el stack				;	PUSH DE			 ; A036 D5		; Guarda DE
	inc	<reg_D			; le suma 2				;	INC D			 ; A037 14		; Incrementa D
	inc	<reg_D			; a reg_D				;	INC D			 ; A038 14		; Incrementa D
	jsr	L_9FC7			; llama L_9FC7				;	CALL L_9FC7		 ; A039 CD C7 9F	; Llama a (-10-)
	puls	u			; recupera reg_DE			;	POP DE			 ; A03C D1		; Recupera DE
	stu	<reg_DE			; del stack
i_A03D	puls	a,cc			; recupera A y flags			;i_A03D: POP AF			 ; A03D F1		; Recupera AF
	lbra	i_9FD9			; vuelve a i_9FD9			;	JP i_9FD9		 ; A03E C3 D9 9F	; Salta a i_9FD9
i_A041	jsr	PutEnter		; imprime Enter				;i_A041: CALL PutEnter		 ; A041 CD 83 85	; llama rutina PutEnter
	bra	i_A03D			; salta a i_A03D			;	JR i_A03D		 ; A044 18 F7		; Salta a i_A03D
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (-17-)	;
L_A046	puls	u			; recupera reg_IX			;L_A046: POP IX			 ; A046 DD E1		; Recupera IX
	stu	<reg_IX			; del stack
	ldu	,s			; recupera valor del stack (S)
	exg	u,x			; lo intercambia con X(HL)
	stu	,s			; pasa valor de X(HL) al stack	  	;	EX (SP), HL		 ; A048 E3		; (SP) <-> HL	; Intercambia el contenido de (SP) con HL
	tfr	x,d			; A contiene H, B contiene L		;	LD A, H			 ; A049 7C		; A = B
	sta	L_869F			; guarda H en L_869F			;	LD (L_869F), A		 ; A04A 32 9F 86	; (L_869F) = A	; 
	tfr	b,a			; copia L en A				;	LD A, L			 ; A04D 7D		; A = L		;
	puls	x,pc			; recupera X y retorna			;	POP HL			 ; A04E E1		; Recupera HL
										;	RET			 ; A04F C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#200# --)
L_A050	ldu	<reg_IX			; guarda				;L_A050: PUSH IX		 ; A050 DD E5		; Guarda IX
	pshs	u			; tres
	ldu	<reg_BC			; registros				;	PUSH BC			 ; A052 C5		; Guarda BC
	ldy	<reg_DE			; en el					;	PUSH DE			 ; A053 D5		; Guarda DE
	pshs	y,u			; stack
	sta	<reg_C			; guarda A en reg_C			;	LD C, A			 ; A054 4F		; Carga C con A
	jsr	GetObjPointer2IX	; obtiene puntero a objeto en Y		;	CALL GetObjPointer2IX	 ; A055 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	lda	7,y			; recupera flags			;	LD A, (IX+$07)		 ; A058 DD 7E 07	; Carga A con (IX+$07)
	anda	#%00101000		; mira bits 3,5 (muerto-abierto)	;	AND $28			 ; A05B E6 28		; Hace AND lgico de A con $28
	beq	i_A097			; si ninguno a 1, salta a i_A097	;	JR Z, i_A097		 ; A05D 28 38		; Si Z = 1, Salta a i_A097
	lda	<reg_C			; recupera A de reg_C			;	LD A, C			 ; A05F 79		; Carga A con C
	jsr	L_9D97			; llama L_9D97				;	CALL L_9D97		 ; A060 CD 97 9D	; llama rutina L_9D97 (#198# --)
	tsta				; actualiza flags			;	CP $00			 ; A063 FE 00		; Compara A con $00
	beq	i_A097			; si Z=1, salta a i_A097		;	JR Z, i_A097		 ; A065 28 30		; Si Z = 1, Salta a i_A097
	ldb	7,y			; toma flags				;	BIT 6, (IX+$07)		 ; A067 DD CB 07 76	; Esta a 1 el bit 6 de (IX+$07)?
	bitb	#%01000000		; bit 6 a 1(animal)?
	beq	i_A074			; no, objeto, salta a i_A074		;	JR Z, i_A074		 ; A06B 28 07		; Si Z = 1, Salta a i_A074
	lda	<reg_C			; recupera A de reg_C			;	LD A, C			 ; A06D 79		; Carga A con C
	pshs	a,cc			; guarda A y flags			;	PUSH AF			 ; A06E F5		; Guarda AF
	ldx	#L_ADF9			; apunta a mensaje			;	LD HL, L_ADF9		 ; A06F 21 F9 AD	; apunta a mensaje "[0x13] carrying[0x14]"
	bra	i_A08E			; salta a i_A08E			;	JR i_A08E		 ; A072 18 1A		; Salta a i_A08E
i_A074	ldx	#$039B			; apunta a palabra 'IS'			;i_A074: LD HL, $039B		 ; A074 21 9B 03	; Carga HL con $039B
	deca				; decrementa A				;	DEC A			 ; A077 3D		; Decrementa A
	beq	i_A07D			; si 0, salta siguiente			;	JR Z, i_A07D		 ; A078 28 03		; Si Z = 1, Salta a i_A07D
	ldx	#$0065			; apunta a palabra 'ARE'		;	LD HL, $0065		 ; A07A 21 65 00	; Carga HL con $0065
i_A07D	pshs	x			; pasa puntero al stack			;i_A07D: PUSH HL		 ; A07D E5		; Guarda HL
	ldd	8,y			; apunta a 1a palabra descripcion	;	LD L, (IX+$08)		 ; A07E DD 6E 08	; Carga L con (IX+$08)
										;	LD A, (IX+$09)		 ; A081 DD 7E 09	; Carga A con (IX+$09)
	anda	#$0F			; quita el MODE de la palabra		;	AND $0F			 ; A084 E6 0F		; Hace AND lgico de A con $0F
	tfr	d,x			; lo pasa a X(HL)			;	LD H, A			 ; A086 67		; Carga H con A
	pshs	x			; pasa puntero al stack			;	PUSH HL			 ; A087 E5		; Guarda HL
	jsr	L_A09D			; llama L_A09D				;	CALL L_A09D		 ; A088 CD 9D A0	; Llama a (-08-)
	ldx	#L_AFE0			; apunta a mensaje			;	LD HL, L_AFE0		 ; A08B 21 E0 AF	; apunta a mensaje "[0x01] there[0x01][0x14]"
i_A08E	jsr	PrintMsg		; lo muestra				;i_A08E: CALL PrintMsg		 ; A08E CD DD 72	; llama rutina PrintMsg
	tsta				; actualiza flags			;	AND A			 ; A091 A7		; A = A AND A	; Adecua flags
	andcc	#%11111110		; reset carry flag
i_A092	tfr	cc,b			; los guarda en B
	puls	y,u			; recupera				;i_A092: POP DE			 ; A092 D1		; Recupera DE
	sty	<reg_DE			; los
	stu	<reg_BC			; tres					;	POP BC			 ; A093 C1		; Recupera BC
	puls	y			; registros				;	POP IX			 ; A094 DD E1		; Recupera IX
	sty	<reg_IX			; del stack
	tfr	b,cc			; recupera flags de B
	rts				; retorna				;	RET			 ; A096 C9		; Retorna
i_A097	jsr	PutEnter		; imprime Enter				;i_A097: CALL PutEnter		 ; A097 CD 83 85	; llama rutina PutEnter
	orcc	#%00000001		; pone a 1 el flag de carry		;	SCF			 ; A09A 37		; Pone a 1 el flag C
	bra	i_A092			; salta a i_A092			;	JR i_A092		 ; A09B 18 F5		; Salta a i_A092
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (-08-) 
L_A09D	ldx	#L_AFCA			; apunta a mensaje mltiple		;L_A09D: LD HL, L_AFCA		 ; A09D 21 CA AF	; Apunta a mensaje "in[0x02][0x11] on[0x02][0x0d] behind[0x02][0x09] under[0x02][0x05] tied to the[0x16]"
	ldy	<reg_IX			; recupera reg_IX
	ldb	4,y			; toma preposicion			;	LD A, (IX+$04)		 ; A0A0 DD 7E 04	; A = (IX+$04)	; Carga el byte 4 de OBJ_TABLE en A (preposicin)
	lslb				; multiplica				;	RLCA			 ; A0A3 07		; Rotar Izq. Circular Acumul.
	lslb				; por cuatro				;	RLCA			 ; A0A4 07		; Rotar Izq. Circular Acumul. = multiplicar x 4
	andb	#%00111100		; guarda bits2-5 (offset)		;	AND $3C			 ; A0A5 E6 3C		; A = A AND $3C	; 00111100b solo deja los 4 bits centrales
										;	LD E, A			 ; A0A7 5F		; E = A		; Lo almacena en E
										;	LD D, $00		 ; A0A8 16 00		; D = 0		; Borra D para formar el offset dentro de la pseudo tabla L_AFCA
	abx				; lo suma al puntero			;	ADD HL, DE		 ; A0AA 19		; HL = HL + DE	; Lo suma a HL (Incrementos de 4 en 4) y HL apunta al inicio del menssaje
	jmp	PrintMsg		; imprime el que 'toca'			;	JP PrintMsg		 ; A0AB C3 DD 72	; salta a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#163# --)
L_A0AE	jsr	GetLocPointer2IX	; obtiene puntero a localizacion	;L_A0AE: CALL GetLocPointer2IX	 ; A0AE CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	leay	7,y			; le suma 7 al puntero			;	LD BC, $0007		 ; A0B1 01 07 00	; Carga BC con $0007
	sty	<reg_IX			; actualiza reg_IX			;	ADD IX, BC		 ; A0B4 DD 09		; Adiciona BC en IX
	clr	<reg_B			; reg_B=0				;	LD BC, $0003		 ; A0B6 01 03 00	; Carga BC con $0003
	ldb	#3			; pone valor 3
	stb	<reg_C			; en reg_C
	rts				; retorna				;	RET			 ; A0B9 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SearchMoveWord									;SearchMoveWord:					; Busca palabra para la direccin de movimiento en MoveDirections ; antes ; (#162# --)
	ldx	#MoveDirections-2	; apunta 2 antes de MoveDirections	;	LD HL,MoveDirections-$02 ; A0BA 21 0E A2	; Carga HL con MoveDirections - $02
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; Busca la palabra del estado de un objeto en FalseFlagWord o en TrueFlagWord ; antes ; (#165# --)
										;							; parametros A - offset o cdigo (0-7 si viene directo, 1-10 si viene de SearchMoveWord)
SearchStatusWord								;SearchStatusWord:					; Devuelve  DE - puntero a palabra (sin el $6000) o bien $0000 
	tfr	a,b			; pasa A a B				;	LD E, A			 ; A0BD 5F		; pasa A a E
	andb	#%01111111		; resetea bit 7				;	RES 7, E		 ; A0BE CB BB		; pasa a 0 el bit 7 de E
										;	LD D, $00		 ; A0C0 16 00		; byte alto a 0. DE = Offset  
	abx				; suma B a X(HL)			;	ADD HL, DE		 ; A0C2 19		; suma el Offset
	abx				; dos veces				;	ADD HL, DE		 ; A0C3 19		; dos veces (registros de 2 bytes)
	ldu	,x+			; toma puntero 'apuntado' por X(HL)	;	LD E, (HL)		 ; A0C4 5E		; carga byte bajo
										;	INC HL			 ; A0C5 23		; Incrementa HL
	stu	<reg_DE			; actaliza reg_DE			;	LD D, (HL)		 ; A0C6 56		; carga byte alto. DE = puntero a palabra buscada
	rts				; retorna				;	RET			 ; A0C7 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#217# --)
L_A0C8	ldu	<reg_BC			; guarda				;L_A0C8: PUSH BC		 ; A0C8 C5		; Guarda BC
	ldy	<reg_DE			; cuatro				;	PUSH DE			 ; A0C9 D5		; Guarda DE
	pshs	y,u			; registros
	ldu	<reg_IY			; en					;	PUSH IY			 ; A0CA FD E5		; Guarda IY
	ldy	<reg_IX			; el					;	PUSH IX			 ; A0CC DD E5		; Guarda IX
	pshs	y,u			; stack
	jsr	L_A0AE			; llama L_A0AE				;	CALL L_A0AE		 ; A0CE CD AE A0	; llama rutina L_A0AE (#163# --)
	ldd	<reg_BC			; recupera reg_BC							
	leay	d,y			; lo suma a Y(IX)			;	ADD IX, BC		 ; A0D1 DD 09		; Adiciona BC en IX
	sty	<reg_IX			; actualiza reg_IX			;	PUSH IX			 ; A0D3 DD E5		; Guarda IX
	sty	<reg_IY			; lo copia en reg_IY			;	POP IY			 ; A0D5 FD E1		; Recupera IY
i_A0D7										;i_A0D7: SUB A			 ; A0D7 97		; Resta A de A
	tst	1,y			; verifica cdigo objeto		;	CP (IY+$01)		 ; A0D8 FD BE 01	; Compara A con (IY+$01)
	beq	i_A113			; si es 0, salta a i_A113		;	JR Z, i_A113		 ; A0DB 28 36		; Si Z = 1, Salta a i_A113
	lda	1,y			; recupera cdigo objeto		;	LD A, (IY+$01)		 ; A0DD FD 7E 01	; Carga A con (IY+$01)
	jsr	GetObjPointer2IX	; obtiene puntero en Y			;	CALL GetObjPointer2IX	 ; A0E0 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	tst	7,y			; mira flags				;	BIT 7, (IX+$07)		 ; A0E3 DD CB 07 7E	; Esta a 1 el bit 7 de (IX+$07)?
	beq	i_A113			; si no es visible, salta a i_A113	;	JR Z, i_A113		 ; A0E7 28 2A		; Si Z = 1, Salta a i_A113
	leay	8,y			; apunta 1ra palabra descripcion	;	LD DE, $0008		 ; A0E9 11 08 00	; Carga DE con $0008
	sty	<reg_IX			; guarda reg_IX				;	ADD IX, DE		 ; A0EC DD 19		; Adiciona DE en IX
	pshs	y			; en el stack				;	PUSH IX			 ; A0EE DD E5		; Guarda IX
	ldy	<reg_IY			; recupera reg_IY
	lda	,y			; toma dir movimiento			;	LD A, (IY+$00)		 ; A0F0 FD 7E 00	; Carga A con (IY+$00)
	jsr	SearchMoveWord		; busca texto movimiento		;	CALL SearchMoveWord	 ; A0F3 CD BA A0	; llama SearchMoveWord
	cmpa	#9			; es A igual a 9?			;	CP $09			 ; A0F6 FE 09		; Compara A con $09
	tfr	cc,b			; guarda flags
	bcs	i_A104			; si A < 9, salta a i_A104		;	JR C, i_A104		 ; A0F8 38 0A		; Si C = 1, Salta a i_A104
	ldu	#$07B5			; apunta a palabra 'ABOVE'		;	LD DE, $07B5		 ; A0FA 11 B5 07	; Carga DE con $07B5
	stu	<reg_DE			; lo guarda en reg_DE
	tfr	b,cc			; recupera flags					
	beq	i_A10A			; si A=9, salta a i_A10A		;	JR Z, i_A10A		 ; A0FD 28 0B		; Si Z = 1, Salta a i_A10A
	ldu	#$082B			; apunta a palabra 'BELOW'		;	LD DE, $082B		 ; A0FF 11 2B 08	; Carga DE con $082B
	stu	<reg_DE			; lo guarda en reg_DE
	bra	i_A10A			; salta a i_A10A			;	JR i_A10A		 ; A102 18 06		; Salta a i_A10A
i_A104	ldx	#L_AE17			; apunta a mensaje			;i_A104: LD HL, L_AE17		 ; A104 21 17 AE	; apunta a mensaje "to the[0x16]"
	jsr	PrintMsg		; imprime el mensaje			;	CALL PrintMsg		 ; A107 CD DD 72	; llama rutina PrintMsg
i_A10A	jsr	PrintWord		; imprime palabra			;i_A10A: CALL PrintWord		 ; A10A CD C1 74	; llama rutina PrintWord
	ldx	#L_B013			; apunta a mensaje			;	LD HL, L_B013		 ; A10D 21 13 B0	; apunta a mensaje "there is[0x00][0x14]"
	jsr	PrintMsg		; lo imprime				;	CALL PrintMsg		 ; A110 CD DD 72	; llama rutina PrintMsg
i_A113	ldd	<reg_BC			; recupera reg_BC			;i_A113: ADD IY, BC		 ; A113 FD 09		; Adiciona BC en IY
	ldy	<reg_IY			; recupera reg_IY
	leay	d,y			; los suma
	sty	<reg_IY			; actualiza reg_IY
	lda	#$FF			; toma valor $FF			;	LD A, $FF		 ; A115 3E FF		; Carga A con $FF
	cmpa	,y			; A = num localizaciones?		;	CP (IY+$00)		 ; A117 FD BE 00	; Compara A con (IY+$00)
	bne	i_A0D7			; no, vuelve a i_A0D7			;	JP NZ, i_A0D7		 ; A11A C2 D7 A0	; Si Z = 0, Salta a i_A0D7
	puls	y,u			; recupera				;	POP IX			 ; A11D DD E1		; Recupera IX
	sty	<reg_IX			; los					;	POP IY			 ; A11F FD E1		; Recupera IY
	stu	<reg_IY			; cuatro
	puls	y,u			; registros
	sty	<reg_DE			; del					;	POP DE			 ; A121 D1		; Recupera DE
	stu	<reg_BC			; stack					;	POP BC			 ; A122 C1		; Recupera BC
	rts				; retorna				;	RET			 ; A123 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#164# --)
L_A124	ldy	<reg_IX			; recupera reg_IX			;L_A124: ADD IX, BC		 ; A124 DD 09		; Adiciona BC en IX
	ldd	<reg_BC			; recupera reg_BC
	leay	d,y			; los suma
	sty	<reg_IX			; actualiza reg_IX
	lda	#$FF			; toma valor $FF			;	LD A, $FF		 ; A126 3E FF		; Carga A con $FF
	cmpa	,y			; A = num localizaciones?		;	CP (IX+$00)		 ; A128 DD BE 00	; Compara A con (IX+$00)
	beq	eA124			; si, retorna				;	RET Z			 ; A12B C8		; Z = 1?	; Retorna si es cero
	clra				; valor 0				;	XOR A			 ; A12C AF		; A = A XOR A	; A = 0, borra A, flag Z = 1
	cmpa	1,y			; contenedor = 0?			;	CP (IX+$01)		 ; A12D DD BE 01	; Compara A con (IX+$01)
	bne	L_A124			; no, vuelve a L_A124			;	JR NZ, L_A124		 ; A130 20 F2		; si flag Z=0, bucle a L_A124
	cmpa	,y			; A = num localizaciones?		;	CP (IX+$00)		 ; A132 DD BE 00	; Compara A con (IX+$00)
	beq	L_A124			; si, vuelve a L_A124			;	JR Z, L_A124		 ; A135 28 ED		; si flag Z=1, bucle a L_A124
eA124	rts				; retorna				;	RET			 ; A137 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;							; (#218# --)
L_A138	ldu	<reg_IX			; guarda				;L_A138: PUSH IX		 ; A138 DD E5		; Guarda IX
	ldy	<reg_IY			; los					;	PUSH IY			 ; A13A FD E5		; Guarda IY
	pshs	y,u			; cuatro
	ldu	<reg_DE			; registros				;	PUSH DE			 ; A13C D5		; Guarda DE
	ldy	<reg_BC			; en el					;	PUSH BC			 ; A13D C5		; Guarda BC
	pshs	y,u			; stack
	jsr	L_A0AE			; llama L_A0AE				;	CALL L_A0AE		 ; A13E CD AE A0	; llama rutina L_A0AE (#163# --)
	jsr	L_A124			; llama L_A124				;	CALL L_A124		 ; A141 CD 24 A1	; llama rutina L_A124 (#164# --)
	beq	i_A15D			; si devuelve 0, sale via i_A15D	;	JR Z, i_A15D		 ; A144 28 17		; Si Z = 1, Salta a i_A15D
	ldx	#L_B020			; apunta a mensaje			;	LD HL, L_B020		 ; A146 21 20 B0	; apunta a mensaje "visible exits are:[0x16]"
	jsr	PrintMsg		; lo imprime				;	CALL PrintMsg		 ; A149 CD DD 72	; llama rutina PrintMsg
i_A14C	ldy	<reg_IX			; recupera reg_IX			;i_A14C: LD A, (IX+$00)		 ; A14C DD 7E 00	; Carga A con (IX+$00)
	lda	,y			; toma cdigo movimiento
	jsr	SearchMoveWord		; busca palabra movimiento		;	CALL SearchMoveWord	 ; A14F CD BA A0	; llama SearchMoveWord
	jsr	PrintWord		; la imprime				;	CALL PrintWord		 ; A152 CD C1 74	; llama rutina PrintWord
	jsr	L_A124			; llama L_A124				;	CALL L_A124		 ; A155 CD 24 A1	; llama rutina L_A124 (#164# --)
	bne	i_A14C			; si no devuelve 0, vuelve a i_A14C	;	JR NZ, i_A14C		 ; A158 20 F2		; Si Z = 0, Salta a i_A14C
	jsr	PutEnter		; imprime Enter				;	CALL PutEnter		 ; A15A CD 83 85	; llama rutina PutEnter
i_A15D	puls	y,u			; recupera				;i_A15D: POP BC			 ; A15D C1		; Recupera BC
	sty	<reg_BC			; los
	stu	<reg_DE			; cuatro				;	POP DE			 ; A15E D1		; Recupera DE
	puls	y,u			; registros
	sty	<reg_IY			; del					;	POP IY			 ; A15F FD E1		; Recupera IY
	stu	<reg_IX			; stack					;	POP IX			 ; A161 DD E1		; Recupera IX
	rts				; retorna				;	RET			 ; A163 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
L_A164	ldx	<reg_IY			; get pseudoreg				; L_A164: LD L, (IY+$08)	 ; A164 FD 6E 08	; Carga L con (IY+$08)
	ldx	8,x			; point to 1st desc word		; 	LD H, (IY+$09)		 ; A167 FD 66 09	; Carga H con (IY+$09)
	bra	PrintObjStatusWithHL	; show description			; 	JR PrintObjStatusWithHL	 ; A16A 18 06		; Salta a PrintObjStatusWithHL
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; HL apunta a FalseFlagWord  TrueFlagWord segn bit7 de A est respectivamente a 0  a 1
										; 							; llama a SearchStatusWord que devuelve una palabra en DE
										; 							; llama a PrintMsg con 2 parmetros (DE = estado y HL = sustantivo del objeto) 
PrintObjStatus									; PrintObjStatus:					; apuntando al mensaje"[0x04] is[0x01][0x15]" que los requiere ; antes ; (#205# --)
	ldy	<reg_IX			; get pseudoreg
	ldx	8,y			; apunta a 1ra palabra descripcion	; 	LD L, (IX+$08)		 ; A16C DD 6E 08	; Carga L con (IX+$08)
										; 	LD H, (IX+$09)		 ; A16F DD 66 09	; Carga H con (IX+$09) HL apunta a nombre del objeto (sustantivo)
PrintObjStatusWithHL								; PrintObjStatusWithHL:
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; A172 D5		; Guarda registro DE
	pshs	u,x			; guarda en stack U,X			; 	PUSH HL			 ; A173 E5		; Guarda HL (puntero al sustantivo)
	ldx	#FalseFlagWord		; apunta a tabla FalseFlagWord		; 	LD HL, FalseFlagWord	 ; A174 21 24 A2	; HL apunta a FalseFlagWord
	tsta				; est a 1 el bit 7?			; 	BIT 7, A		 ; A177 CB 7F		; Esta a 1 el bit 7 de A?
	bpl	i_A17E			; no, salta la siguiente		; 	JR Z, i_A17E		 ; A179 28 03		; no, salta a i_A17E
	ldx	#TrueFlagWord		; apunta a tabla TrueFlagWord		; 	LD HL, TrueFlagWord	 ; A17B 21 34 A2	; HL apunta a TrueFlagWord
i_A17E	jsr	SearchStatusWord	; llama SearchStatusWord		; i_A17E: CALL SearchStatusWord	 ; A17E CD BD A0	; llama SearchStatusWord
	puls	x			; toma X del stack			; 	POP HL			 ; A181 E1		; Recupera HL (puntero a sustantivo)
	ldu	<reg_DE			; recupera reg_DE			; 	PUSH DE			 ; A182 D5		; Guarda DE (palabra de SearchStatusWord)
	pshs	u,x			; pone en el stack U,X			; 	PUSH HL			 ; A183 E5		; Guarda HL (puntero a sustantivo)
	ldx	#L_AFBB			; apunta a mensaje			; 	LD HL, L_AFBB		 ; A184 21 BB AF	; apunta a mensaje "[0x04] is[0x01][0x15]"
	jsr	PrintMsg		; llama PrintMsg			; 	CALL PrintMsg		 ; A187 CD DD 72	; llama rutina PrintMsg con 2 parmetros (DE y HL de SearchStatusWord)
	puls	u			; recupera registro			; 	POP DE			 ; A18A D1		; Recupera registro DE
	stu	<reg_DE			; actualiza reg_DE
	rts				; retorna				; 	RET			 ; A18B C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
UpdateDeadObject								; UpdateDeadObject:					; updates description for dead/broken Object ; (#203# --)
	ldu	<reg_IX			; get pseudoreg				; 	PUSH IX			 ; A18C DD E5		; Guarda IX
	pshs	u			; save it
	jsr	GetObjPointer2IX	; get object pointer			; 	CALL GetObjPointer2IX	 ; A18E CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	clr	12,y			; clear description 			; 	LD (IX+$0C), $00	 ; A191 DD 36 0C 00	; Carga (IX+$0C) con $00
	clr	13,y			; word 3 pointer			; 	LD (IX+$0D), $00	 ; A195 DD 36 0D 00	; Carga (IX+$0D) con $00, ha anulado la 3 palabra descriptiva
	ldu	#$00cd			; point to work BROKEN			; 	LD DE, $00CD		 ; A199 11 CD 00	; Carga DE con $00CD -> palabra "BROKEN"
	ldy	<reg_IX			; get pseudoreg
	ldb	7,y			; get flags
	bitb	#%01000000		; is it animal?				; 	BIT 6, (IX+$07)		 ; A19C DD CB 07 76	; Esta a 1 el bit6 de (IX+$07), es animal?
	beq	i_A1A5			; no, skip next				; 	JR Z, i_A1A5		 ; A1A0 28 03		; no, Salta a i_A1A5
	ldu	#$0192			; point to work DEAD			; 	LD DE, $0192		 ; A1A2 11 92 01	; Carga DE con $0192 -> palabra "DEAD"
i_A1A5	stu	10,y			; put word on description word 2	; i_A1A5: LD (IX+$0A), E	 ; A1A5 DD 73 0A	; Carga (IX+$0A) con E
	puls	u			; restore register			; 	LD (IX+$0B), D		 ; A1A8 DD 72 0B	; Carga (IX+$0B) con D la pone en el primer adjetivo que es lo primero que se imprime!
	stu	<reg_IX			; update reg_IX				; 	POP IX			 ; A1AB DD E1		; Recupera IX
	rts				; return				; 	RET			 ; A1AD C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#196# --)
L_A1C8	ldy	<reg_IX			; get pseudoreg				; L_A1C8: LD A, (IX+$07)	 ; A1C8 DD 7E 07	; Carga A con (IX+$07)
	lda	7,y			; get flags
	anda	#%01001000		; test bits 3 and 6			; 	AND $48			 ; A1CB E6 48		; Hace AND lgico de A con $48
	cmpa	#%01000000		; is it animal and not dead?		; 	CP $40			 ; A1CD FE 40		; Compara A con $40
	rts				; return				; 	RET			 ; A1CF C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; busca cdigo de accin  en la tabla ActionOnObjTable ; antes ; (#120# OK) 
										; 							; parametro A: cdigo de la accin
IsActionInTableA20b								; IsActionInTableA20b:					; si encontrado retorna Z=1
	pshs	x			; guarda X(HL)				; 	PUSH HL			 ; A1D0 E5		; guarda HL
					; no se utiliza				; 	PUSH BC			 ; A1D1 C5		; guarda BC
	ldb	#5			; contador a 5				; 	LD B, $05		 ; A1D2 06 05		; nmero de entradas de la tabla
	ldx	#ActionOnObjTable	; apunta a ActionOnObjTable		; 	LD HL, ActionOnObjTable	 ; A1D4 21 0B A2	; apunta al inicio de ActionOnObjTable
	lda	CurrentAction		; recupera CurrentAction		; 	LD A, (CurrentAction)	 ; A1D7 3A E7 B6	; carga ID de accin a ejecutar
i_A1DA	cmpa	,x+			; es igual a byte apuntado por X?	; i_A1DA: CP (HL)		 ; A1DA BE		; es igual al byte apuntado de la tabla?
	beq	i_A1E0			; si, sale via i_A1E0			; 	JR Z, i_A1E0		 ; A1DB 28 03		; si, salir con Z=1 (encontrado)
										; 	INC HL			 ; A1DD 23		; incrementa puntero a tabla
	decb				; decrementa B
	bne	i_A1DA			; si no es cero, vuelve a i_A1DA	; 	DJNZ i_A1DA		 ; A1DE 10 FA		; decrementa contador, si no cero sigue buscando
	andcc	#%11111011		; clear zero flag to exit with Z=0
i_A1E0										; i_A1E0: POP BC		 ; A1E0 C1		; ahora saldr con Z=0. recupera BC
	puls	x,pc			; recupera X(HL) y retorna		; 	POP HL			 ; A1E1 E1		; recupera HL
										; 	RET			 ; A1E2 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
AppendSayMessage								; AppendSayMessage:					; compone un mensaje con HL. antes ; (#240# OK)
	pshs	x			; save register				; 	PUSH HL			 ; A1E3 E5		; guarda puntero a mensaje central
	ldx	#L_B009			; point to message			; 	LD HL, L_B009		 ; A1E4 21 09 B0	; apunta a mensaje "You say [0x16]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; A1E7 CD DD 72	; llama rutina PrintMsg 
	puls	x			; restore register			; 	POP HL			 ; A1EA E1		; recupera el mensaje central
	lda	#1			; put value 1				; 	LD A, $01		 ; A1EB 3E 01		; pone un 1
	sta	L_B704			; in L_B704				; 	LD (L_B704), A		 ; A1ED 32 04 B7	; en L_B704
	jsr	PrintMsg		; print message				; 	CALL PrintMsg		 ; A1F0 CD DD 72	; llama rutina PrintMsg para mostrar mensaje central
	ldx	#L_B00F			; point to message			; 	LD HL, L_B00F		 ; A1F3 21 0F B0	; apunta a mensaje ".[0x14]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; A1F6 C3 DD 72	; salta a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#199# --)
										; 							; Devuelve A=$80 si locked o bien A=$85 y Z indicando estado del bit5 (open-closed)
L_A1F9	ldy	MainObjectPtr		; recupera puntero a Objeto		; L_A1F9: LD IX, (MainObjectPtr) ; A1F9 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; actualiza reg_IX
	lda	#$80			; prepara resultado $80			; 	BIT 0, (IX+$07)		 ; A1FD DD CB 07 46	; Esta a 1 el bit 0 de (IX+$07)?
	ldb	7,y			; recupera flags objeto			; 	LD A, $80		 ; A201 3E 80		; Carga A con $80
	bitb	#%00000001		; est bloqueado?
	bne	s_A204			; si, sale				; 	RET NZ			 ; A203 C0		; Si Z = 0, Retorna
L_A204	lda	#$85			; prepara resultado $85			; L_A204: BIT 5, (IX+$07)	 ; A204 DD CB 07 6E	; Esta a 1 el bit 5 de (IX+$07)?
	ldb	7,y			; recupera flags objeto			; 	LD A, $85		 ; A208 3E 85		; Carga A con $85
	bitb	#%00100000		; est abierto ($1)?
s_A204	rts				; retorna				; 	RET			 ; A20A C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#281# --)
L_A244	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A244: CALL BreakIfB6faNot1	 ; A244 CD 44 9D	; llama BreakIfB6faNot1
	rts				; return				; 	RET			 ; A247 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Tie									; Action_Tie:						; (# sinNumero)
	lda	MainObject		; get main object 			; 	LD A, (MainObject)	 ; A248 3A E8 B6	; Carga cdigo objeto principal
	cmpa	#$12			; is it 'rope'?				; 	CP $12			 ; A24B FE 12		; Compara A con $12
	beq	i_A2AE			; yes, exit				; 	JR Z, i_A2AE		 ; A24D 28 5F		; Si Z = 1, Salta a i_A2AE
	lda	SecondObject		; get secondary object			; 	LD A, (SecondObject)	 ; A24F 3A E9 B6	; Carga cdigo objeto secundario
	cmpa	#$12			; is it 'rope'?				; 	CP $12			 ; A252 FE 12		; Compara A con $12
	lbne	IfB6FAis1DescAction	; no, desc action			; 	JP NZ, IfB6FAis1DescAction ; A254 C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; A257 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	ldb	7,y			; get flags
	bitb	#%00000010		; is it 'fluid'?			; 	BIT 1, (IX+$07)		 ; A25B DD CB 07 4E	; Esta a 1 el bit 1 de (IX+$07)?
	lbne	IfB6FAis1DescAction	; no, desc action			; 	JP NZ, IfB6FAis1DescAction ; A25F C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction)
	jsr	L_9D97			; call L_9D97				; 	CALL L_9D97		 ; A262 CD 97 9D	; llama rutina L_9D97 (#198# --)
	ldx	#L_B07D			; point to message			; 	CP $00			 ; A265 FE 00		; Compara A con $00
	tsta				; test received result			; 	LD HL, L_B07D		 ; A267 21 7D B0	; apunta a mensaje "[0x09] is already tied[0x15]"
	lbne	PrintMsg		; if not zero, show message		; 	JP NZ, PrintMsg		 ; A26A C2 DD 72	; si no es cero, salta a PrintMsg
	ldb	7,y			; get flags
	bitb	#%00001000		; is it tagged as dead? 		; 	BIT 3, (IX+$07)		 ; A26D DD CB 07 5E	; Esta a 1 el bit 3 de (IX+$07)?
	bne	i_A27A			; yes, skip two				; 	JR NZ, i_A27A		 ; A271 20 07		; Si Z = 0, Salta a i_A27A
	bitb	#%01000000		; is it animal?				; 	BIT 6, (IX+$07)		 ; A273 DD CB 07 76	; Esta a 1 el bit 6 de (IX+$07)?
	lbne	IfB6FAis1DescAction	; yes, desc action			; 	JP NZ, IfB6FAis1DescAction ; A277 C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
i_A27A	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; i_A27A: CALL BreakIfB6faNot1	 ; A27A CD 44 9D	; llama BreakIfB6faNot1
	ldy	SecndObjectPtr		; get second obj pointer		; 	LD IY, (SecndObjectPtr)	 ; A27D FD 2A 0A B7	; Carga SecndObjectPtr
	sty	<reg_IY			; save it
	jsr	OwnsActorCurObject1	; is owner by actor?			; 	CALL OwnsActorCurObject1 ; A281 CD 78 9C	; llama OwnsActorCurObject1
	tfr	cc,b			; save flags
	lda	SecondObject		; get 2nd object			; 	LD A, (SecondObject)	 ; A284 3A E9 B6	; Carga cdigo objeto secundario
	ldu	<reg_IX			; get pointer
	sta	1,u			; put as container			; 	LD (IX+$01), A		 ; A287 DD 77 01	; Carga (IX+$01) con A
	tfr	b,cc			; restore flags
	bcs	i_A2A2			; if carry, skip section		; 	JR C, i_A2A2		 ; A28A 38 16		; Si C = 1, Salta a i_A2A2
	clra				; put value zero			; 	SUB A			 ; A28C 97		; Resta A de A
	sta	L_B6FA			; in L_B6FA				; 	LD (L_B6FA), A		 ; A28D 32 FA B6	; Carga (L_B6FA) con A
	jsr	Action_Pickup		; call Action_Pickup			; 	CALL Action_Pickup	 ; A290 CD 33 8D	; llama rutina Action_Pickup
	ldb	L_B6FB			; get value to test it later		; 	LD A, (L_B6FB)		 ; A293 3A FB B6	; Carga A con (L_B6FB)
	lda	#1			; put value 1				; 	CP $00			 ; A296 FE 00		; Compara A con $00
	sta	L_B6FA			; in L_B6FA				; 	LD A, $01		 ; A298 3E 01		; Carga A con $01
	sta	L_B6FB			; and L_B6FB				; 	LD (L_B6FA), A		 ; A29A 32 FA B6	; Carga (L_B6FA) con A
	tstb				; was L_B6FB zero? 			; 	LD (L_B6FB), A		 ; A29D 32 FB B6	; Carga (L_B6FB) con A
	beq	i_A2A9			; yes, exit				; 	JR Z, i_A2A9		 ; A2A0 28 07		; Si Z = 1, Salta a i_A2A9
i_A2A2	lda	ActionActor		; get actor				; i_A2A2: LD A, (ActionActor)	 ; A2A2 3A EA B6	; Carga ActionActor
	ldy	<reg_IY			; get pseudoreg
	sta	1,y			; put as container			; 	LD (IY+$01), A		 ; A2A5 FD 77 01	; Carga (IY+$01) con A
	rts				; return				; 	RET			 ; A2A8 C9		; Retorna
i_A2A9	ldb	#$ff			; put value				; i_A2A9: LD (IY+$01), $FF	 ; A2A9 FD 36 01 FF	; Carga (IY+$01) con $FF
	ldy	<reg_IY			; get pseudoreg
	stb	1,y			; of NO container
	rts				; return				; 	RET			 ; A2AD C9		; Retorna
i_A2AE	ldx	#Action_Tie		; point to Action_Tie			; i_A2AE: LD HL, Action_Tie	 ; A2AE 21 48 A2	; Carga HL con Action_Tie
	lbra	L_9F4A			; goto L_9F4A				; 	JP L_9F4A		 ; A2B1 C3 4A 9F	; salta a L_9F4A (#193# --)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Untie									; Action_Untie:						; (# sinNumero)
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; A2B4 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	lda	1,y			; get container				; 	LD A, (IX+$01)		 ; A2B8 DD 7E 01	; Carga A con (IX+$01)
	ldx	#L_B092			; point to message			; 	CP $12			 ; A2BB FE 12		; Compara A con $12
	cmpa	#$12			; is it 'rope'?				; 	LD HL, L_B092		 ; A2BD 21 92 B0	; apunta a mensaje "[0x07] is not tied[0x15]"
	lbne	PrintMsg		; no, show message			; 	JP NZ, PrintMsg		 ; A2C0 C2 DD 72	; si no es cero, salta a PrintMsg
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A2C3 CD 44 9D	; llama BreakIfB6faNot1
	lda	L_C366+1		; get byte after 'rope' ID		; 	LD A, ($C367)		 ; A2C6 3A 67 C3	; Carga A con ($C367)
	sta	1,y			; put as container			; 	LD (IX+$01), A		 ; A2C9 DD 77 01	; Carga (IX+$01) con A
	rts				; return				; 	RET			 ; A2CC C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#260# --)
L_A2CD	jsr	L_9F25			; call L_9F25				; L_A2CD: CALL L_9F25		 ; A2CD CD 25 9F	; llama rutina L_9F25 (#190# --)
	ldu	<reg_IX			; get pseudoreg				; 	LD A, (IX+$02)		 ; A2D0 DD 7E 02	; Carga A con (IX+$02)
	lda	2,u			; get volume				; 	CP $00			 ; A2D3 FE 00		; Compara A con $00
	bne	i_A2DB			; if not zero, skip two			; 	JR NZ, i_A2DB		 ; A2D5 20 04		; Si Z = 0, Salta a i_A2DB
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A2D7 CD 44 9D	; llama BreakIfB6faNot1
	rts				; return				; 	RET			 ; A2DA C9		; Retorna
										; 
i_A2DB	lda	,u			; get number of locations		; i_A2DB: LD A, (IX+$00)	 ; A2DB DD 7E 00	; Carga A con (IX+$00)
	ldx	CurrentAction		; get action and main object		; 	LD HL, (CurrentAction)	 ; A2DE 2A E7 B6	; carga ID de accin y cdigo de objeto principal
	pshs	x			; save values				; 	PUSH HL			 ; A2E1 E5		; Guarda HL
	sta	CurrentAction		; set action				; 	LD (CurrentAction), A	 ; A2E2 32 E7 B6	; Carga ID de accin
	ldu	MainObjectPtr		; get obj ptr				; 	LD IX, (MainObjectPtr)	 ; A2E5 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; save it
	ldb	7,u			; get flags
	orb	#%00100000		; set to open
	stb	7,u			; update flags				; 	SET 5, (IX+$07)		 ; A2E9 DD CB 07 EE	; Pasa a 1 el bit 5 en (IX+$07)
	pshs	u			; save ptr				; 	PUSH IX			 ; A2ED DD E5		; Guarda IX
	lda	#$ff			; put None				; 	LD A, $FF		 ; A2EF 3E FF		; Carga A con $FF
	sta	MainObject		; to main object			; 	LD (MainObject), A	 ; A2F1 32 E8 B6	; guarda cdigo objeto principal
	jsr	L_8DAB			; call L_8DAB				; 	CALL L_8DAB		 ; A2F4 CD AB 8D	; llama rutina L_8DAB (#236# --)
	puls	u			; restore ptr				; 	POP IX			 ; A2F7 DD E1		; Recupera IX
	stu	<reg_IX			; update pseudoreg
	ldb	7,u			; get flags
	andb	#%11011111		; set to closed
	stb	7,u			; update flags				; 	RES 5, (IX+$07)		 ; A2F9 DD CB 07 AE	; Pasa a 0 el bit 5 en (IX+$07)
	puls	x			; restore saved values			; 	POP HL			 ; A2FD E1		; Recupera HL
	stx	CurrentAction		; to their variables			; 	LD (CurrentAction), HL	 ; A2FE 22 E7 B6	; recupera ID de accin y cdigo de objeto principal
	rts				; retun					; 	RET			 ; A301 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Burn									; Action_Burn:						; (# sinNumero)
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; A302 3A EA B6	; Carga ActionActor
	cmpa	#$3c			; is it 'red golden dragon'?		; 	CP $3C			 ; A305 FE 3C		; Compara A con $3C
	lbne	IfB6FAis1DescAction	; no, desc action			; 	JP NZ, IfB6FAis1DescAction ; A307 C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A30A CD 44 9D	; llama BreakIfB6faNot1
	lbra	L_977C			; goto L_977C				; 	JP L_977C		 ; A30D C3 7C 97	; Salta a L_977C
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#259# --)
L_A310	jsr	BreakIfB6faNot1		; break if B6fa is not 1		; L_A310: CALL BreakIfB6faNot1	 ; A310 CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_B0B4			; point to message			; 	LD HL, L_B0B4		 ; A313 21 B4 B0	; apunta a mensaje "as soon as you touch the river you fall asleep and gently float away"
i_A316	jsr	PrintMsg		; show it				; i_A316: CALL PrintMsg		 ; A316 CD DD 72	; llama rutina PrintMsg
	lda	ActionActor		; get actor ID				; 	LD A, (ActionActor)	 ; A319 3A EA B6	; Carga ActionActor
	pshs	a,cc			; save registers			; 	PUSH AF			 ; A31C F5		; Guarda AF
	ldx	#L_ADA9			; point to message			; 	AND A			 ; A31D A7		; A = A AND A	; Adecua flags
	tsta				; is it Bilbo?				; 	LD HL, L_ADA9		 ; A31E 21 A9 AD	; apunta parte de un mensaje "Time passes..[0x15]"
	bne	1f			; no, skip next
	jsr	PrintMsg		; show message				; 	CALL Z, PrintMsg	 ; A321 CC DD 72	; si es cero, llama rutina PrintMsg
1	puls	a,cc			; restore registers			; 	POP AF			 ; A324 F1		; Recupera AF
	lbra	ProcessDeadObject	; process actor death			; 	JP ProcessDeadObject	 ; A325 C3 7F 97	; salta a ProcessDeadObject
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#280# --)
L_A328	jsr	BreakIfB6faNot1		; break if B6fa is not 1		; L_A328: CALL BreakIfB6faNot1	 ; A328 CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_B0F8			; point to message			; 	LD HL, L_B0F8		 ; A32B 21 F8 B0	; apunta a mensaje "You fall asleep[0x15]"
	bra	i_A316			; go show it via i_A316			; 	JR i_A316		 ; A32E 18 E6		; Salta a i_A316
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#262# --)
L_A330	ldb	#2			; put ID for 'small curious key'	; L_A330: LD B, $02		 ; A330 06 02		; Carga B con $02
	stb	<reg_B			; into reg_B
	bra	i_A33A			; go process keys actions		; 	JR i_A33A		 ; A332 18 06		; Salta a i_A33A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#256# --) 
L_A334	ldb	#$0f			; get ID for 'red key'			; L_A334: LD B, $0F		 ; A334 06 0F		; Carga B con $0F
	bra	i_A33X			; skip next				; 	JR i_A33A		 ; A336 18 02		; Salta a i_A33A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#252# --)
L_A338	ldb	#4			; get ID for 'large key'		; L_A338: LD B, $04	 	 ; A338 06 04		; Carga B con $04
i_A33X	stb	<reg_B			; save in reg_B
i_A33A	lda	SecondObject		; get 2nd object			; i_A33A: LD A, (SecondObject)	 ; A33A 3A E9 B6	; Carga cdigo objeto secundario
	cmpa	<reg_B			; is that key?				; 	CP B			 ; A33D B8		; Compara A con B
	bne	i_A34B			; no, skip section			; 	JR NZ, i_A34B		 ; A33E 20 0B		; Si Z = 0, Salta a i_A34B
	lda	CurrentAction		; get action				; 	LD A, (CurrentAction)	 ; A340 3A E7 B6	; Carga ID de accin
	cmpa	#$25			; is it lock with?			; 	CP $25			 ; A343 FE 25		; Compara A con $25
	lbeq	L_946D			; yes, goto L_946D			; 	JP Z, L_946D		 ; A345 CA 6D 94	; Si Z = 1, Salta a L_946D
	lbra	L_948D			; goto L_948D				; 	JP L_948D		 ; A348 C3 8D 94	; Salta a L_948D
i_A34B	cmpa	#2			; is 'small curious key'?		; i_A34B: CP $02		 ; A34B FE 02		; Compara A con $02
	beq	L_A358			; yes, skip section			; 	JR Z, L_A358		 ; A34D 28 09		; Si Z = 1, Salta a L_A358
	cmpa	#4			; is 'large key'?			; 	CP $04			 ; A34F FE 04		; Compara A con $04
	beq	L_A358			; yes, skip section			; 	JR Z, L_A358		 ; A351 28 05		; Si Z = 1, Salta a L_A358
	cmpa	#$0f			; is it 'red key'?			; 	CP $0F			 ; A353 FE 0F		; Compara A con $0F
	lbne	L_72CE			; no, goto L_72CE			; 	JP NZ, L_72CE		 ; A355 C2 CE 72	; si flag Z=0, salta a L_72CE (#211# --)
										; 							; (#250# --)
L_A358	ldx	#L_B02D			; point to message			; L_A358: LD HL, L_B02D		 ; A358 21 2D B0	; apunta a mensaje "[0x09] does not fit this lock"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; A35B C3 DD 72	; salta a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#263# --)
L_A35E	jsr	BreakIfB6faAndfbZero	; exit if b6fa-fb are zero		; L_A35E: CALL BreakIfB6faAndfbZero ; A35E CD FF 97	; llama BreakIfB6faAndfbZero
	ldu	MainObjectPtr		; point to main obj			; 	LD IX, (MainObjectPtr)	 ; A361 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; save pointer
	lbra	L_9117			; goto L_9117				; 	JP L_9117		 ; A365 C3 17 91	; Salta a L_9117
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#254# --)
L_A368	ldu	ObjectPointer		; get pointer				; L_A368: LD IX, (ObjectPointer) ; A368 DD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IX			; update reg_IX
	lda	16,u			; get location				; 	LD A, (IX+$10)		 ; A36C DD 7E 10	; Carga A con (IX+$10)
	cmpa	#$0f			; is it dark stuffy passage?		; 	CP $0F			 ; A36F FE 0F		; Compara A con $0F
	lbne	IfB6FAis1DescAction	; no, desc Action if B6FA is 1		; 	JP NZ, IfB6FAis1DescAction ; A371 C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	lbra	L_910E			; go L_910E				; 	JP L_910E		 ; A374 C3 0E 91	; salta a L_910E (#238# --)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#255# --)
L_A377	ldu	MainObjectPtr		; get main obj pointer			; L_A377: LD IX, (MainObjectPtr) ; A377 DD 2A 08 B7	; Carga MainObjectPtr
	stu	<reg_IX			; save it
	ldb	7,u			; get flags
	bitb	#%00001000		; is it dead/broken?			; 	BIT 3, (IX+$07)		 ; A37B DD CB 07 5E	; Esta a 1 el bit 3 de (IX+$07)?
	beq	e_A377			; no, exit				; 	RET Z			 ; A37F C8		; Z = 1?	; Retorna si es cero
	orb	#%00100000		; set to 'open'
	stb	7,u			; update flags				; 	SET 5, (IX+$07)		 ; A380 DD CB 07 EE	; Pasa a 1 el bit 5 en (IX+$07)
	lda	D_CA8B			; get byte related with 'spider web'	; 	LD A, (D_CA8B)		 ; A384 3A 8B CA	; Carga A con (D_CA8B)
	sta	D_CA8C			; activate its script			; 	LD (D_CA8C), A		 ; A387 32 8C CA	; Carga (D_CA8C) con A
	ldx	#L_B099			; point to message			; 	LD HL, L_B099		 ; A38A 21 99 B0	; apunta a mensaje "some spiders start mend(s|d|ing|es) the broken web"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; A38D C3 DD 72	; salta a PrintMsg
e_A377	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
WearRing									; WearRing:						; Se pone el anillo 	; antes ; (#266# --)
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1   	; A390 CD 44 9D   	; llama BreakIfB6faNot1
	ldy	ObjectPointer		; get pointer				; 	LD IY, (ObjectPointer) 	; A393 FD 2A 0C B7   	; recupera ObjectPointer (puntero a quien tiene el anillo)
	sty	<reg_IY			; save it
	ldu	#L_C31A			; point to 'valuable golden ring'	; 	LD IX, L_C31A       	; A397 DD 21 1A C3   	; Carga IX con L_C31A = 10 [ff] ring valuable golden
	stu	<reg_IX			; save pointer
	ldb	7,y			; get characater flags
	andb	#%01111111		; set as NOT visible
	stb	7,y			; update flags				; 	RES 7, (IY+$07)       	; A39B FD CB 07 BE   	; Pasa a 0 el bit 7 en (IY+$07) = contenedor anillo se hace invisible
	ldb	5,y			; get strength
	lsrb				; divide				; 	SRL (IY+$05)       	; A39F FD CB 05 3E   	; Rota lgicamente a la derecha (IY+$05)
	lsrb				; by 4
	stb	5,y			; update strength			; 	SRL (IY+$05)       	; A3A3 FD CB 05 3E   	; dos veces. Byte St=St/4 
	ldb	7,u			; get ring flags
	andb	#%01111111		; set to NOT visible
	stb	7,u			; update them				; 	RES 7, (IX+$07)       	; A3A7 DD CB 07 BE   	; Pasa a 0 el bit 7 en (IX+$07) = anillo se hace invisible
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)    	; A3AB 3A EA B6   	; Carga ActionActor
	sta	1,u			; put as ring container			; 	LD (IX+$01), A       	; A3AE DD 77 01   	; lo guarda en (IX+$01) = indicador de contenido en otro objeto si <>$FF
	lda	#8			; max number				; 	LD A, $08       	; A3B1 3E 08      	; Carga A con $08 (limite del random a generar)
	jsr	GetPosRandom		; create a random number		; 	CALL GetPosRandom    	; A3B3 CD 9F 9C   	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	adda	#2			; add 2					; 	ADD A, $02       	; A3B6 C6 02      	; le suma 2 para tener valor entre 2 y 10
	sta	D_CAAF			; put into Bilbo events related to ring ; 	LD (D_CAAF), A       	; A3B8 32 AF CA   	; guarda el valor generado en D_CAAF
	rts				; return				; 	RET          		; A3BB C9      		; Retorna   
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
TakeOffRing									; TakeOffRing:						; Se quita el anillo ; antes ; (#267# --)
	ldu	ObjectPointer		; get pointer				; 	LD IX, (ObjectPointer) 	; A3BC DD 2A 0C B7   	; recupera ObjectPointer (puntero a quien tiene el anillo)
	stu	<reg_IX			; save it
	ldy	#L_C31A			; point to 'valuable golden ring'	; 	LD IY, L_C31A       	; A3C0 FD 21 1A C3   	; Carga IY con L_C31A = 10 [ff] ring valuable golden
	sty	<reg_IY			; save pointer
	ldb	7,y			; get ring flags
	ldx	#L_B074			; point to message			; 	BIT 7, (IY+$07)       	; A3C4 FD CB 07 7E   	; Esta a 1 el bit 7 de (IY+$07) = es visible el anillo?
	bitb	#%10000000		; is it visible?			; 	LD HL, L_B074       	; A3C8 21 74 B0   	; apunta a mensaje "You are not wearing[0x07][0x15]"
	lbne	PrintMsg		; no, show message			; 	JP NZ, PrintMsg       	; A3CB C2 DD 72   	; es visible, salta a PrintMsg
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1   	; A3CE CD 44 9D   	; llama BreakIfB6faNot1
	ldb	7,y			; get ring flags
	orb	#%10000000		; set as visible
	stb	7,y			; update them				; 	SET 7, (IY+$07)       	; A3D1 FD CB 07 FE   	; Pasa a 1 el bit 7 en (IY+$07) hace visible el anillo
	ldb	7,u			; get character flags
	orb	#%10000000		; set as visible
	stb	7,u			; update them				; 	SET 7, (IX+$07)       	; A3D5 DD CB 07 FE   	; Pasa a 1 el bit 7 en (IX+$07) hace visible su contenedor
	ldb	5,u			; get strength
	lslb				; multiply				; 	SLA (IX+$05)       	; A3D9 DD CB 05 26   	; Rota aritmticamente a la izquierda (IX+$05)
	lslb				; by 4
	stb	5,u			; update strength			; 	SLA (IX+$05)       	; A3DD DD CB 05 26   	; dos veces. Byte St=4*St
	clra				; put value zero			; 	SUB A          		; A3E1 97      		; pone valor 0
	sta	D_CAAF			; into Bilbo events related to ring	; 	LD (D_CAAF), A       	; A3E2 32 AF CA   	; en D_CAAF
	rts				; return				; 	RET          		; A3E5 C9      		; Retorna   
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_Capture									; Action_Capture:					; (# sinNumero)
	ldy	MainObjectPtr		; get main Object pointer		; 	LD IX, (MainObjectPtr)	 ; A3E6 DD 2A 08 B7	; Carga MainObjectPtr
	lda	4,y			; get unknown meaning byte		; 	LD A, (IX+$04)		 ; A3EA DD 7E 04	; Carga A con (IX+$04)
	anda	#%01110000		; test bits 4-5-6			; 	AND $70			 ; A3ED E6 70		; Hace AND lgico de A con $70
	pshs	y			; save pointer				; 	PUSH IX			 ; A3EF DD E5		; Guarda IX
	ldy	ObjectPointer		; get pointer				; 	LD IX, (ObjectPointer)	 ; A3F1 DD 2A 0C B7	; recupera ObjectPointer
	anda	4,y			; do any of bits 4-5-6 coincide?	; 	AND (IX+$04)		 ; A3F5 DD A6 04	; Hace AND lgico de A con (IX+$04)
	tfr	cc,b			; save flags
	puls	y			; rstore pointer			; 	POP IX			 ; A3F8 DD E1		; Recupera IX
	sty	<reg_IX			; update pseudoreg
	tfr	b,cc			; restore flags
	lbne	IfB6FAis1DescAction	; if any coincidence go desc action	; 	JP NZ, IfB6FAis1DescAction ; A3FA C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	ldy	<reg_IX			; get pseudoreg
	ldb	7,y			; get flags
	bitb	#%01000000		; is it animal?				; 	BIT 6, (IX+$07)		 ; A3FD DD CB 07 76	; Esta a 1 el bit 6 de (IX+$07)?
	lbeq	IfB6FAis1DescAction	; no, desc Action			; 	JP Z, IfB6FAis1DescAction ; A401 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; A404 3A EA B6	; Carga ActionActor
	ldb	#$1f			; put value $1f (dark dungeon?)
	stb	<reg_B			; in reg_B				; 	LD B, $1F		 ; A407 06 1F		; Carga B con $1F
	cmpa	#$40			; is "wood elf"?			; 	CP $40			 ; A409 FE 40		; Compara A con $40
	beq	i_A413			; yes, go i_A413			; 	JR Z, i_A413		 ; A40B 28 06		; Si Z = 1, Salta a i_A413
	cmpa	#$42			; is "butler"?				; 	CP $42			 ; A40D FE 42		; Compara A con $42
	beq	i_A413			; yes, go i_A413			; 	JR Z, i_A413		 ; A40F 28 02		; Si Z = 1, Salta a i_A413
	ldb	#$0d			; put value $0d (globlins dungeon?)
	stb	<reg_B			; in reg_B				; 	LD B, $0D		 ; A411 06 0D		; Carga B con $0D
i_A413	lda	ObjectLocation		; get object location			; i_A413: LD A, (ObjectLocation) ; A413 3A F6 B6	; recupera ObjectLocation
	cmpa	<reg_B			; is the same in reg_B?			; 	CP B			 ; A416 B8		; Compara A con B
	lbeq	IfB6FAis1DescAction	; yes, desc action			; 	JP Z, IfB6FAis1DescAction ; A417 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; A41A CD 44 9D	; llama BreakIfB6faNot1
	ldy	MainObjectPtr		; point to main Object			; 	LD IX, (MainObjectPtr)	 ; A41D DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save pointer
	ldb	<reg_B			; get location
	stb	16,y			; set as actual location		; 	LD (IX+$10), B		 ; A421 DD 70 10	; graba en localizacin actual del objeto el registro B
	ldb	#$ff			; put NO container
	stb	1,y			; to main object			; 	LD (IX+$01), $FF	 ; A424 DD 36 01 FF     ; indica en byte 1 que no est contenido dentro de otro objeto
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; A428 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_9BDD			; affects contained objects		; 	CALL L_9BDD		 ; A42B CD DD 9B	; llama rutina L_9BDD (#186# --)
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; A42E 3A E8 B6	; Carga cdigo objeto principal
										; 	CP $00			 ; A431 FE 00		; Compara A con $00
	bne	e_A413			; if not Bilbo, exit			; 	RET NZ			 ; A433 C0		; Si Z = 0, Retorna
	sta	ActionActor		; put as actor				; 	LD (ActionActor), A	 ; A434 32 EA B6	; guarda ActionActor
	ldx	#OBJ_TABLE		; point to OBJ table			; 	LD HL, OBJ_TABLE	 ; A437 21 1B C1	; Carga HL con OBJ_TABLE
	stx	ObjectPointer		; save value				; 	LD (ObjectPointer), HL	 ; A43A 22 0C B7	; la guarda en ObjectPointer
	jsr	IsItDark		; is it dark?				; 	CALL IsItDark		 ; A43D CD ED 95	; llama rutina IsItDark
	bcs	e_A413			; yes, exit				; 	RET C			 ; A440 D8		; Si C = 1, Retorna
	lda	<reg_B			; get location				; 	LD A, B			 ; A441 78		; Carga A con B
	ldx	#L_AFFC			; point to message			; 	LD HL, L_AFFC		 ; A442 21 FC AF	; apunta al mensaje en L_AFFC ("You are in [0x16]")
	lbra	L_964D			; go add location message		; 	JP L_964D		 ; A445 C3 4D 96	; Salta a L_964DL_964D
e_A413	rts				; returns				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
CreateNewGoblin									; CreateNewGoblin:					; Si ha muerto, crea otro igual y avisa si es la misma ubicacin de Bilbo ; antes ; (#287# --)
	ldy	MainObjectPtr		; get pointer				; 	LD IX, (MainObjectPtr)	 ; A448 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	ldb	7,y			; get flags
	bitb	#%00001000		; is it broken/dead?			; 	BIT 3, (IX+$07)		 ; A44C DD CB 07 5E	; Est vivo?
	beq	e_A413			; no, exit				; 	RET Z			 ; A450 C8		; si, retorna
	andb	#%11110111		; set as alive (resurrected ;-))	; 	RES 3, (IX+$07)		 ; A451 DD CB 07 9E	; Lo marca como vivo ('resucita')
	stb	7,y			; update flags
										; 	LD DE, $0006		 ; A455 11 06 00	; Longitud de registro = 6
	ldy	#GoblinsDataTable	; point to goblins table		; 	LD IY, GoblinsDataTable	 ; A458 FD 21 9C A4	; apunta a GoblinsDataTable
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; A45C 3A E8 B6	; Carga cdigo objeto principal
i_A45F	cmpa	,y			; is the ID of this table entry?	; i_A45F: CP (IY+$00)		 ; A45F FD BE 00	; coincide con ID en la tabla?
	beq	i_A468			; yes, exit loop			; 	JR Z, i_A468		 ; A462 28 04		; si, sal de la bsqueda
	leay	6,y			; point to next goblin			; 	ADD IY, DE		 ; A464 FD 19		; pasa al siguiente goblin
	sty	<reg_IY			; update reg_IY
	bra	i_A45F			; loopback				; 	JR i_A45F		 ; A466 18 F7		; vuelva a i_A45F
i_A468	leax	1,y			; point to HLDir address		; i_A468: PUSH IY		 ; A468 FD E5		; pasa IY
					; X(Goblins dataTable ptr)		; 	POP HL			 ; A46A E1		; a HL = puntero al ID en la tabla de Goblins
										; 	INC HL			 ; A46B 23		; Incrementa HL
	ldu	,x++			; get that address			; 	LD E, (HL)		 ; A46C 5E		; Carga byte bajo
					; U(Goblin_HLDir ptr)			; 	INC HL			 ; A46D 23		; Incrementa HL
										; 	LD D, (HL)		 ; A46E 56		; Carga byte alto. HL apunta al inicio del directoro de Alto Nivel del Goblin a resucitar
	sta	,u			; put main object as goblin ID		; 	LD (DE), A		 ; A46F 12		; repone el ID del Goblin en el primer byte del Directorio de Alto Nivel
										; 	INC HL			 ; A470 23		; Incrementa HL
	lda	,x+			; get location from table		; 	LD A, (HL)		 ; A471 7E		; recupera byte siguiente de GoblinsDataTable (localizacin donde ponerlo)
	ldy	<reg_IX			; get object pointer			; 	LD (IX+$10), A		 ; A472 DD 77 10	; lo guarda en Localizacin en estructura del Objeto
	sta	16,y			; set its location			; 	INC HL			 ; A475 23		; Incrementa HL
	ldu	,x++			; get qualifier word (kind of goblin)	; 	LD A, (HL)		 ; A476 7E		; recupera byte siguiente de GoblinsDataTable (byte bajo puntero a adjetivo)
	stu	10,y			; put in desc word 2			; 	LD (IX+$0A), A		 ; A477 DD 77 0A	; lo pone en byte bajo adjetivo en estructura del Objeto
										; 	INC HL			 ; A47A 23		; Incrementa HL
										; 	LD A, (HL)		 ; A47B 7E		; recupera byte siguiente de GoblinsDataTable (byte alto puntero a adjetivo)
										; 	LD (IX+$0B), A		 ; A47C DD 77 0B	; lo pone en byte alto adjetivo en estructura del Objeto
	ldx	#L_B068			; point to message			; 	LD HL, L_B068		 ; A47F 21 68 B0	; apunta a mensaje "[0x07] fall(s|d|ing|es) down a hole and vanish(s|d|ing|es)[0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; A482 CD DD 72	; llama rutina PrintMsg
	lda	L_C11B+16		; get Bilbo location			; 	LD A, (L_C11B + $10)	 ; A485 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	cmpa	<reg_B			; is same as reg_B?			; 	CP B			 ; A488 B8		; es la misma Localizacin que B?
	bne	e_A413			; no, exit				; 	RET NZ			 ; A489 C0		; no, retorna
	ldu	#$005E			; get word ANOTHER
	stu	<reg_DE			; pass as param				; 	LD DE, $005E		 ; A48A 11 5E 00	; Carga DE con palabra "ANOTHER"
	jsr	PrintWord		; show it				; 	CALL PrintWord		 ; A48D CD C1 74	; llama rutina PrintWord
	ldu	#$02E2			; get word GOBLIN
	stu	<reg_DE			; pass as param				; 	LD DE, $02E2		 ; A490 11 E2 02	; Carga DE con palabra "GOBLIN"
	jsr	PrintWord		; show it				; 	CALL PrintWord		 ; A493 CD C1 74	; llama rutina PrintWord
	ldx	#L_B018			; point to message			; 	LD HL, L_B018		 ; A496 21 18 B0	; apunta a mensaje "enter(s|d|ing|es).[0x14]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; A499 C3 DD 72	; salta a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#268# --)
L_A4C0	ldu	ObjectPointer		; get object pointer			; L_A4C0: LD IX, (ObjectPointer) ; A4C0 DD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IX			; save it
	lda	16,u			; get location				; 	LD A, (IX+$10)		 ; A4C4 DD 7E 10	; Carga A con (IX+$10)
	cmpa	#16			; is it 'beorns house'?			; 	CP $10			 ; A4C7 FE 10		; Compara A con $10
	lbne	IfB6FAis1DescAction	; no, desc action			; 	JP NZ, IfB6FAis1DescAction ; A4C9 C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	jsr	L_910E			; call L_910E				; 	CALL L_910E		 ; A4CC CD 0E 91	; llama rutina L_910E (#238# --)
	jsr	BreakIfB6faAndfbZero	; exit if B6fa-fb are zero		; 	CALL BreakIfB6faAndfbZero ; A4CF CD FF 97	; llama BreakIfB6faAndfbZero
	lda	D_CA99			; get byte related to 'gobblins door'	; 	LD A, (D_CA99)		 ; A4D2 3A 99 CA	; Carga A con (D_CA99)
	sta	D_CA9A			; activate its script			; 	LD (D_CA9A), A		 ; A4D5 32 9A CA	; Carga (D_CA9A) con A
	rts				; return				; 	RET			 ; A4D8 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CA9B-9C
L_A4D9	ldx	#L_C344+7		; get 'goblins door' flags		; L_A4D9: LD HL, L_C344 + $07	 ; A4D9 21 4B C3 	; accede a flags del objeto $11 goblins door
	ldb	,x			; get flags
	andb	#%11011111		; set to closed
	stb	,x			; update flags				; 	RES 5, (HL)		 ; A4DC CB AE		; Pasa a 0 el bit 5 en (HL)
	rts				; return				; 	RET			 ; A4DE C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntado desde $CA80 en (#45#)
L_A4DF	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A4DF: CALL BreakIfB6faNot1	 ; A4DF CD 44 9D	; llama BreakIfB6faNot1
	lda	#10			; max value				; 	LD A, $0A		 ; A4E2 3E 0A		; Carga A con $0A
	jsr	GetPosRandom		; for random number			; 	CALL GetPosRandom	 ; A4E4 CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	ldx	#L_B0A6			; point to message			; 	LD HL, L_B0A6		 ; A4E7 21 A6 B0	; apunta a mensaje "what do you expect me to do with this ?[0x16]"
	cmpa	#8			; random >=8?				; 	CP $08			 ; A4EA FE 08		; Compara A con $08
	lbcc	AppendSayMessage	; yes, show msg				; 	JP NC, AppendSayMessage	 ; A4EC D2 E3 A1	; si flag C=0, salta a AppendSayMessage
	ldx	#L_B047			; point to message			; 	LD HL, L_B047		 ; A4EF 21 47 B0	; apunta a mensaje "thank you."
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A4F2 C3 E3 A1	; salta a AppendSayMessage
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntado desde $C8C9 de (#45#)
L_A4F5	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; L_A4F5: CALL BreakIfB6faNot1	 ; A4F5 CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_B04B			; point to message			; 	LD HL, L_B04B		 ; A4F8 21 4B B0	; apunta a mensaje "what's this ?[0x16]"
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A4FB C3 E3 A1	; salta a AppendSayMessage
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntado desde $C8D7 de (#45#)
L_A4FE	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; L_A4FE: CALL BreakIfB6faNot1	 ; A4FE CD 44 9D	; llama BreakIfB6faNot1
	lda	#2			; set maximum value to 2		; 	LD A, $02		 ; A501 3E 02		; Carga A con $02
	jsr	GetPosRandom		; get a random number (0-2)		; 	CALL GetPosRandom	 ; A503 CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	ldx	#L_B052			; point to message			; 	LD HL, L_B052		 ; A506 21 52 B0	; apunta a mensaje "you are do(s|d|ing|es) a great job."
	tsta				; was random num equal zero?		; 	CP $00			 ; A509 FE 00		; Compara A con $00
	lbeq	AppendSayMessage	; yes, show message			; 	JP Z, AppendSayMessage	 ; A50B CA E3 A1	; si flag Z=1, salta a AppendSayMessage
	ldx	#L_B05B			; point to message			; 	LD HL, L_B05B		 ; A50E 21 5B B0	; apunta a mensaje "hurry up."
	cmpa	#1			; was it 1?				; 	CP $01			 ; A511 FE 01		; Compara A con $01
	lbeq	AppendSayMessage	; yes, show message			; 	JP Z, AppendSayMessage	 ; A513 CA E3 A1	; si flag Z=1, salta a AppendSayMessage
	ldx	#L_B05F			; point to message for value 2		; 	LD HL, L_B05F		 ; A516 21 5F B0	; apunta a mensaje "hello."
	lbra	AppendSayMessage	; show message				; 	JP AppendSayMessage	 ; A519 C3 E3 A1	; salta a AppendSayMessage
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntado desde $C8FC de (#45#)
L_A51C	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A51C: CALL BreakIfB6faNot1	 ; A51C CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_B061			; point to message			; 	LD HL, L_B061		 ; A51F 21 61 B0	; apunta a mensaje "this was Thrains key."
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A522 C3 E3 A1	; salta a AppendSayMessage
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; llamada desde $C99B de (#45#)
L_A525	lda	ObjectLocation		; get location				; L_A525: LD A, (ObjectLocation) ; A525 3A F6 B6	; recupera ObjectLocation
	ldx	#BilboLocation		; point to Bilbo location		; 	LD HL, BilboLocation	 ; A528 21 F5 B6	; apunta a BilboLocation
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A52B BE		; Compara A con (HL)
	bne	e_A525			; no, exit				; 	RET NZ			 ; A52C C0		; Si Z = 0, Retorna
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; A52D CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_B05F			; point to message			; 	LD HL, L_B05F		 ; A530 21 5F B0	; apunta a mensaje "hello."
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A533 C3 E3 A1	; salta a AppendSayMessage
e_A525	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Action_ClimbOut									; Action_ClimbOut:					; (# sinNumero)
	ldy	ObjectPointer		; get object pointer			; 	LD IY, (ObjectPointer)	 ; A541 FD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IY			; save it
	lda	MainObject		; get main object			; 	LD A, (MainObject)	 ; A545 3A E8 B6	; Carga cdigo objeto principal
	cmpa	1,y			; is the container of the object?	; 	CP (IY+$01)		 ; A548 FD BE 01	; Compara A con (IY+$01)
	lbne	IfB6FAis1DescAction	; no, desc action if B6fa is 1		; 	JP NZ, IfB6FAis1DescAction ; A54B C2 76 9F	; si flag Z=0, salta a IfB6FAis1DescAction
	jsr	GetObjPointer2IX	; get pointer				; 	CALL GetObjPointer2IX	 ; A54E CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	jsr	TestOpenFlag		; is it open?				; 	CALL TestOpenFlag	 ; A551 CD CA A5	; llama TestOpenFlag
	lbeq	PrintObjStatus		; no, show status			; 	JP Z, PrintObjStatus	 ; A554 CA 6C A1	; si flag Z=1, salta a PrintObjStatus con A=$05 (flag5=0) closed
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A557 CD 44 9D	; llama BreakIfB6faNot1
	ldb	#$ff			; put NO container
	ldy	<reg_IY			; restore pseudoreg
	stb	1,y			; in object				; 	LD (IY+$01), $FF	 ; A55A FD 36 01 FF	; Carga (IY+$01) con $FF
	rts				; return				; 	RET			 ; A55E C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#277# --)
L_A55F	ldy	ObjectPointer		; get pointer				; L_A55F: LD IY, (ObjectPointer) ; A55F FD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IY			; save it
	lda	MainObject		; get main obj ID			; 	LD A, (MainObject)	 ; A563 3A E8 B6	; Carga cdigo objeto principal
	cmpa	1,y			; is the container of object?		; 	CP (IY+$01)		 ; A566 FD BE 01	; Compara A con (IY+$01)
	lbeq	IfB6FAis1DescAction	; yes, desc action			; 	JP Z, IfB6FAis1DescAction ; A569 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	ldy	MainObjectPtr		; get main obj pointer			; 	LD IY, (MainObjectPtr)	 ; A56C FD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IY			; save it
	jsr	ReachesItBilbo		; see if Bilbo sees it			; 	CALL ReachesItBilbo	 ; A570 CD 34 9E	; Llama a ReachesItBilbo
	lbeq	IfB6FAis1DescAction	; no, desc action			; 	JP Z, IfB6FAis1DescAction ; A573 CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	lda	MainObject		; get object ID				; 	LD A, (MainObject)	 ; A576 3A E8 B6	; Carga cdigo objeto principal
i_A579	jsr	GetObjPointer2IX	; get its pointer			; i_A579: CALL GetObjPointer2IX	 ; A579 CD CA 9B	; llama GetObjPointer2IX devuelve puntero al objeto en IX
	lda	1,y			; get container				; 	LD A, (IX+$01)		 ; A57C DD 7E 01	; Carga A con (IX+$01)
	cmpa	#$ff			; is it none?				; 	CP $FF			 ; A57F FE FF		; Compara A con $FF
	beq	i_A596			; yes, skip section			; 	JR Z, i_A596		 ; A581 28 13		; Si Z = 1, Salta a i_A596
	lda	ActionActor		; get actor ID				; 	LD A, (ActionActor)	 ; A583 3A EA B6	; Carga ActionActor
	cmpa	1,y			; is actor the container?		; 	CP (IX+$01)		 ; A586 DD BE 01	; Compara A con (IX+$01)
	tfr	cc,b			; save flags
	lda	1,y			; get main object container		; 	LD A, (IX+$01)		 ; A589 DD 7E 01	; Carga A con (IX+$01)
	tfr	b,cc			; restore flags
	bne	i_A579			; if actor is not container, loopback	; 	JR NZ, i_A579		 ; A58C 20 EB		; Si Z = 0, Salta a i_A579
	ldy	MainObjectPtr		; get main obj pointer			; 	LD IX, (MainObjectPtr)	 ; A58E DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	ldb	#$ff			; put NO container
	stb	1,y			; in it					; 	LD (IX+$01), $FF	 ; A592 DD 36 01 FF	; Carga (IX+$01) con $FF
i_A596	ldy	ObjectPointer		; get Object pointer			; i_A596: LD IY, (ObjectPointer) ; A596 FD 2A 0C B7	; recupera ObjectPointer
	sty	<reg_IY			; save it
	lda	ActionActor		; get actor ID				; 	LD A, (ActionActor)	 ; A59A 3A EA B6	; Carga ActionActor
	jsr	L_9CE8			; call L_9CE8 - volume calculation	; 	CALL L_9CE8		 ; A59D CD E8 9C	; llama rutina L_9CE8  (#183# --)
	ldy	<reg_IY			; get pseudoreg
	adda	2,y			; add actor volume			; 	ADD A, (IY+$02)		 ; A5A0 FD 86 02	; Adiciona (IY+$02) en A
	bcs	i_A5A7			; if overflow, skip next		; 	JR C, i_A5A7		 ; A5A3 38 02		; Si C = 1, Salta a i_A5A7
	lda	#$ff			; set value -1				; 	LD A, $FF		 ; A5A5 3E FF		; Carga A con $FF
i_A5A7	sta	<reg_B			; save volume in reg_B			; i_A5A7: LD B, A		 ; A5A7 47		; Carga B con A
	ldy	MainObjectPtr		; get main obj pointer			; 	LD IX, (MainObjectPtr)	 ; A5A8 DD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IX			; save it
	jsr	TestOpenFlag		; is it open?				; 	CALL TestOpenFlag	 ; A5AC CD CA A5	; llama TestOpenFlag
	lbeq	PrintObjStatus		; no, show status			; 	JP Z, PrintObjStatus	 ; A5AF CA 6C A1	; si flag Z=1, salta a PrintObjStatus con A=$05 (flag5=0) closed
	lda	2,y			; get Object volume			; 	LD A, (IX+$02)		 ; A5B2 DD 7E 02	; Carga A con (IX+$02)
	cmpa	#$ff			; is it maximum value?			; 	CP $FF			 ; A5B5 FE FF		; Compara A con $FF
	beq	i_A5C0			; yes, skip three			; 	JR Z, i_A5C0		 ; A5B7 28 07		; Si Z = 1, Salta a i_A5C0
	ldx	#L_B13E			; point to message			; 	SUB B			 ; A5B9 90		; Resta B de A
	suba	<reg_B			; subtract saved volume			; 	LD HL, L_B13E		 ; A5BA 21 3E B1	; apunta a mensaje "You are too big"
	lbcc	PrintMsg		; if not borrow, show msg		; 	JP NC, PrintMsg		 ; A5BD D2 DD 72	; si no hay acarreo, salta a PrintMsg
i_A5C0	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; i_A5C0: CALL BreakIfB6faNot1	 ; A5C0 CD 44 9D	; llama BreakIfB6faNot1
	lda	MainObject		; get main obj ID			; 	LD A, (MainObject)	 ; A5C3 3A E8 B6	; Carga cdigo objeto principal
	ldy	<reg_IY			; get pseudoreg	
	sta	1,y			; update container			; 	LD (IY+$01), A		 ; A5C6 FD 77 01	; Carga (IY+$01) con A
	rts				; return				; 	RET			 ; A5C9 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; returns the status value on Z flag
TestOpenFlag									; TestOpenFlag:						; y ademas devuelve A = $05. Antes ; (#188# --)
	ldy	<reg_IX			; to avoid errors on wrong calls AS IT uses regY to point to the Object
	ldb	7,y			; get status byte
	lda	#5			; get this value (bitnuber?)		; 	BIT 5, (IX+$07)		 ; A5CA DD CB 07 6E	; Est a 1 el bit 5 de (IX+$07)? (byte de flags del objeto apuntado por IX)
	bitb	#%00100000		; is it open?				; 	LD A, $05		 ; A5CE 3E 05		; Carga A con $05
	rts				; return				; 	RET			 ; A5D0 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntado desde $C934 de (#45#)
L_A5D1	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; L_A5D1: CALL BreakIfB6faNot1	 ; A5D1 CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_C442+16		; point to vicious warg location	; 	LD HL, L_C442 + $10	 ; A5D4 21 52 C4	; apunta a la localizacin del objeto $43 vicious warg
	lda	L_C11B+16		; get Bilbo location			; 	LD A, (L_C11B + $10)	 ; A5D7 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A5DA BE		; Compara A con (HL)
	bne	e_A5D1			; no, exit				; 	RET NZ			 ; A5DB C0		; Si Z = 0, Retorna
	ldx	#L_B085			; point to message			; 	LD HL, L_B085		 ; A5DC 21 85 B0	; apunta a mensaje "the vicious warg run around you and howls."
	lbra	L_97F4			; go L_97F4				; 	JP L_97F4		 ; A5DF C3 F4 97	; Salta a L_97F4
e_A5D1	rts									; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#265# --)
L_A5E2	lda	MainObject		; get main object			; L_A5E2: LD A, (MainObject)	 ; A5E2 3A E8 B6	; Carga cdigo objeto principal
	cmpa	#$13			; is it 'barrel'			; 	CP $13			 ; A5E5 FE 13		; Compara A con $13
	bne	e_A5E2			; no, exit				; 	RET NZ			 ; A5E7 C0		; Si Z = 0, Retorna
	jsr	BreakIfB6faAndfbZero	; exit if b6fa-fb are zero		; 	CALL BreakIfB6faAndfbZero ; A5E8 CD FF 97	; llama BreakIfB6faAndfbZero
	ldu	#L_C3EE			; point to object 'barrel'		; 	LD IX, L_C3EE		 ; A5EB DD 21 EE C3	; Carga IX con L_C3EE
	stu	<reg_IX			; save pointer
	lda	16,u			; get location				; 	LD A, (IX+$10)		 ; A5EF DD 7E 10	; Carga A con (IX+$10)
	cmpa	#$21			; is it 'forest river'?			; 	CP $21			 ; A5F2 FE 21		; Compara A con $21
	bne	e_A5E2			; no, exit				; 	RET NZ			 ; A5F4 C0		; Si Z = 0, Retorna
	lda	#2			; put value 2				; 	LD A, $02		 ; A5F5 3E 02		; pone valor $02
	sta	BilboEvents+1		; in Bilbo events related to 'barrel'	; 	LD (BilboEvents+$01), A	 ; A5F7 32 85 CA	; en contador1 del primer bloque de 7 bytes en BilboEvents
e_A5E2	rts				; return				; 	RET			 ; A5FA C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CA86-87
L_A5FB	clra				; clear					; L_A5FB: SUB A			 ; A5FB 97		; pone 0
	sta	L_B6F0			; L_B6F0				; 	LD (L_B6F0), A		 ; A5FC 32 F0 B6	; en L_B6F0
	lda	L_C11B+1		; get Bilbo's container			; 	LD A, (L_C11B + $01)	 ; A5FF 3A 1C C1	; recupera ID del posible contenedor de Bilbo
	ldx	#L_B32C			; point to message			; 	CP $13			 ; A602 FE 13		; es el barrel?
	cmpa	#$13			; is in the 'barrel'?			; 	LD HL, L_B32C		 ; A604 21 2C B3	; apunta a mensaje "you are thrown onto the bank of the long lake"
	bne	1f			; no, skip next
	jsr	PrintMsg		; show msg				; 	CALL Z, PrintMsg	 ; A607 CC DD 72	; si esta en el 'barrel', llama rutina PrintMsg
1	lda	#$22			; get ID for 'long lake'		; 	LD A, $22		 ; A60A 3E 22		; Carga A con $22
	sta	L_C3EE+16		; put as 'barrel' location 		; 	LD (L_C3EE + $10), A	 ; A60C 32 FE C3	; actualiza localizacin del objeto $13 barrel
	sta	<reg_B			; save location ID			; 	LD B, A			 ; A60F 47		; Carga B con A
	lda	#$13			; get ID for 'barrel'			; 	LD A, $13		 ; A610 3E 13		; Carga A con $13 (ID de 'barrel')
	jsr	L_9BDD			; call L_9BDD				; 	CALL L_9BDD		 ; A612 CD DD 9B	; llama rutina L_9BDD (#186# --)
	ldu	#L_C3EE			; point to 'barrel'			; 	LD IX, L_C3EE		 ; A615 DD 21 EE C3	; Carga IX con L_C3EE
	stu	<reg_IX			; save pointer
	ldb	#$20			; get ID for 'elvenkings cellar'
	stb	16,u			; put as 'barrel' location		; 	LD (IX+$10), $20	 ; A619 DD 36 10 20	; Carga (IX+$10) con $20 (localizacin = 'elvenkings cellar')
	ldb	7,u			; get flags
	andb	#%11011111		; set to closed				; 	RES 5, (IX+$07)		 ; A61D DD CB 07 AE	; Pasa a 0 el bit 5 en (IX+$07) = 'cerrado'
	orb	#%00000100		; and full				; 	SET 2, (IX+$07)		 ; A621 DD CB 07 D6	; Pasa a 1 el bit 2 en (IX+$07) = 'lleno'
	stb	7,u			; update flags
	clra				; put zero				; 	SUB A			 ; A625 97		; Resta A de A
	sta	L_B702			; to L_B702				; 	LD (L_B702), A		 ; A626 32 02 B7	; Carga (L_B702) con A
	lda	#$13			; get 'barrel' ID			; 	LD A, $13		 ; A629 3E 13		; Carga A con $13
	jsr	AnalyzeObjContents	; see what it contains			; 	CALL AnalyzeObjContents  ; A62B CD 53 9D	; llama AnalyzeObjContents
	lda	#1			; put value 1				; 	LD A, $01		 ; A62E 3E 01		; Carga A con $01
	sta	L_B702			; to L_B702				; 	LD (L_B702), A		 ; A630 32 02 B7	; Carga (L_B702) con A
	ldu	#L_C418			; point to 'wine' 			; 	LD IY, L_C418		 ; A633 FD 21 18 C4	; Carga IY con L_C418
	stu	<reg_IY			; save ptr
	ldb	#$20			; get ID for 'elvenkings cellar'
	stb	16,u			; put as 'wine' location		; 	LD (IY+$10), $20	 ; A637 FD 36 10 20	; Carga (IY+$10) con $20
	ldb	#$13			; get ID for 'barrel'
	stb	1,u			; put as 'wine' container		; 	LD (IY+$01), $13	 ; A63B FD 36 01 13	; Carga (IY+$01) con $13
	rts				; return				; 	RET			 ; A63F C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntado desde $C900 de (#45#)
L_A640	lda	ObjectLocation		; get location				; L_A640: LD A, (ObjectLocation) ; A640 3A F6 B6	; recupera ObjectLocation
	ldx	#BilboLocation		; point to Bilbo location		; 	LD HL, BilboLocation	 ; A643 21 F5 B6	; apunta a BilboLocation
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A646 BE		; Compara A con (HL)
	bne	e_A640			; no, exit				; 	RET NZ			 ; A647 C0		; Si Z = 0, Retorna
	lda	L_C11B+7		; get Bilbo's flags			; 	LD A, (L_C11B + $07)	 ; A648 3A 22 C1	; apunta al byte 7 (flags) del objeto $00 - Bilbo
	bita	#%10000000		; is he visible?			; 	BIT 7, A		 ; A64B CB 7F		; Esta a 1 el bit 7 de A?
	bne	e_A640			; yes, exit				; 	RET NZ			 ; A64D C0		; Si Z = 0, Retorna
	jsr	BreakIfB6faNot1		; exit if b6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A64E CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_B0CB			; point to message			; 	LD HL, L_B0CB		 ; A651 21 CB B0	; apunta a mensaje "where's the thief ?[0x16]"
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A654 C3 E3 A1	; salta a AppendSayMessage
e_A640	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntado desde $C90D de (#45#)
L_A657	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A657: CALL BreakIfB6faNot1	 ; A657 CD 44 9D	; llama BreakIfB6faNot1
	lda	#8			; max random				; 	LD A, $08		 ; A65A 3E 08		; Carga A con $08
	jsr	GetPosRandom		; gte a random number			; 	CALL GetPosRandom	 ; A65C CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	cmpa	#5			; is it greater/equal than 5?		; 	CP $05			 ; A65F FE 05		; Compara A con $05
	bcc	e_A640			; yes, exit (5-6-7-8)			; 	RET NC			 ; A661 D0		; Si C = 0, Retorna
	ldx	#L_B0F4			; point to message			; 	CP $03			 ; A662 FE 03		; Compara A con $03
	cmpa	#3			; is it greater/equal than 3?		; 	LD HL, L_B0F4		 ; A664 21 F4 B0	; apunta a mensaje "thorin wait."
	lbcc	L_97F4			; yes (3-4) show message		; 	JP NC, L_97F4		 ; A667 D2 F4 97	; Si C = 0, Salta a L_97F4
	ldx	#L_B0D5			; point to message			; 	LD HL, L_B0D5		 ; A66A 21 D5 B0	; apunta a mensaje "get us out of this one, thief ![0x16]"
	lbeq	AppendSayMessage	; show it				; 	JP Z, AppendSayMessage	 ; A66D CA E3 A1	; si flag Z=1, salta a AppendSayMessage
	ldx	#L_B0E5			; point to message			; 	LD HL, L_B0E5		 ; A670 21 E5 B0	; apunta a mensaje "thorin sit(s|d|ing|es) down and start(s|d|ing|es) sing(s|d|ing|es) about gold." 
	tsta				; was random eq 0?			; 	CP $00			 ; A673 FE 00		; Compara A con $00
	lbeq	L_97F4			; yes, show message			; 	JP Z, L_97F4		 ; A675 CA F4 97	; Si Z = 1, Salta a L_97F4
	ldx	#L_B05B			; else (1-2) get message		; 	LD HL, L_B05B		 ; A678 21 5B B0	; apunta a mensaje "hurry up."
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A67B C3 E3 A1	; salta a AppendSayMessage
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#264# --)
L_A67E	ldu	ObjectPointer		; get pointer				; L_A67E: LD IX, (ObjectPointer) ; A67E DD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IX			; save it
	lda	16,u			; get location				; 	LD A, (IX+$10)		 ; A682 DD 7E 10	; Carga A con (IX+$10)
	ldx	#L_B11B			; point to message			; 	CP $20			 ; A685 FE 20		; Compara A con $20
	cmpa	#$20			; is loc 'elvenkings cellar'?		; 	LD HL, L_B11B		 ; A687 21 1B B1	; apunta a mensaje "you cannot reach[0x07][0x15]"
	lbne	PrintMsg		; no, show msg				; 	JP NZ, PrintMsg		 ; A68A C2 DD 72	; si no es cero, salta a PrintMsg
	lda	CurrentAction		; get action				; 	LD A, (CurrentAction)	 ; A68D 3A E7 B6	; Carga ID de accin
	cmpa	#$0c			; is it 'close'?			; 	CP $0C			 ; A690 FE 0C		; Compara A con $0C
	lbeq	L_9138			; yes, goto L_9138			; 	JP Z, L_9138		 ; A692 CA 38 91	; si flag Z=1, salta a L_9138 (#247# --)
	lbra	L_910E			; goto L_910E				; 	JP L_910E		 ; A695 C3 0E 91	; salta a L_910E (#238# --)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; llamada desde $C9C2 en (#45#)
L_A698	lda	L_C11B+16		; get Bilbo's location 			; L_A698: LD A, (L_C11B + $10)	 ; A698 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	cmpa	#$27			; is it 'front gate'?			; 	CP $27			 ; A69B FE 27		; Compara A con $27
	beq	i_A6A6			; yes, skip controls			; 	JR Z, i_A6A6		 ; A69D 28 07		; Si Z = 1, Salta a i_A6A6
	cmpa	#$2C			; is it 'lonely mountain'?		; 	CP $2C			 ; A69F FE 2C		; Compara A con $2C
	beq	i_A6A6			; yes, skip control			; 	JR Z, i_A6A6		 ; A6A1 28 03		; Si Z = 1, Salta a i_A6A6
	cmpa	#$29			; is it 'lower halls'?			; 	CP $29			 ; A6A3 FE 29		; Compara A con $29
	bne	e_A6BE			; no, exit				; 	RET NZ			 ; A6A5 C0		; Si Z = 0, Retorna
i_A6A6	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; i_A6A6: CALL BreakIfB6faNot1	 ; A6A6 CD 44 9D	; llama BreakIfB6faNot1
	lda	L_C11B+16		; get Bilbo's location			; 	LD A, (L_C11B + $10)	 ; A6A9 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	ldx	#L_C133+16		; poin to 'red golden dragon' location 	; 	LD HL, L_C133 + $10	 ; A6AC 21 43 C1	; apunta a la locaclizacin del objeto $3C red golden dragon
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A6AF BE		; Compara A con (HL)
	beq	e_A6BE			; yes, exit				; 	RET Z			 ; A6B0 C8		; Z = 1?	; Retorna si es cero
	sta	,x			; put Bilbo loc to the 'dragon' too	; 	LD (HL), A		 ; A6B1 77		; Carga (HL) con A
	lda	#1			; put value 1				; 	LD A, $01		 ; A6B2 3E 01		; Carga A con $01
	sta	L_B702			; to L_B702				; 	LD (L_B702), A		 ; A6B4 32 02 B7	; Carga (L_B702) con A
	ldx	#L_C133+8		; point to 1st desc word of dragon	; 	LD HL, L_C133 + $08	 ; A6B7 21 3B C1	; apunta a palabra 3a (offset 8-9) del objeto $3C red golden dragon
	pshs	x			; pass as parameter			; 	PUSH HL			 ; A6BA E5		; Guarda HL
	ldx	#L_B017			; point to message			; 	LD HL, L_B017		 ; A6BB 21 17 B0	; apunta a mensaje "[0x00] enter(s|d|ing|es).[0x14]"
L_A6BE	jsr	PrintMsg		; show msg				; L_A6BE: CALL PrintMsg		 ; A6BE CD DD 72	; llama rutina PrintMsg
e_A6BE	rts				; return				; 	RET			 ; A6C1 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntada por $C9C8 en (#45#)
L_A6C2	lda	L_C11B+16		; get Bilbo's location			; L_A6C2: LD A, (L_C11B + $10)	 ; A6C2 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	ldx	#ObjectLocation		; get locaion pointer			; 	LD HL, ObjectLocation	 ; A6C5 21 F6 B6	; apunta a ObjectLocation
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A6C8 BE		; Compara A con (HL)
	bne	e_A6DA			; no, exit				; 	RET NZ			 ; A6C9 C0		; Si Z = 0, Retorna
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A6CA CD 44 9D	; llama BreakIfB6faNot1
	lda	L_C11B+7		; get Bilbo's flags			; 	LD A, (L_C11B + $07)	 ; A6CD 3A 22 C1	; recupera el byte 7 (flags) del objeto $00 - Bilbo
	ldx	#L_B17E			; point to message			; 	AND $80			 ; A6D0 E6 80		; Hace AND lgico de A con $80
	anda	#%10000000		; is Bilbo visible?			; 	LD HL, L_B17E		 ; A6D2 21 7E B1	; apunta a mensaje "the dragon say(s|d|ing|es) " I may not be able to see you thief but I can still burn you. prepare to die " .[0x14]"
	beq	i_A6DA			; no, skip next				; 	JR Z, i_A6DA		 ; A6D5 28 03		; Si Z = 1, Salta a i_A6DA
	ldx	#L_B15D			; point to message			; 	LD HL, L_B15D		 ; A6D7 21 5D B1	; apunta a mensaje "the dragon say(s|d|ing|es) " Well thief your cunning has failed you this time. prepare to die " .[0x14]"
i_A6DA	bra	L_A6BE			; goto L_A6BE				; i_A6DA: JR L_A6BE		 ; A6DA 18 E2		; Salta a L_A6BE
e_A6DA	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; llamada desde $C9B9 en (#45#)
L_A6DC	lda	L_C5CD+16		; get 'valuable treasure' location	; L_A6DC: LD A, (L_C5CD + $10)	 ; A6DC 3A DD C5	; recupera localizacin (offset 16) del tesoro (objeto $23 inicio en L_C5CD)
	cmpa	#$29			; is it 'lower halls'?			; 	CP $29			 ; A6DF FE 29		; est en la situacin inicial?
	beq	e_A6DC			; yes, exit				; 	RET Z			 ; A6E1 C8		; Z = 1?	; Retorna si es cierto
	lda	L_C11B+16		; get Bilbo's location			; 	LD A, (L_C11B + $10)	 ; A6E2 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	jsr	GetLocPointer2IX	; get its pointer			; 	CALL GetLocPointer2IX	 ; A6E5 CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	ldb	,y			; get loc flags
	bitb	#%10000000		; has it light?				; 	BIT 7, (IX+$00)		 ; A6E8 DD CB 00 7E	; byte 0 de localizacin indica con bit7 a 1 si tiene preposicin asociada
	beq	e_A6DC			; no, exit 				; 	RET Z			 ; A6EC C8		; Z = 1?	; Retorna si no tiene preposicin
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A6ED CD 44 9D	; llama BreakIfB6faNot1
	lda	#1			; put value 1				; 	LD A, $01		 ; A6F0 3E 01		; si tiene preposicin, y pone un 1
	sta	L_B702			; to L_B702				; 	LD (L_B702), A		 ; A6F2 32 02 B7	; en L_B702
	ldx	#L_B1A6			; point to message			; 	LD HL, L_B1A6		 ; A6F5 21 A6 B1	; apunta a mensaje "in the distance you see the shape of a monstrous dragon flying after you"
	lda	#100			; max value 100				; 	LD A, $64		 ; A6F8 3E 64		; Carga A con $64
	jsr	GetPosRandom		; for random number			; 	CALL GetPosRandom	 ; A6FA CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	cmpa	#80			; is random < 80?			; 	CP $50			 ; A6FD FE 50		; Compara A con $50
	bcs	L_A6BE			; yes, foto L_A6BE			; 	JR C, L_A6BE		 ; A6FF 38 BD		; Si C = 1, Salta a L_A6BE
	ldx	#L_B1BA			; point to message			; 	LD HL, L_B1BA		 ; A701 21 BA B1	; apunta a mensaje "the dragon descends and in a terrific{5} spout of flames burn(s|d|ing|es) you to a crisp[0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; A704 CD DD 72	; llama rutina PrintMsg
	lbra	BilboIsDeadEndGame	; end game				; 	JP BilboIsDeadEndGame	 ; A707 C3 D2 90	; salta a BilboIsDeadEndGame
e_A6DC	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#271# --)
L_A71E	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A71E: CALL BreakIfB6faNot1	 ; A71E CD 44 9D	; llama BreakIfB6faNot1
	ldu	ObjectPointer		; get pointer				; 	LD IX, (ObjectPointer)	 ; A721 DD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IX			; save it
	ldb	7,u			; get flags
	ldx	#L_AFF4			; point to message			; 	BIT 7, (IX+$07)		 ; A725 DD CB 07 7E	; Esta a 1 el bit 7 de (IX+$07)?
	bitb	#%10000000		; is it visible?			; 	LD HL, L_AFF4		 ; A729 21 F4 AF	; apunta a mensaje "You see nothing special here"
	lbne	PrintMsg		; no, show msg				; 	JP NZ, PrintMsg		 ; A72C C2 DD 72	; si no es cero, salta a PrintMsg
	lda	D_CAA7			; get byte reated to 'magic door'	; 	LD A, (D_CAA7)		 ; A72F 3A A7 CA	; Carga A con (D_CAA7)
	sta	D_CAA8			; activate its script			; 	LD (D_CAA8), A		 ; A732 32 A8 CA	; Carga (D_CAA8) con A
	ldx	#L_B2AA			; point to message			; 	LD HL, L_B2AA		 ; A735 21 AA B2	; apunta a mensaje "The magic door warn(s|d|ing|es) of elves approach(s|d|ing|es)[0x15]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; A738 C3 DD 72	; salta a PrintMsg 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#272# --)
L_A73B	ldx	#L_C3B2+7		; point to 'thorin' flags 		; L_A73B: LD HL, L_C3B2 + $07	 ; A73B 21 B9 C3	; apunta a flags objeto $3f Thorin
	ldb	,x			; get flags
	bitb	#%00001000		; is he dead?				; 	BIT 3, (HL)		 ; A73E CB 5E		; Esta a 1 el bit 3 de (HL)?
	beq	e_A73B			; no, exit				; 	RET Z			 ; A740 C8		; Z = 1?	; Retorna si es cero
	jsr	BreakIfB6faAndfbZero	; exit if B6fa-fb are zero		; 	CALL BreakIfB6faAndfbZero ; A741 CD FF 97	; llama BreakIfB6faAndfbZero
	ldu	#L_C1AD			; point to 'small curious key'		; 	LD IX, L_C1AD		 ; A744 DD 21 AD C1	; Carga IX con L_C1AD
	stu	<reg_IX			; save ptr
	ldb	7,u			; get flags
	orb	#%00001000		; set to 'broken'
	stb	7,u			; update flags				; 	SET 3, (IX+$07)		 ; A748 DD CB 07 DE	; Pasa a 1 el bit 3 en (IX+$07)
	lda	#2			; get ID for 'small curious key'	; 	LD A, $02		 ; A74C 3E 02		; Carga A con $02
	jsr	UpdateDeadObject	; clear desc and put 'broken'		; 	CALL UpdateDeadObject	 ; A74E CD 8C A1	; llama UpdateDeadObject
	lda	#2			; get ID for 'small curious key'	; 	LD A, $02		 ; A751 3E 02		; Carga A con $02
	ldu	#OBJ_TABLE		; point to object table	(Bilbo)		; 	LD IY, OBJ_TABLE	 ; A753 FD 21 1B C1	; Carga IY con OBJ_TABLE
	stu	<reg_IY			; save ptr
	jsr	L_9E25			; are in same location (Bilbo, key)?	; 	CALL L_9E25		 ; A757 CD 25 9E	; llama rutina L_9E25 (#161# --)
	beq	e_A73B			; no, exit				; 	RET Z			 ; A75A C8		; Z = 1?	; Retorna si es cero
	ldx	#L_B109			; point to message			; 	LD HL, L_B109		 ; A75B 21 09 B1	; apunta a mensaje "the small curious key shatter(s|d|ing|es)[0x15]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg		 ; A75E C3 DD 72	; salta a PrintMsg
e_A73B	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#283# --)
L_A761	lda	ActionActor		; is Bilbo the actor?			; L_A761: LD A, (ActionActor)	 ; A761 3A EA B6	; Carga ActionActor
										; 	CP $00			 ; A764 FE 00		; Compara A con $00
	bne	i_A776			; no, skip section			; 	JR NZ, i_A776		 ; A766 20 0E		; Si Z = 0, Salta a i_A776
	lda	L_C11B+1		; get Bilbo's container			; 	LD A, (L_C11B + $01)	 ; A768 3A 1C C1	; recupera ID del posible contenedor de Bilbo
	ldx	#L_B11B			; point to message			; 	LD HL, L_B11B		 ; A76B 21 1B B1	; apunta a mensaje "you cannot reach[0x07][0x15]"
	cmpa	#$ff			; was no container?			; 	CP $FF			 ; A76E FE FF		; Compara A con $FF
	lbeq	PrintMsg		; yes, show msg				; 	JP Z, PrintMsg		 ; A770 CA DD 72	; si flag Z = 1, salta a PrintMsg
	lbra	IfB6FAis1DescAction	; show desc				; 	JP IfB6FAis1DescAction	 ; A773 C3 76 9F	; salta a IfB6FAis1DescAction
i_A776	lda	CurrentAction		; get action				; i_A776: LD A, (CurrentAction)	 ; A776 3A E7 B6	; Carga ID de accin
	cmpa	#$0c			; is it 'close'?			; 	CP $0C			 ; A779 FE 0C		; Compara A con $0C
	lbeq	L_9138			; yes, goto L_9138			; 	JP Z, L_9138		 ; A77B CA 38 91	; si flag Z=1, salta a L_9138 (#247# --)
	cmpa	#$10			; is it 'open'?				; 	CP $10			 ; A77E FE 10		; Compara A con $10
	lbeq	L_910E			; yes, goto L_910E			; 	JP Z, L_910E		 ; A780 CA 0E 91	; si flag Z=1, salta a L_910E (#238# --)
	rts				; return				; 	RET			 ; A783 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#282# --)
L_A784	lda	ActionActor		; is Bilbo the actor?			; L_A784: LD A, (ActionActor)	 ; A784 3A EA B6	; Carga ActionActor
										; 	CP $00			 ; A787 FE 00		; Compara A con $00
	bne	i_A797			; no, skip section			; 	JP NZ, i_A797		 ; A789 C2 97 A7	; Si Z = 0, Salta a i_A797
	lda	L_C11B+1		; get Bilbo's container			; 	LD A, (L_C11B + $01)	 ; A78C 3A 1C C1	; recupera ID del posible contenedor de Bilbo
	ldx	#L_B11B			; point to message 			; 	CP $FF			 ; A78F FE FF		; Compara A con $FF
	cmpa	#$ff			; was no container?			; 	LD HL, L_B11B		 ; A791 21 1B B1	; apunta a mensaje "you cannot reach[0x07][0x15]"
	lbeq	PrintMsg		; yes, show msg				; 	JP Z, PrintMsg		 ; A794 CA DD 72	; si flag Z = 1, salta a PrintMsg
i_A797	lda	CurrentAction		; get action				; i_A797: LD A, (CurrentAction)	 ; A797 3A E7 B6	; Carga ID de accin
	cmpa	#$1e			; is it 'go through'?			; 	CP $1E			 ; A79A FE 1E		; Compara A con $1E
	lbeq	L_8F3B			; yes, goto L_8F3B			; 	JP Z, L_8F3B		 ; A79C CA 3B 8F	; si flag Z=1, salta a L_8F3B (#249# --)
	cmpa	#$0b			; is it 'strike with'?			; 	CP $0B			 ; A79F FE 0B		; Compara A con $0B
	lbeq	L_92ED			; yes, goto L_92ED			; 	JP Z, L_92ED		 ; A7A1 CA ED 92	; si flag Z=1, salta a L_92ED (#245# --)
	cmpa	#$18			; is it 'look through'?			; 	CP $18			 ; A7A4 FE 18		; Compara A con $18
	lbeq	L_8EEC			; yes, goto L_8EEC			; 	JP Z, L_8EEC		 ; A7A6 CA EC 8E	; si flag Z=1, salta a L_8EEC (#248# --)
	rts				; return				; 	RET			 ; A7A9 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; DETERMINER table 1 (#D26#) son $098 (8) bytes
DetTable1						; the,a,an,some
	fdb L_669F-$6000	; AD2D $06,$9F		; palabra THE
	fdb L_6040-$6000	; AD2F $00,$40		; palabra A
	fdb L_6058-$6000	; AD31 $00,$58		; palabra AN
	fdb L_6603-$6000	; AD33 $06,$03		; palabra SOME					
							; End of Determiner table 1
							; last byte occupied is $AD34 (verified) 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; DETERMINER table 2 (#D27#) son $08 (8) bytes
DetTable2						; the,the,the,some
	fdb $669F-$6000		; AD35 $06,$9F		; palabra THE
	fdb $669F-$6000		; AD37 $06,$9F		; palabra THE
	fdb $669F-$6000		; AD39 $06,$9F		; palabra THE
	fdb $6603-$6000		; AD3B $06,$03		; palabra SOME					
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CAB7-B8
L_AB0B	clra				; put zero 				; L_AB0B: SUB A			 ; AB0B 97      	; pone a 0
	sta	L_B700			; in L_B700				; 	LD (L_B700), A		 ; AB0C 32 00 B7	; L_B700
	rts				; return				; 	RET			 ; AB0F C9		; Retorna
										; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
	zmb	$6000-*			; Dictionary begins exactly at $6000
	include "HOB_DATOS-08A25.txt"	; added data for ProcessBilboEvents
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Preposition Table (#D37#) son $A (10) bytes
PREP_TABLE
	fdb L_64C2-$6000+$8000		; BA80 $84,$C2	; palabra OUTSIDE
	fdb L_637B-$6000+$8000		; BA82 $83,$7B	; palabra INSIDE
	fdb L_6378-$6000+$8000		; BA84 $83,$78	; palabra IN
	fdb L_64AA-$6000+$8000		; BA86 $84,$AA	; palabra ON
	fdb L_6070-$6000+$8000		; BA88 $80,$70	; palabra AT
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CAA2-CAA3, $CAA5-CAA6
L_A7AA	lda	L_C11B+16		; get Bilbo's location			; L_A7AA: LD A, (L_C11B + $10)	 ; A7AA 3A 2B C1 	; recupera localizacin del objeto $00 - Bilbo
	cmpa	#$1d			; is it 'deep bog'?			; 	CP $1D			 ; A7AD FE 1D		; Compara A con $1D
	bne	i_A7B5			; no, skip two				; 	JR NZ, i_A7B5		 ; A7AF 20 04		; Si Z = 0, Salta a i_A7B5
	clra				; put zero				; 	SUB A			 ; A7B1 97		; Resta A de A
	sta	D_CAA1			; disable its macro			; 	LD (D_CAA1), A		 ; A7B2 32 A1 CA	; Carga (D_CAA1) con A
i_A7B5	ldx	#L_B153			; point to message			; i_A7B5: LD HL, L_B153		 ; A7B5 21 53 B1	; apunta a mensaje "You are slowly sink(s|d|ing|es) into the bog"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; A7B8 CD DD 72	; llama rutina PrintMsg
	lda	D_CAA1			; get macro counter			; 	LD A, (D_CAA1)		 ; A7BB 3A A1 CA	; Carga A con (D_CAA1)
	bne	1f			; if not zero, skip next		; 	CP $00			 ; A7BE FE 00		; Compara A con $00
	lbra	BilboIsDeadEndGame	; end game				; 	RET NZ			 ; A7C0 C0		; Si Z = 0, Retorna
1	rts				; return				; 	JP BilboIsDeadEndGame	 ; A7C1 C3 D2 90	; salta a BilboIsDeadEndGame
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#253# --)
L_A7C4	lda	ActionActor		; get actor ID				; L_A7C4: LD A, (ActionActor)	 ; A7C4 3A EA B6	; Carga ActionActor
	cmpa	#$41			; is it 'elrond'?			; 	CP $41			 ; A7C7 FE 41		; Compara A con $41
	lbne	Action_Examine		; no, go examine action			; 	JP NZ, Action_Examine	 ; A7C9 C2 DA 93	; Si Z = 0, Salta a Action_Examine
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A7CC CD 44 9D	; llama BreakIfB6faNot1
D_A7CF	ldy	#$0000			; get pointer (value modif. by code)	; D_A7CF: LD IY, $0000		 ; A7CF FD 21 00 00	; Carga IY con $0000, esto se modifica en (#86# OK)
	sty	<reg_IY			; save it				; 	LD L, (IY+$01)		 ; A7D3 FD 6E 01	; Carga L con (IY+$01)
	ldx	1,y			; point to location output data		; 	LD H, (IY+$02)		 ; A7D6 FD 66 02	; Carga H con (IY+$02)
	lda	L_B6F1			; is L_B6F1 zero?			; 	LD A, (L_B6F1)		 ; A7D9 3A F1 B6	; Carga A con (L_B6F1)
	bne	i_A7EF			; no, skip section 			; 	CP $00			 ; A7DC FE 00		; Compara A con $00
	ldb	#3			; set val 3 (number of bytes x output)	; 	JR NZ, i_A7EF		 ; A7DE 20 0F		; Si Z = 0, Salta a i_A7EF
	stb	<reg_B			; in counter				; 	LD B, $03		 ; A7E0 06 03		; Carga B con $03
i_A7E2	lda	3,y			; get exit def bytes 			; i_A7E2: LD A, (IY+$03)	 ; A7E2 FD 7E 03	; Carga A con (IY+$03)
	sta	,x+			; copy to destination			; 	LD (HL), A		 ; A7E5 77		; Carga (HL) con A
	leay	1,y			; increment pointer			; 	INC HL			 ; A7E6 23		; Incrementa HL
	dec	<reg_B			; decrement counter			; 	INC IY			 ; A7E7 FD 23		; Incrementa IY
	bne	i_A7E2			; if not zero, loopback			; 	DJNZ i_A7E2		 ; A7E9 10 F7		; Decrementa B y si no es cero vuelve a i_A7E2
	ldy	D_A7CF+2		; get modifiable pointer value 		; 	LD IY, (D_A7CF + $02)	 ; A7EB FD 2A D1 A7	; Carga IY con (D_A7D1-D2)
	sty	<reg_IY			; save it
i_A7EF	lda	5,y			; get destination location		; i_A7EF: LD A, (IY+$05)	 ; A7EF FD 7E 05	; Carga A con (IY+$05)
	jsr	GetLocPointer2IX	; get its pointer			; 	CALL GetLocPointer2IX	 ; A7F2 CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	leay	2,y			; point to 1st description word		; 	INC IX			 ; A7F5 DD 23		; Incrementa IX
	sty	<reg_IX			; update pseudoreg			; 	INC IX			 ; A7F7 DD 23		; Incrementa IX
	pshs	y			; pass as parameter			; 	PUSH IX			 ; A7F9 DD E5		; Guarda IX
	ldy	<reg_IY			; point to modifiable output
	lda	,y			; get origin location			; 	LD A, (IY+$00)		 ; A7FB FD 7E 00	; Carga A con (IY+$00)
	jsr	GetLocPointer2IX	; get its pointer			; 	CALL GetLocPointer2IX	 ; A7FE CD B1 9B	; llama rutina GetLocPointer2IX recibe en IX puntero a localizacin de A
	leay	2,y			; point to 1st description word		; 	INC IX			 ; A801 DD 23		; Incrementa IX
	sty	<reg_IX			; update pseudoreg			; 	INC IX			 ; A803 DD 23		; Incrementa IX
	pshs	y			; pass as parameter			; 	PUSH IX			 ; A805 DD E5		; Guarda IX
	ldy	reg_IY			; point to modifiable output
	lda	3,y			; get move direction			; 	LD A, (IY+$03)		 ; A807 FD 7E 03	; Carga A con (IY+$03)
	jsr	SearchMoveWord		; convert to text pointer in DE		; 	CALL SearchMoveWord	 ; A80A CD BA A0	; llama SearchMoveWord
	ldu	<reg_DE			; get direction pointer
	pshs	u			; pass as parameter			; 	PUSH DE			 ; A80D D5		; Guarda DE
	ldx	#L_B1D0			; point to message			; 	LD HL, L_B1D0		 ; A80E 21 D0 B1	; apunta a mensaje "{5} go[0x01] from[0x00] to{5} get to[0x00][0x16]"
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A811 C3 E3 A1	; salta a AppendSayMessage
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#269# --)
L_A814	lda	SecondObject		; get 2nd obj ID			; L_A814: LD A, (SecondObject)	 ; A814 3A E9 B6	; Carga cdigo objeto secundario
	jsr	L_9F28			; call L_9F28				; 	CALL L_9F28		 ; A817 CD 28 9F	; llama rutina L_9F28 (#207# --)
	cmpa	#$ff			; found object in table?		; 	CP $FF			 ; A81A FE FF		; Compara A con $FF
	lbeq	IfB6FAis1DescAction	; no, desc action			; 	JP Z, IfB6FAis1DescAction ; A81C CA 76 9F	; si flag Z=1, salta a IfB6FAis1DescAction
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A81F CD 44 9D	; llama BreakIfB6faNot1
	ldx	#L_AF66			; point to message			; 	LD HL, L_AF66		 ; A822 21 66 AF	; apunta a mensaje "it sail(s|d|ing|es) across and."
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; A825 CD DD 72	; llama rutina PrintMsg
	lda	L_C61B+16		; get 'wooden boat' location 		; 	LD A, (L_C61B + $10)	 ; A828 3A 2B C6	; accede a localizacin del objeto $29 wooden boat
	ldu	<reg_IX			; get pseudoreg
	cmpa	2,u			; are locations same?			; 	CP (IX+$02)		 ; A82B DD BE 02	; Compara A con (IX+$02)
	bne	i_A84C			; no, skip section			; 	JR NZ, i_A84C		 ; A82E 20 1C		; Si Z = 0, Salta a i_A84C
	jsr	L_A86E			; get random 0-100			; 	CALL L_A86E		 ; A830 CD 6E A8	; llama rutina i_A86E (#239# --)
	bcs	i_A842			; if lower than 50, skip section	; 	JR C, i_A842		 ; A833 38 0D		; Si C = 1, Salta a i_A842
	ldx	#L_AF76			; point to message			; 	LD HL, L_AF76		 ; A835 21 76 AF	; apunta a mensaje "fall(s|d|ing|es) just short of the other side"
	jsr	L_A86E			; get random 0-100			; 	CALL L_A86E		 ; A838 CD 6E A8	; llama rutina i_A86E (#239# --)
	bcs	i_A86B			; if lower than 50, exit		; 	JR C, i_A86B		 ; A83B 38 2E		; Si C = 1, Salta a i_A86B
	ldx	#L_AF82			; point to message			; 	LD HL, L_AF82		 ; A83D 21 82 AF	; apunta a mensaje "[0x0b][0x08] but slide(s|d|ing|es) out again"
	bra	i_A86B			; get random 0-100			; 	JR i_A86B		 ; A840 18 29		; Salta a i_A86B
i_A842	lda	#$12			; put 'rope'				; i_A842: LD A, $12		 ; A842 3E 12		; Carga A con $12
	sta	L_C61B+1		; as 'wooden boat' container		; 	LD ($C61C), A		 ; A844 32 1C C6	; Carga ($C61C) con A
	ldx	#L_AF8B			; point to message			; 	LD HL, L_AF8B		 ; A847 21 8B AF	; apunta a mensaje "lands in the boat"
	bra	i_A86B			; show it and exit			; 	JR i_A86B		 ; A84A 18 1F		; Salta a i_A86B
i_A84C	ldx	#L_AF76			; point to message			; i_A84C: LD HL, L_AF76		 ; A84C 21 76 AF	; apunta a mensaje "fall(s|d|ing|es) just short of the other side"
	jsr	L_A86E			; get random 0-100			; 	CALL L_A86E		 ; A84F CD 6E A8	; llama rutina i_A86E (#239# --)
	bcs	i_A86B			; if lower than 50, exit		; 	JR C, i_A86B		 ; A852 38 17		; Si C = 1, Salta a i_A86B
	ldu	<reg_IX			; get pseudoreg
	lda	2,u			; get location				; 	LD A, (IX+$02)		 ; A854 DD 7E 02	; Carga A con (IX+$02)
	ldu	MainObjectPtr		; point to main object			; 	LD IX, (MainObjectPtr)	 ; A857 DD 2A 08 B7	; Carga MainObjectPtr
	sta	16,u			; update its location			; 	LD (IX+$10), A		 ; A85B DD 77 10	; Carga (IX+$10) con A
	ldb	#$ff			; set NO container
	stb	1,u			; to it					; 	LD (IX+$01), $FF	 ; A85E DD 36 01 FF	; Carga (IX+$01) con $FF
	lda	MainObject		; get main object ID			; 	LD A, (MainObject)	 ; A862 3A E8 B6	; Carga cdigo objeto principal
	jsr	L_9BDD			; call L_9BDD				; 	CALL L_9BDD		 ; A865 CD DD 9B	; llama rutina L_9BDD (#186# --)
	ldx	#L_AF6D			; point to message			; 	LD HL, L_AF6D		 ; A868 21 6D AF	; apunta a mensaje "lands on the other side"
i_A86B	lbra	PrintMsg		; show it				; i_A86B: JP PrintMsg		 ; A86B C3 DD 72	; salta a PrintMsg
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#239# --)
L_A86E	lda	#$64			; max value 100				; L_A86E: LD A, $64		 ; A86E 3E 64		; Carga A con $64
	jsr	GetPosRandom		; get a random number			; 	CALL GetPosRandom	 ; A870 CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
	cmpa	#$32			; set carry if number < 50		; 	CP $32			 ; A873 FE 32		; Compara A con $32
	rts				; return				; 	RET			 ; A875 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#270# --)
L_A876	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A876: CALL BreakIfB6faNot1	 ; A876 CD 44 9D	; llama BreakIfB6faNot1
	lda	L_C61B+1		; get 'wooden boat' container		; 	LD A, ($C61C)		 ; A879 3A 1C C6	; Carga A con ($C61C)
	cmpa	#$12			; is it 'rope'?				; 	CP $12			 ; A87C FE 12		; Compara A con $12
	bne	e_A890			; no, exit				; 	RET NZ			 ; A87E C0		; Si Z = 0, Retorna
	ldx	#L_AF92			; point to message			; 	LD HL, L_AF92		 ; A87F 21 92 AF	; apunta a mensaje "the boat glides across the river and lands on this side" 
i_A882	jsr	PrintMsg		; show it				; i_A882: CALL PrintMsg		 ; A882 CD DD 72	; llama rutina PrintMsg
	lda	L_C61B+16		; get 'wooden boat' location		; 	LD A, (L_C61B + $10)	 ; A885 3A 2B C6	; accede a localizacin del objeto $29 wooden boat
	cmpa	#$42			; is it	'west bank'?			; 	CP $42			 ; A888 FE 42		; Compara A con $42
	tfr	cc,b			; save flags
	lda	#$42			; get ID for 'west bank'		; 	LD A, $42		 ; A88A 3E 42		; Carga A con $42
	tfr	b,cc			; restore flags
	bne	i_A890			; if not west bank skip next		; 	JR NZ, i_A890		 ; A88C 20 02		; Si Z = 0, Salta a i_A890
	lda	#$43			; get ID for 'east bank'		; 	LD A, $43		 ; A88E 3E 43		; Carga A con $43
i_A890	sta	L_C61B+16		; update 'wooden boat' location		; i_A890: LD (L_C61B + $10), A	 ; A890 32 2B C6	; actualiza la localizacin del objeto $29 wooden boat
	sta	<reg_B			; save location in reg_B		; 	LD B, A			 ; A893 47		; Carga B con A
	lda	#$ff			; put NO container			; 	LD A, $FF		 ; A894 3E FF		; Carga A con $FF
	sta	L_C61B+1		; to 'wooden boat'			; 	LD ($C61C), A		 ; A896 32 1C C6	; Carga ($C61C) con A
	lda	#$29			; get ID for 'wooden boat'		; 	LD A, $29		 ; A899 3E 29		; Carga A con $29 (ID de 'wooden boat')
	lbra	L_9BDD			; call L_9BDD				; 	JP L_9BDD		 ; A89B C3 DD 9B	; salta a L_9BDD (#186# --)
e_A890	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#286# --)
L_A89E	jsr	BreakIfB6faAndfbZero	; exit if B6fa-fb are zero		; L_A89E: CALL BreakIfB6faAndfbZero ; A89E CD FF 97	; llama BreakIfB6faAndfbZero
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; A8A1 3A EA B6	; Carga ActionActor
	bne	e_A89E			; if not Bilbo, exit			; 	AND A			 ; A8A4 A7		; A = A AND A	; Adecua flags
										; 	RET NZ			 ; A8A5 C0		; Si Z = 0, Retorna
	ldx	#L_AFA4			; point to message			; 	LD HL, L_AFA4		 ; A8A6 21 A4 AF	; apunta a mensaje "with a lurch the boat glides across the river and[0x02] ngfar"
	bra	i_A882			; goto i_A882				; 	JR i_A882		 ; A8A9 18 D		; Salta a i_A882
e_A89E	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntada por $C9DF en (#45#)
L_A8AB	lda	FoundIn8x25		; get flag 8x25				; L_A8AB: LD A, (FoundIn8x25)	 ; A8AB 3A F4 B6	; recupera FoundIn8x25
	cmpa	#1			; is it on?				; 	CP $01			 ; A8AE FE 01		; Compara A con $01
	bne	e_A8AB			; yes, exit				; 	RET NZ			 ; A8B0 C0		; Si Z = 0, Retorna
	clra				; set to zero				; 	SUB A			 ; A8B1 97		; pone a 0
	sta	FoundIn8x25		; that flag				; 	LD (FoundIn8x25), A	 ; A8B2 32 F4 B6	; FoundIn8x25
	inca				; get value 1				; 	INC A			 ; A8B5 3C		; Incrementa A
	jsr	L_7F1A			; call L_7F1A				; 	CALL L_7F1A		 ; A8B6 CD 1A 7F	; llama rutina L_7F1A (#224# --)
	beq	e_A8AB			; if returned Z=1, exit			; 	RET Z			 ; A8B9 C8		; Z = 1?	; Retorna si es cero
	clra				; put zero				; 	SUB A			 ; A8BA 97		; pone 0
	sta	L_B6FB			; in L_B6fb				; 	LD (L_B6FB), A		 ; A8BB 32 FB B6	; en L_B6FB
										; 							; y ahora modifica el script Bard_E01 segundo comando
	lda	CurActionCpy		; put action				; 	LD A, (CurActionCpy)	 ; A8BE 3A E6 B6	; pone la CurActionCpy
	sta	D_C9E3			; in 'wooden chest' script		; 	LD (D_C9E3), A		 ; A8C1 32 E3 C9	; en D_C9E3 (como accin a ejecutar en el script)
	ldu	MainObject		; point to main object			; 	LD BC, (MainObject)	 ; A8C4 ED 4B E8 B6	; pone los IDs de objeto principal y objeto secundario
	stu	D_C9E4			; set it as main obj in script		; 	LD (D_C9E4), BC		 ; A8C8 ED 43 E4 C9	; en (L_D9E4-E5)
	lda	#$42			; get value for 'DO Action'		; 	LD A, $42		 ; A8CC 3E 42		; pone $42 (comando Do_Action)
	sta	D_C9E2			; put in in the script			; 	LD (D_C9E2), A		 ; A8CE 32 E2 C9	; en D_C9E2
e_A8AB	rts				; return				; 	RET			 ; A8D1 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntada por $C9F8 en (#45#)
L_A8D2	lda	L_C4B1+16		; get Gollum's location			; L_A8D2: LD A, (L_C4B1 + $10)	 ; A8D2 3A C1 C4	; carga en A la localizacin en que se encuentra Gollum
	ldx	#BilboLocation		; point to Bilbo location		; 	LD HL, BilboLocation	 ; A8D5 21 F5 B6	; apunta a BilboLocation
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A8D8 BE		; es la misma localizacin ?
	bne	e_A8D2			; no, exit				; 	RET NZ			 ; A8D9 C0		; no, salir de la subrutina
	ldx	#L_C11B+7		; point to Bilbo's flags		; 	LD HL, L_C11B + $07	 ; A8DA 21 22 C1	; apunta al byte 7 (flags) del objeto $00 - Bilbo
	ldb	,x			; get them
	bitb	#%10000000		; is Bilbo visible?			; 	BIT 7, (HL)		 ; A8DD CB 7E		; tiene el bit7 a 1?
	beq	e_A8D2			; no, exit				; 	RET Z			 ; A8DF C8		; no, retorna
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; A8E0 CD 44 9D	; llama BreakIfB6faNot1
	ldx	GollumMsgPtr		; get pointer to Gollums messages	; 	LD HL, (GollumMsgPtr)	 ; A8E3 2A EE B6	; recupera GollumMsgPtr
										; 	INC HL			 ; A8E6 23		; incrementa puntero 2 veces
										; 	INC HL			 ; A8E7 23		; para saltar los dos primeros bytes del bloque de 4
										; 	LD E, (HL)		 ; A8E8 5E		; carga byte bajo en E
										; 	INC HL			 ; A8E9 23		; incrementa puntero
										; 	LD D, (HL)		 ; A8EA 56		; carga byte alto en D
										; 	PUSH DE			 ; A8EB D5		; pasa este valor
	ldx	2,x			; point to 1st one			; 	POP HL			 ; A8EC E1		; a HL, apunta a un mensaje de Gollum
	jsr	AppendSayMessage	; show message				; 	CALL AppendSayMessage	 ; A8ED CD E3 A1	; llama la subrutina AppendSayMessage
	lda	#1			; put value 1				; 	LD A, $01		 ; A8F0 3E 01		; pone un 1
	sta	L_B6F9			; in LB6F9				; 	LD (L_B6F9), A		 ; A8F2 32 F9 B6	; en L_B6F9
e_A8D2	rts				; return				; 	RET			 ; A8F5 C9		; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntada desde $C9FE en (#45#)
L_A8F6	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A8F6: CALL BreakIfB6faNot1	 ; A8F6 CD 44 9D	; llama BreakIfB6faNot1
	clra				; put zero				; 	SUB A			 ; A8F9 97		; Resta A de A
	sta	L_B6F9			; in L_B6F9				; 	LD (L_B6F9), A		 ; A8FA 32 F9 B6	; Carga (L_B6F9) con A
	jsr	L_7F1A			; call L_7F1A				; 	CALL L_7F1A		 ; A8FD CD 1A 7F	; llama rutina L_7F1A (#224# --)
	beq	i_A915			; if returns Z=1, skip section		; 	JR Z, i_A915		 ; A900 28 13		; Si Z = 1, Salta a i_A915
	ldb	#24			; length				; 	LD BC, $0018		 ; A902 01 18 00	; Carga BC con $0018
	ldu	GollumMsgPtr		; point to Gollum message		; 	LD DE, (GollumMsgPtr)	 ; A905 ED 5B EE B6	; recupera GollumMsgPtr
	lda	,u			; get 1st byte				; 	LD A, (DE)		 ; A909 1A		; Carga A con (DE)
i_A90A	cmpa	,x+			; is same value pointed by X?		; i_A90A: CPIR			 ; A90A ED B1		; (HL)->(DE);BC bytes
	beq	eCPIR			; yes, exit loop
	decb				; decrement counter
	bne	i_A90A			; if not zero, loopback
	andcc	#%11111011		; set flag Z=0 (not found equal)
eCPIR	bne	i_A915			; if byte not found, skip section	; 	JR NZ, i_A915		 ; A90C 20 07		; Si Z = 0, Salta a i_A915
										; 	INC DE			 ; A90E 13		; Incrementa DE
	lda	1,u			; load next byte from message		; 	LD A, (DE)		 ; A90F 1A		; Carga A con (DE)
										; 	DEC DE			 ; A910 1B		; Decrementa DE
	cmpa	,x			; is the same pointed by X?		; 	CP (HL)			 ; A911 BE		; Compara A con (HL)
	bne	i_A90A			; no, loopback				; 	JR NZ, i_A90A		 ; A912 20 F6		; Si Z = 0, Salta a i_A90A
	rts				; return				; 	RET			 ; A914 C9		; Retorna
i_A915	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; i_A915: CALL BreakIfB6faNot1	 ; A915 CD 44 9D	; llama rutina BreakIfB6faNot1
	lda	#1			; put value 1				; 	LD A, $01		 ; A918 3E 01		; Carga A con $01
	sta	L_B702			; in L_B702				; 	LD (L_B702), A		 ; A91A 32 02 B7	; Carga (L_B702) con A
	ldx	#L_B1DB			; point to message			; 	LD HL, L_B1DB		 ; A91D 21 DB B1	; apunta a mensaje "someone strangle(s|d|ing|es) you from behind"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; A920 CD DD 72	; llama rutina PrintMsg
	lbra	BilboIsDeadEndGame	; end game				; 	JP BilboIsDeadEndGame	 ; A923 C3 D2 90	; salta a BilboIsDeadEndGame
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; apuntada desde $CA15 en (#45#)
L_A926	lda	L_C4B1+16		; get Gollum's location			; L_A926: LD A, (L_C4B1 + $10)	 ; A926 3A C1 C4	; A se carga con la ubicacin en que se encuentra Gollum
	ldx	#BilboLocation		; point to Bilbo location		; 	LD HL, BilboLocation	 ; A929 21 F5 B6	; apunta a BilboLocation
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A92C BE		; est en la misma localizacin que Gollum?	
	bne	e_A926			; no, exit				; 	RET NZ			 ; A92D C0		; no, salir de la subrutina
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; A92E CD 44 9D	; si est, llama BreakIfB6faNot1
	ldx	#L_B2D9			; point to message			; 	LD HL, L_B2D9		 ; A931 21 D9 B2	; apunta a mensaje "what has it got in its pocket(s|d|ing|es) ?[0x16]"
	lda	#8			; set maximum value			; 	LD A, $08		 ; A934 3E 08		; toma valor 8 para A (para el generador aleatotio)
	jsr	GetPosRandom		; generate random number		; 	CALL GetPosRandom	 ; A936 CD 9F 9C	; llama rutina GetPosRandom (retorna en A y Carry a 1 si sali negativo)
										; 							; aparentemente NO afecta a HL, por tanto el mensaje a mostrar ya est apuntado antes por HL
	lbcc	AppendSayMessage	; if C=0 show message			; 	JP NC, AppendSayMessage	 ; A939 D2 E3 A1	; si flag C=0, salta a AppendSayMessage
	ldu	#L_C31A			; point to ring				; 	LD IX, L_C31A		 ; A93C DD 21 1A C3	; apunta al obtejo anillo ID=$10 (valuable golden ring)
	stu	<reg_IX			; save pointer
	lda	#$44			; set Gollum ID				; 	LD A, $44		 ; A940 3E 44		; carga el cdigo de objeto de Gollum
	cmpa	1,u			; has Gollum the ring?			; 	CP (IX+$01)		 ; A942 DD BE 01	; compara con el byte 1 del objeto (anillo contenido dentro de Gollum?, lo lleva encima?)
	lbeq	AppendSayMessage	; yes, show message			; 	JP Z, AppendSayMessage	 ; A945 CA E3 A1	; si son iguales, salta a AppendSayMessage
	ldx	#L_B2E7			; point to message			; 	LD HL, L_B2E7		 ; A948 21 E7 B2	; apunta a mensaje "my birthday present " how did we lose it.[0x0d] my precious "[0x16]"
	lbra	AppendSayMessage	; show it				; 	JP AppendSayMessage	 ; A94B C3 E3 A1	; salta a AppendSayMessage
e_A926	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										;  							; llamada desde $CA42, $CA48, $CA4E y $CA54 en (#45#)
L_A94E	lda	ObjectLocation		; get location				; L_A94E: LD A, (ObjectLocation) ; A94E 3A F6 B6	; recupera ObjectLocation
	ldx	#BilboLocation		; point to Bilbo's one			; 	LD HL, BilboLocation	 ; A951 21 F5 B6	; apunta a BilboLocation
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A954 BE		; Compara A con (HL)
	bne	e_A94E			; no, exit				; 	RET NZ			 ; A955 C0		; Si Z = 0, Retorna
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; A956 CD 44 9D	; llama BreakIfB6faNot1
	lda	#$1b			; get ID for 'EAT'			; 	LD A, $1B		 ; A959 3E 1B		; Carga A con $1B
	sta	CurrentAction		; set as action				; 	LD (CurrentAction), A 	 ; A95B 32 E7 B6	; guarda ID de accin
	clra				; getID for Bilbo			; 	LD A, $00		 ; A95E 3E 00		; Carga A con $00
	sta	MainObject		; set as main object			; 	LD (MainObject), A	 ; A960 32 E8 B6	; guarda cdigo objeto principal
	deca				; put no object ($ff)			; 	LD A, $FF		 ; A963 3E FF		; Carga A con $FF
	sta	SecondObject		; to secondary object			; 	LD (SecondObject), A	 ; A965 32 E9 B6	; guarda cdigo objeto secundario
	jsr	IfB6FAis1DescAction	; desc action				; 	CALL IfB6FAis1DescAction ; A968 CD 76 9F	; llama IfB6FAis1DescAction
	jsr	L_92B5			; call L_9B25				; 	CALL L_92B5		 ; A96B CD B5 92	; llama rutina L_92B5 (#242# --)
	lbra	BilboIsDeadEndGame	; end game				; 	JP BilboIsDeadEndGame	 ; A96E C3 D2 90	; salta a BilboIsDeadEndGame
e_A94E	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; llamada desde $CA58 en (#45#)
L_A971	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; L_A971: CALL BreakIfB6faNot1	 ; A971 CD 44 9D	; llama BreakIfB6faNot1
	lda	#$47			; get Id for 'hideous troll'		; 	LD A, $47		 ; A974 3E 47		; Carga A con $47 (hideous troll)
	jsr	ProcessDeadObject	; process its death			; 	CALL ProcessDeadObject	 ; A976 CD 7F 97	; llama ProcessDeadObject
	lda	#$48			; get ID for 'vicious troll'		; 	LD A, $48		 ; A979 3E 48		; Carga A con $48 (vicious troll)
	jsr	ProcessDeadObject	; process its death			; 	CALL ProcessDeadObject	 ; A97B CD 7F 97	; llama ProcessDeadObject
	ldx	#L_C63F+7		; point 'hideous troll' flags		; 	LD HL, L_C63F + $07	 ; A97E 21 46 C6	; apunta a flags del objeto $47 hideous troll
	ldb	,x			; get flags
	andb	#%01111111		; set as not visible
	stb	,x			; update flags				; 	RES 7, (HL)		 ; A981 CB BE		; Pasa a 0 el bit 7 en (HL)
	ldx	#L_C651+7		; point 'vicious troll' flags		; 	LD HL, L_C651 + $07	 ; A983 21 58 C6	; apunta a flags del objeto $48 vicious troll
	ldb	,x			; get flags
	andb	#%01111111		; set as not visible
	stb	,x			; update flags				; 	RES 7, (HL)		 ; A986 CB BE		; Pasa a 0 el bit 7 en (HL)
	ldx	#L_B262			; point to message 			; 	LD HL, L_B262		 ; A988 21 62 B2	; apunta a mensaje "in a clearing with two stone trolls."
	stx	L_BABC+8		; update pointer to message		; 	LD (L_BABC + $08), HL	 ; A98B 22 C4 BA	; actualiza puntero a descripcin mensaje localizacin $05 trolls clearing
	ldx	#L_BABC			; point to 'trolls clearing'		; 	LD HL, L_BABC		 ; A98E 21 BC BA	; apunta a datos de la localizacin $05
	ldb	,x			; get location flags
	andb	#%10111111		; reset bit 6
	stb	,x			; update flags				; 	RES 6, (HL)		 ; A991 CB B6		; Pasa a 0 el bit 6 en (HL)
	lda	#$47			; get ID for 'hideous troll'		; 	LD A, $47		 ; A993 3E 47		; Carga A con $47 (hideous troll)
	jsr	AnalyzeObjContents	; see what he has			; 	CALL AnalyzeObjContents  ; A995 CD 53 9D	; llama AnalyzeObjContents
	lda	#$48			; get ID for 'vicious troll'		; 	LD A, $48		 ; A998 3E 48		; Carga A con $48 (vicious troll)
	jsr	AnalyzeObjContents	; see what he has			; 	CALL AnalyzeObjContents	 ; A99A CD 53 9D	; llama AnalyzeObjContents
	ldx	#L_B30B			; point to message			; 	LD HL, L_B30B		 ; A99D 21 0B B3	; apunta a mensaje "day dawn(s|d|ing|es) |b"
	lda	#1			; put value 1				; 	LD A, $01		 ; A9A0 3E 01		; pone 1
	sta	L_B702			; in L_B702				; 	LD (L_B702), A		 ; A9A2 32 02 B7	; en L_B702
	jsr	PrintMsg		; show message				; 	CALL PrintMsg		 ; A9A5 CD DD 72	; llama rutina PrintMsg
	ldb	#$ff			; set DAY time				
	stb	trlClr			; for trolls clearing			
										; 	LD IX, GFX_TABL		 ; A9A8 DD 21 00 CC	; Carga IX con GFX_TABL
										; 	LD A, $05		 ; A9AC 3E 05		; Carga A con $05 ("trolls clearing")
										; 	CALL FindPointer	 ; A9AE CD BD 9D	; llama rutina FindPointer - busca puntero con cdigo A e inicio tabla en IX
										; 	LD L, (IX+$01)		 ; A9B1 DD 6E 01	; Carga L con (IX+$01)
										; 	LD H, (IX+$02)		 ; A9B4 DD 66 02	; Carga H con (IX+$02)
										; 	LD (HL), $05		 ; A9B7 36 05		; Carga (HL) con $05
										; 	INC HL			 ; A9B9 23		; Incrementa HL
										; 	LD (HL), $28		 ; A9BA 36 28		; Carga (HL) con $28
	rts				; return				; 	RET			 ; A9BC C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; llamada desde $CA3C en (#45#)
L_A9BD	lda	BilboLocation		; get Bilbo location			; L_A9BD: LD A, (BilboLocation)	 ; A9BD 3A F5 B6	; recupera BilboLocation
	cmpa	#5			; is it the trolls clearing?		; 	CP $05			 ; A9C0 FE 05		; Compara A con $05
	bne	e_A9BD			; no, exit				; 	RET NZ			 ; A9C2 C0		; Si Z = 0, Retorna
	jsr	BreakIfB6faNot1		; exit if B6FA is not 1			; 	CALL BreakIfB6faNot1	 ; A9C3 CD 44 9D	; llama BreakIfB6faNot1
	lda	ActionActor		; get actor				; 	LD A, (ActionActor)	 ; A9C6 3A EA B6	; Carga ActionActor
	ldx	#L_B238			; point to message			; 	LD HL, L_B238		 ; A9C9 21 38 B2	; apunta a mensaje "blimey, look at this!! Can yer cook'em?[0x16]"
	cmpa	#$47			; is actor the hideous troll		; 	CP $47			 ; A9CC FE 47		; Compara A con $47
	beq	i_A9D3			; yes, show message			; 	JR Z, i_A9D3		 ; A9CE 28 03		; Si Z = 1, Salta a i_A9D3
	ldx	#L_B24C			; point to message			; 	LD HL, L_B24C		 ; A9D0 21 4C B2	; apunta a mensaje "yer can try, but he wouldn't make above a mouthfull."
i_A9D3	lbra	AppendSayMessage	; show it				; i_A9D3: JP AppendSayMessage	 ; A9D3 C3 E3 A1	; salta a AppendSayMessage 
e_A9BD	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Antes ; (#220# --)
HasPlayerWon									; HasPlayerWon:						; Mira si ya tienes el tesoro. 
	lda	L_C5CD+1		; get treasure location			; 	LD A, (L_C5CD + $01)	 ; A9D6 3A CE C5	; recupera donde esta el tesoro (si no es $FF)
	cmpa	#$25			; is it in the chest?			; 	CP $25			 ; A9D9 FE 25		; est dentro del 'wooden chest'?
	bne	eHPW			; no, exit				; 	RET NZ			 ; A9DB C0		; NO, salir
	tst	L_B707			; playing in text mode?
	beq	2f			; yes, skip loading image
	ldx	#NomLoc			; point to Location Name
	ldd	#$4646			; add chars "FF"
	std	4,x			; after "LOC"
	stx	FilePtr			; save pointer
	lbsr	LdFClr			; load image and clean 2 lines
	ldb	#5			; make 5
	jsr	Beeps			; beeps
1	jsr	ReadKey			; read keyboard
	beq	1b			; if no key, loopback
2	ldx	#L_B3D9+3		; point to message, skipping 3 intros	; 	LD HL, L_B3D9		 ; A9DC 21 D9 B3	; apunta a mensaje final "[0x0d][0x0d][0x0d] a cheering crowd of dwarves, hobbits and elves appear(s|d|ing|es). led by gandalf they carry you off into the sunset, proclaiming you  hero of heroes and master adventurer !!![0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; A9DF CD DD 72	; llama rutina PrintMsg
	jmp	WaitKeyToRestart	; go restart game			; 	JP WaitKeyToRestart	 ; A9E2 C3 DF 90	; salta a WaitKeyToRestart
eHPW	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; llamada desde $C9A1 en (#45#)
L_A9E5	lda	ObjectLocation		; get char location			; L_A9E5: LD A, (ObjectLocation) ; A9E5 3A F6 B6	; recupera ObjectLocation
	ldx	#BilboLocation		; point to Bilbo location		; 	LD HL, BilboLocation	 ; A9E8 21 F5 B6	; apunta a BilboLocation
	cmpa	,x			; are the same?				; 	CP (HL)			 ; A9EB BE		; Compara A con (HL)
	bne	e_A9FE			; no, exit				; 	RET NZ			 ; A9EC C0		; Si Z = 0, Retorna
	ldu	#L_C663			; point to obj 'lunch'			; 	LD IX, L_C663		 ; A9ED DD 21 63 C6	; Carga IX con L_C663
	lda	16,u			; get location				; 	LD A, (IX+$10)		 ; A9F1 DD 7E 10	; Carga A con (IX+$10)
										; 	CP $00			 ; A9F4 FE 00		; Compara A con $00
	beq	i_A9FE			; if none, exit				; 	JR Z, i_A9FE		 ; A9F6 28 06		; Si Z = 1, Salta a i_A9FE
	lda	#$41			; get ID for 'Elrond'			; 	LD A, $41		 ; A9F8 3E 41		; Carga A con $41
	cmpa	1,u			; has he the lunch?			; 	CP (IX+$01)		 ; A9FA DD BE 01	; Compara A con (IX+$01)
	bne	e_A9FE			; no, exit				; 	RET NZ			 ; A9FD C0		; Si Z = 0, Retorna
i_A9FE	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; i_A9FE: CALL BreakIfB6faNot1	 ; A9FE CD 44 9D	; llama BreakIfB6faNot1
	lda	ObjectLocation		; get char location			; 	LD A, (ObjectLocation)	 ; AA01 3A F6 B6	; recupera ObjectLocation
	sta	16,u			; put as new lunch location		; 	LD (IX+$10), A		 ; AA04 DD 77 10	; Carga (IX+$10) con A
	ldb	#$41			; get ID for 'Elrond'
	stb	1,u			; put as lunch container		; 	LD (IX+$01), $41	 ; AA07 DD 36 01 41	; Carga (IX+$01) con $41
	ldd	#$2600			; set 2nd Object = Bilbo		; 	LD BC, $0026		 ; AA0B 01 26 00	; Carga BC con $0026
	std	MainObject		; set main object = lunch		; 	LD (MainObject), BC	 ; AA0E ED 43 E8 B6	; guarda cdigos objeto principal y objeto secundario
	lda	#$1d			; set 'give to'				; 	LD A, $1D		 ; AA12 3E 1D		; Carga A con $1D
	sta	CurrentAction		; as action				; 	LD (CurrentAction), A	 ; AA14 32 E7 B6	; guarda ID de accin
	stu	MainObjectPtr		; put lunch pointer as main obj ptr	; 	LD (MainObjectPtr), IX	 ; AA17 DD 22 08 B7	; guarda MainObjectPtr
	ldx	#OBJ_TABLE		; put ObjectsTable			; 	LD HL, OBJ_TABLE	 ; AA1B 21 1B C1	; Carga HL con OBJ_TABLE
	stx	SecndObjectPtr		; as 2nd obj ptr			; 	LD (SecndObjectPtr), HL	 ; AA1E 22 0A B7	; guarda SecndObjectPtr
	jsr	IfB6FAis1DescAction	; desc action				; 	CALL IfB6FAis1DescAction ; AA21 CD 76 9F	; llama IfB6FAis1DescAction
	lbra	Action_Give		; give lunch to Bilbo			; 	JP Action_Give		 ; AA24 C3 9E 93	; Salta a Action_Give
e_A9FE	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#276# --)
L_AA27	ldy	MainObjectPtr		; get pointer				; L_AA27: LD IY, (MainObjectPtr) ; AA27 FD 2A 08 B7	; Carga MainObjectPtr
	sty	<reg_IY			; save it
	lda	16,y			; get location 				; 	LD A, (IY+$10)		 ; AA2B FD 7E 10	; Carga A con (IY+$10)
	sta	<reg_B			; put in reg_B				; 	LD B, A			 ; AA2E 47		; Carga B con A
	jsr	L_9F2D			; call L_9F2D				; 	CALL L_9F2D		 ; AA2F CD 2D 9F	; llama rutina L_9F2D (#192# --)
	ldx	#L_B301			; point to message			; 	CP $FF			 ; AA32 FE FF		; Compara A con $FF
	cmpa	#$ff			; end of table?				; 	LD HL, L_B301		 ; AA34 21 01 B3	; apunta a mensaje "You cannot jump onto[0x07] from here[0x15]
	lbeq	PrintMsg		; yes, show msg				; 	JP Z, PrintMsg		 ; AA37 CA DD 72	; si flag Z = 1, salta a PrintMsg
	ldu	<reg_IX			; get pseudoreg
	lda	,u			; get 1st pointed byte			; 	LD A, (IX+$00)		 ; AA3A DD 7E 00	; Carga A con (IX+$00)
	cmpa	#$0a			; is it 10?				; 	CP $0A			 ; AA3D FE 0A		; Compara A con $0A
	lbne	LDANGER			; avoid "bne L_B301" into a message	; 	JP NZ, L_B301		 ; AA3F C2 01 B3	; ###E ; OJO esto no es salto a cdigo sino a texto de mensaje. PELIGROOOOO !!!!!
	jsr	BreakIfB6faNot1		; exit if B6fa is not 1			; 	CALL BreakIfB6faNot1	 ; AA42 CD 44 9D	; llama BreakIfB6faNot1
	lda	MainObject		; get main object ID			; 	LD A, (MainObject)	 ; AA45 3A E8 B6	; Carga cdigo objeto principal
	ldu	ObjectPointer		; get pointer				; 	LD IX, (ObjectPointer)	 ; AA48 DD 2A 0C B7	; recupera ObjectPointer
	stu	<reg_IX			; save it
	sta	1,u			; update location			; 	LD (IX+$01), A		 ; AA4C DD 77 01	; Carga (IX+$01) con A
	jsr	L_9BDD			; call L_9BDD				; 	CALL L_9BDD		 ; AA4F CD DD 9B	; llama rutina L_9BDD (#186# --)
	lda	ActionActor		; get actor ID				; 	LD A, (ActionActor)	 ; AA52 3A EA B6	; Carga ActionActor
										; 	CP $00			 ; AA55 FE 00		; Compara A con $00
	bne	e_AA27			; if not Bilbo, exit			; 	RET NZ			 ; AA57 C0		; Si Z = 0, Retorna
	lda	<reg_B			; get saved location			; 	LD A, B			 ; AA58 78		; Carga A con B
	lbra	L_9630			; goto L_9630				; 	JP L_9630		 ; AA59 C3 30 96	; Salta a L_9630
e_AA27	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CA8D-8E
L_AA5C	ldu	#L_C205			; point to 'spider web'			; L_AA5C: LD IX, L_C205		 ; AA5C DD 21 05 C2 	; Carga IX con L_C205
	stu	<reg_IX			; save ptr
	ldb	7,u			; get flags
	andb	#%11010111		; set as closed and not dead		; 	RES 3, (IX+$07)		 ; AA60 DD CB 07 9E	; Pasa a 0 el bit 3 en (IX+$07)
	stb	7,u			; update flags				; 	RES 5, (IX+$07)		 ; AA64 DD CB 07 AE	; Pasa a 0 el bit 5 en (IX+$07)
	ldb	5,u			; get strength				; 	SLA (IX+$05)		 ; AA68 DD CB 05 26	; Rota aritmticamente a la izquierda (IX+$05)
	lslb				; double it
	stb	5,u			; update strength
	ldu	#$0623			; put word 'spider'			; 	LD DE, $0623		 ; AA6C 11 23 06	; Carga DE con $0623 = palabra SPIDER
	stu	L_C205+10		; in second desc. word			; 	LD (L_C205 + $0A), DE	 ; AA6F ED 53 0F C2	; actualiza segunda palabra objeto $07 web spider
	rts				; return				; 	RET			 ; AA73 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Hace invisible el agujero
MakeHoleDisappear								; MakeHoleDisappear:					; Apuntada por las posiciones $CAC5-C6 ; (# sinNumero)
	ldx	#L_C2B5+7		; point to 'mountains side door' flags	; 	LD HL, L_C2B5 + $07    	; AA74 21 BC C2    	; apunta a flags objeto $0B mountains side door
	ldb	,x			; get them
	bitb	#%00100000		; is it open?				; 	BIT 5, (HL)       	; AA77 CB 6E      	; Esta abierta la puerta?
	bne	e_AA8B			; no, exit				; 	RET NZ          	; AA79 C0      		; Si, Retorna
	lda	D_CAC3			; get 1st byte for 'hole' BilboEvents	; 	LD A, (D_CAC3)       	; AA7A 3A C3 CA   	; pasa valor de D_CAC3
	sta	D_CAC4			; to 2nd byte (reset counter)		; 	LD (D_CAC4), A       	; AA7D 32 C4 CA   	; a D_CAC4
	andb	#%01111111		; set to NOT visible			; 	LD HL, L_C2B5 + $07    	; AA80 21 BC C2   	; apunta a flags objeto $0B mountains side door
	stb	,x			; update flags				; 	RES 7, (HL)       	; AA83 CB BE      	; Pasa a 0 el bit7 haciendo desaparecer el objeto!
	lda	L_C11B+16		; get Bilbo location			; 	LD A, (L_C11B + $10)    ; AA85 3A 2B C1   	; recupera localizacin del objeto $00 - Bilbo
	cmpa	#$2a			; is it 'sidedoor'?			; 	CP $2A          	; AA88 FE 2A      	; es SideDoor?
	bne	e_AA8B			; no, exit				; 	RET NZ          	; AA8A C0      		; no, retorna
i_AA8B	ldx	#L_B2A4			; point to message			; i_AA8B: LD HL, L_B2A4       	; AA8B 21 A4 B2   	; apunta a mensaje "the hole vanish(s|d|ing|es)[0x15]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg       	; AA8E C3 DD 72   	; salta a PrintMsg
e_AA8B	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Hace visible el agujero de la montaa
MakeHoleAppear									; MakeHoleAppear:					; Apuntada por las posiciones $CAC8-C9 ; (# sinNumero)
	ldx	#L_C2B5+7		; point to 'mountains side door' flags	; 	LD HL, L_C2B5 + $07     ; AA91 21 BC C2    	; apunta a flags objeto $0B mountains side door
	ldb	,x			; get them
	orb	#%10000000		; set it visible
	stb	,x			; update flags				; 	SET 7, (HL)       	; AA94 CB FE      	; Pasa a 1 el bit7 haciendo visible el objeto
	lda	L_C11B+16		; get Bilbo location			; 	LD A, (L_C11B + $10)    ; AA96 3A 2B C1   	; recupera localizacin del objeto $00 - Bilbo
	cmpa	#$2a			; is it 'sidedoor'?			; 	CP $2A          	; AA99 FE 2A      	; es SideDoor?
	bne	e_MHlAp			; no, exit				; 	RET NZ          	; AA9B C0      		; no, retorna
	ldx	#L_B277			; point to message			; 	LD HL, L_B277       	; AA9C 21 77 B2   	; apunta a mensaje "there is a loud crack and a hole appear(s|d|ing|es) about three feet from the ground.[0x0d] You are stand(s|d|ing|es) in front of the side door to the Lonely Mountain[0x15]"
	lbra	PrintMsg		; show it				; 	JP PrintMsg       	; AA9F C3 DD 72   	; salta a PrintMsg
e_MHlAp	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
LockMountainSideDoor								; LockMountainSideDoor:					; Oculta y bloquea agujero de la montaa	; antes ; (#261# --)
	jsr	BreakIfB6faAndfbZero	; exit if b6fa-fb are zero		; 	CALL BreakIfB6faAndfbZero; AAA2 CD FF 97	; llama BreakIfB6faAndfbZero
	lda	#6			; put value 6				; 	LD A, $06       	; AAA5 3E 06      	; pone valor $06
	sta	D_CAC4			; to reset 1st counter for hole		; 	LD (D_CAC4), A       	; AAA7 32 C4 CA   	; en D_CAC4
	ldx	#L_C2B5+7		; point to 'mountains side door' flags	; 	LD HL, L_C2B5 + $07    	; AAAA 21 BC C2   	; apunta a flags objeto $0B mountains side door
	ldb	,x			; get them
	orb	#%00000001		; set to locked				; 	SET 0, (HL)       	; AAAD CB C6      	; Pasa a 1 el bit0 = puerta bloqueada (Locked)
	andb	#%01111111		; and NOT visible
	stb	,x			; update flags				; 	RES 7, (HL)       	; AAAF CB BE      	; Pasa a 0 el bit7 y la puerta deja de ser visible
	bra	i_AA8B			; goto i_AA8B				; 	JR i_AA8B       	; AAB1 18 D8      	; Salta a i_AA8B e imprime "THE HOLE VANISHES"
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Abre la puerta mgica ; (# sinNumero)
OpenMagicDoor									; OpenMagicDoor:					; Apuntada por las posiciones $CAAC-AD
	ldx	#L_C381+7		; point to 'magic door' flags		; 	LD HL, L_C381 + $07 	 ; AAB3 21 88 C3 	; apunta a flags objeto $0D magic door
	ldb	,x			; get them
	orb	#%00100000		; set to open
	stb	,x			; update flags				; 	SET 5, (HL)       	 ; AAB6 CB EE      	; Pasa a 1 el bit5 = open door
	ldx	#L_B037			; point to message			; 	LD HL, L_B037		 ; AAB8 21 37 B0	; apunta a mensaje "the magic door open(s|d|ing|es).[0x14]"
	jsr	SeesMagicDoor		; show it if Bilbo is there		; 	CALL SeesMagicDoor	 ; AABB CD C7 AA	; llama SeesMagicDoor
	ldx	#L_B113			; point to message			; 	LD HL, L_B113		 ; AABE 21 13 B1	; apunta a mesaje "an elf sweeps past" 
	jsr	SeesMagicDoor		; show it if Bilbo is there		; 	CALL SeesMagicDoor	 ; AAC1 CD C7 AA	; llama SeesMagicDoor
	bra	IsRingContainerVisible	; goto IsRingContainerVisible		; 	JP IsRingContainerVisible ; AAC4 C3 E0 AA	; Salta a IsRingContainerVisible
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SeesMagicDoor									; SeesMagicDoor:					; detecta si Bilbo puede ver la puerta mgica	; antes ; (#243# --)
	lda	L_C11B+16		; get Bilbo location			; 	LD A, (L_C11B + $10)	 ; AAC7 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	cmpa	#$1e			; is it 'elvenkings great halls'?	; 	CP $1E          	 ; AACA FE 1E      	; es $1E = Elvenkings Great Halls?
	lbeq	PrintMsg		; yes, show message			; 	JP Z, PrintMsg       	 ; AACC CA DD 72   	; si, salta a PrintMsg
	cmpa	#$1c			; is it 'levelled elvish clearing'	; 	CP $1C          	 ; AACF FE 1C   	; es $1C = Levelled Elvish Clearing?
	lbeq	PrintMsg		; yes, show message			; 	JP Z, PrintMsg       	 ; AAD1 CA DD 72   	; si, salta a PrintMsg
	rts				; return				; 	RET			 ; AAD4 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
CloseMagicDoor									; CloseMagicDoor:					; Apuntada por las posiciones $CAA9-AA. Cierra la magic door (# sinNumero) 
	ldx	#L_C381+7		; point to 'magic door' flags		; 	LD HL, L_C381 + $07	 ; AAD5 21 88 C3 	; apunta a flags objeto $0D magic door
	ldb	,x			; get them
	andb	#%11011111		; set to closed
	stb	,x			; update flags				; 	RES 5, (HL)		 ; AAD8 CB AE		; Pasa a 0 el bit 5 en (HL) estado = cerrado
	ldx	#L_B03F			; point to message			; 	LD HL, L_B03F		 ; AADA 21 3F B0	; apunta a mensaje "the magic door close(s|d|ing|es).[0x14]"
	bra	SeesMagicDoor		; show it if Bilbo is there		; 	JP SeesMagicDoor	 ; AADD C3 C7 AA	; salta a SeesMagicDoor
										; 
										; 
IsRingContainerVisible								; IsRingContainerVisible:				; es visible el contenedor del anillo (si esta en algn objeto)? ; (# sinNumero)
	ldy	#L_C31A			; point to 'valuable golden ring'	; 	LD IX, L_C31A		; AAE0 DD 21 1A C3	; Carga IX con L_C31A = 10 [ff] ring valuable golden 
	sty	<reg_IX			; save pointer
	lda	1,y			; get container				; 	LD A, (IX+$01)       	; AAE4 DD 7E 01   	; Carga A con (IX+$01) = contenedor, si est contenido en otro objeto
	cmpa	#$ff			; is it none?				; 	CP $FF          	; AAE7 FE FF      	; es igual a $FF (no contenido)? 
	beq	e_IRCV			; yes, exit				; 	RET Z          		; AAE9 C8      		; si, retorna. Nadie tiene el anillo 
	jsr	GetObjPointer2IX	; get container pointer			; 	CALL GetObjPointer2IX   ; AAEA CD CA 9B   	; llama GetObjPointer2IX devuelve puntero al contenedor en IX
	sty	ObjectPointer		; save it				; 	LD (ObjectPointer), IX 	; AAED DD 22 0C B7   	; guarda puntero al objeto que tiene el anillo en ObjectPointer
	ldb	7,y			; get its flags
	bitb	#%10000000		; is it visible?			; 	BIT 7, (IX+$07)       	; AAF1 DD CB 07 7E   	; Est a 1 el bit7 de (IX+$07) = es visible el contenedor?
	lbeq	TakeOffRing		; no, take off ring			; 	JP Z, TakeOffRing      	; AAF5 CA BC A3   	; no, salta a TakeOffRing. Se quita el anillo, si no es visible el contenedor
e_IRCV	rts				; return				; 	RET          		; AAF8 C9      		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; (#279# --)
L_AAF9	lda	ActionActor		; get actor				; L_AAF9: LD A, (ActionActor)	 ; AAF9 3A EA B6	; Carga ActionActor
										; 	CP $00			 ; AAFC FE 00		; Compara A con $00
	bne	e_AAF9			; if not Bilbo, exit			; 	RET NZ			 ; AAFE C0		; Si Z = 0, Retorna
	lda	#1			; put value 1				; 	LD A, $01		 ; AAFF 3E 01		; Carga A con $01
	sta	L_B700			; in L_B700				; 	LD (L_B700), A		 ; AB01 32 00 B7	; Carga (L_B700) con A
	lda	D_CAB5			; put 1st byte from one Bilbo event	; 	LD A, (D_CAB5)		 ; AB04 3A B5 CA	; Carga A con (D_CAB5)
	sta	D_CAB6			; to 2nd byte (reset counter)		; 	LD (D_CAB6), A		 ; AB07 32 B6 CA	; Carga (D_CAB6) con A
e_AAF9	rts				; return				; 	RET			 ; AB0A C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CA94-95
L_AB10	lda	L_C11B+16		; get Bilbo's location			; L_AB10: LD A, (L_C11B + $10)	 ; AB10 3A 2B C1 	; recupera localizacin del objeto $00 - Bilbo
	cmpa	#$1a			; is it 'spider threads place'?		; 	CP $1A			 ; AB13 FE 1A		; Compara A con $1A
	bne	e_AB10			; no, exit				; 	RET NZ			 ; AB15 C0		; Si Z = 0, Retorna
	ldx	#L_B0FD			; point to message			; 	LD HL, L_B0FD		 ; AB16 21 FD B0	; apunta a mensaje "the spider web is slowly smothering you."
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; AB19 CD DD 72	; llama rutina PrintMsg
	lbra	BilboIsDeadEndGame	; end game				; 	JP BilboIsDeadEndGame	 ; AB1C C3 D2 90	; salta a BilboIsDeadEndGame
e_AB10	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CAC1-C2
L_AB1F	ldx	#L_B311			; point to message			; L_AB1F: LD HL, L_B311		 ; AB1F 21 11 B3 	; apunta a mensaje "You see some pale bulbous eyes star(s|d|ing|es) at You[0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; AB22 CD DD 72	; llama rutina PrintMsg
	lda	L_C11B+16		; save Bilbo's location			; 	LD A, (L_C11B + $10)	 ; AB25 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	sta	reg_C			; in reg_C				; 	LD C, A			 ; AB28 4F		; Carga C con A
	ldx	#L_B6F3			; point to variable 			; 	LD HL, L_B6F3		 ; AB29 21 F3 B6	; Carga HL con L_B6F3
	cmpa	,x			; are same?				; 	CP (HL)			 ; AB2C BE		; Compara A con (HL)
	beq	e_AB36			; yes, exit				; 	RET Z			 ; AB2D C8		; Z = 1?	; Retorna si es cero
	ldb	,x			; put location from variable 		; 	LD B, (HL)		 ; AB2E 46		; Carga B con (HL)
	stb	<reg_B			; in reg_B
	lda	#2			; get 'forest road' ID			; 	LD A, $02		 ; AB2F 3E 02		; Carga A con $02
	cmpa	<reg_B			; is same as variable loc?		; 	CP B			 ; AB31 B8		; Compara A con B
	bne	i_AB36			; no, skip next				; 	JR NZ, i_AB36		 ; AB32 20 02		; Si Z = 0, Salta a i_AB36
	lda	#3			; get 'forest' ID			; 	LD A, $03		 ; AB34 3E 03		; Carga A con $03
i_AB36	cmpa	<reg_C			; is same as Bilbo's?			; i_AB36: CP C			 ; AB36 B9		; Compara A con C
	beq	e_AB36			; yes, exit				; 	RET Z			 ; AB37 C8		; Z = 1?	; Retorna si es cero
	bra	i_AB4A			; goto i_AB4A				; 	JR i_AB4A		 ; AB38 18 10		; Salta a i_AB4A
e_AB36	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Apuntada por las posiciones $CABE-BF
L_AB3A	lda	L_C11B+16		; get Bilbo's location			; L_AB3A: LD A, (L_C11B + $10)	 ; AB3A 3A 2B C1	; recupera localizacin del objeto $00 - Bilbo
	cmpa 	#2			; is it 'forest road'?			; 	CP $02			 ; AB3D FE 02		; Compara A con $02
	beq	i_AB44			; yes, skip control			; 	JR Z, i_AB44		 ; AB3F 28 03		; Si Z = 1, Salta a i_AB44
	cmpa	#3			; is it 'forest'?			; 	CP $03			 ; AB41 FE 03		; Compara A con $03
	bne	e_AB36			; no,exit				; 	RET NZ			 ; AB43 C0		; Si Z = 0, Retorna
i_AB44	ldx	#L_B311			; point to message			; i_AB44: LD HL, L_B311		 ; AB44 21 11 B3	; apunta a mensaje "You see some pale bulbous eyes star(s|d|ing|es) at You[0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; AB47 CD DD 72	; llama rutina PrintMsg
i_AB4A	ldx	#L_B31F			; point to message			; i_AB4A: LD HL, L_B31F		 ; AB4A 21 1F B3	; apunta a mensaje "some thing drop(s|d|ing|es) from above and sting(s|d|ing|es)[0x15]"
	jsr	PrintMsg		; show it				; 	CALL PrintMsg		 ; AB4D CD DD 72	; llama rutina PrintMsg
	lbra	BilboIsDeadEndGame	; end game				; 	JP BilboIsDeadEndGame	 ; AB50 C3 D2 90	; salta a BilboIsDeadEndGame
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ActivateButler									;  ActivateButler:					; reactiva a Butler si est desactivado ; antes ; (#49# --)
	ldx	#L_C430+7		; point to 'butler' flags		; 	LD HL, L_C430 + $07	 ; C7A4 21 37 C4	; apunta a flags del objeto $42 Butler
	ldb	,x			; get them
	bitb	#%00001000		; is he tagged as dead?			; 	BIT 3, (HL)		 ; C7A7 CB 5E		; est vivo?
	bne	e_RBut			; yes, exit				; 	RET NZ			 ; C7A9 C0		; si, retorna
	lda	#$42			; get ID for Butler			; 	LD A, $42		 ; C7AA 3E 42		; pone valor $42 (ID de Objeto de BUTLER)
	sta	Butler_HLDir		; put at HLevelDir			; 	LD (Butler_HLDir), A	 ; C7AC 32 E7 CA	; en primer byte del Butler_HLDir, para 'resucitarlo'
	orb	#%10000000		; set as visible			; 	SET 7, (HL)		 ; C7AF CB FE		; lo marca como vivo
	stb	,x			; update flags
e_RBut	rts				; return				; 	RET			 ; C7B1 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ActivateSpiderWebBlk								; ActivateSpiderWebBlk:					; reactiva el quebloq eu procesa la SpiderWeb ; antes ; (#50# --)
	lda	D_CA92			; put 1.'spider web' byte (BilboEvents)	; 	LD A, (D_CA92)		 ; C7B2 3A 92 CA	; recupera valor de cabecera del bloque SpiderWeb de BilboEvents
	sta	D_CA93			; to 2nd byte (reset counter)		; 	LD (D_CA93), A		 ; C7B5 32 93 CA	; lo copia en Byte1 para reactivarla
	rts				; return				; 	RET			 ; C7B8 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ActivateDeepBogBlk								; ActivateDeepBogBlk:					; reactiva el bloque que procesa Deep Bog ; antes ; (#51# --)
	lda	D_CAA0			; put 1.'deep bog' byte (BilboEvents)	; 	LD A, (D_CAA0)		 ; C7B9 3A A0 CA	; recupera valor de cabecera del bloque DeepBog de BilboEvents
	sta	D_CAA1			; to 2nd byte (reset counter)		; 	LD (D_CAA1), A		 ; C7BC 32 A1 CA	; lo copia en Byte1 para reactivarla
	rts				; return				; 	RET			 ; C7BF C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
										; 							; Reactiva si estan desactivados los personajes:
ActivateDragonBard								; ActivateDragonBard:					; Red Golden Dragon y Bard ; antes ; (#52# --)
	lda	#3			; put value 3				; 	LD A, $03		 ; C7C0 3E 03		; pone valor $03
	sta	D_CAC4			; to reactivate 'hole' in Bilboevents	; 	LD (D_CAC4), A		 ; C7C2 32 C4 CA	; en BYTE1 del bloque que procesa el "Hole" = lo reactiva
	ldx	#L_C133+7		; point to 'red golden dragon' flags	; 	LD HL, L_C133 + $07	 ; C7C5 21 3A C1	; apunta a flags del objeto $3c "Red Golden Dragon"
	ldb	,x			; get flags
	bitb	#%00001000		; is it tagged as dead?			; 	BIT 3, (HL)		 ; C7C8 CB 5E		; est vivo?
	bne	i_C7D1			; yes, exit				; 	JR NZ, i_C7D1		 ; C7CA 20 05		; si, salta a i_C7D1 a procesar Bard
	lda	#$3c			; get ID for 'red golden dragon'	; 	LD A, $3C		 ; C7CC 3E 3C		; pone valor $3C, objeto "Red Golden Dragon"
	sta	Dragon_HLDir		; put in HLevelDir			; 	LD (Dragon_HLDir), A	 ; C7CE 32 03 CB	; en primer byte (ID) del Dragon_HLDir = lo reactiva / resucita
i_C7D1	ldx	#L_C4C3+7		; point to 'bard' flags			; i_C7D1: LD HL, L_C4C3 + $07	 ; C7D1 21 CA C4	; apunta a flags del objeto $46 "Bard"
	ldb	,x			; get flags
	bitb	#%00001000		; is he tagged as dead?			; 	BIT 3, (HL)		 ; C7D4 CB 5E		; est vivo?
	bne	e_C7D1			; yes, exit 				; 	RET NZ			 ; C7D6 C0		; si, retorna
	lda	#$46			; get ID for 'bard'			; 	LD A, $46		 ; C7D7 3E 46		; pone valor $46, objeto "Bard"
	sta	Bard_HLDir		; put in HLevelDir			; 	LD (Bard_HLDir), A	 ; C7D9 32 FC CA	; en primer byte (ID) del Bard_HLDir = lo resucita / reactiva
e_C7D1	rts				; return				; 	RET			 ; C7DC C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ActivateForest									; ActivateForest:					; reactiva Forest ; antes ; (#53# --)
	lda	L_8D9B			; copy L_8D9B				; 	LD A, (L_8D9B)		 ; C7DD 3A 9B 8D	; guarda valor de L_8D9B
	sta	L_B6F3			; to L_B6F3				; 	LD (L_B6F3), A		 ; C7E0 32 F3 B6	; en L_B6F3
	lda	D_CABC			; put 1.'forest' byte (BilboEvents)	; 	LD A, (D_CABC)		 ; C7E3 3A BC CA	; recupera valor de cabecera del bloque Forest de BilboEvents
	sta	D_CABD			; to 2nd byte (reset counter)		; 	LD (D_CABD), A		 ; C7E6 32 BD CA	; lo copia en Byte1 para reactivarla
	rts				; return				; 	RET			 ; C7E9 C9		; Retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
IfNotInBarrelBilboDies								; IfNotInBarrelBilboDies:				; Si Bilbo no est en el barril, muere ; antes ; (#54# --)
	lda	L_C11B+1		; get Bilbo container			; 	LD A, (L_C11B + $01)	 ; C7EA 3A 1C C1	; recupera ID del posible contenedor de Bilbo
	cmpa	#$13			; is it 'barrel'?			; 	CP $13			 ; C7ED FE 13		; es el "Barrel"?
	beq	e_INIBD			; yes, exit				; 	RET Z			 ; C7EF C8		; si, retorna
	jsr	L_8E39			; call L_8E39				; 	CALL L_8E39		 ; C7F0 CD 39 8E	; llama rutina L_8E39 (#244# --)
	ldx	#L_B26D			; point to message			; 	LD HL, L_B26D		 ; C7F3 21 6D B2	; apunta a mensaje "You are swept forcefully against the portcullis"
	jsr	PrintMsg		: show it				; 	CALL PrintMsg		 ; C7F6 CD DD 72	; llama rutina PrintMsg
	lbra	BilboIsDeadEndGame	; end game				; 	JP BilboIsDeadEndGame	 ; C7F9 C3 D2 90	; salta a BilboIsDeadEndGame - fin de la partida, Bilbo muere
e_INIBD	rts				; return				; 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: Devuelve control al Intrprete de Basic				;
;   Utiliza: CC, A								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
OutToB	orcc    #$50			; deshabilita interrupciones x Stack
	ldx	#$2400			; basic beginning for Dragon
	tst	CoCoFlg			; is this a CoCo?
	beq	1f			; no, skip next
	ldx	#$2600			; basic beginning for CoCo
1	clra				; create
	clrb				; 16 bit zero
	std	,x++			; null basic number line
	std	,x			; null link to next one
	ldx	$00a6			; point to next command data
	std	1,x			; put nulls
	lds	#$7f36			; deja stack listo para BASIC
	andcc   #$af			; habilita interrupciones x Basic
	tst	CoCoFlg			; is a CoCo? 
	beq	1f			; no, skip next two
	clr	$ffd8			; ensure we return to Basic at normal speed!
	jmp	$ac73			; goto CoCo Basic Interpreter
1	jmp	$84da			; goto Basic Interpreter (command dispatcher)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
shwMsg	lda	,x+			; toma 1 caracter
	jsr	L_85B8			; lo envia a pantalla
	cmpa	#$0d			; era Enter?
	bne	shwMsg			; no, siguiente caracter
	rts				; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
shwNchr lda	,x+			; toma un caracter
	jsr	L_85B8			; lo imprime
	decb				; decrementa contador
	bne	shwNchr			; si no es 0, sigue
	rts				; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Beeps	tst	CoCoFlg			; is it a CoCo?
	beq	1f			; no, goto Dragon beep
2	pshs	b			; save counter
	ldd	#$b001			; set up sound parameters (freq, length)
	sta	<$8c			; for a single beep
	jsr	$a951			; emit it
	puls	b			; restore counter
	decb				; decrement it
	bne	2b			; not done, loopback
	jsr	$a974			; stop audio
	rts				; return
1	jsr	detect2			; detect DOS type
	bmi	DPlusB			; if DosPlus skip two
	jsr	$dba5			; efectuar B pitidos
	bra	eBeeps			; go close audio
DPlusB	jsr	$dea8			; B beeps (antes $dea6 = 1 pitido)
eBeeps	jsr	$bac3			; cerrar audio
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; SvFile guarda una posicion en Disco
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SvFile	tst	CoCoFlg			; is it a CoCo? 
	lbne	SvFCC			; yes, goto CoCo process
	lbsr	diskInside		; is there a disk?
	lbne	noDisk			; no, show error
	lbsr	isItProt		; check disk protection
	cmpb	#$40			; is it protected?
	beq	diskPt			; yes, show error
	lbsr	detect2			; averigua que DOS hay instalado
	bmi	DPlusF			; si negativo es el DosPlus5.0
	beq	DOS1xF			; si cero es el DDOS11C/12A/13A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DOS41F	jsr	$d173			; llama rutina FREE del DOS4.1
	bra     SaveG1			; va al siguiente paso
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DPlusF	jsr	$c16a			; test disk
	cmpb	#$80			; is there a disk?
	beq	noDisk			: no, show error
	jsr	$c808			; call get_opt_drive
	ldb	workEB			; get the drive number we entered (saved in workEB)
	stb	<$eb			; update with the desired drive number
	lda	>$060a			; get working default drive
	pshs	a			; save onto stack
	stb	>$60a			; force to requested one
	jsr	$d24f			; call GetFree
	tfr	cc,b			; save flags
	puls	a			; restore from stack
	sta	>$60a			; update working value
	tfr	b,cc			; restore flags
	bne	noDisk			; if not zero, process NO disk error
	jsr	$dd97			; continue into original DosPlus5.0
	bra	SaveG1			; va al siguiente paso
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DOS1xF  jsr     $d14d			; llama rutina FREE del DDOS11C/12A/13A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SaveG1	bne	noDisk			; si no hay disco, mostrar error
keep	cmpx	#$000d			; cabe un fichero SAVGAM?		
	blo	dskFull			; no, tratar disco lleno			
doSave	ldx	<$f8			; get pseudo-reg_BC
	stx	f8cps			; save to variable
	ldx	#SaveGam		; apunta a parametros de SaveGam			
	stx	<$a6			; lo guarda en la rutina getChar
	jsr	detect2			; averigua que DOS hay instalado
	bmi	DPlusS			; si negativo es el DosPlus5.0
	beq	DOS1xS			; si cero, es el DDOS11C/12A/13A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DOS41S	jsr	$d562			; llama rutina SAVE del DDOS4.1
	bra     SaveG2			; va al siguiente paso
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DPlusS	jsr	$d5df			; llama al SAVE del DosPlus5.0
	bra	SaveG2			; va al siguiente paso
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DOS1xS  jsr     $d53f			; llama rutina SAVE del DDOS11C/12A/13A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SaveG2	ldx	f8cps			; get f8-f9
	stx	<$f8			; update pseudo-reg
CloFS	jsr	[$c010]			; cierra ficheros abiertos		
	clr	$ff48			; stop spinning motor
	bsr	rstA6			; restore interpreter input
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
rstA6	ldx	#$02DC			; apunta al buffer de entrada de teclado	
	stx	<$a6			; lo pasa a rutina CharGet		
	clra				; prepara 0				
	clrb				; de 16 bits				
	std	,x			; lo pone al inicio del buffer teclado	
	rts				; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
diskPt	ldx	#DskProt		; point to message
	fcb	$10			; to mask next ldx => ldy
dskFull	ldx	#FullDsk		; apunta a mensaje
	fcb	$10			; to mask next ldx => ldy
noDisk	ldx	#woDsk			; apunta a mensaje
	lbsr	BckBeep			; lo muestra y emite pitidos
	bra	SaveG2			; salir de SAVE
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SvFCC	bsr	diskInside		; is there a disk?
	bne	nDskCC			; no, show error message
	ldb	workEB			; get requested drive number
	jsr	$b4f3			; convert regB to FPA0	
	jsr	$ce9c			; call CoCo FREE - number of granules in FPA0 ($004f-$0053)
	jsr	$b3ed			; convert FAC to integer in regD
	cmpd	#$0002 			; verify if result >= 2 granules
	blo	FdskCC			; not enough granules, so disk is full
	ldx	#SaveGam-1		; apunta a SaveGam			
	stx	<$a6			; lo guarda en rutina GetNextChar	
	jsr	$cf68			; call CoCo SAVE
eSvFCC	jsr	$a426			; call CoCo CLOSE
	clr	$ff40			; stop motor
	bsr	rstA6			; restore interpreter pointer $A6
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
protDsk	leas	15,s			; clean stack ('patch')
	ldx	#DskProt		; point to message: DISK PROT!
	fcb	$10			; to mask next ldx => ldy
FdskCC	ldx	#FullDsk		; apunta a mensaje: DISK FULL!
	fcb	$10			; to mask next ldx => ldy
nDskCC	ldx	#woDsk			; apunta a mensaje: NO DISK!
	lbsr	BckBeep			; show message, emit beeps
	bra	eSvFCC			; exit 
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; 	if NO disk returns negative (bit7 set)
; 	if protected returns $40 (bit 6 set)
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
diskInside
	lda	#2			; command for READ
	fcb	#$8c			; to mask next lda
isItProt
	lda	#4			; command for WRITE
	tst	CoCoFlg			; is it a CoCo?
	beq	1f			; no, skip next
	ldx	#$600			; get CoCo 1st buffer address
	fcb	$10			; to mask next ldx
1	ldx	#$800			; get Dragon 1st Buffer address
	ldb	<$eb			; save drive
	pshs	b			; onto stack
	ldu	$c006			; point to drive data ($ea)
	sta	,u			; command read/write sector ($ea)
	stx	4,u			; put at $ee
	clrb				; put value zero
	stb	2,u			; as track ($ec)
	incb				; put value 1
	stb	3,u			; as sector ($ed)
	ldb	workEB			; get user requested drive
	stb	1,u			; put at $eb
	jsr	[$c004]			; call DSKCON (exec command)
	puls	b			; restore from stack
	stb	<$eb			; drive number
	ldb	6,u			; getoperation status
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Finalidad: carga un fichero de disco						;
; Parmetro: FilePtr es la direccin del texto a usar como nombre del Fichero	;
;  Preserva: D, X, Y, U								;
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
LdFilePgm
	pshs	b			; save register
	ldb	oldEB			; get program drive
	stb	workEB			; set in working variable
	puls	b			; restore register
	andcc	#%11111110		; clear carry flag
LdFileSG
	pshs	cc,d,x,y,u  		; guarda todos los registros
	tst	CoCoFlg			; is it a Coco?
	bne	LdFCC			; yes, do a CoCo Load
	ldx	<$f8			; get pseudo-reg_BC
	stx	f8cps			; save in variable
	ldx	FilePtr			; recupera puntero a nombre de fichero
	stx	<$A6			; poner en rutina GetChar
	jsr	detect2			; averigua que DOS hay instalado
	bmi	DPlusV			; si es el DosPlus 5.0 salta a DPlusV
	beq	DOS1xV			; si es el DOS11C/12A/13A salta a DOS1xV
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DOS41V	jsr	$d6cc			; llama rutina LOF del DOS4.1
	bne	eMal			; si no devuelve 0, muestra error
	ldx	FilePtr			; recupera el puntero
	stx	<$A6			; lo vuelve a poner en la rutina GetChar
	jsr	$d4ce			; llama rutina LOAD del DOS4.1
	bra     CloFL			; cerrar ficheros y salir
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DPlusV	jsr	$d741			; calls LOF function
	bne	eMal			; if error, show it
	jsr	$df0a			; calculate exact length (sectors)
	bne	eMal			; show error if any
	ldx	FilePtr			; recupera el puntero
	stx	<$A6			; lo vuelve a poner en la rutina GetChar
	jsr	$d50d			; llama LOAD del DPlus5.0
	bra	CloFL			; cerrar ficheros y salir
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
DOS1xV  jsr     $d6c8			; llama rutina LOF del DOS11C/12A/13A
	bne	eMal			; si no devuelve 0, muestra error
	ldx	FilePtr			; recupera el puntero
	stx	<$A6			; lo vuelve a poner en la rutina GetChar
	jsr     $d4a7			; llama rutina LOAD del DOS11C/12A/13A
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
CloFL	jsr 	[$c010]			; cierra ficheros abiertos
	clr	$ff48			; stop spinning motor
	ldx	f8cps			; get f8-f9
	stx	<$f8			; update pseudo-reg
	lbsr	rstA6			; restore interpreter pointer $A6
	puls	cc,d,x,y,u,pc		; recupera registros y retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
eMal	ldx	#nFound			; apunta a mensaje de error
	bsr	BckBeep			; show message and emit beeps
	bra	CloFL			; salir de LOAD
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
BckBeep
eMal2	ldb	#11			; para escribir tras el nombre del fichero
	bsr	BackSpaces		; los envia a pantalla
	lbsr	shwMsg			; muestra el mensaje
	ldb	#3			; numero de pitidos
	lbsr	Beeps			; emite pitidos
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
BackSpaces				; enviar B retrocesos de carro
	lda	#8			; cdigo de BackSpace
nxtBS	jsr	L_85B8			; imprimirlo
	decb				; decrementa contador
	bne	nxtBS			; si no es 0, siguiente espacio atrs
	rts				; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; message for problems detecting the DOS
Severe  ldx	#abEnd			; apunta a mensaje
	lbsr	shwMsg			; muestra mensaje
rdKey	jsr	ReadKey			; lee teclado
	beq	rdKey			; si ninguna letra vuelve a leer
	lbra	OutToB			; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
LdFCC	lbsr	diskInside		; is there a disk?
	bne	lNoDsk			; no, show error message
	ldx	FilePtr			; recupera el puntero
	leax	-1,x			; points one char before
	stx	<$A6			; lo pone en la rutina GetChar
	jsr	$cfc1			; llama LOAD de CoCo
eLdCC	clr	$ff40			; stop motor CoCo
	puls	cc,d,x,y,u,pc		; restore registers and return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
eMalCC	leas	7,s			; clean stack, RS-DOS has filled it ('patch')
	lda	,s			; get flags
	ora	#1			; set carry
	sta	,s			; update flags on stack
	ldx	#nFound			; apunta a mensaje de error
	fcb	$10			; to mask next ldx
lNoDsk	ldx	#woDsk			; point to error message
	bsr	BckBeep			; show message and emit beeps
	bra	eLdCC			; exit CoCo LOAD
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
WorkFileName
	ldb	<$eb			; save last used drive number
	stb	oldEB			; into copy variable
	ldb	13,x			; get drive number shown on screen
	subd	#$30			; convert to binary
	stb	workEB			; put as working variable
	pshs	x			; save filename pointer (Load and Save do not use the same)
	ldb	#25			; para escribir un espacio despus del comando LOAD
WFN01	bsr	BackSpaces		; los envia a pantalla
	ldb	#14			; longitud nombre del fichero mas unidad disco
	jsr	shwNchr			; imprime B caracteres de X
					; permite numeros (0-9), Enter y RetrocesoCarro	
readK	jsr	ReadKey			; leer teclado
	cmpa	#$0D			; es Enter?
	beq	eReadK			; salir con el numero recibido
					; adems admite A-B-C-D como unidades 1-2-3-4
	cmpa	#'A'			; is it lower than letter A?
	blo	1f			; yes, skip controls
	cmpa	#'D'			; is it greater then letter D?
	bhi	1f			; yes, skip control
	suba	#$10			; convert to number
	ldx	,s			; get received filename pointer
	stx	FilePtr			; update pointer			
	tst	CoCoFlg			; is it a CoCo?
	beq	2f			; no, skip next
	deca				; convert 1-2-3-4 into 0-1-2-3 for CoCo
2	sta	13,x			; update drive number
	suba	#'0'			; to convert 31-32-33-34 into 1-2-3-4 
					;         or 30-31-32-33 into 0-1-2-3
	sta	workEB			; update selected drive
	ldb	#14			; to go 14 spaces back
	bra	WFN01			; update screen
1	cmpa	#$08			; es RetrocesoCarro?
	bne	number			; no, mirar si es cifra
	ldb	-8,x			; tomar decena como unidad
	lda	#'0			; 0 como decena
	std	-8,x			; actualizar numeros en nombre fichero
	bra	reDraw			; repintar en pantalla
number	cmpa	#'0			; es menor que 0?
	blo	readK			; si, leer de nuevo
	cmpa	#'9			; es mayor que 9?
	bhi	readK			; si, leer de nuevo
	ldb	-7,x			; tomar unidad
	stb	-8,x			; poner como decena
	sta	-7,x			; poner cifra tecleada como unidad
					; redibujar cifras en pantalla
reDraw	
	ldb	#8			; send eight
	jsr	BackSpaces		; backspaces (filenum.BIN:drive)
	leax	-8,x			; ser pointer 8 positions backwards
	ldb	#8			; bytes to print
	jsr	shwNchr			; show text
	bra     readK			; vuelve a leer teclado
eReadK	jsr	L_85B8			; envia un Enter
	ldb	workEB			; put selected drive number
	stb	<$eb			; to DOS variable
	leas	2,s			; get rid of saved pointer
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; intercambia los registros BC, DE y HL con sus registros espejo (EXX de Z-80)
					; o sea reg_BC, reg_DE, reg_HL con esp_BC, esp_DE, esp_HL
do_exx	pshs	x,u			; salva registros de trabajo
	ldx	<reg_BC			; recupera registro BC
	ldu	esp_BC			; recupera espejo BC
	stx	esp_BC			; pasa registro a espejo
	stu	<reg_BC			; pasa espejo a registro
	ldx	<reg_DE			; recupera registro DE
	ldu	esp_DE			; recupera espejo DE
	stx	esp_DE			; pasa registro a espejo
	stu	<reg_DE			; pasa espejo a registro
	ldx	<reg_HL			; recupera registro HL
	ldu	esp_HL			; recupera espejo HL
	stx	esp_HL			; pasa registro a espejo
	stu	<reg_HL			; pasa espejo a registro
	puls	x,u,pc			; restaura registros y retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; copia B bytes apuntados por X a la zona apuntada por U (LDIR de Z-80)
do_ldir pshs	a			; save working register
do_ldi1	lda	,x+			; lee 1 byte de origen
	sta	,u+			; lo pasa a destino
	decb				; decrementa contador
	bne	do_ldi1			; si no es cero, vuelve a do_ldir
	puls	a,pc			; restore register and return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
					; intercambia registro A y Flags con sus espejos AF'
do_exAF_AF				; stack. arriba pc
	pshs	u			; stack. arriba u,pc
	tfr	cc,b			; D = A,F
	ldu	esp_AF			; U = AF', recupera valores espejo
	std	esp_AF			; guarda valores actuales en espejo
	tfr	u,d			; pasa valores espejo a D
	tfr	b,cc			; pasa valor espejo F' a flags
	puls	u,pc			; recupera U y retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
;No_implementado
LDANGER	tfr	d,x			; pass A and B to X to be shown
	pshs	x
	ldx	#danger			; apunta a mensaje
shwTxt	ldb	,x+			; toma longitud
	jsr	shwNchr			; muestra cadena
nxtStep	lda	2,s			; recupera byte alto direccin de retorno del stack
	bsr	ShowHexa		; mostrarlo en formato hexadecimal
	lda	3,s			; recupera byte bajo direccin de retorno del stack
	bsr	ShowHexa		; mostrarlo en formato hexadecimal
	lda	#' '
	jsr	L_85B8			; imprimirlo
	lda	#'-'
	jsr	L_85B8			; imprimirlo
	lda	#' '
	jsr	L_85B8			; imprimirlo
	lda	,s			; recupera byte alto registro X
	bsr	ShowHexa		; mostrarlo en formato hexadecimal
	lda	1,s			; recupera byte bajo registro X
	bsr	ShowHexa		; mostrarlo en formato hexadecimal
	leas	2,s			; clean stack
	ldb	#1			; un pitido
	jsr	Beeps			; emitirlo
cWfK0	jsr	ReadKey			; lee teclado
	beq	cWfK0			; si no tecla, volver a leer
	lbra	OutToB			; abandona el programa y vuelve al Intrprete de Basic
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ShowHexa				; muestra en dos caracteres (0-9 y A-F) el byte recibido en A
	bsr	convHexa		; convertir A en 2 digitos hexa
	jsr	L_85B8			; imprime primer digito hexa
	tfr	b,a			; pasa B a A
	jsr	L_85B8			; imprime segundo digito hexa
	rts				; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
convHexa				; convierte A en dos digitis hexadecimales (ASCII) en D
	tfr	a,b			; lo copia en B (nibble bajo)
	lsra				; nibble alto. Pasa los 4
	lsra				; bits altos
	lsra				; hacia los
	lsra				; 4 bits bajos. Ceros en el nibble alto
	andb	#$0F			; pasa a 0 el nibble alto de B
	cmpa	#$0a			; es A menor de 10?
	blo	nxtDig			; si, no retocar
	adda	#7			; no, aadir 7 para convertir en letra
nxtDig	cmpb	#$0a			; es B menor de 10?
	blo	adjust			; si, no retocar
	addb	#7			; no, aadir 7 para convertir en letra
adjust	addd	#$3030			; los pasa a ASCII
	rts
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
detect2 pshs	x			; guarda registro
	clra				; resultado para DOS11C/12A/13A
	ldx	$D4A7			; lee dos bytes concretos
	cmpx	#$5FF7			; son los del DOS11C/12A/13A?
	beq	eDet2			; si, sale
	inca				; resultado para DOS4.1
	cmpx	#$8E06			; son los del DOS4.1?	
	beq	eDet2			; si, sale
	lda	#$ff			; resultado para DosPlus (-1)
	cmpx	#$17df			; son los bytes del DPlus?
	beq	eDet2			; si, sale
uknwn	ldx	#ukDOS			; apunta a mensaje
	jsr	shwMsg			; lo muestra
	lbra	Severe			; sale via error severo
eDet2	tsta				; actualiza flag Z	
	puls	x,pc			; retorna
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
LoadParts				; verify DOS version. If not supported send message TO BASIC!!
	ldb	<$eb			; get program drive
	stb	oldEB			; save copy
	clr	CoCoFlg			; set CoCo flag to false
	lda	$ffff			; get contents of $FFFF
	cmpa	#$b4			; is it $B4 (a Dragon)?
	beq	isDgn			; yes, goto Dragon code
	cmpa 	#$1b			; is a CoCo3?
	bne	isCoCo			; no, so is a CoCo2
	inc	CoCoFlg			; so that it will end with value 2
   if DOUBLE==1				; if running H2X 
	clr	$ffd9			; set double speed
   else					; if running H1X or HIMG
	clr	$ffd8			; ensure normal speed
   endif
	clr	$ffde			; disable Super Extended Basic
	ldb	#$36			; get code for yellow color
	stb	$ffb1			; update palette slot
isCoCo	inc 	CoCoFlg			; set the CoCo flag to true (1 or 2)
				; CoCo RS-DOS control
	ldx	$c153			; get data from the RS-DOS
	cmpx	#$312e			; is it 1.1 - 1.2 or 1.2A? (looks for "1.")
	beq	keepCo			; yes, goto CoCo code
					; no, send unsupported RS-DOS message. disk1.0 has $3938
unSup2	ldx	#ukDOS-1		; point to message
	leas 	2,s			; get rid of return address from the stack
	jmp	$b99c			; rutina send String to CoCo screen
				; Dragon DDOS control
isDgn   ldx	$D4A7			; lee dos bytes concretos
	cmpx	#$5FF7			; son los del DOS11C/12A/13A?
	beq	keepOn			; si, sale
	cmpx	#$17df			; son los bytes del DPlus?
	beq	keepOn			; si, sale
	cmpx	#$8E06			; son los del DOS4.1  SuperDos?	
	beq	keepOn			; si, sale
	ldx	$dfda			; get data
	cmpx	#$2045			; is " E" (SuperDOS signature)? 
	beq	keepOn			; si, sale
unSup1	ldx	#ukDOS-1		; apunta a mensaje
	leas	2,s			; get rid of return address from the stack
	jmp	$90e5			; rutina send message to Dragon screen
keepCo	lda	#$30			; get drive 0
	sta	LoadGam+14		; set drive = 0 for Load
	sta	SaveGam+14		; set drive = 0 for Save
keepOn	ldx	#Utils			; apunta a pantalla inicial
	stx	FilePtr			; guarda puntero			
	jsr	LdFilePgm		; carga fichero de disco		
	jsr	CoCo3Uti		; call patch
wUsrK	jsr	ReadKey			; read beyboard
	beq	wUsrK			; no key, loopback
	ldx	#Credits		; apunta a pantalla creditos
	stx	FilePtr			; guarda puntero			
	jsr	LdFilePgm		; carga fichero de disco		
	jsr	CoCo3Cre		; call patch
SwM1	bsr	SwMap1			; switch to map1 if not already in it
	tst	CoCoFlg			; is it a CoCo?
	beq	PM4img			; no, skip two
	ldu	#eMalCC			; error dispatch routine
	stu	$c6ed			; patch RS-DOS for NF ERROR
	ldu	#protDsk		; error dispatch routine
	stu	$d70c			; patch RS-DOS for SAVE if protected disk
	ldb	<$eb			; get system drive
	stb	drvAlt			; set as alternate too
	ldx	#AltDrv			; point to data table
	lda	b,x			; get alternate drive
	pshs	a,b			; save onto stack: alternate and actual
	sta	workEB			; set drive to verify
	jsr	diskInside		; call diskInside routine
	puls	a			; get aternate value
	bne	rstDrv			; no disk, do nothing
	sta	drvAlt			; if OK update alternate one
rstDrv	puls	b			; restore actual drive
	stb	<$eb			; update system variable
PM4img	ldx	#Pmode4			; apunta a presentacin en PMode4	
	stx	FilePtr			; guarda puntero			
	jsr	LdFilePgm		; carga fichero de disco		
	ldx	#Hob2			; apunta a fichero datos Hobbit
	stx	FilePtr			; guarda puntero			
	jsr	LdFilePgm		; carga fichero de disco		
	ldx	#SelPal			; point to message
	ldu	#$5e0			; point to screen
prtChr	lda	,x+			; get a char
	beq	setBuf			; if null, exit
	sta	,u+			; put on screen
	bra	prtChr			; go for next char
setBuf	clr	<$f7			; set Buff palette by default
readKbd	bsr	ReadKey			; read keyboard
	beq	readKbd			; no key, loop
	cmpa	#'G'			; G pressed?
	bne	quitBk			: no, skip next
	inc	<$f7			; set Green palette
quitBk	rts				; return
AltDrv	fcb	$01,$00,$03,$02		; alternate drive for each one of them
drvAlt	fcb	$00			; alternative drive for Images
segDrv	fcb	$00			; to save oldEB while loading Images with alternate drive
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
SwMap1	orcc	#$50			; disable interrupts
	ldx	$c000			; get 2 bytes from ROM area
	ldu	#$9669			; write 2 'special' bytes
	stu	$c000			; in its place
	cmpu	$c000			; have they changed?
	bne	switch			; no, must switch to MAP1
	stx	$c000			; yes, restore both bytes
	bra	doNot			; do nothing, we are already in MAP1
switch	ldx	#$8000			; point to std BASIC ROM
loop1	sta	$ffde			; switch to MAP0 (RAM-ROM)
	ldd	,x			; get a word
	sta	$ffdf			; switch to MAP1 (all 64k RAM)
	std	,x++			; put at destination
	cmpx	#$e000	 		; copied full ROMs (Basic and DDOS)? - just till DFFF!!
	blo	loop1			; no, loopback
doNot	andcc	#$af			; enable interrupts
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
ReadKey	tst	CoCoFlg			; is CoCo machine?
	beq	1f			; no, go to Dragon routine
	jsr	$a1c1			; scan CoCo keyboard
	bra	ctrLow			; go avoid lowercase
1	jsr	$8006			; scan Dragon keyboard
ctrLow	beq	2f			; no key, exit
	cmpa	#$61			; is it lowercase 'a' or greater?
	blo	2f			; no, skip next
	anda	#%11011111		; lowcase -> uppercase
2	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
LdFClr					; Load File, clean screen lines and decrunch
   if DOUBLE==1 			; if running H2X
	clr	$ffd9			; set double speed
   else
     if SEMI==1				; if running HIMG
        clr	$ffd9			; set double speed
     else   				; if running H1X
	clr	$ffd8			; ensure normal speed
     endif
   endif
	tst	CoCoFlg			; get coco flag
	beq	1f			; if not a CoCo, go load file
	ldb	oldEB			; get actual drive
	stb	segDrv			; save value
	ldb	drvAlt			; get alternate drive
	stb	oldEB			; update old system value
	stb	<$eb			; andsystem value
	stb	$095A			; set as DEFDRV
1	lbsr	LdFilePgm		; load the file
	pshs	cc			; save flags
	tst	CoCoFlg			; get coco flag
	beq	5f			; if not a CoCo, skip next two
	ldb	segDrv			; get saved value
	stb	oldEB			; restore old value
	stb	<$eb			; update system value
	stb	$095A			; set as DEFDRV
5	puls 	cc			; restore flags
	bcs	2f			; if load error, exit
	bsr	Clr2Rows		; clean the needed rows
	tst	CoCoFlg			; is it a CoCo?
	beq	1f			; no, skip decrunching
	jsr	deExo2			; decrunch loaded image
2	ldb	CoCoFlg			; get CoCo flag
	cmpb	#2			; is it a CoCo3?
	bne	1f			; no, skip next
   if DOUBLE==1				; if running H2X
     	clr	$ffd9			; ensure double speed
   else					; if running H1X or HIMG
	clr	$ffd8			; ensure normal speed
   endif   
1	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
Clr2Rows				; clear 1-2 rows upon the machine
	ldx	#$1dc0			; point to next pixel row after image
	ldd	#$ff40			; white color and number of bytes
	tst	CoCoFlg			; is it a CoCo?
	beq	1f			; no, skip corrections
	rorb				; fill only 32 bytes
	abx				; begin one row lower ($1de0)
1	sta	,x+			; paint a byte
	decb				; decrement counter
	bne	1b			; not yet done, loopback
	rts				; return
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
	zmb	$7ed8-*			; free space. Next comes BASIC & DOS
	include "HOB_DATOS-08B06.txt"
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------
