From f0dd6a26953923a71cb0929365d7b2e0563dd67d Mon Sep 17 00:00:00 2001 From: Charles Mangin Date: Sat, 10 Aug 2019 10:14:30 -0400 Subject: [PATCH] New version, pulls HEADER.BIN from disk --- HASH2.dsk | Bin 0 -> 143360 bytes HASH2.s | 2666 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2666 insertions(+) create mode 100644 HASH2.dsk create mode 100644 HASH2.s diff --git a/HASH2.dsk b/HASH2.dsk new file mode 100644 index 0000000000000000000000000000000000000000..6c158c7aed84eb8cc2b1b7432b9329de0c397004 GIT binary patch literal 143360 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 literal 0 HcmV?d00001 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 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 ; 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 + +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 + + + + + + + + +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 + + +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 + +;;RESULT32LO 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 + + + +; 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 + + +; 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 + + +; STABLE DA S0,S1 +;;STABLELO 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 + + +; 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 + +ROTATE1LO db ROTATE1DATA + +ROTATE2LO 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