; Adapted for Z80 Spectrum syntax, assembled with pasmo
; Z80 disassembly routine in Z80

        ORG 50000

        LD      A,2             ; upper screen
        CALL    5633            ; open channel

        LD      DE,0            ; first address to disassembly
        LD      BC,30           ; number of lines
        CALL    _disz80

	; need to return to lower screen
        LD      A,1             ; lower screen
        CALL    5633            ; open channel

	CALL    $15DE           ; WAIT-KEY1

        RET


;  This code is been found in a ZX Spectrum tool called UTILITY3 v1.3


_disz80:
        push    ix

dizloop:
        push    bc
        call    DISASM
        pop     bc
        ld      a,13
        call    CHROP
        dec     bc
        ld      a,b
        or      c
        jr      nz,dizloop
        ld      h,d
        ld      l,e
        pop     ix
        ret

; ====================
; DIS-Z80 was published in the SUBSET column of Personal Computer World 1987.
; The routine disassembles a single Z80 instruction at address DE.
; It is required to be followed by a routine called CHROP that outputs a
; single ASCII character.
; It was originally developed for CP/M on an Amstrad CPC128.

; The original ORG was $0100. I have added $5000 to all addresses.
; The stated aim was to write a Z80 disassembly routine in as short a space
; as possible and, at just over 1K (1090 bytes), it is a rather incredible
; program.

; The SUBSET editor David Barrow was able to trim only one byte from John
; Kerr's compact code. I've forgotten where so there's a challenge.
; ====================

; STRUCTURAL CONCEPTS
; DATA
;
; Disassembled line:
;		field 1: instruction 1st byte location (5 cols).
;		field 2: instruction bytes (12 cols).
;		field 3: mnemonic (5 cols).
;		field 4: operand(s) (13 cols).
;
; Location address	: ASCII hex (4 digits).
; Instruction bytes	: ASCII hex (2 digits sequence).
; Operand data &	: ASCII hex with appended "H" if >9,
;	addresses		:	and preceeding "0" if 1st digit >9.
; Operand offsets	: signed decimal, linked "+" or "-".

; PROGRAM DETAILS
;
; INPUT				DE addresses 1st byte of instruction to disassemble.
; OUTPUT			35 character disassembled line to uotput device.
; STATE CHANGES		DE updated to address 1st byte of next instruction.
;					AF BC HL changed.
; I/O ERRORS		None.
; OPTIMISATION		Not given.
; INTERRUPT EFFECT	May be interrupted and re-entered.
; LOCATION NEEDS	Not specific. Not relocatable. PROMable.
;					(Listing in this datasheet is assembled at 0100H)
; PROGRAM BYTES		695: code 206 + referenced tables:-
;						GROUP2 (27), GROUP1 (168), GROUP3 (86),
;						MONICS (208).
; STACK BYTES		46 maximum.
; CLOCK CYCLES		Not given.


DISASM:	CALL 	ADRSP		; Output the source pointer.

       	LD 	BC,$0900		; Create an 18-byte output
       	LD 	HL,$2020		; buffer in the stack area.

BUFFER:	PUSH 	HL			; Buffer initially contains
       	DJNZ 	BUFFER		; 18 ASCII spaces (20H).

       	LD 	H,B				; Copy SP into HL, so the
       	LD 	L,C				; first byte of the output
       	ADD 	HL,SP		; buffer is addressed by HL.

       	PUSH 	BC			; Save original IX and
       	EX 	(SP),IX			; initialize to zero.
       	PUSH 	BC			; Initialize temp storage
       	PUSH 	BC			; (workspace) to all zeros.
       	ADD 	IX,SP		; Point IX to workspace.

       	PUSH 	HL			; Save buffer pointer; point
       	LD 	HL,GROUP3		; to "ED" instruction group.

TRYNDX:	CALL 	FETCH		; Fetch a byte of code.

       	LD 	B,C				; First check whether this
       	CP 	$ED				; is an "ED" instruction.
       	JR 	Z,CONFLG		; Yes; clear the index flag.

       	INC 	B			; Ready to set flag to "1"
       	CP 	$DD				; if the byte is 0DDH (an
       	JR 	Z,CONFLG		; instruction using IX).

       	INC 	B			; Ready to set flag to "2"
       	CP 	$FD				; if the byte is 0FDH (an
       	JR 	NZ,NOTNDX		; instruction using IY).

CONFLG:	LD 	(IX+1),B		; Condition the index flag.
       	INC 	B			; Repeat index tests if the
       	DJNZ 	TRYNDX		; pre-byte was 0DDH or 0FDH.
       	JR 	NXBYTE			; Otherwise continue.

NOTNDX:	LD 	C,A				; Save byte; check if index
       	LD 	A,(IX+1)		; flag was set (Allows any
       	OR 	A				; series of 0DDH and/or OFDH
       	JR 	Z,NODISP		; bytes, as per Zilog spec).

       	LD 	A,C				; If so, check for presence
       	CP 	$CB				; of any displacement.
       	JR 	Z,GETDIS		; 0CBH needs a displacement.

       	AND 	$44			; A displacement is required
       	CP 	4				; if opcode has bit 2 set
       	JR 	Z,GETDIS		; and bit 6 reset.

       	LD 	A,C				; A displacemnet is required
       	AND 	$C0			; if opcode has bit 6 set
       	CP 	$40				; and bit 7 reset.
       	JR 	NZ,NODISP

GETDIS:	CALL 	FETCH		; Get displacement if needed
       	LD 	(IX+2),A		; and save it in workspace.

NODISP:	LD 	HL,GROUP1		; "Main" instruction gorup.
       	LD 	A,C				; Recover opcode & check
       	CP 	$CB				; for OCBH ("bit" group).
       	JR 	NZ,NEWMSK		; No; start the search.

       	LD 	HL,GROUP2		; Yes; point to "CB" group.

NXBYTE:	CALL 	FETCH		; Fetch the last non-data
       	LD 	C,A				; byte and store it in C.

NEWMSK:	LD 	A,(HL)			; Fetch a mask from table.
       	OR 	A				; Mask value of 0 indicates
       	JR 	Z,TABEND		; end of table; quit search.

       	AND 	C			; Otherwise mask the opcode
       	INC 	HL			; and address the mode byte.

NEWMOD:	LD 	B,(HL)			; Fetch the mode byte in B.
       	INC 	HL			; Point to the match byte.
       	INC 	B			; Test if the mode is 0FFH
       	JR 	Z,NEWMSK		; and if so, get a new mak.

TRYMAT:	CP 	(HL)			; Is the masked opcode
       	INC 	HL			; equal to the match byte?
       	JR 	Z,GETNDX		; Stop searching if it is.

       	BIT 	7,(HL)		; index byte bit 7 is set if
       	INC 	HL			; address mode changes.
       	JR 	Z,TRYMAT		; No change; try next match.

       	JR 	NEWMOD			; Change; get a new mode.

GETNDX:	LD 	A,(HL)			; Matched: fetch mnemonic
       	AND 	$7F			; index, mask bit 7, and
       	DEC 	B			; restore the mode byte.

TABEND:	POP 	HL			; Save the source pointer
       	PUSH 	DE			; below the output buffer
       	PUSH 	HL			; pointer on stack.

       	EX 	DE,HL			; Point HL to start of the
       	LD 	HL,MONICS		; mnemonics table.
       	CALL 	XTRACT		; Copy mnemonic to buffer.

       	POP 	HL			; Restore output pointer
       	LD 	DE,5			; and adjust to align
       	ADD 	HL,DE		; any operands present.
       	POP 	DE			; Restore source pointer.

       	LD 	A,B				; Test high-order B to see
       	AND 	$F0			; if any "first" operand
       	JR 	Z,SECOND		; is present.

       	RRA					; Yes; move the operand
       	RRA					; index into the lower
       	RRA					; half of A.
       	RRA					; Then save
       	PUSH 	BC			; operand and opcode.

       	LD 	B,A				; Operand index in B.
       	LD 	A,C				; Restore opcode to A.
       	CALL 	OPRND1		; Process the operand.

       	POP 	BC			; Restore the operand byte
       	LD 	A,B				; and opcode; test
       	AND 	$0F			; low-order B for any
       	JR 	Z,OPDONE		; "second" operand.

       	LD 	(HL),44  		; Opearnd index in B.
       	INC 	HL			; Restore opcode to A.

SECOND:	LD 	A,B				; Check for the presence
       	AND 	$0F			; of a "second" operand.

       	LD 	B,A				; Operand index in B.
       	LD 	A,C				; Restore opcode to A.
       	CALL 	NZ,OPRND2	; Process any operand.

OPDONE:	LD 	A,3				; Check how many bytes
       	SUB 	(IX+0)		; have been fetched.

       	POP 	HL			; Discard workspace.
       	POP 	HL
       	POP 	IX			; Restore index register.

       	JR 	C,OUTEXT		; 4 or more bytes fetched.

       	INC 	A			; Less than four bytes
       	LD 	B,A				; fetched; so output
       	ADD 	A,B			; enough spaces to
       	ADD 	A,B			; align the mnemonics.
       	LD 	B,A

SPACES:	LD 	A,$20			; Output spaces
       	CALL 	CHROP		; to start of
       	DJNZ 	SPACES		; mnemonic field.

OUTEXT:	LD 	B,18			; Set buffer byte count.

PUTOUT:	DEC 	SP			; Copy stored text, byte
       	POP 	HL			; at a time, from output
       	LD 	A,H				; buffer on stack to
       	CALL 	CHROP		; the output channel.
       	DJNZ 	PUTOUT

       	RET					; Instruction disassembled.

;***********************

GROUP2:	defb 	$C0,$36,$40
	defb 	$04,$80,$2D,$C0,$BE
	defb 	$FF,$F8,$06,$00,$33
	defb 	$08,$38,$10,$35,$18
	defb 	$3A,$20,$3F,$28,$40
	defb 	$30,$00,$38,$C1


GROUP1:	defb 	$FF,$00,$00
	defb 	$24,$07,$32,$0F,$37
	defb 	$17,$31,$1F,$36,$27
	defb 	$0D,$2F,$0B,$37,$3D
	defb 	$3F,$06,$76,$14,$C9
	defb 	$30,$D9,$12,$F3,$0F
	defb 	$FB,$91,$72,$C6,$02
	defb 	$CE,$01,$DE,$BC,$02
	defb 	$D6,$42,$E6,$03,$EE
	defb 	$43,$F6,$25,$FE,$8C
	defb 	$04,$08,$93,$01,$10
	defb 	$10,$18,$9D,$AF,$22
	defb 	$A2,$FA,$2A,$A2,$A7
	defb 	$32,$A2,$7A,$3A,$A2
	defb 	$03,$C3,$1C,$CD,$85
	defb 	$97,$D3,$AA,$79,$DB
	defb 	$9B,$5F,$E3,$93,$0E
	defb 	$E9,$9C,$05,$EB,$93
	defb 	$DF,$F9,$A2,$FF,$C0
	defb 	$B6,$40,$A2,$FF,$F8
	defb 	$76,$80,$02,$88,$01
	defb 	$98,$BC,$06,$90,$42
	defb 	$A0,$03,$A8,$43,$B0
	defb 	$25,$B8,$8C,$FF,$C7
	defb 	$0B,$04,$16,$05,$8E
	defb 	$B2,$06,$A2,$20,$C0
	defb 	$B0,$23,$C2,$1C,$C4
	defb 	$85,$10,$C7,$BB,$FF
	defb 	$CF,$D3,$01,$A2,$0D
	defb 	$03,$16,$0B,$8E,$FD
	defb 	$09,$82,$60,$C1,$2B
	defb 	$C5,$AC,$FF,$E7,$21
	defb 	$20,$9D,$FF,$EF,$E7
	defb 	$02,$A2,$7E,$0A,$A2


GROUP3:	defb 	$FF,$00,$44
	defb 	$23,$45,$2F,$4D,$2E
	defb 	$4E,$00,$67,$39,$6F
	defb 	$34,$70,$00,$71,$00
	defb 	$A0,$21,$A1,$0A,$A2
	defb 	$1A,$A3,$29,$A8,$1F
	defb 	$A9,$08,$AA,$18,$AB
	defb 	$28,$B0,$20,$B1,$09
	defb 	$B2,$19,$B3,$27,$B8
	defb 	$1E,$B9,$07,$BA,$17
	defb 	$BB,$A6,$FF,$C7,$B8
	defb 	$40,$9B,$8B,$41,$AA
	defb 	$FF,$CF,$FD,$42,$3C
	defb 	$4A,$81,$AD,$43,$A2
	defb 	$DA,$4B,$A2,$FF,$E7
	defb 	$40,$46,$95,$FF,$F7
	defb 	$C7,$47,$A2,$7C,$57
	defb 	$A2,$FF,$00

;_______________

MONICS:	defb 	$BF
	defb 	'A','D','C'+$80   	; ADC
	defb 	'A','D','D'+$80   	; ADD
	defb 	'A','N','D'+$80   	; AND
	defb 	'B','I','T'+$80   	; BIT
	defb 	'C','A','L','L'+$80	; CALL
	defb 	'C','C','F'+$80   	; CCF
	defb 	'C','P','D','R'+$80	; CPDR
	defb 	'C','P','D'+$80   	; CPD
	defb 	'C','P','I','R'+$80	; CPIR
	defb 	'C','P','I'+$80   	; CPI
	defb 	'C','P','L'+$80   	; CPL
	defb 	'C','P'+$80      	; CP
	defb 	'D','A','A'+$80   	; DAA
	defb 	'D','E','C'+$80   	; DEC
	defb 	'D','I'+$80      	; DI
	defb 	'D','J','N','Z'+$80	; DJNZ
	defb 	'E','I'+$80      	; EI
	defb 	'E','X','X'+$80   	; EXX
	defb 	'E','X'+$80      	; EX
	defb 	'H','A','L','T'+$80	; HALT
	defb 	'I','M'+$80      	; IM
	defb 	'I','N','C'+$80   	; INC
	defb 	'I','N','D','R'+$80	; INDR
	defb 	'I','N','D'+$80   	; IND
	defb 	'I','N','I','R'+$80	; INIR
	defb 	'I','N','I'+$80   	; INI
	defb 	'I','N'+$80      	; IN
	defb 	'J','P'+$80      	; JP
	defb 	'J','R'+$80      	; JR
	defb 	'L','D','D','R'+$80	; LDDR
	defb 	'L','D','D'+$80   	; LDD
	defb 	'L','D','I','R'+$80	; LDIR
	defb 	'L','D','I'+$80   	; LDI
	defb 	'L','D'+$80      	; LD
	defb 	'N','E','G'+$80   	; NEG
	defb 	'N','O','P'+$80   	; NOP
	defb 	'O','R'+$80      	; OR
	defb 	'O','T','D','R'+$80	; OTDR
	defb 	'O','T','I','R'+$80	; OTIR
	defb 	'O','U','T','D'+$80	; OUTD
	defb 	'O','U','T','I'+$80	; OUTI
	defb 	'O','U','T'+$80   	; OUT
	defb 	'P','O','P'+$80   	; POP
	defb 	'P','U','S','H'+$80	; PUSH
	defb 	'R','E','S'+$80   	; RES
	defb 	'R','E','T','I'+$80	; RETI
	defb 	'R','E','T','N'+$80	; RETN
	defb 	'R','E','T'+$80   	; RET
	defb 	'R','L','A'+$80   	; RLA
	defb 	'R','L','C','A'+$80	; RLCA
	defb 	'R','L','C'+$80   	; RLC
	defb 	'R','L','D'+$80   	; RLD
	defb 	'R','L'+$80      	; RL
	defb 	'R','R','A'+$80   	; RRA
	defb 	'R','R','C','A'+$80	; RA
	defb 	'R','R','C'+$80   	; RRC
	defb 	'R','R','D'+$80   	; RRD
	defb 	'R','R'+$80      	; RR
	defb 	'R','S','T'+$80   	; RST
	defb 	'S','B','C'+$80   	; SBC
	defb 	'S','C','F'+$80   	; SCF
	defb 	'S','E','T'+$80   	; SET
	defb 	'S','L','A'+$80   	; SLA
	defb 	'S','R','A'+$80   	; SRA
	defb 	'S','R','L'+$80   	; SRL
	defb 	'S','U','B'+$80   	; SUB
	defb 	'X','O','R'+$80   	; XOR


; OPRNDZ		Operand Disassembler. To disassembler and output a valid
;				Z80 machine code operand.
; OPRND1		Entry point for certain modes (see DATA)
; OPRND2		Entry point for certain modes (see DATA)

; STRUCTURAL CONCEPTS
; DATA
;
;		Operand:	Standard Z80 assembler format.
;					The operand mode is determined by an input
;					index (1 - 15) and by point of entry:-
;
;		Index		OPRND1				OPRND2
;		------------------------------------------------------
;		1			RST address			Relative address
;		2			Condition			Immediate byte
;		3			Bit number			Immediate word
;		4			Interrupt mode		AF,AF'
;		5			(SP)				DE,HL
;		6			Register pair		8-bit source
;		------------------------------------------------------
;		7					A
;		8					(C)
;		9					(port number)
;		A					(Absolute address)
;		B					8-bit destination
;		C					I or R
;		D					16-bit register
;		E					Address in 16-bit register
;		F					Index register
;
; PROGRAM DETAILS
; INPUT
;					A = opcode.
;					B = operand index.
;					DE addresses next instruction byte.
;					HL addresses next free byte in output buffer.
;					(IX+0) = no. of instruction bytes fetched.
;					(IX+1) = index register flag (1=IX, 2=IY, else 0).
;					(IX+2) = displacement for any indexed instruction.
;
; OUTPUT			Operand is in output buffer.
;					DE and HL are updated.
; STATE CHANGES		AF BC are changed.
;					IX IY (IX+0,1,2) are unchanged.
;*****************

OPRND1:	DJNZ 	CONDIT		; First entry point; is mode
RSTADR:	AND 	$38			; a restart address? If so,
       	JR 	DA				; isolate opcode bits 5-3.

OPRND2:	DJNZ 	DAT8		; 2nd entry point; is mode
RELADR:	CALL 	FETCH		; PC relative? If so, fetch
       	LD 	C,A				; displacement & extend
       	RLA					; sign; put full 16-bit
       	SBC 	A,A			; signed displacemnet into
       	LD 	B,A				; BC.
       	EX 	DE,HL			; Move source pointer to HL,
       	PUSH 	HL			; save it on stack, compute
       	ADD 	HL,BC		; destination address & send
       	JR 	DHL				; to the output buffer.

CONDIT:	RRA					; Opcode bits 2-0 are not
       	RRA					; needed for any of the
       	RRA					; following modes (OPRND1).
       	DJNZ 	BITNUM		; Is operand a condition?
       	BIT 	4,A			; If so, check whether the
       	JR 	NZ,ABS			; address mode is relative
       	AND 	3			; or absolute. If relative,
ABS:   	AND 	7			; adjust condition index.
       	ADD 	A,$14		; Index condition in table.
       	JR 	PS1				; Copy it to the output buffer.

DAT8:  	DJNZ 	DAT16		; Is operand immediate byte?

D8:    	CALL 	FETCH		; Fetch a byte.
       	JR 	DA				; Send to output buffer.

BITNUM:	DJNZ 	INTMOD		; Is operand a bit number?
       	AND 	7			; Yes; isolate the index.

DA:    	LD 	C,A				; Move 8-bit data for output
       	SUB 	A			; from A into AC (so A=0)
       	JR 	DAC				; and send to output buffer.

DAT16: 	DJNZ 	EXAF		; Is operand an address?
D16:   	CALL 	FETCH	; Fetch low-order byte.
       	LD 	C,A				; Save it in C.
       	CALL 	FETCH		; Fetch high order byte.

DAC:   	EX 	DE,HL			; Exchange source & output
       	PUSH 	HL			; pointers. Save the source
       	LD 	H,A				; pointer & copy output data
       	LD 	L,C				; from AC into HL.

DHL:   	LD 	C,$F8			; Specify hex conversion.
       	PUSH 	HL			; Save output for checking.
       	CALL 	CONVHL		; Perform ASCII conversion.
       	POP 	HL			; retrieve output value.

       	LD 	BC,$000A		; Check whether the value
       	OR 	A				; output was greater than 9.
       	SBC 	HL,BC		; Result of test in Cy.

		POP 	HL			; Restore source & output
       	EX 	DE,HL			; pointers to their originall
       	RET 	C			; registers. Exit if output
       	LD 	(HL),'H'		; value was 9 or less; else
       	INC 	HL			; put "H" (denoting hex)
       	RET					; after the output & exit.

INTMOD:	DJNZ 	STKTOP		; Is operand interrupt mode?
       	AND 	3			; Index the list of
       	ADD 	A,$1C		; interrupt modes (0,1,2)
PS1:   	JR 	PS3				; Copy to output buffer.

STKTOP:	LD 	C,$13			; The constant operand (SP)
       	DEC 	B			; is entry number 19 in the
       	JR 	Z,PS2			; RGSTRS table.

REG16P:	DJNZ 	COMMON2		; Is the operand register pair?
       	RRA					; Isolate the two bits of the
       	AND 	3			; opcode which determine the
       	CP 	3				; pair. Is it AF?
       	JR 	NZ,RX			; No; go to double register.
       	DEC 	A			; Yes, adjust pointer.
       	JR 	RNX				; Copy out register name.

EXAF:  	LD 	C,$0A			; The constant operand
       	DEC 	B			; AF,AF' is entry number 10
       	JR 	Z,PS2			; in the RGSTRS table.

EXDE:  	INC 	C			; The constant operand DE,HL
       	DEC 	B			; is entry number 11 in the
       	JR 	Z,PS2			; RGSTRS table.

REG8S: 	DJNZ 	ACCUM		; Is operand 8-bit source?

R8:    	AND 	7			; Get register number.
       	CP 	6				; Is it a memory location?
       	JR 	NZ,PS3			; No; so it's B/C/D/E/H/L/A.
       	LD 	(HL),'('		; Yes; put the left parenthesis
       	INC 	HL			; into the output buffer.
       	CALL 	REGX		; Copy register HL/IX/IY.
       	LD 	A,(IX+2)		; Retrieve offset; check if
       	OR 	A				; it is zero. If so, don't
       	JR 	Z,RP			; bother to print it.
       	LD 	(HL),43 		; Otherwise, put a "+" sign
       	RLCA				; into the output buffer, but
       	RRCA				; now test the offset sign.
       	JR 	NC,POS			; If negative, change  the
       	LD 	(HL),45			; sign to "-" and negate
       	NEG					; the offset.

POS:   	INC 	HL			; Update the output pointer.
       	EX 	DE,HL			; Exchange pointers, saving
       	PUSH 	HL			; source pointer on stack.
       	LD 	H,B				; Put the absolute value
       	LD 	L,A				; of the offset into HL.
       	LD 	C,$FB			; Specify decimal and
       	CALL 	CONVHL		; perform ASCII convesion.
       	POP 	HL			; Restore pointers to their
       	EX 	DE,HL			; original registers.
       	JR 	RP				; Go put right parenthesis.

ACCUM: 	RRA					; Opcode bits 2-0 can now
       	RRA					; be discarded by OPRND2.
       	RRA

COMMON2:
	LD 	C,7				; OPRND1 and OPRND2 merge.
       	DEC 	B			; Accumulator addressing;
       	JR 	Z,PS2			; put "A" to output buffer.

PORTC: 	DEC 	C			; Constant operand "(C)" is
       	DJNZ 	IDAT8		; entry number 6 in RGSTRS.
PS2:   	LD 	A,C				; Copy string number into A.
PS3:   	JR 	PS4				; Go copy out the string.

IDAT8: 	DJNZ 	IDAT16		; Is operand a constant port
       	LD 	(HL),'('		; number? If so, that's just
       	INC 	HL			; like an immediate byte but
       	CALL 	D8			; inside brackets.
       	JR 	RP				; Close the brackets.

IDAT16:	DJNZ 	REG8		; Is operand an address for
       	LD 	(HL),'('		; data? That's just like a
       	INC 	HL			; CALL or JP address but
       	CALL 	D16			; inside brackets.
       	JR 	RP				; Close the brackets.

REG8:  	DEC 	B			; Use 8-bit source routine
       	JR 	Z,R8			; for an 8-bit destination.

IPAREF: DJNZ 	REG16	; Is operand I or R?
       	AND 	9			; Yes, then copy the correct
       	JR 	PS4				; string from RGSTRS.

REG16: 	RRA					; Is operand a
       	DJNZ 	IREG16		; 16-bit register?

R16:   	AND 	3			; Check for index register.

RX:    	CP  	2			; If it's an index register,
       	JR 	Z,REGX			; go use separate routine.

RNX:   	ADD 	A,$0C		; Not an index register;
       	JR 	PS4				; point ot BC/DE/AF/SP.

IREG16:	DJNZ 	REGX		; Is the operand an address
       	LD 	(HL),'('		; contained in a register?
       	INC 	HL			; Then just put brackets
       	CALL 	R16			; round the result from R16.

RP:    	LD 	(HL),')'		; Put right parenthesis in
       	INC 	HL			; output buffer, update
       	RET					; pointer, then exit.

REGX:  	LD 	A,(IX+1)		; Use the index flag to
       	ADD 	A,$10		; select an index register.

PS4:   	EX 	DE,HL			; Copy a string from RGSTRS.
       	PUSH 	HL			; Exchange pointers; save
       	LD 	HL,RGSTRS		; source pointer; point HL
       	CALL 	XTRACT		; to start of table and
       	POP 	HL			; copy out the string. Then
       	EX 	DE,HL			; restore pointers to their
       	RET					; original registers, exit.

;*************

RGSTRS:	defb 	'B'				+$80
	defb 	'C'       			+$80
	defb 	'D'       			+$80
	defb 	'E'       			+$80
	defb 	'H'       			+$80
	defb 	'L'       			+$80
	defb 	'(','C',')' 			+$80
	defb 	'A'       			+$80
	defb 	'I'       			+$80
	defb 	'R'       			+$80
	defb 	'A','F',',','A','F','\'		+$80
	defb 	'D','E',',','H','L'    		+$80
	defb 	'B','C'             		+$80
	defb 	'D','E'             		+$80
	defb 	'A','F'             		+$80
	defb 	'S','P'             		+$80
	defb 	'H','L'             		+$80
	defb 	'I','X'             		+$80
	defb 	'I','Y'             		+$80
	defb 	'(','S','P',')'       		+$80
	defb 	'N','Z'             		+$80
	defb 	'Z'                		+$80
	defb 	'N','C'             		+$80
	defb 	'C'                		+$80
	defb 	'P','O'             		+$80
	defb 	'P','E'             		+$80
	defb 	'P'                		+$80
	defb 	'M'                		+$80
	defb 	'0'    				+$80
	defb 	'?'    				+$80
	defb 	'1'    				+$80
	defb 	'2'    				+$80

;********************

CONVHL:	SUB 	A

CVHL1: 	PUSH 	AF
       	SUB 	A
       	LD 	B,16

CVHL2: 	ADD 	A,C
       	JR 	C,CVHL3
       	SUB 	C

CVHL3: 	ADC 	HL,HL
       	RLA
       	DJNZ 	CVHL2

       	JR 	NZ,CVHL1

       	CP 	10
       	INC 	B
       	JR 	NC,CVHL1

CVHL4: 	CP 	10
       	SBC 	A,$69
       	DAA
       	LD 	(DE),A
       	INC 	DE
       	POP 	AF
       	JR 	NZ,CVHL4

       	RET

;****************

XTRACT:	OR 	A
       	JR 	Z,COPY

SKIP:  	BIT 	7,(HL)
       	INC 	HL
       	JR 	Z,SKIP

       	DEC 	A
       	JR 	NZ,SKIP

COPY:  	LD 	A,(HL)
       	RLCA
       	SRL 	A
       	LD 	(DE),A

       	INC 	DE
       	INC 	HL
       	JR 	NC,COPY

       	RET

;*******************

FETCH: 	LD 	A,(DE)
       	INC 	DE
       	INC 	(IX+0)
       	PUSH 	AF
       	CALL 	BYTSP
       	POP 	AF
       	RET

ADRSP: 	LD 	A,D
       	CALL 	BYTOP
       	LD 	A,E

BYTSP: 	CALL 	BYTOP
       	LD 	A,$20
       	JR 	CHROP

BYTOP: 	PUSH 	AF
       	RRA
       	RRA
       	RRA
       	RRA
       	CALL 	HEXOP
       	POP 	AF

HEXOP: 	AND 	$0F
       	CP 	10
       	SBC 	A,$69
       	DAA

; -----------------------------------
;
; End of John Kerr's DIS-Z80 routine.
;
; The next routine outputs a character.
;
; -------------------------------------

CHROP: 	PUSH 	HL
       	PUSH 	DE
       	PUSH 	BC

	push	AF		; parameter passing
	RST	16
	pop     AF

       	POP 	BC
       	POP 	DE
       	POP 	HL

       	RET