Elite on the BBC Micro and NES

# Maths (Arithmetic): FMLTU

## [Acorn Electron version]

```       Name: FMLTU                                                   [Show more]
Type: Subroutine
Category: Maths (Arithmetic)
Summary: Calculate A = A * Q / 256
Context: See this subroutine in context in the source code
Variations: See code variations for this subroutine in the different versions
References: This subroutine is called as follows:
* DOEXP calls FMLTU
* LL51 calls FMLTU
* LL9 (Part 5 of 12) calls FMLTU
* MVEIT (Part 3 of 9) calls FMLTU

Do the following multiplication of two unsigned 8-bit numbers, returning only
the high byte of the result:

(A ?) = A * Q

or, to put it another way:

A = A * Q / 256

Returns:

C flag               The C flag is set

.FMLTU

EOR #%11111111         \ Flip the bits in A, set the C flag and rotate right,
SEC                    \ so the C flag now contains bit 0 of A inverted, and P
ROR A                  \ contains A inverted and shifted right by one, with bit
STA P                  \ 7 set to a 1. We can now use P as our source of bits
\ to shift right, just as in MU11, just with the logic
\ reversed

LDA #0                 \ Set A = 0 so we can start building the answer in A

.MUL3

BCS MU7                \ If C (i.e. the next bit from P) is set, do not do the
\ to just do the shifts

\
\   A = A + Q + C
\     = A + Q

ROR A                  \ Shift A right to catch the next digit of our result.
\ If we were interested in the low byte of the result we
\ would want to save the bit that falls off the end, but
\ we aren't, so we can ignore it

LSR P                  \ Shift P right to fetch the next bit for the
\ calculation into the C flag

BNE MUL3               \ Loop back to MUL3 if P still contains some set bits
\ (so we loop through the bits of P until we get to the
\ 1 we inserted before the loop, and then we stop)

\ If we get here then the C flag is set as we just
\ rotated a 1 out of the right end of P

RTS                    \ Return from the subroutine

.MU7

LSR A                  \ Shift A right to catch the next digit of our result,
\ pushing a 0 into bit 7 as we aren't adding anything
\ here (we can't use a ROR here as the C flag is set, so
\ a ROR would push a 1 into bit 7)

LSR P                  \ Fetch the next bit from P into the C flag

BNE MUL3               \ Loop back to MUL3 if P still contains some set bits
\ (so we loop through the bits of P until we get to the
\ 1 we inserted before the loop, and then we stop)

\ If we get here then the C flag is set as we just
\ rotated a 1 out of the right end of P

RTS                    \ Return from the subroutine
```