8-Bit Software

The BBC and Master Computer Public Domain Library

Back to 8BS Or Back to Disassembly


Page Last Altered:

A6CF Floating-Point Multiplication

Submitted by Steve Fewell

Routine:fpmult
Name: Floating-Point Multiplication
Starting Address: &A6CF
Entry criteria: &4A and &4B (the argp) point to a 5-byte Floating-Point variable to multiply the FWB by.
Exit: The FWA contains the normalised result [FWA=argp variable * FWA].

Description:

If FWA is zero, then the result is zero, so just exit.

Unpack the argp variable to the FWB.
If the FWB is zero then call FWA clear routine to return with a zero result.

Add the FWB exponent to the FWA exponent and subtract #&7F (to account for the #&80 offset)
The FWA overflow byte will contain any overflow that occurred.
This gives the results exponent value, so store it in the FWA exponent.

EOR the FWB sign with the FWA sign byte to obtain the sign of the result and store results
sign in the FWA sign byte. (i.e. neg_num * neg_num = pos_num, pos_num * pos_num = pos_num
neg_num * pos_num = neg_num, & pos_num * neg_num = neg_num).

Store X on the stack during the routine (as X contains the next operator?).
Move the FWA Mantissa to locations &42 to &45 (in reverse order), and clear out
FWA mantissa value (to zero). (i.e. &45 = &31; &44 = &32; &43 = &33; &42 = &34).
Zero The FWB Exponent, the FWB Sign and location &3A (these bytes form the leading zeros
during the multiplication.

(A735): Load the next byte (&42 for the first time, as Y = 0 and X = &FC; so load LSB of Mantissa first).
If the byte is not zero then perform the multiply operation with the byte (A705).
Repeat for all bytes (&42 to &45).
When complete, store any rounding in the FWA Rounding Byte, then if the FWA
Mantissa (Result) Byte 1 top bit is 0 then exit via the normalise FWA routine.
Otherwise, just exit as the number is already normalised.

(A705): Performing the multiplication for the current byte:
X is saved to the stack during this routine and retrived at the end, this is so that
the value of X - which is used in the byte loop (above) - is not overwritten.

The multiplication consists of the following steps:
1) Divide the FWB Mantissa by 2 [bytes &3D to &41]
2) Shift the top bit out of the FWA byte we are looking at (Either: &42, &43, &44 or &45, as the FWA Mantissa has been moved to these temporary locations).
--> If the top bit shifted out was 0 then look at the next byte (4).
--> If the top bit shifted out was 1 then add the FWB Mantissa to the results Mantissa (FWA)(?).
Add the corresponding FWB byte to Y [rounding value]. (?)
3) look at the next byte. When the top bit of all 4 bytes is processed then go back to A735 to work with
the next byte.

Example:
FWA = 718.456 [exp = 8A;Man 1 = B3; Man 2 = 9D; Man 3 = 2F; Man 4 = 1B]
FWB = 47.1173 [exp = 86;Man 1 = BC; Man 2 = 78; Man 3 = 1D; Man 4 = 7E]
Result should be 33851.7068888.

Add exponents: 8A + 86 - 7F = 91.

Move FWA to &45 to &42 and zero some fields, So:
?&45 = &B3 [Temp FWA Mantissa 1]
?&44 = &9D [Temp FWA Mantissa 2]
?&43 = &2F [Temp FWA Mantissa 3]
?&42 = &1B [Temp FWA Mantissa 4]
?&41 = &00 [FWB Rounding]
?&40 = &7E [FWB Mantissa 4]
?&3F = &1D [FWB Mantissa 3]
?&3E = &78 [FWB Mantissa 2]
?&3D = &BC [FWB Mantissa 1]
?&3C = &00
?&3B = &00
?&3A = &00

Process next byte [A735]
Y = 0
X = &FC
A = &1B [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 5E;?&3E = 3C;?&3F = 0E;?&40 = BF;?&41 = 00]
Multiply Byte (&46,X) by 2 [?&42] = &1B * 2 = &36
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &2F * 2 = &5E
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &9D * 2 = &3A
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40]. Y = &BF.
?&34 = ?&34 + &41,X [&3F] = &00 + &0E = &0E
?&33 = ?&33 + &40,X [&3E] = &00 + &3C = &3C
?&32 = ?&32 + &3F,X [&3D] = &00 + &5E = &5E
?&31 = ?&31 + &3E,X [&3C] = &00 + &00 = &00
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &B3 * 2 = &66
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41]. Y = &BF + &00 = &BF.
?&34 = ?&34 + &41,X [&40] = &0E + &BF = &CD
?&33 = ?&33 + &40,X [&3F] = &3C + &0E = &4A
?&32 = ?&32 + &3F,X [&3E] = &5E + &3C = &9A
?&31 = ?&31 + &3E,X [&3D] = &00 + &5E = &5E
A731: X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &BF
X = &FC
A = &36 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 2F;?&3E = 1E;?&3F = 07;?&40 = 5F;?&41 = 80]
Multiply Byte (&46,X) by 2 [?&42] = &36 * 2 = &6C
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &5E * 2 = &BC
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &3A * 2 = &74
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &66 * 2 = &CC
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &BF
X = &FC
A = &6C [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 17;?&3E = 8F;?&3F = 03;?&40 = AF;?&41 = C0]
Multiply Byte (&46,X) by 2 [?&42] = &6C * 2 = &D8
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &BC * 2 = &78
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = 03]. Y = &C2.
?&34 = ?&34 + &41,X [&3E] = &CD + &8F + 1 = &5D
?&33 = ?&33 + &40,X [&3D] = &4A + &17 + 1 = &62
?&32 = ?&32 + &3F,X [&3C] = &9A + &00 = &9A
?&31 = ?&31 + &3E,X [&3B] = &5E + &00 = &5E
A731: X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &74 * 2 = &E8
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &CC * 2 = &98
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = C0]. Y = &82.
?&34 = ?&34 + &41,X [&40] = &5D + &AF + 1 = &0D
?&33 = ?&33 + &40,X [&3F] = &62 + &03 + 1 = &66
?&32 = ?&32 + &3F,X [&3E] = &9A + &8F = &29
?&31 = ?&31 + &3E,X [&3D] = &5E + &17 + 1 = &76
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &03
X = &FC
A = &D8 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 0B;?&3E = C7;?&3F = 81;?&40 = D7;?&41 = E0]
Multiply Byte (&46,X) by 2 [?&42] = &D8 * 2 = &B0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = C7]. Y = &49.
?&34 = ?&34 + &41,X [&3D] = &0D + &0B + 1 = &19
?&33 = ?&33 + &40,X [&3C] = &66 + &00 = &66
?&32 = ?&32 + &3F,X [&3B] = &29 + &00 = &29
?&31 = ?&31 + &3E,X [&3A] = &76 + &00 = &76
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &78 * 2 = &F0
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &E8 * 2 = &D0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = D7]. Y = &20.
?&34 = ?&34 + &41,X [&3F] = &19 + &81 + 1 = &9B
?&33 = ?&33 + &40,X [&3E] = &66 + &C7 = &2D
?&32 = ?&32 + &3F,X [&3D] = &29 + &0B + 1 = &35
?&31 = ?&31 + &3E,X [&3C] = &76 + &00 = &76
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &98 * 2 = &30
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = E0]. Y = &00.
?&34 = ?&34 + &41,X [&40] = &9B + &D7 + 1 = &73
?&33 = ?&33 + &40,X [&3F] = &2D + &81 + 1 = &AF
?&32 = ?&32 + &3F,X [&3E] = &35 + &C7 = &FC
?&31 = ?&31 + &3E,X [&3D] = &76 + &0B = &81
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &00
X = &FC
A = &B0 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 05;?&3E = E3;?&3F = C0;?&40 = EB;?&41 = F0]
Multiply Byte (&46,X) by 2 [?&42] = &B0 * 2 = &60 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = E3]. Y = &E3.
?&34 = ?&34 + &41,X [&3D] = &73 + &05 + 0 = &78
?&33 = ?&33 + &40,X [&3C] = &AF + &00 = &AF
?&32 = ?&32 + &3F,X [&3B] = &FC + &00 = &FC
?&31 = ?&31 + &3E,X [&3A] = &81 + &00 = &81
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &F0 * 2 = &E0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = C0]. Y = &A3.
?&34 = ?&34 + &41,X [&3E] = &78 + &E3 + 1 = &5C
?&33 = ?&33 + &40,X [&3D] = &AF + &05 + 1 = &B5
?&32 = ?&32 + &3F,X [&3C] = &FC + &00 = &FC
?&31 = ?&31 + &3E,X [&3B] = &81 + &00 = &81
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &D0 * 2 = &A0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = EB]. Y = &8E.
?&34 = ?&34 + &41,X [&3F] = &5C + &C0 + 1 = &1D
?&33 = ?&33 + &40,X [&3E] = &B5 + &E3 + 1 = &99
?&32 = ?&32 + &3F,X [&3D] = &FC + &05 + 1 = &02
?&31 = ?&31 + &3E,X [&3C] = &81 + &00 + 1 = &82
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &30 * 2 = &60
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &8E
X = &FC
A = &60 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 02;?&3E = F1;?&3F = E0;?&40 = 75;?&41 = F8]
Multiply Byte (&46,X) by 2 [?&42] = &60 * 2 = &C0 (Carry 0)
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &E0 * 2 = &C0 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = E0]. Y = &6E.
?&34 = ?&34 + &41,X [&3E] = &1D + &F1 + 1 = &0F
?&33 = ?&33 + &40,X [&3D] = &99 + &02 + 1 = &9C
?&32 = ?&32 + &3F,X [&3C] = &02 + &00 = &02
?&31 = ?&31 + &3E,X [&3B] = &82 + &00 = &82
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &A0 * 2 = &40
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = 75]. Y = &E3.
?&34 = ?&34 + &41,X [&3F] = &0F + &E0 + 0 = &EF
?&33 = ?&33 + &40,X [&3E] = &9C + &F1 + 0 = &8D
?&32 = ?&32 + &3F,X [&3D] = &02 + &02 + 1 = &05
?&31 = ?&31 + &3E,X [&3C] = &82 + &00 + 0 = &82
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &60 * 2 = &C0
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &E3
X = &FC
A = &C0 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 01;?&3E = 78;?&3F = F0;?&40 = 3A;?&41 = FC]
Multiply Byte (&46,X) by 2 [?&42] = &C0 * 2 = &80 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = 78]. Y = &5B.
?&34 = ?&34 + &41,X [&3D] = &EF + &01 + 1 = &F1
?&33 = ?&33 + &40,X [&3C] = &8D + &00 + 0 = &8D
?&32 = ?&32 + &3F,X [&3B] = &05 + &00 = &05
?&31 = ?&31 + &3E,X [&3A] = &82 + &00 = &82
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &C0 * 2 = &80 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = F0]. Y = &4B.
?&34 = ?&34 + &41,X [&3E] = &F1 + &78 + 1 = &6A
?&33 = ?&33 + &40,X [&3D] = &8D + &01 + 1 = &8F
?&32 = ?&32 + &3F,X [&3C] = &05 + &00 = &05
?&31 = ?&31 + &3E,X [&3B] = &82 + &00 = &82
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &40 * 2 = &80
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &C0 * 2 = &80
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = FC]. Y = &47.
?&34 = ?&34 + &41,X [&40] = &6A + &3A + 1 = &A5
?&33 = ?&33 + &40,X [&3F] = &8F + &F0 + 0 = &7F
?&32 = ?&32 + &3F,X [&3E] = &05 + &78 + 1 = &7E
?&31 = ?&31 + &3E,X [&3D] = &82 + &01 + 0 = &83
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &09
X = &FC
A = &80 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 00;?&3E = BC;?&3F = 78;?&40 = 1D;?&41 = 7E]
Multiply Byte (&46,X) by 2 [?&42] = &80 * 2 = &00 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = BC]. Y = &03.
?&34 = ?&34 + &41,X [&3D] = &A5 + &00 + 1 = &A6
?&33 = ?&33 + &40,X [&3C] = &7F + &00 + 0 = &7F
?&32 = ?&32 + &3F,X [&3B] = &7E + &00 = &7E
?&31 = ?&31 + &3E,X [&3A] = &83 + &00 = &83
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &80 * 2 = &00 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = 78]. Y = &7B.
?&34 = ?&34 + &41,X [&3E] = &A6 + &BC + 0 = &62
?&33 = ?&33 + &40,X [&3D] = &7F + &00 + 1 = &80
?&32 = ?&32 + &3F,X [&3C] = &7E + &00 = &7E
?&31 = ?&31 + &3E,X [&3B] = &83 + &00 = &83
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &80 * 2 = &00 (carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = 1D]. Y = &98.
?&34 = ?&34 + &41,X [&3F] = &62 + &78 + 0 = &DA
?&33 = ?&33 + &40,X [&3E] = &80 + &BC + 0 = &3C
?&32 = ?&32 + &3F,X [&3D] = &7E + &00 + 1 = &7F
?&31 = ?&31 + &3E,X [&3C] = &83 + &00 + 0 = &83
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &80 * 2 = &00 (carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = 7E]. Y = &16.
?&34 = ?&34 + &41,X [&40] = &DA + &1D + 1 = &F8
?&33 = ?&33 + &40,X [&3F] = &3C + &78 + 0 = &B4
?&32 = ?&32 + &3F,X [&3E] = &7F + &BC + 0 = &3B
?&31 = ?&31 + &3E,X [&3D] = &83 + &00 + 1 = &84
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)


?&45, ?&44, ?&43 and ?&42 are all now zero, so we have our result in FWA: Exponent = 90 (after normalisation)
Mantissa 1 = &4 (minus &80 offset)
Mantissa 2 = &3B
Mantissa 3 = &B4
Mantissa 4 = &F8
Mantissa 5 = &16 (set from Y)
Decimal value = 33851.7069

I think this routine uses the "Binary Multiply - Repeated Shift and Add" method for multiplication.
This method is described below:
* Result = 0
* Repeat
*     Shift 2nd multiplicand left until rightmost digit is lined up with leftmost 1 in the
first multiplicand.
*     Add 2nd multiplicand in that position to the result.
*     Remove the 1 from the 1st multiplicand (done when the value is shifted left).
* Until 1st multiplicand is zero * the result has now been obtained


Disassembly for the Floating-Point Multiplication routine

A6CF 1 165 049 A5 31 LDA &31
A6D1   240 241 F0 F1 BEQ -15 --> &A6C4 [RTS]
A6D3   032 224 164 20 E0 A4 JSR &A4E0 Unpack (&4A, &4B) var to FWB
A6D6   240 220 F0 DC BEQ -36 --> &A6B4 Clear FWA
A6D8   024 18 CLC
A6D9 0 165 048 A5 30 LDA &30
A6DB e< 101 060 65 3C ADC &3C
A6DD &/ 038 047 26 2F ROL &2F
A6DF   233 127 E9 7F SBC#&7F
A6E1 0 133 048 85 30 STA &30
A6E3   176 002 B0 02 BCS 2 --> &A6E7
A6E5 / 198 047 C6 2F DEC &2F
A6E7 . 165 046 A5 2E LDA &2E
A6E9 E; 069 059 45 3B EOR &3B
A6EB . 133 046 85 2E STA &2E
A6ED   218 DA PHX
A6EE   162 248 A2 F8 LDX#&F8
A6F0   160 004 A0 04 LDY#&04
A6F2 9 181 057 B5 39 LDA &39,X
A6F4 t9 116 057 74 39 STZ &39,X
A6F6 A 153 065 000 99 41 00 STA &0041,Y
A6F9   232 E8 INX
A6FA   136 88 DEY
A6FB   208 245 D0 F5 BNE -11 --> &A6F2
A6FD d< 100 060 64 3C STZ &3C
A6FF d; 100 059 64 3B STZ &3B
A701 d: 100 058 64 3A STZ &3A
A703 0 128 048 80 30 BRA 48 --> &A735
A705   218 DA PHX
A706 F= 070 061 46 3D LSR &3D
A708 f> 102 062 66 3E ROR &3E
A70A f? 102 063 66 3F ROR &3F
A70C f@ 102 064 66 40 ROR &40
A70E fA 102 065 66 41 ROR &41
A710 F 022 070 16 46 ASL &46,X
A712   144 029 90 1D BCC 29 --> &A731
A714   024 18 CLC
A715   152 98 TYA
A716 uB 117 066 75 42 ADC &42,X
A718   168 A8 TAY
A719 4 165 052 A5 34 LDA &34
A71B uA 117 065 75 41 ADC &41,X
A71D 4 133 052 85 34 STA &34
A71F 3 165 051 A5 33 LDA &33
A721 u@ 117 064 75 40 ADC &40,X
A723 3 133 051 85 33 STA &33
A725 2 165 050 A5 32 LDA &32
A727 u? 117 063 75 3F ADC &3F,X
A729 2 133 050 85 32 STA &32
A72B 1 165 049 A5 31 LDA &31
A72D u> 117 062 75 3E ADC &3E,X
A72F 1 133 049 85 31 STA &31
A731   232 E8 INX
A732 0 048 220 30 DC BMI -36 --> &A710
A734   250 FA PLX
A735 F 181 070 B5 46 LDA &46,X
A737   208 204 D0 CC BNE -52 --> &A705
A739   232 E8 INX
A73A 0 048 249 30 F9 BMI -7 --> &A735
A73C   250 FA PLX
A73D 5 132 053 84 35 STY &35
A73F 1 165 049 A5 31 LDA &31
A741 0 048 129 30 81 BMI -127 --> &A6C4 [RTS]
A743 L 076 251 129 4C FB 81 JMP &81FB Normalise FWA

 


 Back to 8BS
Or