; ======================================================================
; XANDRIAN LABS  /  CS617 CHAPTER 09
; ======================================================================
; Program    : MathROM - Test Application
; Source     : mathrom_test_app.s
; Revision   : r029a
; Target     : Casio PB-2000C / HD61700
; Role       : Display selected math probes and aggregate reports.
; Interface  : MathROM home menu, native-call fixtures and VT views.
; Maintainer : Xandrian Labs
; ----------------------------------------------------------------------
; Owns application scratch, report rendering and test menu.
; UA14 application RAM and shared viewer space must not collide.
; ======================================================================

; ----------------------------------------------------------------------
; IMPLEMENTATION NOTES
; ----------------------------------------------------------------------
; Inputs and B9 results use $10..$18; UA14 owns app scratch.
; Snapshots are saved before formatting changes registers.

MR_DOC:   EQU &H2000  ; 24x80 caller-owned page, bound to VT23
MR_A1:    EQU &H2D00
MR_E1:    EQU &H2D09
MR_R1:    EQU &H2D12
MR_F1:    EQU &H2D1B
MR_A2:    EQU &H2D30
MR_E2:    EQU &H2D39
MR_R2:    EQU &H2D42
MR_F2:    EQU &H2D4B
MR_A3:    EQU &H2D60
MR_E3:    EQU &H2D69
MR_R3:    EQU &H2D72
MR_F3:    EQU &H2D7B
MR_A4:    EQU &H2D90
MR_E4:    EQU &H2D99
MR_R4:    EQU &H2DA2
MR_F4:    EQU &H2DAB
MR_LINE:  EQU &H2DC0  ; 23 bytes for ASCII name + 18 hex digits
MR_ROW:   EQU &H2DE0
MR_ANG:   EQU &H2DE1
MR_SEL:   EQU &H2DE2  ; 0..9 function index, alphabetic
MR_PICK:  EQU &H2DE3  ; in-selector cursor only
MR_VAL:   EQU &H2DE4  ; single-byte row result if raw-exact anchor
MR_TBUF:  EQU &H2E00  ; 32-byte report staging row, no overlap with 2F20
MR_I1:    EQU &H2E20  ; separately re-run CNVR(4) for input witness, 9 bytes
MR_I2:    EQU &H2E30  ; legacy unused reservation; preserved for rollback
MR_SPLMODE:EQU &H2E40 ; 1=power-on splash, 0=warm reset bypass
MR_MARK:  EQU &H2E50 ; nine-byte renderer self-test: 12 34 56 78 9A BC DE F0 0F
; r010 owned workspace (last byte 2F15, below SYS540 2F20).
MR_ALLRAW:EQU &H2E60 ; 10 * 9-byte saved outputs = 2E60..2EB9
MR_STATUS:EQU &H2EBA ; 10 unary statuses: 0 NOT RUN, 1 PASS, 2 FAIL, 3 CHECK
MR_TEXT:  EQU &H2EC4 ; 20-byte decimal rendering buffer
MR_MANT:  EQU &H2ED8 ; 13 packed-decimal digits -> ASCII
MR_INDEX: EQU &H2EE5 ; next row/function index
MR_VROW:  EQU &H2EE6 ; current VT23 page line
MR_PAGE:  EQU &H2EE7 ; one-based sequential page number
MR_EXP:   EQU &H2EE8 ; 0=-1, 1=0, 2=+1, otherwise unsupported
MR_BOK:   EQU &H2EE9 ; 1 supported positive B9, 0 invalid/unsupported
MR_DIGP:  EQU &H2EEA ; decimal output point position after 0,1,2 digits
MR_PCHR:  EQU &H2EEB ; page number ASCII (2 bytes)
MR_ZERO:  EQU &H2EED ; one ASCII zero for 0.xxx
MR_NEXT:  EQU &H2EEE ; result of caller VT23_VIEW
MR_ALLPOS:EQU &H2EEF ; sweep position 0..10 (10 means complete)
MR_ALLMODE:EQU &H2EF0 ; 1 = report originates from [all]
MR_ALLSTOP:EQU &H2EF1 ; 0 none, 2 FAIL, 3 CHECK
MR_NEARCT:EQU  &H2EF2 ; 0..10 accepted deviations in sweep
MR_NEARSTR:EQU &H2EF3 ; two ASCII decimal digits for near count
MR_XSEL:   EQU &H2F09 ; additional native candidate index 0..10
MR_XREG0:  EQU &H2F00 ; nine-byte observed $0..$8 register image
MR_XSTATUS:EQU &H2F0A ; five separate extra-sweep statuses, 0..4
MR_XSTOP:  EQU &H2F0F ; one if failure belongs to extra cohort
MR_XFIRST: EQU &H2F10 ; first extra near case+1, zero if none
MR_XRAW:   EQU &H2D30 ; 5*9 saved extra B9 outputs, 2D30..2D5C
MR_XDONE:  EQU &H2F11 ; 0 while extras not yet run, 1 completed
MR_DETAILX:EQU &H2F12 ; Q detail uses saved extra raw instead of unary
MR_XFOCUS: EQU &H2F13 ; extra Q case even after table reindex
MR_XRET:   EQU &H2F14 ; 1 selected from unified list, 0 [more] menu
MR_ONESTAT:EQU &H2F1D ; selected single-test verdict, 1 PASS,4 PASS~,2 FAIL,3 CHECK
; r020 supplementary six-result ledger, UA=14. External report scratch
; 2B00..2B45 lies after the known 2AC0 Lab canary and below MR_A1 2D00.
; No assumptions about public ABI: this is MathROM application-private RAM.
MR_E_RAW:  EQU &H2B00 ; 8*9 result records X5..12, 2B00..2B47
MR_E_STATUS:EQU &H2B60 ; eight statuses X=5..12: 2B60..2B67
MR_XRAWA:  EQU &H2D60 ; pre-call A (5*9) for all five extra cases
MR_XRAWB:  EQU &H2D90 ; pre-call B (5*9), ends before 2DC0
        ORG &H0E80
LAB_COLD:
        PRE     SS,&H0100
        LD      $29,1          ; cold launch: show splash
        JP      LAB_SETUP
LAB_WARM:
        PRE     SS,&H0100
        LD      $29,0          ; soft reset: no repeated splash
LAB_SETUP:
        LD      $30,1
        LD      $31,0
        PSR     SZ,0
        PSR     SY,30
        PSR     SX,31
        PST     UA,&H14
        PRE     IX,MR_SPLMODE
        ST      $29,(IX+$SX)
        PRE     IX,RCS_TOP
        PRE     IY,RCS_END-1
        PRE     IZ,RCS
        PST     UA,&H44
        BUP
        PST     UA,&H14
        PRE     SS,SSPTP
        PRE     US,USPTP
        CAL     SYS_INIT
        CAL     SCREEN_INIT
        PST     UA,&H14
        PRE     IX,MR_SPLMODE
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      Z,LAB_BEGIN
        CAL     MR_SPLASH
        JP      LAB_BEGIN

; Two observed TM transitions; bounded polling fallback prevents a dead TM
; source from trapping the application forever. Not calibrated seconds.
MR_SPLASH:
        ; Common lib-set-01 renderer, zero library delay.
        ; Legacy bounded two-transition polling remains below.
        LDW     $10,MR_SPL_TEXT
        LD      $12,0
        CAL     SPL_SHOW
        AN      $0,$0
        JR      NZ,MR_SPL_BAD
        GST     TM,$8
        GST     TM,$8
        LD      $10,$8
        LD      $11,2
        JP      MR_SPL_WAIT
MR_SPL_BAD:
        RTN

MR_SPL_WAIT:
        LDW     $24,&HFFFF
MR_SPL_POLL:
        CAL     OFFCHK
        GST     TM,$8
        GST     TM,$8
        LD      $12,$8
        SBC     $12,$10
        JR      NZ,MR_SPL_NEXT
        SBW     $24,$SY
        JR      NZ,MR_SPL_POLL
        RTN                  ; bounded fallback, timer did not move
MR_SPL_NEXT:
        LD      $10,$8
        SB      $11,$SY
        JR      NZ,MR_SPL_WAIT
        RTN

LAB_BEGIN:
; Visible home first; native kernels are never called on boot.
        PST     UA,&H14
        PRE     IX,MR_SEL
        LD      $0,8          ; initial selection SQR, index 8 of 10
        ST      $0,(IX+$SX)
        CAL     MR_HOME_SCR
        CAL     KBD_INIT
; VT23 binds the report canvas; :t is handled inside the library.
; No application-owned RS232C loop, send event adapter, or VT20.
        CAL     VT23_INIT
        LDW     $10,MR_DOC
        CAL     VT23_BIND_RAM
        CAL     MR_INIT
        JP      MR_WAIT

; ----------------------------------------------------------------------
; HOME MENU
; ----------------------------------------------------------------------
MR_HOME:
        CAL     MR_HOME_SCR
        JP      MR_WAIT

; Convention: data on rows 1..3, four 8-column softkey cells on row 4.
; Do not describe function keys, MENU or BRK in content rows.
MR_HOME_SCR:
        PST     UA,&H14
        CAL     LCD_CLEAR
        LD      $6,0
        PRE     IZ,MR_H0
        CAL     LCD_ROM32
        LDW     $4,MR_NAMES
        CAL     MR_NAMEPTR
        PRE     IZ,$4
        LD      $6,&H20
        CAL     LCD_ROM32
        LD      $6,&H40
        PRE     IZ,DY_HOME_HINT
        CAL     LCD_ROM32
        LD      $6,&H60
        PRE     IZ,MR_HKEY
        CAL     LCD_ROM32
        RTN

MR_WAIT:
        CAL     KEY_WAIT
        SBC     $17,2
        JP      Z,LAB_WARM
        LD      $15,$0
        SBC     $15,KEYETC
        JP      Z,DY_MENU
        LD      $15,$0
        SBC     $15,KEYF1
        JP      Z,MR_SELECT
        LD      $15,$0
        SBC     $15,KEYF2
        JP      Z,MR_THIN
        LD      $15,$0
        SBC     $15,KEYF3
        JP      Z,MR_INFO
        LD      $15,$0
        SBC     $15,KEYF4
        JP      Z,MR_ALL
        JP      MR_WAIT

MR_INFO:
        CAL     LCD_CLEAR
        LD      $6,0
        PRE     IZ,MR_INFOTITLE
        CAL     LCD_ROM32
        LD      $6,&H20
        PRE     IZ,MR_INFOTEXT
        CAL     LCD_ROM32
        LD      $6,&H40
        PRE     IZ,MR_INFOTEXT2
        CAL     LCD_ROM32
        LD      $6,&H60
        PRE     IZ,MR_INFOKEYS
        CAL     LCD_ROM32
        CAL     KEY_WAIT
        JP      MR_HOME

MR_SELECT:
        PST     UA,&H14
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        LD      $1,0
        LDW     $4,MR_SORTREV   ; canonical ID -> alphabetical cursor
        ADW     $4,$0
        PRE     IZ,$4
        LD      $0,(IZ+$SX)
        PRE     IX,MR_PICK
        ST      $0,(IX+$SX)
MR_DRAWSEL:
        CAL     LCD_CLEAR
        LD      $6,0
        PRE     IZ,MR_SELTITLE
        CAL     LCD_ROM32
        LDW     $4,MR_NAMES
        CAL     MR_PICKPTR
        LD      $6,&H20
        PRE     IZ,$4
        CAL     LCD_ROM32
        LD      $6,&H60
        PRE     IZ,MR_SELROW
        CAL     LCD_ROM32
MR_SELWAIT:
        CAL     KEY_WAIT
        SBC     $17,2
        JP      Z,LAB_WARM
        LD      $15,$0
        SBC     $15,KEYMENU
        JP      Z,MR_HOME
        LD      $15,$0
        SBC     $15,KEYF3
        JP      Z,MR_SELOK
        LD      $15,$0
        SBC     $15,KEYF1
        JP      Z,MR_SELPREV
        LD      $15,$0
        SBC     $15,KEYF2
        JP      Z,MR_SELNEXT
        JP      MR_SELWAIT
MR_SELPREV:
        PRE     IX,MR_PICK
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_SELPDEC
        LD      $0,23
MR_SELPDEC:
        SB      $0,$SY
        ST      $0,(IX+$SX)
        JP      MR_DRAWSEL
MR_SELNEXT:
        PRE     IX,MR_PICK
        LD      $0,(IX+$SX)
        AD      $0,$SY
        SBC     $0,23            ; compare-only; 23 catalogued entries
        JR      NZ,MR_SELNSTORE
        LD      $0,0             ; wrap 20 -> 0
MR_SELNSTORE:
        ST      $0,(IX+$SX)
        JP      MR_DRAWSEL
MR_SELOK:
        CAL     MR_SORTGET      ; commit canonical engine ID, not list rank
        PRE     IX,MR_SEL
        ST      $0,(IX+$SX)
        JP      MR_HOME

; Given $4 = ROM base of 32-byte strings, index selected $0..9.
; Uses only 16-bit addition and well-tested IX RAM reads.
MR_NAMEPTR:
        PRE     IX,MR_SEL
        LD      $20,(IX+$SX)
        JR      MR_OFFSET32
MR_PICKPTR:
        CAL     MR_SORTGET
        LD      $20,$0
        LDW     $4,MR_NAMES    ; r017a: SORTGET clobbers name-table base
        JP      MR_OFFSET32
MR_SORTGET:
        PRE     IX,MR_PICK
        LD      $0,(IX+$SX)
        LD      $1,0
        LDW     $4,MR_SORTFWD    ; alphabetical rank -> canonical ID
        ADW     $4,$0
        PRE     IZ,$4
        LD      $0,(IZ+$SX)
        RTN
MR_OFFSET32:
        AN      $20,$20
        JR      Z,MR_OFFDONE
MR_OFFLOOP:
        LDW     $0,32
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_OFFLOOP
MR_OFFDONE:
        RTN

; One native invocation for one function on FK2. Never on startup.
MR_THIN:
        PST     UA,&H14
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        SBC     $0,23         ; all 23 resident candidates use selected path
        JP      NC,MR_UNSAFE
        SBC     $0,10         ; original ten unary services
        JP      C,MR_THIN_UNARY
        SB      $0,10         ; unified indexes 10..18 map to X 0..8
        PRE     IX,MR_XSEL
        ST      $0,(IX+$SX)
        PRE     IX,MR_XRET
        LD      $0,1          ; after report, return to home/selection
        ST      $0,(IX+$SX)
        JP      MR_XRUN
MR_UNSAFE:
        PST     UA,&H14
        CAL     VT23_CLEAR
        PRE     IX,MR_PAGE
        LD      $0,1
        ST      $0,(IX+$SX)
        CAL     MR_PAGE_HEADER
        LDW     $4,MR_NAMES
        CAL     MR_NAMEPTR
        LD      $9,1
        LD      $13,32
        PRE     IX,MR_VROW
        LD      $0,4
        ST      $0,(IX+$SX)
        CAL     MR_PUT_ROM
        PRE     IX,MR_VROW
        LD      $0,6
        ST      $0,(IX+$SX)
        LDW     $4,MR_UNSAFE_MSG
        LD      $9,1
        LD      $13,64
        CAL     MR_PUT_ROM
        CAL     VT23_VIEW
        JP      MR_HOME
; ----------------------------------------------------------------------
; NATIVE CALL AND REPORT
; ----------------------------------------------------------------------
MR_THIN_UNARY:
        PRE     IX,MR_ALLMODE
        LD      $0,0
        ST      $0,(IX+$SX)   ; no sweep banner on single-case probe
        PRE     IX,MR_DETAILX
        ST      $0,(IX+$SX)   ; Q belongs to selected unary
        CAL     LCD_CLEAR
        LD      $6,0
        PRE     IZ,MR_EXMSG
        CAL     LCD_ROM32
        CAL     MR_RUN_ONE
        CAL     MR_KEEP_ONE
        CAL     MR_REPORT_MAIN
MR_VIEW_RESULT:
        PRE     IX,MR_NEXT
        ST      $0,(IX+$SX)
        SBC     $0,2
        JP      Z,LAB_WARM
        PRE     IX,MR_NEXT
        LD      $0,(IX+$SX)
        SBC     $0,1
        JP      Z,MR_HOME
; Q advances to the separate B9 evidence page.
        CAL     MR_RPT_DETAIL
        CAL     VT23_VIEW
        SBC     $0,2
        JP      Z,LAB_WARM
        JP      MR_HOME

; [all] is a STOP-ON-FIRST-RETURNED-ERROR SMOKE SWEEP, not a
; blanket machine-ABI or hardware certification. It cannot recover from
; a native routine that never returns; a physical/emulator BRK may be needed.
; Run previously witnessed SQR first and provisional 0.5 fixture last.
; Each returned result is saved and compared BEFORE the next native call.
; ----------------------------------------------------------------------
; NATIVE SWEEP
; ----------------------------------------------------------------------
MR_ALL:
        PST     UA,&H14
        CAL     MR_INIT       ; fresh two-ledger 15-row statuses: NOT RUN
        PRE     IX,MR_ALLPOS
        LD      $0,0
        STI     $0,(IX+$SX)  ; POS = 0
        LD      $0,1
        STI     $0,(IX+$SX)  ; MODE = 1
        LD      $0,0
        STI     $0,(IX+$SX) ; STOP = 0; advance to NEARCT
        ST      $0,(IX+$SX)  ; NEARCT = 0
        PRE     IX,MR_XSTOP
        ST      $0,(IX+$SX)
        PRE     IX,MR_XFIRST
        ST      $0,(IX+$SX)
        PRE     IX,MR_XDONE
        ST      $0,(IX+$SX)
        PRE     IX,MR_DETAILX
        ST      $0,(IX+$SX)
        PRE     IX,MR_XFOCUS
        ST      $0,(IX+$SX)
MR_ALL_LOOP:
        PRE     IX,MR_ALLPOS
        LD      $0,(IX+$SX)
        LD      $1,0
        LDW     $4,MR_ALL_ORDER
        ADW     $4,$0
        PRE     IZ,$4
        LD      $0,(IZ+$SX)
        PRE     IX,MR_SEL
        ST      $0,(IX+$SX)
        CAL     MR_RUN_ONE
        CAL     MR_KEEP_ONE
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        PRE     IX,MR_INDEX
        ST      $0,(IX+$SX)
        CAL     MR_RAWPTR
        CAL     MR_B9_DEC
        CAL     MR_B9_COMPARE
        LD      $29,$0
        CAL     MR_STATPTR
        PRE     IX,$4
        ST      $29,(IX+$SX)
        SBC     $29,4         ; PASS~ continues but is counted
        JP      Z,MR_ALL_NEAR
        SBC     $29,1         ; exact-13 PASS continues
        JP      NZ,MR_ALL_STOPNOW
        JP      MR_ALL_ADV
MR_ALL_NEAR:
        PRE     IX,MR_NEARCT
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
MR_ALL_ADV:
        PRE     IX,MR_ALLPOS
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        SBC     $0,10
        JP      NZ,MR_ALL_LOOP
        JP      MR_ALL_EXTRA
; Phase II: five owner-reported positive r014 experiments; independently
; preserve output, classify against five predeclared host oracle envelopes.
; This is a smoke expansion, NOT complete native ABI qualification.
MR_ALL_EXTRA:
        PRE     IX,MR_XSEL
        LD      $0,0
        ST      $0,(IX+$SX)
MR_AX_LOOP:
        ; r021: thirteen extra fixtures; CMP flag-as-B9 witness and POWER B9.
        ; Original C/BASIC code is NOT included or linked.
        CAL     MR_XCAL
        LDW     $8,MR_A1
        CAL     MR_SAVE9      ; preserve output BEFORE any reporting work
        CAL     MR_XRAWPTR   ; X 0..4 legacy ledger, X 5..12 app-owned
        LDW     $10,MR_A1
        CAL     MR_XCOPY9
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        SBC     $0,5
        JP      NC,MR_AX_NOINPUT
        ; Only legacy first five have reserved pre-call A/B raw snapshots.
        CAL     MR_XPTR_A
        LDW     $10,MR_I1
        CAL     MR_XCOPY9
        CAL     MR_XPTR_B
        LDW     $10,MR_I2
        CAL     MR_XCOPY9
MR_AX_NOINPUT:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        AD      $0,10
        PRE     IX,MR_SEL
        ST      $0,(IX+$SX)
        ; Same type-aware fixture judge used for [select]->[run].
        ; CNVR is B9 +2; B2BCD is packed decimal, never B9.
        CAL     MR_XJUDGE
        PRE     IX,MR_ONESTAT
        LD      $29,(IX+$SX)
        CAL     MR_XSTATPTR
        PRE     IX,$4
        ST      $29,(IX+$SX)
        SBC     $29,4
        JR      Z,MR_AX_NEAR
        SBC     $29,1
        JP      NZ,MR_AX_STOP
        JR      MR_AX_NEXT
MR_AX_NEAR:
        PRE     IX,MR_NEARCT
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        PRE     IX,MR_XFIRST
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_AX_NEXT
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        AD      $0,$SY
        PRE     IX,MR_XFIRST
        ST      $0,(IX+$SX)
MR_AX_NEXT:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        SBC     $0,13
        JP      NZ,MR_AX_LOOP
        PRE     IX,MR_XDONE
        LD      $0,1
        ST      $0,(IX+$SX)
        JP      MR_ALL_SHOW
MR_AX_STOP:
        PRE     IX,MR_ALLSTOP
        ST      $29,(IX+$SX)
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        PRE     IX,MR_XFOCUS
        ST      $0,(IX+$SX)
        PRE     IX,MR_DETAILX
        LD      $0,1
        ST      $0,(IX+$SX)
        PRE     IX,MR_XSTOP
        LD      $0,1
        ST      $0,(IX+$SX)
        JP      MR_ALL_SHOW
MR_ALL_STOPNOW:
        PRE     IX,MR_ALLSTOP
        ST      $29,(IX+$SX)
MR_ALL_SHOW:
        PRE     IX,MR_ALLSTOP
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_ALL_REPORT ; on FAIL/CHECK Q opens offender
        CAL     MR_ALL_FINDNEAR  ; on success Q opens first deviation
MR_ALL_REPORT:
        CAL     MR_REPORT_MAIN
        JP      MR_VIEW_RESULT

; First alphabetical PASS~ becomes the Q diagnostic focus.
; If no deviations exist, leave the last selected case unchanged.
MR_ALL_FINDNEAR:
        PRE     IX,MR_STATUS
        LD      $20,0
MR_FINDLOOP:
        LDI     $0,(IX+$SX)
        SBC     $0,4
        JR      Z,MR_FOUNDDV
        AD      $20,$SY
        LD      $0,$20
        SBC     $0,10
        JR      NZ,MR_FINDLOOP
        PRE     IX,MR_XFIRST
        LD      $0,(IX+$SX)
        AN      $0,$0
        RTN     Z
        SB      $0,$SY
        PRE     IX,MR_XFOCUS
        ST      $0,(IX+$SX)
        PRE     IX,MR_DETAILX
        LD      $0,1
        ST      $0,(IX+$SX)
        RTN
MR_FOUNDDV:
        PRE     IX,MR_SEL
        ST      $20,(IX+$SX)
        RTN

MR_THICK:
        CAL     LCD_CLEAR
        LD      $6,0
        PRE     IZ,MR_TK0
        CAL     LCD_ROM32
        LD      $6,&H20
        PRE     IZ,MR_TK1
        CAL     LCD_ROM32
        LD      $6,&H60
        PRE     IZ,MR_HKEY
        CAL     LCD_ROM32
        JP      MR_WAIT

; Clear prior result bytes to EE: no uninitialized RAM rendered as results.
; r010 ledger statuses 0=NOT RUN, 1=PASS, 2=FAIL, 3=CHECK.
; ---------------------------------------------------------------------
; r015 EXTRA CANDIDATES (not r013 accepted unary sweep).
; Original interpreter's math entry points: all remain ABI hypotheses.
; No auto-run: five calls are individually selected, single-invocation.
; Screen always shows BOTH native FP register banks and input operands.
; Original C/BASIC sources attribute SQ 06B5, PI 0A77, FIX 0A82,
; ADD 068C, MUL 06B9. Binary inputs: $10..$18 (A), $0..$8 (B).
; ---------------------------------------------------------------------
MR_XENTER:
        PST     UA,&H14
        PRE     IX,MR_XRET
        LD      $0,0
        ST      $0,(IX+$SX)
        PRE     IX,MR_XSEL
        LD      $0,0
        ST      $0,(IX+$SX)
MR_XDRAW:
        PST     UA,&H14
        CAL     LCD_CLEAR
        LD      $6,0
        PRE     IZ,MR_XTITLE
        CAL     LCD_ROM32
        LDW     $4,MR_XNAMES
        CAL     MR_XNAMEPTR
        PRE     IZ,$4
        LD      $6,&H20
        CAL     LCD_ROM32
        LD      $6,&H60
        PRE     IZ,MR_XKEYS
        CAL     LCD_ROM32
MR_XWAIT:
        CAL     KEY_WAIT
        SBC     $17,2
        JP      Z,LAB_WARM
        LD      $15,$0
        SBC     $15,KEYMENU
        JP      Z,MR_HOME
        LD      $15,$0
        SBC     $15,KEYF4
        JP      Z,MR_HOME
        LD      $15,$0
        SBC     $15,KEYF1
        JP      Z,MR_XPREV
        LD      $15,$0
        SBC     $15,KEYF2
        JP      Z,MR_XNEXT
        LD      $15,$0
        SBC     $15,KEYF3
        JP      Z,MR_XRUN
        JP      MR_XWAIT
MR_XPREV:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_XDEC
        LD      $0,13
MR_XDEC:
        SB      $0,$SY
        ST      $0,(IX+$SX)
        JP      MR_XDRAW
MR_XNEXT:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        AD      $0,$SY
        SBC     $0,13      ; compare, NOT subtract
        JR      NZ,MR_XSTORE
        LD      $0,0
MR_XSTORE:
        ST      $0,(IX+$SX)
        JP      MR_XDRAW
MR_XNAMEPTR:
        PRE     IX,MR_XSEL
        LD      $20,(IX+$SX)
        JP      MR_OFFSET32

; Capture a literal pre-call B9 operand without altering $10..$18.
; Only $0/$8 scratch altered; no arithmetic call follows until restored
; in the binary path.
MR_XSAVEA:
        LDW     $8,MR_I1
        CAL     MR_SAVE9
        RTN
MR_XSAVE_B:
        PST     UA,&H14
        PRE     IX,MR_I2
        STM     $10,(IX+$SX),8
        PRE     IX,MR_I2+8
        ST      $18,(IX+$SX)
        RTN
MR_XZEROIN:
        PRE     IX,MR_I1
        LD      $0,0
        LD      $20,9
MR_XZLOOP:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_XZLOOP
        RTN

; Load two already-observed CNVR operands from independent RAM snapshots.
; Binary caller evidence: $10..$18 numerator/A, $0..$8 operand B.
MR_XLOAD_B:
        PST     UA,&H14
        PRE     IX,MR_I2
        LDM     $0,(IX+$SX),8
        PRE     IX,MR_I2+8
        LD      $8,(IX+$SX)
        PRE     IX,MR_I1
        LDM     $10,(IX+$SX),8
        PRE     IX,MR_I1+8
        LD      $18,(IX+$SX)
        RTN

; Same selected function engine serves all individual source-backed probes.
MR_XRUN:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        AD      $0,10
        PRE     IX,MR_SEL
        ST      $0,(IX+$SX)  ; [more] shares the unified selection
        CAL     MR_XCAL
        JP      MR_XCAP
MR_XCAL:
        PST     UA,&H14
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        SBC     $0,0
        JP      Z,MR_XSQ
        SBC     $0,1
        JP      Z,MR_XPI
        SBC     $0,2
        JP      Z,MR_XFIX
        SBC     $0,3
        JP      Z,MR_XADD
        SBC     $0,4
        JP      Z,MR_XMUL
        SBC     $0,5
        JP      Z,MR_XSUB
        SBC     $0,6
        JP      Z,MR_XROUND
        SBC     $0,7
        JP      Z,MR_XINC
        SBC     $0,8
        JP      Z,MR_XDIV
        SBC     $0,9
        JP      Z,MR_XCNVR
        SBC     $0,10
        JP      Z,MR_XBCD
        SBC     $0,11
        JP      Z,MR_XCMP
        JP      MR_XPOWER
MR_XSQ:
        LDW     $15,7
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        CAL     MR_XZERO_B
        CAL     MATH_SQ  ; square of B9 7, candidate $10..$18
        RTN
MR_XPI:
        CAL     MR_XZEROIN
        CAL     MR_XZERO_B
        CAL     MATH_PI  ; zero-argument PI constant loader, bank TBD
        RTN
MR_XFIX:
        LDW     $15,7
        CAL     MATH_CNVR
        LD      $15,&H50 ; B9 7.5 second significant digit in next BCD byte
        LD      $16,&H07 ; first significant digit in low nibble (CNVR(7))
        CAL     MR_XSAVEA
        CAL     MR_XZERO_B
        CAL     MATH_FIX  ; native FIX, flags/error contract unqualified
        RTN
MR_XADD:
        LDW     $15,1
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        LDW     $15,2
        CAL     MATH_CNVR
        CAL     MR_XSAVE_B
        CAL     MR_XLOAD_B
        CAL     MATH_ADD  ; candidate ADD: B9(1) + B9(2)
        RTN
MR_XMUL:
        LDW     $15,6
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        LDW     $15,7
        CAL     MATH_CNVR
        CAL     MR_XSAVE_B
        CAL     MR_XLOAD_B
        CAL     MATH_MUL  ; candidate MUL: B9(6) * B9(7)
        RTN
; Not added to [all] yet: SUB operand convention, rounding side effects
; and exact exception behavior are still individual owner experiments.
MR_XSUB:
        LDW     $15,5
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        LDW     $15,2
        CAL     MATH_CNVR
        CAL     MR_XSAVE_B
        CAL     MR_XLOAD_B
        CAL     MATH_SUB       ; subtraction ABI hypothesis; 5-2 ->3
        RTN
MR_XROUND:
        LDW     $15,7
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        CAL     MR_XZERO_B
        CAL     MATH_RND12       ; 12-digit mantissa round; 7 -> 7
        RTN
; Caller-attributed low-ROM experiments, manually gated until witnessed.
; 068A: BASIC/C ROM callers annotate +1 on expanded $10..$18 B9.
; 06F8: ordinary BASIC/C divide operator A/B; 06F6 is a DIFFERENT
; source-witnessed call path and remains unresolved, never conflated.
MR_XINC:
        LDW     $15,7
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        CAL     MR_XZERO_B
        CAL     MATH_INC       ; B9(7)+1 ->8 candidate
        RTN
MR_XDIV:
        LDW     $15,8
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        LDW     $15,2
        CAL     MATH_CNVR
        CAL     MR_XSAVE_B
        CAL     MR_XLOAD_B
        CAL     MATH_DIV       ; ordinary DIV candidate B9(8)/B9(2) ->4
        RTN
; The next two candidates are independently attributed ROM0 services.
; CNVR is already exercised as fixture staging; here it is the subject.
; B2BCD takes a 16-bit integer in $3/$4 and emits packed BCD $14..$16,
; *not* a B9 floating point value. Do not interpret BCD as numeric B9.
MR_XCNVR:
        LDW     $15,123
        CAL     MATH_CNVR       ; signed 16-bit integer -> expanded B9
        CAL     MR_XSAVEA   ; output is also a deliberate witness fixture
        CAL     MR_XZERO_B
        RTN
MR_XBCD:
        CAL     MR_XZEROIN
        CAL     MR_XZERO_B
        LDW     $3,123
        PRE     IX,MR_I1   ; packed input witness, *not* B9
        ST      $3,(IX+$SX)
        PRE     IX,MR_I1+1
        ST      $4,(IX+$SX)
        CAL     MATH_B2BCD       ; 16-bit binary -> BCD $14..$16
        RTN
; Resident CMP caller evidence: BASIC 1D08/7AAE, C EBCB/EC10.
; Inputs: $10..$18 = B9(2), $0..$8 = B9(3). Carry indicates LT.
; This adapter converts flag into B9(1) or B9(0) for common fixture
; display. That converted result is NOT a raw native floating result.
MR_XCMP:
        LDW     $15,2
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        LDW     $15,3
        CAL     MATH_CNVR
        CAL     MR_XSAVE_B
        CAL     MR_XLOAD_B
        CAL     MATH_CMP       ; resident compare, inspect C immediately
        JR      C,MR_XCMP_LT
        LDW     $15,0       ; false, CMP(2,3) should be less-than
        CAL     MATH_CNVR
        RTN
MR_XCMP_LT:
        LDW     $15,1       ; true flag encoded into B9 for oracle
        CAL     MATH_CNVR
        RTN
; Resident POWER: BASIC operator ^ at 1D7D JP 09E0, C adapter
; at 71CA CAL 09E0. The C adapter is NOT linked or invoked.
MR_XPOWER:
        LDW     $15,2
        CAL     MATH_CNVR
        CAL     MR_XSAVEA
        LDW     $15,3
        CAL     MATH_CNVR
        CAL     MR_XSAVE_B
        CAL     MR_XLOAD_B
        CAL     MATH_POWER       ; native 2^3 -> B9(8), no C card
        RTN
MR_XZERO_B:
        PST     UA,&H14
        PRE     IX,MR_I2
        LD      $0,0
        LD      $20,9
MR_XZBLOOP:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_XZBLOOP
        RTN

; Capture both register blocks IMMEDIATELY following the native CAL.
; Do not infer return ownership until owner emulator evidence.
MR_XCAP:
        PST     UA,&H14
        PRE     IX,MR_XREG0
        STM     $0,(IX+$SX),8
        PRE     IX,MR_XREG0+8
        ST      $8,(IX+$SX)
        LDW     $8,MR_A1
        CAL     MR_SAVE9
        CAL     MR_XJUDGE
        CAL     MR_XREPORT
        CAL     VT23_VIEW
        SBC     $0,2
        JP      Z,LAB_WARM
        PRE     IX,MR_XRET
        LD      $0,(IX+$SX)
        AN      $0,$0
        JP      NZ,MR_HOME  ; unified [select] -> [thin] invocation
        JP      MR_XDRAW   ; individual [more] continues extra menu

; Cautious human+raw page: NO PASS or ABI qualified verdict without
; owner observations. One experiment per page / test, no blind sweep.
; The extra-sweep ledger uses dedicated safe app-owned RAM.
; Five entries at MR_XRAW, five statuses at MR_XSTATUS.
MR_XRAWPTR:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        SBC     $0,5
        JP      C,MR_XR_LEGACY
        LD      $20,$0
        SB      $20,5
        LDW     $4,MR_E_RAW
        AN      $20,$20
        JR      Z,MR_XR_DONE
MR_XR_ELOOP:
        LDW     $0,9
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_XR_ELOOP
        RTN
MR_XR_LEGACY:
        LDW     $4,MR_XRAW
        JP      MR_XBASEPTR
MR_XPTR_A:
        LDW     $4,MR_XRAWA
        JP      MR_XBASEPTR
MR_XPTR_B:
        LDW     $4,MR_XRAWB
MR_XBASEPTR:
        PRE     IX,MR_XSEL
        LD      $20,(IX+$SX)
        AN      $20,$20
        JR      Z,MR_XR_DONE
MR_XR_LOOP:
        LDW     $0,9
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_XR_LOOP
MR_XR_DONE:
        RTN
; $4 destination, $10 source; both 9-byte RAM records in bank one.
MR_XCOPY9:
        PRE     IX,$4
        PRE     IZ,$10
        PST     UA,&H54
        LD      $20,9
MR_XCP_LOOP:
        LDI     $0,(IZ+$SX)
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_XCP_LOOP
        PST     UA,&H14
        RTN
MR_XSTATPTR:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        SBC     $0,5
        JR      C,MR_XS_LEGACY
        SB      $0,5
        LDW     $4,MR_E_STATUS
        JR      MR_XS_ADD
MR_XS_LEGACY:
        LDW     $4,MR_XSTATUS
MR_XS_ADD:
        LD      $1,0
        ADW     $4,$0
        RTN

; Shared fixture judge: extra 0..9 are bounded positive B9 numerics.
; CNVR(123) uses the newly admitted B9 +2 exponent fixture;
; B2BCD(123) is *packed BCD*, never feed it to the B9 comparator.
; No routine can claim PASS merely from showing its expected value label.
; Return declared result type from a single canonical-ID type registry.
; Selected function engine keeps MR_SEL in the original canonical domain.
MR_KINDGET:
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        LD      $1,0
        LDW     $4,MR_REGKIND
        ADW     $4,$0
        PRE     IZ,$4
        LD      $0,(IZ+$SX)
        RTN
MR_XJUDGE:
        PST     UA,&H14
        CAL     MR_KINDGET
        SBC     $0,1
        JR      Z,MR_XJUDGE_B9
        SBC     $0,2
        JR      Z,MR_XJUDGE_BCD
        SBC     $0,3
        JR      Z,MR_XJUDGE_B9  ; CMP adapter flag encoded B9
        JR      MR_XJCHECK
MR_XJUDGE_BCD:
        CAL     MR_BCD123
        JR      MR_XJSAVE
MR_XJUDGE_B9:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        SBC     $0,13        ; X 0..12, except BCD(10), have B9 fixture outputs
        JR      NC,MR_XJCHECK
        AD      $0,10
        PRE     IX,MR_INDEX
        ST      $0,(IX+$SX)
        LDW     $4,MR_A1
        CAL     MR_B9_DEC
        CAL     MR_B9_COMPARE
        JR      MR_XJSAVE
MR_XJCHECK:
        LD      $0,3
MR_XJSAVE:
        PRE     IX,MR_ONESTAT
        ST      $0,(IX+$SX)
        RTN

; Candidate packed-BCD fixture: binary 123 -> $14..$16 = 23,01,00
; (least significant packed digits first). Source ROM's 'binary to BCD'
; designation and owner's earlier B9-misdecode are consistent with this.
; This is ONE EXACT-FIXTURE smoke match, NOT a general BCD ABI proof.
; A mismatch stays CHECK, not FAIL, until the caller/byte-order audit.
; $14,$15,$16 are captured in MR_A1 offsets 4,5,6 before rendering.
MR_BCD123:
        LDW     $10,MR_A1+4
        CAL     MR_B9_READ
        SBC     $0,&H23
        JR      NZ,MR_BCD_UNCERT
        LDW     $10,MR_A1+5
        CAL     MR_B9_READ
        SBC     $0,&H01
        JR      NZ,MR_BCD_UNCERT
        LDW     $10,MR_A1+6
        CAL     MR_B9_READ
        AN      $0,$0
        JR      NZ,MR_BCD_UNCERT
        LD      $0,1
        RTN
MR_BCD_UNCERT:
        LD      $0,3
        RTN

MR_XREPORT:
        PST     UA,&H14
        CAL     MR_MARK_INIT
        CAL     VT23_CLEAR
        PRE     IX,MR_PAGE
        LD      $0,1
        ST      $0,(IX+$SX)
        CAL     MR_PAGE_HEADER
        PRE     IX,MR_VROW
        LD      $0,3
        ST      $0,(IX+$SX)
        LDW     $4,MR_XBRIEF
        LD      $9,1
        LD      $13,61
        CAL     MR_PUT_ROM
        LDW     $4,MR_XNAMES
        CAL     MR_XNAMEPTR
        PRE     IX,MR_VROW
        LD      $0,4
        ST      $0,(IX+$SX)
        LD      $9,1
        LD      $13,32
        CAL     MR_PUT_ROM
        LD      $8,5
        LDW     $10,MR_MARK
        LDW     $14,MR_LMARK
        CAL     MR_RAW_ROW
        LD      $8,6
        LDW     $10,MR_I1
        LDW     $14,MR_XINA
        CAL     MR_RAW_ROW
        LD      $8,7
        LDW     $10,MR_I2
        LDW     $14,MR_XINB
        CAL     MR_RAW_ROW
        LD      $8,8
        LDW     $10,MR_A1
        LDW     $14,MR_XOUTA
        CAL     MR_RAW_ROW
        LD      $8,9
        LDW     $10,MR_XREG0
        LDW     $14,MR_XOUTB
        CAL     MR_RAW_ROW
        CAL     MR_KINDGET
        SBC     $0,2
        JR      Z,MR_XBCDTEXT
        LDW     $4,MR_A1
        CAL     MR_B9_DEC
        JR      MR_XDECOK
MR_XBCDTEXT:
        PRE     IX,MR_TEXT
        PRE     IZ,MR_BCDTEXT
        LD      $20,18
MR_BCD_COPY:
        LDI     $0,(IZ+$SX)
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_BCD_COPY
MR_XDECOK:
        PRE     IX,MR_VROW
        LD      $0,11
        ST      $0,(IX+$SX)
        CAL     MR_KINDGET
        SBC     $0,2
        JR      Z,MR_X_BCDLABEL
        LDW     $4,MR_XDLABEL
        JR      MR_X_LABELOK
MR_X_BCDLABEL:
        LDW     $4,MR_BCDLABEL
MR_X_LABELOK:
        LD      $9,1
        LD      $13,12
        CAL     MR_PUT_ROM
        LDW     $4,MR_TEXT
        LD      $9,13
        LD      $13,18
        CAL     MR_PUT_RAM
        LDW     $4,MR_XORACLE
        CAL     MR_XNAMEPTR
        PRE     IX,MR_VROW
        LD      $0,12
        ST      $0,(IX+$SX)
        LD      $9,1
        LD      $13,32
        CAL     MR_PUT_ROM
        PRE     IX,MR_VROW
        LD      $0,13
        ST      $0,(IX+$SX)
        LDW     $4,MR_RESULTLABEL
        LD      $9,1
        LD      $13,14
        CAL     MR_PUT_ROM
        PRE     IX,MR_ONESTAT
        LD      $0,(IX+$SX)
        SBC     $0,1
        JR      Z,MR_XP_PASS
        SBC     $0,4
        JR      Z,MR_XP_NEAR
        SBC     $0,2
        JR      Z,MR_XP_FAIL
        LDW     $4,MR_CHECK_TXT
        JR      MR_XP_DRAW
MR_XP_PASS:
        LDW     $4,MR_PASS_TXT
        JR      MR_XP_DRAW
MR_XP_NEAR:
        LDW     $4,MR_NEAR_TXT
        JR      MR_XP_DRAW
MR_XP_FAIL:
        LDW     $4,MR_FAIL_TXT
MR_XP_DRAW:
        LD      $9,16
        LD      $13,8
        CAL     MR_PUT_ROM
        PRE     IX,MR_VROW
        LD      $0,14
        ST      $0,(IX+$SX)
        LDW     $4,MR_XCAUTION
        LD      $9,1
        LD      $13,67
        CAL     MR_PUT_ROM
        RTN

MR_INIT:
        PST     UA,&H14
        PRE     IX,MR_A1
        LD      $5,&HB4        ; 2D00..2DB3 (includes every raw result)
        LD      $0,&HEE
MR_ILP:
        STI     $0,(IX+$SX)
        SB      $5,$SY
        JR      NZ,MR_ILP
        LD      $0,2
        PRE     IX,MR_F1
        STI     $0,(IX+$SX)
        STI     $0,(IX+$SX)
        PRE     IX,MR_F2
        STI     $0,(IX+$SX)
        STI     $0,(IX+$SX)
        PRE     IX,MR_F3
        STI     $0,(IX+$SX)
        STI     $0,(IX+$SX)
        PRE     IX,MR_F4
        STI     $0,(IX+$SX)
        STI     $0,(IX+$SX)
; r010 ledger: no not-run entry may be mistaken for a prior PASS.
        PRE     IX,MR_STATUS
        LD      $20,10
        LD      $0,0
MR_INIT_STAT:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_INIT_STAT
        PRE     IX,MR_XSTATUS
        LD      $20,5
MR_INIT_XSTAT:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_INIT_XSTAT
        PRE     IX,MR_E_STATUS
        LD      $20,8
        LD      $0,0
MR_INIT_ESTAT:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_INIT_ESTAT
        PRE     IX,MR_E_RAW
        LD      $20,72
        LD      $0,&HEE
MR_INIT_ERAW:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_INIT_ERAW
        RTN

; Nine-byte snapshot, proven bank-1 write path retained from r008.
; Saved immediately following the native CAL without formatting.
MR_SAVE9:
        PST     UA,&H14
        PRE     IX,$8
        STM     $10,(IX+$SX),8
        LDW     $0,8
        ADW     $8,$0
        PRE     IX,$8
        ST      $18,(IX+$SX)
        RTN

; Nontrivial independent input (0.5) for both inverse-trig functions.
; B9 inferred from documented 13-digit decimal/BCD exponent 99 convention.
; Treat as an experimental fixture, not an independently runtime-qualified input.
MR_HALF:
        LD      $10,0
        LD      $11,0
        LD      $12,0
        LD      $13,0
        LD      $14,0
        LD      $15,0
        LD      $16,&H05
        LD      $17,&H99
        LD      $18,0
        RTN

; Return exactly one prepared input in $10..$18.
MR_LOAD_ONE:
        PST     UA,&H14
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        LD      $1,$0
        AN      $1,$1
        JR      Z,MR_HALF
        SBC     $1,1
        JR      Z,MR_HALF
        LD      $1,$0
        SBC     $1,2
        JP      Z,MR_LOAD_ATN
        LD      $1,$0
        SBC     $1,3
        JP      Z,MR_LOAD_COS
        LD      $1,$0
        SBC     $1,4
        JP      Z,MR_LOAD_EXP
        LD      $1,$0
        SBC     $1,5
        JP      Z,MR_LOAD_LGT
        LD      $1,$0
        SBC     $1,6
        JP      Z,MR_LOAD_LOG
        LD      $1,$0
        SBC     $1,7
        JP      Z,MR_LOAD_SIN
        LD      $1,$0
        SBC     $1,8
        JP      Z,MR_LOAD_SQR
        LD      $1,$0
        SBC     $1,9
        JP      Z,MR_LOAD_TAN
        RTN
MR_LOAD_ATN:
        LDW     $15,2
        CAL     MATH_CNVR
        RTN
MR_LOAD_COS:
        LDW     $15,60
        CAL     MATH_CNVR
        RTN
MR_LOAD_EXP:
        LDW     $15,1
        CAL     MATH_CNVR
        RTN
MR_LOAD_LGT:
        LDW     $15,2
        CAL     MATH_CNVR
        RTN
MR_LOAD_LOG:
        LDW     $15,2
        CAL     MATH_CNVR
        RTN
MR_LOAD_SIN:
        LDW     $15,30
        CAL     MATH_CNVR
        RTN
MR_LOAD_SQR:
        LDW     $15,7
        CAL     MATH_CNVR
        RTN
MR_LOAD_TAN:
        LDW     $15,30
        CAL     MATH_CNVR
        RTN

; Preserve original degree-mode byte and restore following the probe.
MR_RUN_ONE:
        PST     UA,&H14
        PRE     IX,&H0A03
        LD      $0,(IX+$SX)
        PRE     IX,MR_ANG
        ST      $0,(IX+$SX)
        PRE     IX,&H0A03
        LD      $0,0
        ST      $0,(IX+$SX)
        CAL     MR_LOAD_ONE
        CAL     MR_CALL_ONE
        LDW     $8,MR_A1
        CAL     MR_SAVE9
; Deliberately reconstruct input AFTER result saved: not a register freeze.
        CAL     MR_LOAD_ONE
        LDW     $8,MR_I1
        CAL     MR_SAVE9
        PRE     IX,MR_ANG
        LD      $0,(IX+$SX)
        PRE     IX,&H0A03
        ST      $0,(IX+$SX)
        PST     UA,&H14
        RTN

; Dispatch examines selector using $0/$1 immediately before call.
; This is a provisional experimental ABI: flags/$0/$1 clobbers unqualified.
MR_CALL_ONE:
        PST     UA,&H14
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        LD      $1,$0
        SBC     $1,0
        JP      Z,MR_DO_ACS
        LD      $1,$0
        SBC     $1,1
        JP      Z,MR_DO_ASN
        LD      $1,$0
        SBC     $1,2
        JP      Z,MR_DO_ATN
        LD      $1,$0
        SBC     $1,3
        JP      Z,MR_DO_COS
        LD      $1,$0
        SBC     $1,4
        JP      Z,MR_DO_EXP
        LD      $1,$0
        SBC     $1,5
        JP      Z,MR_DO_LGT
        LD      $1,$0
        SBC     $1,6
        JP      Z,MR_DO_LOG
        LD      $1,$0
        SBC     $1,7
        JP      Z,MR_DO_SIN
        LD      $1,$0
        SBC     $1,8
        JP      Z,MR_DO_SQR
        LD      $1,$0
        SBC     $1,9
        JP      Z,MR_DO_TAN
        RTN
MR_DO_ACS:
        CAL     MATH_ACS
        RTN
MR_DO_ASN:
        CAL     MATH_ASN
        RTN
MR_DO_ATN:
        CAL     MATH_ATN
        RTN
MR_DO_COS:
        CAL     MATH_COS
        RTN
MR_DO_EXP:
        CAL     MATH_EXP
        RTN
MR_DO_LGT:
        CAL     MATH_LGT
        RTN
MR_DO_LOG:
        CAL     MATH_LOG
        RTN
MR_DO_SIN:
        CAL     MATH_SIN
        RTN
MR_DO_SQR:
        CAL     MATH_SQR
        RTN
MR_DO_TAN:
        CAL     MATH_TAN
        RTN

; r007: intentionally no floating-number interpretation on VT20.
; Every visible value is exactly nine observed B9 bytes rendered as hex.
; MARK is nine KNOWN RAM bytes to qualify the renderer and bank access first.
; CNVR4/CNVR9 are independent converter calls, not an invasive pre-SQR probe.
; MR_RAW_ROW in: $8 VT20 row, $10 address of nine bytes, $14 ROM 10-byte label.
MR_RAW_ROW:
        PST     UA,&H14
        PRE     IX,MR_ROW
        ST      $8,(IX+$SX)
        PRE     IX,MR_TBUF
        LD      $0,&H20
        LD      $20,32
MR_RBLANK:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_RBLANK
        PRE     IX,MR_TBUF
        PRE     IZ,$14
        LD      $20,10
MR_RCOPY:
        LDI     $0,(IZ+$SX)
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_RCOPY
        JP      MR_RAWVAL

; Nine bytes become precisely 18 hex characters, no H: or decimal.
; NOTE: Rendering remains an unqualified instrument until MARK passes.
MR_RAWVAL:
        PRE     IX,MR_TBUF+10
        LD      $20,9
MR_RAWLOOP:
        PRE     IZ,$10
; UA=14 keeps IZ in bank 0, while captured B9 bytes live in bank 1.
; Change only the Z bank for the RAM fetch; restore before ROM DIGITS lookup.
        PST     UA,&H54
        LDI     $0,(IZ+$SX)
        PST     UA,&H14
        LD      $1,$0
        DID     $1
        AN      $1,&H0F
        AN      $0,&H0F
        PRE     IZ,MR_DIGITS
        LD      $2,(IZ+$1)
        STI     $2,(IX+$SX)
        LD      $2,(IZ+$0)
        STI     $2,(IX+$SX)
        LDW     $4,1
        ADW     $10,$4
        SB      $20,$SY
        JR      NZ,MR_RAWLOOP
MR_SENDROW:
        PRE     IX,MR_ROW
        LD      $8,(IX+$SX)
        LD      $9,1
        LDW     $10,MR_TBUF
        LD      $12,SRC_RAM
        LD      $13,32
        CAL     VT23_WRITE
        RTN

; Independent converter/dump self-check (no mathematical ROM calls here).
; Marker bytes are written through the same RAM bank as numerical captures.
MR_MARK_INIT:
        PST     UA,&H14
        PRE     IX,MR_MARK
        LD      $0,&H12
        STI     $0,(IX+$SX)
        LD      $0,&H34
        STI     $0,(IX+$SX)
        LD      $0,&H56
        STI     $0,(IX+$SX)
        LD      $0,&H78
        STI     $0,(IX+$SX)
        LD      $0,&H9A
        STI     $0,(IX+$SX)
        LD      $0,&HBC
        STI     $0,(IX+$SX)
        LD      $0,&HDE
        STI     $0,(IX+$SX)
        LD      $0,&HF0
        STI     $0,(IX+$SX)
        LD      $0,&H0F
        STI     $0,(IX+$SX)
        RTN

; r010 human-first renderer lives below; raw B9 renderer above unchanged.
; ======================================================================
; r010 report producer. VT20 remains an unmodified 80x24 viewport.
; One selected native invocation per FK2; ten-row accumulating ledger.
; Consumer owns page breaks. Q=next report page; MENU=leave; BRK=reset.
; Seven leading normalized B9 digits + exponent compared with an
; independent host oracle signature; this is a smoke gate, not parity.
; ======================================================================

; Preserve an actual observed B9 in its per-function slot (90 bytes total).
MR_KEEP_ONE:
        PST     UA,&H14
        PRE     IX,MR_SEL
        LD      $20,(IX+$SX)
        LDW     $4,MR_ALLRAW
        AN      $20,$20
        JR      Z,MR_KEEP_PTR
MR_KEEP_ADD:
        LDW     $0,9
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_KEEP_ADD
MR_KEEP_PTR:
        PRE     IX,$4
        PRE     IZ,MR_A1
        PST     UA,&H54
        LD      $20,9
MR_KEEP_L:
        LDI     $0,(IZ+$SX)
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_KEEP_L
        PST     UA,&H14
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        LDW     $4,MR_STATUS
        LD      $3,$0
        LDW     $0,0
        LD      $0,$3
        ADW     $4,$0
        PRE     IX,$4
        LD      $0,3                  ; observed, comparator pending
        ST      $0,(IX+$SX)
        RTN

; Return address of raw record MR_INDEX in $4.
MR_RAWPTR:
        LDW     $4,MR_ALLRAW
        PRE     IX,MR_INDEX
        LD      $20,(IX+$SX)
        AN      $20,$20
        JR      Z,MR_RAWPTR_END
MR_RAWPTR_LOOP:
        LDW     $0,9
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_RAWPTR_LOOP
MR_RAWPTR_END:
        RTN

; Return address of status byte MR_INDEX in $4.
MR_STATPTR:
        PRE     IX,MR_INDEX
        LD      $0,(IX+$SX)
        LDW     $4,MR_STATUS
        LD      $3,$0
        LDW     $0,0
        LD      $0,$3
        ADW     $4,$0
        RTN

; Return 32-byte ROM record at base $4, indexed by MR_INDEX.
MR_INDEX32:
        PRE     IX,MR_INDEX
        LD      $20,(IX+$SX)
        JP      MR_OFFSET32

; Input captions are exactly 12 bytes, NOT 32-byte ROM records.
; r010 reused MR_INDEX32 here: later rows displayed unrelated ROM text.
; Keep 32-byte indexing for names, oracle records and signatures only.
MR_INDEX12:
        PRE     IX,MR_INDEX
        LD      $20,(IX+$SX)
        AN      $20,$20
        JR      Z,MR_I12_DONE
MR_I12_LOOP:
        LDW     $0,12
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_I12_LOOP
MR_I12_DONE:
        RTN

; VT20 writer: ROM/RAM address $4, column $9, byte count $13.
; Current one-based physical report row is MR_VROW.
MR_PUT:
        PRE     IX,MR_VROW
        LD      $8,(IX+$SX)
        LDW     $10,$4
        CAL     VT23_WRITE
        RTN
MR_PUT_ROM:
        LD      $12,SRC_ROM
        JP      MR_PUT
MR_PUT_RAM:
        LD      $12,SRC_RAM
        JP      MR_PUT

; Page number in the header is sequential and requires no total count.
; Handles Page 1 ... Page 99; current application needs only two pages.
MR_PAGE_HEADER:
        LD      $0,1
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LDW     $4,MR_REPORT_TITLE
        LD      $9,1
        LD      $13,33
        CAL     MR_PUT_ROM
        LDW     $4,MR_PAGE_PREFIX
        LD      $9,72
        LD      $13,5
        CAL     MR_PUT_ROM
        PRE     IX,MR_PAGE
        LD      $0,(IX+$SX)
        LD      $1,0
MR_PAGE_TENS:
        LD      $2,$0
        SBC     $2,10
        JR      C,MR_PAGE_DIGITS
        SB      $0,10
        AD      $1,$SY
        JP      MR_PAGE_TENS
MR_PAGE_DIGITS:
        PRE     IX,MR_PCHR
        AN      $1,$1
        JR      Z,MR_PAGE_SINGLE
        AD      $1,&H30
        STI     $1,(IX+$SX)
        AD      $0,&H30
        STI     $0,(IX+$SX)
        JR      MR_PAGE_WRITE
MR_PAGE_SINGLE:
        AD      $0,&H30
        STI     $0,(IX+$SX)
        LD      $0,&H20
        STI     $0,(IX+$SX)
MR_PAGE_WRITE:
        LDW     $4,MR_PCHR
        LD      $9,77
        LD      $13,2
        CAL     MR_PUT_RAM
        RTN

; Full 23-service report. First 15 retain original execution and comparators;
; the remaining eight have explicit NOT RUN/BLOCKED rows, not hidden passes.
MR_REPORT_MAIN:
        PST     UA,&H14
        CAL     MR_MARK_INIT
        PRE     IX,MR_PAGE
        LD      $0,1
        ST      $0,(IX+$SX)
        PRE     IX,MR_INDEX
        LD      $0,0
        ST      $0,(IX+$SX)
MR_TBL_NEWPAGE:
        CAL     VT23_CLEAR
        CAL     MR_PAGE_HEADER
        LD      $0,3
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LDW     $4,MR_TABLE_HEAD
        LD      $9,1
        LD      $13,76
        CAL     MR_PUT_ROM
        CAL     MR_ALL_BANNER
        PRE     IX,MR_VROW
        LD      $0,5
        ST      $0,(IX+$SX)
MR_TABLE_LOOP:
        PRE     IX,MR_INDEX
        LD      $0,(IX+$SX)
        SBC     $0,23
        JR      C,MR_TBL_ACTIVE
        JP      MR_TABLE_END
MR_TBL_ACTIVE:
        PRE     IX,MR_VROW
        LD      $0,(IX+$SX)
        SBC     $0,21
        JR      NC,MR_TBL_FULL
        PRE     IX,MR_INDEX
        LD      $0,(IX+$SX)
        SBC     $0,23
        JR      NC,MR_TBL_PENDING
        SBC     $0,10
        JR      C,MR_TBL_OLD
        CAL     MR_XTABLE_ROW
        JR      MR_TBL_NEXT
MR_TBL_PENDING:
        CAL     MR_PENDING_ROW
        JR      MR_TBL_NEXT
MR_TBL_OLD:
        CAL     MR_TABLE_ROW
MR_TBL_NEXT:
        PRE     IX,MR_INDEX
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        PRE     IX,MR_VROW
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        JP      MR_TABLE_LOOP
MR_TBL_FULL:
        LD      $0,22
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LDW     $4,MR_PAGE_MORE
        LD      $9,1
        LD      $13,50
        CAL     MR_PUT_ROM
        CAL     VT23_VIEW
        LD      $29,$0
        AN      $29,$29
        JR      NZ,MR_TBL_EARLY
        PRE     IX,MR_PAGE
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        JP      MR_TBL_NEWPAGE
MR_TBL_EARLY:
        LD      $0,$29
        RTN
MR_TABLE_END:
        LD      $0,22
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LDW     $4,MR_PAGE_POLICY
        LD      $9,1
        LD      $13,67
        CAL     MR_PUT_ROM
        LD      $0,23
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LDW     $4,MR_PAGE_HELP
        LD      $9,1
        LD      $13,49
        CAL     MR_PUT_ROM
        CAL     VT23_VIEW
        RTN

; First VT20 LCD viewport row 4 reports sweep success or the first
; returned failure, without replacing the required human-readable table.
MR_ALL_BANNER:
        PRE     IX,MR_ALLMODE
        LD      $0,(IX+$SX)
        AN      $0,$0
        RTN     Z
        PRE     IX,MR_VROW
        LD      $0,4
        ST      $0,(IX+$SX)
        PRE     IX,MR_ALLSTOP
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      Z,MR_BNR_NORMAL
        JP      MR_BANNER_STOP
MR_BNR_NORMAL:
        PRE     IX,MR_XDONE
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      Z,MR_ALL_TENONLY
        LDW     $4,MR_ALL_OKTXT
        JR      MR_ALL_PRINTOK
MR_ALL_TENONLY:
        LDW     $4,MR_ALL_TENTXT
MR_ALL_PRINTOK:
        LD      $9,1
        LD      $13,19
        CAL     MR_PUT_ROM
        PRE     IX,MR_NEARCT
        LD      $0,(IX+$SX)
        SBC     $0,10
        JR      C,MR_NEAR_SINGLE
        SBC     $0,20
        JR      C,MR_NEAR_TEEN
        SB      $0,20
        PRE     IX,MR_NEARSTR
        LD      $1,&H32
        STI     $1,(IX+$SX)
        AD      $0,&H30
        ST      $0,(IX+$SX)
        JR      MR_NEAR_PRINT
MR_NEAR_TEEN:
        SB      $0,10
        PRE     IX,MR_NEARSTR
        LD      $1,&H31
        STI     $1,(IX+$SX)
        AD      $0,&H30
        ST      $0,(IX+$SX)
        JR      MR_NEAR_PRINT
MR_NEAR_SINGLE:
        PRE     IX,MR_NEARSTR
        AD      $0,&H30
        STI     $0,(IX+$SX)
        LD      $0,&H20
        ST      $0,(IX+$SX)
MR_NEAR_PRINT:
        LDW     $4,MR_NEARSTR
        LD      $9,20
        LD      $13,2
        CAL     MR_PUT_RAM
        LDW     $4,MR_PENDING_TXT
        LD      $9,25
        LD      $13,17
        JP      MR_PUT_ROM
MR_BANNER_STOP:
        LDW     $4,MR_ALL_ERRTXT
        LD      $9,1
        LD      $13,11
        CAL     MR_PUT_ROM
        PRE     IX,MR_XSTOP
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_BANNER_XNAME
        LDW     $4,MR_NAMES
        CAL     MR_NAMEPTR
        JR      MR_BAN_NAMEOK
MR_BANNER_XNAME:
        LDW     $4,MR_XNAMES
        CAL     MR_XNAMEPTR
MR_BAN_NAMEOK:
        LDW     $0,2
        ADW     $4,$0
        LD      $9,12
        LD      $13,3
        CAL     MR_PUT_ROM
        PRE     IX,MR_ALLSTOP
        LD      $0,(IX+$SX)
        SBC     $0,2
        JR      Z,MR_BANNER_FAIL
        LDW     $4,MR_CHECK_TXT
        JR      MR_B_VERDICT
MR_BANNER_FAIL:
        LDW     $4,MR_FAIL_TXT
MR_B_VERDICT:
        LD      $9,18
        LD      $13,8
        JP      MR_PUT_ROM

 ; One row: FUNCTION / INPUT / decoded native / independent oracle / verdict.
MR_TABLE_ROW:
        LDW     $4,MR_NAMES
        CAL     MR_INDEX32
        LDW     $0,2
        ADW     $4,$0
        LD      $9,1
        LD      $13,8
        CAL     MR_PUT_ROM
        LDW     $4,MR_INPUTS
        CAL     MR_INDEX12
        LD      $9,12
        LD      $13,12
        CAL     MR_PUT_ROM
        CAL     MR_STATPTR
        PRE     IX,$4
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_TBL_OBS
        LDW     $4,MR_UNRUN_TXT
        LD      $9,24
        LD      $13,18
        CAL     MR_PUT_ROM
        JP      MR_TABLE_ORACLE
MR_TBL_OBS:
        CAL     MR_RAWPTR
        CAL     MR_B9_DEC
        LDW     $4,MR_TEXT
        LD      $9,24
        LD      $13,18
        CAL     MR_PUT_RAM
        CAL     MR_B9_COMPARE
        LD      $29,$0
        CAL     MR_STATPTR
        PRE     IX,$4
        ST      $29,(IX+$SX)
MR_TABLE_ORACLE:
        LDW     $4,MR_ORACLES
        CAL     MR_INDEX32
        LDW     $0,7
        ADW     $4,$0
        LD      $9,46
        LD      $13,18
        CAL     MR_PUT_ROM
        CAL     MR_STATPTR
        PRE     IX,$4
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      Z,MR_TABLE_WAIT
        SBC     $0,1
        JR      Z,MR_TABLE_PASS
        SBC     $0,4             ; accepted but divergent
        JR      Z,MR_TABLE_NEAR
        SBC     $0,2             ; SBC compares but does NOT decrement
        JR      Z,MR_TABLE_FAIL
        LDW     $4,MR_CHECK_TXT
        JR      MR_TABLE_STATUS
MR_TABLE_WAIT:
        LDW     $4,MR_WAIT_TXT
        JR      MR_TABLE_STATUS
MR_TABLE_PASS:
        LDW     $4,MR_PASS_TXT
        JR      MR_TABLE_STATUS
MR_TABLE_NEAR:
        LDW     $4,MR_NEAR_TXT
        JR      MR_TABLE_STATUS
MR_TABLE_FAIL:
        LDW     $4,MR_FAIL_TXT
MR_TABLE_STATUS:
        LD      $9,68
        LD      $13,8
        CAL     MR_PUT_ROM
        RTN

; Eleven additional rows following original ten, with second app-owned ledger.
; X=10 holds packed BCD, so never run its result through B9_DEC.
MR_XTABLE_ROW:
        PRE     IX,MR_INDEX
        LD      $0,(IX+$SX)
        SB      $0,10
        PRE     IX,MR_XSEL
        ST      $0,(IX+$SX)
        LDW     $4,MR_XNAMES
        CAL     MR_XNAMEPTR
        LDW     $0,2
        ADW     $4,$0
        LD      $9,1
        LD      $13,8
        CAL     MR_PUT_ROM
        LDW     $4,MR_XINPUTS
        CAL     MR_XINDEX12
        LD      $9,12
        LD      $13,12
        CAL     MR_PUT_ROM
        CAL     MR_XSTATPTR
        PRE     IX,$4
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_XTABLE_OBS
        LDW     $4,MR_UNRUN_TXT
        LD      $9,24
        LD      $13,18
        CAL     MR_PUT_ROM
        JP      MR_XTAB_ORACLE
MR_XTABLE_OBS:
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        SBC     $0,10
        JR      Z,MR_XTB_BCDRAW
        SBC     $0,11
        JR      Z,MR_XTB_CMPFLAG
        CAL     MR_XRAWPTR
        CAL     MR_B9_DEC
        LDW     $4,MR_TEXT
        LD      $9,24
        LD      $13,18
        CAL     MR_PUT_RAM
        JP      MR_XTAB_ORACLE
MR_XTB_CMPFLAG:
        LDW     $4,MR_TAB_CMPTXT
        LD      $9,24
        LD      $13,18
        CAL     MR_PUT_ROM
        JP      MR_XTAB_ORACLE
MR_XTB_BCDRAW:
        LDW     $4,MR_TAB_BCDTXT
        LD      $9,24
        LD      $13,18
        CAL     MR_PUT_ROM
        ; Crucial: status from first raw-byte judge is never overwritten.
MR_XTAB_ORACLE:
        LDW     $4,MR_XORACLES
        CAL     MR_XNAMEPTR
        LDW     $0,7
        ADW     $4,$0
        LD      $9,46
        LD      $13,18
        CAL     MR_PUT_ROM
        CAL     MR_XSTATPTR
        PRE     IX,$4
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      Z,MR_XTB_WAIT
        SBC     $0,1
        JR      Z,MR_XTB_PASS
        SBC     $0,4
        JR      Z,MR_XTB_NEAR
        SBC     $0,2
        JR      Z,MR_XTB_FAIL
        LDW     $4,MR_CHECK_TXT
        JR      MR_XTB_STATUS
MR_XTB_WAIT:
        LDW     $4,MR_WAIT_TXT
        JR      MR_XTB_STATUS
MR_XTB_PASS:
        LDW     $4,MR_PASS_TXT
        JR      MR_XTB_STATUS
MR_XTB_NEAR:
        LDW     $4,MR_NEAR_TXT
        JR      MR_XTB_STATUS
MR_XTB_FAIL:
        LDW     $4,MR_FAIL_TXT
MR_XTB_STATUS:
        LD      $9,68
        LD      $13,8
        CAL     MR_PUT_ROM
        RTN
; r020 catalog-only rows 21..22: CMP and POWER now have caller-backed experimental fixtures.
; Their native ABI and side effects are not yet safely specified.
MR_PENDING_ROW:
        LDW     $4,MR_NAMES
        CAL     MR_INDEX32
        LDW     $0,2
        ADW     $4,$0
        LD      $9,1
        LD      $13,8
        CAL     MR_PUT_ROM
        LDW     $4,MR_PEND_INPUTS
        CAL     MR_PEND12PTR
        LD      $9,12
        LD      $13,12
        CAL     MR_PUT_ROM
        LDW     $4,MR_UNRUN_TXT
        LD      $9,24
        LD      $13,18
        CAL     MR_PUT_ROM
        LDW     $4,MR_PEND_ORACLES
        CAL     MR_PEND32PTR
        LDW     $0,7
        ADW     $4,$0
        LD      $9,46
        LD      $13,18
        CAL     MR_PUT_ROM
        PRE     IX,MR_INDEX
        LD      $0,(IX+$SX)
        SBC     $0,23
        JR      C,MR_PEND_WAIT
        LDW     $4,MR_BLOCK_TXT
        JR      MR_PEND_OUT
MR_PEND_WAIT:
        LDW     $4,MR_WAIT_TXT
MR_PEND_OUT:
        LD      $9,68
        LD      $13,8
        CAL     MR_PUT_ROM
        RTN
; Base in $4, index MR_INDEX-15; 12-byte pending input text.
MR_PEND12PTR:
        PRE     IX,MR_INDEX
        LD      $20,(IX+$SX)
        SB      $20,15
MR_PEND12LOOP:
        AN      $20,$20
        JR      Z,MR_PEND12END
        LDW     $0,12
        ADW     $4,$0
        SB      $20,$SY
        JR      MR_PEND12LOOP
MR_PEND12END:
        RTN
; Base in $4, index MR_INDEX-15; 32-byte host-reference description.
MR_PEND32PTR:
        PRE     IX,MR_INDEX
        LD      $20,(IX+$SX)
        SB      $20,15
MR_PEND32LOOP:
        AN      $20,$20
        JR      Z,MR_PEND32END
        LDW     $0,32
        ADW     $4,$0
        SB      $20,$SY
        JR      MR_PEND32LOOP
MR_PEND32END:
        RTN

MR_XINDEX12:
        PRE     IX,MR_XSEL
        LD      $20,(IX+$SX)
        AN      $20,$20
        JR      Z,MR_XI12_END
MR_XI12_LOOP:
        LDW     $0,12
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_XI12_LOOP
MR_XI12_END:
        RTN

 ; Read captured B9 byte from bank one ($10 = pointer), restores UA=14.
; Does NOT access the original native routine or change its state.
MR_B9_READ:
        PRE     IZ,$10
        PST     UA,&H54
        LD      $0,(IZ+$SX)
        PST     UA,&H14
        RTN

; Convert actual B9 result into a human fixed-point decimal string.
; r019 smoke domain: positive, normalized, exponent -1/0/+1/+2 only.
; Unsupported/invalid BCD is CHECK with INVALID B9, never a false PASS.
; In $4=bank-one pointer to nine raw result bytes. Out MR_TEXT and MR_BOK.
MR_B9_DEC:
        LDW     $24,$4
        PRE     IX,MR_BOK
        LD      $0,1
        ST      $0,(IX+$SX)
        LDW     $10,$24
        LDW     $4,7
        ADW     $10,$4
        CAL     MR_B9_READ
        LD      $6,$0
        LDW     $4,1
        ADW     $10,$4
        CAL     MR_B9_READ
        LD      $7,$0
        LD      $1,$7
        AN      $1,&H0F
        AN      $1,$1
        JR      Z,MR_B9_H0
        SBC     $1,1
        JR      Z,MR_B9_H1
        JP      MR_B9_INVALID
MR_B9_H0:
        LD      $1,$6
        SBC     $1,&H99
        JP      NZ,MR_B9_INVALID
        LD      $0,0                   ; exponent -1
        JR      MR_B9_SETEXP
MR_B9_H1:
        LD      $1,$6
        AN      $1,$1
        JR      Z,MR_B9_EXPZERO
        SBC     $1,1
        JR      Z,MR_B9_EXPONE
        SBC     $1,2
        JP      NZ,MR_B9_INVALID
        LD      $0,3                   ; exponent +2 for CNVR(123)
        JR      MR_B9_SETEXP
MR_B9_EXPONE:
        LD      $0,2                   ; exponent +1
        JR      MR_B9_SETEXP
MR_B9_EXPZERO:
        LD      $0,1                   ; exponent zero
MR_B9_SETEXP:
        PRE     IX,MR_EXP
        ST      $0,(IX+$SX)
        LD      $21,$0
        LDW     $10,$24
        LDW     $4,6
        ADW     $10,$4
        PRE     IX,MR_MANT
        LD      $29,1                  ; valid BCD flag
        CAL     MR_B9_READ
        AN      $0,&H0F
        LD      $2,$0
        SBC     $2,10
        JR      C,MR_B9_DIG0
        LD      $29,0
MR_B9_DIG0:
        AD      $0,&H30
        STI     $0,(IX+$SX)
        LD      $20,6
MR_B9_DIGPAIR:
        LDW     $4,1
        SBW     $10,$4
        CAL     MR_B9_READ
        LD      $1,$0
        DID     $1
        AN      $1,&H0F
        AN      $0,&H0F
        LD      $2,$1
        SBC     $2,10
        JR      C,MR_B9_HI_OK
        LD      $29,0
MR_B9_HI_OK:
        LD      $2,$0
        SBC     $2,10
        JR      C,MR_B9_LO_OK
        LD      $29,0
MR_B9_LO_OK:
        AD      $1,&H30
        STI     $1,(IX+$SX)
        AD      $0,&H30
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_B9_DIGPAIR
        AN      $29,$29
        JP      Z,MR_B9_INVALID
; Fill the actual display field with spaces (never oracle bytes).
        PRE     IX,MR_TEXT
        LD      $0,&H20
        LD      $20,18
MR_B9_TXTBLANK:
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_B9_TXTBLANK
        PRE     IX,MR_TEXT
        PRE     IZ,MR_MANT
        LD      $22,0
        ; $21 is still 0,1,2 integer digits according to exponent
        AN      $21,$21
        JR      NZ,MR_B9_COPYDIGS
        LD      $0,&H30                ; negative-one exponent: leading 0.
        STI     $0,(IX+$SX)
        LD      $0,&H2E
        STI     $0,(IX+$SX)
MR_B9_COPYDIGS:
        LD      $20,13
MR_B9_TXTLOOP:
        PST     UA,&H54
        LDI     $0,(IZ+$SX)
        PST     UA,&H14
        STI     $0,(IX+$SX)
        AD      $22,$SY
        LD      $1,$22
        SBC     $1,$21
        JR      NZ,MR_B9_NEXTDIG
        AN      $21,$21
        JR      Z,MR_B9_NEXTDIG
        LD      $0,&H2E
        STI     $0,(IX+$SX)
MR_B9_NEXTDIG:
        SB      $20,$SY
        JR      NZ,MR_B9_TXTLOOP
        RTN
MR_B9_INVALID:
        PRE     IX,MR_BOK
        LD      $0,0
        ST      $0,(IX+$SX)
        PRE     IX,MR_TEXT
        PRE     IZ,MR_INVALID_TXT
        LD      $20,18
MR_B9_INV_COPY:
        LDI     $0,(IZ+$SX)
        STI     $0,(IX+$SX)
        SB      $20,$SY
        JR      NZ,MR_B9_INV_COPY
        RTN

; r013 paired host-oracle checks (positive normalized B9, exponent -1/0/+1).
; PASS=1: all 13 visible mantissa digits equal host-truncated 13-digit oracle.
; PASS~=4: unequal, but native value inside host-generated inclusive envelope.
; FAIL=2: outside envelope; CHECK=3: invalid/unsupported decoded B9.
; Policy used only in the ten FIXED smoke fixtures; not general ABI precision.
MR_B9_COMPARE:
        PRE     IX,MR_BOK
        LD      $0,(IX+$SX)
        AN      $0,$0
        JR      NZ,MR_B9_VALID
        LD      $0,3
        RTN
MR_B9_VALID:
        LDW     $4,MR_E_SIGS
        CAL     MR_INDEX14
        CAL     MR_B9_SIGNCMP
        AN      $0,$0
        JR      Z,MR_B9_EXACT
        LDW     $4,MR_LO_SIGS
        CAL     MR_INDEX14
        CAL     MR_B9_SIGNCMP
        SBC     $0,1         ; actual < inclusive lower envelope?
        JR      Z,MR_B9_CFAIL
        LDW     $4,MR_HI_SIGS
        CAL     MR_INDEX14
        CAL     MR_B9_SIGNCMP
        SBC     $0,2         ; actual > inclusive upper envelope?
        JR      Z,MR_B9_CFAIL
        LD      $0,4         ; PASS~: flag deviation, never erase it
        RTN
MR_B9_EXACT:
        LD      $0,1
        RTN
MR_B9_CFAIL:
        LD      $0,2
        RTN

; Comparator of positive normalized (exponent bucket + 13 digits).
; Input $4 = pointer to 14 ASCII ROM bytes. Output $0:
;  0 equal, 1 native less, 2 native greater than reference.
; This is a lexical numeric comparison because both representations
; are normalized and nonnegative; source host unit tests guard boundaries.
MR_B9_SIGNCMP:
        PRE     IZ,$4
        LDI     $1,(IZ+$SX)
        SB      $1,&H30
        PRE     IX,MR_EXP
        LD      $0,(IX+$SX)
        SBC     $0,$1
        JR      C,MR_BSC_LESS
        JR      NZ,MR_BSC_MORE
        PRE     IX,MR_MANT
        LD      $20,13
MR_BSC_LOOP:
        LDI     $0,(IX+$SX)
        LDI     $1,(IZ+$SX)
        SBC     $0,$1
        JR      C,MR_BSC_LESS
        JR      NZ,MR_BSC_MORE
        SB      $20,$SY
        JR      NZ,MR_BSC_LOOP
        LD      $0,0
        RTN
MR_BSC_LESS:
        LD      $0,1
        RTN
MR_BSC_MORE:
        LD      $0,2
        RTN

; Select fixed-width 14-byte reference record by MR_INDEX=0..9.
MR_INDEX14:
        PRE     IX,MR_INDEX
        LD      $20,(IX+$SX)
        AN      $20,$20
        JR      Z,MR_I14_DONE
MR_I14_LOOP:
        LDW     $0,14
        ADW     $4,$0
        SB      $20,$SY
        JR      NZ,MR_I14_LOOP
MR_I14_DONE:
        RTN

; Dedicated, on-demand diagnostic page for selected case, never a substitute
; for the human comparison table. Page number follows emitted pages.
; Extra cohort detail reads the saved 9-byte sweep output, never re-runs
; a native kernel. Exact B9 input snapshots are not yet stored for this cohort;
; the fixture description is provided honestly in the human table.
MR_XDETAIL:
        PRE     IX,MR_XFOCUS
        LD      $0,(IX+$SX)
        PRE     IX,MR_XSEL
        ST      $0,(IX+$SX)
        PRE     IX,MR_PAGE
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        CAL     VT23_CLEAR
        CAL     MR_PAGE_HEADER
        PRE     IX,MR_VROW
        LD      $0,3
        ST      $0,(IX+$SX)
        LDW     $4,MR_XDETAILTXT
        LD      $9,1
        LD      $13,60
        CAL     MR_PUT_ROM
        LDW     $4,MR_XNAMES
        CAL     MR_XNAMEPTR
        PRE     IX,MR_VROW
        LD      $0,4
        ST      $0,(IX+$SX)
        LD      $9,1
        LD      $13,32
        CAL     MR_PUT_ROM
        LD      $8,5
        LDW     $10,MR_MARK
        LDW     $14,MR_LMARK
        CAL     MR_RAW_ROW
        PRE     IX,MR_XSEL
        LD      $0,(IX+$SX)
        SBC     $0,5
        JP      NC,MR_XD_FIXTURE
        CAL     MR_XPTR_A
        LDW     $10,$4
        LD      $8,6
        LDW     $14,MR_XINA
        CAL     MR_RAW_ROW
        CAL     MR_XPTR_B
        LDW     $10,$4
        LD      $8,7
        LDW     $14,MR_XINB
        CAL     MR_RAW_ROW
        JP      MR_XD_OUTPUT
MR_XD_FIXTURE:
        PRE     IX,MR_VROW
        LD      $0,6
        ST      $0,(IX+$SX)
        LDW     $4,MR_XFIX_NOTICE
        LD      $9,1
        LD      $13,64
        CAL     MR_PUT_ROM
MR_XD_OUTPUT:
        CAL     MR_XRAWPTR
        LDW     $10,$4
        LD      $8,8
        LDW     $14,MR_XOUTA
        CAL     MR_RAW_ROW
        RTN

MR_RPT_DETAIL:
        PRE     IX,MR_DETAILX
        LD      $0,(IX+$SX)
        AN      $0,$0
        JP      NZ,MR_XDETAIL
MR_UNARY_DETAIL:
        PRE     IX,MR_PAGE
        LD      $0,(IX+$SX)
        AD      $0,$SY
        ST      $0,(IX+$SX)
        CAL     VT23_CLEAR
        CAL     MR_PAGE_HEADER
        LDW     $4,MR_HEADS
        CAL     MR_NAMEPTR
        LD      $0,3
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LD      $9,1
        LD      $13,32
        CAL     MR_PUT_ROM
        LD      $8,5
        LDW     $10,MR_MARK
        LDW     $14,MR_LMARK
        CAL     MR_RAW_ROW
; Q diagnostic uses the case selected AFTER the whole sweep, not the
; last call's scratch registers. Input is re-created after results are saved,
; just as in r012, and is not a cycle-accurate pre-CAL snapshot.
        PST     UA,&H14
        CAL     MR_LOAD_ONE
        LDW     $8,MR_I1
        CAL     MR_SAVE9
        LD      $8,6
        LDW     $10,MR_I1
        LDW     $14,MR_LINPUT
        CAL     MR_RAW_ROW
        PRE     IX,MR_SEL
        LD      $0,(IX+$SX)
        PRE     IX,MR_INDEX
        ST      $0,(IX+$SX)
        CAL     MR_RAWPTR
        LDW     $10,$4
        LD      $8,7
        LDW     $14,MR_LOUTPUT
        CAL     MR_RAW_ROW
        LDW     $4,MR_ORACLES
        CAL     MR_NAMEPTR
        LD      $0,8
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LD      $9,1
        LD      $13,32
        CAL     MR_PUT_ROM
        LD      $0,10
        PRE     IX,MR_VROW
        ST      $0,(IX+$SX)
        LDW     $4,MR_DEBUG_NOTE
        LD      $9,1
        LD      $13,70
        CAL     MR_PUT_ROM
        RTN

; r014 extra candidate labels and independent descriptive oracles.
; All entries in MR_XNAMES/MR_XORACLE are EXACTLY 32 bytes.
MR_XTITLE: DB "RESIDENT EXTRA MATH / 13        "
MR_XKEYS: DB "[prev  ][next  ][run   ][home  ]"
MR_XNAMES:
MR_XN_SQ: DB "> SQ: 7 * 7                     "
MR_XN_PI: DB "> PI: zero arguments            "
MR_XN_FX: DB "> FIX: 7.5 to integer           "
MR_XN_AD: DB "> ADD: 1 + 2                    "
MR_XN_MU: DB "> MUL: 6 * 7                    "
MR_XN_SU: DB "> SUB: 5 - 2                    "
MR_XN_RD: DB "> RND12: 7 (unqualified)        "
MR_XN_IC: DB "> INC: 7 + 1                    "
MR_XN_DV: DB "> DIV: 8 / 2                    "
MR_XN_CN: DB "> CNVR: signed16 123 -> B9      "
MR_XN_BC: DB "> B2BCD: 123 -> packed BCD      "
MR_XN_CM: DB "> CMP: 2 < 3 (carry flag)       "
MR_XN_PW: DB "> POWER: 2 ^ 3 = 8              "
MR_XORACLE:
MR_XO_SQ: DB "HOST REFERENCE: 49              "
MR_XO_PI: DB "HOST REFERENCE: 3.14159265359   "
MR_XO_FX: DB "HOST REFERENCE: 7               "
MR_XO_AD: DB "HOST REFERENCE: 3               "
MR_XO_MU: DB "HOST REFERENCE: 42              "
MR_XO_SU: DB "HOST REFERENCE: 3               "
MR_XO_RD: DB "HOST REFERENCE: 7               "
MR_XO_IC: DB "HOST REFERENCE: 8               "
MR_XO_DV: DB "HOST REFERENCE: 4               "
MR_XO_CN: DB "HOST REFERENCE: B9(123)         "
MR_XO_BC: DB "HOST REF: BCD LE 23 01 00       "
MR_XO_CM: DB "HOST REF: CMP(2,3) LT=1         "
MR_XO_PW: DB "HOST REF: POWER(2,3)=8          "
MR_XORACLES:
MR_XTA_SQ: DB "ORACLE 49.0000000000000         "
MR_XTA_PI: DB "ORACLE 3.14159265358979         "
MR_XTA_FX: DB "ORACLE 7.00000000000000         "
MR_XTA_AD: DB "ORACLE 3.00000000000000         "
MR_XTA_MU: DB "ORACLE 42.0000000000000         "
MR_XTA_SU: DB "ORACLE 3                        "
MR_XTA_RD: DB "ORACLE 7 (identity fixture)     "
MR_XTA_IC: DB "ORACLE 8                        "
MR_XTA_DV: DB "ORACLE 4                        "
MR_XTA_CN: DB "ORACLE B9(123)                  "
MR_XTA_BC: DB "ORACLE BCD(123)                 "
MR_XTA_CM: DB "ORACLE CMP LT=1 (adapter)       "
MR_XTA_PW: DB "ORACLE 8                        "
MR_XINPUTS:
MR_XI_SQ: DB "7           "
MR_XI_PI: DB "none        "
MR_XI_FX: DB "7.5         "
MR_XI_AD: DB "1 + 2       "
MR_XI_MU: DB "6 * 7       "
MR_XI_SU: DB "5 - 2       "
MR_XI_RD: DB "RND12(7)    "
MR_XI_IC: DB "7 + 1       "
MR_XI_DV: DB "8 / 2       "
MR_XI_CN: DB "I16:123     "
MR_XI_BC: DB "I16:123     "
MR_XI_CM: DB "2 < 3       "
MR_XI_PW: DB "2 ^ 3       "
MR_INFOKEYS: DB "[back  ][      ][      ][      ]"
MR_INFOTITLE: DB "MathROM r029 - testing registry "
MR_INFOTEXT: DB "23 registered / 23 auto-tested  "
MR_INFOTEXT2: DB "CMP flag; POWER B9: 1 fixture   "
MR_UNSAFE_MSG: DB "NOT RUN: caller ABI unsafe or unqualified. Use source census first."
MR_RESULTLABEL: DB "SMOKE RESULT: "
MR_BCDTEXT: DB "BCD 123: SEE RAW  "
MR_BCDLABEL: DB "TYPE / RAW: "
MR_BLOCK_TXT: DB "BLOCKED "
MR_PENDING_TXT: DB "; 0 BLOCKED      "
MR_XDETAILTXT: DB "AUTOTEST RAW OUTPUT; INPUT BYTES ONLY FOR FIRST FIVE EXTRA CALLS"
MR_XINA: DB "INPUT_A   "
MR_XINB: DB "INPUT_B   "
MR_XOUTA: DB "OUT_10    "
MR_XOUTB: DB "OUT_00    "
MR_TAB_BCDTXT: DB "PACKED BCD: Q RAW "
MR_TAB_CMPTXT: DB "FLAG -> B9: Q RAW "
MR_XFIX_NOTICE: DB "Fixture in report; pre-call raw operands not kept for X=5..10   "
MR_XDLABEL: DB "B9 DECODER: "
MR_XBRIEF: DB "CANDIDATE LOW-ROM SERVICE - SELECTED OR AUTOTEST - NOT CERTIFIED"
MR_XCAUTION: DB "Fixture verdict only. BCD=expected $14..16 23 01 00 (LE); CHECK means unqualified."

; All long-form text remains ROM data, so no runtime sprintf or C library.
MR_REPORT_TITLE: DB "MathROM r029 - Resident Survey "
MR_PAGE_PREFIX: DB "Page "
MR_ALL_OKTXT: DB "RUN 23/23 OK; NEAR="
MR_ALL_TENTXT: DB "RUN 10/23 OK; NEAR="
MR_ALL_ERRTXT: DB "ALL STOP @ "
MR_TABLE_HEAD: DB "FUNCTION   INPUT       NATIVE OUTPUT         ORACLE                 RESULT  "
MR_PAGE_MORE: DB "Q next table page; MENU exit; BRK reset             "
MR_PAGE_POLICY: DB "Smoke: 13-digit oracle equality or declared tolerance; NOT ABI"
MR_PAGE_HELP: DB "Q raw details; MENU exit; BRK reset                "
MR_UNRUN_TXT: DB "not run           "
MR_INVALID_TXT: DB "INVALID B9        "
MR_WAIT_TXT: DB "NOT RUN "
MR_PASS_TXT: DB "PASS    "
MR_NEAR_TXT: DB "PASS~   "
MR_FAIL_TXT: DB "FAIL    "
MR_CHECK_TXT: DB "CHECK   "
MR_DEBUG_NOTE: DB "Raw bytes are evidence; INPUT is re-created after native result capture."
; The independent host oracle signatures below encode exponent bucket
; 0=-1, 1=0, 2=+1, then seven significant decimal digits. This is NOT
; a native-derived reference and not a recovered-library implementation.
; r013 host-generated exact-13 and inclusive 13-digit positive-B9 envelope.
; Labels and bounds are pinned to notes/R013_ORACLE_POLICY.json.
; First ASCII byte = exponent bucket 0 (-1), 1 (0), 2 (+1).
; Next 13 = normalized decimal mantissa. NO native math calls here.
MR_E_SIGS:
MR_E_ACS: DB "26000000000000"
MR_E_ASN: DB "23000000000000"
MR_E_ATN: DB "26343494882292"
MR_E_COS: DB "05000000000000"
MR_E_EXP: DB "12718281828459"
MR_E_LGT: DB "03010299956639"
MR_E_LOG: DB "06931471805599"
MR_E_SIN: DB "05000000000000"
MR_E_SQR: DB "12645751311064"
MR_E_TAN: DB "05773502691896"
MR_E_SQ: DB "24900000000000"
MR_E_PI: DB "13141592653589"
MR_E_FIX: DB "17000000000000"
MR_E_ADD: DB "13000000000000"
MR_E_MUL: DB "24200000000000"
MR_E_X_SUB: DB "13000000000000"
MR_E_X_RND: DB "17000000000000"
MR_E_X_INC: DB "18000000000000"
MR_E_X_DIV: DB "14000000000000"
MR_E_X_CNVR: DB "31230000000000" ; host exact CNVR integer=123, exponent +2
MR_E_X_BCD: DB "10000000000000" ; unused type-specific packed BCD
MR_E_X_CMP: DB "11000000000000" ; 2<3 flag becomes adapter B9(1)
MR_E_X_POWER: DB "18000000000000" ; 2^3=8
MR_LO_SIGS:
MR_LO_ACS: DB "25999999400000"
MR_LO_ASN: DB "22999999700000"
MR_LO_ATN: DB "26343494247942"
MR_LO_COS: DB "04999999500000"
MR_LO_EXP: DB "12718281556630"
MR_LO_LGT: DB "03010299655609"
MR_LO_LOG: DB "06931471112452"
MR_LO_SIN: DB "04999999500000"
MR_LO_SQR: DB "12645751046489"
MR_LO_TAN: DB "05773502114545"
MR_LO_SQ: DB "24899999510000"
MR_LO_PI: DB "13141592339430"
MR_LO_FIX: DB "16999999300000"
MR_LO_ADD: DB "12999999700000"
MR_LO_MUL: DB "24199999580000"
MR_LO_X_SUB: DB "12999999700000"
MR_LO_X_RND: DB "16999999300000"
MR_LO_X_INC: DB "17999999200000"
MR_LO_X_DIV: DB "13999999600000"
MR_LO_X_CNVR: DB "31230000000000" ; host exact CNVR integer=123, exponent +2
MR_LO_X_BCD: DB "10000000000000" ; unused
MR_LO_X_CMP: DB "11000000000000" ; strict boolean exact
MR_LO_X_POWER: DB "17999999200000"
MR_HI_SIGS:
MR_HI_ACS: DB "26000000600000"
MR_HI_ASN: DB "23000000300000"
MR_HI_ATN: DB "26343495516642"
MR_HI_COS: DB "05000000500000"
MR_HI_EXP: DB "12718282100288"
MR_HI_LGT: DB "03010300257670"
MR_HI_LOG: DB "06931472498747"
MR_HI_SIN: DB "05000000500000"
MR_HI_SQR: DB "12645751575640"
MR_HI_TAN: DB "05773503269247"
MR_HI_SQ: DB "24900000490000"
MR_HI_PI: DB "13141592967750"
MR_HI_FIX: DB "17000000700000"
MR_HI_ADD: DB "13000000300000"
MR_HI_MUL: DB "24200000420000"
MR_HI_X_SUB: DB "13000000300000"
MR_HI_X_RND: DB "17000000700000"
MR_HI_X_INC: DB "18000000800000"
MR_HI_X_DIV: DB "14000000400000"
MR_HI_X_CNVR: DB "31230000000000" ; host exact CNVR integer=123, exponent +2
MR_HI_X_BCD: DB "10000000000000" ; unused
MR_HI_X_CMP: DB "11000000000000" ; strict boolean exact
MR_HI_X_POWER: DB "18000000800000"
; Retained r012 seven-digit signature table, no longer consulted at runtime.
MR_SIGS:
MR_SIG_ACS: DB "26000000                        "
MR_SIG_ASN: DB "23000000                        "
MR_SIG_ATN: DB "26343494                        "
MR_SIG_COS: DB "05000000                        "
MR_SIG_EXP: DB "12718281                        "
MR_SIG_LGT: DB "03010299                        "
MR_SIG_LOG: DB "06931471                        "
MR_SIG_SIN: DB "05000000                        "
MR_SIG_SQR: DB "12645751                        "
MR_SIG_TAN: DB "05773502                        "
; Same ordering as MR_NAMES / MR_ORACLES. User-visible one-case inputs.
; Deterministic smoke order: known SQR, arithmetic, trig, then provisional
; inverse-trigonometric half-input probes. Each index appears exactly once.
MR_SORTFWD: DB 0,13,1,2,20,21,19,3,18,4,12,17,5,6,14,11,22,16,7,10,8,15,9 ; rank -> canonical ID
MR_SORTREV: DB 0,2,3,7,9,12,13,18,20,22,19,15,10,1,14,21,17,11,8,6,4,5,16 ; canonical ID -> rank
; One 23-service registry keyed by canonical ID. View rank uses SORTFWD;
; KIND=1 B9 (experimentally typed), 2 packed BCD, 3 flags, 4 unknown;
; SAFE=1 denotes the existing 15-item fixed oracle sweep, zero means
; listed explicitly but NOT auto-invoked until its individual gate passes.
MR_REGKIND: DB 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,3,1
MR_REGSAFE: DB 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
MR_ALL_ORDER: DB 8,4,6,5,3,7,9,2,1,0
MR_INPUTS:
MR_IN_ACS: DB "0.5         "
MR_IN_ASN: DB "0.5         "
MR_IN_ATN: DB "2           "
MR_IN_COS: DB "60 deg      "
MR_IN_EXP: DB "1           "
MR_IN_LGT: DB "2           "
MR_IN_LOG: DB "2           "
MR_IN_SIN: DB "30 deg      "
MR_IN_SQR: DB "7           "
MR_IN_TAN: DB "30 deg      "

; Four 8-column lower-case softkey cells; all physical LCD strings are
; exact 32 bytes. Selection order is alphabetical: SIN, SQR.
MR_SPL_TEXT:
        DB 0
        DB "Xandrian Labs",0
        DB "MathROM r029",0
        DB "PB-2000C / CS617",0
MR_DIGITS: DB "0123456789ABCDEF"
MR_H0: DB "MATHROM r029  PB-2000C          "
MR_HKEY: DB "[select][run   ][info  ][all   ]"
MR_SELTITLE: DB "SELECT FUNCTION / 23            "
MR_SELROW: DB "[prev  ][next  ][ok    ][      ]"
MR_TK0: DB "THICK COMPARISON                "
MR_TK1: DB "RECOVERED CODE NOT AVAILABLE    "
MR_EXMSG: DB "THIN ONE-ORACLE PROBE...        "
MR_LMARK: DB "MARK      "
MR_LINPUT: DB "INPUT     "
MR_LOUTPUT: DB "OUTPUT    "
MR_NAMES:
MR_NAME_ACS: DB "> ACS                           "
MR_NAME_ASN: DB "> ASN                           "
MR_NAME_ATN: DB "> ATN                           "
MR_NAME_COS: DB "> COS                           "
MR_NAME_EXP: DB "> EXP                           "
MR_NAME_LGT: DB "> LGT                           "
MR_NAME_LOG: DB "> LOG                           "
MR_NAME_SIN: DB "> SIN                           "
MR_NAME_SQR: DB "> SQR                           "
MR_NAME_TAN: DB "> TAN                           "
; Extend only the display/selection table. Original 0..9 ABI and ALL order
; remain untouched; indexes 10..18 mirror MR_XNAMES candidate order.
MR_NAME_SQ: DB "> SQ                            "
MR_NAME_PI: DB "> PI                            "
MR_NAME_FIX: DB "> FIX                           "
MR_NAME_ADD: DB "> ADD                           "
MR_NAME_MUL: DB "> MUL                           "
MR_NAME_SUB: DB "> SUB                           "
MR_NAME_RD: DB "> RND12                         "
MR_NAME_INC: DB "> INC                           "
MR_NAME_DIV: DB "> DIV                           "
MR_NAME_CNVR: DB "> CNVR                          "
MR_NAME_B2BCD: DB "> B2BCD                         "
MR_NAME_CMP: DB "> CMP                           "
MR_NAME_POWER: DB "> POWER                         "
; r018 pending entries 15..22 in canonical order. Type-specific host
; references are descriptive until each numeric comparator is qualified.
MR_PEND_INPUTS:
MR_P_IN0: DB "5 - 2       "
MR_P_IN1: DB "7 round     "
MR_P_IN2: DB "7 + 1       "
MR_P_IN3: DB "8 / 2       "
MR_P_IN4: DB "i16:123     "
MR_P_IN5: DB "i16:123     "
MR_P_IN6: DB "two B9      "
MR_P_IN7: DB "two B9      "
MR_PEND_ORACLES:
MR_P_OR0: DB "ORACLE 3                        "
MR_P_OR1: DB "ORACLE 7                        "
MR_P_OR2: DB "ORACLE 8                        "
MR_P_OR3: DB "ORACLE 4                        "
MR_P_OR4: DB "ORACLE B9(123)                  "
MR_P_OR5: DB "ORACLE BCD(123)                 "
MR_P_OR6: DB "CMP(2,3) CARRY->1               "
MR_P_OR7: DB "POWER(2,3) = 8                  "
MR_HEADS:
MR_HEAD_ACS: DB "B9 r014 / ACS 0.5               "
MR_HEAD_ASN: DB "B9 r014 / ASN 0.5               "
MR_HEAD_ATN: DB "B9 r014 / ATN 2                 "
MR_HEAD_COS: DB "B9 r014 / COS 60                "
MR_HEAD_EXP: DB "B9 r014 / EXP 1                 "
MR_HEAD_LGT: DB "B9 r014 / LGT 2                 "
MR_HEAD_LOG: DB "B9 r014 / LOG 2                 "
MR_HEAD_SIN: DB "B9 r014 / SIN 30                "
MR_HEAD_SQR: DB "B9 r014 / SQR 7                 "
MR_HEAD_TAN: DB "B9 r014 / TAN 30                "
MR_ORACLES:
MR_ORA_ACS: DB "ORACLE 60.0000000000000 DEG     "
MR_ORA_ASN: DB "ORACLE 30.0000000000000 DEG     "
MR_ORA_ATN: DB "ORACLE 63.4349488229220 DEG     "
MR_ORA_COS: DB "ORACLE 0.500000000000000        "
MR_ORA_EXP: DB "ORACLE 2.71828182845905         "
MR_ORA_LGT: DB "ORACLE 0.301029995663981        "
MR_ORA_LOG: DB "ORACLE 0.693147180559945        "
MR_ORA_SIN: DB "ORACLE 0.500000000000000        "
MR_ORA_SQR: DB "ORACLE 2.64575131106459         "
MR_ORA_TAN: DB "ORACLE 0.577350269189626        "