diff --git a/HASH2.dsk b/HASH2.dsk
new file mode 100644
index 0000000..6c158c7
Binary files /dev/null and b/HASH2.dsk differ
diff --git a/HASH2.s b/HASH2.s
new file mode 100644
index 0000000..52d4f26
--- /dev/null
+++ b/HASH2.s
@@ -0,0 +1,2666 @@
+	DSK HASH
+
+**************************************************
+* Note:		
+*
+* TO DO:	Grab new header from VSDRIVE 
+*			reset nonce to random? based on last H00?
+*			proceed until new header appears, or n nonces hashed
+*			Repeat.
+**************************************************
+* Variables
+**************************************************
+
+INPUT32				EQU $E0				;	DS	4				; 32-bit Accumulator
+XREGISTER32			EQU	$E4				;	DS	4				; input 1 for XOR, etc (X)
+YREGISTER32			EQU	$E8				;	DS	4				; input 2 for MAJ, etc (Y)
+RESULT32			EQU	$EC				;	DS	4				; temp storage for various operations
+	
+CURRENTCHUNK		EQU	$FF				; chunk zero or one.
+HASHPASS			EQU	$FE				; pass zero or one.
+
+CURRENTMESSAGELO	EQU	$FC
+CURRENTMESSAGEHI	EQU	$FD
+
+S0					EQU $80
+S1					EQU	$84
+
+TEMP0				EQU	$88				; temp storage for various operations
+TEMP1				EQU	$8C				; temp storage for various operations
+
+HASHCACHED			EQU	$D0				; is the first pass already done, and the result cached in CACHEDHASH?
+ITERATION			EQU	$D1				; Do 255 iterations on each header, then fetch new one from disk.
+
+**************************************************
+* Apple Standard Memory Locations
+**************************************************
+CLRLORES	EQU	$F832
+LORES		EQU	$C050
+TXTSET		EQU	$C051
+MIXCLR		EQU	$C052
+MIXSET		EQU	$C053
+TXTPAGE1	EQU	$C054
+TXTPAGE2	EQU	$C055
+KEY			EQU	$C000
+C80STOREOFF	EQU	$C000
+C80STOREON	EQU	$C001
+STROBE		EQU	$C010
+SPEAKER		EQU	$C030
+VBL			EQU	$C02E
+RDVBLBAR	EQU	$C019		; not VBL (VBL signal low
+WAIT		EQU	$FCA8 
+RAMWRTAUX	EQU	$C005
+RAMWRTMAIN	EQU	$C004
+SETAN3		EQU	$C05E		; Set annunciator-3 output to 0
+SET80VID	EQU	$C00D		; enable 80-column display mode (WR-only)
+HOME		EQU	$FC58		; clear the text screen
+VTAB		EQU	$FC22		; Sets the cursor vertical position (from CV)
+COUT		EQU	$FDED		; Calls the output routine whose address is stored in CSW,
+;COUTI		EQU	$fbf0								;  normally COUTI
+CROUT		EQU	$FD8E 			; prints CR
+
+STROUT		EQU	$DB3A			;Y=String ptr high, A=String ptr low
+PRBYTE		EQU	$FDDA 			; print hex byte in A
+
+ALTTEXT		EQU	$C055
+ALTTEXTOFF	EQU	$C054
+
+
+PB0			EQU	$C061		; paddle 0 button. high bit set when pressed.
+PDL0		EQU	$C064		; paddle 0 value, or should I use PREAD?
+PREAD		EQU	$FB1E
+
+ROMINIT  	EQU	$FB2F
+ROMSETKBD	EQU	$FE89
+ROMSETVID	EQU	$FE93
+
+ALTCHAR		EQU	$C00F		; enables alternative character set - mousetext
+
+CH			EQU	$24			; cursor Horiz
+CV			EQU	$25			; cursor Vert
+
+WNDWDTH		EQU	$21			; Width of text window
+WNDTOP		EQU	$22			; Top of text window
+
+BELL   		EQU	$FF3A     	; Monitor BELL routine
+;CROUT  		EQU	$FD8E     	; Monitor CROUT routine
+;PRBYTE 		EQU	$FDDA     	; Monitor PRBYTE routine
+MLI    		EQU	$BF00     	; ProDOS system call
+OPENCMD		EQU	$C8			; OPEN command index
+READCMD		EQU	$CA			; READ command index
+CLOSECMD	EQU	$CC			; CLOSE command index
+
+
+**************************************************
+* START - sets up various fiddly zero page bits
+**************************************************
+
+				ORG $2000						; PROGRAM DATA STARTS AT $2000
+
+				JSR HOME						; clear screen
+
+				STA	$C050   					; rw:TXTCLR	; Set Lo-res page 1, mixed graphics + text
+				STA	$C053   					; rw:MIXSET
+				STA	$C054   					; rw:TXTPAGE1
+				STA	$C056   					; rw:LORES
+
+				JSR FILLSCREENFAST				; blanks screen to black.
+				JSR SPLASHSCREEN				; fancy lo-res graphics
+
+STARTMINING		JSR BLOAD						; load HEADER.BIN into HEADER
+
+]noncebyte = 0
+				LUP 4
+				LDA H00 + ]noncebyte
+				STA NONCE + ]noncebyte
+]noncebyte = ]noncebyte+1
+				--^				
+
+
+				LDA #$00
+				STA HASHCACHED					; clear cache status
+				STA ITERATION					
+				JSR FLIPCOIN
+
+				; set text window to last 4 lines of GR screen.
+				LDA #$14
+				STA CV
+				STA	WNDTOP
+				JSR VTAB
+
+**************************************************
+*	SETUP
+**************************************************
+*
+*	Initialize hash values:
+*	(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+*		See HTABLE
+*	
+*	Initialize array of round constants:
+*	(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):
+*		See KTABLE
+*	
+*	Pre-processing (Padding):
+*	begin with the original message of length L bits (80*8 = 640bits)
+*	append a single '1' bit (641bits)
+*	means shifting everything over 1 bit to be 81 bytes
+*	append K '0' bits, where K is the minimum number >= 0 such that L + 1 + K + 64 is a multiple of 512 (640+1+K+64=1024 K=319)
+*	append L as a 64-bit big-endian integer, making the total post-processed length a multiple of 512 bits (append 0000000000000280)
+
+**************************************************
+*	Pre-processing (Padding):
+**************************************************	
+; Start with MESSAGE padded out to 1024bits (see MESSAGE below)
+
+*	Process the message in successive 512-bit chunks:
+*	break message into 512-bit chunks
+
+*	80byte header yields 1024bit message, so chunks = 2
+*	Cache result of first chunk, so subsequent passes are cache then hash.
+
+PREPROCESS
+				LDA #$00
+				STA HASHPASS					; pass the first = 0
+				STA CURRENTCHUNK				; chunk the first = 0
+				
+				LDA MESSAGELO
+				STA	CURRENTMESSAGELO
+				LDA MESSAGEHI
+				STA	CURRENTMESSAGEHI
+
+INITIALIZEHASH  								; for the 32 bytes in INITIALHASH, push them into H00-H07
+
+INITIALHASHES	
+]hashnumber		=	31
+				LUP 32
+				LDA INITIALHASH + ]hashnumber			
+				STA H00 + ]hashnumber					
+]hashnumber		=	]hashnumber - 1	
+				--^			
+
+*	for each chunk
+*	    create a 64-entry message schedule array w[0..63] of 32-bit words
+*	    (The initial values in w[0..63] don't matter, so many implementations zero them here)
+
+*			See WTABLE				
+
+*	    copy chunk into first 16 words w[0..15] of the message schedule array
+
+COPYCHUNKS
+
+CHECKCACHE
+
+; if HASHCACHED == 1
+; AND chunk=0 AND pass=0
+; then read from CACHEDHASH
+
+				LDA HASHCACHED					; has chunk0 pass0 already done?
+				BEQ NOTCACHED
+				
+CACHEDONE		LDA HASHPASS					; pass = 0
+				ORA CURRENTCHUNK				; chunk = 0
+				BEQ CACHETOHASH
+
+NOTCACHED			JMP NOCACHE
+
+CACHETOHASH
+]cachebyte = 0
+				LUP 32
+				LDA CACHEDHASH + ]cachebyte
+				STA H00 + ]cachebyte
+]cachebyte = ]cachebyte+1
+				--^				
+				JMP CHECKCHUNK
+NOCACHE
+
+
+				LDA CURRENTCHUNK				; which chunk?
+				BNE NEXTCHUNK					; skip chunk0 if already done
+				
+				LDY #$3F						; Y = 63 to 0 on chunk 0, then 64 to 127 on chunk 1
+COPYCHUNK0		LDA (CURRENTMESSAGELO),Y
+				STA W00,Y
+				DEY
+				BPL	COPYCHUNK0					; if hasn't rolled over to FF, loop to copy next byte.
+
+***** if I'm on second pass, only do chunk0
+; HASHPASS = 1, add to CURRENTCHUNK?
+				LDA HASHPASS
+				STA CURRENTCHUNK
+***** if I'm on second pass, only do chunk0
+				
+				JMP EXTENDWORDS					; done with chunk 0
+
+NEXTCHUNK		
+
+
+**** Only does this (second chunk) on first pass. So CURRENTMESSAGE always points to MESSAGE (never MESSAGE2)
+]chunkbyte = 64
+				LUP 64
+COPYCHUNK1		LDA MESSAGE + ]chunkbyte					
+				STA W00 - 64 + ]chunkbyte					; 
+]chunkbyte = ]chunkbyte + 1				
+				--^
+
+**** Only does this (second chunk) on first pass.
+
+
+*	    Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array:
+
+*	    for i from 16 to 63
+*	        s0 = (w[i-15] rightrotate  7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift  3)
+*			s0 = (XREGISTER32) xor (YREGISTER32) xor (INPUT32)
+
+EXTENDWORDS
+				LDX #60								; 15*4
+
+EXTEND				TXA
+				CLC
+				ADC #$04							; increment A = 16
+				;;CMP #$40							; compare to 64*4
+
+				BNE	EXTEND2							; done with EXTEND step (done through 63)
+				JMP INITIALIZE
+				
+EXTEND2			TAX
+				;;SEC									; set carry for subtract
+				;;SBC	#$0F							; -15
+
+				LDXWR15								; takes X as arg. load W[a-15] into XREGISTER32 and ROR32
+
+RIGHTROTATEX7	LUP	6
+				RIGHTROTATEX32						; ROR32 6 more times
+				--^
+
+				STA XREGISTER32		
+				;;TAX32								; should store partial result at XREGISTER32
+				
+RIGHTROTATE18	RIGHTROTATEXY8									; copy from XREGISTER32 into YREGISTER32 and ROR32 9 times
+				LUP 2
+				RIGHTROTATEY32						; ROR32 2 more times
+				--^
+								
+				STA YREGISTER32		
+				;;TAY32								; should store partial result at YREGISTER32
+
+														; X still = X*4
+				LDAWR15									; load W[a-15] into INPUT32
+
+RIGHTSHIFT3		LUP	2
+				RIGHTSHIFT32						; shift right, ignore carry
+				--^
+													; store partial result in INPUT32
+
+*	        s0 = (w[i-15] rightrotate  7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift  3)
+*			s0 = (XREGISTER32) xor (YREGISTER32) xor (INPUT32)
+
+				XORAXY32T0
+
+; A32 -> TEMP0
+				;;STATEMP0								
+			
+*	        s1 := (w[i- 2] rightrotate 17) xor (w[i- 2] rightrotate 19) xor (w[i- 2] rightshift 10)
+				;;SEC									; set carry for subtract
+				;;SBC	#$02							; -02
+
+				LDXWR2								; load W14 into XREGISTER32 and ROR32 17 times
+				STA XREGISTER32		
+									
+RIGHTROTATE17			TXYR32							; copy XREGISTER32 to YREGISTER32 and ROR32
+
+RIGHTROTATE2			RIGHTROTATEY32					; ROR32 1 more time
+				STA YREGISTER32		
+				;;TAY32							; should store partial result at YREGISTER32
+
+													; ; X = X*4
+				LDAWS248							; load W14 into INPUT32 and ROR32
+
+RIGHTSHIFT10	;;RIGHTSHIFT8
+				;;LUP 2
+				RIGHTSHIFT24					; shift right, ignore carry
+				;;--^
+													; store partial result in INPUT32
+*	        s1 := (w[i- 2] rightrotate 17) xor (w[i- 2] rightrotate 19) xor (w[i- 2] rightshift 10)
+*	        s1 := (XREGISTER32) xor (YREGISTER32) xor (INPUT32)
+*	        w[i] := w[i-16] + s0 + w[i-7] + s1
+*	        w[i] := w[i-16] + TEMP0 + w[i-7] + INPUT32
+*	        w[i] := w[i-16] + INPUT32 + w[i-7] + XREGISTER32
+				CLC
+				
+				XORAXYADD24
+
+				;;SEC
+				;;SBC	#$10						; w[0]
+
+				; load W00 into pointer, add with X32, store to X32
+				LDWADDXX16					; takes X
+
+				;;TAX32							; transfer to XREGISTER32
+
+				;;SEC
+				;;SBC	#$07						; w[09]
+
+				; load W09 into pointer, add with X32
+				; store result in w[i]
+												
+				LDWADDX7STA32					; takes X, store in W16
+
+												
+STOREW			;;LDWSTA32						; store in W16
+
+				JMP EXTEND						; repeat until i=63
+
+INITIALIZE
+*	    Initialize working variables to current hash value:
+*	    Va := h00
+*	    Vb := h01
+*	    Vc := h02
+*	    Vd := h03
+*	    Ve := h04
+*	    Vf := h05
+*	    Vg := h06
+*	    Vh := h07
+
+HASHTOV
+
+]bytenumber	= 0		
+			LUP	32
+HTOV		LDA H00 + ]bytenumber
+			STA VA + ]bytenumber
+]bytenumber	= ]bytenumber + 1
+			--^
+
+**************************************************
+*	MAIN LOOP. OPTIMIZE THIS.
+**************************************************
+
+
+
+COMPRESSION
+
+*	    Compression function main loop:
+*	    for i from 0 to 63
+
+				LDA #$00
+COMPRESS			TAX
+					
+*	        S1 := (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)
+
+				LDVLDXR32 4							; pointer to VE, ROR32
+
+RIGHTROTATE06	LUP 5
+				RIGHTROTATEX32					; shift right, ignore carry
+				--^
+				STA XREGISTER32
+				
+				;;TAX32							; result in XREGISTER32
+				TXYR32
+
+RIGHTROTATE11	LUP 4
+				RIGHTROTATEY32					; shift right 5 more times=11, ignore carry
+				--^
+				STA YREGISTER32
+				;;TAY32							; result in YREGISTER32
+				
+RIGHTROTATE25	RIGHTROTATEYA8
+				LUP 5
+				RIGHTROTATEA32					; shift right 14 more times=25, ignore carry
+				--^
+				
+*	        S1 := (XREGISTER32) xor (YREGISTER32) xor (INPUT32)
+
+				XORAXY32S1
+				
+
+;S1
+				;;STAS1								; store INPUT32 in S1
+
+
+**** CHOICE and MAJ always take the same 3 arguments - make macros
+														
+*	        ch := (e and f) xor ((not e) and g)
+; CH in INPUT32
+*	        temp1 := Vh + S1 + ch + k[i] + w[i] = TEMP0
+
+				CHOICE32ADD						
+
+; S1 + CH
+				;;LDSADC32 4							; (S1 + ch) in INPUT32
+				
+; + VH
+				LDVHADC32
+				
+				LDKADC32									; K[i] in pointer
+; + K[i]
+				
+				LDWADCS0							; W[i] in pointer
+; + W[i]
+;				LDXADC32							; (S1 + ch + VH + k[i] + w[i]) in INPUT32
+				
+; = TEMP0
+				;;STATEMP0							; store temp1 at TEMP0
+
+
+
+*	        S0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)
+
+				LDVLDXR32 0								; pointer to VA, ROR32
+
+RIGHTROTATE02	;;LUP 2
+				RIGHTROTATEX32					; ROR 2 times
+				;;--^
+				STA XREGISTER32
+				
+				;;TAX32							; result in XREGISTER32
+				
+RIGHTROTATE13	RIGHTROTATEXY8
+				LUP 2
+				RIGHTROTATEY32					; ROR 11 more times=13
+				--^
+				STA YREGISTER32
+				;;TAY32							; result in YREGISTER32
+				
+RIGHTROTATE22	RIGHTROTATE8
+				RIGHTROTATEA32					; ROR 9 more times=22
+
+				
+*	        S0 := (XREGISTER32) xor (YREGISTER32) xor (INPUT32)
+
+				XORAXY32S0
+
+;S0				
+				;;STAS0								; store INPUT32 in S0
+
+
+**** CHOICE and MAJ always take the same 3 arguments - make macros
+
+*	        maj := (a and b) xor (a and c) xor (b and c)
+*	        temp2 := S0 + maj
+*	        temp2 := S0 + INPUT32
+													; load A,B,C into A32,X32,Y32
+				MAJ32ADDT1							; MAJ in INPUT32
+
+													; load S0 into X32
+;S0 -> X32
+				;;LDA STABLELO						; takes X as argument
+				;;STA $00	
+				;;LDA STABLEHI	
+				;;STA $01       		  				; now word/pointer at $0+$1 points to 32bit word at STABLE,X 
+				;;LDX32								; S0 in XREGISTER32
+				
+				;;CLC
+				;;ADC32								; TEMP2 in INPUT32	
+				
+;A32 -> TEMP1
+				;;STATEMP1							; temp2 to TEMP1
+				
+
+				
+ROTATE
+
+*	        Vh := Vg
+*	        Vg := Vf
+*	        Vf := Ve
+
+; Store VG in VH
+			VXTOVY 6;7
+
+			VXTOVY 5;6
+			
+			VXTOVY 4;5
+
+*	        Ve := Vd + temp1
+
+				LDVADDT0STA 3
+
+;TEMP0 -> X32
+				;;LDX TEMPLO						
+				;;STX $00	
+				;;LDX TEMPHI
+				;;STX $01       		  				; now word/pointer at $0+$1 points to TEMP0
+
+				;;LDXADC32
+
+				;;LDVSTA 4
+
+
+
+*	        Vd := Vc
+*	        Vc := Vb
+*	        Vb := Va
+
+				VXTOVY 2;3
+
+				VXTOVY 1;2
+
+				VXTOVY 0;1
+
+*	        Va := temp1 + temp2
+
+;TEMP1 -> X32
+				;;LDX TEMPLO+1						
+				;;STX $00	
+				;;LDX TEMPHI+1
+				;;STX $01       		  		; now word/pointer at $0+$1 points to TEMP1
+
+				;;LDX32						; load TEMP1 into XREGISTER32
+
+;TEMP0 -> A32
+				LDATEMP0ADD 0
+				;;CLC
+				;;ADC32
+
+				;;LDVSTA 0
+
+COMPRESSLOOP	TXA							; Round 0-63 from stack
+				CLC
+				ADC #$04
+				;;CMP #$40
+				BEQ ADDHASH				; checks to see if we can skip or pull from cache
+
+				JMP COMPRESS
+**************************************************
+*	END MAIN LOOP. 
+
+*	FINALIZE HASH AND OUTPUT.
+**************************************************
+
+
+
+
+ADDHASH
+	
+*	    Add the compressed chunk to the current hash value:
+*	    h0 := h0 + Va
+*	    h1 := h1 + Vb
+*	    h2 := h2 + Vc
+*	    h3 := h3 + Vd
+*	    h4 := h4 + Ve
+*	    h5 := h5 + Vf
+*	    h6 := h6 + Vg
+*	    h7 := h7 + Vh
+
+]varbyte = 0
+				LUP 8
+				
+				CLC
+				LDA H00+3 + ]varbyte
+				ADC VA+3 + ]varbyte
+				STA H00+3 + ]varbyte
+				
+				LDA H00+2 + ]varbyte
+				ADC VA+2 + ]varbyte
+				STA H00+2 + ]varbyte
+				
+				LDA H00+1 + ]varbyte
+				ADC VA+1 + ]varbyte
+				STA H00+1 + ]varbyte
+				
+				LDA H00 + ]varbyte
+				ADC VA + ]varbyte
+				STA H00 + ]varbyte
+]varbyte = ]varbyte + 4
+				--^
+				
+
+; if HASHCACHED == 0
+; AND chunk=0 AND pass=0
+; then write to CACHEDHASH
+
+CHECKCHUNK		LDA CURRENTCHUNK
+				BNE CHECKPASS					; did I just do chunk 0? INC and go back and do second chunk.
+				INC CURRENTCHUNK				; set to chunk 1				
+
+				LDA HASHCACHED					; has chunk0 pass0 already done?
+				BEQ HASHTOCACHE 				; otherwise
+
+				JMP COPYCHUNKS					; 
+
+CHECKPASS		LDA HASHPASS					; pass 0? set the message to the hash output and go again
+
+				BEQ INCHASHPASS					; pass 1, skip to digest.
+				
+				JMP DIGEST
+				
+INCHASHPASS		INC HASHPASS					; 
+				JMP HASHTOMESSAGE
+
+HASHTOCACHE
+]cachebyte = 0
+				LUP 32
+				LDA H00 + ]cachebyte
+				STA CACHEDHASH + ]cachebyte
+]cachebyte = ]cachebyte+1
+				--^				
+
+				INC HASHCACHED					; don't repeat.
+				JMP COPYCHUNKS					; 
+
+				
+
+HASHTOMESSAGE
+				
+												; for each of 32 bytes, Y
+												; load byte from H00,Y
+												; store at MESSAGE2,Y
+COPYHASH
+
+]hashbyte = 31
+				LUP 32
+				LDA H00 + ]hashbyte
+				STA MESSAGE2 + ]hashbyte
+]hashbyte = ]hashbyte - 1
+				--^
+
+				LDA #<MESSAGE2
+				STA	CURRENTMESSAGELO
+				LDA #>MESSAGE2
+				STA	CURRENTMESSAGEHI
+
+******* only need one chunk for message2
+				LDA #$00 
+				STA CURRENTCHUNK
+				JMP INITIALIZEHASH				; re-initializes the original sqrt hash values for pass 2					
+
+DIGEST											; done the thing. 
+
+				LDA #$06						;	set the memory location for line $14.
+				STA $29							;	
+				LDA #$50						;	
+				STA $28							;	
+				LDY #$00				; 0
+				
+PRNONCE
+]hashbyte		=	0				
+				LUP 4
+				LDX NONCE + ]hashbyte							; load from table pointer	
+				PRHEX							; PRBYTE - clobbers Y
+													;**** ROLL MY OWN?
+]hashbyte = ]hashbyte + 1
+				--^
+
+]noncebyte = 0
+				LUP 4
+				LDA H00 + ]noncebyte
+				STA NONCE + ]noncebyte
+]noncebyte = ]noncebyte+1
+				--^				
+
+				INC CV								; down one line
+				INC CV								; down one line
+				LDA #$00
+				STA CH								; left cursor
+				INC $29								; 0650 -> 0750
+				LDA #$50						;	
+				STA $28							;	
+
+
+PRDIGEST		
+				LDX H00				
+				BEQ ZEROBYTE
+				JMP PRBYTE1
+ZEROBYTE							; if zero, spin the coin
+				JSR FLIPCOIN
+				
+									; if the first byte is 00, maybe additional bytes are, too?
+				
+				LDA H00
+]hashbyte		=	1	
+				LUP 8				; 18 leading zeroes == 9 zero bytes at current difficulty (roughly)
+				ORA H00 + ]hashbyte
+]hashbyte = ]hashbyte + 1
+				--^
+				BEQ INTERESTING
+				JMP PRBYTE1
+				
+INTERESTING		LDY #$00			; print the interesting result and then crash
+				PRHEX							
+
+]hashbyte		=	1				
+				LUP 19
+				LDX H00 + ]hashbyte				
+				PRHEX							
+												
+]hashbyte = ]hashbyte + 1
+				--^
+
+				RTS			; drop to monitor if we found anything interesting.
+				
+				
+				
+				LDX H00				
+PRBYTE1			LDY #$00				; 0
+				PRHEX							
+												
+
+
+
+]hashbyte		=	1				
+				LUP 19
+				LDX H00 + ]hashbyte				
+				PRHEX							
+												
+]hashbyte = ]hashbyte + 1
+				--^
+
+
+NEXTLINE			LDA #$D0
+				STA $28				; $0750 to $07D0
+				LDY #$00				; 0
+
+]hashbyte		=	20				
+				LUP 12
+				LDX H00 + ]hashbyte				
+				PRHEX							
+												
+]hashbyte = ]hashbyte + 1
+				--^
+
+
+				INC ITERATION
+				BEQ DONEWORK 
+
+				JMP PREPROCESS					; INC NONCE, start over.		
+
+DONEWORK		
+
+				JMP STARTMINING
+
+
+
+**************************************************
+*	macros (expanded at assembly time)
+**************************************************
+
+;;LDW			MAC
+;;			LDA WTABLELO,X					; takes X as argument
+;;			STA $00
+;;			LDA WTABLEHI,X
+;;			STA $01       		  			; now word/pointer at $0+$1 points to 32bit word at WTABLE,X 
+;;            <<<            ; End of Macro
+
+;;LDK			MAC
+;;			LDA KTABLELO,X					; takes X as argument
+;;			STA $00
+;;			LDA KTABLEHI,X
+;;			STA $01       		  			; now word/pointer at $0+$1 points to 32bit word at KTABLE,X 
+;;            <<<            ; End of Macro
+
+;	LDH			MAC
+;				LDA HTABLELO,X					; takes X as argument
+;				STA $00
+;				LDA HTABLEHI,X
+;				STA $01       		  			; now word/pointer at $0+$1 points to 32bit word at HTABLE,X 
+;	            <<<            ; End of Macro
+
+;;LDV			MAC
+;;				LDA VTABLELO,X					; takes X as argument
+;;				STA $00
+;;				LDA VTABLEHI,X
+;;				STA $01       		  			; now word/pointer at $0+$1 points to 32bit word at VTABLE,X 
+;;	            <<<            ; End of Macro
+
+;;LDVV		MAC
+;;			LDA VTABLELO+]1					; takes X as argument
+;;			STA $00
+;;			LDA VTABLEHI+]1
+;;			STA $01       		  			; now word/pointer at $0+$1 points to 32bit word at VTABLE,X 
+;;            <<<            ; End of Macro
+
+
+
+LDVLDXR32	MAC
+			LDA VA + ]1 + ]1 + ]1 + ]1			; load from table pointer
+			LSR
+			STA XREGISTER32						; store in 32 bit "accumulator"
+
+			LDA VA + ]1 + ]1 + ]1 + ]1 +1		; load from table pointer
+			ROR
+			STA XREGISTER32+1					; store in 32 bit "accumulator"
+	
+			LDA VA + ]1 + ]1 + ]1 + ]1 +2		; load from table pointer
+			ROR
+			STA XREGISTER32+2					; store in 32 bit "accumulator"
+
+			LDA VA + ]1 + ]1 + ]1 + ]1 +3		; load from table pointer
+			ROR
+			STA XREGISTER32+3					; store in 32 bit "accumulator"
+
+			LDA #$00							; accumulator to 0
+			ROR								; CARRY into bit7
+			ORA	XREGISTER32					; acccumulator bit7 into BIT31
+	
+            <<<            ; End of Macro
+
+LDVADDT0STA	MAC
+			CLC
+			LDA VA + ]1 + ]1 + ]1 + ]1 +3		; load from table pointer
+			ADC TEMP0 +3
+			STA VA + 16 +3				; load from table pointer
+	
+			LDA VA + ]1 + ]1 + ]1 + ]1 +2		; load from table pointer
+			ADC TEMP0 +2
+			STA VA + 16 +2				; load from table pointer
+	
+			LDA VA + ]1 + ]1 + ]1 + ]1 +1		; load from table pointer
+			ADC TEMP0 +1
+			STA VA + 16 +1				; load from table pointer
+	
+			LDA VA + ]1 + ]1 + ]1 + ]1			; load from table pointer
+			ADC TEMP0
+			STA VA + 16				; load from table pointer
+
+            <<<            ; End of Macro
+
+LDVLDX		MAC
+			LDA VA + ]1 + ]1 + ]1 + ]1 +3		; load from table pointer
+			STA XREGISTER32+3					; store in 32 bit "accumulator"
+	
+			LDA VA + ]1 + ]1 + ]1 + ]1 +2		; load from table pointer
+			STA XREGISTER32+2					; store in 32 bit "accumulator"
+	
+			LDA VA + ]1 + ]1 + ]1 + ]1 +1		; load from table pointer
+			STA XREGISTER32+1					; store in 32 bit "accumulator"
+	
+			LDA VA + ]1 + ]1 + ]1 + ]1			; load from table pointer
+			STA XREGISTER32						; store in 32 bit "accumulator"
+
+            <<<            ; End of Macro
+
+
+LDVSTA		MAC
+			LDA INPUT32+3						; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1 +3		; load from table pointer
+	
+			LDA INPUT32+2						; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1 +2		; load from table pointer
+	
+			LDA INPUT32+1						; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1 +1		; load from table pointer
+	
+			LDA INPUT32						; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1		; load from table pointer
+
+            <<<            ; End of Macro
+
+
+VXTOVY		MAC										; rotate Vn to Vn-1
+			
+			LDA VA + ]1+ ]1+ ]1+ ]1 				; load from table pointer
+			STA VA + ]2+ ]2+ ]2+ ]2					; store in table pointer
+	
+			LDA VA +  ]1+ ]1+ ]1+ ]1 + 1			; load from table pointer
+			STA VA +  ]2+ ]2+ ]2+ ]2 + 1			; store in table pointer
+	
+			LDA VA +  ]1+ ]1+ ]1+ ]1 + 2			; load from table pointer
+			STA VA +  ]2+ ]2+ ]2+ ]2 + 2			; store in table pointer
+	
+			LDA VA +  ]1+ ]1+ ]1+ ]1 + 3			; load from table pointer
+			STA VA +  ]2+ ]2+ ]2+ ]2 + 3			; store in table pointer
+            <<<            ; End of Macro
+
+
+
+LDXWR15		MAC									; X indicates which W0x word to read from
+
+				LDA W00 - 60,X						; load from table pointer
+				LSR
+				STA XREGISTER32							; store in 32 bit "accumulator"
+
+				LDA W00 + 1 - 60,X						; load from table pointer
+				ROR
+				STA XREGISTER32+1						; store in 32 bit "accumulator"
+
+				LDA W00 + 2 - 60,X						; load from table pointer
+				ROR
+				STA XREGISTER32+2						; store in 32 bit "accumulator"
+
+				LDA W00 + 3 - 60,X						; load from table pointer
+				ROR
+				STA XREGISTER32+3						; store in 32 bit "accumulator"
+
+				LDA #$00							; accumulator to 0
+				ROR								; CARRY into bit7
+				ORA	XREGISTER32						; acccumulator bit7 into BIT31
+
+			<<<
+
+
+LDXWR2		MAC									; X indicates which W0x word to read from
+
+				LDA W00 + 2 - 8,X						; load from table pointer
+				LSR
+				STA XREGISTER32							; store in 32 bit "accumulator"
+
+				LDA W00 + 3 - 8,X						; load from table pointer
+				ROR
+				STA XREGISTER32+1						; store in 32 bit "accumulator"
+
+				LDA W00 - 8,X							; load from table pointer
+				ROR
+				STA XREGISTER32+2						; store in 32 bit "accumulator"
+
+				LDA W00 + 1 - 8,X						; load from table pointer
+				ROR
+				STA XREGISTER32+3						; store in 32 bit "accumulator"
+
+				LDA #$00							; accumulator to 0
+				ROR								; CARRY into bit7
+				ORA	XREGISTER32						; acccumulator bit7 into BIT31
+
+			<<<
+
+
+LDAWR15		MAC									; X indicates which W0x word to read from
+			
+			LDA W00 - 60,X							; load from table pointer
+			LSR
+			STA INPUT32							; store in 32 bit "accumulator"
+
+			LDA W00 + 1 - 60,X						; load from table pointer
+			ROR
+			STA INPUT32+1							; store in 32 bit "accumulator"
+	
+			LDA W00 + 2 - 60,X						; load from table pointer
+			ROR
+			STA INPUT32+2							; store in 32 bit "accumulator"
+	
+			LDA W00 + 3 - 60,X						; load from table pointer
+			ROR
+	
+			<<<
+			
+
+LDAW		MAC									; X indicates which W0x word to read from
+			
+			LDA W00 + 3,X						; load from table pointer
+			STA INPUT32+3						; store in 32 bit "accumulator"
+	
+			LDA W00 + 2,X						; load from table pointer
+			STA INPUT32+2						; store in 32 bit "accumulator"
+	
+			LDA W00 + 1,X						; load from table pointer
+			STA INPUT32+1						; store in 32 bit "accumulator"
+	
+			LDA W00,X							; load from table pointer
+			STA INPUT32							; store in 32 bit "accumulator"
+
+			<<<
+			
+
+LDAWS248	MAC									; X indicates which W0x word to read from
+
+			LDA W00 - 8,X							; load from table pointer
+			LSR
+			STA INPUT32+1						; store in 32 bit "accumulator"
+
+			LDA W00 + 1 - 8,X					; load from table pointer
+			ROR
+			STA INPUT32+2						; store in 32 bit "accumulator"
+	
+			LDA W00 + 2 - 8,X					; load from table pointer
+			ROR
+	
+			<<<
+			
+
+LDWSTA32	MAC									; store INPUT32 in W0x word
+
+			LDA INPUT32+3						; load from 32 bit "accumulator"
+			STA W00 + 3,X							; store in table pointer
+	
+			LDA INPUT32+2						; load from 32 bit "accumulator"
+			STA W00 + 2,X							; store in table pointer
+	
+			LDA INPUT32+1						; load from 32 bit "accumulator"
+			STA W00 + 1,X							; store in table pointer
+	
+			LDA INPUT32						; load from 32 bit "accumulator"
+			STA W00,X							; store in table pointer
+
+			<<<
+
+
+STA32		MAC				; puts 4 bytes from 32 bit "accumulator" INPUT32 into ($01,$00), clobbers A,Y
+
+			LDY #$03							
+			LDA INPUT32+3						; load from 32 bit "accumulator"
+			STA ($0),Y							; store in table pointer
+	
+			LDY #$02							
+			LDA INPUT32+2						; load from 32 bit "accumulator"
+			STA ($0),Y							; store in table pointer
+	
+			LDY #$01							
+			LDA INPUT32+1						; load from 32 bit "accumulator"
+			STA ($0),Y							; store in table pointer
+	
+			LDY #$00							
+			LDA INPUT32						; load from 32 bit "accumulator"
+			STA ($0),Y							; store in table pointer
+	
+            <<<            ; End of Macro
+
+
+
+STAS1		MAC				; puts 4 bytes from 32 bit "accumulator" INPUT32 into S1
+
+			LDA INPUT32+3						; load from 32 bit "accumulator"
+			STA S1+3							; store in table pointer
+	
+			LDA INPUT32+2						; load from 32 bit "accumulator"
+			STA S1+2							; store in table pointer
+	
+			LDA INPUT32+1						; load from 32 bit "accumulator"
+			STA S1+1							; store in table pointer
+	
+			LDA INPUT32						; load from 32 bit "accumulator"
+			STA S1							; store in table pointer
+	
+            <<<            ; End of Macro
+
+
+STAS0		MAC				; puts 4 bytes from 32 bit "accumulator" INPUT32 into S0
+
+			LDA INPUT32+3						; load from 32 bit "accumulator"
+			STA S0+3							; store in table pointer
+	
+			LDA INPUT32+2						; load from 32 bit "accumulator"
+			STA S0+2							; store in table pointer
+	
+			LDA INPUT32+1						; load from 32 bit "accumulator"
+			STA S0+1							; store in table pointer
+	
+			LDA INPUT32						; load from 32 bit "accumulator"
+			STA S0							; store in table pointer
+	
+            <<<            ; End of Macro
+
+STATEMP1		MAC				; puts 4 bytes from 32 bit "accumulator" INPUT32 into TEMP0
+
+			LDA INPUT32+3						; load from 32 bit "accumulator"
+			STA TEMP1+3							; store in table pointer
+	
+			LDA INPUT32+2						; load from 32 bit "accumulator"
+			STA TEMP1+2							; store in table pointer
+	
+			LDA INPUT32+1						; load from 32 bit "accumulator"
+			STA TEMP1+1							; store in table pointer
+	
+			LDA INPUT32						; load from 32 bit "accumulator"
+			STA TEMP1							; store in table pointer
+	
+            <<<            ; End of Macro
+
+
+
+STATEMP0	MAC				; puts 4 bytes from 32 bit "accumulator" INPUT32 into TEMP0
+
+			LDA INPUT32+3						; load from 32 bit "accumulator"
+			STA TEMP0+3							; store in table pointer
+	
+			LDA INPUT32+2						; load from 32 bit "accumulator"
+			STA TEMP0+2							; store in table pointer
+	
+			LDA INPUT32+1						; load from 32 bit "accumulator"
+			STA TEMP0+1							; store in table pointer
+	
+			LDA INPUT32						; load from 32 bit "accumulator"
+			STA TEMP0							; store in table pointer
+	
+            <<<            ; End of Macro
+
+
+
+LDATEMP0ADD		MAC				; puts 4 bytes from ($01,$00) into 32 bit "accumulator" INPUT32, clobbers A,Y
+
+			CLC
+			LDA TEMP0+3							; load from table pointer
+			ADC INPUT32+3						; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1 +3		; load from table pointer	
+	
+			LDA TEMP0+2							; load from table pointer
+			ADC INPUT32+2						; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1 +2		; load from table pointer
+	
+			LDA TEMP0+1							; load from table pointer
+			ADC INPUT32+1						; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1 +1		; load from table pointer
+	
+			LDA TEMP0							; load from table pointer
+			ADC INPUT32							; store in 32 bit "accumulator"
+			STA VA + ]1 + ]1 + ]1 + ]1		; load from table pointer
+
+            <<<            ; End of Macro
+;/LDATEMP0
+
+
+LDA32		MAC				; puts 4 bytes from ($01,$00) into 32 bit "accumulator" INPUT32, clobbers A,Y
+			LDY #$03							
+			LDA ($0),Y							; load from table pointer
+			STA INPUT32+3						; store in 32 bit "accumulator"
+	
+			LDY #$02							
+			LDA ($0),Y							; load from table pointer
+			STA INPUT32+2						; store in 32 bit "accumulator"
+	
+			LDY #$01							
+			LDA ($0),Y							; load from table pointer
+			STA INPUT32+1						; store in 32 bit "accumulator"
+	
+			LDY #$00							
+			LDA ($0),Y							; load from table pointer
+			STA INPUT32						; store in 32 bit "accumulator"
+
+            <<<            ; End of Macro
+;/LDA32
+LDX32		MAC				; puts 4 bytes from ($01,$00) into 32 bit "X register" XREGISTER32
+			LDY #$03							
+			LDA ($0),Y							; load from table pointer
+			STA XREGISTER32+3						; store in 32 bit "X register"
+	
+			LDY #$02							
+			LDA ($0),Y							; load from table pointer
+			STA XREGISTER32+2						; store in 32 bit "X register"
+	
+			LDY #$01							
+			LDA ($0),Y							; load from table pointer
+			STA XREGISTER32+1						; store in 32 bit "X register"
+	
+			LDY #$00							
+			LDA ($0),Y							; load from table pointer
+			STA XREGISTER32						; store in 32 bit "X register"
+
+            <<<            ; End of Macro
+;/LDX32
+LDY32		MAC				; puts 4 bytes from ($01,$00) into 32 bit "Y register" YREGISTER32
+			LDY #$03							
+			LDA ($0),Y							; load from table pointer
+			STA YREGISTER32+3						; store in 32 bit "Y register"
+	
+			LDY #$02							
+			LDA ($0),Y							; load from table pointer
+			STA YREGISTER32+2						; store in 32 bit "Y register"
+	
+			LDY #$01							
+			LDA ($0),Y							; load from table pointer
+			STA YREGISTER32+1						; store in 32 bit "Y register"
+	
+			LDY #$00							
+			LDA ($0),Y							; load from table pointer
+			STA YREGISTER32						; store in 32 bit "Y register"
+
+            <<<            ; End of Macro
+;/LDY32
+
+TAX32		MAC				
+			LDA INPUT32+3								; load from INPUT32
+			STA XREGISTER32+3								; store in 32 bit "X register"
+			LDA INPUT32+2								; load from INPUT32
+			STA XREGISTER32+2								; store in 32 bit "X register"
+			LDA INPUT32+1								; load from INPUT32
+			STA XREGISTER32+1								; store in 32 bit "X register"
+			LDA INPUT32								; load from INPUT32
+			STA XREGISTER32								; store in 32 bit "X register"
+            <<<            ; End of Macro
+;/TAX32
+
+TAY32		MAC				
+			LDA INPUT32+3								; load from INPUT32
+			STA YREGISTER32+3								; store in 32 bit "Y register"
+			LDA INPUT32+2								; load from INPUT32
+			STA YREGISTER32+2								; store in 32 bit "Y register"
+			LDA INPUT32+1								; load from INPUT32
+			STA YREGISTER32+1								; store in 32 bit "Y register"
+			LDA INPUT32								; load from INPUT32
+			STA YREGISTER32								; store in 32 bit "Y register"
+            <<<            ; End of Macro
+;/TAY32
+
+TXA32		MAC				
+			LDA XREGISTER32+3								; load from 32 bit "X register"
+			STA INPUT32+3								; store in INPUT32
+			LDA XREGISTER32+2								; load from 32 bit "X register"
+			STA INPUT32+2								; store in INPUT32
+			LDA XREGISTER32+1								; load from 32 bit "X register"
+			STA INPUT32+1								; store in INPUT32
+			LDA XREGISTER32								; load from 32 bit "X register"
+			STA INPUT32								; store in INPUT32
+            <<<            ; End of Macro
+;/TXA32
+
+TYA32		MAC				
+			LDA YREGISTER32+3							; load from 32 bit "Y register"
+			STA INPUT32+3								; store in INPUT32
+			LDA YREGISTER32+2							; load from 32 bit "Y register"
+			STA INPUT32+2								; store in INPUT32
+			LDA YREGISTER32+1							; load from 32 bit "Y register"
+			STA INPUT32+1								; store in INPUT32
+			LDA YREGISTER32							; load from 32 bit "Y register"
+			STA INPUT32								; store in INPUT32
+            <<<            ; End of Macro
+
+;/TYA32
+
+TYX32		MAC				
+			LDA YREGISTER32+3							; load from 32 bit "Y register"
+			STA XREGISTER32+3							; store in XREGISTER32
+			LDA YREGISTER32+2							; load from 32 bit "Y register"
+			STA XREGISTER32+2							; store in XREGISTER32
+			LDA YREGISTER32+1							; load from 32 bit "Y register"
+			STA XREGISTER32+1							; store in XREGISTER32
+			LDA YREGISTER32							; load from 32 bit "Y register"
+			STA XREGISTER32							; store in XREGISTER32
+            <<<            ; End of Macro
+
+;/TYX32
+
+
+
+TXYR32		MAC				
+			LSR								; load from 32 bit "X register"
+			STA YREGISTER32							; store in YREGISTER32
+			LDA XREGISTER32+1							; load from 32 bit "X register"
+			ROR
+			STA YREGISTER32+1							; store in YREGISTER32
+			LDA XREGISTER32+2							; load from 32 bit "X register"
+			ROR
+			STA YREGISTER32+2							; store in YREGISTER32
+			LDA XREGISTER32+3							; load from 32 bit "X register"
+			ROR
+			STA YREGISTER32+3							; store in YREGISTER32
+			LDA #$00							; accumulator to 0
+			ROR									; CARRY into bit7
+			ORA	YREGISTER32							; acccumulator bit7 into BIT31
+
+            <<<            ; End of Macro
+
+;/TXYR32
+
+
+
+RIGHTROTATEXY8	MAC							; rotate INPUT32 by a full byte
+			STA YREGISTER32+1
+			LDA XREGISTER32+3
+			LSR
+			STA YREGISTER32
+			ROR YREGISTER32+1
+			LDA XREGISTER32+1
+			ROR
+			STA YREGISTER32+2
+			LDA XREGISTER32+2
+			ROR
+			STA YREGISTER32+3
+			LDA #$00							; accumulator to 0
+			ROR									; CARRY into bit7
+			ORA	YREGISTER32						; acccumulator bit7 into BIT31
+            <<<            ; End of Macro
+;/RIGHTROTATEXY8
+
+RIGHTROTATEYA8	MAC							; rotate INPUT32 by a full byte
+			STA INPUT32+1
+			LDA YREGISTER32+3
+			LSR
+			STA INPUT32
+			ROR INPUT32+1
+			LDA YREGISTER32+1
+			ROR
+			STA INPUT32+2
+			LDA YREGISTER32+2
+			ROR
+			STA INPUT32+3
+			LDA #$00							; accumulator to 0
+			ROR									; CARRY into bit7
+			ORA	INPUT32							; acccumulator bit7 into BIT31
+            <<<            ; End of Macro
+;/RIGHTROTATEYA8
+
+RIGHTROTATE8	MAC							; rotate INPUT32 by a full byte
+			STA	INPUT32+1
+			LDA YREGISTER32+1
+			STA INPUT32+2
+			LDA YREGISTER32+2
+			STA INPUT32+3
+			LDA YREGISTER32+3
+            <<<            ; End of Macro
+;/RIGHTROTATE8
+
+RIGHTSHIFT8	MAC									; rotate 32 bits right, 0->BIT31, clobbers AY
+			LDY	#$00
+			LDA INPUT32+2
+			STA INPUT32+3
+			LDA INPUT32+1
+			STA INPUT32+2
+			LDA INPUT32
+			STA	INPUT32+1
+			STY INPUT32
+            <<<            ; End of Macro
+;/RIGHTSHIFT8
+
+
+RIGHTROTATEX32	MAC								; rotate 32 bits right, BIT0->BIT31, clobbers AY
+			RIGHTSHIFTX32
+
+			LDA #$00							; accumulator to 0
+			ROR									; CARRY into bit7
+			ORA	XREGISTER32							; acccumulator bit7 into BIT31
+
+            <<<            ; End of Macro
+;/RIGHTROTATEX32
+		
+												
+RIGHTROTATEY32	MAC								; rotate 32 bits right, BIT0->BIT31, clobbers AY
+			RIGHTSHIFTY32
+
+			LDA #$00							; accumulator to 0
+			ROR									; CARRY into bit7
+			ORA	YREGISTER32							; acccumulator bit7 into BIT31
+
+            <<<            ; End of Macro
+;/RIGHTROTATEY32
+		
+												
+RIGHTROTATE32	MAC								; rotate 32 bits right, BIT0->BIT31, clobbers AY
+			RIGHTSHIFT32
+
+			LDA #$00							; accumulator to 0
+			ROR									; CARRY into bit7
+			ORA	INPUT32								; acccumulator bit7 into BIT31
+
+            <<<            ; End of Macro
+;/RIGHTROTATE32
+		
+												
+RIGHTROTATEA32	MAC								; rotate 32 bits right, BIT0->BIT31, clobbers AY
+			RIGHTSHIFTA32
+
+			LDA #$00							; accumulator to 0
+			ROR									; CARRY into bit7
+			ORA	INPUT32								; acccumulator bit7 into BIT31
+
+            <<<            ; End of Macro
+;/RIGHTROTATEA32
+		
+												
+RIGHTSHIFTX32	MAC									; rotate 32 bits right, 0->BIT31, clobbers AY
+			LSR
+			STA XREGISTER32		
+			ROR XREGISTER32+1							; put result into XREGISTER32
+			ROR XREGISTER32+2							; put result into XREGISTER32
+			ROR XREGISTER32+3							; put result into XREGISTER32
+			
+            <<<            ; End of Macro
+;/RIGHTSHIFTX32
+
+
+RIGHTSHIFTY32	MAC									; rotate 32 bits right, 0->BIT31, clobbers AY
+			LSR
+			STA YREGISTER32		
+			ROR YREGISTER32+1							; put result into YREGISTER32
+			ROR YREGISTER32+2							; put result into YREGISTER32
+			ROR YREGISTER32+3							; put result into YREGISTER32
+			
+            <<<            ; End of Macro
+;/RIGHTSHIFTY32
+
+
+RIGHTSHIFT32	MAC									; rotate 32 bits right, 0->BIT31, clobbers AY
+			LSR INPUT32		
+			ROR INPUT32+1								; put result into INPUT32
+			ROR INPUT32+2								; put result into INPUT32
+			ROR									; put result into INPUT32
+			
+            <<<            ; End of Macro
+;/RIGHTSHIFT32
+
+
+RIGHTSHIFTA32	MAC									; rotate 32 bits right, 0->BIT31, clobbers AY
+			LSR		
+			STA INPUT32
+			ROR INPUT32+1								; put result into INPUT32
+			ROR INPUT32+2								; put result into INPUT32
+			ROR INPUT32+3								; put result into INPUT32
+			
+            <<<            ; End of Macro
+;/RIGHTSHIFTA32
+
+
+RIGHTSHIFT24	MAC									; rotate 24 bits right, 0->BIT23, clobbers AY
+			LSR INPUT32+1								; put result into INPUT32
+			ROR INPUT32+2								; put result into INPUT32
+			ROR									; put result into INPUT32
+			
+            <<<            ; End of Macro
+;/RIGHTSHIFT24
+
+
+ADC32	MAC	; Adds INPUT32 and XREGISTER32 with carry, if any, clobbers A,Y
+			LDA INPUT32+3								; LDA byte
+			ADC XREGISTER32+3								; ADD with CARRY with OPERAND
+			STA INPUT32+3								; output to INPUT32, overflow into carry
+			
+			LDA INPUT32+2								; LDA byte
+			ADC XREGISTER32+2								; ADD with CARRY with OPERAND
+			STA INPUT32+2								; output to INPUT32, overflow into carry
+			
+			LDA INPUT32+1								; LDA byte
+			ADC XREGISTER32+1								; ADD with CARRY with OPERAND
+			STA INPUT32+1								; output to INPUT32, overflow into carry
+			
+			LDA INPUT32								; LDA byte
+			ADC XREGISTER32								; ADD with CARRY with OPERAND
+			STA INPUT32								; output to INPUT32, overflow into carry
+			
+            <<<            ; End of Macro
+;/ADC32
+
+
+
+LDKADC32	MAC								; puts 4 bytes from K0n into 32 bit "accumulator" INPUT32, clobbers A,Y
+			CLC
+			LDA K00 + 3,X					; load from table pointer
+			ADC INPUT32+3				; ADD with CARRY with OPERAND
+			STA INPUT32+3					; output to INPUT32, overflow into carry
+	
+			LDA K00 + 2,X					; load from table pointer
+			ADC INPUT32+2				; ADD with CARRY with OPERAND
+			STA INPUT32+2					; output to INPUT32, overflow into carry
+	
+			LDA K00 + 1,X					; load from table pointer
+			ADC INPUT32+1				; ADD with CARRY with OPERAND
+			STA INPUT32+1					; output to INPUT32, overflow into carry
+	
+			LDA K00,X						;load from table pointer
+			ADC INPUT32					; ADD with CARRY with OPERAND
+			STA INPUT32						; output to INPUT32, overflow into carry
+
+            <<<            ; End of Macro
+;/LDKADC32
+
+
+LDVHADC32	MAC								; puts 4 bytes from K0n into 32 bit "accumulator" INPUT32, clobbers A,Y
+			CLC
+
+			LDA VH+3					; load from table pointer
+			ADC INPUT32+3				; ADD with CARRY with OPERAND
+			STA INPUT32+3					; output to INPUT32, overflow into carry
+	
+			LDA VH+2					; load from table pointer
+			ADC INPUT32+2				; ADD with CARRY with OPERAND
+			STA INPUT32+2					; output to INPUT32, overflow into carry
+	
+			LDA VH+1					; load from table pointer
+			ADC INPUT32+1				; ADD with CARRY with OPERAND
+			STA INPUT32+1					; output to INPUT32, overflow into carry
+	
+			LDA VH						;load from table pointer
+			ADC INPUT32					; ADD with CARRY with OPERAND
+			STA INPUT32						; output to INPUT32, overflow into carry
+
+            <<<            ; End of Macro
+;/LDVHADC32
+
+
+LDWADCS0	MAC							; puts 4 bytes from W0n into 32 bit "accumulator" INPUT32, clobbers A,Y
+			CLC
+			LDA W00 + 3,X					; load from table pointer
+			ADC INPUT32+3				; ADD with CARRY with OPERAND
+			STA TEMP0+3					; output to TEMP0, overflow into carry
+	
+			LDA W00 + 2,X					; load from table pointer
+			ADC INPUT32+2				; ADD with CARRY with OPERAND
+			STA TEMP0+2					; output to TEMP0, overflow into carry
+	
+			LDA W00 + 1,X					; load from table pointer
+			ADC INPUT32+1				; ADD with CARRY with OPERAND
+			STA TEMP0+1					; output to TEMP0, overflow into carry
+	
+			LDA W00,X						;load from table pointer
+			ADC INPUT32					; ADD with CARRY with OPERAND
+			STA TEMP0						; output to TEMP0, overflow into carry
+
+            <<<            ; End of Macro
+;/LDWADC
+
+
+LDWADDXX16	MAC							; puts 4 bytes from W0n into 32 bit "accumulator" XREGISTER32, clobbers A,Y
+
+			CLC
+			LDA W00 + 3 - 64,X				; load from table pointer
+			ADC XREGISTER32+3				; ADD with CARRY with OPERAND
+			STA XREGISTER32+3				; output to INPUT32, overflow into carry
+	
+			LDA W00 + 2 - 64,X				; load from table pointer
+			ADC XREGISTER32+2				; ADD with CARRY with OPERAND
+			STA XREGISTER32+2				; output to INPUT32, overflow into carry
+	
+			LDA W00 + 1 - 64,X				; load from table pointer
+			ADC XREGISTER32+1				; ADD with CARRY with OPERAND
+			STA XREGISTER32+1				; output to INPUT32, overflow into carry
+	
+			LDA W00 - 64,X						;load from table pointer
+			ADC XREGISTER32					; ADD with CARRY with OPERAND
+			STA XREGISTER32					; output to INPUT32, overflow into carry
+
+            <<<            ; End of Macro
+;/LDWADDXX
+
+LDWADDX7STA32	MAC							; puts 4 bytes from W0n into 32 bit "accumulator" INPUT32, clobbers A,Y
+
+			CLC
+			LDA W00 + 3 - 28,X				; load from table pointer
+			ADC XREGISTER32+3				; ADD with CARRY with OPERAND
+			STA W00 + 3,X							; store in table pointer
+	
+			LDA W00 + 2 - 28,X				; load from table pointer
+			ADC XREGISTER32+2				; ADD with CARRY with OPERAND
+			STA W00 + 2,X							; store in table pointer
+	
+			LDA W00 + 1 - 28,X				; load from table pointer
+			ADC XREGISTER32+1				; ADD with CARRY with OPERAND
+			STA W00 + 1,X							; store in table pointer
+	
+			LDA W00 - 28,X						;load from table pointer
+			ADC XREGISTER32					; ADD with CARRY with OPERAND
+			STA W00,X							; store in table pointer
+
+            <<<            ; End of Macro
+;/LDWADDX
+
+LDWADDX	MAC								; puts 4 bytes from W0n into 32 bit "accumulator" INPUT32, clobbers A,Y
+
+			TXA
+			ASL
+			ROL
+			TAX								; x=x*4
+
+			LDA W00 + 3,X					; load from table pointer
+			ADC XREGISTER32+3				; ADD with CARRY with OPERAND
+			STA INPUT32+3					; output to INPUT32, overflow into carry
+	
+			LDA W00 + 2,X					; load from table pointer
+			ADC XREGISTER32+2				; ADD with CARRY with OPERAND
+			STA INPUT32+2					; output to INPUT32, overflow into carry
+	
+			LDA W00 + 1,X					; load from table pointer
+			ADC XREGISTER32+1				; ADD with CARRY with OPERAND
+			STA INPUT32+1					; output to INPUT32, overflow into carry
+	
+			LDA W00,X						;load from table pointer
+			ADC XREGISTER32					; ADD with CARRY with OPERAND
+			STA INPUT32						; output to INPUT32, overflow into carry
+
+            <<<            ; End of Macro
+;/LDWADDX
+
+LDXADC32	MAC									; adds INPUT32 with bytes from table 00,01
+
+			CLC
+			LDY #$03							
+			LDA INPUT32+3						; LDA byte
+			ADC ($0),Y							; ADD with CARRY with OPERAND
+			STA INPUT32+3						; output to INPUT32, overflow into carry
+	
+			LDY #$02							
+			LDA INPUT32+2						; LDA byte
+			ADC ($0),Y							; ADD with CARRY with OPERAND
+			STA INPUT32+2						; output to INPUT32, overflow into carry
+
+			LDY #$01							
+			LDA INPUT32+1						; LDA byte
+			ADC ($0),Y							; ADD with CARRY with OPERAND
+			STA INPUT32+1						; output to INPUT32, overflow into carry
+
+			LDY #$00							
+			LDA INPUT32							; LDA byte
+			ADC ($0),Y							; ADD with CARRY with OPERAND
+			STA INPUT32							; output to INPUT32, overflow into carry
+
+            <<<            ; End of Macro
+;/LDXADC32
+
+
+
+
+LDSADC32	MAC									; adds INPUT32 with bytes from Stable
+
+			CLC
+			LDA INPUT32+3						; LDA byte
+			ADC S0 + ]1 + 3							; ADD with CARRY with OPERAND
+			STA INPUT32+3						; output to INPUT32, overflow into carry
+	
+			LDA INPUT32+2						; LDA byte
+			ADC S0 + ]1 + 2							; ADD with CARRY with OPERAND
+			STA INPUT32+2						; output to INPUT32, overflow into carry
+
+			LDA INPUT32+1						; LDA byte
+			ADC S0 + ]1 + 1							; ADD with CARRY with OPERAND
+			STA INPUT32+1						; output to INPUT32, overflow into carry
+
+			LDA INPUT32							; LDA byte
+			ADC S0 + ]1							; ADD with CARRY with OPERAND
+			STA INPUT32							; output to INPUT32, overflow into carry
+
+            <<<            ; End of Macro
+;/LDSADC32
+
+
+
+
+
+
+
+AND32	MAC										; AND function, output to INPUT32, clobbers AY
+			LDA INPUT32+3								; LDA byte
+			AND XREGISTER32+3								; AND with OPERAND
+			STA	INPUT32+3								; output to INPUT32
+			
+			LDA INPUT32+2								; LDA byte
+			AND XREGISTER32+2								; AND with OPERAND
+			STA	INPUT32+2								; output to INPUT32
+			
+			LDA INPUT32+2								; LDA byte
+			AND XREGISTER32+1								; AND with OPERAND
+			STA	INPUT32+1								; output to INPUT32
+			
+			LDA INPUT32								; LDA byte
+			AND XREGISTER32								; AND with OPERAND
+			STA	INPUT32								; output to INPUT32
+			
+            <<<            ; End of Macro
+			
+;/AND32
+
+;	XOR32	MAC									; XOR function, output to INPUT32, clobbers AY
+;				LDA INPUT32+3								; LDA byte
+;				EOR XREGISTER32+3								; EOR with OPERAND
+;				STA	INPUT32+3								; output to INPUT32
+;				
+;				LDA INPUT32+2								; LDA byte
+;				EOR XREGISTER32+2								; EOR with OPERAND
+;				STA	INPUT32+2								; output to INPUT32
+;				
+;				LDA INPUT32+1								; LDA byte
+;				EOR XREGISTER32+1								; EOR with OPERAND
+;				STA	INPUT32+1								; output to INPUT32
+;				
+;				LDA INPUT32								; LDA byte
+;				EOR XREGISTER32								; EOR with OPERAND
+;				STA	INPUT32								; output to INPUT32
+;				
+;	            <<<            ; End of Macro
+;	;/XOR32
+
+
+
+
+
+XORAXY32T0	MAC
+
+			EOR XREGISTER32+3								; EOR with OPERAND
+			EOR YREGISTER32+3								; EOR with OPERAND
+			STA	TEMP0+3									; output to TEMP0
+			
+			LDA INPUT32+2								; LDA byte
+			EOR XREGISTER32+2								; EOR with OPERAND
+			EOR YREGISTER32+2								; EOR with OPERAND
+			STA	TEMP0+2									; output to TEMP0
+			
+			LDA INPUT32+1								; LDA byte
+			EOR XREGISTER32+1								; EOR with OPERAND
+			EOR YREGISTER32+1								; EOR with OPERAND
+			STA	TEMP0+1									; output to INPUT32
+			
+			LDA INPUT32								; LDA byte
+			EOR XREGISTER32								; EOR with OPERAND
+			EOR YREGISTER32								; EOR with OPERAND
+			STA	TEMP0								; output to TEMP0
+	
+
+			<<<            ; End of Macro
+;/XORAXY32            
+
+
+XORAXY32S1	MAC
+
+			EOR XREGISTER32								; EOR with OPERAND
+			EOR YREGISTER32								; EOR with OPERAND
+			STA	S1								; output to INPUT32
+			
+			LDA INPUT32+1								; LDA byte
+			EOR XREGISTER32+1								; EOR with OPERAND
+			EOR YREGISTER32+1								; EOR with OPERAND
+			STA	S1+1									; output to INPUT32
+			
+			LDA INPUT32+2								; LDA byte
+			EOR XREGISTER32+2								; EOR with OPERAND
+			EOR YREGISTER32+2								; EOR with OPERAND
+			STA	S1+2									; output to INPUT32
+
+			LDA INPUT32+3								; LDA byte
+			EOR XREGISTER32+3								; EOR with OPERAND
+			EOR YREGISTER32+3								; EOR with OPERAND
+			STA	S1+3									; output to INPUT32
+
+			<<<            ; End of Macro
+;/XORAXY32S1
+
+
+XORAXY32S0	MAC
+				
+			EOR XREGISTER32								; EOR with OPERAND
+			EOR YREGISTER32								; EOR with OPERAND
+			STA	S0								; output to INPUT32
+
+			LDA INPUT32+1								; LDA byte
+			EOR XREGISTER32+1								; EOR with OPERAND
+			EOR YREGISTER32+1								; EOR with OPERAND
+			STA	S0+1									; output to INPUT32
+
+			LDA INPUT32+2								; LDA byte
+			EOR XREGISTER32+2								; EOR with OPERAND
+			EOR YREGISTER32+2								; EOR with OPERAND
+			STA	S0+2									; output to INPUT32
+
+			LDA INPUT32+3								; LDA byte
+			EOR XREGISTER32+3								; EOR with OPERAND
+			EOR YREGISTER32+3								; EOR with OPERAND
+			STA	S0+3									; output to INPUT32
+			
+			<<<            ; End of Macro
+;/XORAXY32S0
+			
+			
+XORAXYADD24	MAC
+				
+			EOR XREGISTER32+3								; EOR with OPERAND
+			EOR YREGISTER32+3								; EOR with OPERAND
+			ADC TEMP0+3									; ADD with CARRY with OPERAND
+			STA	XREGISTER32+3								; output to XREGISTER32
+			
+			LDA INPUT32+2								; LDA byte
+			EOR XREGISTER32+2								; EOR with OPERAND
+			EOR YREGISTER32+2								; EOR with OPERAND
+			ADC TEMP0+2									; ADD with CARRY with OPERAND
+			STA	XREGISTER32+2								; output to XREGISTER32
+			
+			LDA INPUT32+1								; LDA byte
+			EOR XREGISTER32+1								; EOR with OPERAND
+			EOR YREGISTER32+1								; EOR with OPERAND
+			ADC TEMP0+1
+			STA	XREGISTER32+1								; output to XREGISTER32
+
+			LDA XREGISTER32								; EOR with OPERAND
+			EOR YREGISTER32								; EOR with OPERAND
+			ADC TEMP0									; ADD with CARRY with OPERAND
+			STA	XREGISTER32								; output to XREGISTER32
+						
+            <<<            ; End of Macro
+;/XORAXYADD24            
+
+
+*	Produce the final hash value (big-endian):
+*	digest := hash := h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
+*
+**************************************************
+
+
+INCNONCE	MAC				
+			INC	NONCE+3							; rolled to zero, do next byte up
+			BNE NONCEDONE				
+			INC	NONCE+2							; rolled to zero, do next byte up
+			BNE NONCEDONE				
+			INC	NONCE+1							; rolled to zero, do next byte up
+			BNE NONCEDONE				
+			INC	NONCE							; rolled to zero, do next byte up
+			BNE NONCEDONE				
+			JMP DONEWORK						; done? seriously?
+NONCEDONE					
+			<<<
+;			RTS
+
+
+
+
+MAJ32ADDT1	MAC	
+			; majority function. Takes INPUT32, XREGISTER32 and YREGISTER32, returns with result in INPUT32, clobbers AXY
+			
+			; load VA,VB,VC into AXY
+
+			CLC
+			LDA VA + 3				; A and Y, result to RESULT32,4
+			AND VC + 3
+			STA RESULT32+4
+			LDA VB + 3				; X and Y, result to RESULT32,5
+			AND VC + 3
+			STA RESULT32+5
+			; RESULT32,3 xor RESULT32,4 xor RESULT32,5
+			LDA VA + 3
+			AND VB + 3				; A and X, result to RESULT32,3
+			EOR RESULT32+4
+			EOR RESULT32+5
+			ADC S0 + 3
+			STA INPUT32 + 3
+
+			LDA VA + 2				; A and Y, result to RESULT32,4
+			AND VC + 2
+			STA RESULT32+4
+			LDA VB + 2				; X and Y, result to RESULT32,5
+			AND VC + 2
+			STA RESULT32+5
+			; RESULT32,3 xor RESULT32,4 xor RESULT32,5
+			LDA VA + 2
+			AND VB + 2				; A and X, result to RESULT32,3
+			EOR RESULT32+4
+			EOR RESULT32+5
+			ADC S0 + 2
+			STA	INPUT32+2
+
+			LDA VA + 1				; A and Y, result to RESULT32,4
+			AND VC + 1
+			STA RESULT32+4
+			LDA VB + 1				; X and Y, result to RESULT32,5
+			AND VC + 1
+			STA RESULT32+5
+			; RESULT32,3 xor RESULT32,4 xor RESULT32,5
+			LDA VA + 1
+			AND VB + 1				; A and X, result to RESULT32,3
+			EOR RESULT32+4
+			EOR RESULT32+5
+			ADC S0 + 1
+			STA	INPUT32+1
+
+			LDA VA + 0				; A and Y, result to RESULT32,4
+			AND VC + 0
+			STA RESULT32+4
+			LDA VB + 0				; X and Y, result to RESULT32,5
+			AND VC + 0
+			STA RESULT32+5
+			; RESULT32,3 xor RESULT32,4 xor RESULT32,5
+			LDA VA + 0
+			AND VB + 0				; A and X, result to RESULT32,3
+			EOR RESULT32+4
+			EOR RESULT32+5
+			ADC S0
+			STA	INPUT32+0		
+
+			<<<            ; End of Macro
+
+;/MAJ32
+
+
+
+			; choice function. Takes INPUT32 and XREGISTER32, adds S1, returns with result in INPUT32, clobbers AXY
+CHOICE32ADD	MAC	
+			; ch := (A and X) xor ((not A) and Y)
+			; (RESULT32,2) EOR ((not A) AND Y)
+			; (RESULT32,2) EOR (RESULT32,1 AND Y)
+			
+			; if bit(A)=0, then bit(Y), else bit(X)
+			
+			CLC
+			LDA VE + 3					; VE
+			AND VF + 3				
+			STA RESULT32+2				; A AND X to TEMP
+			LDA VE + 3				; AND with (NOT A)
+			EOR #$FF					; NOT A
+			AND VG + 3					; VG
+			EOR RESULT32+2				; EOR (A AND X)
+			ADC S1 + 3							; ADD with CARRY with OPERAND
+			STA INPUT32 + 3
+		
+			LDA VE + 2					; VE
+			AND VF + 2				
+			STA RESULT32+2				; A AND X to TEMP
+			LDA VE + 2				; AND with (NOT A)
+			EOR #$FF					; NOT A
+			AND VG + 2					; VG
+			EOR RESULT32+2				; EOR (A AND X)
+			ADC S1 + 2							; ADD with CARRY with OPERAND
+			STA INPUT32 + 2
+		
+			LDA VE + 1					; VE
+			AND VF + 1				
+			STA RESULT32+2				; A AND X to TEMP
+			LDA VE + 1				; AND with (NOT A)
+			EOR #$FF					; NOT A
+			AND VG + 1					; VG
+			EOR RESULT32+2				; EOR (A AND X)
+			ADC S1 + 1							; ADD with CARRY with OPERAND
+			STA INPUT32 + 1
+		
+			LDA VE + 0					; VE
+			AND VF + 0				
+			STA RESULT32+2				; A AND X to TEMP
+			LDA VE + 0				; AND with (NOT A)
+			EOR #$FF					; NOT A
+			AND VG + 0					; VG
+			EOR RESULT32+2				; EOR (A AND X)
+			ADC S1								; ADD with CARRY with OPERAND
+			STA INPUT32 + 0
+
+            <<<            ; End of Macro
+			
+;/CHOICE32
+
+PRHEX	MAC			; replaces PRBYTE routine. still uses COUT. You're next, COUT. Watch your back.
+					
+					LDA HEXTOASCIIHI,X	; get ascii code for nibble "0"-"F"
+
+					STA ($28),Y
+					INY				; 1
+
+					LDA HEXTOASCIILO,X	; get ascii code for nibble "0"-"F"
+
+					STA ($28),Y
+					INY
+					
+			<<<
+;/PRHEX
+
+**************************************************
+*	subroutines
+**************************************************
+ROTATE1				LDA	ROTATE1LO		; Setup pointers to move memory
+					STA	$3C				; $3C and $3D for source start
+					LDA	ROTATE1HI
+					STA	$3D
+	
+					LDA	ROTATE1LO
+					STA	$3E				; $3E and $3F for source end
+					LDA	ROTATE1HI
+					CLC	
+					ADC	#$04			; add $400 to start == end of graphic
+					STA	$3F				; 
+					JMP MOVEIMAGE
+
+ROTATE2				LDA	ROTATE2LO		; Setup pointers to move memory
+					STA	$3C				; $3C and $3D for source start
+					LDA	ROTATE2HI
+					STA	$3D
+	
+					LDA	ROTATE2LO
+					STA	$3E				; $3E and $3F for source end
+					LDA	ROTATE2HI
+					CLC	
+					ADC	#$04			; add $400 to start == end of graphic
+					STA	$3F				; 
+					JMP MOVEIMAGE
+
+FLIPCOIN			JSR ROTATE1
+					LDA #$30
+					JSR WAIT
+					JSR ROTATE2
+					LDA #$30
+					JSR WAIT
+					;;JSR SPLASHSCREEN				; fancy lo-res graphics
+					;;RTS ;fall through
+;/FLIPCOIN					
+
+
+
+
+SPLASHSCREEN		LDA	SPLASHLO		; Setup pointers to move memory
+					STA	$3C				; $3C and $3D for source start
+					LDA	SPLASHHI
+					STA	$3D
+	
+					LDA	SPLASHLO
+					STA	$3E				; $3E and $3F for source end
+					LDA	SPLASHHI
+					CLC	
+					ADC	#$04			; add $400 to start == end of graphic
+					STA	$3F				; 
+
+MOVEIMAGE			LDA	#$00			; move graphic data to $8000
+					STA	$42				; $42 and $43 for destination
+					LDA	#$80
+					STA	$43
+					LDA	#$00			; Clear ACC, X,Y for smooth operation
+					TAX	
+					TAY	
+					JSR	$FE2C    		; F8ROM:MOVE	; Do the memory move
+						
+
+										; display the data from $8000 at $400					
+RESETVPTR			LDA	#$00			; Move titlepage from $8000 to $400 (screen)
+					STA	$FE				; pointer for where we are at vertically on screen
+					TAY					; Y-Reg used for indexing across (horiz) screen
+
+VERTICALPTR			LDA	$FE				; pointer for where we are at vertically on screen
+					JSR	$F847    		; F8ROM:GBASCALC
+	
+					LDA	$26
+					STA	$FA				; $FA is our offset GBASL Byte (Source data titlepage)
+		
+					LDA	$27				; Add 04 w/ Carry to get to $8000 where graphic data is
+					ADC	#$7C	
+					STA	$FB				; $FB is our offset GBASH Byte (Source data titlepage)
+							
+					LDY #$07
+GRABSTORAGE			LDA	($FA),Y			; Grab from storage
+					STA	($26),Y			; Put to screen
+					INY		
+					CPY	#$21			; #$28 past the width of screen?
+					BNE	GRABSTORAGE		; No?  Back for another round
+
+					LDA	#$00
+					TAX	
+					TAY	
+	
+						
+					INC	$FE				; Next line down vertically
+					LDA	#$00
+					TAX	
+					TAY	
+					LDA	$FE
+					CMP	#$14			; #$18 bottom of screen?
+					BNE	VERTICALPTR		; No? Go back and do next line down
+					
+					RTS					; We now return you to your regular programming
+
+;/SPLASHSCREEN
+
+
+
+
+FILLSCREENFAST		LDA #$00 
+      				LDY #$78 
+
+FILL1 				DEY
+      				STA $400, Y
+      				STA $480, Y
+      				STA $500, Y
+      				STA $580, Y
+      				BNE FILL1
+
+      				LDY #$50 			; #$78 for all 24 lines.
+
+FILL2 				DEY
+					STA $600, Y
+					STA $680, Y
+					STA $700, Y
+					STA $780, Y
+					BNE FILL2
+					RTS
+
+
+
+
+**************************************************
+*	Load "HEADER" into memory
+**************************************************
+
+BLOAD   		JSR	OPEN    				;open "HEADER"
+       			JSR READ
+				JSR CLOSE
+       			RTS            				;Otherwise done
+				
+OPEN 			JSR	MLI       				;Perform call
+       			DB	OPENCMD    				;OPEN command number
+       			DW	OPENLIST   				;Pointer to parameter list
+       			BNE	ERROR     				;If error, display it
+       			LDA REFERENCE
+       			STA READLIST+1
+       			STA CLOSELIST+1
+       			RTS				
+
+READ			JSR MLI
+				DB	READCMD
+				DW	READLIST
+       			BNE ERROR					
+				RTS
+
+CLOSE			JSR MLI
+				DB	CLOSECMD
+				DW	CLOSELIST
+       			BNE ERROR					
+				RTS
+				
+ERROR  			CMP #$46					
+				BNE PRINTERROR
+				LDA #$30
+				STA ENDNAME-1
+				STA ENDNAME-2
+				JMP OPEN
+PRINTERROR		JSR	PRBYTE    				;Print error code
+       			JSR	BELL      				;Ring the bell
+       			JSR	CROUT     				;Print a carriage return
+       			RTS				
+
+OPENLIST		DB	$03						; parameter list for OPEN command
+				DW	FILENAME
+				DA	MLI-$400				; buffer snuggled up tight with PRODOS
+REFERENCE		DB	$00						; reference to opened file
+			
+READLIST		DB	$04
+				DB	$00						; REFERENCE written here after OPEN
+				DB	<HEADER,>HEADER			; write to HEADER
+				DB	$50,$00					; read as much as $ (80 bytes) - should error out with EOF before that.
+TRANSFERRED		DB	$00,$00				
+
+CLOSELIST		DB	$01
+				DB	$00
+				
+FILENAME		DB	ENDNAME-NAME 			;Length of name
+NAME    		ASC	'/HASH/HEADER.BIN' 			;followed by the name
+ENDNAME 		EQU	*
+
+
+
+
+
+
+
+**************************************************
+* MESSAGE TO BE HASHED.
+*
+**************************************************
+MESSAGELO			DB <MESSAGE
+MESSAGEHI			DB >MESSAGE
+	
+MESSAGE				EQU *
+	
+HEADER				DS 76	;EQU *				; 80 bytes for header = L = 640 bits
+	
+
+*	What's being hashed is: version4 + previous block hash32 + merkel root32 + time4 + bits (target)4 + nonce4 = blockheader (80 bytes)
+
+; 20000000e905eff72bb63f67b3abf7e0d930371814fad083000ce8640000000000000000cfbf4e0e035d175595d486a99705151b956c0a36d9febeb9ea7968ad38e54ead5d3b5f4a171f3a0800000000
+;	[2019-07-26 16:15:11.585] Selecting pool 0 for work
+;	[2019-07-26 16:15:11.586] Generated stratum merkle cfbf4e0e035d175595d486a99705151b956c0a36d9febeb9ea7968ad38e54ead
+;	[2019-07-26 16:15:11.586] Generated stratum header 20000000e905eff72bb63f67b3abf7e0d930371814fad083000ce8640000000000000000cfbf4e0e035d175595d486a99705151b956c0a36d9febeb9ea7968ad38e54ead5d3b5f4a171f3a08000000000000008000000000000000000000000000000000000000000000000000000000
+;	[2019-07-26 16:15:11.586] Work job_id 65e11 nonce2 5 ntime 5d3b5f4a
+;	[2019-07-26 16:15:11.586] Generated target 00000000000000000000000000000000000000000000000080ff7f0000000000
+;	[2019-07-26 16:15:11.586] Generated stratum work
+ 
+;	VERSION			HEX 20,00,00,00	;	DS 4
+;	PREVHASH		HEX e9,05,ef,f7,2b,b6,3f,67,b3,ab,f7,e0,d9,30,37,18,14,fa,d0,83,00,0c,e8,64,00,00,00,00,00,00,00,00	;	DS 32
+;	MERKELROOT		HEX cf,bf,4e,0e,03,5d,17,55,95,d4,86,a9,97,05,15,1b,95,6c,0a,36,d9,fe,be,b9,ea,79,68,ad,38,e5,4e,ad	;	DS 32
+;	TIMESTAMP		HEX 5d,3b,5f,4a	;	DS 4
+;	TARGET			HEX 17,1f,3a,08	;	DS 4
+NONCE			HEX 00,00,00,00	;	DS 4
+
+									; then append one 1 bit
+APPENDBIT		DB #$80				; 10000000 - 7 extra bits = 648 bits
+
+									; append K '0' bits, where K is the minimum number >= 0 such that L + 1 + K + 64 is a multiple of 512
+									; 648 + K + 64 = 1024
+PADDINGBITS		DS 39				; K = 312 bits = 39 bytes
+									;	append L as a 64-bit big-endian integer, making the total post-processed length a multiple of 512 bits
+MESSAGELENGTH	HEX	00,00,00,00,00,00,02,80						
+									; 	L = 640, in 8 bytes = 0,0,0,0,0,0,02,80
+
+;nonce 0000 = 1A722F82830421E6F4655470C6565614144DD70202FC8C56D8E7C601060FBAD1
+;NONCELO				DB	<NONCE
+;NONCEHI				DB	>NONCE
+
+
+
+
+
+
+
+
+JOBID 			ASC "65e11"
+
+;	VERSION			HEX 01,00,00,00	;	DS 4
+;	PREVHASH		HEX 00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00	;	DS 32
+;	MERKELROOT		HEX 3b,a3,ed,fd,7a,7b,12,b2,7a,c7,2c,3e,67,76,8f,61,7f,c8,1b,c3,88,8a,51,32,3a,9f,b8,aa,4b,1e,5e,4a	;	DS 32
+;	TIMESTAMP		HEX 29,ab,5f,49	;	DS 4
+;	TARGET			HEX ff,ff,00,1d	;	DS 4
+;	NONCE			HEX 1d,ac,2b,7c	;	DS 4
+;										; then append one 1 bit
+;	APPENDBIT		DB #$80				; 10000000 - 7 extra bits = 648 bits
+;										; append K '0' bits, where K is the minimum number >= 0 such that L + 1 + K + 64 is a multiple of 512
+;										; 648 + K + 64 = 1024
+;	PADDINGBITS		DS 39				; K = 312 bits = 39 bytes
+;										;	append L as a 64-bit big-endian integer, making the total post-processed length a multiple of 512 bits
+;	MESSAGELENGTH	HEX	00,00,00,00,00,00,02,80						
+;										; 	L = 640, in 8 bytes = 0,0,0,0,0,0,02,80
+;	JOBID 			ASC "0"	; GENESIS BLOCK
+
+
+
+
+**** Message2 only needs one chunk! ****
+
+;;MESSAGE2LO		DB <MESSAGE2
+;;MESSAGE2HI		DB >MESSAGE2
+
+
+MESSAGE2		DS 32				; new message content after first pass produces hash - 256 bits
+									; then append one 1 bit
+APPENDBIT2		DB #$80				; 10000000 - 7 extra bits = 264 bits
+
+									; append K '0' bits, where K is the minimum number >= 0 such that L + 1 + K + 64 is a multiple of 512
+									; 264 + K + 64 = 512 !!!! 1024
+PADDINGBITS2	DS 23				; K = 184 bits = 87 bytes
+									;	append L as a 64-bit big-endian integer, making the total post-processed length a multiple of 512 bits
+MESSAGELENGTH2	HEX	00,00,00,00,00,00,01,00						
+									; 	L = 256, in 8 bytes = 0,0,0,0,0,0,01,00
+
+
+
+
+
+
+
+**************************************************
+* Data Tables
+*
+**************************************************
+
+		
+;;TEMPLO			DB <TEMP0,<TEMP1
+;;TEMPHI			DB >TEMP0,>TEMP1		
+
+;;RESULT32LO		DB	<RESULT32
+;;RESULT32HI		DB	>RESULT32
+
+VA					DS	4
+VB					DS	4
+VC					DS	4
+VD					DS	4
+VE					DS	4
+VF					DS	4
+VG					DS	4
+VH					DS	4
+
+;	VTABLE				DA	VA,VB,VC,VD,VE,VF,VG,VH
+;;VTABLELO			DB	<VA,<VB,<VC,<VD,<VE,<VF,<VG,<VH
+;;VTABLEHI			DB	>VA,>VB,>VC,>VD,>VE,>VF,>VG,>VH
+
+
+												
+;    create a 64-entry message schedule array w[0..63] of 32-bit words
+;    (The initial values in w[0..63] don't matter, so many implementations zero them here)
+
+	DS \
+	DS 64
+W00					DS 4
+W01					DS 4
+W02					DS 4
+W03					DS 4
+W04					DS 4
+W05					DS 4
+W06					DS 4
+W07					DS 4
+W08					DS 4
+W09					DS 4
+W10					DS 4
+W11					DS 4
+W12					DS 4
+W13					DS 4
+W14					DS 4
+W15					DS 4
+W16					DS 4
+W17					DS 4
+W18					DS 4
+W19					DS 4
+W20					DS 4
+W21					DS 4
+W22					DS 4
+W23					DS 4
+W24					DS 4
+W25					DS 4
+W26					DS 4
+W27					DS 4
+W28					DS 4
+W29					DS 4
+W30					DS 4
+W31					DS 4
+W32					DS 4
+W33					DS 4
+W34					DS 4
+W35					DS 4
+W36					DS 4
+W37					DS 4
+W38					DS 4
+W39					DS 4
+W40					DS 4
+W41					DS 4
+W42					DS 4
+W43					DS 4
+W44					DS 4
+W45					DS 4
+W46					DS 4
+W47					DS 4
+W48					DS 4
+W49					DS 4
+W50					DS 4
+W51					DS 4
+W52					DS 4
+W53					DS 4
+W54					DS 4
+W55					DS 4
+W56					DS 4
+W57					DS 4
+W58					DS 4
+W59					DS 4
+W60					DS 4
+W61					DS 4
+W62					DS 4
+W63					DS 4
+
+;	WTABLE			DA	W00,W01,W02,W03,W04,W05,W06,W07,W08,W09
+;					DA	W10,W11,W12,W13,W14,W15,W16,W17,W18,W19
+;					DA	W20,W21,W22,W23,W24,W25,W26,W27,W28,W29
+;					DA	W30,W31,W32,W33,W34,W35,W36,W37,W38,W39
+;					DA	W40,W41,W42,W43,W44,W45,W46,W47,W48,W49
+;					DA	W50,W51,W52,W53,W54,W55,W56,W57,W58,W59
+;					DA	W60,W61,W62,W63
+
+;;WTABLELO		DB	<W00,<W01,<W02,<W03,<W04,<W05,<W06,<W07,<W08,<W09
+;;				DB	<W10,<W11,<W12,<W13,<W14,<W15,<W16,<W17,<W18,<W19
+;;				DB	<W20,<W21,<W22,<W23,<W24,<W25,<W26,<W27,<W28,<W29
+;;				DB	<W30,<W31,<W32,<W33,<W34,<W35,<W36,<W37,<W38,<W39
+;;				DB	<W40,<W41,<W42,<W43,<W44,<W45,<W46,<W47,<W48,<W49
+;;				DB	<W50,<W51,<W52,<W53,<W54,<W55,<W56,<W57,<W58,<W59
+;;				DB	<W60,<W61,<W62,<W63
+
+;;WTABLEHI		DB	>W00,>W01,>W02,>W03,>W04,>W05,>W06,>W07,>W08,>W09
+;;				DB	>W10,>W11,>W12,>W13,>W14,>W15,>W16,>W17,>W18,>W19
+;;				DB	>W20,>W21,>W22,>W23,>W24,>W25,>W26,>W27,>W28,>W29
+;;				DB	>W30,>W31,>W32,>W33,>W34,>W35,>W36,>W37,>W38,>W39
+;;				DB	>W40,>W41,>W42,>W43,>W44,>W45,>W46,>W47,>W48,>W49
+;;				DB	>W50,>W51,>W52,>W53,>W54,>W55,>W56,>W57,>W58,>W59
+;;				DB	>W60,>W61,>W62,>W63
+
+
+;	Initialize hash values:
+;	(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+
+CACHEDHASH		DS 32					; storage for the first chunk of first pass. Won't change between nonce changes.
+
+INITIALHASH		HEX	6a,09,e6,67			; need to keep this on hand to reset after hash pass 1.
+				HEX	bb,67,ae,85
+				HEX	3c,6e,f3,72
+				HEX	a5,4f,f5,3a
+				HEX	51,0e,52,7f
+				HEX	9b,05,68,8c
+				HEX	1f,83,d9,ab
+				HEX	5b,e0,cd,19
+
+H00				HEX	6a,09,e6,67
+H01				HEX	bb,67,ae,85
+H02				HEX	3c,6e,f3,72
+H03				HEX	a5,4f,f5,3a
+H04				HEX	51,0e,52,7f
+H05				HEX	9b,05,68,8c
+H06				HEX	1f,83,d9,ab
+H07				HEX	5b,e0,cd,19
+
+;	HTABLE			DA	H00,H01,H02,H03,H04,H05,H06,H07
+;;HTABLELO		DB	<H00,<H01,<H02,<H03,<H04,<H05,<H06,<H07
+;;HTABLEHI		DB	>H00,>H01,>H02,>H03,>H04,>H05,>H06,>H07
+
+
+;	STABLE				DA	S0,S1
+;;STABLELO			DB	<S0,<S1
+;;STABLEHI			DB	>S0,>S1
+
+
+;	Initialize array of round constants:
+;	(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):
+
+	DS \
+K00				HEX	42,8a,2f,98
+K01				HEX	71,37,44,91
+K02				HEX	b5,c0,fb,cf
+K03				HEX	e9,b5,db,a5
+K04				HEX	39,56,c2,5b
+K05				HEX	59,f1,11,f1
+K06				HEX	92,3f,82,a4
+K07				HEX	ab,1c,5e,d5
+K08				HEX	d8,07,aa,98
+K09				HEX	12,83,5b,01
+K10				HEX	24,31,85,be
+K11				HEX	55,0c,7d,c3
+K12				HEX	72,be,5d,74
+K13				HEX	80,de,b1,fe
+K14				HEX	9b,dc,06,a7
+K15				HEX	c1,9b,f1,74
+K16				HEX	e4,9b,69,c1
+K17				HEX	ef,be,47,86
+K18				HEX	0f,c1,9d,c6
+K19				HEX	24,0c,a1,cc
+K20				HEX	2d,e9,2c,6f
+K21				HEX	4a,74,84,aa
+K22				HEX	5c,b0,a9,dc
+K23				HEX	76,f9,88,da
+K24				HEX	98,3e,51,52
+K25				HEX	a8,31,c6,6d
+K26				HEX	b0,03,27,c8
+K27				HEX	bf,59,7f,c7
+K28				HEX	c6,e0,0b,f3
+K29				HEX	d5,a7,91,47
+K30				HEX	06,ca,63,51
+K31				HEX	14,29,29,67
+K32				HEX	27,b7,0a,85
+K33				HEX	2e,1b,21,38
+K34				HEX	4d,2c,6d,fc
+K35				HEX	53,38,0d,13
+K36				HEX	65,0a,73,54
+K37				HEX	76,6a,0a,bb
+K38				HEX	81,c2,c9,2e
+K39				HEX	92,72,2c,85
+K40				HEX	a2,bf,e8,a1
+K41				HEX	a8,1a,66,4b
+K42				HEX	c2,4b,8b,70
+K43				HEX	c7,6c,51,a3
+K44				HEX	d1,92,e8,19
+K45				HEX	d6,99,06,24
+K46				HEX	f4,0e,35,85
+K47				HEX	10,6a,a0,70
+K48				HEX	19,a4,c1,16
+K49				HEX	1e,37,6c,08
+K50				HEX	27,48,77,4c
+K51				HEX	34,b0,bc,b5
+K52				HEX	39,1c,0c,b3
+K53				HEX	4e,d8,aa,4a
+K54				HEX	5b,9c,ca,4f
+K55				HEX	68,2e,6f,f3
+K56				HEX	74,8f,82,ee
+K57				HEX	78,a5,63,6f
+K58				HEX	84,c8,78,14
+K59				HEX	8c,c7,02,08
+K60				HEX	90,be,ff,fa
+K61				HEX	a4,50,6c,eb
+K62				HEX	be,f9,a3,f7
+K63				HEX	c6,71,78,f2
+
+;	KTABLE			DA	K00,K01,K02,K03,K04,K05,K06,K07,K08,K09
+;					DA	K10,K11,K12,K13,K14,K15,K16,K17,K18,K19
+;					DA	K20,K21,K22,K23,K24,K25,K26,K27,K28,K29
+;					DA	K30,K31,K32,K33,K34,K35,K36,K37,K38,K39
+;					DA	K40,K41,K42,K43,K44,K45,K46,K47,K48,K49
+;					DA	K50,K51,K52,K53,K54,K55,K56,K57,K58,K59
+;					DA	K60,K61,K62,K63
+
+;;KTABLELO		DB	<K00,<K01,<K02,<K03,<K04,<K05,<K06,<K07,<K08,<K09
+;;				DB	<K10,<K11,<K12,<K13,<K14,<K15,<K16,<K17,<K18,<K19
+;;				DB	<K20,<K21,<K22,<K23,<K24,<K25,<K26,<K27,<K28,<K29
+;;				DB	<K30,<K31,<K32,<K33,<K34,<K35,<K36,<K37,<K38,<K39
+;;				DB	<K40,<K41,<K42,<K43,<K44,<K45,<K46,<K47,<K48,<K49
+;;				DB	<K50,<K51,<K52,<K53,<K54,<K55,<K56,<K57,<K58,<K59
+;;				DB	<K60,<K61,<K62,<K63
+
+;;KTABLEHI		DB	>K00,>K01,>K02,>K03,>K04,>K05,>K06,>K07,>K08,>K09
+;;				DB	>K10,>K11,>K12,>K13,>K14,>K15,>K16,>K17,>K18,>K19
+;;				DB	>K20,>K21,>K22,>K23,>K24,>K25,>K26,>K27,>K28,>K29
+;;				DB	>K30,>K31,>K32,>K33,>K34,>K35,>K36,>K37,>K38,>K39
+;;				DB	>K40,>K41,>K42,>K43,>K44,>K45,>K46,>K47,>K48,>K49
+;;				DB	>K50,>K51,>K52,>K53,>K54,>K55,>K56,>K57,>K58,>K59
+;;				DB	>K60,>K61,>K62,>K63
+				
+
+; 80 ascii '0'
+; 4c7f3da0386523b102328418c28d886bb9dc9c555671884e8fcc9bcba407e819
+; 4C7F3DA0386523B102328418C28D886BB9DC9C555671884E8FCC9BCBA407E819 - boom. (1 pass)
+
+; The quick brown fox jumps over the lazy dog - len 43
+; d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592 - https://www.xorbin.com/tools/sha256-hash-calculator
+; D7A8FBB307D7809469CA9ABCB0082E4F8D5651E46D3CDB762D02D0BF37C9E592 - https://docs.google.com/spreadsheets/d/1ipesRlJGtS_1Tm452lOueBEZzdgZkaH-AihtJDo55Sc/edit#gid=2107569783
+
+; D7A8FBB307D7809469CA9ABCB0082E4F8D5651E46D3CDB762D02D0BF37C9E592 - confirmed (1 pass)
+
+
+;0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c
+; GENESIS BLOCK
+;af42031e805ff493a07341e2f74ff58149d22ab9ba19f61343e2c86c71c5d66d  pass 1
+;6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000  pass 2
+
+
+;AF42031E805FF493A07341E2F74FF58149D22AB9BA19F61343E2C86C71C5D66D - pass 1
+;6FE28C0AB6F1B372C1A6A246AE63F74F931E8365E15A089C68D6190000000000 - boom.
+
+
+	DS \
+HEXTOASCIILO			ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+				ASC "0123456789ABCDEF" 
+HEXTOASCIIHI			ASC "0000000000000000" 
+				ASC "1111111111111111" 
+				ASC "2222222222222222" 
+				ASC "3333333333333333" 
+				ASC "4444444444444444" 
+				ASC "5555555555555555" 
+				ASC "6666666666666666" 
+				ASC "7777777777777777" 
+				ASC "8888888888888888" 
+				ASC "9999999999999999" 
+				ASC "AAAAAAAAAAAAAAAA" 
+				ASC "BBBBBBBBBBBBBBBB" 
+				ASC "CCCCCCCCCCCCCCCC" 
+				ASC "DDDDDDDDDDDDDDDD" 
+				ASC "EEEEEEEEEEEEEEEE" 
+				ASC "FFFFFFFFFFFFFFFF" 
+
+SPLASHLO			db	<SPLASHSCREENDATA
+SPLASHHI			db	>SPLASHSCREENDATA
+
+ROTATE1LO			db	<ROTATE1DATA
+ROTATE1HI			db	>ROTATE1DATA
+
+ROTATE2LO			db	<ROTATE2DATA
+ROTATE2HI			db	>ROTATE2DATA
+
+SPLASHSCREENDATA	HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,D0,90,9D,99,99,99,99,99,99,99,90,90,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,99,99,99,99,99,99,99,99,DD,FF,FF,FF
+					HEX	99,99,99,99,99,FF,FF,FF,99,99,99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,0D
+					HEX	D9,99,99,99,9F,9F,9F,DF,FF,FF,9F,DF,FF,FF,9F,9F,9F,99,99,99,09,00,00,00,00,00,00,00,00,00
+					HEX	FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,D0,9D,99,99,99,99,99,99,99,99
+					HEX	99,99,99,99,99,90,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,99,99,99,99
+					HEX	99,99,99,99,DD,FF,FF,FF,F9,F9,F9,F9,FD,FF,FF,9F,99,99,99,99,99,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,0D,D9,99,99,99,99,99,DD,FF,FF,99,DD,FF,FF,99,99,99,99,99,09,00,00
+					HEX	00,00,00,00,00,00,00,00,FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,D0,9D,99,99
+					HEX	99,99,99,DD,FF,FF,99,DD,FF,FF,99,99,99,99,99,90,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,DD,99,99,99,99,99,99,99,99,DD,FF,FF,FF,FF,FF,FF,FF,FF,FF,FF,FF,99,99,99,99,99,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,0D,D9,99,99,99,9D,9F,9F,99,9D,9F,9F
+					HEX	99,99,99,09,00,00,00,00,00,00,00,00,00,00,00,00,FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00
+					HEX	00,00,00,00,DD,99,99,99,99,99,99,DD,FF,FF,99,DD,FF,FF,99,99,99,99,99,99,90,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,DD,99,99,99,99,99,99,99,99,DD,FF,FF,FF,9F,9F,9F,9F,9F,DF
+					HEX	FF,FF,FF,99,99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,0D,D9
+					HEX	89,99,99,99,99,99,99,99,89,09,00,00,00,00,00,00,00,00,00,00,00,00,00,00,FF,FF,FF,FF,FF,FF
+					HEX	FF,FF,00,00,00,00,00,00,00,00,00,DD,99,99,99,99,FF,FF,FF,FF,FF,FF,FF,FF,FF,FF,FF,FF,F9,99
+					HEX	99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,99,99,99,99,99,99,99,99,DD,FF
+					HEX	FF,FF,99,99,99,99,99,99,FF,FF,FF,99,99,99,89,00,00,00,00,00,00,00,DF,DF,DF,DF,DF,DF,DF,DF
+					HEX	DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,A0,A0,A0,A0,A0
+					HEX	A0,D5,FF,FF,FF,FF,FF,FF,FF,70,00,00,00,00,00,00,00,00,D0,9D,99,99,99,99,9F,FF,FF,FF,FF,FF
+					HEX	FF,FF,FF,FF,FF,FF,FF,F9,99,99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,99
+					HEX	99,99,99,99,99,99,DD,FF,FF,FF,99,99,99,99,99,D9,FF,FF,FF,99,99,99,00,00,00,00,00,00,00,00
+					HEX	1F,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0
+					HEX	A0,A0,1F,A0,A0,A0,A0,A0,A0,A0,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,DD,99,99,99
+					HEX	99,99,99,99,DD,FF,FF,FF,99,99,99,9D,DF,FF,FF,FF,99,99,99,99,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,DD,99,99,99,99,99,99,F9,FD,FF,FF,FF,F9,F9,F9,F9,FD,FF,FF,FF,9F,99,99,99
+					HEX	00,00,00,00,00,00,00,00,1F,A0,D8,BE,A0,B0,B0,A0,D9,BE,A0,B0,B0,A0,D0,EC,EF,F4,BE,A0,CF,E6
+					HEX	E6,A0,C3,EF,EC,BE,A0,B0,B9,A0,1F,A0,A0,A0,A0,A0,A0,A0,70,FF,FF,FF,FF,FF,FF,00,00,00,00,00
+					HEX	00,00,00,D0,9D,99,99,99,99,99,99,99,DD,FF,FF,FF,99,99,99,99,99,FF,FF,FF,99,99,99,99,90,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,99,99,99,99,FF,FF,FF,FF,FF,FF,FF,FF,FF,FF
+					HEX	FF,FF,FF,9F,99,99,99,00,00,00,00,00,00,00,00,00,20,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF
+					HEX	DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,20,A0,BF,AD,C8,E5,EC,F0,C7,FF,FF,FF
+					HEX	FF,FF,FF,FF
+
+
+ROTATE1DATA			HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,D0,DD,9D,99,99,99,99,90,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,99,99,99,DD,FF,99
+					HEX	99,99,DD,FF,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	0D,DD,D9,99,9D,9F,DF,FF,DF,FF,9F,99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,FF,FF,FF,FF
+					HEX	FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,99,99,99,99,99,99,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,99,99
+					HEX	99,DD,FF,F9,F9,FD,FD,9F,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,DD,DD,99,99,99,DD,FF,DD,FF,99,99,99,09,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,99,DD,FF,DD,FF
+					HEX	99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD
+					HEX	99,99,99,99,99,DD,FF,FF,FF,FF,FF,99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,9D,9F,9D,9F,99,99,09,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,99
+					HEX	DD,FF,DD,FF,99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,DD,DD,99,99,99,99,99,DD,FF,9F,9F,DF,DF,FF,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,0D,DD,D9,99,99,99,99,09,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD
+					HEX	99,99,D9,F9,FD,FF,FD,FF,F9,99,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,DD,DD,99,99,99,99,99,DD,FF,99,99,99,DD,FF,99,99,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF
+					HEX	DF,DF,DF,DF,DF,A0,A0,A0,A0,A0,A0,D5,FF,FF,FF,FF,FF,FF,FF,80,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,DD,DD,99,99,DD,FF,FF,FF,FF,FF,FF,FF,99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,0D,DD,D9,99,99,99,99,DD,FF,99,99,99,DD,FF,99,99,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,1F,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0
+					HEX	A0,A0,A0,A0,A0,A0,A0,A0,1F,A0,A0,A0,A0,A0,A0,A0,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,DD,DD,99,99,99,99,DD,FF,99,99,9D,DF,F9,99,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,D9,F9,FD,FF,F9,F9,FD,FD,FF,99,09,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,1F,A0,D8,BE,A0,B0,B0,A0,D9,BE,A0,B0,B0,A0,D0,EC,EF,F4,BE,A0,
+					HEX	CF,E6,E6,A0,C3,EF,EC,BE,A0,B0,C6,A0,1F,A0,A0,A0,A0,A0,A0,A0,70,FF,FF,FF,FF,FF,FF,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,DD,DD,99,99,99,99,99,DD,FF,99,99,99,DD,FF,99,99,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,99,99,DD,FF,FF,FF,FF,FF,FF,FF
+					HEX	99,99,00,00,00,00,00,00,00,00,00,00,00,00,00,20,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF
+					HEX	DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,20,A0,BF,AD,C8,E5,EC,F0,C7,FF,FF,FF,FF,FF,FF,FF
+
+
+ROTATE2DATA			HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,D0,DF,DF,DF,D0,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DF,DF,DF,99
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,DD,DD,DD,DD,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,FF,FF,FF,FF
+					HEX	FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DF,DF,DF,99,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD
+					HEX	DD,DD,DD,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,DD,DF,DF,DF,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DF,DF,DF,99,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,DD,DF,DF,DF,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,DD,DF,DF,DF,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DF
+					HEX	DF,DF,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,DD,DD,DD,DD,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,0D,DF,DF,DF,0D,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,FF,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,DD,FD,FD,FD,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,DD,DF,DF,DF,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF
+					HEX	DF,DF,DF,DF,DF,A0,A0,A0,A0,A0,A0,D5,FF,FF,FF,FF,FF,FF,FF,80,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,DD,DD,DD,DD,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,DD,DD,99,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,1F,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0,A0
+					HEX	A0,A0,A0,A0,A0,A0,A0,A0,1F,A0,A0,A0,A0,A0,A0,A0,FF,FF,FF,FF,FF,FF,FF,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,DD,DF,DF,DF,99,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DF,DF,DF,99,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,1F,A0,D8,BE,A0,B0,B0,A0,D9,BE,A0,B0,B0,A0,D0,EC,EF,F4,BE,A0
+					HEX	CF,E6,E6,A0,C3,EF,EC,BE,A0,B0,C6,A0,1F,A0,A0,A0,A0,A0,A0,A0,70,FF,FF,FF,FF,FF,FF,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,DD,DD,DD,99,00,00,00,00,00,00,00,00,00,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,DD,FD,FD,FD,99,00,00,00
+					HEX	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,20,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF
+					HEX	DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,DF,20,A0,BF,AD,C8,E5,EC,F0,C7,FF,FF,FF,FF,FF,FF,FF
\ No newline at end of file