diff --git a/compiler/res/prog8lib/c64/floats.asm b/compiler/res/prog8lib/c64/floats.asm
index 2770cfb96..4d0c92b03 100644
--- a/compiler/res/prog8lib/c64/floats.asm
+++ b/compiler/res/prog8lib/c64/floats.asm
@@ -120,133 +120,6 @@ cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
 		.pend
 
 
-stack_b2float	.proc
-		; -- b2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  FREADSA
-		jmp  push_fac1._internal
-		.pend
-
-stack_w2float	.proc
-		; -- w2float operating on the stack
-		inx
-		ldy  P8ESTACK_LO,x
-		lda  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVAYF
-		jmp  push_fac1._internal
-		.pend
-
-stack_ub2float	.proc
-		; -- ub2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG
-		tay
-		lda  #0
-		jsr  GIVAYF
-		jmp  push_fac1._internal
-		.pend
-
-stack_uw2float	.proc
-		; -- uw2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVUAYFAY
-		jmp  push_fac1._internal
-		.pend
-
-stack_float2w	.proc               ; also used for float2b
-		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG
-		jsr  AYINT
-		ldx  P8ZP_SCRATCH_REG
-		lda  floats.AYINT_facmo
-		sta  P8ESTACK_HI,x
-		lda  floats.AYINT_facmo+1
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-stack_float2uw	.proc               ; also used for float2ub
-		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG
-		jsr  GETADR
-		ldx  P8ZP_SCRATCH_REG
-		sta  P8ESTACK_HI,x
-		tya
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-push_float	.proc
-		; ---- push mflpt5 in A/Y onto stack
-		; (taking 3 stack positions = 6 bytes of which 1 is padding)
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_HI,x
-		dex
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_HI,x
-		dex
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-pop_float	.proc
-		; ---- pops mflpt5 from stack to memory A/Y
-		; (frees 3 stack positions = 6 bytes of which 1 is padding)
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #4
-		inx
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		inx
-		lda  P8ESTACK_HI,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		inx
-		lda  P8ESTACK_HI,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		rts
-		.pend
-
-pop_float_fac1	.proc
-		; -- pops float from stack into FAC1
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jmp  MOVFM
-		.pend
-
 copy_float	.proc
 		; -- copies the 5 bytes of the mflt value pointed to by P8ZP_SCRATCH_W1,
 		;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
@@ -305,84 +178,10 @@ dec_var_f	.proc
 		.pend
 
 
-pop_2_floats_f2_in_fac1	.proc
-		; -- pop 2 floats from stack, load the second one in FAC1 as well
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jmp  MOVFM
-		.pend
-
-
 fmath_float1	.byte 0,0,0,0,0	; storage for a mflpt5 value
 fmath_float2	.byte 0,0,0,0,0	; storage for a mflpt5 value
 
 
-push_fac1	.proc
-		; -- push the float in FAC1 onto the stack
-		stx  P8ZP_SCRATCH_REG
-_internal	ldx  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVMF
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		ldx  P8ZP_SCRATCH_REG
-		jmp  push_float
-		.pend
-
-div_f		.proc
-		; -- push f1/f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FDIV
-		jmp  push_fac1._internal
-		.pend
-
-add_f		.proc
-		; -- push f1+f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FADD
-		jmp  push_fac1._internal
-		.pend
-
-sub_f		.proc
-		; -- push f1-f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FSUB
-		jmp  push_fac1._internal
-		.pend
-
-mul_f		.proc
-		; -- push f1*f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FMULT
-		jmp  push_fac1._internal
-		.pend
-
-neg_f		.proc
-		; -- toggle the sign bit on the stack
-		lda  P8ESTACK_HI+3,x
-		eor  #$80
-		sta  P8ESTACK_HI+3,x
-		rts
-		.pend
-
 var_fac1_less_f	.proc
 		; -- is the float in FAC1 < the variable AY?
 		stx  P8ZP_SCRATCH_REG
@@ -478,42 +277,6 @@ _false		lda  #0
 		rts
 		.pend
 
-equal_f		.proc
-		; -- are the two mflpt5 numbers on the stack identical?
-		inx
-		inx
-		inx
-		inx
-		lda  P8ESTACK_LO-3,x
-		cmp  P8ESTACK_LO,x
-		bne  _equals_false
-		lda  P8ESTACK_LO-2,x
-		cmp  P8ESTACK_LO+1,x
-		bne  _equals_false
-		lda  P8ESTACK_LO-1,x
-		cmp  P8ESTACK_LO+2,x
-		bne  _equals_false
-		lda  P8ESTACK_HI-2,x
-		cmp  P8ESTACK_HI+1,x
-		bne  _equals_false
-		lda  P8ESTACK_HI-1,x
-		cmp  P8ESTACK_HI+2,x
-		bne  _equals_false
-_equals_true	lda  #1
-_equals_store	inx
-		sta  P8ESTACK_LO+1,x
-		rts
-_equals_false	lda  #0
-		beq  _equals_store
-		.pend
-
-notequal_f	.proc
-		; -- are the two mflpt5 numbers on the stack different?
-		jsr  equal_f
-		eor  #1		; invert the result
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
 
 vars_less_f	.proc
 		; -- is float in AY < float in P8ZP_SCRATCH_W2 ?
@@ -586,30 +349,6 @@ greatereq_f	.proc
 		bne  compare_floats._return_false
 		.pend
 
-compare_floats	.proc
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVFM		; fac1 = flt1
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP		; A = flt1 compared with flt2 (0=equal, 1=flt1>flt2, 255=flt1<flt2)
-		ldx  P8ZP_SCRATCH_REG
-		rts
-_return_false	lda  #0
-_return_result  sta  P8ESTACK_LO,x
-		dex
-		rts
-_return_true	lda  #1
-		bne  _return_result
-		.pend
-
 set_array_float_from_fac1	.proc
 		; -- set the float in FAC1 in the array (index in A, array in P8ZP_SCRATCH_W1)
 		sta  P8ZP_SCRATCH_B1
@@ -667,56 +406,3 @@ set_array_float		.proc
 			; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_ZPWORD1,
 			;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
 		.pend
-
-
-equal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		beq  _true
-		bne  _false
-_true		lda  #1
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-_false		lda  #0
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-notequal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		bne  equal_zero._true
-		beq  equal_zero._false
-		.pend
-
-greater_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		beq  equal_zero._false
-		bpl  equal_zero._true
-		jmp  equal_zero._false
-		.pend
-
-less_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		bmi  equal_zero._true
-		jmp  equal_zero._false
-		.pend
-
-greaterequal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		bpl  equal_zero._true
-		jmp  equal_zero._false
-		.pend
-
-lessequal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		beq  equal_zero._true
-		bmi  equal_zero._true
-		jmp  equal_zero._false
-		.pend
diff --git a/compiler/res/prog8lib/c64/floats_funcs.asm b/compiler/res/prog8lib/c64/floats_funcs.asm
index 79e560331..19faa85fb 100644
--- a/compiler/res/prog8lib/c64/floats_funcs.asm
+++ b/compiler/res/prog8lib/c64/floats_funcs.asm
@@ -1,13 +1,6 @@
 ; --- floating point builtin functions
 
 
-func_sign_f_stack	.proc
-		jsr  func_sign_f_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_f_into_A	.proc
 		jsr  MOVFM
 		jmp  SIGN
diff --git a/compiler/res/prog8lib/math.asm b/compiler/res/prog8lib/math.asm
index fa1ffa011..add505203 100644
--- a/compiler/res/prog8lib/math.asm
+++ b/compiler/res/prog8lib/math.asm
@@ -257,501 +257,6 @@ b1=*+1
 randbyte = randword    ; -- 8 bit pseudo random number generator into A (by just reusing randword)
 
 
-; ----------- optimized multiplications (stack) : ---------
-stack_mul_byte_3	.proc
-		; X + X*2
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_3	.proc
-		; W*2 + W
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-
-stack_mul_byte_5	.proc
-		; X*4 + X
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_5	.proc
-		; W*4 + W
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-
-stack_mul_byte_6	.proc
-		; (X*2 + X)*2
-		lda  P8ESTACK_LO+1,x
-		asl  a
-                clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_6	.proc
-		; (W*2 + W)*2
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_7	.proc
-		; X*8 - X
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		asl  a
-		sec
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_7	.proc
-		; W*8 - W
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		sec
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		sbc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_9	.proc
-		; X*8 + X
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_9	.proc
-		; W*8 + W
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_10	.proc
-		; (X*4 + X)*2
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_10	.proc
-		; (W*4 + W)*2
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_11	.proc
-		; (X*2 + X)*4 - X
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		sec
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-; mul_word_11 is skipped (too much code)
-
-stack_mul_byte_12	.proc
-		; (X*2 + X)*4
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_12	.proc
-		; (W*2 + W)*4
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_13	.proc
-		; (X*2 + X)*4 + X
-		lda  P8ESTACK_LO+1,x
-		asl  a
-                clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-                clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-; mul_word_13 is skipped (too much code)
-
-stack_mul_byte_14	.proc
-		; (X*8 - X)*2
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		asl  a
-                sec
-		sbc  P8ESTACK_LO+1,x
-                asl  a
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-; mul_word_14 is skipped (too much code)
-
-stack_mul_byte_15	.proc
-		; X*16 - X
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		asl  a
-		asl  a
-		sec
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_15	.proc
-		; W*16 - W
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		sec
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		sbc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_20	.proc
-		; (X*4 + X)*4
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_20	.proc
-		; (W*4 + W)*4
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_25	.proc
-		; (X*2 + X)*8 + X
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		asl  a
-		asl  a
-		asl  a
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_25	.proc
-		; W = (W*2 + W) *8 + W
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_W1+1
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ZP_SCRATCH_W1+1
-		adc  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ZP_SCRATCH_W1
-		asl  a
-		rol  P8ZP_SCRATCH_W1+1
-		asl  a
-		rol  P8ZP_SCRATCH_W1+1
-		asl  a
-		rol  P8ZP_SCRATCH_W1+1
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_W1+1
-		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_40	.proc
-		lda  P8ESTACK_LO+1,x
-		and  #7
-		tay
-		lda  mul_byte_40._forties,y
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_40	.proc
-		; (W*4 + W)*8
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_REG
-		lda  P8ESTACK_LO+1,x
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		asl  a
-		rol  P8ZP_SCRATCH_REG
-		clc
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_REG
-		adc  P8ESTACK_HI+1,x
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		asl  P8ESTACK_LO+1,x
-                rol  a
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_50	.proc
-		lda  P8ESTACK_LO+1,x
-		and  #7
-		tay
-		lda  mul_byte_50._fifties, y
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_50	.proc
-		; W = W * 25 * 2
-		jsr  stack_mul_word_25
-		asl  P8ESTACK_LO+1,x
-		rol  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_80	.proc
-		lda  P8ESTACK_LO+1,x
-		and  #3
-		tay
-		lda  mul_byte_80._eighties, y
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_80	.proc
-		; W = W * 40 * 2
-		jsr  stack_mul_word_40
-		asl  P8ESTACK_LO+1,x
-		rol  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_byte_100	.proc
-		lda  P8ESTACK_LO+1,x
-		and  #3
-		tay
-		lda  mul_byte_100._hundreds, y
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-stack_mul_word_100	.proc
-		; W = W * 25 * 4
-		jsr  stack_mul_word_25
-		asl  P8ESTACK_LO+1,x
-		rol  P8ESTACK_HI+1,x
-		asl  P8ESTACK_LO+1,x
-		rol  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_word_320	.proc
-		; stackW = stackLo * 256 + stackLo * 64	 (stackHi doesn't matter)
-		ldy  P8ESTACK_LO+1,x
-		lda  #0
-		sta  P8ESTACK_HI+1,x
-		tya
-		asl  a
-		rol  P8ESTACK_HI+1,x
-		asl  a
-		rol  P8ESTACK_HI+1,x
-		asl  a
-		rol  P8ESTACK_HI+1,x
-		asl  a
-		rol  P8ESTACK_HI+1,x
-		asl  a
-		rol  P8ESTACK_HI+1,x
-		asl  a
-		rol  P8ESTACK_HI+1,x
-		sta  P8ESTACK_LO+1,x
-		tya
-		clc
-		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-stack_mul_word_640	.proc
-		; stackW = (stackLo * 2 * 320)    (stackHi doesn't matter)
-		asl  P8ESTACK_LO+1,x
-		jmp  stack_mul_word_320
-		.pend
-
-
 ; ----------- optimized multiplications (in-place A (byte) and ?? (word)) : ---------
 mul_byte_3	.proc
 		; A = A + A*2
@@ -1252,236 +757,6 @@ mul_word_640	.proc
 ; ----------- end optimized multiplications -----------
 
 
-; bit shifts.
-; anything below 3 is done inline. anything above 7 is done via other optimizations.
-
-shift_left_w_7	.proc
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-
-		asl  a
-		rol  P8ZP_SCRATCH_B1
-_shift6		asl  a
-		rol  P8ZP_SCRATCH_B1
-_shift5		asl  a
-		rol  P8ZP_SCRATCH_B1
-_shift4		asl  a
-		rol  P8ZP_SCRATCH_B1
-_shift3		asl  a
-		rol  P8ZP_SCRATCH_B1
-		asl  a
-		rol  P8ZP_SCRATCH_B1
-		asl  a
-		rol  P8ZP_SCRATCH_B1
-
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_B1
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-shift_left_w_6	.proc
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		jmp  shift_left_w_7._shift6
-		.pend
-
-shift_left_w_5	.proc
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		jmp  shift_left_w_7._shift5
-		.pend
-
-shift_left_w_4	.proc
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		jmp  shift_left_w_7._shift4
-		.pend
-
-shift_left_w_3	.proc
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		jmp  shift_left_w_7._shift3
-		.pend
-
-
-shift_left_w	.proc
-		; -- variable number of shifts left
-		inx
-		ldy  P8ESTACK_LO,x
-		bne  _shift
-		rts
-_shift		asl  P8ESTACK_LO+1,x
-		rol  P8ESTACK_HI+1,x
-		dey
-		bne  _shift
-		rts
-		.pend
-
-shift_right_uw	.proc
-		; -- uword variable number of shifts right
-		inx
-		ldy  P8ESTACK_LO,x
-		bne  _shift
-		rts
-_shift		lsr  P8ESTACK_HI+1,x
-		ror  P8ESTACK_LO+1,x
-		dey
-		bne  _shift
-		rts
-		.pend
-
-shift_right_uw_7	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_HI+1,x
-
-		lsr  a
-		ror  P8ZP_SCRATCH_B1
-_shift6		lsr  a
-		ror  P8ZP_SCRATCH_B1
-_shift5		lsr  a
-		ror  P8ZP_SCRATCH_B1
-_shift4		lsr  a
-		ror  P8ZP_SCRATCH_B1
-_shift3		lsr  a
-		ror  P8ZP_SCRATCH_B1
-		lsr  a
-		ror  P8ZP_SCRATCH_B1
-		lsr  a
-		ror  P8ZP_SCRATCH_B1
-
-		sta  P8ESTACK_HI+1,x
-		lda  P8ZP_SCRATCH_B1
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-shift_right_uw_6	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_HI+1,x
-		jmp  shift_right_uw_7._shift6
-		.pend
-
-shift_right_uw_5	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_HI+1,x
-		jmp  shift_right_uw_7._shift5
-		.pend
-
-shift_right_uw_4	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_HI+1,x
-		jmp  shift_right_uw_7._shift4
-		.pend
-
-shift_right_uw_3	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_HI+1,x
-		jmp  shift_right_uw_7._shift3
-		.pend
-
-
-shift_right_w_7		.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-
-		asl  a
-		ror  P8ZP_SCRATCH_W1+1
-		ror  P8ZP_SCRATCH_W1
-
-		lda  P8ZP_SCRATCH_W1+1
-_shift6		asl  a
-		ror  P8ZP_SCRATCH_W1+1
-		ror  P8ZP_SCRATCH_W1
-		lda  P8ZP_SCRATCH_W1+1
-_shift5		asl  a
-		ror  P8ZP_SCRATCH_W1+1
-		ror  P8ZP_SCRATCH_W1
-		lda  P8ZP_SCRATCH_W1+1
-_shift4		asl  a
-		ror  P8ZP_SCRATCH_W1+1
-		ror  P8ZP_SCRATCH_W1
-		lda  P8ZP_SCRATCH_W1+1
-_shift3		asl  a
-		ror  P8ZP_SCRATCH_W1+1
-		ror  P8ZP_SCRATCH_W1
-		lda  P8ZP_SCRATCH_W1+1
-		asl  a
-		ror  P8ZP_SCRATCH_W1+1
-		ror  P8ZP_SCRATCH_W1
-		lda  P8ZP_SCRATCH_W1+1
-		asl  a
-		ror  P8ZP_SCRATCH_W1+1
-		ror  P8ZP_SCRATCH_W1
-
-		lda  P8ZP_SCRATCH_W1
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_W1+1
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-shift_right_w_6	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		jmp  shift_right_w_7._shift6
-		.pend
-
-shift_right_w_5	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		jmp  shift_right_w_7._shift5
-		.pend
-
-shift_right_w_4	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		jmp  shift_right_w_7._shift4
-		.pend
-
-shift_right_w_3	.proc
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		jmp  shift_right_w_7._shift3
-		.pend
-
-
-shift_right_w	.proc
-		; -- signed word variable number of shifts right
-		inx
-		ldy  P8ESTACK_LO,x
-		bne  _shift
-		rts
-_shift		lda  P8ESTACK_HI+1,x
-		asl  a
-		ror  P8ESTACK_HI+1,x
-		ror  P8ESTACK_LO+1,x
-		dey
-		bne  _shift
-		rts
-		.pend
-
-
 ; support for bit shifting that is too large to be unrolled:
 
 lsr_byte_A	.proc
diff --git a/compiler/res/prog8lib/prog8_funcs.asm b/compiler/res/prog8lib/prog8_funcs.asm
index cdb5f2bb1..67681684a 100644
--- a/compiler/res/prog8lib/prog8_funcs.asm
+++ b/compiler/res/prog8lib/prog8_funcs.asm
@@ -1,20 +1,6 @@
 ; ---- builtin functions
 
 
-func_any_b_stack	.proc
-		jsr  func_any_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_all_b_stack	.proc
-		jsr  func_all_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_any_b_into_A	.proc
 		; -- any(array),  array in P8ZP_SCRATCH_W1, num bytes in A
 		sta  _cmp_mod+1		; self-modifying code
@@ -49,14 +35,6 @@ func_any_w_into_A	.proc
 		jmp  func_any_b_into_A
 		.pend
 
-func_any_w_stack	.proc
-		asl  a
-		jsr  func_any_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_all_w_into_A	.proc
 		; -- all(warray),  array in P8ZP_SCRATCH_W1, num bytes in A
 		asl  a			; times 2 because of word
@@ -77,22 +55,6 @@ _cmp_mod	cpy  #255		; modified
 		rts
 		.pend
 
-func_all_w_stack	.proc
-		jsr  func_all_w_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-abs_b_stack	.proc
-	; -- push abs(A) on stack (as unsigned word)
-		jsr  abs_b_into_A
-		sta  P8ESTACK_LO,x
-		stz  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
 abs_b_into_A	.proc
 	; -- A = abs(A)
 		cmp  #0
@@ -104,16 +66,6 @@ abs_b_into_A	.proc
 		rts
 		.pend
 
-abs_w_stack	.proc
-	; -- push abs(AY) on stack (as word)
-		jsr  abs_w_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
 abs_w_into_AY	.proc
 	; -- AY = abs(AY)
 		cpy  #0
@@ -142,13 +94,6 @@ _neg		lda  #-1
 		rts
 		.pend
 
-func_sign_b_stack	.proc
-		jsr  func_sign_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_ub_into_A	.proc
 		cmp  #0
 		bne  _pos
@@ -157,13 +102,6 @@ _pos		lda  #1
 		rts
 		.pend
 
-func_sign_ub_stack	.proc
-		jsr  func_sign_ub_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_uw_into_A	.proc
 		cpy  #0
 		beq  _possibly_zero
@@ -174,13 +112,6 @@ _possibly_zero	cmp  #0
 		rts
 		.pend
 
-func_sign_uw_stack	.proc
-		jsr  func_sign_uw_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_w_into_A	.proc
 		cpy  #0
 		beq  _possibly_zero
@@ -195,20 +126,6 @@ _possibly_zero	cmp  #0
 		.pend
 
 
-func_sign_w_stack	.proc
-		jsr  func_sign_w_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_sqrt16_stack	.proc
-		jsr  func_sqrt16_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sqrt16_into_A	.proc
 		; integer square root from  http://6502org.wikidot.com/software-math-sqrt
 		sta  P8ZP_SCRATCH_W1
diff --git a/compiler/res/prog8lib/prog8_lib.asm b/compiler/res/prog8lib/prog8_lib.asm
index e5e21b61b..d5992d60f 100644
--- a/compiler/res/prog8lib/prog8_lib.asm
+++ b/compiler/res/prog8lib/prog8_lib.asm
@@ -4,330 +4,6 @@
 
 orig_stackpointer	.byte  0	; stores the Stack pointer register at program start
 
-read_byte_from_address_on_stack	.proc
-	; -- read the byte from the memory address on the top of the stack, return in A (stack remains unchanged)
-		lda  P8ESTACK_LO+1,x
-		ldy  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W2),y
-		rts
-		.pend
-
-
-write_byte_to_address_on_stack	.proc
-	; -- write the byte in A to the memory address on the top of the stack (stack remains unchanged)
-		ldy  P8ESTACK_LO+1,x
-		sty  P8ZP_SCRATCH_W2
-		ldy  P8ESTACK_HI+1,x
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  #0
-		sta  (P8ZP_SCRATCH_W2),y
-		rts
-		.pend
-
-
-
-neg_b		.proc
-		lda  #0
-		sec
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-neg_w		.proc
-		sec
-		lda  #0
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  #0
-		sbc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-inv_word	.proc
-		lda  P8ESTACK_LO+1,x
-		eor  #255
-		sta  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+1,x
-		eor  #255
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-bitand_b	.proc
-		; -- bitwise and (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		and  P8ESTACK_LO+1,x
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-bitor_b		.proc
-		; -- bitwise or (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_LO+1,x
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-bitxor_b	.proc
-		; -- bitwise xor (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		eor  P8ESTACK_LO+1,x
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-bitand_w	.proc
-		; -- bitwise and (of 2 words)
-		lda  P8ESTACK_LO+2,x
-		and  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+2,x
-		and  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+2,x
-		inx
-		rts
-		.pend
-
-bitor_w		.proc
-		; -- bitwise or (of 2 words)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+2,x
-		ora  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+2,x
-		inx
-		rts
-		.pend
-
-bitxor_w	.proc
-		; -- bitwise xor (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		eor  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+2,x
-		eor  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+2,x
-		inx
-		rts
-		.pend
-
-
-add_w		.proc
-	; -- push word+word / uword+uword
-		inx
-		clc
-		lda  P8ESTACK_LO,x
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI,x
-		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-sub_w		.proc
-	; -- push word-word
-		inx
-		sec
-		lda  P8ESTACK_LO+1,x
-		sbc  P8ESTACK_LO,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+1,x
-		sbc  P8ESTACK_HI,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-mul_byte	.proc
-	; -- b*b->b (signed and unsigned)
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_LO+1,x
-		jsr  math.multiply_bytes
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-mul_word	.proc
-		inx
-		lda  P8ESTACK_LO,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO+1,x
-		ldy  P8ESTACK_HI+1,x
-		jsr  math.multiply_words
-		sta  P8ESTACK_LO+1,x
-		tya
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-idiv_b		.proc
-	; signed division: use unsigned division and fix sign of result afterwards
-		inx
-		lda  P8ESTACK_LO,x
-		eor  P8ESTACK_LO+1,x
-		php			; save sign of result
-		lda  P8ESTACK_LO,x
-		bpl  +
-		eor  #$ff
-		sec
-		adc  #0			; make num1 positive
-+		tay
-		inx
-		lda  P8ESTACK_LO,x
-		bpl  +
-		eor  #$ff
-		sec
-		adc  #0			; make num2 positive
-+		jsr  math.divmod_ub_asm
-		sta  _remainder
-		tya
-		plp			; get sign of result
-		bpl  +
-		eor  #$ff
-		sec
-		adc  #0			; negate result
-+		sta  P8ESTACK_LO,x
-		dex
-		rts
-_remainder	.byte  0
-		.pend
-
-idiv_ub		.proc
-		inx
-		ldy  P8ESTACK_LO,x
-		lda  P8ESTACK_LO+1,x
-		jsr  math.divmod_ub_asm
-		tya
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-idiv_w		.proc
-	; signed division: use unsigned division and fix sign of result afterwards
-		lda  P8ESTACK_HI+2,x
-		eor  P8ESTACK_HI+1,x
-		php				; save sign of result
-		lda  P8ESTACK_HI+1,x
-		bpl  +
-		jsr  neg_w			; make value positive
-+		inx
-		lda  P8ESTACK_HI+1,x
-		bpl  +
-		jsr  neg_w			; make value positive
-+		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jsr  math.divmod_uw_asm
-		sta  P8ESTACK_LO+1,x
-		tya
-		sta  P8ESTACK_HI+1,x
-		plp
-		bpl  +
-		jmp  neg_w		; negate result
-+		rts
-		.pend
-
-idiv_uw		.proc
-		inx
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jsr  math.divmod_uw_asm
-		sta  P8ESTACK_LO+1,x
-		tya
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-remainder_ub	.proc
-		inx
-		ldy  P8ESTACK_LO,x	; right operand
-		lda  P8ESTACK_LO+1,x  ; left operand
-		jsr  math.divmod_ub_asm
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-remainder_uw	.proc
-		inx
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jsr  math.divmod_uw_asm
-		lda  P8ZP_SCRATCH_W2
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_W2+1
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-equal_w		.proc
-	; -- are the two words on the stack identical?
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bne  equal_b._equal_b_false
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		bne  equal_b._equal_b_false
-		beq  equal_b._equal_b_true
-		.pend
-
-notequal_b	.proc
-	; -- are the two bytes on the stack different?
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		beq  equal_b._equal_b_false
-		bne  equal_b._equal_b_true
-		.pend
-
-notequal_w	.proc
-	; -- are the two words on the stack different?
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		beq  notequal_b
-		bne  equal_b._equal_b_true
-		.pend
-
-less_ub		.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcc  equal_b._equal_b_true
-		bcs  equal_b._equal_b_false
-		.pend
-
-less_b		.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		sec
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
 reg_less_uw	.proc
 		;  AY < P8ZP_SCRATCH_W2?
 		cpy  P8ZP_SCRATCH_W2+1
@@ -341,17 +17,6 @@ _true		lda  #1
 		rts
 		.pend
 
-less_uw		.proc
-		lda  P8ESTACK_HI+2,x
-		cmp  P8ESTACK_HI+1,x
-		bcc  equal_b._equal_b_true
-		bne  equal_b._equal_b_false
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcc  equal_b._equal_b_true
-		bcs  equal_b._equal_b_false
-		.pend
-
 reg_less_w	.proc
 		; -- AY < P8ZP_SCRATCH_W2?
 		cmp  P8ZP_SCRATCH_W2
@@ -366,48 +31,6 @@ _true		lda  #1
 		rts
 		.pend
 
-less_w		.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+2,x
-		sbc  P8ESTACK_HI+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
-equal_b		.proc
-	; -- are the two bytes on the stack identical?
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bne  _equal_b_false
-_equal_b_true	lda  #1
-_equal_b_store	inx
-		sta  P8ESTACK_LO+1,x
-		rts
-_equal_b_false	lda  #0
-		beq  _equal_b_store
-		.pend
-
-lesseq_ub	.proc
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-lesseq_b	.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		clc
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
 reg_lesseq_uw	.proc
 		; AY <= P8ZP_SCRATCH_W2?
 		cpy  P8ZP_SCRATCH_W2+1
@@ -424,17 +47,6 @@ _true		lda  #1
 		rts
 		.pend
 
-lesseq_uw	.proc
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		bcc  equal_b._equal_b_false
-		bne  equal_b._equal_b_true
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
 reg_lesseq_w	.proc
 		; -- P8ZP_SCRATCH_W2 <= AY ?   (note: order different from other routines)
 		cmp  P8ZP_SCRATCH_W2
@@ -449,224 +61,6 @@ reg_lesseq_w	.proc
 		rts
 		.pend
 
-lesseq_w	.proc
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+1,x
-		sbc  P8ESTACK_HI+2,x
-		bvc  +
-		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
-		.pend
-
-greater_ub	.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		beq  equal_b._equal_b_false
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-greater_b	.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		clc
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
-		.pend
-
-greater_uw	.proc
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		bcc  equal_b._equal_b_true
-		bne  equal_b._equal_b_false
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bcc  equal_b._equal_b_true
-		bcs  equal_b._equal_b_false
-		.pend
-
-greater_w	.proc
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+1,x
-		sbc  P8ESTACK_HI+2,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
-greatereq_ub	.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-greatereq_b	.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		sec
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
-		.pend
-
-greatereq_uw	.proc
-		lda  P8ESTACK_HI+2,x
-		cmp  P8ESTACK_HI+1,x
-		bcc  equal_b._equal_b_false
-		bne  equal_b._equal_b_true
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-greatereq_w	.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+2,x
-		sbc  P8ESTACK_HI+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_false
-		bpl  equal_b._equal_b_true
-		.pend
-
-
-shiftleft_b	.proc
-		inx
-		ldy  P8ESTACK_LO,x
-		bne  +
-		rts
-+		lda  P8ESTACK_LO+1,x
--		asl  a
-		dey
-		bne  -
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-shiftright_b	.proc
-		inx
-		ldy  P8ESTACK_LO,x
-		bne  +
-		rts
-+		lda  P8ESTACK_LO+1,x
--		lsr  a
-		dey
-		bne  -
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-
-equalzero_b	.proc
-		lda  P8ESTACK_LO+1,x
-		beq  _true
-		bne  _false
-_true		lda  #1
-		sta  P8ESTACK_LO+1,x
-		rts
-_false		lda  #0
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-equalzero_w	.proc
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		beq  equalzero_b._true
-		bne  equalzero_b._false
-		.pend
-
-notequalzero_b	.proc
-		lda  P8ESTACK_LO+1,x
-		beq  equalzero_b._false
-		bne  equalzero_b._true
-		.pend
-
-notequalzero_w	.proc
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		beq  equalzero_b._false
-		bne  equalzero_b._true
-		.pend
-
-lesszero_b	.proc
-		lda  P8ESTACK_LO+1,x
-		bmi  equalzero_b._true
-		jmp  equalzero_b._false
-		.pend
-
-lesszero_w	.proc
-		lda  P8ESTACK_HI+1,x
-		bmi  equalzero_b._true
-		jmp  equalzero_b._false
-		.pend
-
-greaterzero_ub	.proc
-		lda  P8ESTACK_LO+1,x
-		bne  equalzero_b._true
-		beq  equalzero_b._false
-		.pend
-
-greaterzero_sb	.proc
-		lda  P8ESTACK_LO+1,x
-		beq  equalzero_b._false
-		bpl  equalzero_b._true
-		bmi  equalzero_b._false
-		.pend
-
-greaterzero_uw	.proc
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		bne  equalzero_b._true
-		beq  equalzero_b._false
-		.pend
-
-greaterzero_sw	.proc
-		lda  P8ESTACK_HI+1,x
-		bmi  equalzero_b._false
-		ora  P8ESTACK_LO+1,x
-		beq  equalzero_b._false
-		bne  equalzero_b._true
-		.pend
-
-lessequalzero_sb	.proc
-		lda  P8ESTACK_LO+1,x
-		bmi  equalzero_b._true
-		beq  equalzero_b._true
-		bne  equalzero_b._false
-		.pend
-
-lessequalzero_sw	.proc
-		lda  P8ESTACK_HI+1,x
-		bmi  equalzero_b._true
-		ora  P8ESTACK_LO+1,x
-		beq  equalzero_b._true
-		bne  equalzero_b._false
-		.pend
-
-greaterequalzero_sb	.proc
-		lda  P8ESTACK_LO+1,x
-	    	bpl  equalzero_b._true
-	    	bmi  equalzero_b._false
-		.pend
-
-greaterequalzero_sw	.proc
-		lda  P8ESTACK_HI+1,x
-	    	bpl  equalzero_b._true
-	    	bmi  equalzero_b._false
-		.pend
 
 memcopy16_up	.proc
 	; -- copy memory UP from (P8ZP_SCRATCH_W1) to (P8ZP_SCRATCH_W2) of length X/Y (16-bit, X=lo, Y=hi)
@@ -996,21 +390,6 @@ _arg_s1		.word  0
 _arg_s2		.word  0
 		.pend
 
-strcmp_stack	.proc
-		; -- compare strings, both on stack.
-		;    Returns -1,0,1 in A, depeding on the ordering. Clobbers Y.
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jmp  strcmp_mem
-		.pend
-
-
 strcmp_mem	.proc
 		; --   compares strings in s1 (AY) and s2 (P8ZP_SCRATCH_W2).
 		;      Returns -1,0,1 in A, depeding on the ordering. Clobbers Y.
@@ -1041,16 +420,6 @@ _return_minusone
 		.pend
 
 
-sign_extend_stack_byte	.proc
-	; -- sign extend the (signed) byte on the stack to full 16 bits
-		lda  P8ESTACK_LO+1,x
-		ora  #$7f
-		bmi  +
-		lda  #0
-+		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
 strlen          .proc
         ; -- returns the number of bytes in the string in AY, in Y.
 		sta  P8ZP_SCRATCH_W1
diff --git a/docs/source/todo.rst b/docs/source/todo.rst
index 7ae12265d..65cf5159b 100644
--- a/docs/source/todo.rst
+++ b/docs/source/todo.rst
@@ -1,7 +1,6 @@
 TODO
 ====
 
-- (branch): remove all evalstack references from asm code files
 - (branch): remove ExpressionsAsmGen.kt altogether
 - (branch): clean up all X register special handling
 - (branch): fix optimizeCmpSequence in AsmOptimizer