;Not sure what to do about these numerics
;Constants
PI       db 00h,80h,31h,41h,59h,26h,53h,58h,98h
SQRTPI   db 00h,80h,17h,72h,45h,38h,50h,90h,55h
EULER    db 00h,80h,27h,18h,28h,18h,28h,45h,90h
PHI      db 00h,80h,16h,18h,03h,39h,88h,74h,99h
SQRT2    db 00h,80h,14h,14h,21h,35h,62h,37h,31h
InitRandomSeed db 89h,86h,53h,48h,94h,49h

;#include "FPEx.z80"
FPOP3ExOP4:
   ld hl,OP3
   ld de,OP4
   jr FPDEExHL

FPOP2ExOP6:
   ld hl,OP2
   ld de,OP6
   jr FPDEExHL

FPOP2ExOP5:
   ld hl,OP2
   ld de,OP5
   jr FPDEExHL

FPOP2ExOP4:
   ld hl,OP2
   ld de,OP4
   jr FPDEExHL

FPOP2ExOP3:
   ld hl,OP2
   ld de,OP3
   jr FPDEExHL

FPOP1ExOP2:
   ld hl,OP2
FPOP1ExHL:
   ld de,OP1
FPDEExHL:
   ld b,9
FPOP1ExOP2_loop:
   ld c,(hl)
   ld a,(de)
   ld (hl),a
   ld a,c
   ld (de),a
   inc hl
   inc de
   djnz FPOP1ExOP2_loop
   ret

FPOP1ExOP3:
   ld hl,OP3
   jr FPOP1ExHL
FPOP1ExOP4:
   ld hl,OP4
   jr FPOP1ExHL
FPOP1ExOP5
   ld hl,OP5
   jr FPOP1ExHL
FPOP1ExOP6
   ld hl,OP6
   jr FPOP1ExHL
;#end "FPEx.z80
;#include "FPMov.z80"
FPOP3ToOP6:
   ld hl,OP3
   ld de,OP6
   jr FPMov9dehl

FPOP4ToOP2:
   ld hl,OP4
   ld de,OP2
   jr FPMov9dehl

FPOP4ToOP3:
   ld hl,OP4
   ld de,OP3
   jr FPMov9dehl

FPOP4ToOP1:
   ld hl,OP4
   ld de,OP1
   jr FPMov9dehl

FPOP4ToOP5:
   ld hl,OP4
   ld de,OP5
   jr FPMov9dehl

FPOP4ToOP6:
   ld hl,OP4
   ld de,OP6
   jr FPMov9dehl

FPOP5ToOP2:
   ld hl,OP5
   ld de,OP2
   jr FPMov9dehl

FPOP5ToOP3:
   ld hl,OP5
   ld de,OP3
   jr FPMov9dehl

FPOP5ToOP4:
   ld hl,OP5
   ld de,OP4
   jr FPMov9dehl

FPOP5ToOP1:
   ld hl,OP5
   ld de,OP1
   jr FPMov9dehl

FPOP5ToOP6:
   ld hl,OP5
   ld de,OP6
   jr FPMov9dehl

FPOP6ToOP2:
   ld hl,OP6
   ld de,OP2
   jr FPMov9dehl

FPOP6ToOP3:
   ld hl,OP6
   ld de,OP3
   jr FPMov9dehl

FPOP6ToOP4:
   ld hl,OP6
   ld de,OP4
   jr FPMov9dehl

FPOP6ToOP5:
   ld hl,OP6
   ld de,OP5
   jr FPMov9dehl

FPOP6ToOP1:
   ld hl,OP6
   ld de,OP1
   jr FPMov9dehl

FPOP1ToOP2:
   ld hl,OP1
   ld de,OP2
FPMov9dehl: ;I am aware of Mov9B... I want speed!
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ret

FPMov9ToOP1:
   ld de,OP1
   jr FPMov9dehl

FPOP1ToOP3:
   ld hl,OP1
   ld de,OP3
   jr FPMov9dehl


FPOP1ToOP4:
   ld hl,OP1
   ld de,OP4
   jr FPMov9dehl

FPOP1ToOP5:
   ld hl,OP1
   ld de,OP5
   jr FPMov9dehl

FPOP1ToOP6:
   ld hl,OP1
   ld de,OP6
   jr FPMov9dehl

FPOP2ToOP1:
   ld hl,OP2
   ld de,OP1
   jr FPMov9dehl

FPOP2ToOP3:
   ld hl,OP2
   ld de,OP3
   jr FPMov9dehl

FPOP2ToOP4:
   ld hl,OP2
   ld de,OP4
   jr FPMov9dehl

FPOP2ToOP5:
   ld hl,OP2
   ld de,OP5
   jr FPMov9dehl

FPOP2ToOP6:
   ld hl,OP2
   ld de,OP6
   jr FPMov9dehl

FPOP3ToOP2:
   ld hl,OP3
   ld de,OP2
   jr FPMov9dehl

FPOP3ToOP1:
   ld hl,OP3
   ld de,OP1
   jr FPMov9dehl

FPOP3ToOP4:
   ld hl,OP3
   ld de,OP4
   jr FPMov9dehl

FPOP3ToOP5:
   ld hl,OP3
   ld de,OP5
   jr FPMov9dehl

FPMov9ToOP2:
   ld de,OP2
;   jr FPMov9dehl_

FPFPMov9dehl_:
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ldi
   ret
;#end "FPMov.z80"
;#include "FPSet.z80"
FPSetOP4To1:
   ld a,10h
   jr FPSetOP4ToA

FPSetOP3To2:
   ld a,20h
   jr FPSetOP3ToA

FPSetOP3To1:
   ld a,10h
   jr FPSetOP3ToA

FPSetOP3To0:
   xor a
FPSetOP3ToA:
   ld hl,OP3
   jr FPSetOPToA

FPSetOP4To0:
   xor a
FPSetOP4ToA:
   ld hl,OP4
   jr FPSetOPToA

FPSetOP5To0:
   ld hl,OP5
   jr FPSetOPTo0

FPSetOP6To0:
   ld hl,OP6
   jr FPSetOPTo0

FPSetOP2To8:
   ld hl,OP2
   ld a,80h
   jr FPSetOPToA

FPSetOP2To60: ;I assume this is a useful value?
   call FPSetOP2To6
   ld hl,(OP2+1)
   inc (hl)
   ret

FPSetOP1To6:
   ld hl,OP1
   jr FPSetOP1To6_
FPSetOP2To6:
   ld hl,OP2
FPSetOP1To6_:
   ld a,60h
   jr FPSetOPToA

FPSetOP1To5:
   ld hl,OP1
   jr FPSetOP1To5_
FPSetOP2To5:
   ld hl,OP2
FPSetOP1To5_:
   ld a,50h
   jr FPSetOPToA

FPSetOP1To4:
   ld hl,OP1
   jr FPSetOP1To4_
FPSetOP2To4:
   ld hl,OP2
FPSetOP1To4_:
   ld a,40h
   jr FPSetOPToA

FPSetOP1To3:
   ld hl,OP1
   jr FPSetOP1To3_
FPSetOP2To3:
   ld hl,OP2
FPSetOP1To3_:
   ld a,30h
   jr FPSetOPToA

FPSetOP1To2:
   ld hl,OP1
   jr FPSetOP1To2_
FPSetOP2To2:
   ld hl,OP2
FPSetOP1To2_:
   ld a,20h
   jr FPSetOPToA

FPSetOP1To1:
   ld hl,OP1
   jr FPSetOP1To1_
FPSetOP2To1:
   ld hl,OP2
FPSetOP1To1_:
   ld a,10h
   jr FPSetOPToA

FPSetOP1To0:
   ld hl,OP1
   jr FPSetOPTo0
FPSetOP2To0:
   ld hl,OP2
FPSetOPTo0:
   xor a

FPSetOPToA:
   ld (hl),0
   inc hl
   ld (hl),80h
   inc hl
   ld (hl),a
   jr FPclearOP_6

FPclearOP:
   xor a
   ld (hl),a
   inc hl
   ld (hl),a
   inc hl
   ld (hl),a
FPclearOP_6:
   xor a
   inc hl
   ld (hl),a
   inc hl
   ld (hl),a
   inc hl
   ld (hl),a
   inc hl
   ld (hl),a
   inc hl
   ld (hl),a
   inc hl
   ld (hl),a
   ret
;#end "FPSet.z80
;#include "FPmisc.z80"
FPAbs:
   xor a
   ld a,(OP1)
   ret

FPRand: ;holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff
   call FPSetOP1To0
   ld hl,RandSeed
   ld de,OP1+1
   ldi
    ldi
    ldi
    ldi
    ldi
    ldi

   ld hl,FPrand_a
   call FPMov9ToOP2

   call FPMult

   ld hl,FPrand_c
   call FPMov9ToOP2

   call FPAdd

   ld hl,FPrand_m
   call FPMov9ToOP2

   call FPMod

   ld hl,OP1+1
   ld de,RandSeed
   ldi
    ldi
    ldi
    ldi
    ldi
    ldi

   ld a,7Fh
   ld (OP1+1),a   ;Makes our random number a decimal...
   ret

FPrand_a:
   db 00h,85h,21h,40h,13h,00h,00h,00h,00h
FPrand_c:
   db 00h,86h,25h,31h,01h,10h,00h,00h,00h
FPrand_m:
   db 00h,84h,65h,53h,50h,00h,00h,00h,00h

;Float Compares

FPchkHalfINT:
   call FPOP1ToOP3

   ld hl,OP2
   xor a
   ld (hl),a
   ld de,507Fh
   ld (OP1+1),de
   inc hl
   call FPclearOP_6

   call FPAdd
   call FPchkINT
   push af
   call FPOP3ToOP1
   pop af
   ret

FPchkINT:
   ld a,(OP1+1)
   sub 80h
   inc a
   ld c,a
   sla a
   ld d,0
    ld e,a
   ld hl,OP1+2
   add hl,de
   ld a,c
   bit 0,a
   ld a,(hl)
   jr z,chkINTL

   and 0Fh
   ret

chkINTL:
   and 240;F0h
   ret

;Floating Point - Compare OP1 To OP2
FPCpOP1ToOP2:
   ld a,(OP2+1)
   ld b,a
   ld a,(OP1+1)
   cp b
   ret nz

   ld hl,OP1+2
   ld de,OP2+2
   ld b,7
FPCpOP1ToOP2_loop:
   ld a,(de)
   ld b,(hl)
   cp b
   ret nz
   inc hl
   inc de
   djnz FPCpOP1ToOP2_loop
   ret

;Floating Point - Compare OP1 To zero
FPCpOP1To0:
   ld a,(OP1+1)
   cp 80h
   ret nz

   ld hl,OP1+2
FPCpOPTo0:
   ld b,7
FPCpOP1To0_loop:
   ld a,(hl)
   or a
   ret nz
   inc hl
   djnz FPCpOP1To0_loop
   ret

FPCpOP2To0:
   ld a,(OP2+1)
   cp 80h
   ret nz

   ld hl,OP2+2
   jr FPCpOPTo0

FPCpOP3To0:
   ld a,(OP3+1)
   cp 80h
   ret nz

   ld hl,OP3+2
   jr FPCpOPTo0

FPCpOP4To0:
   ld a,(OP4+1)
   cp 80h
   ret nz

   ld hl,OP4+2
   jr FPCpOPTo0

;Float Shifting by Nibbles

FPsrOP1_1:
   ld a,1
FPsrOP1:
   ld b,a
   ld de,OP1+2
FPsr_l:
   ld h,d
    ld l,e
   xor a
   rrd
   inc hl
   rrd
   inc hl
   rrd
   inc hl
   rrd
   inc hl
   rrd
   inc hl
   rrd
   inc hl
   rrd
   inc hl
   rrd
   djnz FPsr_l
   ret

FPsrOP2_1:
   ld a,1
FPsrOP2:
   ld b,a
   ld de,OP2+2
   jr FPsr_l

FPsrOP3_1:
   ld a,1
FPsrOP3:
   ld b,a
   ld de,OP3+2
   jr FPsr_l

FPsrOP4_1:
   ld a,1
FPsrOP4:
   ld b,a
   ld de,OP4+2
   jr FPsr_l

FPslOP1_1:
   ld a,1
;Floating Point - Shift OP1 Left a digits
FPslOP1:
   or a
   sla a
   sla a
   ld b,a
FPslOP1_o:
   ld d,b
   ld hl,OP1+9
   or a
   ld b,8
FPslOP1_i:
   rl (hl)
   dec hl
   djnz FPslOP1_i
   ld b,d
   djnz FPslOP1_o
   ret

FPslOP3_1:
   ld a,1
;Floating Point - Shift OP3 Left a digits
FPslOP3:
   or a
   sla a
   sla a
   ld b,a
FPslOP3_o:
   ld d,b
   ld hl,OP3+9
   or a
   ld b,8
FPslOP3_i:
   rl (hl)
   dec hl
   djnz FPslOP3_i
   ld b,d
   djnz FPslOP3_o
   ret

;Truely Misc.

FPsum_digitsOP2: ;Multiplication Run-Time Optimization
   ld hl,OP2+2
   jr FPsum_digitsOP2_
FPsum_digitsOP1:
   ld hl,OP1+2
FPsum_digitsOP2_:
   ld b,7
   xor a
   ld c,a
FPsum_digits_l:
   rrd
   ld e,a
   add a,c
   ld c,a
   ld a,e
   rrd
   ld e,a
   add a,c
   ld c,a
   ld a,e
   rrd
   inc hl
   djnz FPsum_digits_l
   ret

FPNormalize_OP1:
   ld hl,OP1+2
   ld b,14
FPnormalize_OP1_loop:
   ld a,(hl)
   and 240;F0h
   ret nz
   push hl
   call FPslOP1_1
   pop hl
   ld a,(OP1+1)
   dec a
   ld (OP1+1),a
   djnz FPnormalize_OP1_loop

   jp FPSetOP1To0

FPNormalize_OP3:
   ld hl,OP3+2
   ld b,14
FPnormalize_OP3_loop:
   ld a,(hl)
   and 240;$F0
   ret nz
   push hl
   push bc
   call FPslOP3_1
   pop bc
   pop hl
   ld a,(OP3+1)
   dec a
   ld (OP3+1),a
   djnz FPnormalize_OP3_loop

   jp FPSetOP3To0

FPDecOP3:
   call FPSetOP4To1
   call FPSubOP3OP4
   jp FPCpOP3To0
FPDecOP4:
   call FPOP4ToOP3
   call FPSetOP4To1
   call FPSubOP3OP4
   call FPOP3ToOP4
   jp FPCpOP4To0

FPIncOP3:
   call FPSetOP4To1
   call FPAddOP3OP4
   jp FPCpOP3To0
FPIncOP4:
   call FPOP4ToOP3
   call FPSetOP4To1
   call FPAddOP3OP4
   call FPOP3ToOP4
   jp FPCpOP4To0

;#end "FPmisc.z80"
;#include "FPadd.z80"
FPAdd:
   call FPCpOP1To0 ;Check for either being zero
   jp z,FPOP2ToOP1
   call FPCpOP2To0
   ret z

   xor a
   ld (OP1+9),a
   ld (OP2+9),a

   ld a,(OP1)
   ld b,a
   ld a,(OP2)
   cp b
   jr z,FPadd_same_sign

;signs are different -- put the one with the
;  minus sign in the subtrahend position,
;  reMove its sign, and use FPsub

   jr nc,FPadd_no_swap
   call FPOP1ExOP2
FPadd_no_swap:
   xor 1 ;change sign
   ld (OP2),a
   jp FPSub

FPadd_same_sign:
   ld a,(OP2+1)
   ld c,a
   ld a,(OP1+1)
   cp c
   jr z,FPadd_same_Exp

   jr nc,FPadd_adjust

   ld b,a
   push bc
   call FPOP1ExOP2 ;Make the larger one in OP1
   pop bc
   ld a,c
   ld c,b

FPadd_adjust:
   sub c
   cp 15       ;If the Exponent is so much smaller that it doesn't make a difference don't bother
   ret nc

;a = difference in Exponent
   call FPsrOP2

FPadd_same_Exp:
   call FPsrOP2_1 ;Room for a carry
   call FPsrOP1_1

;Now they both have the same Exponent
   ld hl,OP1+9
   ld de,OP2+9

   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5               ;Rounding Rule... 5 > on the dropped digit rounds up otherwise it is just dropped
   ccf
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a

;Now the numbers are added Together

   ld a,(OP1+2)
   and 240;$F0
   jr nz,FPadd_no_shiftback ;Did we carry over

   call FPslOP1_1
   ret ;No chance To overflow

FPadd_no_shiftback:
   ld a,(OP1+1) ;Get Exponent
   inc a
   ld (OP1+1),a
   or a ; If it is zero than we overflowed
   RCALLZ Err_Overflow
   ret ;Done adding them OP2 is de-normalized

;Other additions

FPAddOP3OP4:
   call FPCpOP3To0 ;Check for either being zero
   jp z,FPOP4ToOP3
   call FPCpOP4To0
   ret z

   xor a
   ld (OP3+9),a
   ld (OP4+9),a

   ld a,(OP3)
   ld b,a
   ld a,(OP4)
   cp b
   jr z,FPaddOP3OP4_same_sign

;signs are different -- put the one with the
;  minus sign in the subtrahend position,
;  reMove its sign, and use FPsub

   jr nc,FPaddOP3OP4_no_swap
   call FPOP3ExOP4
FPaddOP3OP4_no_swap:
   xor 1 ;change sign
   ld (OP4),a
   jp FPSubOP3OP4

FPaddOP3OP4_same_sign:
   ld a,(OP4+1)
   ld c,a
   ld a,(OP3+1)
   cp c
   jr z,FPaddOP3OP4_same_Exp

   jr nc,FPaddOP3OP4_adjust

   ld b,a
   push bc
   call FPOP3ExOP4 ;Make the larger one in OP3
   pop bc
   ld a,c
   ld c,b

FPaddOP3OP4_adjust:
   sub c
   cp 15       ;If the Exponent is so much smaller that it doesn't make a difference don't bother
   ret nc

;a = difference in Exponent
   call FPsrOP4

FPaddOP3OP4_same_Exp:
   call FPsrOP4_1 ;Room for a carry
   call FPsrOP3_1

;Now they both have the same Exponent
   ld hl,OP3+9
   ld de,OP4+9

   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5               ;Rounding Rule... 5 > on the dropped digit rounds up otherwise it is just dropped
   ccf
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec hl
   dec de
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a

;Now the numbers are added Together

   ld a,(OP3+2)
   and 240;$F0
   jr nz,FPaddOP3OP4_no_shiftback ;Did we carry over

   call FPslOP3_1
   ret ;No chance To overflow

FPaddOP3OP4_no_shiftback:
   ld a,(OP3+1) ;Get Exponent
   inc a
   ld (OP3+1),a
   or a ; If it is zero than we overflowed
   RCALLZ Err_Overflow
   ret ;Done adding them OP4 is de-normalized
;#end "FPadd.z80"
;#include "FPsub.z80"
FPSub:
   call FPCpOP1To0 ;Check for either being zero
   jp z,FPOP2ToOP1
   call FPCpOP2To0
   ret z

   xor a
   ld (OP1+9),a
   ld (OP2+9),a

   ld a,(OP1)
   ld b,a
   ld a,(OP2)
   cp b
   jr z,FPsub_same_sign

; signs are different -- change sign of subtrahend
;   and use FPadd
   xor 1
   ld (OP2),a
   jp FPAdd

FPsub_same_sign:
   ld a,(OP2+1)
   ld c,a
   ld a,(OP1+1)
   cp c
   jr z,FPsub_same_Exp

   jr nc,FPsub_adjust

   ld b,a
   push bc
   call FPOP1ExOP2 ;Make the larger one in OP1 and swap the sign on the resultant
   ld a,(OP1)
   xor 1
   ld (OP1),a
   pop bc
   ld a,c
   ld c,b

FPsub_adjust:
   sub c
   cp 15       ;If the Exponent is so much smaller that it doesn't make a difference don't bother
   ret nc

;a = difference in Exponent
   call FPsrOP2

FPsub_same_Exp:
   call FPsrOP2_1 ;Room for a carry
   call FPsrOP1_1

;Now they both have the same Exponent
   ld hl,OP2+9
   ld de,OP1+9

   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5               ;Rounding Rule... 5 > on the dropped digit rounds up otherwise it is just dropped
   ccf
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de


;Now the numbers are added Together

   ld a,(OP1+2)
   and 240;$F0
   jr nz,FPsub_no_shiftback ;Did we carry over

   ld hl,(OP1+2)
   ld a,(hl)
   and 0Fh

   call FPslOP1_1

   call FPNormalize_OP1
   ret ;No chance To overflow

FPsub_no_shiftback:
   ld a,(OP1+1) ;Get Exponent
   inc a
   ld (OP1+1),a
   or a ; If it is zero than we overflowed
   RCALLZ Err_Overflow
   ret ;Done adding them OP2 is de-normalized


;Other subtractions
FPSubOP3OP4:
   call FPCpOP3To0 ;Check for either being zero
   jp z,FPOP4ToOP3
   call FPCpOP4To0
   ret z

   xor a
   ld (OP3+9),a
   ld (OP4+9),a

   ld a,(OP3)
   ld b,a
   ld a,(OP4)
   cp b
   jr z,FPsubOP3OP4_same_sign

; signs are different -- change sign of subtrahend
;   and use FPadd
   xor 1
   ld (OP4),a
   jp FPAddOP3OP4

FPsubOP3OP4_same_sign:
   ld a,(OP4+1)
   ld c,a
   ld a,(OP3+1)
   cp c
   jr z,FPsubOP3OP4_same_Exp

   jr nc,FPsubOP3OP4_adjust

   ld b,a
   push bc
   call FPOP3ExOP4 ;Make the larger one in OP3 and swap the sign on the resultant
   ld a,(OP3)
   xor 1
   ld (OP3),a
   pop bc
   ld a,c
   ld c,b

FPsubOP3OP4_adjust:
   sub c
   cp 15       ;If the Exponent is so much smaller that it doesn't make a difference don't bother
   ret nc

;a = difference in Exponent
   call FPsrOP4

FPsubOP3OP4_same_Exp:
   call FPsrOP4_1 ;Room for a carry
   call FPsrOP3_1

;Now they both have the same Exponent
   ld hl,OP4+9
   ld de,OP3+9

   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5               ;Rounding Rule... 5 > on the dropped digit rounds up otherwise it is just dropped
   ccf
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de
   ld a,(de)
   sbc a,(hl)
   daa
   ld (de),a
   dec hl
   dec de


;Now the numbers are added Together

   ld a,(OP3+2)
   and 240;F0
   jr nz,FPsubOP3OP4_no_shiftback ;Did we carry over

   call FPslOP3_1
   call FPNormalize_OP3
   ret ;No chance To overflow

FPsubOP3OP4_no_shiftback:
   ld a,(OP3+1) ;Get Exponent
   inc a
   ld (OP3+1),a
   or a ; If it is zero than we overflowed
   RCALLZ Err_Overflow
   ret ;Done adding them OP4 is de-normalized
;#end "FPsub.z80"
;#include "FPmult.z80"
op1plusop3 .macro
    ld hl,OP1+8
    ld de,OP3+8
    loopchunk
    loopchunk
    loopchunk
    loopchunk
    loopchunk
    loopchunk
    ld a,(de)
    adc a,(hl)
    daa
    ld (hl),a
    .endm
loopchunk .macro
    ld a,(de)
    adc a,(hl)
    daa
    ld (hl),a
    dec hl
    dec de
    .endm

FPMult:
   call FPCpOP1To0 ;Check for either being zero
   ret z
   call FPCpOP2To0
   jp z,FPSetOP1To0

   xor a
   ld (OP1+9),a
   ld (OP2+9),a

   call FPsum_digitsOP1
   ld d,c
   call FPsum_digitsOP2
   ld a,d
   cp c
   jr nc,FPmult_dont_swap    ;With this we optimize the multiplication To take the least sums

   call FPOP1ExOP2

FPmult_dont_swap:
   ld a,(OP1+1)
;   sub $80      ;Convienant that you don't have To fix the skew (carries over and is dropped)
   ld c,a
   ld a,(OP2+1)
;   sub $80
   add a,c
   add a,80h     ;But you still do here
   or a
   RCALLZ Err_Overflow
   ld (OP1+1),a    ;Addition of Exponent yields the products Exponent (with the possibility of a carry)

   ld a,(OP1)
   ld c,a
   ld a,(OP2)
   xor c
   ld (OP1),a   ;Set the sign of our product

   call FPSetOP3To0 ;clear or holder

   call FPsrOP1_1   ;Room To catch a carries

   ld de,OP2+8
   ld b,6
FPmult_o:
   push bc
   ld a,(de)
   and 0Fh
   jr z,FPmult_empty_l

   push de
   ld b,a
FPmult_i_l:
;op1plusop3
   ld hl,OP3+9
   ld de,OP1+9
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5
   ccf
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   ld a,(de)
    adc a,(hl)
    daa
    ld (hl),a

   djnz FPmult_i_l

   call FPsrOP3_1

   pop de
FPmult_empty_l
   ld a,(de)
   and 0F0h
   jr z,FPmult_empty_r

   push de
   srl a
    srl a
    srl a
    srl a
   ld b,a
FPmult_i_r:
;op1plusop3
   ld hl,OP3+9
   ld de,OP1+9
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5
   ccf
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   ld a,(de)
    adc a,(hl)
    daa
    ld (hl),a

   djnz FPmult_i_r

   call FPsrOP3_1

   pop de
FPmult_empty_r:
   dec de
   pop bc
   dec b
   jp nz,FPmult_o

;Last digits...
   ld a,(de)
   and 0Fh
   jr z,FPmult_empty_l_

   push de
   ld b,a
FPmult_i_l_:
;op1plusop3
   ld hl,OP3+9
   ld de,OP1+9
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5
   ccf
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   ld a,(de)
    adc a,(hl)
    daa
    ld (hl),a

   djnz FPmult_i_l_

   call FPsrOP3_1

   pop de
FPmult_empty_l_:
   ld a,(de)
   and 0F0h
   jr z,FPmult_empty_r_  ;Impossible on normalized numbers... but leave it

   srl a
    srl a
    srl a
    srl a
   ld b,a
FPmult_i_r_:
;op1plusop3
   ld hl,OP3+9
   ld de,OP1+9
   ld a,(de)
   adc a,(hl)
   daa
   ld (hl),a
   dec de
   dec hl
   srl a
   srl a
   srl a
   srl a
   cp 5
   ccf
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   loopchunk
   ld a,(de)
    adc a,(hl)
    daa
    ld (hl),a

   djnz FPmult_i_r_

FPmult_empty_r_:

   ld hl,OP3+2
   ld de,OP1+2
   ldi
    ldi
    ldi
    ldi
    ldi
    ldi
    ldi

   ld a,(OP1+2)
   and 0F0h
   jr z,FPmult_no_carry

   ld hl,OP1+1
   ld a,(hl)
   inc a
   or a
   RCALLZ Err_Overflow
   ld (hl),a
   ret

FPmult_no_carry:
   call FPslOP1_1
   ret
;#end "FPmult.z80
;#include "FPdiv.z80"
FPDiv:
   ret
;#end "FPdiv.z80"
;#include "FPmod.z80"
FPMod:
   ;Note output uses sign of OP1

   xor a
   ld (OP2),a ;Clear the sign on OP2 no matter what

   call FPOP2ToOP3
FPmod_l:
   call FPOP3ToOP2
   call FPCpOP1ToOP2
   ret c                ;If OP2 > OP1

   call FPOP3ToOP2
   call FPSub
   jp FPmod_l
;#end "FPmod.z80"
;#include "FPfacTorial.z80"
FPFactorial:
   call FPCpOP1To0
   jp z,FPSetOP1To1


   call FPSetOP2To0
   call FPCpOP1ToOP2
;   RCALLC Err_Domain

   call FPOP1ToOP4
   call FPSetOP1To1
FPfacTorial_loop:
   call FPOP4ToOP2
   call FPMult

   call FPDecOP4
   jr nz,FPfacTorial_loop

   ret
;#end "FPfacTorial.z80"
;#include "FPconv.z80"
;Through a string inTo HL of OP1
FPOP1ToStr:
   ret