PAGE 01 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 002 ORG :EC00 003 * 004 * 005 * 006 ************************ 007 * FIXED MULTIPLICATION * 008 ************************ 009 * 010 * Multiplies a mantissa in registers C,D,E with 011 * the mantissa of a number in the MACC. The result 012 * is in B,C,D,E (binary point left of B). 013 * 014 * Used for multiplication of mantissa's in a 015 * FPT multiplication. 016 * 017 * Exit: AFHL corrupted. 018 * 019 EC00 79 MULX MOV A,C ) 020 EC01 32DD00 STA :00DD ) Mantissa from CDE into 021 EC04 62 MOV H,D ) 00DD, 00DC, 00DB 022 EC05 6B MOV L,E ) 023 EC06 22DB00 SHLD :00DB ) 024 EC09 AF XRA A 025 EC0A 57 MOV D,A ) 026 EC0B 4F MOV C,A ) Clear ABCD 027 EC0C 47 MOV B,A ) 028 EC0D 3AD800 LDA :00D8 Get lobyte MACC mantissa 029 EC10 CD1CEC CALL :EC1C Multiply 030 EC13 3AD700 LDA :00D7 Get next byte MACC mantissa 031 EC16 CD1CEC CALL :EC1C Multiply 032 EC19 3AD600 LDA :00D6 Get hibyte MACC mantissa 033 034 * Prepare multiplication: 035 036 EC1C 6A L1E203 MOV L,D 037 EC1D 59 MOV E,C 038 EC1E 50 MOV D,B 039 EC1F 47 MOV B,A Byte from MACC in B 040 EC20 AF XRA A 041 EC21 4F MOV C,A 042 EC22 90 SUB B 043 EC23 DA29EC JC :EC29 Then multiply 044 EC26 4A MOV C,D 045 EC27 53 MOV D,E 046 EC28 C9 RET 047 048 * Multiply (product in BDCE): 049 050 EC29 7D L1E204 MOV A,L 051 EC2A 8F ADC A 052 EC2B C8 RZ Abort if 2*L+CY=0 053 EC2C 6F MOV L,A Else update L 054 EC2D CD48EB CALL :EB48 Shift BCDE 1 bit left 055 EC30 D229EC JNC :EC29 Again if no overflow 056 EC33 3ADB00 LDA :00DB 057 EC36 83 ADD E 058 EC37 5F MOV E,A E=E+(00DB) 059 EC38 3ADC00 LDA :00DC 060 EC3B 8A ADC D 061 EC3C 57 MOV D,A D=D+(00DC)+CY 062 EC3D 3ADD00 LDA :00DD 063 EC40 89 ADC C PAGE 02 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 064 EC41 4F MOV C,A C=C+(00DD)+CY 065 EC42 D229EC JNC :EC29 Again if no overflow 066 EC45 04 INR B If overflow: B=B+1 067 EC46 B7 ORA A Clear CY 068 EC47 C329EC JMP :EC29 Again 069 * 070 ****************** 071 * FIXED DIVISION * 072 ****************** 073 * 074 * Divides a mantissa in registers C,D,E by the 075 * mantissa of the number in the MACC. The result 076 * is in B,C,D and the msb of E. The remainder is 077 * in the rest of E and in HL. 078 * 079 * Used to divide mantissa's in a FPT division. 080 * 081 * Exit: AF corrupted. 082 * CY=1: Overflow in adjusting exponents. 083 * CY=0: O.K. 084 * 085 EC4A 21D800 DIVX LXI H,:00D8 Addr lobyte MACC 086 EC4D 7E MOV A,M ) 087 EC4E 93 SUB E ) 088 EC4F 77 MOV M,A ) 089 EC50 2B DCX H ) Mantissa MACC = 090 EC51 7E MOV A,M ) CDE - mantissa MACC 091 EC52 9A SBB D ) 092 EC53 77 MOV M,A ) 093 EC54 2B DCX H ) 094 EC55 7E MOV A,M ) 095 EC56 99 SBB C ) 096 EC57 77 MOV M,A ) 097 EC58 21DD00 LXI H,:00DD Addr save area 098 EC5B 37 STC 099 EC5C 79 MOV A,C ) 100 EC5D 1F RAR ) 101 EC5E 77 MOV M,A ) 102 EC5F 2B DCX H ) 103 EC60 7A MOV A,D ) 00DD,00DC,00DB = 104 EC61 1F RAR ) CDE SHR 1 with msb C=1 105 EC62 77 MOV M,A ) 106 EC63 2B DCX H ) 107 EC64 7B MOV A,E ) 108 EC65 1F RAR ) 109 EC66 77 MOV M,A ) 110 EC67 2B DCX H 111 EC68 0600 MVI B,:00 112 EC6A 78 MOV A,B ) 113 EC6B 1F RAR ) 114 EC6C 77 MOV M,A ) 00DA =00 or 80, depending 115 ) on result RAR 116 EC6D 21D600 LXI H,:00D6 117 EC70 7E MOV A,M ) 118 EC71 23 INX H ) Get mantissa MACC in ADE 119 EC72 56 MOV D,M ) 120 EC73 23 INX H ) 121 EC74 5E MOV E,M ) 122 EC75 B7 ORA A 123 EC76 FAC4EC JM :ECC4 Jump if normalised 124 EC79 CDD9EB CALL :EBD9 Incr FPT exponent 125 EC7C D8 RC Abort if overflow PAGE 03 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 126 EC7D 6B MOV L,E ) 127 EC7E 62 MOV H,D ) Remainder in EHL 128 EC7F 5F MOV E,A ) 129 EC80 1601 MVI D,:01 130 EC82 48 MOV C,B 131 EC83 C5 L1E206 PUSH B 132 EC84 44 MOV B,H 133 EC85 4D MOV C,L 134 EC86 21DA00 LXI H,:00DA 135 EC89 AF XRA A 136 EC8A 96 SUB M 137 EC8B 23 INX H 138 EC8C 79 MOV A,C 139 EC8D 9E SBB M 140 EC8E 4F MOV C,A 141 EC8F 23 INX H 142 EC90 78 MOV A,B 143 EC91 9E SBB M 144 EC92 47 MOV B,A 145 EC93 23 INX H 146 EC94 7B MOV A,E 147 EC95 9E SBB M 148 EC96 5F MOV E,A 149 EC97 69 MOV L,C 150 EC98 60 MOV H,B 151 EC99 C1 POP B 152 EC9A 3ADA00 L1E207 LDA :00DA 153 EC9D 07 RLC 154 EC9E 78 MOV A,B 155 EC9F 17 RAL 156 ECA0 3F CMC 157 ECA1 D0 RNC 158 ECA2 1F RAR 159 ECA3 7D MOV A,L 160 ECA4 17 RAL 161 ECA5 6F MOV L,A 162 ECA6 7C MOV A,H 163 ECA7 17 RAL 164 ECA8 67 MOV H,A 165 ECA9 CD48EB CALL :EB48 Shift BCDE left 1 bit 166 ECAC 7A MOV A,D 167 ECAD 0F RRC 168 ECAE DA83EC JC :EC83 169 ECB1 C5 L1E208 PUSH B 170 ECB2 44 MOV B,H 171 ECB3 4D MOV C,L 172 ECB4 2ADB00 LHLD :00DB 173 ECB7 09 DAD B 174 ECB8 3ADD00 LDA :00DD 175 ECBB 8B ADC E 176 ECBC 5F MOV E,A 177 ECBD C1 POP B 178 ECBE 3ADA00 LDA :00DA 179 ECC1 C39DEC JMP :EC9D 180 ECC4 6B L1E209 MOV L,E 181 ECC5 62 MOV H,D 182 ECC6 5F MOV E,A 183 ECC7 50 MOV D,B 184 ECC8 48 MOV C,B 185 ECC9 C3B1EC JMP :ECB1 186 * 187 * PAGE 04 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 188 *********************************** 189 * AMD: ISSUE COMMAND TO MATH.CHIP * 190 *********************************** 191 * 192 * Entry: HL points to command. 193 * Exit: HL updated, A corrupted, BCDEF preserved. 194 * 195 ECCC 7E MPT15 MOV A,M Get command 196 ECCD 23 INX H 197 ECCE 3202FB STA :FB02 Issue cmd to math.chip 198 ECD1 C9 RET 199 * 200 ****************************** 201 * AMD: TURN OFF ERROR STATUS * 202 ****************************** 203 * 204 * Exit: All registers preserved. 205 * 206 ECD2 F5 MPT16 PUSH PSW 207 ECD3 AF XRA A 208 ECD4 3202FB STA :FB02 Cmd math.chip = 0 209 ECD7 F1 POP PSW 210 ECD8 C9 RET 211 * 212 **************************************** 213 * AMD: LOAD 16-BIT DATA INTO MATH.CHIP * 214 **************************************** 215 * 216 * Entry: 1st byte in A, 2nd on stack. 217 * 218 ECD9 3200FB MPT17 STA :FB00 Load 1st byte in math.chip 219 ECDC F1 POP PSW 220 ECDD 3200FB STA :FB00 Load data in math.chip 221 ECE0 C9 RET 222 * 223 ************************** 224 * part of 'IAND' (1E32C) * 225 ************************** 226 * 227 ECE1 CD8CE3 L1E213 CALL :E38C Copy MACC into EBCA 228 ECE4 CD35E3 CALL :E335 Run IAND 229 ECE7 C385E3 JMP :E385 Copy ABCD into MACC 230 * 231 ************************* 232 * part of 'IOR' (1E345) * 233 ************************* 234 * 235 ECEA CD8CE3 L1E214 CALL :E38C Copy MACC into EBCA 236 ECED CD4CE3 CALL :E34C Run IOR 237 ECF0 C385E3 JMP :E385 Copy ABCD into MACC 238 * 239 ************************** 240 * part of 'IXOR' (1E35C) * 241 ************************** 242 * 243 ECF3 CD8CE3 L1E215 CALL :E38C Copy MACC into EBCA 244 ECF6 CD63E3 CALL :E363 Run IXOR 245 ECF9 C385E3 JMP :E385 Copy ABCD into MACC 246 * 247 ***************************************** 248 * COPY MACC INTO REGISTERS A,B,C,D: CMA * 249 ***************************************** PAGE 05 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 250 * 251 * Part of 1E373. 252 * 253 ECFC CD33E1 L1E216 CALL :E133 Copy MACC into ABCD 254 ECFF 2F CMA Compl exponent byte 255 ED00 C9 RET 256 * 257 ************************************ 258 * COPY MACC INTO REGISTERS E,B,C,A * 259 ************************************ 260 * 261 * Part of 1E38C. 262 * 263 ED01 CD33E1 L1E217 CALL :E133 Copy MACC into ABCD 264 ED04 5F IGP10 MOV E,A Exp in E 265 ED05 C38FE3 JMP :E38F Copy BCDE into EBCA 266 * 267 ************************************ 268 * COPY MACC INTO REGISTERS B,C,D,E * 269 ************************************ 270 * 271 * Part of SHR (1E398) and SHL (1E3A5). 272 * Tests if the value of a INT operand in memory is 273 * bigger than 32 (nr of bits for a mantissa). 274 * If not, the contents of the MACC is copied 275 * into the registers BCDE. If the number is too 276 * big, the registers BCDE are cleared. 277 * 278 * Entry: HL points to INT operand in memory. 279 * 280 ED08 CDB2E3 L1E219 CALL :E3B2 Test if operand > 31; if 281 true: clear ABCDE 282 ED0B CCD6E3 CZ :E3D6 If OK: nr in A, contents 283 MACC into BCDE 284 ED0E C9 RET 285 * 286 ********************************************* 287 * COPY CONTENTS MACC INTO REGISTERS B,C,D,E * 288 ********************************************* 289 * 290 * Entry L1E220: Not used. 291 * Entry GBC10 : Copy ABCD into BCDE. 292 * 293 ED0F F5 L1E220 PUSH PSW 294 ED10 CD6FE5 CALL :E56F Copy MACC into ABCD 295 * 296 ED13 5A GBC10 MOV E,D ) 297 ED14 51 MOV D,C ) Copy ABCD into BCDE 298 ED15 48 MOV C,B ) 299 ED16 47 MOV B,A ) 300 ED17 F1 POP PSW 301 ED18 C9 RET 302 * 303 ************* 304 * AMD: IAND * 305 ************* 306 * 307 * MTOS = MTOS IAND MEM. 308 * 309 * Entry: HL points to operand in memory. 310 * Exit: All registers preserved. 311 * PAGE 06 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 312 ED19 F5 ZIAND PUSH PSW 313 ED1A C5 PUSH B 314 ED1B D5 PUSH D 315 ED1C E5 PUSH H 316 ED1D CD4FED CALL :ED4F Copy MTOS into EBCA 317 ED20 CD35E3 CALL :E335 Run IAND 318 ED23 C33DED JMP :ED3D Result into MTOS 319 * 320 ************ 321 * AMD: IOR * 322 ************ 323 * 324 * MTOS = MTOS IOR MEM. 325 * 326 * Entry: HL points to operand in memory. 327 * Exit: All registers preserved. 328 * 329 ED26 F5 ZIOR PUSH PSW 330 ED27 C5 PUSH B 331 ED28 D5 PUSH D 332 ED29 E5 PUSH H 333 ED2A CD4FED CALL :ED4F Copy MTOS into EBCA 334 ED2D CD4CE3 CALL :E34C Run IOR 335 ED30 C33DED JMP :ED3D Result into MTOS 336 * 337 ************* 338 * AMD: IXOR * 339 ************* 340 * 341 * MTOS = MTOS IXOR MEM. 342 * 343 * Entry: HL points to operand in memory. 344 * Exit: All registers preserved. 345 * 346 ED33 F5 ZIXOR PUSH PSW 347 ED34 C5 PUSH B 348 ED35 D5 PUSH D 349 ED36 E5 PUSH H 350 ED37 CD4FED CALL :ED4F Copy MTOS into EBCA 351 ED3A CD63E3 CALL :E363 Run IXOR; result in ABCD 352 ED3D CD5FE5 ZORT1 CALL :E55F Copy ABCD into MTOS 353 ED40 C34DC1 JMP :C14D Popall, ret 354 * 355 ************* 356 * AMD: INOT * 357 ************* 358 * 359 * MTOS = INOT (MTOS). 360 * 361 * Exit: All registers preserved. 362 * 363 * REMARK: Wrong routine: MTOS is made -MTOS, 364 * and then 1 is added. So result is 365 * INOT (MTOS)+2. 366 * Correct would be: Add -1. 367 * 368 ED43 CD22E5 ZINOT CALL :E522 Change sign MTOS (INT) 369 ED46 E5 PUSH H 370 ED47 2120C4 LXI H,:C420 Addr INT (1) 371 ED4A CDF4E4 CALL :E4F4 MTOS = - MTOS + 1 372 ED4D E1 POP H 373 ED4E C9 RET PAGE 07 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 374 * 375 ***************************************** 376 * AMD: COPY MTOS INTO REGISTERS E,B,C,A * 377 ***************************************** 378 * 379 ED4F CD6FE5 ZIGTP CALL :E56F Copy MTOS into ABCD 380 ED52 C304ED JMP :ED04 Copy ABCD into EBCA 381 * 382 ************ 383 * AMD: SHR * 384 ************ 385 * 386 * Shifts MTOS right MEM positions. 387 * 388 * Entry: HL points to INT number in memory. 389 * Exit: All registers preserved. 390 * 391 ED55 F5 ZSHR PUSH PSW 392 ED56 C5 PUSH B 393 ED57 D5 PUSH D 394 ED58 E5 PUSH H 395 ED59 CDB2E3 CALL :E3B2 Check value of MEM. Value in 396 A. Clear ABCDE if too big 397 ED5C CC7CED CZ :ED7C Else: Copy MTOS in BCDE 398 ED5F CD55EB CALL :EB55 Shift BCDE right A positions 399 ED62 78 ZRREG MOV A,B ) 400 ED63 41 MOV B,C ) 401 ED64 4A MOV C,D ) Copy BCDE into ABCD 402 ED65 53 MOV D,E ) 403 ED66 CD5FE5 CALL :E55F Copy ABCD into MTOS 404 ED69 C34DC1 JMP :C14D Popall, ret 405 * 406 ************ 407 * AMD: SHL * 408 ************ 409 * 410 * Shifts MTOS left MEM positions. 411 * 412 * Entry: HL points to INT number in memory. 413 * Exit: All registers preserved. 414 * 415 ED6C F5 ZSHL PUSH PSW 416 ED6D C5 PUSH B 417 ED6E D5 PUSH D 418 ED6F E5 PUSH H 419 ED70 CDB2E3 CALL :E3B2 Test value of MEM. Value in 420 A. Clear ABCDE if too big 421 ED73 CC7CED CZ :ED7C If OK: Copy MTOS into BCDE 422 ED76 CD39EB CALL :EB39 Shift BCDE left A positions 423 ED79 C362ED JMP :ED62 Copy BCDE into MTOS 424 * 425 ***************************************** 426 * AMD: COPY MTOS INTO REGISTERS B,C,D,E * 427 ***************************************** 428 * 429 * Exit: AHL preserved. 430 * 431 ED7C F5 ZGBCDE PUSH PSW 432 ED7D CD6FE5 CALL :E56F Copy MTOS into ABCD 433 ED80 C313ED JMP :ED13 Copy ABCD into BCDE 434 * 435 * PAGE 08 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 436 *********************************************** 437 * CHECK IF CONTENTS REGISTERS B,C,D,E IS ZERO * 438 *********************************************** 439 * 440 * Exit: Z=1: Contents BCDE is zero. 441 * BCDEHL preserved. 442 * 443 ED83 78 L1E232 MOV A,B 444 ED84 B1 ORA C 445 ED85 B2 ORA D 446 ED86 B3 ORA E 447 ED87 C9 RET 448 * 449 ****************************************** 450 * EVT. NEGATE CONTENTS REGISTERS B,C,D,E * 451 ****************************************** 452 * 453 * If S=1: Contents BCDE is negated. Overflow 454 * exit if negation not possible. 455 * On exit, flags are set on contents entry A. 456 * 457 ED88 F5 L1E233 PUSH PSW 458 ED89 FCC9E3 CM :E3C9 Evt negate BCDE 459 ED8C F1 POP PSW 460 ED8D B7 ORA A 461 ED8E C9 RET 462 * 463 **************** 464 * SIGN COMPARE * 465 **************** 466 * 467 * Entry: HL: Points to divisor. 468 * Exit: B: Exponent MACC. 469 * F: Set on XOR of exp bytes MACC and MEM. 470 * S=1 if difference in sign. 471 * 472 ED8F 3AD500 L1E234 LDA :00D5 Get exp byte MACC 473 ED92 47 MOV B,A in B 474 ED93 AE XRA M XOR with exp byte MEM 475 ED94 C9 RET 476 * 477 ********************************** 478 * AMD: GET STATUS BITS MATH.CHIP * 479 ********************************** 480 * 481 * Exit: A: Status. 482 * FBCDEHL preserved. 483 * 484 ED95 CD2DE5 M4STAT CALL :E52D Operate immediate 485 ED98 37 DATA :37 Push MTOS 486 ED99 CD2DE5 CALL :E52D Operate immediate 487 ED9C 38 DATA :38 Pop MTOS 488 ED9D 3A02FB LDA :FB02 Get status math.chip 489 EDA0 C9 RET 490 * 491 ************** 492 * AMD: POWER * 493 ************** 494 * 495 * MTOS = MTOS ^ MEM. 496 * 497 * Entry: HL points to power in memory. PAGE 09 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 498 * Exit: AF corrupted, BCDEHL preserved. 499 * 500 EDA1 CD95ED ZPWR CALL :ED95 Get status math.chip 501 EDA4 E620 ANI :20 MTOS empty ? 502 EDA6 C0 RNZ Abort if not 503 EDA7 C3ACE4 JMP :E4AC Run PWR routine 504 * 505 **************** 506 * FPT ADDITION * 507 **************** 508 * 509 * For FPT values: MACC = MACC + MEM. 510 * 511 * Entry: HL points to FPT number in memory. 512 * Exit: All registers preserved. 513 * 514 EDAA F5 XFADD PUSH PSW 515 EDAB C5 PUSH B 516 EDAC D5 PUSH D 517 EDAD E5 PUSH H 518 EDAE CD72EA CALL :EA72 MACC = MACC + MEM 519 EDB1 C34DC1 JMP :C14D Popall, ret 520 * 521 ******************* 522 * FPT SUBTRACTION * 523 ******************* 524 * 525 * For FPT values: MACC = MACC - MEM. 526 * 527 * Entry: HL points to FPT number in memory. 528 * Exit: All registers preserved. 529 * 530 EDB4 F5 XFSUB PUSH PSW 531 EDB5 C5 PUSH B 532 EDB6 D5 PUSH D 533 EDB7 E5 PUSH H 534 EDB8 CD6DEA CALL :EA6D MACC = MACC - MEM 535 EDBB C34DC1 JMP :C14D Popall, ret 536 * 537 EDBE FF DATA :FF 538 EDBF FF DATA :FF 539 * 540 *************************************** 541 * SAVEA: PREPARE SAVING STRING ARRAYS * 542 *************************************** 543 * 544 * Reserves space in free RAM for a string, composed 545 * from all string elements of a string array. 546 * The array elements are moved into this area. 547 * If not sufficient free RAM available, 'OUT OF 548 * MEMORY' error occurs. 549 * 550 * Entry: DE: Length array to be saved. 551 * HL: Pointer to array. 552 * Exit: DE: Length of block in free RAM. 553 * HL: Startaddress block in free RAM. 554 * AF corrupted, BC preserved. 555 * 556 EDC0 C5 MSA PUSH B 557 EDC1 42 MOV B,D ) Length array in BC 558 EDC2 4B MOV C,E ) 559 EDC3 EB XCHG Varptr in DE PAGE 10 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 560 EDC4 2AA302 LHLD :02A3 Get startaddr free RAM space 561 EDC7 E5 PUSH H and save it on stack 562 EDC8 EB XCHG and in DE; HL is array pntr 563 EDC9 78 MOV A,B ) 564 EDCA CDFDED CALL :EDFD ) Save length array in 1st 565 EDCD 79 MOV A,C ) location free RAM 566 EDCE CDFDED CALL :EDFD ) 567 EDD1 78 L1E240 MOV A,B 568 EDD2 B1 ORA C 569 EDD3 CAE5ED JZ :EDE5 Abort if ready 570 EDD6 7E MOV A,M 571 EDD7 23 INX H 572 EDD8 E5 PUSH H Addr array pntr on stack 573 EDD9 66 MOV H,M ) Addr string element in HL 574 EDDA 6F MOV L,A ) 575 EDDB CDEDED CALL :EDED Store element in free RAM 576 EDDE E1 POP H Get array pntr back 577 EDDF 23 INX H Pnts to next element 578 EDE0 0B DCX B ) Decr length still to be 579 EDE1 0B DCX B ) done 580 EDE2 C3D1ED JMP :EDD1 Continu 581 582 * If ready: 583 584 EDE5 E1 L1E241 POP H Get startaddr new string 585 EDE6 EB XCHG in DE; HL is end used area 586 EDE7 CD1ADE CALL :DE1A Calc length of string 587 EDEA EB XCHG in DE 588 EDEB C1 POP B 589 EDEC C9 RET 590 * 591 * COPY STRING ELEMENT INTO FREE RAM: 592 * 593 EDED C5 L1E242 PUSH B 594 EDEE 46 MOV B,M Get length of string in B 595 EDEF 7E L1E243 MOV A,M Byte in A 596 EDF0 23 INX H Pnts to next byte 597 EDF1 CDFDED CALL :EDFD Copy byte into free RAM 598 EDF4 78 MOV A,B ) 599 EDF5 D601 SUI :01 ) Update length 600 EDF7 47 MOV B,A ) 601 EDF8 D2EFED JNC :EDEF Next byte if not ready 602 EDFB C1 POP B 603 EDFC C9 RET 604 * 605 * STORE STRINGDATA IN FREE RAM SPACE: 606 * 607 * Moves 1 byte of a string array element into the 608 * free RAM space and checks for 'OUT OF MEMORY'. 609 * 610 * Entry: DE: Points to 1st free address in RAM. 611 * A: Byte to be moved. 612 * Exit: DE updated, BCHL preserved. 613 * 614 EDFD 12 L1E244 STAX D Store byte in free RAM 615 EDFE 13 INX D Update RAM pntr 616 EDFF E5 PUSH H 617 EE00 2AA502 LHLD :02A5 Get addr bottom screen RAM 618 EE03 CD14DE CALL :DE14 End free RAM reached ? 619 EE06 DA10DA JC :DA10 Then run error 'OUT OF 620 MEMORY' 621 EE09 E1 POP H PAGE 11 DAI FIRMWARE 1EC00-1EE0A V1.0 Rev.1 622 EE0A C9 RET 623 * 624 * 625 * 626 EE0B END *************************** * S Y M B O L T A B L E * *************************** DIVX EC4A GBC10 ED13 IGP10 ED04 L1E203 EC1C L1E204 EC29 L1E206 EC83 L1E207 EC9A L1E208 ECB1 L1E209 ECC4 L1E213 ECE1 L1E214 ECEA L1E215 ECF3 L1E216 ECFC L1E217 ED01 L1E219 ED08 L1E220 ED0F L1E232 ED83 L1E233 ED88 L1E234 ED8F L1E240 EDD1 L1E241 EDE5 L1E242 EDED L1E243 EDEF L1E244 EDFD M4STAT ED95 MPT15 ECCC MPT16 ECD2 MPT17 ECD9 MSA EDC0 MULX EC00 XFADD EDAA XFSUB EDB4 ZGBCDE ED7C ZIAND ED19 ZIGTP ED4F ZINOT ED43 ZIOR ED26 ZIXOR ED33 ZORT1 ED3D ZPWR EDA1 ZRREG ED62 ZSHL ED6C ZSHR ED55