diff --git a/graphics/hgr/wipes/Makefile b/graphics/hgr/wipes/Makefile index 3d4e6783..7b862c9a 100644 --- a/graphics/hgr/wipes/Makefile +++ b/graphics/hgr/wipes/Makefile @@ -11,6 +11,8 @@ all: wipes.dsk wipes.dsk: HELLO \ bubbles/WIPE_BUBBLES \ star/WIPE_STAR \ + star/WIPE_STAR_BLOOM \ + star/WIPE_STAR_IN \ cascade/WIPE_CASCADE \ center/WIPE_CENTER \ diamond/WIPE_DIAMOND \ @@ -23,6 +25,8 @@ wipes.dsk: HELLO \ $(DOS33) -y wipes.dsk SAVE A HELLO $(DOS33) -y wipes.dsk BSAVE -a 0x5700 bubbles/WIPE_BUBBLES $(DOS33) -y wipes.dsk BSAVE -a 0x1000 star/WIPE_STAR + $(DOS33) -y wipes.dsk BSAVE -a 0x1000 star/WIPE_STAR_BLOOM + $(DOS33) -y wipes.dsk BSAVE -a 0x1000 star/WIPE_STAR_IN $(DOS33) -y wipes.dsk BSAVE -a 0x6000 diamond/WIPE_DIAMOND $(DOS33) -y wipes.dsk BSAVE -a 0x6000 diamond_stripes/WIPE_DIAMOND_STRIPE $(DOS33) -y wipes.dsk BSAVE -a 0x6000 crystal/WIPE_CRYSTAL @@ -65,6 +69,12 @@ lr/WIPE_LR: star/WIPE_STAR: cd star && make +star/WIPE_STAR_IN: + cd star && make + +star/WIPE_STAR_BLOOM: + cd star && make + thin_bar/WIPE_THIN_BAR: cd thin_bar && make diff --git a/graphics/hgr/wipes/fx.lib.2bit.s b/graphics/hgr/wipes/fx.lib.2bit.s new file mode 100644 index 00000000..4cbcea68 --- /dev/null +++ b/graphics/hgr/wipes/fx.lib.2bit.s @@ -0,0 +1,836 @@ +;license:MIT +;(c) 2024 by 4am +; +; common routines used by graphic effects +; +; Note: launcher code can call these routines directly. However, +; graphic effects are assembled as separate targets and must call +; these routines indirectly via the vectors defined in constants.a, +; e.g. iBuildHGRTables instead of BuildHGRTables. +; +; Public functions: +; - WaitForKeyWithTimeout +; - BuildHGRTables +; - BuildHGRMirrorTables +; - BuildHGRMirrorCols +; - BuildDHGRMirrorCols +; - BuildHGRDitherMasks +; - BuildDHGRDitherMasks + +; - BuildHGRSparseBitmasks1Bit +; - BuildDHGRSparseBitmasks1Bit +; - ReverseCoordinates1Bit +; - RippleCoordinates1Bit +; - RippleCoordinates1Bit2 +; - RippleCoordinates1Bit3 +; - RippleCoordinates1Bit4 + +; - BuildHGRSparseBitmasks2Bit +; - BuildDHGRSparseBitmasks2Bit +; - ReverseCoordinates2Bit +; - RippleCoordinates2Bit + +; - SetupPrecomputed3Bit +; - ReverseCoordinates3Bit +; - RippleCoordinates3Bit + +; !source "src/fx/macros.a" + +WaitForKeyWithTimeout: +; in: A = timeout length (like standard $FCA8 wait routine) +; out: A clobbered (not always 0 if key is pressed, but also not the key pressed) +; X/Y preserved + sec +wait1: pha +wait2: sbc #1 + bne wait2 + pla + bit KBD + bmi wfk_exit + sbc #1 + bne wait1 +wfk_exit: rts + +; based on routine by John Brooks +; posted on comp.sys.apple2 on 2018-07-11 +; https://groups.google.com/d/msg/comp.sys.apple2/v2HOfHOmeNQ/zD76fJg_BAAJ +BuildHGRTables: +; out: populates tables at $0201 (hgrlo) and $0301 (hgrhi) +; A clobbered +; X=$C0 (important! some callers rely on this) +; Z=1 +; Y preserved + ldx #0 +bht_m1: txa + and #$F8 + bpl bht_p1 + ora #5 +bht_p1: asl + bpl bht_p2 + ora #5 +bht_p2: asl + asl + sta hgrlo, x + txa + and #7 + rol + asl hgrlo, x + rol + ora #$20 + sta hgrhi, x + inx + cpx #$C0 + bne bht_m1 + rts + +BuildHGRMirrorTables: + ldx #$C0 + ldy #0 +bhm1_m1: tya + and #$F8 + bpl bhm1_p1 + ora #5 +bhm1_p1: asl + bpl bhm1_p2 + ora #5 +bhm1_p2: asl + asl + sta hgrlomirror-1, x + tya + and #7 + rol + asl hgrlomirror-1, x + rol + ora #$20 + sta hgr1himirror-1, x + iny + dex + bne bhm1_m1 + rts + +BuildHGRMirrorCols: +; in: none +; out: mirror_cols populated with lookup table to get $27-y for y in $00..$27 +; all registers and flags clobbered + ldx #$27 + ldy #$00 +bhmc_m1: tya + sta mirror_cols, x + iny + dex + bpl bhmc_m1 + rts + +.if 0 +BuildDHGRMirrorCols: +; out: mirror_cols populated with lookup table to get $27-y for y in $00..$27 +; duplicated in both mainmem and auxmem +; X=0 +; Z=1 + ldx #$28 + ldy #$00 +- tya + sta mirror_cols-1, x + sta $C005 + sta mirror_cols-1, x + sta $C004 + iny + dex + bne - + rts + +BuildHGRDitherMasks: + ldy #40 +- lda #%10110011 + sta dithermasks, y + lda #%11100110 + sta dithermasks+1, y + lda #%11001100 + sta dithermasks+2, y + lda #%10011001 + sta dithermasks+3, y + dey + dey + dey + dey + bpl - + ldy #43 + lda #$FF +- sta no_masks, y + dey + bpl - + rts + +BuildDHGRDitherMasks: + ldy #40 +- lda #%10011110 + sta dithermasks, y + lda #%11111000 + sta dithermasks+1, y + lda #%11100001 + sta dithermasks+2, y + lda #%10000111 + sta dithermasks+3, y + dey + dey + dey + dey + bpl - + ldy #43 +- lda #$FF + sta no_masks, y + dey + bpl - + sta $C005 + ldy #40 +- lda #%10001111 + sta dithermasks, y + lda #%10111100 + sta dithermasks+1, y + lda #%11110000 + sta dithermasks+2, y + lda #%11000011 + sta dithermasks+3, y + dey + dey + dey + dey + bpl - + ldy #43 +- lda #$FF + sta no_masks, y + dey + bpl - + sta $C004 + rts +.endif + +BuildHGRSparseBitmasks1Bit: + lda #%10000001 + sta copymasks1bit + sta mirror_copymasks1bit+$C0 + + lda #%10000010 + sta copymasks1bit+$20 + sta mirror_copymasks1bit+$A0 + + lda #%10000100 + sta copymasks1bit+$40 + sta mirror_copymasks1bit+$80 + + lda #%10001000 + sta copymasks1bit+$60 + sta mirror_copymasks1bit+$60 + + lda #%10010000 + sta copymasks1bit+$80 + sta mirror_copymasks1bit+$40 + + lda #%10100000 + sta copymasks1bit+$A0 + sta mirror_copymasks1bit+$20 + + lda #%11000000 + sta copymasks1bit+$C0 + sta mirror_copymasks1bit + rts +.if 0 +BuildDHGRSparseBitmasks1Bit: +; out: X=0 + ldx #$00 + txa +- sta copymasks1bit, x + sta $C005 + sta copymasks1bit, x + sta $C004 + inx + bne - + ; X=0 + + lda #%00000111 + sta copymasks1bit+$80 + sta mirror_copymasks1bit+$40 + + lda #%00011000 + sta copymasks1bit+$A0 + sta mirror_copymasks1bit+$20 + + lda #%01100000 + sta copymasks1bit+$C0 + sta mirror_copymasks1bit + + sta $C005 + + lda #%10000011 + sta copymasks1bit + sta mirror_copymasks1bit+$C0 + + lda #%10001100 + sta copymasks1bit+$20 + sta mirror_copymasks1bit+$A0 + + lda #%10110000 + sta copymasks1bit+$40 + sta mirror_copymasks1bit+$80 + + lda #%11000000 + sta copymasks1bit+$60 + sta mirror_copymasks1bit+$60 + + sta $C004 + rts + +ReverseCoordinates1Bit: + ldy #0 ; Coordinates1Bit + sta $f1 + lda #<(EndCoordinates1Bit - 2) + sta $f2 + lda #>(EndCoordinates1Bit - 2) + sta $f3 + clc + !byte $24 +- sec +-- lda ($f0), y + pha + lda ($f2), y + sta ($f0), y + pla + sta ($f2), y + iny + bcc - + ldy #0 + !byte $24 +- clc + inc $f0 + bne + + inc $f1 ++ lda $f1 + eor #>(Coordinates1Bit + $1A40) + bne + + lda $f0 + eor #<(Coordinates1Bit + $1A40) + beq ++ ++ lda $f2 + bne + + dec $f3 ++ dec $f2 + bcs - + bcc -- ; always +++ rts +.endif + +BuildHGRSparseBitmasks2Bit: + lda #%10000011 + sta copymasks2bit + sta mirror_copymasks2bit+$E0 + + lda #%10001100 + sta copymasks2bit+$20 + sta mirror_copymasks2bit+$C0 + + lda #%10110000 + sta copymasks2bit+$40 + sta mirror_copymasks2bit+$A0 + + lda #%11000000 + sta copymasks2bit+$60 + sta mirror_copymasks2bit+$80 + + lda #%10000001 + sta copymasks2bit+$80 + sta mirror_copymasks2bit+$60 + + lda #%10000110 + sta copymasks2bit+$A0 + sta mirror_copymasks2bit+$40 + + lda #%10011000 + sta copymasks2bit+$C0 + sta mirror_copymasks2bit+$20 + + lda #%11100000 + sta copymasks2bit+$E0 + sta mirror_copymasks2bit + rts +.if 0 +BuildDHGRSparseBitmasks2Bit: + ldx #$00 + txa +- sta copymasks2bit, x + sta $C005 + sta copymasks2bit, x + sta $C004 + inx + bne - + + lda #%10011111 + sta copymasks2bit+$40 + sta mirror_copymasks2bit+$A0 + + lda #%11100000 + sta copymasks2bit+$60 + sta mirror_copymasks2bit+$80 + + lda #%10000111 + sta copymasks2bit+$C0 + sta mirror_copymasks2bit+$20 + + lda #%11111000 + sta copymasks2bit+$E0 + sta mirror_copymasks2bit + + sta $C005 + + lda #%10001111 + sta copymasks2bit + sta mirror_copymasks2bit+$E0 + + lda #%11110000 + sta copymasks2bit+$20 + sta mirror_copymasks2bit+$C0 + + lda #%10000011 + sta copymasks2bit+$80 + sta mirror_copymasks2bit+$60 + + lda #%11111100 + sta copymasks2bit+$A0 + sta mirror_copymasks2bit+$40 + + sta $C004 + rts +.endif + +ReverseCoordinates2Bit: + ldy #0 ; Coordinates2Bit + sta $f1 + lda #<(EndCoordinates2Bit - 2) + sta $f2 + lda #>(EndCoordinates2Bit - 2) + sta $f3 + + ldx #$1E ; #$3C/2 + clc + .byte $24 ; bit ZP +rc2_m: + sec +rc2_mm: + lda ($f0), Y + pha + lda ($f2), Y + sta ($f0), Y + pla + sta ($f2), Y + iny + bcc rc2_m + ldy #0 + .byte $24 +rc2_m2: + clc + inc $f0 + bne rc2_p + inc $f1 + dex + beq rc2_pp +rc2_p: + lda $f2 + bne rc2_p2 + dec $f3 +rc2_p2: + dec $f2 + bcs rc2_m2 + bcc rc2_mm ; always branches +rc2_pp: + rts + + +.if 0 +RippleCoordinates2Bit: + ldy #0 + + ldx #$33 +- lda @ptrtbl, x + sta $c0, x + dex + bpl - + + lda #$9b + sta $fe + iny + sty $ff + + ldx #6 +- lda Coordinates2Bit + 1, x + sta $7f, x + lda Coordinates2Bit + 9, x + sta $85, x + lda Coordinates2Bit + 17, x + sta $8b, x + lda Coordinates2Bit + 65, x + sta $9b, x + dex + bne - + lda Coordinates2Bit + 28 + sta $92 + lda Coordinates2Bit + 29 + sta $93 + ldx #4 +- lda Coordinates2Bit + 33, x + sta $93, x + lda Coordinates2Bit + 41, x + sta $97, x + lda Coordinates2Bit + 83, x + sta $a1, x + dex + bne - + ldx #2 +- lda Coordinates2Bit + 125, x + sta $a5, x + lda Coordinates2Bit + 131, x + sta $a7, x + lda Coordinates2Bit + 139, x + sta $a9, x + lda Coordinates2Bit + 169, x + sta $ab, x + lda Coordinates2Bit + 237, x + sta $ad, x + lda Coordinates2Bit + 2193, x + sta $af, x + lda Coordinates2Bit + 6581, x + sta $b1, x + dex + bne - + +--- ldx #$34 +-- lda $be, x + tay + ora $bf, x + beq + + lda $bf, x + jsr @aslmod + sty $be, x + sta $bf, x + sty $fc + clc + adc #>Coordinates2Bit + sta $fd + ldy #0 + !byte $24 +- sec + lda ($fc), y + pha + lda $7e, x + sta ($fc), y + pla + sta $7e, x + inx + iny + bcc - + dex + dex ++ dex + dex + bne -- + ldy #1 + lda $fe + eor #<(411 - 2) + beq + + ldy #9 + eor #<(411 - 2) xor <(411 - 136) + bne ++ ++ +- ldx @zerotbl, y + sta $0, x + sta $1, x + dey + bpl - +++ dec $fe + bne --- + dec $ff + bpl --- + bmi @exit ; always branches +@aslmod jsr + ++ cmp #$1E + bcc + + iny ++ pha + tya + asl + tay + pla + rol + cmp #$3C + bcc @exit + sbc #$3C +@exit rts +@ptrtbl !word 2, 4, 6, 10, 12, 14, 18, 20 + !word 22, 28, 34, 36, 42, 44, 66, 68 + !word 70, 84, 86, 126, 132, 140, 170, 238 + !word 2194, 6582 +@zerotbl !byte $f0, $f2, $ca, $d2, $d8, $e0, $e2, $e6, $ea, $ee + +SetupPrecomputed3Bit: + ; build regular HGR lookup tables, then split them + jsr BuildHGRTables + ldx #$BF + ldy #$3F +- lda hgrlo, x + sta hgrlo3c, y + sta hgrlo3c+$40, y + lda hgrhi, x + sta hgrhi3c, y + sta hgrhi3c+$40, y + dex + lda hgrlo, x + sta hgrlo3b, y + sta hgrlo3b+$40, y + lda hgrhi, x + sta hgrhi3b, y + sta hgrhi3b+$40, y + dex + lda hgrlo, x + sta hgrlo3a, y + sta hgrlo3a+$40, y + lda hgrhi, x + sta hgrhi3a, y + sta hgrhi3a+$40, y + dex + dey + bpl - + + ; build lookup table to get $20+y for y in $00..$07 + ldx #$07 + ldy #$27 +- tya + sta extra_cols-$20, y + dey + dex + bpl - + + ; build sparse lookup tables for bitmasks + lda #%10000011 + sta copymasks3bit + + lda #%10001100 + sta copymasks3bit+$20 + + lda #%10110000 + sta copymasks3bit+$40 + + lda #%11000000 + sta copymasks3bit+$60 + + lda #%10000001 + sta copymasks3bit+$80 + + lda #%10000110 + sta copymasks3bit+$A0 + + lda #%10011000 + sta copymasks3bit+$C0 + + lda #%11100000 + sta copymasks3bit+$E0 + rts + +ReverseCoordinates3Bit: + ldy #0 ; Coordinates3Bit + sta $f1 + lda #<(EndCoordinates3Bit - 2) + sta $f2 + lda #>(EndCoordinates3Bit - 2) + sta $f3 + + ldx #$28 ; #$50/2 + clc + !byte $24 +- sec +-- lda ($f0), y + pha + lda ($f2), y + sta ($f0), y + pla + sta ($f2), y + iny + bcc - + ldy #0 + !byte $24 +- clc + inc $f0 + bne + + inc $f1 + dex + beq ++ ++ lda $f2 + bne + + dec $f3 ++ dec $f2 + bcs - + bcc -- ; always branches +++ rts + +RippleCoordinates3Bit: + ldx #$1B +- lda @ripplezp, x + sta $e0, x + dex + bpl - + +--- ldx #$0c +-- ldy $ee, x + lda $ef, x + jsr @aslmod + sty $ee, x + sta $ef, x + sty $ec + clc + adc #>Coordinates3Bit + sta $ed + ldy #0 + !byte $24 +- sec + lda ($ec), y + pha + lda $de, x + sta ($ec), y + pla + sta $de, x + inx + iny + bcc - + dex + dex + dex + dex + bne -- + dec $ee + bne --- + dec $ef + bpl --- + bmi @exit ; always branches +@aslmod jsr + ++ cmp #$28 + bcc + + iny ++ pha + tya + asl + tay + pla + rol + cmp #$50 + bcc @exit + sbc #$50 +@exit rts +@ripplezp + !byte $1F,$F3,$20,$F3,$20,$14,$20,$D3 + !byte $1E,$F3,$1F,$54,$00,$00,$AA,$06 + !byte $02,$00,$04,$00,$06,$00,$0C,$00 + !byte $16,$00,$1A,$00 + +!zone { +RippleCoordinates1Bit4: + lda #Coordinates1Bit + sta $ed + ldy #0 + !byte $24 +- sec + lda ($ec), y + pha + lda $de, x + sta ($ec), y + pla + sta $de, x + inx + iny + bcc - + dex + dex + dex + dex + bne -- + dec $ee + bne --- + dec $ef + bpl --- + bmi exit ; always branches +aslmod4 jsr aslmod +aslmod3 jsr aslmod +aslmod2 jsr aslmod +aslmod cmp #$1A +!if (>aslmod != >aslmod4) { + !serious "aslmod entry points are not on the same page" +} + bcc + + bne ++ + cpy #$40 + bcc + +++ iny ++ pha + tya + asl + tay + pla + rol + cmp #$34 + bcc exit + bne ++ + cpy #$80 + bcc exit +++ pha + tya + sbc #$80 + tay + pla + sbc #$34 +exit rts +} + +.endif diff --git a/graphics/hgr/wipes/fx.lib.s b/graphics/hgr/wipes/fx.lib.s index edb64288..6e75034c 100644 --- a/graphics/hgr/wipes/fx.lib.s +++ b/graphics/hgr/wipes/fx.lib.s @@ -401,45 +401,55 @@ BuildDHGRSparseBitmasks2Bit: sta $C004 rts +.endif +.if 0 ReverseCoordinates2Bit: - ldy #0 ; Coordinates2Bit - sta $f1 - lda #<(EndCoordinates2Bit - 2) - sta $f2 - lda #>(EndCoordinates2Bit - 2) - sta $f3 + ldy #0 ; Coordinates2Bit + sta $f1 + lda #<(EndCoordinates2Bit - 2) + sta $f2 + lda #>(EndCoordinates2Bit - 2) + sta $f3 - ldx #$1E ; #$3C/2 - clc - !byte $24 -- sec --- lda ($f0), y - pha - lda ($f2), y - sta ($f0), y - pla - sta ($f2), y - iny - bcc - - ldy #0 - !byte $24 -- clc - inc $f0 - bne + - inc $f1 - dex - beq ++ -+ lda $f2 - bne + - dec $f3 -+ dec $f2 - bcs - - bcc -- ; always branches -++ rts + ldx #$1E ; #$3C/2 + clc + .byte $24 ; bit ZP +rc2_m: + sec +rc2_mm: + lda ($f0), Y + pha + lda ($f2), Y + sta ($f0), Y + pla + sta ($f2), Y + iny + bcc rc2_m + ldy #0 + .byte $24 +rc2_m2: + clc + inc $f0 + bne rc2_p + inc $f1 + dex + beq rc2_pp +rc2_p: + lda $f2 + bne rc2_p2 + dec $f3 +rc2_p2: + dec $f2 + bcs rc2_m2 + bcc rc2_mm ; always branches +rc2_pp: + rts +.endif +.if 0 RippleCoordinates2Bit: ldy #0 diff --git a/graphics/hgr/wipes/star/Makefile b/graphics/hgr/wipes/star/Makefile index 44e8d156..9aa21027 100644 --- a/graphics/hgr/wipes/star/Makefile +++ b/graphics/hgr/wipes/star/Makefile @@ -3,7 +3,7 @@ include ../../../../Makefile.inc LINKER_SCRIPTS = ../../../../linker_scripts ZX02 = ~/research/6502_compression/zx02.git/build/zx02 -f -all: WIPE_STAR +all: WIPE_STAR WIPE_STAR_BLOOM WIPE_STAR_IN ### @@ -23,8 +23,42 @@ wipe_star.o: wipe_star.s \ ### +WIPE_STAR_BLOOM: wipe_star_bloom.o + ld65 -o WIPE_STAR_BLOOM wipe_star_bloom.o -C $(LINKER_SCRIPTS)/apple2_1000.inc + +wipe_star_bloom.o: wipe_star_bloom.s \ + ../zp.inc ../hardware.inc ../wait_keypress.s ../zx02_optim.s \ + code.hgr.precomputed.2bit.s \ + ../main_macros.s \ + fx.hgr.star.s \ + fx.hgr.precomputed.2bit.s \ + fx.hgr.star_bloom.data \ + ../fx.lib.s \ + ../macros.s + ca65 -o wipe_star_bloom.o wipe_star_bloom.s -l wipe_star_bloom.lst + +### + +WIPE_STAR_IN: wipe_star_in.o + ld65 -o WIPE_STAR_IN wipe_star_in.o -C $(LINKER_SCRIPTS)/apple2_1000.inc + +wipe_star_in.o: wipe_star_in.s \ + ../zp.inc ../hardware.inc ../wait_keypress.s ../zx02_optim.s \ + code.hgr.precomputed.2bit.s \ + ../main_macros.s \ + fx.hgr.star.in.s \ + fx.hgr.precomputed.2bit.s \ + fx.hgr.star.data \ + ../fx.lib.s \ + ../macros.s + ca65 -o wipe_star_in.o wipe_star_in.s -l wipe_star_in.lst + + +### + star_data.zx02: fx.hgr.star.data $(ZX02) fx.hgr.star.data star_data.zx02 +### fx.hgr.star.data: fx.hgr.star.data.o ld65 -o fx.hgr.star.data fx.hgr.star.data.o -C $(LINKER_SCRIPTS)/apple2_8100.inc @@ -34,6 +68,17 @@ fx.hgr.star.data.o: fx.hgr.star.data.s ### -clean: - rm -f *~ *.o *.lst *.zx02 HELLO WIPE_STAR fx.hgr.star.data +fx.hgr.star_bloom.data: fx.hgr.star_bloom.data.o + ld65 -o fx.hgr.star_bloom.data fx.hgr.star_bloom.data.o -C $(LINKER_SCRIPTS)/apple2_8100.inc + +fx.hgr.star_bloom.data.o: fx.hgr.star.bloom.data.s + ca65 -o fx.hgr.star_bloom.data.o fx.hgr.star.bloom.data.s -l fx.hgr.star_bloom.data.lst + + +### + +clean: + rm -f *~ *.o *.lst *.zx02 HELLO \ + WIPE_STAR WIPE_STAR_BLOOM WIPE_STAR_IN \ + fx.hgr.star.data fx.hgr.star_bloom.data diff --git a/graphics/hgr/wipes/star/fx.hgr.star.bloom.data.s b/graphics/hgr/wipes/star/fx.hgr.star.bloom.data.s new file mode 100644 index 00000000..28d39c3f --- /dev/null +++ b/graphics/hgr/wipes/star/fx.hgr.star.bloom.data.s @@ -0,0 +1,7683 @@ +; !cpu 6502 +; !to "build/FXDATA/STAR.BLOOM.DATA",plain +; *=$8100 + .byte $A5,%01000000 + .byte $01,%00100010 + .byte $B3,%00100010 + .byte $B3,%00000010 + .byte $1D,%00100000 + .byte $B7,%10100001 + .byte $B7,%10000001; + .byte $B7,%01100000 + .byte $BB,%10000001; + .byte $BB,%01100000 + .byte $29,%11100001 + .byte $BD,%11100001 + .byte $33,%00100000 + .byte $01,%10100011 + .byte $01,%00100100 + .byte $03,%01000000 + .byte $03,%11000001 + .byte $03,%00100000 + .byte $03,%00000000 + .byte $03,%11100001 + .byte $A7,%00000000 + .byte $7D,%01000000 + .byte $07,%01000000 + .byte $AD,%00000000 + .byte $0B,%11000001 + .byte $0B,%10000011; + .byte $0B,%01100010 + .byte $B1,%00100000 + .byte $0B,%01000000 + .byte $BF,%10000001; + .byte $BF,%01100000 + .byte $BB,%10100001 + .byte $11,%10100001 + .byte $13,%00000000 + .byte $05,%11000111 + .byte $15,%11100001 + .byte $89,%00000000 + .byte $BF,%11100011 + .byte $91,%00100000 + .byte $05,%10100101 + .byte $97,%00100000 + .byte $13,%10000101; + .byte $13,%01100100 + .byte $03,%01000100 + .byte $9D,%01000000 + .byte $27,%01000100 + .byte $15,%00000100 + .byte $9D,%00000000 + .byte $07,%11100011 + .byte $A1,%00100010 + .byte $11,%11100011 + .byte $A3,%11100011 + .byte $19,%11100011 + .byte $A1,%00000000 + .byte $A5,%01000100 + .byte $A5,%00100010 + .byte $07,%01000010 + .byte $A5,%00000010 + .byte $A5,%11100001 + .byte $03,%00100010 + .byte $17,%10000011; + .byte $17,%01100010 + .byte $A9,%10100011 + .byte $43,%11000001 + .byte $A9,%10000011; + .byte $A9,%01100010 + .byte $13,%00100010 + .byte $A9,%11100001 + .byte $A9,%11000001 + .byte $09,%11100001 + .byte $0F,%00000010 + .byte $25,%10000011; + .byte $25,%01100010 + .byte $AD,%10100001 + .byte $AD,%11100101 + .byte $AD,%11000101 + .byte $AD,%11000001 + .byte $AD,%01000000 + .byte $AD,%00100000 + .byte $AD,%00000100 + .byte $AD,%11100011 + .byte $AD,%11100001 + .byte $AD,%10000001; + .byte $AD,%01100000 + .byte $AF,%00000000 + .byte $AF,%10000101; + .byte $AF,%01100100 + .byte $AF,%10101001 + .byte $AF,%10000011; + .byte $AF,%01100010 + .byte $23,%00000010 + .byte $05,%00100000 + .byte $19,%11000001 + .byte $09,%01000000 + .byte $17,%10100001 + .byte $09,%00100000 + .byte $B1,%10000101; + .byte $B1,%01100100 + .byte $B1,%11100001 + .byte $B1,%11000001 + .byte $B1,%01000000 + .byte $B3,%00000000 + .byte $B3,%10100001 + .byte $B3,%10000011; + .byte $B3,%01100010 + .byte $B3,%10100011 + .byte $B1,%00001010 + .byte $B3,%01000010 + .byte $B5,%00100000 + .byte $B5,%01000000 + .byte $1B,%01000000 + .byte $B3,%00101000 + .byte $B7,%00000010 + .byte $B7,%11000001 + .byte $B5,%11100101 + .byte $B9,%01000000 + .byte $B7,%11100011 + .byte $B3,%10001011; + .byte $B3,%01101010 + .byte $B5,%10100111 + .byte $B7,%00100100 + .byte $B9,%11100011 + .byte $B9,%00100010 + .byte $BB,%01000000 + .byte $1F,%00100000 + .byte $B7,%11000101 + .byte $B9,%11000011 + .byte $B9,%01000010 + .byte $BB,%11000001 + .byte $1D,%00000000 + .byte $BD,%11000001 + .byte $BD,%00000010 + .byte $31,%10100001 + .byte $BF,%00100000 + .byte $BB,%00100110 + .byte $BB,%00000110 + .byte $B7,%00101010 + .byte $BF,%10100011 + .byte $31,%01000000 + .byte $2D,%00100000 + .byte $BF,%01000100 + .byte $BD,%00100110 + .byte $BF,%00000100 + .byte $BF,%10100101 + .byte $BF,%10000101; + .byte $BF,%01100100 + .byte $3D,%11000001 + .byte $6F,%00100000 + .byte $33,%00000000 + .byte $BD,%11101001 + .byte $B9,%10001101; + .byte $B9,%01101100 + .byte $BB,%00101100 + .byte $3B,%00000000 + .byte $BF,%10001011; + .byte $BF,%01101010 + .byte $43,%01000000 + .byte $85,%00000000 + .byte $51,%00000010 + .byte $4B,%10100001 + .byte $47,%01000000 + .byte $43,%00000000 + .byte $85,%01000000 + .byte $BF,%10001101; + .byte $BF,%01101100 + .byte $8F,%00000000 + .byte $87,%10100001 + .byte $93,%00000000 + .byte $95,%00000000 + .byte $01,%11000011 + .byte $03,%01001110 + .byte $01,%01000010 + .byte $9B,%00000000 + .byte $99,%00100000 + .byte $83,%00100010 + .byte $99,%01000000 + .byte $95,%10000001; + .byte $95,%01100000 + .byte $05,%00100100 + .byte $05,%10100011 + .byte $03,%10100001 + .byte $07,%01000100 + .byte $05,%10000001; + .byte $05,%01100000 + .byte $A5,%00000000 + .byte $9F,%01000000 + .byte $9D,%10000001; + .byte $9D,%01100000 + .byte $A3,%01000000 + .byte $A9,%00000000 + .byte $A7,%00100000 + .byte $09,%11000011 + .byte $09,%11000001 + .byte $0B,%00000100 + .byte $57,%01000000 + .byte $A7,%01000000 + .byte $A3,%10000001; + .byte $A3,%01100000 + .byte $AF,%00100000 + .byte $9B,%11100001 + .byte $9D,%11100001 + .byte $AB,%01000000 + .byte $0B,%00100000 + .byte $0D,%01000010 + .byte $B7,%00000000 + .byte $AF,%01000000 + .byte $A3,%11000001 + .byte $0F,%10100011 + .byte $BB,%00000000 + .byte $9F,%00000010 + .byte $B7,%00100000 + .byte $AF,%10000001; + .byte $AF,%01100000 + .byte $AB,%10100001 + .byte $9B,%01000010 + .byte $0F,%01000000 + .byte $0F,%11000001 + .byte $BF,%00000000 + .byte $5B,%00100000 + .byte $B9,%10000001; + .byte $B9,%01100000 + .byte $11,%10000001; + .byte $11,%01100000 + .byte $BD,%01000000 + .byte $A7,%00000010 + .byte $9F,%01000010 + .byte $11,%01000000 + .byte $AB,%11100001 + .byte $AB,%00000010 + .byte $13,%01000010 + .byte $B5,%11100001 + .byte $BF,%10100001 + .byte $B9,%11000001 + .byte $AF,%00000010 + .byte $A3,%10100011 + .byte $B9,%11100001 + .byte $AD,%01000010 + .byte $B5,%00000010 + .byte $17,%11100001 + .byte $A5,%10100011 + .byte $17,%11000001 + .byte $BB,%00000010 + .byte $B1,%01000010 + .byte $AF,%01000010 + .byte $AB,%10000011; + .byte $AB,%01100010 + .byte $B7,%01000010 + .byte $BB,%00100010 + .byte $A1,%11100011 + .byte $19,%00000000 + .byte $19,%01000010 + .byte $19,%10000011; + .byte $19,%01100010 + .byte $BF,%00000010 + .byte $B5,%01000010 + .byte $1B,%00100000 + .byte $B7,%10000011; + .byte $B7,%01100010 + .byte $1B,%00000000 + .byte $1B,%10000001; + .byte $1B,%01100000 + .byte $B1,%10100011 + .byte $BF,%01000010 + .byte $B1,%11000011 + .byte $BB,%10100011 + .byte $B5,%11000011 + .byte $A9,%00000100 + .byte $BD,%11000011 + .byte $AF,%00000100 + .byte $A3,%01000100 + .byte $1F,%01000000 + .byte $1F,%10100011 + .byte $21,%11100001 + .byte $B5,%00000100 + .byte $A9,%01000100 + .byte $B5,%00100100 + .byte $21,%11100011 + .byte $BD,%00000100 + .byte $AD,%01000100 + .byte $BD,%00100100 + .byte $69,%00000000 + .byte $BB,%00100100 + .byte $A7,%10100101 + .byte $B9,%01000100 + .byte $BB,%01000100 + .byte $B5,%10000101; + .byte $B5,%01100100 + .byte $B9,%10000101; + .byte $B9,%01100100 + .byte $B1,%10100101 + .byte $29,%00000000 + .byte $BD,%10100101 + .byte $BF,%11010011 + .byte $B1,%11100101 + .byte $AF,%11100101 + .byte $29,%00000010 + .byte $B7,%11100101 + .byte $AD,%00100110 + .byte $B7,%00100110 + .byte $B5,%00100110 + .byte $31,%00100000 + .byte $09,%00101010 + .byte $BF,%01000110 + .byte $03,%00101010 + .byte $B3,%10100111 + .byte $AB,%10100111 + .byte $7B,%00000010 + .byte $77,%01000000 + .byte $BF,%10100111 + .byte $BB,%10100111 + .byte $7D,%00100010 + .byte $37,%11000001 + .byte $BD,%11100111 + .byte $B7,%11100111 + .byte $B5,%11100111 + .byte $B3,%11100111 + .byte $0B,%11001001 + .byte $B9,%00001000 + .byte $05,%11001001 + .byte $7F,%00100010 + .byte $A3,%00101000 + .byte $AD,%00101000 + .byte $3B,%10100001 + .byte $09,%10101001 + .byte $B9,%01001000 + .byte $3D,%11100001 + .byte $BF,%10001001; + .byte $BF,%01101000 + .byte $B9,%10001001; + .byte $B9,%01101000 + .byte $BF,%10101001 + .byte $83,%11100001 + .byte $13,%01001000 + .byte $B3,%11001001 + .byte $87,%11100011 + .byte $81,%00100000 + .byte $83,%01000000 + .byte $BB,%00001010 + .byte $83,%00000000 + .byte $1F,%00101000 + .byte $03,%00001000 + .byte $03,%11000111 + .byte $01,%10100111 + .byte $49,%01000010 + .byte $BF,%10101011 + .byte $11,%11000111 + .byte $BD,%11001011 + .byte $8D,%01000010 + .byte $8F,%11100011 + .byte $8B,%00000000 + .byte $1D,%11000111 + .byte $05,%10000111; + .byte $05,%01100110 + .byte $01,%01000110 + .byte $53,%10000001; + .byte $53,%01100000 + .byte $55,%00000000 + .byte $0B,%01000110 + .byte $55,%10000001; + .byte $55,%01100000 + .byte $8F,%01000000 + .byte $17,%10000111; + .byte $17,%01100110 + .byte $07,%00100110 + .byte $05,%00000110 + .byte $91,%00100010 + .byte $1F,%10000111; + .byte $1F,%01100110 + .byte $03,%11100101 + .byte $01,%11100101 + .byte $93,%11000011 + .byte $91,%00000000 + .byte $93,%00100000 + .byte $BD,%10001101; + .byte $BD,%01101100 + .byte $93,%00100010 + .byte $93,%01000000 + .byte $0B,%11100101 + .byte $BF,%10101101 + .byte $5F,%00000000 + .byte $BD,%10101101 + .byte $03,%10100101 + .byte $95,%10100001 + .byte $95,%00100000 + .byte $95,%11000001 + .byte $09,%11000101 + .byte $01,%10100101 + .byte $5D,%11000001 + .byte $0D,%11000101 + .byte $97,%10100011 + .byte $21,%00100110 + .byte $0D,%10100101 + .byte $97,%10100001 + .byte $97,%01000000 + .byte $97,%10000001; + .byte $97,%01100000 + .byte $97,%00000000 + .byte $99,%00100100 + .byte $99,%10000001; + .byte $99,%01100000 + .byte $21,%00000110 + .byte $0B,%10000101; + .byte $0B,%01100100 + .byte $99,%00100010 + .byte $05,%01000100 + .byte $03,%00100100 + .byte $09,%01000100 + .byte $9B,%00000010 + .byte $9B,%10100001 + .byte $9B,%00100000 + .byte $63,%11000001 + .byte $1B,%11000101 + .byte $9B,%00100010 + .byte $9B,%11000001 + .byte $9B,%01000000 + .byte $05,%00000100 + .byte $69,%01000000 + .byte $11,%01000100 + .byte $0F,%01000100 + .byte $0F,%00100100 + .byte $9D,%10000011; + .byte $9D,%01100010 + .byte $9D,%10100001 + .byte $9D,%00100010 + .byte $9D,%11000001 + .byte $09,%00000100 + .byte $03,%10101111 + .byte $09,%11100011 + .byte $9F,%10000001; + .byte $9F,%01100000 + .byte $17,%01000100 + .byte $03,%11000011 + .byte $9F,%10100001 + .byte $0D,%00000100 + .byte $05,%11000011 + .byte $03,%10001111; + .byte $03,%01101110 + .byte $03,%10100011 + .byte $9F,%10000011; + .byte $9F,%01100010 + .byte $07,%11000011 + .byte $9F,%11000011 + .byte $9F,%10100011 + .byte $9F,%00100010 + .byte $BF,%11001111 + .byte $15,%00100100 + .byte $23,%10100101 + .byte $9F,%01000110 + .byte $A1,%11100001 + .byte $A1,%10000001; + .byte $A1,%01100000 + .byte $A1,%00100000 + .byte $17,%00100100 + .byte $05,%01001110 + .byte $A1,%00000010 + .byte $23,%10000101; + .byte $23,%01100100 + .byte $03,%01000010 + .byte $01,%10101101 + .byte $A3,%00000000 + .byte $75,%00000000 + .byte $73,%00100000 + .byte $A1,%10100011 + .byte $37,%00100110 + .byte $13,%11100011 + .byte $0F,%11000011 + .byte $07,%10000011; + .byte $07,%01100010 + .byte $0D,%10100011 + .byte $A3,%10100001 + .byte $11,%11000011 + .byte $09,%10000011; + .byte $09,%01100010 + .byte $01,%10001101; + .byte $01,%01101100 + .byte $A3,%10000011; + .byte $A3,%01100010 + .byte $A3,%00000010 + .byte $1D,%00100100 + .byte $05,%01000010 + .byte $07,%00101110 + .byte $09,%01000010 + .byte $A1,%11000111 + .byte $A5,%10000001; + .byte $A5,%01100000 + .byte $1B,%00000100 + .byte $0D,%10000011; + .byte $0D,%01100010 + .byte $A3,%00100100 + .byte $A3,%11000011 + .byte $73,%10100001 + .byte $B7,%11101111 + .byte $21,%00100100 + .byte $A5,%01000010 + .byte $BD,%00110000 + .byte $1B,%11100011 + .byte $A1,%00101000 + .byte $A5,%10000011; + .byte $A5,%01100010 + .byte $11,%10000011; + .byte $11,%01100010 + .byte $A5,%00000100 + .byte $A7,%11000001 + .byte $2B,%10000101; + .byte $2B,%01100100 + .byte $15,%10100011 + .byte $05,%11100001 + .byte $09,%11101101 + .byte $A5,%00100100 + .byte $A7,%11100001 + .byte $A7,%10100001 + .byte $7D,%00000000 + .byte $BD,%01010000 + .byte $2F,%10100101 + .byte $21,%00000100 + .byte $19,%11000011 + .byte $17,%10100011 + .byte $07,%00000010 + .byte $01,%11000001 + .byte $15,%10000011; + .byte $15,%01100010 + .byte $05,%11000001 + .byte $A5,%11100101 + .byte $A9,%10100001 + .byte $07,%11100001 + .byte $01,%10100001 + .byte $A7,%11100011 + .byte $A7,%10000011; + .byte $A7,%01100010 + .byte $A9,%10000001; + .byte $A9,%01100000 + .byte $35,%11000101 + .byte $07,%11000001 + .byte $AB,%00100000 + .byte $1F,%11000011 + .byte $11,%00100010 + .byte $A9,%01000010 + .byte $7B,%10100001 + .byte $2F,%10000101; + .byte $2F,%01100100 + .byte $15,%01000010 + .byte $0D,%00000010 + .byte $0B,%11100001 + .byte $01,%10000001; + .byte $01,%01100000 + .byte $11,%00000010 + .byte $A9,%11000011 + .byte $BB,%10110001 + .byte $0D,%11100001 + .byte $01,%01000000 + .byte $01,%11101001 + .byte $A7,%00000110 + .byte $A9,%11100011 + .byte $2B,%00100100 + .byte $A9,%10000101; + .byte $A9,%01100100 + .byte $AB,%00100010 + .byte $01,%10101001 + .byte $A7,%10000111; + .byte $A7,%01100110 + .byte $A9,%10100101 + .byte $A9,%00100100 + .byte $AB,%01000010 + .byte $1D,%10000011; + .byte $1D,%01100010 + .byte $11,%11100001 + .byte $05,%01000000 + .byte $01,%00100000 + .byte $01,%10001001; + .byte $01,%01101000 + .byte $A9,%11000101 + .byte $2B,%00000100 + .byte $25,%11000011 + .byte $1D,%01000010 + .byte $0B,%10000001; + .byte $0B,%01100000 + .byte $05,%00001010 + .byte $A9,%00000110 + .byte $A9,%11100101 + .byte $AB,%11100011 + .byte $03,%11001001 + .byte $2B,%11100011 + .byte $13,%11000001 + .byte $0D,%10000001; + .byte $0D,%01100000 + .byte $07,%00100000 + .byte $01,%00001000 + .byte $AB,%01000100 + .byte $AD,%10100011 + .byte $AF,%10100001 + .byte $B1,%00000000 + .byte $25,%10100011 + .byte $A9,%01000110 + .byte $AD,%11000011 + .byte $89,%00100000 + .byte $1B,%00100010 + .byte $19,%00000010 + .byte $01,%00101000 + .byte $0F,%10000001; + .byte $0F,%01100000 + .byte $05,%10001001; + .byte $05,%01101000 + .byte $AD,%00100100 + .byte $83,%11000001 + .byte $1B,%00000010 + .byte $19,%11100001 + .byte $03,%00101000 + .byte $07,%11101001 + .byte $A9,%11000111 + .byte $AB,%11000101 + .byte $AF,%00100010 + .byte $B1,%10100001 + .byte $15,%11000001 + .byte $13,%10100001 + .byte $0D,%01000000 + .byte $05,%10101001 + .byte $1B,%11100001 + .byte $07,%11001001 + .byte $AF,%10100011 + .byte $B3,%01000000 + .byte $2F,%11100011 + .byte $2B,%11000011 + .byte $15,%10100001 + .byte $13,%10000001; + .byte $13,%01100000 + .byte $0D,%00100000 + .byte $AB,%00100110 + .byte $AD,%10100101 + .byte $AD,%10000101; + .byte $AD,%01100100 + .byte $B1,%00000010 + .byte $B3,%10000001; + .byte $B3,%01100000 + .byte $33,%00100100 + .byte $23,%01000010 + .byte $05,%00101000 + .byte $15,%10000001; + .byte $15,%01100000 + .byte $13,%01000000 + .byte $AD,%00000110 + .byte $89,%10100001 + .byte $2B,%10100011 + .byte $23,%00100010 + .byte $AB,%10000111; + .byte $AB,%01100110 + .byte $B5,%00000000 + .byte $0D,%00000000 + .byte $07,%01001000 + .byte $AD,%01000110 + .byte $B1,%11100011 + .byte $3F,%10100101 + .byte $01,%11000101 + .byte $B1,%00000100 + .byte $B5,%11000001 + .byte $37,%00100100 + .byte $2F,%11000011 + .byte $21,%00000010 + .byte $07,%00001000 + .byte $25,%00000010 + .byte $B1,%00100100 + .byte $15,%00100000 + .byte $01,%10000101; + .byte $01,%01100100 + .byte $AB,%01001000 + .byte $B1,%01000100 + .byte $2F,%10100011 + .byte $2B,%10000011; + .byte $2B,%01100010 + .byte $01,%01000100 + .byte $03,%11000101 + .byte $05,%00100110 + .byte $0B,%10101001 + .byte $1F,%10100001 + .byte $1D,%10000001; + .byte $1D,%01100000 + .byte $01,%00000100 + .byte $05,%11000101 + .byte $09,%11000111 + .byte $0D,%10101001 + .byte $AD,%00001000 + .byte $B1,%11000101 + .byte $B5,%10100011 + .byte $B9,%00100000 + .byte $95,%01000000 + .byte $93,%10000001; + .byte $93,%01100000 + .byte $23,%11100001 + .byte $21,%11000001 + .byte $01,%11100011 + .byte $0B,%01001000 + .byte $AF,%10000111; + .byte $AF,%01100110 + .byte $B3,%00000100 + .byte $99,%00000000 + .byte $2B,%01000010 + .byte $29,%00100010 + .byte $03,%10000101; + .byte $03,%01100100 + .byte $05,%11100101 + .byte $07,%01000110 + .byte $0F,%00101010 + .byte $2F,%10000011; + .byte $2F,%01100010 + .byte $21,%10100001 + .byte $1F,%10000001; + .byte $1F,%01100000 + .byte $19,%00100000 + .byte $01,%10000011; + .byte $01,%01100010 + .byte $05,%10000101; + .byte $05,%01100100 + .byte $09,%01000110 + .byte $0B,%11100111 + .byte $AF,%10100111 + .byte $B1,%00000110 + .byte $B7,%00100010 + .byte $2B,%00100010 + .byte $03,%00000100 + .byte $AF,%11000111 + .byte $B1,%00100110 + .byte $B3,%10100101 + .byte $B5,%11100011 + .byte $B5,%01010010 + .byte $1D,%01000000 + .byte $17,%00000000 + .byte $03,%11100011 + .byte $2F,%01000010 + .byte $05,%11100011 + .byte $07,%10100101 + .byte $AF,%11100111 + .byte $B5,%01000100 + .byte $B7,%10100011 + .byte $B9,%00000010 + .byte $BD,%00100000 + .byte $9F,%00000000 + .byte $9D,%00100000 + .byte $93,%11000001 + .byte $91,%11100001 + .byte $01,%11100001 + .byte $03,%10000011; + .byte $03,%01100010 + .byte $07,%10000101; + .byte $07,%01100100 + .byte $09,%11100101 + .byte $AD,%10001001; + .byte $AD,%01101000 + .byte $B1,%10000111; + .byte $B1,%01100110 + .byte $B1,%01000110 + .byte $BD,%00000000 + .byte $8D,%00100010 + .byte $31,%10000011; + .byte $31,%01100010 + .byte $21,%10000001; + .byte $21,%01100000 + .byte $01,%00000010 + .byte $2F,%00100010 + .byte $03,%00000010 + .byte $BD,%10100001 + .byte $9B,%10000001; + .byte $9B,%01100000 + .byte $99,%10100001 + .byte $97,%11000001 + .byte $23,%10000001; + .byte $23,%01100000 + .byte $21,%01000000 + .byte $07,%00100100 + .byte $09,%10100101 + .byte $0D,%10100111 + .byte $AD,%11001001 + .byte $B1,%11000111 + .byte $B3,%00000110 + .byte $B5,%10100101 + .byte $B9,%10100011 + .byte $9F,%00100000 + .byte $87,%11000011 + .byte $05,%10000011; + .byte $05,%01100010 + .byte $07,%00000100 + .byte $09,%10000101; + .byte $09,%01100100 + .byte $01,%00000000 + .byte $0D,%01000110 + .byte $AF,%10001001; + .byte $AF,%01101000 + .byte $B5,%00000110 + .byte $BB,%01000010 + .byte $35,%10000011; + .byte $35,%01100010 + .byte $29,%11000001 + .byte $03,%10000001; + .byte $03,%01100000 + .byte $05,%00000010 + .byte $07,%10100011 + .byte $0D,%00100110 + .byte $B7,%10000101; + .byte $B7,%01100100 + .byte $B9,%00000100 + .byte $BB,%10000011; + .byte $BB,%01100010 + .byte $BF,%01000000 + .byte $A3,%00100000 + .byte $A1,%01000000 + .byte $99,%11000001 + .byte $97,%11100001 + .byte $05,%00100010 + .byte $09,%00100100 + .byte $0B,%10100101 + .byte $39,%10100011 + .byte $23,%00100000 + .byte $05,%10100001 + .byte $07,%00100010 + .byte $0B,%00100100 + .byte $B5,%01000110 + .byte $BD,%00100010 + .byte $BF,%11100001 + .byte $A5,%00100000 + .byte $99,%11100001 + .byte $29,%10100001 + .byte $0F,%01000110 + .byte $11,%00001000 + .byte $13,%10101001 + .byte $B7,%10100101 + .byte $B9,%00100100 + .byte $BD,%01000010 + .byte $BF,%11000001 + .byte $3F,%00000100 + .byte $21,%00000000 + .byte $09,%10100011 + .byte $0B,%01000100 + .byte $31,%00000010 + .byte $2B,%10100001 + .byte $29,%10000001; + .byte $29,%01100000 + .byte $0B,%10100011 + .byte $0B,%11100011 + .byte $B1,%01001000 + .byte $B3,%00001000 + .byte $B5,%10000111; + .byte $B5,%01100110 + .byte $B7,%00000110 + .byte $BD,%10100011 + .byte $A9,%00100000 + .byte $A1,%10100001 + .byte $9F,%11000001 + .byte $05,%00000000 + .byte $07,%10100001 + .byte $09,%00100010 + .byte $0B,%11000011 + .byte $0D,%00100100 + .byte $0D,%10000101; + .byte $0D,%01100100 + .byte $0F,%00000110 + .byte $11,%10000111; + .byte $11,%01100110 + .byte $B1,%10001001; + .byte $B1,%01101000 + .byte $BF,%00100010 + .byte $AB,%00000000 + .byte $35,%01000010 + .byte $27,%01000000 + .byte $25,%00100000 + .byte $07,%10000001; + .byte $07,%01100000 + .byte $09,%00000010 + .byte $0D,%01000100 + .byte $15,%11101001 + .byte $09,%10000001; + .byte $09,%01100000 + .byte $0B,%00000010 + .byte $0B,%01000010 + .byte $B5,%11000111 + .byte $BB,%10000101; + .byte $BB,%01100100 + .byte $BF,%10000011; + .byte $BF,%01100010 + .byte $A5,%10100001 + .byte $39,%10000011; + .byte $39,%01100010 + .byte $09,%10100001 + .byte $0B,%00100010 + .byte $0D,%11100011 + .byte $AF,%00101010 + .byte $B7,%01000110 + .byte $BD,%11100011 + .byte $A9,%01000000 + .byte $A7,%10000001; + .byte $A7,%01100000 + .byte $A1,%11000001 + .byte $9F,%11100001 + .byte $9D,%00000010 + .byte $3D,%11000011 + .byte $35,%00100010 + .byte $31,%11100001 + .byte $29,%01000000 + .byte $27,%00100000 + .byte $07,%00000000 + .byte $0D,%11000011 + .byte $0F,%10000101; + .byte $0F,%01100100 + .byte $11,%00000110 + .byte $0F,%00000100 + .byte $11,%10000101; + .byte $11,%01100100 + .byte $B1,%11101001 + .byte $B5,%00001000 + .byte $B9,%00000110 + .byte $BB,%10100101 + .byte $8D,%00000100 + .byte $29,%00100000 + .byte $27,%00000000 + .byte $0F,%11100011 + .byte $11,%11000101 + .byte $17,%10001001; + .byte $17,%01101000 + .byte $BB,%11000101 + .byte $AB,%10000001; + .byte $AB,%01100000 + .byte $A5,%11000001 + .byte $A3,%11100001 + .byte $4D,%11000101 + .byte $3D,%10100011 + .byte $35,%00000010 + .byte $31,%11000001 + .byte $09,%00000000 + .byte $0B,%10100001 + .byte $0D,%00100010 + .byte $13,%00100110 + .byte $15,%11100111 + .byte $0B,%00000000 + .byte $0F,%00100010 + .byte $0F,%10000011; + .byte $0F,%01100010 + .byte $11,%00100100 + .byte $B3,%00100000 + .byte $9D,%01000010 + .byte $2B,%00100000 + .byte $0D,%11000001 + .byte $0F,%01000010 + .byte $11,%00000100 + .byte $13,%11100101 + .byte $BB,%11100101 + .byte $BF,%00100100 + .byte $0D,%10100001 + .byte $15,%01000110 + .byte $17,%00101000 + .byte $0F,%10100001 + .byte $0F,%11100001 + .byte $AD,%00001100 + .byte $B9,%11000111 + .byte $BB,%01000110 + .byte $B1,%10000001; + .byte $B1,%01100000 + .byte $AB,%11000001 + .byte $A3,%00100010 + .byte $A1,%01000010 + .byte $31,%10000001; + .byte $31,%01100000 + .byte $2F,%01000000 + .byte $13,%00100100 + .byte $AF,%10101011 + .byte $B3,%11101001 + .byte $B9,%00000000 + .byte $9B,%10100011 + .byte $41,%11000011 + .byte $11,%01000010 + .byte $11,%10100011 + .byte $13,%00000100 + .byte $13,%01000100 + .byte $15,%11100101 + .byte $49,%00100100 + .byte $13,%10100011 + .byte $19,%11000111 + .byte $B5,%11001001 + .byte $B5,%10101001 + .byte $BB,%10000111; + .byte $BB,%01100110 + .byte $BF,%11000101 + .byte $B5,%10000001; + .byte $B5,%01100000 + .byte $AF,%11000001 + .byte $A9,%00000010 + .byte $A7,%00100010 + .byte $3B,%00100010 + .byte $0F,%00000000 + .byte $13,%10000011; + .byte $13,%01100010 + .byte $17,%00100110 + .byte $B1,%10001011; + .byte $B1,%01101010 + .byte $B7,%01001000 + .byte $BB,%00100000 + .byte $B7,%01000000 + .byte $A3,%01000010 + .byte $A1,%10000011; + .byte $A1,%01100010 + .byte $41,%10100011 + .byte $37,%11100001 + .byte $0F,%00100000 + .byte $11,%11000001 + .byte $13,%11000011 + .byte $17,%00000110 + .byte $19,%00001000 + .byte $1D,%10001011; + .byte $1D,%01101010 + .byte $4B,%01000100 + .byte $3F,%01000010 + .byte $11,%00100000 + .byte $13,%00000010 + .byte $B1,%10101011 + .byte $B9,%00101000 + .byte $BB,%11000111 + .byte $BD,%01000110 + .byte $BF,%11100101 + .byte $B3,%11000001 + .byte $AD,%00000010 + .byte $3B,%00000010 + .byte $11,%00000000 + .byte $13,%11100001 + .byte $15,%11100011 + .byte $B7,%10001001; + .byte $B7,%01101000 + .byte $BF,%00000110 + .byte $B5,%10100001 + .byte $AF,%11100001 + .byte $A9,%00100010 + .byte $A7,%01000010 + .byte $9D,%11000011 + .byte $15,%11000011 + .byte $17,%10100101 + .byte $1B,%00101000 + .byte $1B,%01001000 + .byte $1B,%10001001; + .byte $1B,%01101000 + .byte $13,%00100000 + .byte $15,%00000010 + .byte $17,%11000011 + .byte $B7,%10101001 + .byte $BB,%11100111 + .byte $9B,%00000100 + .byte $37,%10100001 + .byte $17,%00000100 + .byte $AF,%00001100 + .byte $BD,%10000001; + .byte $BD,%01100000 + .byte $B9,%10100001 + .byte $B3,%11100001 + .byte $AD,%00100010 + .byte $A1,%11000011 + .byte $45,%11000011 + .byte $31,%00000000 + .byte $15,%00100010 + .byte $17,%11100011 + .byte $19,%11000101 + .byte $43,%10000011; + .byte $43,%01100010 + .byte $19,%00100100 + .byte $1B,%01000110 + .byte $AF,%01001100 + .byte $BB,%00101000 + .byte $A7,%10100011 + .byte $A5,%11000011 + .byte $39,%10100001 + .byte $37,%10000001; + .byte $37,%01100000 + .byte $17,%00000010 + .byte $17,%01000010 + .byte $19,%00000100 + .byte $1B,%00000110 + .byte $B7,%11100001 + .byte $B1,%00100010 + .byte $15,%00000000 + .byte $15,%01000000 + .byte $17,%00100010 + .byte $19,%01000100 + .byte $39,%10000001; + .byte $39,%01100000 + .byte $19,%00100010 + .byte $B1,%00001100 + .byte $B5,%01001010 + .byte $BF,%11000111 + .byte $AD,%10000011; + .byte $AD,%01100010 + .byte $AB,%10100011 + .byte $9B,%01000100 + .byte $93,%10100101 + .byte $17,%00100000 + .byte $17,%10000001; + .byte $17,%01100000 + .byte $1B,%00100100 + .byte $B5,%10001011; + .byte $B5,%01101010 + .byte $BD,%00001000 + .byte $BB,%11100001 + .byte $B5,%00100010 + .byte $A7,%11000011 + .byte $A5,%11100011 + .byte $17,%01000000 + .byte $19,%10100011 + .byte $39,%01000000 + .byte $19,%01000000 + .byte $19,%10100001 + .byte $1B,%10100011 + .byte $1D,%10000101; + .byte $1D,%01100100 + .byte $B3,%11101011 + .byte $B1,%10000011; + .byte $B1,%01100010 + .byte $01,%00010010 + .byte $41,%00000010 + .byte $19,%10000001; + .byte $19,%01100000 + .byte $1B,%10000011; + .byte $1B,%01100010 + .byte $1D,%11100101 + .byte $AB,%11000011 + .byte $A3,%00000100 + .byte $A1,%00100100 + .byte $97,%10100101 + .byte $05,%11110001 + .byte $49,%11000011 + .byte $35,%00000000 + .byte $1B,%01000010 + .byte $1B,%11000011 + .byte $1D,%10100101 + .byte $1B,%10100001 + .byte $1D,%10100011 + .byte $1D,%00000100 + .byte $1F,%00100110 + .byte $AF,%11001101 + .byte $B5,%10000011; + .byte $B5,%01100010 + .byte $AF,%11000011 + .byte $A7,%00000100 + .byte $A1,%01000100 + .byte $03,%11110001 + .byte $47,%10000011; + .byte $47,%01100010 + .byte $1D,%11100011 + .byte $1F,%00000110 + .byte $B1,%01001100 + .byte $B7,%01001010 + .byte $B9,%00001010 + .byte $39,%00100000 + .byte $1B,%11000001 + .byte $1D,%11000011 + .byte $1D,%00000010 + .byte $1F,%00100100 + .byte $B9,%00101010 + .byte $BB,%11101001 + .byte $BF,%01001000 + .byte $B9,%10000011; + .byte $B9,%01100010 + .byte $B3,%11000011 + .byte $AB,%00000100 + .byte $45,%00100010 + .byte $3F,%10100001 + .byte $1D,%10100001 + .byte $1D,%11100001 + .byte $1D,%00100010 + .byte $1F,%00000100 + .byte $B1,%10001101; + .byte $B1,%01101100 + .byte $B5,%11101011 + .byte $B9,%01001010 + .byte $BD,%10101001 + .byte $AF,%11100011 + .byte $A7,%00100100 + .byte $A1,%10000101; + .byte $A1,%01100100 + .byte $01,%11110001 + .byte $3B,%00100000 + .byte $39,%00000000 + .byte $1D,%11000001 + .byte $1F,%11100011 + .byte $1F,%11000001 + .byte $1F,%00000010 + .byte $21,%11000101 + .byte $BB,%00101010 + .byte $BD,%10000011; + .byte $BD,%01100010 + .byte $B7,%11000011 + .byte $A7,%01000100 + .byte $A5,%10000101; + .byte $A5,%01100100 + .byte $99,%11100101 + .byte $07,%10110001 + .byte $4B,%10100011 + .byte $3F,%10000001; + .byte $3F,%01100000 + .byte $1F,%11100001 + .byte $1F,%01000010 + .byte $21,%10100101 + .byte $23,%11000111 + .byte $BD,%11001001 + .byte $B3,%11100011 + .byte $AB,%00100100 + .byte $03,%11010001 + .byte $4D,%11000011 + .byte $1F,%00100010 + .byte $1F,%10000011; + .byte $1F,%01100010 + .byte $3F,%01000000 + .byte $21,%10000011; + .byte $21,%01100010 + .byte $AF,%00001110 + .byte $B3,%10001101; + .byte $B3,%01101100 + .byte $B7,%11101011 + .byte $BF,%11001001 + .byte $BB,%11000011 + .byte $AF,%00100100 + .byte $47,%00000010 + .byte $1F,%00000000 + .byte $21,%01000010 + .byte $21,%11000011 + .byte $B1,%11001101 + .byte $BD,%00001010 + .byte $A7,%10000101; + .byte $A7,%01100100 + .byte $A5,%10100101 + .byte $05,%10110001 + .byte $01,%11010001 + .byte $21,%00100010 + .byte $21,%10100011 + .byte $25,%10101001 + .byte $41,%01000000 + .byte $21,%00100000 + .byte $23,%10000011; + .byte $23,%01100010 + .byte $23,%11100011 + .byte $BF,%11101001 + .byte $BF,%11000011 + .byte $BB,%11100011 + .byte $B3,%00100100 + .byte $AB,%10000101; + .byte $AB,%01100100 + .byte $23,%11000011 + .byte $23,%01000100 + .byte $B3,%10101101 + .byte $B7,%00000100 + .byte $AF,%01000100 + .byte $A3,%11000101 + .byte $3D,%00000000 + .byte $23,%10100011 + .byte $23,%00000100 + .byte $25,%00000100 + .byte $B3,%01000100 + .byte $A7,%11000101 + .byte $01,%10110001 + .byte $4F,%10100011 + .byte $45,%10100001 + .byte $23,%11000001 + .byte $25,%11100011 + .byte $25,%01000100 + .byte $B3,%11001101 + .byte $B5,%10001101; + .byte $B5,%01101100 + .byte $B9,%11101011 + .byte $BB,%00000100 + .byte $AB,%10100101 + .byte $57,%10000101; + .byte $57,%01100100 + .byte $47,%11100001 + .byte $41,%00100000 + .byte $3F,%00000000 + .byte $23,%00000000 + .byte $23,%01000000 + .byte $23,%10100001 + .byte $25,%00100100 + .byte $25,%11100001 + .byte $25,%00100010 + .byte $B7,%01000100 + .byte $AF,%10100101 + .byte $03,%10010001; + .byte $03,%01110000 + .byte $45,%10000001; + .byte $45,%01100000 + .byte $25,%10000001; + .byte $25,%01100000 + .byte $25,%11000001 + .byte $B5,%10101101 + .byte $BB,%11001011 + .byte $B3,%10000101; + .byte $B3,%01100100 + .byte $A7,%11100101 + .byte $4D,%01000010 + .byte $41,%00000000 + .byte $25,%00000000 + .byte $25,%01000000 + .byte $25,%10100001 + .byte $25,%01000010 + .byte $4B,%00000010 + .byte $27,%10100001 + .byte $27,%11100001 + .byte $27,%10100011 + .byte $B7,%10001101; + .byte $B7,%01101100 + .byte $BB,%11101011 + .byte $AB,%11100101 + .byte $45,%01000000 + .byte $27,%10000001; + .byte $27,%01100000 + .byte $27,%11000001 + .byte $27,%00100010 + .byte $27,%10000011; + .byte $27,%01100010 + .byte $27,%11100011 + .byte $B9,%00101100 + .byte $BD,%01000100 + .byte $AF,%11000101 + .byte $01,%10010001; + .byte $01,%01110000 + .byte $49,%11000001 + .byte $27,%00000010 + .byte $27,%01000010 + .byte $27,%11000011 + .byte $45,%00100000 + .byte $29,%01000010 + .byte $29,%11000011 + .byte $29,%00000110 + .byte $B7,%10101101 + .byte $B9,%01001100 + .byte $BB,%00001100 + .byte $B9,%10100101 + .byte $B3,%11000101 + .byte $A5,%00100110 + .byte $29,%10100011 + .byte $BD,%10000101; + .byte $BD,%01100100 + .byte $B5,%11000101 + .byte $AB,%00000110 + .byte $03,%01010000 + .byte $49,%10100001 + .byte $29,%10000011; + .byte $29,%01100010 + .byte $29,%11100011 + .byte $53,%10100011 + .byte $4F,%00100010 + .byte $47,%00100000 + .byte $AD,%11101111 + .byte $B3,%00101110 + .byte $B9,%11000101 + .byte $AF,%00000110 + .byte $B1,%10001111; + .byte $B1,%01101110 + .byte $B5,%11101101 + .byte $BD,%11101011 + .byte $BF,%11001011 + .byte $B3,%11100101 + .byte $A9,%00100110 + .byte $01,%01010000 + .byte $5B,%10000101; + .byte $5B,%01100100 + .byte $4D,%11100001 + .byte $49,%10000001; + .byte $49,%01100000 + .byte $2B,%10000111; + .byte $2B,%01100110 + .byte $2B,%11000111 + .byte $2B,%00000000 + .byte $2B,%01000000 + .byte $2B,%00000010 + .byte $BD,%11000101 + .byte $AB,%01000110 + .byte $0D,%11101111 + .byte $2B,%11100001 + .byte $BB,%01001100 + .byte $BF,%11101011 + .byte $B9,%11100101 + .byte $AF,%00100110 + .byte $03,%00110000 + .byte $2B,%10000001; + .byte $2B,%01100000 + .byte $2B,%11000001 + .byte $2D,%00000000 + .byte $2D,%01000000 + .byte $2D,%00000010 + .byte $2D,%10000011; + .byte $2D,%01100010 + .byte $2D,%11100011 + .byte $2D,%10000101; + .byte $2D,%01100100 + .byte $B7,%11101101 + .byte $B3,%00100110 + .byte $A5,%10100111 + .byte $01,%00110000 + .byte $53,%01000010 + .byte $49,%00100000 + .byte $2D,%10100001 + .byte $2D,%11100001 + .byte $2D,%01000010 + .byte $2D,%11000011 + .byte $2D,%00100100 + .byte $AB,%01010000 + .byte $BB,%10001101; + .byte $BB,%01101100 + .byte $BD,%11100101 + .byte $AF,%01000110 + .byte $9F,%11000111 + .byte $2D,%10000001; + .byte $2D,%01100000 + .byte $2D,%11000001 + .byte $2D,%00100010 + .byte $2D,%10100011 + .byte $2D,%11000101 + .byte $2D,%11100101 + .byte $2F,%00000000 + .byte $2F,%00000010 + .byte $B9,%11101101 + .byte $B9,%00100110 + .byte $B3,%01000110 + .byte $0D,%11001111 + .byte $4F,%11000001 + .byte $2F,%10100001 + .byte $2F,%11100001 + .byte $B1,%11001111 + .byte $BD,%00000110 + .byte $AD,%10000111; + .byte $AD,%01100110 + .byte $03,%00010000 + .byte $55,%10000011; + .byte $55,%01100010 + .byte $4D,%10000001; + .byte $4D,%01100000 + .byte $2F,%00100000 + .byte $2F,%10000001; + .byte $2F,%01100000 + .byte $2F,%11000001 + .byte $4B,%00000000 + .byte $BF,%00100110 + .byte $B9,%01000110 + .byte $AD,%10100111 + .byte $B3,%10000111; + .byte $B3,%01100110 + .byte $05,%11101111 + .byte $4F,%10000001; + .byte $4F,%01100000 + .byte $B7,%10000111; + .byte $B7,%01100110 + .byte $AD,%11000111 + .byte $AB,%11000111 + .byte $1B,%01001110 + .byte $03,%11101111 + .byte $51,%10100001 + .byte $31,%01000010 + .byte $31,%11100011 + .byte $31,%10000101; + .byte $31,%01100100 + .byte $31,%10100101 + .byte $31,%11000101 + .byte $B7,%01001110 + .byte $B9,%00001110 + .byte $B9,%10000111; + .byte $B9,%01100110 + .byte $B1,%10100111 + .byte $0F,%10101111 + .byte $61,%11000101 + .byte $55,%00100010 + .byte $53,%11100001 + .byte $4F,%01000000 + .byte $4D,%00100000 + .byte $31,%00100010 + .byte $31,%10100011 + .byte $31,%11000011 + .byte $57,%01000010 + .byte $33,%11000001 + .byte $33,%00100010 + .byte $33,%10100011 + .byte $AD,%10010001; + .byte $AD,%01110000 + .byte $BD,%10000111; + .byte $BD,%01100110 + .byte $B3,%11000111 + .byte $13,%10001111; + .byte $13,%01101110 + .byte $33,%01000000 + .byte $33,%10100001 + .byte $33,%00000010 + .byte $33,%10000011; + .byte $33,%01100010 + .byte $33,%11100011 + .byte $B5,%10101111 + .byte $BF,%10000111; + .byte $BF,%01100110 + .byte $B9,%10100111 + .byte $B7,%10100111 + .byte $AD,%11100111 + .byte $AB,%11100111 + .byte $17,%01001110 + .byte $0D,%10101111 + .byte $33,%10000001; + .byte $33,%01100000 + .byte $33,%11100001 + .byte $33,%01000010 + .byte $33,%11000011 + .byte $35,%10000001; + .byte $35,%01100000 + .byte $35,%11000001 + .byte $B3,%11101111 + .byte $BB,%00001110 + .byte $B1,%11100111 + .byte $03,%11001111 + .byte $01,%11001111 + .byte $5D,%11100011 + .byte $53,%10100001 + .byte $4F,%00000000 + .byte $35,%01000000 + .byte $35,%10100001 + .byte $33,%10100101 + .byte $BD,%10100111 + .byte $B7,%11000111 + .byte $AB,%00001000 + .byte $35,%00100000 + .byte $35,%11100001 + .byte $33,%10000101; + .byte $33,%01100100 + .byte $55,%11000001 + .byte $51,%00100000 + .byte $35,%10100011 + .byte $BD,%00001110 + .byte $B9,%11100111 + .byte $B1,%00001000 + .byte $AF,%00001000 + .byte $05,%10101111 + .byte $5F,%00000100 + .byte $5B,%10000011; + .byte $5B,%01100010 + .byte $57,%00000010 + .byte $37,%00000000 + .byte $37,%01000000 + .byte $35,%11100011 + .byte $35,%00000100 + .byte $BD,%11000111 + .byte $21,%00001110 + .byte $1B,%00101110 + .byte $37,%00100000 + .byte $35,%11000011 + .byte $35,%10000101; + .byte $35,%01100100 + .byte $37,%00100010 + .byte $37,%10100011 + .byte $AF,%10010001; + .byte $AF,%01110000 + .byte $BD,%00101110 + .byte $BF,%11100111 + .byte $B7,%00001000 + .byte $37,%00000010 + .byte $37,%10000011; + .byte $37,%01100010 + .byte $35,%00000110 + .byte $AB,%11110001 + .byte $B7,%11001111 + .byte $B9,%10001111; + .byte $B9,%01101110 + .byte $B1,%00101000 + .byte $AF,%00101000 + .byte $01,%10101111 + .byte $5D,%10100011 + .byte $37,%01000010 + .byte $37,%11000011 + .byte $37,%11100011 + .byte $57,%10100001 + .byte $39,%11000001 + .byte $39,%00100010 + .byte $37,%01000100 + .byte $AD,%11010001 + .byte $B3,%00110000 + .byte $BF,%00001000 + .byte $B7,%00101000 + .byte $B5,%00101000 + .byte $07,%10001111; + .byte $07,%01101110 + .byte $59,%11100001 + .byte $55,%01000000 + .byte $39,%00000010 + .byte $B5,%00010000 + .byte $BB,%10001111; + .byte $BB,%01101110 + .byte $BB,%00001000 + .byte $AF,%01001000 + .byte $AD,%01001000 + .byte $5B,%00100010 + .byte $53,%00000000 + .byte $39,%11100001 + .byte $39,%01000010 + .byte $37,%10000101; + .byte $37,%01100100 + .byte $37,%10100101 + .byte $5D,%01000010 + .byte $3B,%10000001; + .byte $3B,%01100000 + .byte $3B,%11000001 + .byte $39,%11000011 + .byte $39,%10000101; + .byte $39,%01100100 + .byte $BD,%00101000 + .byte $B5,%01001000 + .byte $B3,%01001000 + .byte $0B,%01001110 + .byte $07,%01001110 + .byte $5F,%11000011 + .byte $3B,%01000000 + .byte $AF,%10110001 + .byte $B1,%10010001; + .byte $B1,%01110000 + .byte $BF,%00101110 + .byte $BF,%00101000 + .byte $01,%10001111; + .byte $01,%01101110 + .byte $57,%10000001; + .byte $57,%01100000 + .byte $3B,%11100001 + .byte $39,%11100011 + .byte $37,%10100111 + .byte $3D,%10000001; + .byte $3D,%01100000 + .byte $3B,%11000011 + .byte $BB,%10101111 + .byte $BD,%01001000 + .byte $BB,%01001000 + .byte $AD,%10101001 + .byte $0F,%00101110 + .byte $59,%10100001 + .byte $3D,%01000000 + .byte $3D,%10100001 + .byte $3B,%10000011; + .byte $3B,%01100010 + .byte $3B,%10100011 + .byte $B3,%01010000 + .byte $B5,%10001001; + .byte $B5,%01101000 + .byte $B3,%10001001; + .byte $B3,%01101000 + .byte $3D,%00100000 + .byte $3B,%01000010 + .byte $3B,%11100011 + .byte $39,%11000101 + .byte $39,%00000110 + .byte $5D,%00000010 + .byte $3D,%00100010 + .byte $3B,%10000101; + .byte $3B,%01100100 + .byte $3B,%10100101 + .byte $B7,%00010000 + .byte $BD,%10101111 + .byte $BB,%10001001; + .byte $BB,%01101000 + .byte $3D,%00000010 + .byte $3D,%10000011; + .byte $3D,%01100010 + .byte $B9,%11101111 + .byte $BD,%10001001; + .byte $BD,%01101000 + .byte $B3,%10101001 + .byte $B1,%10101001 + .byte $A9,%11001001 + .byte $3F,%00100000 + .byte $3D,%01000010 + .byte $3F,%11000001 + .byte $3F,%00100010 + .byte $B7,%00110000 + .byte $B9,%10101001 + .byte $5B,%10000001; + .byte $5B,%01100000 + .byte $3F,%00000010 + .byte $AD,%00010010 + .byte $B9,%00010000 + .byte $BB,%10101001 + .byte $B1,%11001001 + .byte $AF,%11001001 + .byte $6B,%00100110 + .byte $67,%10000101; + .byte $67,%01100100 + .byte $59,%00100000 + .byte $3F,%11100001 + .byte $3D,%11100011 + .byte $3D,%00000100 + .byte $41,%11000001 + .byte $3F,%11000011 + .byte $3D,%11000101 + .byte $B7,%11001001 + .byte $A3,%00001010 + .byte $09,%00001110 + .byte $01,%00101110 + .byte $41,%10100001 + .byte $3F,%10000011; + .byte $3F,%01100010 + .byte $3F,%10100011 + .byte $A5,%11010011 + .byte $B3,%10110001 + .byte $B5,%10010001; + .byte $B5,%01110000 + .byte $BD,%11001111 + .byte $BB,%11001001 + .byte $B9,%11001001 + .byte $AF,%11101001 + .byte $15,%11101101 + .byte $0B,%00001110 + .byte $41,%10000001; + .byte $41,%01100000 + .byte $41,%11100001 + .byte $3F,%11100011 + .byte $61,%00100010 + .byte $41,%00100010 + .byte $3D,%00100110 + .byte $BB,%00010000 + .byte $B5,%11101001 + .byte $AF,%00001010 + .byte $69,%10100101 + .byte $43,%10100001 + .byte $41,%10000011; + .byte $41,%01100010 + .byte $3F,%01000100 + .byte $3B,%00001000 + .byte $B9,%11101001 + .byte $B7,%11101001 + .byte $11,%11101101 + .byte $07,%00001110 + .byte $03,%00001110 + .byte $5B,%00000000 + .byte $43,%00100000 + .byte $43,%10000001; + .byte $43,%01100000 + .byte $41,%01000010 + .byte $45,%00000000 + .byte $43,%00100010 + .byte $BB,%00110000 + .byte $B3,%00001010 + .byte $63,%01000010 + .byte $5F,%10100001 + .byte $43,%00000010 + .byte $41,%00100100 + .byte $B9,%01010000 + .byte $B7,%00001010 + .byte $B5,%00001010 + .byte $A7,%00101010 + .byte $0D,%11101101 + .byte $61,%11100001 + .byte $43,%11100001 + .byte $43,%01000010 + .byte $41,%11100011 + .byte $41,%00000100 + .byte $67,%11100011 + .byte $5D,%00000000 + .byte $47,%00000000 + .byte $45,%11000001 + .byte $43,%10100011 + .byte $43,%11000011 + .byte $B7,%10110001 + .byte $BF,%11101111 + .byte $01,%11101101 + .byte $45,%00000010 + .byte $AB,%10010011; + .byte $AB,%01110010 + .byte $AF,%00110010 + .byte $BF,%00001010 + .byte $B5,%00101010 + .byte $B3,%00101010 + .byte $B1,%00101010 + .byte $11,%11001101 + .byte $07,%11101101 + .byte $5F,%01000000 + .byte $45,%11100001 + .byte $43,%11100011 + .byte $49,%00000000 + .byte $47,%11000001 + .byte $45,%10100011 + .byte $41,%00000110 + .byte $BD,%00101010 + .byte $69,%00000100 + .byte $47,%10100001 + .byte $45,%10000011; + .byte $45,%01100010 + .byte $43,%00100100 + .byte $BF,%00101010 + .byte $B3,%01001010 + .byte $B1,%01001010 + .byte $AF,%01001010 + .byte $1D,%10101101 + .byte $0F,%11001101 + .byte $0B,%11001101 + .byte $09,%11001101 + .byte $61,%10100001 + .byte $47,%10000001; + .byte $47,%01100000 + .byte $45,%01000010 + .byte $43,%00000100 + .byte $49,%01000000 + .byte $BB,%01001010 + .byte $67,%10000011; + .byte $67,%01100010 + .byte $45,%00000100 + .byte $B1,%00110010 + .byte $B3,%00010010 + .byte $BF,%01001010 + .byte $BD,%01001010 + .byte $AF,%10001011; + .byte $AF,%01101010 + .byte $13,%10101101 + .byte $11,%10101101 + .byte $65,%00000010 + .byte $47,%00100010 + .byte $47,%01000010 + .byte $45,%11100011 + .byte $6B,%00100100 + .byte $67,%00100010 + .byte $4B,%01000000 + .byte $49,%00000010 + .byte $47,%10100011 + .byte $45,%10100101 + .byte $B9,%10001011; + .byte $B9,%01101010 + .byte $B7,%10001011; + .byte $B7,%01101010 + .byte $4B,%00100000 + .byte $4B,%10000001; + .byte $4B,%01100000 + .byte $49,%11100001 + .byte $BD,%10001011; + .byte $BD,%01101010 + .byte $BB,%10001011; + .byte $BB,%01101010 + .byte $0D,%10101101 + .byte $0B,%10101101 + .byte $6F,%00000110 + .byte $69,%10100011 + .byte $63,%10000001; + .byte $63,%01100000 + .byte $49,%00100010 + .byte $47,%11000011 + .byte $47,%11100011 + .byte $49,%10100011 + .byte $B9,%10101011 + .byte $B7,%10101011 + .byte $B5,%10101011 + .byte $B3,%10101011 + .byte $1B,%10001101; + .byte $1B,%01101100 + .byte $17,%10001101; + .byte $17,%01101100 + .byte $63,%00100000 + .byte $4B,%11100001 + .byte $49,%10000011; + .byte $49,%01100010 + .byte $47,%00000100 + .byte $47,%00100100 + .byte $BF,%01010000 + .byte $BD,%10101011 + .byte $BB,%10101011 + .byte $65,%11000001 + .byte $4D,%00000000 + .byte $4D,%01000000 + .byte $4B,%11000001 + .byte $67,%11100001 + .byte $4F,%00100000 + .byte $4D,%10100001 + .byte $4B,%10000011; + .byte $4B,%01100010 + .byte $47,%10000101; + .byte $47,%01100100 + .byte $B7,%11001011 + .byte $B5,%11001011 + .byte $B3,%11001011 + .byte $B1,%11001011 + .byte $AF,%11001011 + .byte $13,%10001101; + .byte $13,%01101100 + .byte $03,%10001101; + .byte $03,%01101100 + .byte $6B,%11000011 + .byte $65,%10000001; + .byte $65,%01100000 + .byte $4B,%01000010 + .byte $49,%11100011 + .byte $49,%00000100 + .byte $BF,%10010001; + .byte $BF,%01110000 + .byte $B9,%11001011 + .byte $AB,%11001011 + .byte $0F,%10001101; + .byte $0F,%01101100 + .byte $0D,%10001101; + .byte $0D,%01101100 + .byte $09,%10001101; + .byte $09,%01101100 + .byte $05,%10001101; + .byte $05,%01101100 + .byte $01,%10010011; + .byte $01,%01110010 + .byte $4D,%11000001 + .byte $4B,%00100010 + .byte $49,%01000100 + .byte $B1,%11101011 + .byte $AF,%11101011 + .byte $01,%01010010 + .byte $51,%00000000 + .byte $4D,%00100010 + .byte $4B,%11100011 + .byte $AD,%11010011 + .byte $AF,%10110011 + .byte $B7,%00010010 + .byte $6D,%11100011 + .byte $67,%10100001 + .byte $65,%00100000 + .byte $4F,%10100001 + .byte $4D,%00000010 + .byte $4B,%11000011 + .byte $47,%11100101 + .byte $51,%10000001; + .byte $51,%01100000 + .byte $4F,%11100001 + .byte $4D,%10000011; + .byte $4D,%01100010 + .byte $4B,%00100100 + .byte $1B,%01001100 + .byte $13,%01001100 + .byte $01,%01001100 + .byte $6F,%00100100 + .byte $6B,%01000010 + .byte $67,%01000000 + .byte $51,%01000000 + .byte $4B,%00000100 + .byte $B9,%00010010 + .byte $BD,%11010001 + .byte $0B,%01001100 + .byte $07,%01001100 + .byte $05,%01001100 + .byte $01,%00110010 + .byte $69,%11100001 + .byte $4F,%00000010 + .byte $4D,%10100011 + .byte $6D,%10000011; + .byte $6D,%01100010 + .byte $6B,%11100001 + .byte $51,%11100001 + .byte $4F,%01000010 + .byte $4D,%00000100 + .byte $B1,%10110011 + .byte $BB,%00010010 + .byte $BF,%00001100 + .byte $BD,%00001100 + .byte $6B,%00000010 + .byte $69,%10100001 + .byte $53,%01000000 + .byte $51,%11000001 + .byte $4D,%11100011 + .byte $BD,%11110001 + .byte $B9,%00001100 + .byte $B7,%00001100 + .byte $B5,%00001100 + .byte $B3,%00001100 + .byte $03,%00110010 + .byte $75,%10100111 + .byte $6F,%00000100 + .byte $67,%00000000 + .byte $53,%00100000 + .byte $4F,%10000011; + .byte $4F,%01100010 + .byte $53,%11000001 + .byte $51,%01000010 + .byte $4F,%11100011 + .byte $4D,%00100100 + .byte $BF,%00101100 + .byte $BD,%00101100 + .byte $15,%00101100 + .byte $03,%00010010 + .byte $6B,%10100001 + .byte $51,%00100010 + .byte $4F,%11000011 + .byte $B7,%00101100 + .byte $B5,%00101100 + .byte $B3,%00101100 + .byte $B1,%00101100 + .byte $AF,%00101100 + .byte $2D,%00101100 + .byte $1D,%00101100 + .byte $0D,%00101100 + .byte $09,%00101100 + .byte $55,%00100000 + .byte $4D,%01000100 + .byte $4B,%11000101 + .byte $6B,%01000000 + .byte $57,%00000000 + .byte $53,%00100010 + .byte $51,%11000011 + .byte $B9,%01010010 + .byte $BF,%01001100 + .byte $BD,%01001100 + .byte $57,%00100000 + .byte $55,%10100001 + .byte $53,%00000010 + .byte $51,%10100011 + .byte $BB,%00110010 + .byte $B7,%01001100 + .byte $B5,%01001100 + .byte $B3,%01001100 + .byte $73,%10100101 + .byte $6F,%10000011; + .byte $6F,%01100010 + .byte $6D,%00000010 + .byte $51,%10000011; + .byte $51,%01100010 + .byte $4F,%00000100 + .byte $4F,%00100100 + .byte $BF,%00010010 + .byte $11,%00001100 + .byte $71,%11000011 + .byte $6B,%00000000 + .byte $55,%11100001 + .byte $55,%00000010 + .byte $53,%10000011; + .byte $53,%01100010 + .byte $B5,%10110011 + .byte $B7,%10010011; + .byte $B7,%01110010 + .byte $0F,%00001100 + .byte $0B,%00001100 + .byte $75,%11100101 + .byte $73,%10000101; + .byte $73,%01100100 + .byte $73,%01000100 + .byte $59,%00000000 + .byte $51,%11100011 + .byte $51,%00000100 + .byte $4F,%01000100 + .byte $B1,%11110011 + .byte $B7,%10110011 + .byte $AF,%10001101; + .byte $AF,%01101100 + .byte $AD,%10001101; + .byte $AD,%01101100 + .byte $01,%11101011 + .byte $75,%11000101 + .byte $71,%10100011 + .byte $59,%10000001; + .byte $59,%01100000 + .byte $57,%11100001 + .byte $55,%01000010 + .byte $51,%01000100 + .byte $BD,%00110010 + .byte $23,%00001100 + .byte $1D,%00001100 + .byte $59,%01000000 + .byte $57,%11000001 + .byte $53,%11000011 + .byte $53,%11100011 + .byte $51,%00100100 + .byte $73,%11000011 + .byte $6F,%11000001 + .byte $6F,%10000001; + .byte $6F,%01100000 + .byte $55,%10100011 + .byte $BB,%10101101 + .byte $B9,%10101101 + .byte $B1,%10101101 + .byte $AF,%10101101 + .byte $13,%11101011 + .byte $11,%11101011 + .byte $0D,%11101011 + .byte $03,%10110001 + .byte $71,%01000010 + .byte $59,%11000001 + .byte $53,%00000100 + .byte $53,%00100100 + .byte $51,%10000101; + .byte $51,%01100100 + .byte $BF,%00110010 + .byte $05,%11010001 + .byte $79,%11100111 + .byte $75,%10100101 + .byte $71,%00100010 + .byte $5B,%01000000 + .byte $57,%00100010 + .byte $55,%11000011 + .byte $57,%10000011; + .byte $57,%01100010 + .byte $BD,%11001101 + .byte $BB,%11001101 + .byte $B9,%11001101 + .byte $B7,%11001101 + .byte $B5,%11001101 + .byte $1B,%11101011 + .byte $03,%11001011 + .byte $71,%11100001 + .byte $5D,%01000000 + .byte $5B,%11000001 + .byte $59,%00100010 + .byte $55,%11100011 + .byte $55,%00000100 + .byte $53,%01000100 + .byte $53,%10000101; + .byte $53,%01100100 + .byte $51,%11100101 + .byte $B9,%10110011 + .byte $BF,%11001101 + .byte $1F,%11101011 + .byte $15,%11101011 + .byte $07,%11001011 + .byte $05,%11001011 + .byte $07,%11010001 + .byte $5D,%00100000 + .byte $5B,%10100001 + .byte $59,%00000010 + .byte $57,%10100011 + .byte $5D,%10000001; + .byte $5D,%01100000 + .byte $5B,%11100001 + .byte $59,%01000010 + .byte $55,%00100100 + .byte $55,%01000100 + .byte $BD,%11101101 + .byte $BB,%11101101 + .byte $23,%11101011 + .byte $13,%11001011 + .byte $0F,%11001011 + .byte $73,%00100010 + .byte $5D,%10100001 + .byte $57,%11000011 + .byte $57,%11100011 + .byte $51,%00100110 + .byte $BF,%11101101 + .byte $05,%10010001; + .byte $05,%01110000 + .byte $75,%11100011 + .byte $71,%10000001; + .byte $71,%01100000 + .byte $5F,%00100000 + .byte $5B,%00000010 + .byte $59,%10000011; + .byte $59,%01100010 + .byte $73,%11100001 + .byte $71,%00100000 + .byte $57,%00000100 + .byte $BB,%10110011 + .byte $B3,%11101101 + .byte $B1,%11101101 + .byte $AF,%11101101 + .byte $1B,%11001011 + .byte $05,%01010000 + .byte $75,%10000011; + .byte $75,%01100010 + .byte $61,%00100000 + .byte $59,%10100011 + .byte $59,%11000011 + .byte $BF,%00001110 + .byte $19,%11001011 + .byte $09,%10101011 + .byte $07,%10101011 + .byte $01,%00010000 + .byte $07,%10010001; + .byte $07,%01110000 + .byte $61,%00000000 + .byte $5F,%10000001; + .byte $5F,%01100000 + .byte $5D,%11100001 + .byte $5B,%01000010 + .byte $57,%00100100 + .byte $55,%10000101; + .byte $55,%01100100 + .byte $55,%10100101 + .byte $77,%00100100 + .byte $61,%01000000 + .byte $59,%11100011 + .byte $BB,%11010011 + .byte $B7,%00001110 + .byte $B5,%00001110 + .byte $B3,%00001110 + .byte $B1,%00001110 + .byte $0F,%10101011 + .byte $01,%10001011; + .byte $01,%01101010 + .byte $01,%11101111 + .byte $07,%01010000 + .byte $61,%10000001; + .byte $61,%01100000 + .byte $5F,%11100001 + .byte $5B,%10100011 + .byte $1F,%11001011 + .byte $03,%10001011; + .byte $03,%01101010 + .byte $05,%00110000 + .byte $09,%10010001; + .byte $09,%01110000 + .byte $77,%00000100 + .byte $63,%00000000 + .byte $5F,%11000001 + .byte $5D,%00100010 + .byte $59,%00000100 + .byte $57,%01000100 + .byte $77,%10000011; + .byte $77,%01100010 + .byte $5F,%00000010 + .byte $5B,%11000011 + .byte $B9,%11110011 + .byte $BB,%00101110 + .byte $B9,%00101110 + .byte $B7,%00101110 + .byte $B5,%00101110 + .byte $05,%00010000 + .byte $09,%01010000 + .byte $79,%01000100 + .byte $65,%00000000 + .byte $5D,%10000011; + .byte $5D,%01100010 + .byte $59,%01000100 + .byte $BD,%11010011 + .byte $AB,%00001110 + .byte $0B,%10001011; + .byte $0B,%01101010 + .byte $09,%10001011; + .byte $09,%01101010 + .byte $07,%00110000 + .byte $7D,%00101000 + .byte $75,%11100001 + .byte $75,%10100001 + .byte $63,%01000000 + .byte $61,%11000001 + .byte $5F,%00100010 + .byte $5B,%11100011 + .byte $59,%00100100 + .byte $57,%10100101 + .byte $5F,%10000011; + .byte $5F,%01100010 + .byte $BD,%01001110 + .byte $BB,%01001110 + .byte $B9,%01001110 + .byte $B1,%00101110 + .byte $11,%10001011; + .byte $11,%01101010 + .byte $03,%01001010 + .byte $01,%01001010 + .byte $07,%00010000 + .byte $77,%00000010 + .byte $65,%01000000 + .byte $5F,%01000010 + .byte $5B,%00000100 + .byte $5B,%00100100 + .byte $59,%10000101; + .byte $59,%01100100 + .byte $BF,%01001110 + .byte $AF,%00101110 + .byte $05,%01001010 + .byte $09,%00110000 + .byte $0B,%01010000 + .byte $79,%00100100 + .byte $75,%00100000 + .byte $63,%10100001 + .byte $61,%00000010 + .byte $5D,%11000011 + .byte $79,%10100011 + .byte $61,%01000010 + .byte $5B,%01000100 + .byte $BD,%10001111; + .byte $BD,%01101110 + .byte $B5,%01001110 + .byte $B3,%01001110 + .byte $B1,%01001110 + .byte $AF,%01001110 + .byte $01,%01001110 + .byte $05,%11001111 + .byte $09,%00010000 + .byte $0B,%00110000 + .byte $7B,%10000101; + .byte $7B,%01100100 + .byte $77,%10100001 + .byte $65,%10100001 + .byte $63,%00000010 + .byte $5D,%00000100 + .byte $59,%10100101 + .byte $59,%11000101 + .byte $BF,%10001111; + .byte $BF,%01101110 + .byte $17,%10001011; + .byte $17,%01101010 + .byte $15,%10001011; + .byte $15,%01101010 + .byte $0D,%01001010 + .byte $0B,%01001010 + .byte $01,%00101010 + .byte $07,%11101111 + .byte $67,%00100000 + .byte $63,%11100001 + .byte $5F,%10100011 + .byte $7B,%00000100 + .byte $79,%00000010 + .byte $63,%00100010 + .byte $5F,%11100011 + .byte $BF,%11110011 + .byte $B7,%10001111; + .byte $B7,%01101110 + .byte $B5,%10001111; + .byte $B5,%01101110 + .byte $B3,%10001111; + .byte $B3,%01101110 + .byte $1B,%10001011; + .byte $1B,%01101010 + .byte $19,%10001011; + .byte $19,%01101010 + .byte $0F,%01001010 + .byte $07,%11001111 + .byte $0D,%00110000 + .byte $7D,%10000111; + .byte $7D,%01100110 + .byte $7D,%01000110 + .byte $7D,%00100110 + .byte $7B,%00100100 + .byte $77,%00100000 + .byte $69,%00100000 + .byte $61,%10100011 + .byte $BF,%10101111 + .byte $13,%01001010 + .byte $07,%00101010 + .byte $09,%11101111 + .byte $0B,%00010000 + .byte $7B,%01000100 + .byte $77,%00000000 + .byte $67,%10000001; + .byte $67,%01100000 + .byte $65,%11100001 + .byte $61,%10000011; + .byte $61,%01100010 + .byte $5D,%00100100 + .byte $5D,%01000100 + .byte $5B,%10100101 + .byte $7F,%00101000 + .byte $7B,%11000011 + .byte $79,%10100001 + .byte $79,%01000000 + .byte $6B,%00100000 + .byte $61,%11000011 + .byte $B9,%10101111 + .byte $B7,%10101111 + .byte $01,%00001010 + .byte $05,%10001111; + .byte $05,%01101110 + .byte $0B,%11101111 + .byte $7D,%10100101 + .byte $7B,%10000011; + .byte $7B,%01100010 + .byte $69,%10000001; + .byte $69,%01100000 + .byte $63,%10000011; + .byte $63,%01100010 + .byte $AF,%10001111; + .byte $AF,%01101110 + .byte $1F,%10001011; + .byte $1F,%01101010 + .byte $0D,%00101010 + .byte $01,%00001110 + .byte $03,%00101110 + .byte $07,%10101111 + .byte $09,%11001111 + .byte $0D,%00010000 + .byte $7B,%10100011 + .byte $67,%11000001 + .byte $65,%00100010 + .byte $61,%11100011 + .byte $5F,%00100100 + .byte $5D,%10000101; + .byte $5D,%01100100 + .byte $5B,%11000101 + .byte $7D,%00100100 + .byte $7B,%00100010 + .byte $6B,%10000001; + .byte $6B,%01100000 + .byte $65,%10000011; + .byte $65,%01100010 + .byte $63,%10100011 + .byte $BB,%11001111 + .byte $B9,%11001111 + .byte $B3,%10101111 + .byte $B1,%10101111 + .byte $25,%10001011; + .byte $25,%01101010 + .byte $11,%00101010 + .byte $05,%00101110 + .byte $7D,%10000101; + .byte $7D,%01100100 + .byte $79,%00000000 + .byte $6D,%00000000 + .byte $69,%11000001 + .byte $65,%01000010 + .byte $61,%00000100 + .byte $5F,%01000100 + .byte $5D,%10100101 + .byte $5D,%11000101 + .byte $AF,%10101111 + .byte $09,%10101111 + .byte $0B,%11001111 + .byte $7B,%11000001 + .byte $6D,%00100000 + .byte $67,%00000010 + .byte $63,%11000011 + .byte $7B,%00100000 + .byte $6F,%00000000 + .byte $6B,%11000001 + .byte $67,%01000010 + .byte $63,%00000100 + .byte $61,%01000100 + .byte $BD,%11101111 + .byte $BB,%11101111 + .byte $B5,%11001111 + .byte $B3,%11001111 + .byte $0B,%00001010 + .byte $0B,%10101111 + .byte $7F,%00000110 + .byte $7D,%10100011 + .byte $6D,%01000000 + .byte $69,%00000010 + .byte $63,%11100011 + .byte $61,%00100100 + .byte $5F,%10000101; + .byte $5F,%01100100 + .byte $5F,%10100101 + .byte $5D,%11100101 + .byte $2F,%10101011 + .byte $0F,%00001010 + .byte $0D,%00001010 + .byte $05,%11101001 + .byte $03,%11101001 + .byte $01,%11001101 + .byte $03,%11101101 + .byte $05,%00001110 + .byte $09,%10001111; + .byte $09,%01101110 + .byte $0F,%00010000 + .byte $7F,%00100110 + .byte $7B,%01000000 + .byte $7B,%00000000 + .byte $6D,%10000001; + .byte $6D,%01100000 + .byte $65,%10100011 + .byte $6F,%01000000 + .byte $69,%00100010 + .byte $65,%11100011 + .byte $BF,%00010000 + .byte $BD,%00010000 + .byte $B5,%11101111 + .byte $03,%11001101 + .byte $05,%11101101 + .byte $09,%01001110 + .byte $0F,%11101111 + .byte $7F,%10100101 + .byte $7D,%11000001 + .byte $6D,%10100001 + .byte $67,%10100011 + .byte $65,%11000011 + .byte $AF,%11001111 + .byte $AD,%11001111 + .byte $1B,%00101010 + .byte $0B,%10001111; + .byte $0B,%01101110 + .byte $7F,%11000101 + .byte $71,%00000000 + .byte $6D,%11000001 + .byte $69,%01000010 + .byte $63,%00100100 + .byte $61,%10000101; + .byte $61,%01100100 + .byte $5F,%11000101 + .byte $6F,%10100001 + .byte $5F,%11100101 + .byte $BF,%00110000 + .byte $B1,%11101111 + .byte $25,%01001010 + .byte $17,%00001010 + .byte $0D,%10001111; + .byte $0D,%01101110 + .byte $11,%11101111 + .byte $7F,%11000011 + .byte $7F,%01000010 + .byte $73,%00000000 + .byte $6D,%11100001 + .byte $69,%10000011; + .byte $69,%01100010 + .byte $65,%00100100 + .byte $63,%10000101; + .byte $63,%01100100 + .byte $5D,%00100110 + .byte $AF,%11101111 + .byte $1F,%00101010 + .byte $0D,%11101001 + .byte $03,%10101101 + .byte $05,%11001101 + .byte $09,%00101110 + .byte $0F,%11001111 + .byte $71,%01000000 + .byte $6B,%00100010 + .byte $67,%11000011 + .byte $65,%00000100 + .byte $63,%01000100 + .byte $61,%10100101 + .byte $7F,%11000001 + .byte $6F,%11100001 + .byte $6B,%10000011; + .byte $6B,%01100010 + .byte $5F,%00000110 + .byte $B3,%00010000 + .byte $B1,%00010000 + .byte $05,%10101101 + .byte $07,%11001101 + .byte $81,%11000101 + .byte $7F,%01000000 + .byte $73,%01000000 + .byte $6D,%00100010 + .byte $67,%00000100 + .byte $65,%01000100 + .byte $63,%10100101 + .byte $B9,%00110000 + .byte $2F,%10001011; + .byte $2F,%01101010 + .byte $19,%00001010 + .byte $13,%11101001 + .byte $03,%10101001 + .byte $01,%00101100 + .byte $03,%01001100 + .byte $0B,%00101110 + .byte $0D,%01001110 + .byte $11,%11001111 + .byte $81,%00000110 + .byte $71,%10100001 + .byte $69,%11000011 + .byte $61,%11100101 + .byte $81,%11000011 + .byte $75,%01000000 + .byte $71,%11000001 + .byte $6F,%00100010 + .byte $6D,%01000010 + .byte $67,%00100100 + .byte $AF,%00010000 + .byte $25,%00101010 + .byte $17,%11101001 + .byte $03,%10001001; + .byte $03,%01101000 + .byte $01,%00001100 + .byte $03,%00101100 + .byte $0D,%00101110 + .byte $0F,%10001111; + .byte $0F,%01101110 + .byte $13,%11001111 + .byte $81,%11100011 + .byte $81,%00100010 + .byte $6F,%00000010 + .byte $6B,%10100011 + .byte $69,%11100011 + .byte $63,%11000101 + .byte $BB,%01010000 + .byte $B5,%00110000 + .byte $AD,%00010000 + .byte $11,%11001001 + .byte $07,%10101101 + .byte $11,%10101111 + .byte $81,%10100011 + .byte $7F,%00000000 + .byte $73,%10000001; + .byte $73,%01100000 + .byte $65,%10000101; + .byte $65,%01100100 + .byte $61,%00000110 + .byte $5F,%01000110 + .byte $81,%11100001 + .byte $81,%01000000 + .byte $81,%00000000 + .byte $71,%00000010 + .byte $6D,%10100011 + .byte $63,%11100101 + .byte $B1,%00110000 + .byte $AF,%00110000 + .byte $01,%01001000 + .byte $01,%11001011 + .byte $07,%10001101; + .byte $07,%01101100 + .byte $09,%10101101 + .byte $0B,%11101101 + .byte $11,%10001111; + .byte $11,%01101110 + .byte $81,%11000001 + .byte $75,%10000001; + .byte $75,%01100000 + .byte $61,%00100110 + .byte $BD,%10010001; + .byte $BD,%01110000 + .byte $BB,%10010001; + .byte $BB,%01110000 + .byte $B7,%01010000 + .byte $B5,%01010000 + .byte $15,%11001001 + .byte $03,%00001100 + .byte $05,%00101100 + .byte $0D,%00001110 + .byte $0F,%01001110 + .byte $13,%10101111 + .byte $73,%11000001 + .byte $6F,%01000010 + .byte $6B,%11100011 + .byte $69,%00100100 + .byte $67,%01000100 + .byte $65,%10100101 + .byte $83,%11100011 + .byte $79,%00100000 + .byte $77,%10000001; + .byte $77,%01100000 + .byte $63,%00000110 + .byte $1D,%11101001 + .byte $17,%11001001 + .byte $0B,%10001001; + .byte $0B,%01101000 + .byte $03,%11101011 + .byte $05,%00001100 + .byte $07,%00101100 + .byte $0F,%00001110 + .byte $83,%00000100 + .byte $75,%11000001 + .byte $6B,%00000100 + .byte $69,%01000100 + .byte $67,%10100101 + .byte $BF,%10110001 + .byte $BD,%10110001 + .byte $B9,%10010001; + .byte $B9,%01110000 + .byte $B7,%10010001; + .byte $B7,%01110000 + .byte $B1,%01010000 + .byte $AD,%00110000 + .byte $23,%00001010 + .byte $01,%10101011 + .byte $11,%01001110 + .byte $83,%11000011 + .byte $73,%00000010 + .byte $6F,%10100011 + .byte $6D,%11000011 + .byte $65,%11000101 + .byte $65,%11100101 + .byte $83,%00100000 + .byte $77,%11000001 + .byte $6D,%00000100 + .byte $69,%10000101; + .byte $69,%01100100 + .byte $63,%00100110 + .byte $AF,%01010000 + .byte $0F,%10001001; + .byte $0F,%01101000 + .byte $09,%01001000 + .byte $03,%10101011 + .byte $09,%01001100 + .byte $13,%01001110 + .byte $75,%00000010 + .byte $6F,%11000011 + .byte $67,%11000101 + .byte $BF,%11010001 + .byte $B9,%10110001 + .byte $B3,%10010001; + .byte $B3,%01110000 + .byte $AD,%01010000 + .byte $21,%11101001 + .byte $1B,%11001001 + .byte $05,%11101011 + .byte $07,%00001100 + .byte $0B,%10001101; + .byte $0B,%01101100 + .byte $0D,%11001101 + .byte $0F,%11101101 + .byte $11,%00101110 + .byte $15,%10101111 + .byte $85,%10001001; + .byte $85,%01101000 + .byte $79,%10000001; + .byte $79,%01100000 + .byte $73,%01000010 + .byte $71,%10000011; + .byte $71,%01100010 + .byte $6B,%01000100 + .byte $65,%00000110 + .byte $67,%11100101 + .byte $BB,%11010001 + .byte $B9,%11010001 + .byte $29,%00001010 + .byte $0D,%01001000 + .byte $07,%11101011 + .byte $09,%00001100 + .byte $11,%00001110 + .byte $15,%10001111; + .byte $15,%01101110 + .byte $85,%11000011 + .byte $85,%01000010 + .byte $85,%11000001 + .byte $85,%10000001; + .byte $85,%01100000 + .byte $7D,%00100000 + .byte $7B,%10000001; + .byte $7B,%01100000 + .byte $77,%11100001 + .byte $73,%10000011; + .byte $73,%01100010 + .byte $65,%00100110 + .byte $BF,%11110001 + .byte $B5,%10110001 + .byte $11,%10001001; + .byte $11,%01101000 + .byte $07,%00101000 + .byte $05,%10101011 + .byte $13,%00101110 + .byte $85,%11100011 + .byte $85,%00100010 + .byte $79,%11000001 + .byte $75,%00100010 + .byte $6F,%11100011 + .byte $6D,%00100100 + .byte $6B,%10000101; + .byte $6B,%01100100 + .byte $69,%11000101 + .byte $7F,%00100000 + .byte $7D,%10000001; + .byte $7D,%01100000 + .byte $79,%11100001 + .byte $6D,%10000101; + .byte $6D,%01100100 + .byte $67,%00000110 + .byte $BB,%11110001 + .byte $B7,%11010001 + .byte $B5,%11010001 + .byte $11,%01001000 + .byte $05,%10001011; + .byte $05,%01101010 + .byte $15,%01001110 + .byte $77,%00100010 + .byte $75,%01000010 + .byte $71,%11100011 + .byte $6D,%01000100 + .byte $6B,%10100101 + .byte $65,%01000110 + .byte $B1,%10110001 + .byte $AB,%10010001; + .byte $AB,%01110000 + .byte $2F,%00101010 + .byte $25,%11101001 + .byte $21,%11001001 + .byte $19,%10101001 + .byte $0B,%00101000 + .byte $05,%00001000 + .byte $09,%11101011 + .byte $0B,%00101100 + .byte $0D,%01001100 + .byte $0F,%10101101 + .byte $13,%00001110 + .byte $17,%10001111; + .byte $17,%01101110 + .byte $73,%10100011 + .byte $69,%11100101 + .byte $67,%00100110 + .byte $87,%00000100 + .byte $87,%01000010 + .byte $87,%11000001 + .byte $87,%10000001; + .byte $87,%01100000 + .byte $87,%00100000 + .byte $79,%00100010 + .byte $77,%01000010 + .byte $73,%11100011 + .byte $71,%00000100 + .byte $6B,%11000101 + .byte $BD,%00010010 + .byte $B9,%11110001 + .byte $B7,%11110001 + .byte $B3,%11010001 + .byte $B1,%11010001 + .byte $AD,%10110001 + .byte $23,%11001001 + .byte $0D,%00101000 + .byte $01,%11001001 + .byte $05,%00101010 + .byte $09,%11001011 + .byte $0B,%11101011 + .byte $13,%11101101 + .byte $87,%10001001; + .byte $87,%01101000 + .byte $87,%01000000 + .byte $87,%00000000 + .byte $7D,%10100001 + .byte $75,%10100011 + .byte $69,%00000110 + .byte $1F,%10101001 + .byte $0F,%00101000 + .byte $09,%00001000 + .byte $03,%11100111 + .byte $03,%00001010 + .byte $07,%10001011; + .byte $07,%01101010 + .byte $15,%00101110 + .byte $87,%11100111 + .byte $87,%10100011 + .byte $7F,%10000001; + .byte $7F,%01100000 + .byte $7B,%11100001 + .byte $6F,%01000100 + .byte $6D,%10100101 + .byte $67,%01000110 + .byte $7F,%10100001 + .byte $77,%10100011 + .byte $75,%11000011 + .byte $6B,%11100101 + .byte $B5,%11110001 + .byte $B3,%11110001 + .byte $AB,%10110001 + .byte $2F,%00001010 + .byte $11,%00101000 + .byte $07,%01001010 + .byte $0F,%01001100 + .byte $17,%00101110 + .byte $81,%10000001; + .byte $81,%01100000 + .byte $7D,%11100001 + .byte $79,%01000010 + .byte $71,%01000100 + .byte $69,%00100110 + .byte $AF,%11010001 + .byte $0D,%00001000 + .byte $0B,%11001011 + .byte $0D,%00001100 + .byte $0F,%00101100 + .byte $11,%10001101; + .byte $11,%01101100 + .byte $13,%11001101 + .byte $15,%00001110 + .byte $73,%00000100 + .byte $71,%00100100 + .byte $6F,%10000101; + .byte $6F,%01100100 + .byte $6D,%11000101 + .byte $67,%10000111; + .byte $67,%01100110 + .byte $89,%11000011 + .byte $89,%00100010 + .byte $89,%01000000 + .byte $83,%10000001; + .byte $83,%01100000 + .byte $7F,%11100001 + .byte $7B,%01000010 + .byte $79,%10000011; + .byte $79,%01100010 + .byte $75,%00000100 + .byte $73,%00100100 + .byte $71,%10000101; + .byte $71,%01100100 + .byte $B1,%11110001 + .byte $AF,%11110001 + .byte $AB,%11010001 + .byte $07,%11000111 + .byte $07,%00001010 + .byte $0B,%10101011 + .byte $0D,%11001011 + .byte $15,%11001101 + .byte $19,%01001110 + .byte $89,%11100011 + .byte $77,%11000011 + .byte $6F,%10100101 + .byte $6D,%11100101 + .byte $69,%01000110 + .byte $BF,%01010010 + .byte $BD,%01010010 + .byte $B9,%00110010 + .byte $B5,%00010010 + .byte $1D,%10001001; + .byte $1D,%01101000 + .byte $19,%01001000 + .byte $09,%01001010 + .byte $11,%01001100 + .byte $17,%00001110 + .byte $89,%00000100 + .byte $89,%00000010 + .byte $89,%11000001 + .byte $85,%00100000 + .byte $81,%10100001 + .byte $7D,%00000010 + .byte $6B,%00000110 + .byte $8B,%11000001 + .byte $79,%11000011 + .byte $77,%11100011 + .byte $6F,%11000101 + .byte $B1,%00010010 + .byte $03,%01001000 + .byte $0F,%11101011 + .byte $11,%00101100 + .byte $19,%00101110 + .byte $8B,%01000000 + .byte $83,%10100001 + .byte $7F,%00000010 + .byte $6D,%00000110 + .byte $6B,%01000110 + .byte $BF,%10010011; + .byte $BF,%01110010 + .byte $BB,%01010010 + .byte $B7,%00110010 + .byte $B5,%00110010 + .byte $AD,%11110001 + .byte $2D,%11101001 + .byte $13,%00001000 + .byte $0D,%11100111 + .byte $01,%10000111; + .byte $01,%01100110 + .byte $09,%00001010 + .byte $0D,%10101011 + .byte $15,%10101101 + .byte $17,%11101101 + .byte $8B,%00100000 + .byte $7D,%01000010 + .byte $75,%00100100 + .byte $71,%10100101 + .byte $6F,%11100101 + .byte $69,%10000111; + .byte $69,%01100110 + .byte $8B,%11100011 + .byte $85,%10100001 + .byte $81,%00000010 + .byte $7D,%10000011; + .byte $7D,%01100010 + .byte $BF,%10110011 + .byte $BB,%10010011; + .byte $BB,%01110010 + .byte $AF,%00010010 + .byte $A9,%11110001 + .byte $2F,%11101001 + .byte $15,%00001000 + .byte $0D,%11000111 + .byte $03,%10000111; + .byte $03,%01100110 + .byte $01,%11000111 + .byte $09,%11101001 + .byte $0D,%10001011; + .byte $0D,%01101010 + .byte $17,%11001101 + .byte $8B,%01000010 + .byte $79,%11100011 + .byte $75,%01000100 + .byte $71,%11000101 + .byte $6B,%10000111; + .byte $6B,%01100110 + .byte $BD,%10010011; + .byte $BD,%01110010 + .byte $B7,%01010010 + .byte $B3,%00110010 + .byte $37,%00101010 + .byte $23,%10001001; + .byte $23,%01101000 + .byte $1D,%01001000 + .byte $11,%11100111 + .byte $09,%10100111 + .byte $01,%11100111 + .byte $05,%01001000 + .byte $07,%10101001 + .byte $0B,%00101010 + .byte $13,%00101100 + .byte $15,%10001101; + .byte $15,%01101100 + .byte $19,%00001110 + .byte $8B,%11000011 + .byte $8B,%00100010 + .byte $6D,%00100110 + .byte $69,%10100111 + .byte $8D,%10100001 + .byte $8D,%01000000 + .byte $89,%10000001; + .byte $89,%01100000 + .byte $7D,%11000011 + .byte $7B,%11100011 + .byte $79,%00000100 + .byte $75,%10000101; + .byte $75,%01100100 + .byte $71,%11100101 + .byte $BD,%10110011 + .byte $B9,%10010011; + .byte $B9,%01110010 + .byte $B3,%01010010 + .byte $21,%01001000 + .byte $0B,%10100111 + .byte $07,%10001001; + .byte $07,%01101000 + .byte $11,%11001011 + .byte $13,%00001100 + .byte $15,%01001100 + .byte $17,%10101101 + .byte $1B,%00001110 + .byte $8D,%00100000 + .byte $83,%00000010 + .byte $6F,%00100110 + .byte $AB,%00010010 + .byte $2D,%11001001 + .byte $07,%10000111; + .byte $07,%01100110 + .byte $09,%11001001 + .byte $0B,%11101001 + .byte $0F,%10001011; + .byte $0F,%01101010 + .byte $19,%11001101 + .byte $19,%11101101 + .byte $8D,%11000001 + .byte $8D,%00000000 + .byte $85,%11100001 + .byte $81,%01000010 + .byte $7F,%10000011; + .byte $7F,%01100010 + .byte $77,%01000100 + .byte $73,%11000101 + .byte $6D,%01000110 + .byte $85,%00000010 + .byte $7F,%10100011 + .byte $B5,%10010011; + .byte $B5,%01110010 + .byte $AD,%00110010 + .byte $2B,%10101001 + .byte $17,%11100111 + .byte $09,%10000111; + .byte $09,%01100110 + .byte $03,%00100110 + .byte $03,%10100111 + .byte $05,%11100111 + .byte $1B,%11101101 + .byte $8D,%11000011 + .byte $8B,%10000001; + .byte $8B,%01100000 + .byte $87,%11100001 + .byte $83,%01000010 + .byte $81,%10000011; + .byte $81,%01100010 + .byte $77,%10000101; + .byte $77,%01100100 + .byte $6F,%01000110 + .byte $6B,%10100111 + .byte $B1,%01010010 + .byte $A9,%00010010 + .byte $37,%00001010 + .byte $27,%10001001; + .byte $27,%01101000 + .byte $1B,%00001000 + .byte $01,%00100110 + .byte $09,%10001001; + .byte $09,%01101000 + .byte $11,%10101011 + .byte $15,%00001100 + .byte $17,%01001100 + .byte $19,%10101101 + .byte $1D,%00101110 + .byte $8B,%11100111 + .byte $8D,%11100011 + .byte $8F,%00100000 + .byte $7D,%11100011 + .byte $73,%11100101 + .byte $71,%00000110 + .byte $6D,%10000111; + .byte $6D,%01100110 + .byte $8D,%10000001; + .byte $8D,%01100000 + .byte $89,%11100001 + .byte $7F,%11100011 + .byte $7D,%00000100 + .byte $6F,%10000111; + .byte $6F,%01100110 + .byte $B3,%10010011; + .byte $B3,%01110010 + .byte $B1,%10010011; + .byte $B1,%01110010 + .byte $1D,%00001000 + .byte $19,%11100111 + .byte $11,%10100111 + .byte $01,%00000110 + .byte $03,%01000110 + .byte $05,%10100111 + .byte $0D,%11001001 + .byte $13,%10101011 + .byte $17,%00101100 + .byte $19,%10001101; + .byte $19,%01101100 + .byte $1D,%00001110 + .byte $73,%00000110 + .byte $6B,%11000111 + .byte $BD,%11110011 + .byte $B9,%11010011 + .byte $AF,%01010010 + .byte $AD,%01010010 + .byte $AB,%00110010 + .byte $A9,%00110010 + .byte $2D,%10101001 + .byte $25,%01001000 + .byte $15,%11000111 + .byte $0D,%10000111; + .byte $0D,%01100110 + .byte $07,%11100111 + .byte $09,%00101000 + .byte $11,%01001010 + .byte $1B,%11001101 + .byte $8F,%00100010 + .byte $8F,%10100001 + .byte $8B,%10100001 + .byte $87,%00000010 + .byte $83,%10000011; + .byte $83,%01100010 + .byte $79,%10000101; + .byte $79,%01100100 + .byte $77,%10100101 + .byte $71,%00100110 + .byte $6D,%10100111 + .byte $8F,%11000011 + .byte $91,%10100001 + .byte $91,%01000000 + .byte $87,%00100010 + .byte $83,%10100011 + .byte $6F,%10100111 + .byte $AB,%01010010 + .byte $A7,%00110010 + .byte $15,%10100111 + .byte $0D,%10001001; + .byte $0D,%01101000 + .byte $0F,%11101001 + .byte $11,%00001010 + .byte $15,%11001011 + .byte $17,%00001100 + .byte $1D,%11101101 + .byte $8B,%11100001 + .byte $85,%10000011; + .byte $85,%01100010 + .byte $79,%10100101 + .byte $71,%01000110 + .byte $BB,%11110011 + .byte $B7,%11010011 + .byte $B3,%10110011 + .byte $AF,%10010011; + .byte $AF,%01110010 + .byte $2B,%10001001; + .byte $2B,%01101000 + .byte $03,%00000110 + .byte $05,%01000110 + .byte $07,%10100111 + .byte $09,%11100111 + .byte $0F,%11001001 + .byte $13,%10001011; + .byte $13,%01101010 + .byte $15,%10101011 + .byte $17,%11101011 + .byte $19,%01001100 + .byte $1B,%10101101 + .byte $8D,%11100111 + .byte $8F,%10000001; + .byte $8F,%01100000 + .byte $7F,%00000100 + .byte $77,%11000101 + .byte $75,%00000110 + .byte $73,%00100110 + .byte $6D,%11000111 + .byte $91,%10100011 + .byte $91,%01000010 + .byte $91,%00000010 + .byte $8D,%11100001 + .byte $89,%01000010 + .byte $81,%00000100 + .byte $7F,%00100100 + .byte $7D,%01000100 + .byte $B7,%11110011 + .byte $2D,%10001001; + .byte $2D,%01101000 + .byte $0B,%00100110 + .byte $07,%00000110 + .byte $0F,%10101001 + .byte $13,%00101010 + .byte $1F,%00001110 + .byte $8F,%11100101 + .byte $91,%10000001; + .byte $91,%01100000 + .byte $8F,%11000001 + .byte $77,%11100101 + .byte $75,%00100110 + .byte $71,%10000111; + .byte $71,%01100110 + .byte $B5,%11010011 + .byte $B3,%11010011 + .byte $AD,%10010011; + .byte $AD,%01110010 + .byte $A9,%01010010 + .byte $29,%01001000 + .byte $0B,%00001000 + .byte $11,%11101001 + .byte $17,%11001011 + .byte $19,%00001100 + .byte $19,%00101100 + .byte $1D,%11001101 + .byte $8B,%00000010 + .byte $87,%10000011; + .byte $87,%01100010 + .byte $85,%10100011 + .byte $7B,%10100101 + .byte $79,%11000101 + .byte $73,%01000110 + .byte $6F,%11000111 + .byte $6D,%11100111 + .byte $91,%11000001 + .byte $77,%00000110 + .byte $75,%01000110 + .byte $B5,%11110011 + .byte $AD,%10110011 + .byte $27,%00101000 + .byte $23,%00001000 + .byte $15,%10000111; + .byte $15,%01100110 + .byte $0F,%01001000 + .byte $15,%01001010 + .byte $17,%10101011 + .byte $19,%11101011 + .byte $1B,%00101100 + .byte $1F,%11001101 + .byte $1F,%11101101 + .byte $91,%11100011 + .byte $93,%00000010 + .byte $8D,%00000010 + .byte $89,%10000011; + .byte $89,%01100010 + .byte $81,%00100100 + .byte $7F,%01000100 + .byte $7B,%11000101 + .byte $71,%10100111 + .byte $B1,%11010011 + .byte $A7,%01010010 + .byte $19,%10100111 + .byte $11,%01000110 + .byte $0B,%00000110 + .byte $07,%11100101 + .byte $0B,%11000111 + .byte $11,%10101001 + .byte $13,%00001010 + .byte $15,%00101010 + .byte $1D,%10001101; + .byte $1D,%01101100 + .byte $8D,%11101001 + .byte $91,%00000100 + .byte $91,%11000011 + .byte $93,%11100001 + .byte $93,%10100001 + .byte $8F,%11100001 + .byte $79,%11100101 + .byte $73,%10000111; + .byte $73,%01100110 + .byte $6D,%00001000 + .byte $91,%11000101 + .byte $8F,%00000010 + .byte $8B,%10000011; + .byte $8B,%01100010 + .byte $85,%00000100 + .byte $83,%00100100 + .byte $81,%01000100 + .byte $7F,%10000101; + .byte $7F,%01100100 + .byte $7B,%11100101 + .byte $B3,%11110011 + .byte $A9,%10010011; + .byte $A9,%01110010 + .byte $A7,%10010011; + .byte $A7,%01110010 + .byte $1B,%10100111 + .byte $11,%00100110 + .byte $0D,%00000110 + .byte $07,%11000101 + .byte $09,%00000110 + .byte $0F,%00001000 + .byte $15,%00001010 + .byte $1F,%10101101 + .byte $8F,%00001000 + .byte $91,%11100101 + .byte $79,%00000110 + .byte $73,%10100111 + .byte $AF,%11010011 + .byte $AB,%10110011 + .byte $39,%11101001 + .byte $33,%10101001 + .byte $25,%00001000 + .byte $21,%11100111 + .byte $1F,%11000111 + .byte $09,%00100110 + .byte $0B,%10000111; + .byte $0B,%01100110 + .byte $13,%11001001 + .byte $17,%01001010 + .byte $19,%10101011 + .byte $1B,%00001100 + .byte $1D,%01001100 + .byte $21,%11101101 + .byte $91,%10100101 + .byte $93,%10100011 + .byte $89,%10100011 + .byte $7D,%11000101 + .byte $77,%00100110 + .byte $75,%10000111; + .byte $75,%01100110 + .byte $71,%11000111 + .byte $6F,%11100111 + .byte $91,%00000110 + .byte $95,%00000010 + .byte $AF,%11110011 + .byte $0F,%11000111 + .byte $13,%10001001; + .byte $13,%01101000 + .byte $17,%00101010 + .byte $95,%11100001 + .byte $8D,%10000011; + .byte $8D,%01100010 + .byte $8B,%10100011 + .byte $85,%00100100 + .byte $83,%01000100 + .byte $81,%10000101; + .byte $81,%01100100 + .byte $7D,%11100101 + .byte $77,%01000110 + .byte $73,%11000111 + .byte $A9,%10110011 + .byte $25,%11100111 + .byte $19,%10000111; + .byte $19,%01100110 + .byte $17,%01000110 + .byte $0F,%11100111 + .byte $1F,%10001101; + .byte $1F,%01101100 + .byte $21,%11001101 + .byte $8F,%01000010 + .byte $7B,%00000110 + .byte $79,%00100110 + .byte $71,%11100111 + .byte $6F,%00001000 + .byte $93,%11000101 + .byte $95,%11000011 + .byte $95,%10000011; + .byte $95,%01100010 + .byte $8F,%10000011; + .byte $8F,%01100010 + .byte $87,%00100100 + .byte $81,%10100101 + .byte $7D,%00000110 + .byte $77,%10000111; + .byte $77,%01100110 + .byte $73,%11100111 + .byte $AB,%11010011 + .byte $A9,%11010011 + .byte $19,%01000110 + .byte $0F,%10000111; + .byte $0F,%01100110 + .byte $13,%00101000 + .byte $15,%10101001 + .byte $19,%01001010 + .byte $1B,%10101011 + .byte $1D,%11101011 + .byte $21,%10101101 + .byte $93,%11100101 + .byte $95,%11100011 + .byte $95,%10100011 + .byte $7B,%00100110 + .byte $AD,%11110011 + .byte $A7,%10110011 + .byte $39,%11001001 + .byte $2F,%01001000 + .byte $15,%00100110 + .byte $0F,%11100101 + .byte $0B,%11000101 + .byte $0F,%10100111 + .byte $15,%10001001; + .byte $15,%01101000 + .byte $19,%00101010 + .byte $1F,%00101100 + .byte $1F,%01001100 + .byte $23,%11101101 + .byte $8F,%10101001 + .byte $8D,%10100011 + .byte $85,%01000100 + .byte $83,%10000101; + .byte $83,%01100100 + .byte $7F,%11100101 + .byte $79,%01000110 + .byte $71,%00001000 + .byte $6F,%00101000 + .byte $93,%00000110 + .byte $95,%00100010 + .byte $15,%00000110 + .byte $0F,%11000101 + .byte $0D,%11100101 + .byte $0F,%00100110 + .byte $13,%11100111 + .byte $15,%01001000 + .byte $19,%11101001 + .byte $21,%01001100 + .byte $21,%10001101; + .byte $21,%01101100 + .byte $93,%00100110 + .byte $97,%10000011; + .byte $97,%01100010 + .byte $91,%10000011; + .byte $91,%01100010 + .byte $8F,%10100011 + .byte $8B,%00000100 + .byte $89,%00100100 + .byte $87,%01000100 + .byte $85,%10000101; + .byte $85,%01100100 + .byte $83,%10100101 + .byte $79,%10000111; + .byte $79,%01100110 + .byte $75,%11000111 + .byte $AB,%11110011 + .byte $A7,%11010011 + .byte $A5,%10110011 + .byte $37,%10101001 + .byte $21,%10100111 + .byte $15,%00101000 + .byte $17,%10101001 + .byte $1B,%01001010 + .byte $1D,%10101011 + .byte $1D,%11001011 + .byte $1F,%00001100 + .byte $23,%11001101 + .byte $91,%00101000 + .byte $91,%00001000 + .byte $97,%01000010 + .byte $97,%00000010 + .byte $93,%01000010 + .byte $7B,%01000110 + .byte $77,%10100111 + .byte $71,%00101000 + .byte $95,%11100101 + .byte $99,%00000010 + .byte $93,%10000011; + .byte $93,%01100010 + .byte $81,%11100101 + .byte $79,%10100111 + .byte $73,%00001000 + .byte $2D,%00001000 + .byte $29,%11100111 + .byte $23,%10100111 + .byte $13,%10100111 + .byte $17,%01001000 + .byte $1B,%00001010 + .byte $21,%00101100 + .byte $95,%01000010 + .byte $75,%11100111 + .byte $A9,%11110011 + .byte $35,%10001001; + .byte $35,%01101000 + .byte $33,%01001000 + .byte $1D,%01000110 + .byte $1B,%00100110 + .byte $13,%11000111 + .byte $19,%11001001 + .byte $23,%10001101; + .byte $23,%01101100 + .byte $23,%10101101 + .byte $25,%11101101 + .byte $95,%11000101 + .byte $97,%00100010 + .byte $8B,%00100100 + .byte $89,%01000100 + .byte $87,%10000101; + .byte $87,%01100100 + .byte $85,%10100101 + .byte $83,%11000101 + .byte $7B,%10000111; + .byte $7B,%01100110 + .byte $77,%11000111 + .byte $95,%00000110 + .byte $97,%01000100 + .byte $99,%10000011; + .byte $99,%01100010 + .byte $A7,%11110011 + .byte $13,%01000110 + .byte $17,%00001000 + .byte $19,%10001001; + .byte $19,%01101000 + .byte $1D,%00101010 + .byte $1D,%01001010 + .byte $1F,%10101011 + .byte $21,%11101011 + .byte $95,%00100110 + .byte $97,%10000101; + .byte $97,%01100100 + .byte $97,%00100100 + .byte $99,%01000010 + .byte $8F,%00000100 + .byte $8D,%00100100 + .byte $8B,%01000100 + .byte $89,%10000101; + .byte $89,%01100100 + .byte $87,%10100101 + .byte $85,%11000101 + .byte $83,%11100101 + .byte $7B,%10100111 + .byte $77,%11100111 + .byte $39,%10101001 + .byte $37,%10001001; + .byte $37,%01101000 + .byte $31,%00101000 + .byte $2B,%11100111 + .byte $27,%11000111 + .byte $25,%10100111 + .byte $1F,%01000110 + .byte $19,%00000110 + .byte $0F,%10100101 + .byte $11,%11100101 + .byte $13,%10000111; + .byte $13,%01100110 + .byte $1B,%11101001 + .byte $21,%00001100 + .byte $23,%01001100 + .byte $25,%11001101 + .byte $79,%11000111 + .byte $75,%00001000 + .byte $73,%00101000 + .byte $71,%01001000 + .byte $95,%01000110 + .byte $99,%11100011 + .byte $93,%11100011 + .byte $81,%00100110 + .byte $7B,%11000111 + .byte $75,%00101000 + .byte $2F,%00001000 + .byte $13,%10100101 + .byte $13,%00000110 + .byte $17,%11000111 + .byte $19,%00101000 + .byte $1B,%10101001 + .byte $93,%00101000 + .byte $95,%10000111; + .byte $95,%01100110 + .byte $7F,%01000110 + .byte $77,%00001000 + .byte $A5,%11110011 + .byte $A3,%11010011 + .byte $35,%01001000 + .byte $25,%10000111; + .byte $25,%01100110 + .byte $11,%10100101 + .byte $1D,%00001010 + .byte $1F,%01001010 + .byte $21,%11001011 + .byte $23,%00101100 + .byte $25,%10001101; + .byte $25,%01101100 + .byte $25,%10101101 + .byte $91,%00001010 + .byte $97,%11000101 + .byte $8F,%00100100 + .byte $8D,%01000100 + .byte $8B,%10000101; + .byte $8B,%01100100 + .byte $89,%10100101 + .byte $87,%11000101 + .byte $85,%11100101 + .byte $83,%00000110 + .byte $73,%01001000 + .byte $99,%10100011 + .byte $91,%00100100 + .byte $8F,%01000100 + .byte $8D,%10000101; + .byte $8D,%01100100 + .byte $8B,%10100101 + .byte $89,%11000101 + .byte $87,%11100101 + .byte $7F,%10000111; + .byte $7F,%01100110 + .byte $39,%10001001; + .byte $39,%01101000 + .byte $33,%00101000 + .byte $1B,%11100101 + .byte $15,%10100101 + .byte $13,%11000101 + .byte $1D,%11001001 + .byte $1F,%00001010 + .byte $97,%11100101 + .byte $93,%00000100 + .byte $85,%00000110 + .byte $83,%00100110 + .byte $7D,%10100111 + .byte $A3,%11110011 + .byte $17,%10100111 + .byte $1D,%10101001 + .byte $21,%10001011; + .byte $21,%01101010 + .byte $21,%10101011 + .byte $25,%01001100 + .byte $27,%11001101 + .byte $97,%00000110 + .byte $99,%01000100 + .byte $9B,%10000011; + .byte $9B,%01100010 + .byte $97,%11000011 + .byte $81,%01000110 + .byte $93,%11001001 + .byte $97,%01000110 + .byte $97,%11100011 + .byte $83,%01000110 + .byte $7D,%11000111 + .byte $77,%00101000 + .byte $1B,%11100111 + .byte $21,%00101010 + .byte $21,%01001010 + .byte $23,%10101011 + .byte $23,%11001011 + .byte $27,%10001101; + .byte $27,%01101100 + .byte $97,%10000111; + .byte $97,%01100110 + .byte $99,%11000101 + .byte $99,%11000011 + .byte $91,%01000100 + .byte $8F,%10000101; + .byte $8F,%01100100 + .byte $8D,%10100101 + .byte $8B,%11000101 + .byte $89,%11100101 + .byte $81,%10000111; + .byte $81,%01100110 + .byte $79,%00001000 + .byte $25,%01000110 + .byte $15,%11000101 + .byte $1F,%11001001 + .byte $1F,%11101001 + .byte $25,%00001100 + .byte $25,%00101100 + .byte $27,%10101101 + .byte $9B,%00100100 + .byte $95,%00000100 + .byte $93,%00100100 + .byte $87,%00000110 + .byte $85,%00100110 + .byte $7F,%10100111 + .byte $7B,%11100111 + .byte $75,%01001000 + .byte $73,%10001001; + .byte $73,%01101000 + .byte $97,%10100111 + .byte $9B,%10000101; + .byte $9B,%01100100 + .byte $9D,%11100011 + .byte $9D,%10100011 + .byte $95,%00100100 + .byte $93,%01000100 + .byte $87,%00100110 + .byte $29,%10000111; + .byte $29,%01100110 + .byte $27,%01000110 + .byte $15,%01000100 + .byte $17,%11100101 + .byte $19,%00100110 + .byte $1F,%10001001; + .byte $1F,%01101000 + .byte $27,%01001100 + .byte $95,%01001000 + .byte $97,%11000111 + .byte $97,%00000100 + .byte $85,%01000110 + .byte $7F,%11000111 + .byte $33,%00001000 + .byte $1F,%11100101 + .byte $17,%10000101; + .byte $17,%01100100 + .byte $15,%10000101; + .byte $15,%01100100 + .byte $17,%11000101 + .byte $1B,%11000111 + .byte $1D,%00101000 + .byte $21,%00001010 + .byte $23,%01001010 + .byte $23,%10001011; + .byte $23,%01101010 + .byte $25,%11001011 + .byte $25,%11101011 + .byte $29,%11001101 + .byte $9B,%11000011 + .byte $91,%10000101; + .byte $91,%01100100 + .byte $8F,%10100101 + .byte $8D,%11000101 + .byte $8B,%11100101 + .byte $89,%00000110 + .byte $83,%10000111; + .byte $83,%01100110 + .byte $81,%10100111 + .byte $7D,%11100111 + .byte $7B,%00001000 + .byte $79,%00101000 + .byte $77,%01001000 + .byte $75,%10001001; + .byte $75,%01101000 + .byte $73,%10101001 + .byte $97,%11100111 + .byte $9D,%00000100 + .byte $9B,%11100011 + .byte $8F,%11000101 + .byte $8D,%11100101 + .byte $21,%11100101 + .byte $19,%10000101; + .byte $19,%01100100 + .byte $19,%11100101 + .byte $21,%10101001 + .byte $27,%00001100 + .byte $27,%00101100 + .byte $29,%10101101 + .byte $9D,%00100100 + .byte $95,%01000100 + .byte $93,%10000101; + .byte $93,%01100100 + .byte $8B,%00000110 + .byte $89,%00100110 + .byte $7B,%00101000 + .byte $1B,%10000111; + .byte $1B,%01100110 + .byte $1D,%11100111 + .byte $1F,%01001000 + .byte $23,%00101010 + .byte $25,%10101011 + .byte $29,%10001101; + .byte $29,%01101100 + .byte $91,%11101011 + .byte $99,%00000100 + .byte $87,%01000110 + .byte $85,%10000111; + .byte $85,%01100110 + .byte $83,%10100111 + .byte $81,%11000111 + .byte $7F,%11100111 + .byte $7D,%00001000 + .byte $79,%01001000 + .byte $77,%10001001; + .byte $77,%01101000 + .byte $81,%11100111 + .byte $7B,%01001000 + .byte $27,%00100110 + .byte $23,%11100101 + .byte $1B,%10000101; + .byte $1B,%01100100 + .byte $19,%10100101 + .byte $1D,%10100111 + .byte $1F,%00001000 + .byte $23,%11101001 + .byte $27,%11001011 + .byte $27,%11101011 + .byte $97,%01001000 + .byte $99,%11000111 + .byte $85,%10100111 + .byte $2D,%10000111; + .byte $2D,%01100110 + .byte $1D,%10000111; + .byte $1D,%01100110 + .byte $1F,%11100111 + .byte $21,%10001001; + .byte $21,%01101000 + .byte $29,%00101100 + .byte $29,%01001100 + .byte $93,%10001011; + .byte $93,%01101010 + .byte $9F,%11100011 + .byte $95,%10000101; + .byte $95,%01100100 + .byte $8D,%00000110 + .byte $8B,%00100110 + .byte $89,%01000110 + .byte $87,%10000111; + .byte $87,%01100110 + .byte $83,%11000111 + .byte $7F,%00001000 + .byte $75,%10101001 + .byte $97,%10001001; + .byte $97,%01101000 + .byte $99,%11100111 + .byte $95,%10100101 + .byte $8F,%00000110 + .byte $8D,%00100110 + .byte $8B,%01000110 + .byte $31,%10100111 + .byte $27,%00000110 + .byte $1F,%10100101 + .byte $1D,%00000110 + .byte $21,%00101000 + .byte $25,%00001010 + .byte $27,%10001011; + .byte $27,%01101010 + .byte $27,%10101011 + .byte $2B,%10101101 + .byte $9F,%00000100 + .byte $89,%10000111; + .byte $89,%01100110 + .byte $83,%11100111 + .byte $1B,%10100101 + .byte $1D,%00100110 + .byte $1F,%10100111 + .byte $21,%00001000 + .byte $23,%10101001 + .byte $29,%00001100 + .byte $2B,%10001101; + .byte $2B,%01101100 + .byte $99,%10000101; + .byte $99,%01100100 + .byte $87,%10100111 + .byte $85,%11000111 + .byte $81,%00001000 + .byte $79,%10001001; + .byte $79,%01101000 + .byte $77,%10101001 + .byte $75,%11001001 + .byte $9F,%10100101 + .byte $A1,%00000100 + .byte $99,%10100101 + .byte $87,%11000111 + .byte $1D,%11000101 + .byte $21,%11000111 + .byte $23,%01001000 + .byte $9B,%11000111 + .byte $9D,%00000110 + .byte $9D,%01000100 + .byte $8F,%00100110 + .byte $8D,%01000110 + .byte $85,%11100111 + .byte $1B,%01000100 + .byte $23,%00101000 + .byte $25,%11001001 + .byte $27,%00101010 + .byte $27,%01001010 + .byte $29,%11001011 + .byte $29,%11101011 + .byte $2B,%01001100 + .byte $9D,%00100110 + .byte $9F,%00100100 + .byte $8B,%10000111; + .byte $8B,%01100110 + .byte $89,%10100111 + .byte $7D,%01001000 + .byte $7B,%10001001; + .byte $7B,%01101000 + .byte $79,%10101001 + .byte $77,%11001001 + .byte $9B,%11100111 + .byte $9F,%11000101 + .byte $8B,%10100111 + .byte $33,%10100111 + .byte $1F,%01000100 + .byte $1F,%11000101 + .byte $21,%10000111; + .byte $21,%01100110 + .byte $23,%11100111 + .byte $25,%10001001; + .byte $25,%01101000 + .byte $2B,%00001100 + .byte $2B,%00101100 + .byte $9F,%11100101 + .byte $9B,%10100101 + .byte $89,%11000111 + .byte $81,%00101000 + .byte $45,%11001001 + .byte $43,%10101001 + .byte $2F,%01000110 + .byte $2B,%00000110 + .byte $1D,%01000100 + .byte $21,%01000110 + .byte $27,%11101001 + .byte $27,%00001010 + .byte $29,%10001011; + .byte $29,%01101010 + .byte $29,%10101011 + .byte $2D,%10001101; + .byte $2D,%01101100 + .byte $2D,%10101101 + .byte $9F,%01000100 + .byte $9D,%10000101; + .byte $9D,%01100100 + .byte $91,%00100110 + .byte $8F,%01000110 + .byte $8D,%10000111; + .byte $8D,%01100110 + .byte $83,%00001000 + .byte $7F,%01001000 + .byte $7D,%10001001; + .byte $7D,%01101000 + .byte $7B,%10101001 + .byte $75,%11101001 + .byte $9B,%00101000 + .byte $A1,%10100101 + .byte $9F,%10000101; + .byte $9F,%01100100 + .byte $91,%01000110 + .byte $8F,%10000111; + .byte $8F,%01100110 + .byte $21,%01000100 + .byte $1F,%10000101; + .byte $1F,%01100100 + .byte $23,%10000111; + .byte $23,%01100110 + .byte $27,%10101001 + .byte $27,%11001001 + .byte $2B,%10101011 + .byte $2B,%11001011 + .byte $2B,%11101011 + .byte $2D,%01001100 + .byte $9F,%00000110 + .byte $A1,%11000101 + .byte $8D,%10100111 + .byte $8B,%11000111 + .byte $83,%00101000 + .byte $79,%11001001 + .byte $25,%10100101 + .byte $25,%00101000 + .byte $29,%00101010 + .byte $29,%01001010 + .byte $99,%10101001 + .byte $9B,%00001000 + .byte $9F,%00100110 + .byte $9D,%10100101 + .byte $9B,%11000101 + .byte $89,%11100111 + .byte $85,%00001000 + .byte $81,%01001000 + .byte $7F,%10001001; + .byte $7F,%01101000 + .byte $77,%11101001 + .byte $9F,%10000111; + .byte $9F,%01100110 + .byte $9D,%11000101 + .byte $9B,%11100101 + .byte $87,%00001000 + .byte $35,%10100111 + .byte $21,%10000101; + .byte $21,%01100100 + .byte $23,%00100110 + .byte $29,%11001001 + .byte $29,%11101001 + .byte $2B,%01001010 + .byte $2B,%10001011; + .byte $2B,%01101010 + .byte $A1,%11100101 + .byte $93,%01000110 + .byte $91,%10000111; + .byte $91,%01100110 + .byte $8F,%10100111 + .byte $7D,%10101001 + .byte $7B,%11001001 + .byte $43,%10001001; + .byte $43,%01101000 + .byte $2F,%00100110 + .byte $2B,%11100101 + .byte $29,%11000101 + .byte $23,%00000110 + .byte $23,%01000110 + .byte $25,%11000111 + .byte $27,%01001000 + .byte $2D,%00001100 + .byte $2F,%10101101 + .byte $97,%01001010 + .byte $9B,%01001000 + .byte $A1,%00000110 + .byte $A3,%10000101; + .byte $A3,%01100100 + .byte $99,%00000110 + .byte $97,%00100110 + .byte $8D,%11000111 + .byte $85,%00101000 + .byte $83,%01001000 + .byte $81,%10001001; + .byte $81,%01101000 + .byte $79,%11101001 + .byte $77,%00001010 + .byte $99,%00100110 + .byte $89,%00001000 + .byte $33,%01000110 + .byte $2B,%11000101 + .byte $25,%00100110 + .byte $27,%00001000 + .byte $2B,%00001010 + .byte $2B,%00101010 + .byte $2F,%10001101; + .byte $2F,%01101100 + .byte $9D,%11100101 + .byte $9B,%00000110 + .byte $7F,%10101001 + .byte $7D,%11001001 + .byte $31,%00100110 + .byte $23,%11000101 + .byte $27,%11100111 + .byte $29,%10001001; + .byte $29,%01101000 + .byte $29,%10101001 + .byte $2D,%10101011 + .byte $2D,%11001011 + .byte $2D,%11101011 + .byte $2F,%01001100 + .byte $9F,%10100111 + .byte $A3,%10100101 + .byte $93,%10000111; + .byte $93,%01100110 + .byte $91,%10100111 + .byte $8F,%11000111 + .byte $87,%00101000 + .byte $85,%01001000 + .byte $83,%10001001; + .byte $83,%01101000 + .byte $7B,%11101001 + .byte $A1,%10000111; + .byte $A1,%01100110 + .byte $93,%10100111 + .byte $91,%11000111 + .byte $87,%01001000 + .byte $7D,%11101001 + .byte $33,%00100110 + .byte $25,%11100101 + .byte $27,%10100111 + .byte $29,%00001000 + .byte $29,%00101000 + .byte $31,%10101101 + .byte $9B,%00100110 + .byte $99,%01000110 + .byte $8F,%11100111 + .byte $8B,%00001000 + .byte $81,%10101001 + .byte $79,%00001010 + .byte $43,%01001000 + .byte $39,%10100111 + .byte $23,%00100100 + .byte $25,%11000101 + .byte $25,%00000110 + .byte $27,%10000111; + .byte $27,%01100110 + .byte $2B,%11001001 + .byte $2B,%11101001 + .byte $2D,%01001010 + .byte $2D,%10001011; + .byte $2D,%01101010 + .byte $2F,%00001100 + .byte $2F,%00101100 + .byte $9B,%11001001 + .byte $9D,%01001000 + .byte $89,%00101000 + .byte $7F,%11001001 + .byte $77,%00101010 + .byte $A5,%11000101 + .byte $29,%10000101; + .byte $29,%01100100 + .byte $27,%11100101 + .byte $29,%10100111 + .byte $29,%11000111 + .byte $2B,%01001000 + .byte $2F,%11001011 + .byte $2F,%11101011 + .byte $95,%10100111 + .byte $93,%11000111 + .byte $91,%11100111 + .byte $8D,%00001000 + .byte $89,%01001000 + .byte $83,%10101001 + .byte $25,%10000101; + .byte $25,%01100100 + .byte $2D,%00001010 + .byte $2D,%00101010 + .byte $31,%01001100 + .byte $31,%10001101; + .byte $31,%01101100 + .byte $99,%10001011; + .byte $99,%01101010 + .byte $A1,%10100111 + .byte $A3,%11100101 + .byte $9B,%01000110 + .byte $99,%10000111; + .byte $99,%01100110 + .byte $8B,%00101000 + .byte $81,%11001001 + .byte $7B,%00001010 + .byte $79,%00101010 + .byte $A1,%11100111 + .byte $A3,%00000110 + .byte $9D,%01000110 + .byte $9B,%10000111; + .byte $9B,%01100110 + .byte $99,%10100111 + .byte $35,%00100110 + .byte $31,%11100101 + .byte $2F,%11000101 + .byte $27,%10100101 + .byte $29,%01000110 + .byte $2B,%00101000 + .byte $8B,%01001000 + .byte $85,%10101001 + .byte $45,%01001000 + .byte $3D,%11000111 + .byte $3B,%10100111 + .byte $27,%10000101; + .byte $27,%01100100 + .byte $27,%11000101 + .byte $29,%00100110 + .byte $2B,%00001000 + .byte $2F,%01001010 + .byte $31,%00001100 + .byte $31,%00101100 + .byte $A1,%00100110 + .byte $95,%11000111 + .byte $93,%11100111 + .byte $8D,%00101000 + .byte $89,%10001001; + .byte $89,%01101000 + .byte $83,%11001001 + .byte $7F,%11101001 + .byte $7D,%00001010 + .byte $7B,%00101010 + .byte $A3,%00100110 + .byte $A1,%01000110 + .byte $95,%11100111 + .byte $93,%00001000 + .byte $8F,%00101000 + .byte $27,%00000100 + .byte $29,%10100101 + .byte $29,%11100101 + .byte $2B,%01000110 + .byte $2D,%01001000 + .byte $33,%10101101 + .byte $9D,%11101001 + .byte $A5,%00000110 + .byte $9D,%10000111; + .byte $9D,%01100110 + .byte $9B,%10100111 + .byte $8D,%01001000 + .byte $87,%10101001 + .byte $79,%01001010 + .byte $27,%00100100 + .byte $2B,%10100111 + .byte $2D,%00101000 + .byte $31,%10101011 + .byte $31,%11001011 + .byte $31,%11101011 + .byte $33,%10001101; + .byte $33,%01101100 + .byte $A1,%00001000 + .byte $8B,%10001001; + .byte $8B,%01101000 + .byte $85,%11001001 + .byte $81,%11101001 + .byte $7F,%00001010 + .byte $9D,%00001010 + .byte $A3,%11100111 + .byte $29,%00000100 + .byte $29,%01000100 + .byte $2D,%11000111 + .byte $2D,%11100111 + .byte $2F,%10001001; + .byte $2F,%01101000 + .byte $2F,%10101001 + .byte $2F,%11001001 + .byte $31,%00101010 + .byte $31,%01001010 + .byte $33,%01001100 + .byte $9F,%10101001 + .byte $A3,%01000110 + .byte $95,%00001000 + .byte $89,%10101001 + .byte $83,%11101001 + .byte $81,%00001010 + .byte $7D,%00101010 + .byte $3D,%10100111 + .byte $2D,%01000100 + .byte $29,%00100100 + .byte $2B,%00100110 + .byte $2D,%10100111 + .byte $31,%10001011; + .byte $31,%01101010 + .byte $33,%00001100 + .byte $33,%00101100 + .byte $A5,%10000111; + .byte $A5,%01100110 + .byte $A7,%00100110 + .byte $9D,%10100111 + .byte $8F,%01001000 + .byte $8D,%10001001; + .byte $8D,%01101000 + .byte $87,%11001001 + .byte $7B,%01001010 + .byte $79,%10001011; + .byte $79,%01101010 + .byte $39,%00100110 + .byte $35,%11100101 + .byte $33,%11000101 + .byte $2B,%01000100 + .byte $2B,%10100101 + .byte $2D,%00000110 + .byte $2D,%01000110 + .byte $2F,%11100111 + .byte $31,%11001001 + .byte $31,%11101001 + .byte $31,%00001010 + .byte $33,%11001011 + .byte $33,%11101011 + .byte $8B,%10101001 + .byte $85,%11101001 + .byte $7F,%00101010 + .byte $45,%00101000 + .byte $3F,%10100111 + .byte $2D,%00100110 + .byte $2F,%00101000 + .byte $A7,%01000110 + .byte $A5,%01000110 + .byte $A3,%10000111; + .byte $A3,%01100110 + .byte $9D,%11000111 + .byte $97,%00001000 + .byte $95,%00101000 + .byte $91,%01001000 + .byte $8F,%10001001; + .byte $8F,%01101000 + .byte $89,%11001001 + .byte $83,%00001010 + .byte $7D,%01001010 + .byte $A3,%01001000 + .byte $A5,%11100111 + .byte $A7,%10100111 + .byte $9D,%11100111 + .byte $8D,%10101001 + .byte $2D,%10100101 + .byte $2F,%10000111; + .byte $2F,%01100110 + .byte $35,%10001101; + .byte $35,%01101100 + .byte $95,%11001101 + .byte $87,%11101001 + .byte $4D,%11001001 + .byte $2F,%10100111 + .byte $2F,%11000111 + .byte $31,%01001000 + .byte $31,%10001001; + .byte $31,%01101000 + .byte $31,%10101001 + .byte $33,%00101010 + .byte $33,%01001010 + .byte $33,%10001011; + .byte $33,%01101010 + .byte $33,%10101011 + .byte $35,%00101100 + .byte $35,%01001100 + .byte $A3,%10100111 + .byte $99,%00001000 + .byte $97,%00101000 + .byte $93,%01001000 + .byte $91,%10001001; + .byte $91,%01101000 + .byte $8B,%11001001 + .byte $85,%00001010 + .byte $81,%00101010 + .byte $7F,%01001010 + .byte $7B,%10001011; + .byte $7B,%01101010 + .byte $9F,%00101010 + .byte $A7,%11000111 + .byte $A9,%10000111; + .byte $A9,%01100110 + .byte $A3,%11000111 + .byte $99,%00101000 + .byte $89,%11101001 + .byte $79,%10101011 + .byte $3B,%00100110 + .byte $2F,%00100100 + .byte $2D,%00000100 + .byte $2F,%00000110 + .byte $31,%11100111 + .byte $31,%00001000 + .byte $35,%00001100 + .byte $A1,%11001001 + .byte $9F,%11100111 + .byte $9D,%00001000 + .byte $93,%10001001; + .byte $93,%01101000 + .byte $91,%10101001 + .byte $31,%01000100 + .byte $2F,%11100101 + .byte $31,%11000111 + .byte $33,%11001001 + .byte $33,%11101001 + .byte $33,%00001010 + .byte $35,%11001011 + .byte $35,%11101011 + .byte $A3,%10001001; + .byte $A3,%01101000 + .byte $8D,%11001001 + .byte $87,%00001010 + .byte $83,%00101010 + .byte $81,%01001010 + .byte $7D,%10001011; + .byte $7D,%01101010 + .byte $A9,%10100111 + .byte $8B,%11101001 + .byte $41,%10100111 + .byte $37,%11000101 + .byte $31,%00100100 + .byte $2F,%00000100 + .byte $2F,%01000100 + .byte $31,%00000110 + .byte $31,%10000111; + .byte $31,%01100110 + .byte $35,%10001011; + .byte $35,%01101010 + .byte $35,%10101011 + .byte $A7,%00001000 + .byte $A5,%11000111 + .byte $99,%01001000 + .byte $95,%10001001; + .byte $95,%01101000 + .byte $93,%10101001 + .byte $83,%01001010 + .byte $31,%01000110 + .byte $33,%10001001; + .byte $33,%01101000 + .byte $35,%00101010 + .byte $35,%01001010 + .byte $37,%01001100 + .byte $37,%10001101; + .byte $37,%01101100 + .byte $A7,%11100111 + .byte $9F,%00001000 + .byte $9D,%00101000 + .byte $8F,%11001001 + .byte $89,%00001010 + .byte $85,%00101010 + .byte $7F,%10001011; + .byte $7F,%01101010 + .byte $7B,%10101011 + .byte $A7,%00101000 + .byte $8F,%11101001 + .byte $85,%01001010 + .byte $47,%00001000 + .byte $33,%10000111; + .byte $33,%01100110 + .byte $37,%11101011 + .byte $A3,%00001000 + .byte $87,%00101010 + .byte $33,%11000111 + .byte $33,%11100111 + .byte $35,%10101001 + .byte $35,%11001001 + .byte $35,%11101001 + .byte $35,%00001010 + .byte $37,%11001011 + .byte $37,%00001100 + .byte $37,%00101100 + .byte $9F,%00101000 + .byte $99,%10001001; + .byte $99,%01101000 + .byte $95,%10101001 + .byte $91,%11001001 + .byte $8B,%00001010 + .byte $81,%10001011; + .byte $81,%01101010 + .byte $7D,%10101011 + .byte $9F,%01001000 + .byte $95,%11001001 + .byte $8B,%00101010 + .byte $89,%00101010 + .byte $3F,%00100110 + .byte $31,%00000100 + .byte $33,%00000110 + .byte $35,%00001000 + .byte $35,%00101000 + .byte $37,%01001010 + .byte $37,%10001011; + .byte $37,%01101010 + .byte $9F,%10101011 + .byte $A9,%11100111 + .byte $7B,%11001011 + .byte $4D,%10001001; + .byte $4D,%01101000 + .byte $47,%11100111 + .byte $33,%11100101 + .byte $35,%11100111 + .byte $37,%10101011 + .byte $A1,%01001010 + .byte $A5,%10101001 + .byte $A5,%00001000 + .byte $9B,%10001001; + .byte $9B,%01101000 + .byte $97,%10101001 + .byte $91,%11101001 + .byte $8D,%00001010 + .byte $87,%01001010 + .byte $83,%10001011; + .byte $83,%01101010 + .byte $7F,%10101011 + .byte $9D,%10001001; + .byte $9D,%01101000 + .byte $9B,%10101001 + .byte $3B,%11000101 + .byte $39,%10100101 + .byte $35,%00100100 + .byte $33,%00000100 + .byte $33,%01000100 + .byte $35,%10000111; + .byte $35,%01100110 + .byte $A5,%11001001 + .byte $A9,%00001000 + .byte $A1,%01001000 + .byte $9F,%10001001; + .byte $9F,%01101000 + .byte $93,%11101001 + .byte $8F,%00001010 + .byte $81,%10101011 + .byte $49,%00001000 + .byte $43,%10000111; + .byte $43,%01100110 + .byte $35,%01000110 + .byte $35,%11000111 + .byte $37,%11001001 + .byte $37,%11101001 + .byte $39,%00001100 + .byte $39,%00101100 + .byte $39,%01001100 + .byte $39,%10001101; + .byte $39,%01101100 + .byte $A5,%00101000 + .byte $97,%11001001 + .byte $8D,%00101010 + .byte $89,%01001010 + .byte $85,%10001011; + .byte $85,%01101010 + .byte $7D,%11001011 + .byte $7B,%11101011 + .byte $A9,%01001000 + .byte $A5,%01001000 + .byte $99,%11001001 + .byte $95,%11101001 + .byte $35,%01000100 + .byte $37,%00001000 + .byte $37,%00101000 + .byte $37,%01001000 + .byte $39,%00101010 + .byte $39,%01001010 + .byte $39,%11001011 + .byte $39,%11101011 + .byte $9D,%10101001 + .byte $97,%11101001 + .byte $93,%00001010 + .byte $7F,%11001011 + .byte $4D,%01001000 + .byte $45,%10100111 + .byte $35,%10100101 + .byte $37,%11000111 + .byte $37,%11100111 + .byte $39,%10001011; + .byte $39,%01101010 + .byte $39,%10101011 + .byte $A3,%00101010 + .byte $A9,%00101000 + .byte $A1,%10001001; + .byte $A1,%01101000 + .byte $8F,%00101010 + .byte $8B,%01001010 + .byte $87,%10001011; + .byte $87,%01101010 + .byte $83,%10101011 + .byte $7D,%11101011 + .byte $A1,%11001011 + .byte $AB,%00101000 + .byte $89,%10001011; + .byte $89,%01101010 + .byte $49,%11100111 + .byte $37,%00000110 + .byte $37,%10000111; + .byte $37,%01100110 + .byte $39,%01001000 + .byte $39,%00001010 + .byte $A9,%10101001 + .byte $A7,%01001000 + .byte $A5,%10001001; + .byte $A5,%01101000 + .byte $9D,%11001001 + .byte $99,%11101001 + .byte $8D,%01001010 + .byte $85,%10101011 + .byte $83,%11001011 + .byte $45,%10000111; + .byte $45,%01100110 + .byte $37,%11100101 + .byte $37,%01000110 + .byte $3B,%01001100 + .byte $3B,%10001101; + .byte $3B,%01101100 + .byte $A9,%10001001; + .byte $A9,%01101000 + .byte $A1,%10101001 + .byte $95,%00001010 + .byte $91,%00101010 + .byte $81,%11001011 + .byte $7F,%11101011 + .byte $7B,%00001100 + .byte $A3,%10101001 + .byte $91,%01001010 + .byte $8F,%01001010 + .byte $3F,%11000101 + .byte $37,%00000100 + .byte $39,%10000111; + .byte $39,%01100110 + .byte $39,%00001000 + .byte $39,%00101000 + .byte $3B,%10101011 + .byte $3B,%00001100 + .byte $A5,%01001010 + .byte $9B,%11101001 + .byte $97,%00001010 + .byte $4D,%00101000 + .byte $3B,%01000100 + .byte $39,%00100100 + .byte $39,%01000110 + .byte $39,%11000111 + .byte $39,%11100111 + .byte $3B,%01001010 + .byte $3B,%10001011; + .byte $3B,%01101010 + .byte $3B,%11001011 + .byte $3B,%11101011 + .byte $3B,%00101100 + .byte $A7,%00001010 + .byte $A7,%10001001; + .byte $A7,%01101000 + .byte $9F,%11001001 + .byte $99,%00001010 + .byte $95,%00101010 + .byte $93,%00101010 + .byte $8D,%10001011; + .byte $8D,%01101010 + .byte $8B,%10001011; + .byte $8B,%01101010 + .byte $89,%10101011 + .byte $87,%10101011 + .byte $85,%11001011 + .byte $81,%11101011 + .byte $7D,%00001100 + .byte $A3,%10101011 + .byte $93,%01001010 + .byte $39,%00000100 + .byte $39,%01000100 + .byte $3B,%00101000 + .byte $3B,%01001000 + .byte $3B,%10001001; + .byte $3B,%01101000 + .byte $3B,%10101001 + .byte $3B,%11001001 + .byte $3B,%11101001 + .byte $3B,%00001010 + .byte $3B,%00101010 + .byte $9B,%11001101 + .byte $AB,%10001001; + .byte $AB,%01101000 + .byte $A3,%11001001 + .byte $8B,%10101011 + .byte $15,%11010011 + .byte $43,%00000110 + .byte $39,%11100101 + .byte $99,%00001110 + .byte $A7,%10101001 + .byte $9F,%11101001 + .byte $9B,%00001010 + .byte $97,%00101010 + .byte $8F,%10001011; + .byte $8F,%01101010 + .byte $87,%11001011 + .byte $83,%11101011 + .byte $7F,%00001100 + .byte $7B,%00101100 + .byte $11,%11110011 + .byte $AB,%11001001 + .byte $A1,%11101001 + .byte $9F,%00001010 + .byte $9B,%00101010 + .byte $95,%01001010 + .byte $3B,%00000110 + .byte $3B,%10000111; + .byte $3B,%01100110 + .byte $3D,%10101011 + .byte $3D,%00101100 + .byte $AB,%10101001 + .byte $A3,%11101001 + .byte $8D,%10101011 + .byte $3B,%00100100 + .byte $3B,%11100101 + .byte $3B,%01000110 + .byte $3B,%11000111 + .byte $3B,%11100111 + .byte $3D,%11001011 + .byte $3D,%11101011 + .byte $3D,%00001100 + .byte $3D,%01001100 + .byte $3D,%10001101; + .byte $3D,%01101100 + .byte $A7,%11001001 + .byte $99,%00101010 + .byte $91,%10001011; + .byte $91,%01101010 + .byte $89,%11001011 + .byte $85,%11101011 + .byte $81,%00001100 + .byte $7D,%00101100 + .byte $A7,%11101001 + .byte $9D,%00101010 + .byte $99,%01001010 + .byte $47,%01000110 + .byte $3F,%10000101; + .byte $3F,%01100100 + .byte $3B,%00000100 + .byte $3D,%00101000 + .byte $3D,%01001000 + .byte $3D,%10001001; + .byte $3D,%01101000 + .byte $3D,%10101001 + .byte $3D,%11001001 + .byte $3D,%11101001 + .byte $3D,%00001010 + .byte $A1,%00001010 + .byte $95,%10001011; + .byte $95,%01101010 + .byte $3D,%11100111 + .byte $3D,%00001000 + .byte $3D,%00101010 + .byte $3D,%01001010 + .byte $3D,%10001011; + .byte $3D,%01101010 + .byte $A1,%00101100 + .byte $A9,%00101010 + .byte $A5,%11101001 + .byte $91,%10101011 + .byte $8F,%10101011 + .byte $8B,%11001011 + .byte $87,%11101011 + .byte $83,%00001100 + .byte $7F,%00101100 + .byte $9B,%01001010 + .byte $4B,%10100111 + .byte $3D,%01000100 + .byte $3D,%10100101 + .byte $3D,%00000110 + .byte $3D,%10000111; + .byte $3D,%01100110 + .byte $A3,%00001100 + .byte $A9,%01001010 + .byte $A9,%11101001 + .byte $A1,%00101010 + .byte $9D,%01001010 + .byte $97,%10001011; + .byte $97,%01101010 + .byte $8F,%11001011 + .byte $8D,%11001011 + .byte $8B,%11101011 + .byte $0B,%11110011 + .byte $53,%10001001; + .byte $53,%01101000 + .byte $4F,%00001000 + .byte $43,%11000101 + .byte $3D,%00100100 + .byte $3D,%10000101; + .byte $3D,%01100100 + .byte $3D,%11100101 + .byte $3D,%01000110 + .byte $3F,%01001100 + .byte $3F,%10001101; + .byte $3F,%01101100 + .byte $AB,%00001010 + .byte $AB,%11101001 + .byte $A5,%00001010 + .byte $93,%10101011 + .byte $89,%11101011 + .byte $85,%00001100 + .byte $81,%00101100 + .byte $7D,%01001100 + .byte $AD,%11101001 + .byte $A5,%00101010 + .byte $3F,%00000110 + .byte $3F,%10000111; + .byte $3F,%01100110 + .byte $3F,%00001000 + .byte $3F,%00101000 + .byte $3F,%01001000 + .byte $3F,%10001001; + .byte $3F,%01101000 + .byte $3F,%10101001 + .byte $3F,%11001001 + .byte $3F,%11101001 + .byte $3F,%00001010 + .byte $3F,%10001011; + .byte $3F,%01101010 + .byte $3F,%11101011 + .byte $A7,%10101011 + .byte $A9,%00001010 + .byte $9F,%01001010 + .byte $9B,%10001011; + .byte $9B,%01101010 + .byte $95,%10101011 + .byte $91,%11001011 + .byte $43,%10100101 + .byte $3F,%00100100 + .byte $3F,%11100101 + .byte $3F,%01000110 + .byte $3F,%11000111 + .byte $3F,%11100111 + .byte $3F,%00101010 + .byte $3F,%01001010 + .byte $3F,%10101011 + .byte $3F,%11001011 + .byte $3F,%00001100 + .byte $3F,%00101100 + .byte $9D,%11101101 + .byte $97,%10101011 + .byte $8D,%11101011 + .byte $87,%00001100 + .byte $83,%00101100 + .byte $7F,%01001100 + .byte $0D,%11010011 + .byte $9B,%00101110 + .byte $AD,%00001010 + .byte $49,%00100110 + .byte $41,%01000100 + .byte $9D,%10001011; + .byte $9D,%01101010 + .byte $53,%01001000 + .byte $43,%10000101; + .byte $43,%01100100 + .byte $A1,%10001101; + .byte $A1,%01101100 + .byte $A9,%10001011; + .byte $A9,%01101010 + .byte $A3,%01001010 + .byte $9F,%10001011; + .byte $9F,%01101010 + .byte $9B,%10101011 + .byte $99,%10101011 + .byte $95,%11001011 + .byte $93,%11001011 + .byte $8F,%11101011 + .byte $8B,%00001100 + .byte $89,%00001100 + .byte $85,%00101100 + .byte $81,%01001100 + .byte $07,%11110011 + .byte $A3,%10001011; + .byte $A3,%01101010 + .byte $8F,%00001100 + .byte $17,%01010010 + .byte $09,%11010011 + .byte $49,%00000110 + .byte $43,%01000100 + .byte $41,%10100101 + .byte $41,%11100101 + .byte $41,%01000110 + .byte $41,%10000111; + .byte $41,%01100110 + .byte $41,%00001000 + .byte $41,%00101000 + .byte $41,%01001000 + .byte $41,%10001001; + .byte $41,%01101000 + .byte $41,%10101001 + .byte $41,%11001001 + .byte $41,%11101001 + .byte $41,%00001010 + .byte $41,%10001011; + .byte $41,%01101010 + .byte $A3,%01001100 + .byte $A7,%01001010 + .byte $93,%11101011 + .byte $8D,%00001100 + .byte $7D,%10001101; + .byte $7D,%01101100 + .byte $13,%10010011; + .byte $13,%01110010 + .byte $03,%11110011 + .byte $41,%10000101; + .byte $41,%01100100 + .byte $41,%11000101 + .byte $41,%00100110 + .byte $41,%11000111 + .byte $41,%11100111 + .byte $41,%00101010 + .byte $41,%01001010 + .byte $41,%10101011 + .byte $41,%11001011 + .byte $41,%11101011 + .byte $41,%00001100 + .byte $41,%00101100 + .byte $41,%01001100 + .byte $41,%10001101; + .byte $41,%01101100 + .byte $41,%10101101 + .byte $AD,%00101010 + .byte $AB,%00101010 + .byte $A1,%10001011; + .byte $A1,%01101010 + .byte $9D,%10101011 + .byte $99,%11001011 + .byte $97,%11001011 + .byte $89,%00101100 + .byte $87,%00101100 + .byte $83,%01001100 + .byte $AB,%01001010 + .byte $A5,%10001011; + .byte $A5,%01101010 + .byte $9D,%11001011 + .byte $95,%11101011 + .byte $7F,%10001101; + .byte $7F,%01101100 + .byte $AB,%10101011 + .byte $A7,%10001011; + .byte $A7,%01101010 + .byte $4F,%10100111 + .byte $4D,%10000111; + .byte $4D,%01100110 + .byte $4B,%00100110 + .byte $A7,%00001100 + .byte $AD,%01001010 + .byte $A1,%10101011 + .byte $9B,%11001011 + .byte $97,%11101011 + .byte $91,%00001100 + .byte $8B,%00101100 + .byte $87,%01001100 + .byte $85,%01001100 + .byte $81,%10001101; + .byte $81,%01101100 + .byte $AB,%10001011; + .byte $AB,%01101010 + .byte $9B,%11101011 + .byte $03,%11010011 + .byte $01,%11110011 + .byte $43,%11100101 + .byte $43,%01000110 + .byte $43,%11100111 + .byte $43,%00001000 + .byte $43,%00101000 + .byte $43,%11001001 + .byte $43,%11101001 + .byte $43,%00001010 + .byte $43,%10001011; + .byte $43,%01101010 + .byte $A9,%11101011 + .byte $A5,%10101011 + .byte $95,%00001100 + .byte $93,%00001100 + .byte $8F,%00101100 + .byte $8D,%00101100 + .byte $49,%11100101 + .byte $43,%00100110 + .byte $43,%10100111 + .byte $43,%11000111 + .byte $43,%00101010 + .byte $43,%01001010 + .byte $43,%10101011 + .byte $A1,%11001101 + .byte $AD,%10001011; + .byte $AD,%01101010 + .byte $9F,%11001011 + .byte $99,%11101011 + .byte $89,%01001100 + .byte $83,%10001101; + .byte $83,%01101100 + .byte $7D,%10101101 + .byte $09,%10110011 + .byte $9F,%11101011 + .byte $99,%00001100 + .byte $0B,%10010011; + .byte $0B,%01110010 + .byte $05,%11110011 + .byte $51,%11000111 + .byte $45,%00100100 + .byte $45,%10000101; + .byte $45,%01100100 + .byte $45,%11100101 + .byte $45,%01000110 + .byte $43,%00001100 + .byte $A5,%11001011 + .byte $A3,%11001011 + .byte $97,%00001100 + .byte $1D,%00010010 + .byte $05,%10110011 + .byte $45,%01000100 + .byte $45,%11000101 + .byte $45,%00000110 + .byte $45,%00100110 + .byte $43,%11001011 + .byte $43,%11101011 + .byte $43,%00101100 + .byte $43,%01001100 + .byte $43,%10001101; + .byte $43,%01101100 + .byte $43,%10101101 + .byte $A9,%10101011 + .byte $9D,%11101011 + .byte $93,%00101100 + .byte $91,%00101100 + .byte $8D,%01001100 + .byte $8B,%01001100 + .byte $87,%10001101; + .byte $87,%01101100 + .byte $85,%10001101; + .byte $85,%01101100 + .byte $81,%10101101 + .byte $7F,%10101101 + .byte $01,%11010011 + .byte $9D,%00001100 + .byte $9B,%00001100 + .byte $45,%11000111 + .byte $45,%11100111 + .byte $45,%00001000 + .byte $45,%11101001 + .byte $45,%00001010 + .byte $AD,%10101011 + .byte $A3,%11101011 + .byte $A1,%11101011 + .byte $97,%00101100 + .byte $91,%01001100 + .byte $89,%10001101; + .byte $89,%01101100 + .byte $0D,%01010010 + .byte $01,%10110011 + .byte $57,%10001001; + .byte $57,%01101000 + .byte $47,%01000100 + .byte $45,%10001001; + .byte $45,%01101000 + .byte $45,%10101001 + .byte $9B,%10101111 + .byte $A9,%11001011 + .byte $A7,%11001011 + .byte $95,%00101100 + .byte $8F,%01001100 + .byte $83,%10101101 + .byte $7D,%11001101 + .byte $05,%11010011 + .byte $09,%11110011 + .byte $05,%10010011; + .byte $05,%01110010 + .byte $03,%10110011 + .byte $0D,%11110011 + .byte $5D,%00101010 + .byte $57,%01001000 + .byte $4D,%00000110 + .byte $49,%10000101; + .byte $49,%01100100 + .byte $47,%11000101 + .byte $47,%00100110 + .byte $47,%11000111 + .byte $45,%10001011; + .byte $45,%01101010 + .byte $45,%00001100 + .byte $AD,%11001011 + .byte $A5,%11101011 + .byte $A1,%00001100 + .byte $9F,%00001100 + .byte $9B,%00101100 + .byte $99,%00101100 + .byte $8D,%10001101; + .byte $8D,%01101100 + .byte $8B,%10001101; + .byte $8B,%01101100 + .byte $87,%10101101 + .byte $07,%11010011 + .byte $4F,%01000110 + .byte $47,%10100101 + .byte $47,%00000110 + .byte $47,%10000111; + .byte $47,%01100110 + .byte $47,%10100111 + .byte $45,%00101010 + .byte $45,%01001010 + .byte $45,%10101011 + .byte $45,%11001011 + .byte $45,%11101011 + .byte $A1,%00001110 + .byte $A5,%10101101 + .byte $A7,%10001101; + .byte $A7,%01101100 + .byte $A9,%01001100 + .byte $A7,%11101011 + .byte $95,%01001100 + .byte $93,%01001100 + .byte $85,%10101101 + .byte $7F,%11001101 + .byte $9F,%01001110 + .byte $AB,%11101011 + .byte $49,%11000101 + .byte $45,%00101100 + .byte $AB,%00101100 + .byte $AD,%11101011 + .byte $A5,%00001100 + .byte $9F,%00101100 + .byte $9D,%00101100 + .byte $99,%01001100 + .byte $91,%10001101; + .byte $91,%01101100 + .byte $81,%11001101 + .byte $07,%01010010 + .byte $07,%10110011 + .byte $55,%11100111 + .byte $53,%10100111 + .byte $49,%10100101 + .byte $47,%00101000 + .byte $47,%01001000 + .byte $47,%10001001; + .byte $47,%01101000 + .byte $47,%10101001 + .byte $47,%11001001 + .byte $47,%11101001 + .byte $45,%01001100 + .byte $45,%10001101; + .byte $45,%01101100 + .byte $45,%10101101 + .byte $97,%01001100 + .byte $8F,%10001101; + .byte $8F,%01101100 + .byte $8B,%10101101 + .byte $89,%10101101 + .byte $83,%11001101 + .byte $03,%10010011; + .byte $03,%01110010 + .byte $0B,%11010011 + .byte $0F,%11110011 + .byte $A9,%00001100 + .byte $93,%10001101; + .byte $93,%01101100 + .byte $8F,%10101101 + .byte $49,%10100111 + .byte $49,%11000111 + .byte $47,%00001010 + .byte $47,%00101010 + .byte $A5,%11101101 + .byte $AB,%00001100 + .byte $A3,%00101100 + .byte $9D,%01001100 + .byte $9B,%01001100 + .byte $03,%01010010 + .byte $0B,%10110011 + .byte $0F,%11010011 + .byte $13,%11110011 + .byte $4F,%00000110 + .byte $4D,%10100101 + .byte $49,%01000110 + .byte $49,%10000111; + .byte $49,%01100110 + .byte $47,%01001010 + .byte $47,%10001011; + .byte $47,%01101010 + .byte $47,%10101011 + .byte $47,%11001011 + .byte $A5,%00101100 + .byte $95,%10001101; + .byte $95,%01101100 + .byte $8D,%10101101 + .byte $87,%11001101 + .byte $85,%11001101 + .byte $7F,%11101101 + .byte $7D,%11101101 + .byte $13,%00010010 + .byte $07,%10010011; + .byte $07,%01110010 + .byte $A9,%00101100 + .byte $07,%00110010 + .byte $4B,%10100101 + .byte $4B,%00000110 + .byte $47,%00001100 + .byte $A1,%01001100 + .byte $9F,%01001100 + .byte $9B,%10001101; + .byte $9B,%01101100 + .byte $97,%10001101; + .byte $97,%01101100 + .byte $93,%10101101 + .byte $8B,%11001101 + .byte $09,%10010011; + .byte $09,%01110010 + .byte $0D,%10110011 + .byte $11,%11010011 + .byte $15,%11110011 + .byte $5D,%11101001 + .byte $4F,%11100101 + .byte $4B,%10000101; + .byte $4B,%01100100 + .byte $4B,%11100101 + .byte $49,%00101000 + .byte $49,%01001000 + .byte $49,%10001001; + .byte $49,%01101000 + .byte $49,%10101001 + .byte $49,%11001001 + .byte $47,%11101011 + .byte $47,%00101100 + .byte $47,%01001100 + .byte $A1,%01001110 + .byte $A7,%00101100 + .byte $99,%10001101; + .byte $99,%01101100 + .byte $91,%10101101 + .byte $89,%11001101 + .byte $83,%11101101 + .byte $81,%11101101 + .byte $05,%01010010 + .byte $09,%01010010 + .byte $0F,%10110011 + .byte $53,%01000110 + .byte $4B,%10000111; + .byte $4B,%01100110 + .byte $49,%00101010 + .byte $AD,%00101100 + .byte $9F,%10001101; + .byte $9F,%01101100 + .byte $9D,%10001101; + .byte $9D,%01101100 + .byte $8F,%11001101 + .byte $17,%11110011 + .byte $4D,%10000101; + .byte $4D,%01100100 + .byte $4B,%01000110 + .byte $4B,%11000111 + .byte $4B,%11100111 + .byte $4B,%00001000 + .byte $49,%11101001 + .byte $49,%00001010 + .byte $49,%01001010 + .byte $49,%10001011; + .byte $49,%01101010 + .byte $47,%10001101; + .byte $47,%01101100 + .byte $47,%10101101 + .byte $A9,%11001101 + .byte $A7,%01001100 + .byte $A5,%01001100 + .byte $97,%10101101 + .byte $95,%10101101 + .byte $8D,%11001101 + .byte $87,%11101101 + .byte $85,%11101101 + .byte $7D,%00001110 + .byte $05,%00110010 + .byte $0D,%10010011; + .byte $0D,%01110010 + .byte $11,%10110011 + .byte $13,%11010011 + .byte $09,%00010010 + .byte $19,%11110011 + .byte $1B,%11110011 + .byte $53,%00100110 + .byte $4F,%10100101 + .byte $4D,%11100101 + .byte $4D,%01000110 + .byte $4B,%00101000 + .byte $4B,%01001000 + .byte $4B,%10001001; + .byte $4B,%01101000 + .byte $4B,%10101001 + .byte $49,%10101011 + .byte $A5,%00101110 + .byte $AB,%10101101 + .byte $AD,%01001100 + .byte $AB,%01001100 + .byte $A3,%10001101; + .byte $A3,%01101100 + .byte $9D,%10101101 + .byte $99,%10101101 + .byte $93,%11001101 + .byte $05,%00010010 + .byte $55,%10000111; + .byte $55,%01100110 + .byte $4D,%00100110 + .byte $4B,%11001001 + .byte $49,%11001011 + .byte $49,%11101011 + .byte $A5,%10001101; + .byte $A5,%01101100 + .byte $9B,%10101101 + .byte $91,%11001101 + .byte $8B,%11101101 + .byte $89,%11101101 + .byte $81,%00001110 + .byte $7F,%00001110 + .byte $09,%00110010 + .byte $0B,%01010010 + .byte $0F,%10010011; + .byte $0F,%01110010 + .byte $13,%10110011 + .byte $17,%11010011 + .byte $A9,%10001101; + .byte $A9,%01101100 + .byte $0F,%01010010 + .byte $4F,%10000101; + .byte $4F,%01100100 + .byte $4D,%11100111 + .byte $4D,%00001000 + .byte $AB,%10001101; + .byte $AB,%01101100 + .byte $A1,%10101101 + .byte $9F,%10101101 + .byte $0B,%11110001 + .byte $0B,%00110010 + .byte $11,%10010011; + .byte $11,%01110010 + .byte $15,%10110011 + .byte $4F,%11000101 + .byte $4D,%10100111 + .byte $4D,%11000111 + .byte $4B,%11101001 + .byte $4B,%00001010 + .byte $4B,%00101010 + .byte $49,%00001100 + .byte $49,%00101100 + .byte $49,%01001100 + .byte $A3,%10101101 + .byte $99,%11001101 + .byte $97,%11001101 + .byte $8F,%11101101 + .byte $8D,%11101101 + .byte $85,%00001110 + .byte $83,%00001110 + .byte $0D,%11110001 + .byte $07,%00010010 + .byte $19,%11010011 + .byte $A9,%10101101 + .byte $0B,%00010010 + .byte $0D,%00110010 + .byte $5B,%01001000 + .byte $57,%10100111 + .byte $4F,%00100110 + .byte $4D,%10101001 + .byte $4B,%01001010 + .byte $9F,%11001101 + .byte $9D,%11001101 + .byte $95,%11101101 + .byte $87,%00001110 + .byte $1B,%10110001 + .byte $07,%11110001 + .byte $17,%10110011 + .byte $1D,%11110011 + .byte $1F,%11110011 + .byte $55,%00100110 + .byte $4F,%10000111; + .byte $4F,%01100110 + .byte $4B,%10001011; + .byte $4B,%01101010 + .byte $4B,%10101011 + .byte $49,%10001101; + .byte $49,%01101100 + .byte $49,%10101101 + .byte $9B,%00110000 + .byte $A7,%00101110 + .byte $A7,%10101101 + .byte $93,%11101101 + .byte $91,%11101101 + .byte $8B,%00001110 + .byte $89,%00001110 + .byte $7F,%00101110 + .byte $7D,%00101110 + .byte $11,%01010010 + .byte $15,%10010011; + .byte $15,%01110010 + .byte $1B,%11010011 + .byte $81,%00101110 + .byte $0B,%11010001 + .byte $09,%11110001 + .byte $19,%10110011 + .byte $53,%11000101 + .byte $51,%11000101 + .byte $4F,%11000111 + .byte $4F,%11100111 + .byte $4D,%11101001 + .byte $AD,%10101101 + .byte $0D,%11010001 + .byte $11,%00110010 + .byte $21,%11110011 + .byte $55,%00000110 + .byte $51,%10100101 + .byte $51,%00000110 + .byte $4F,%00101000 + .byte $4D,%00001010 + .byte $4B,%11001011 + .byte $4B,%11101011 + .byte $4B,%00001100 + .byte $49,%11001101 + .byte $A7,%11001101 + .byte $A5,%11001101 + .byte $A3,%11001101 + .byte $9B,%11101101 + .byte $99,%11101101 + .byte $97,%11101101 + .byte $91,%00001110 + .byte $8F,%00001110 + .byte $8D,%00001110 + .byte $85,%00101110 + .byte $83,%00101110 + .byte $19,%10110001 + .byte $0D,%00010010 + .byte $0F,%00110010 + .byte $13,%01010010 + .byte $17,%10010011; + .byte $17,%01110010 + .byte $1D,%11010011 + .byte $A5,%10001111; + .byte $A5,%01101110 + .byte $AB,%11001101 + .byte $13,%10110001 + .byte $13,%00110010 + .byte $1B,%10110011 + .byte $53,%10100101 + .byte $51,%10100111 + .byte $4D,%10001011; + .byte $4D,%01101010 + .byte $AD,%11001101 + .byte $A3,%11101101 + .byte $A1,%11101101 + .byte $9F,%11101101 + .byte $95,%00001110 + .byte $0F,%00010010 + .byte $15,%01010010 + .byte $51,%01000110 + .byte $51,%10000111; + .byte $51,%01100110 + .byte $4F,%01001000 + .byte $4F,%10001001; + .byte $4F,%01101000 + .byte $4F,%10101001 + .byte $4D,%00101010 + .byte $4D,%01001010 + .byte $4B,%00101100 + .byte $4B,%01001100 + .byte $97,%00001110 + .byte $93,%00001110 + .byte $8B,%00101110 + .byte $89,%00101110 + .byte $87,%00101110 + .byte $7D,%01001110 + .byte $11,%10110001 + .byte $0F,%10110001 + .byte $09,%11010001 + .byte $19,%10010011; + .byte $19,%01110010 + .byte $1F,%11010011 + .byte $AB,%11101101 + .byte $11,%00010010 + .byte $1D,%10110011 + .byte $57,%00100110 + .byte $53,%00000110 + .byte $4F,%00001010 + .byte $4D,%11001011 + .byte $AD,%11101101 + .byte $9F,%00001110 + .byte $9D,%00001110 + .byte $8D,%00101110 + .byte $09,%10110001 + .byte $59,%10000111; + .byte $59,%01100110 + .byte $53,%11100101 + .byte $51,%11100111 + .byte $51,%00001000 + .byte $51,%00101000 + .byte $4F,%11001001 + .byte $4F,%11101001 + .byte $4D,%10101011 + .byte $4D,%11101011 + .byte $4B,%10001101; + .byte $4B,%01101100 + .byte $4B,%10101101 + .byte $A9,%11101101 + .byte $A7,%11101101 + .byte $9B,%00001110 + .byte $91,%00101110 + .byte $8F,%00101110 + .byte $83,%01001110 + .byte $81,%01001110 + .byte $7F,%01001110 + .byte $0F,%11110001 + .byte $15,%00110010 + .byte $1B,%10010011; + .byte $1B,%01110010 + .byte $21,%11010011 + .byte $23,%11110011 + .byte $A3,%11001111 + .byte $19,%01010010 + .byte $1F,%10110011 + .byte $25,%11110011 + .byte $5B,%11000111 + .byte $55,%11100101 + .byte $53,%10000111; + .byte $53,%01100110 + .byte $51,%01001000 + .byte $51,%10001001; + .byte $51,%01101000 + .byte $4F,%00101010 + .byte $A7,%10001111; + .byte $A7,%01101110 + .byte $AD,%00001110 + .byte $A3,%00001110 + .byte $95,%00101110 + .byte $93,%00101110 + .byte $0F,%11010001 + .byte $11,%11110001 + .byte $15,%00010010 + .byte $55,%11000101 + .byte $53,%11000111 + .byte $4F,%01001010 + .byte $4D,%00001100 + .byte $4B,%11001101 + .byte $A9,%00001110 + .byte $A7,%00001110 + .byte $A5,%00001110 + .byte $99,%00101110 + .byte $97,%00101110 + .byte $8B,%01001110 + .byte $89,%01001110 + .byte $87,%01001110 + .byte $85,%01001110 + .byte $15,%10010001; + .byte $15,%01110000 + .byte $0B,%10110001 + .byte $17,%00110010 + .byte $1D,%10010011; + .byte $1D,%01110010 + .byte $23,%11010011 + .byte $A5,%11001111 + .byte $11,%11010001 + .byte $13,%11110001 + .byte $17,%00010010 + .byte $1B,%01010010 + .byte $57,%11100101 + .byte $55,%01000110 + .byte $53,%11100111 + .byte $53,%00001000 + .byte $53,%00101000 + .byte $51,%10101001 + .byte $51,%11001001 + .byte $4F,%10101011 + .byte $A3,%00101110 + .byte $A1,%00101110 + .byte $9F,%00101110 + .byte $9D,%00101110 + .byte $91,%01001110 + .byte $0B,%10010001; + .byte $0B,%01110000 + .byte $0D,%10110001 + .byte $21,%10110011 + .byte $25,%11010011 + .byte $5F,%01001000 + .byte $5D,%00001000 + .byte $51,%11101001 + .byte $4F,%10001011; + .byte $4F,%01101010 + .byte $4D,%00101100 + .byte $4D,%01001100 + .byte $93,%01001110 + .byte $8F,%01001110 + .byte $8D,%01001110 + .byte $81,%10001111; + .byte $81,%01101110 + .byte $7F,%10001111; + .byte $7F,%01101110 + .byte $7D,%10001111; + .byte $7D,%01101110 + .byte $19,%00110010 + .byte $1F,%10010011; + .byte $1F,%01110010 + .byte $27,%11110011 + .byte $AB,%00101110 + .byte $19,%00010010 + .byte $1D,%01010010 + .byte $59,%00100110 + .byte $57,%11000101 + .byte $55,%11000111 + .byte $9D,%01001110 + .byte $95,%01001110 + .byte $1B,%00110010 + .byte $23,%10110011 + .byte $57,%00000110 + .byte $55,%10100111 + .byte $51,%00001010 + .byte $51,%00101010 + .byte $4F,%11001011 + .byte $4F,%11101011 + .byte $4D,%10001101; + .byte $4D,%01101100 + .byte $4D,%10101101 + .byte $A9,%10001111; + .byte $A9,%01101110 + .byte $AD,%00101110 + .byte $A9,%00101110 + .byte $9B,%01001110 + .byte $99,%01001110 + .byte $97,%01001110 + .byte $89,%10001111; + .byte $89,%01101110 + .byte $87,%10001111; + .byte $87,%01101110 + .byte $85,%10001111; + .byte $85,%01101110 + .byte $83,%10001111; + .byte $83,%01101110 + .byte $0D,%10010001; + .byte $0D,%01110000 + .byte $13,%11010001 + .byte $15,%11110001 + .byte $21,%10010011; + .byte $21,%01110010 + .byte $29,%11110011 + .byte $5F,%00101000 + .byte $53,%11101001 + .byte $A3,%00010000 + .byte $A5,%01001110 + .byte $A3,%01001110 + .byte $95,%10001111; + .byte $95,%01101110 + .byte $91,%10001111; + .byte $91,%01101110 + .byte $8B,%10001111; + .byte $8B,%01101110 + .byte $0D,%01010000 + .byte $0F,%10010001; + .byte $0F,%01110000 + .byte $15,%11010001 + .byte $1D,%00110010 + .byte $5B,%01000110 + .byte $57,%01000110 + .byte $57,%10000111; + .byte $57,%01100110 + .byte $55,%00001000 + .byte $55,%00101000 + .byte $53,%10101001 + .byte $53,%11001001 + .byte $51,%01001010 + .byte $51,%10001011; + .byte $51,%01101010 + .byte $4F,%00001100 + .byte $4F,%00101100 + .byte $4D,%11001101 + .byte $4D,%11101101 + .byte $A7,%11001111 + .byte $AD,%01001110 + .byte $AB,%01001110 + .byte $A9,%01001110 + .byte $A7,%01001110 + .byte $93,%10001111; + .byte $93,%01101110 + .byte $8F,%10001111; + .byte $8F,%01101110 + .byte $8D,%10001111; + .byte $8D,%01101110 + .byte $17,%11110001 + .byte $1B,%00010010 + .byte $1F,%01010010 + .byte $25,%10110011 + .byte $27,%11010011 + .byte $0F,%01010000 + .byte $11,%10010001; + .byte $11,%01110000 + .byte $17,%11010001 + .byte $59,%00000110 + .byte $53,%00001010 + .byte $A3,%10001111; + .byte $A3,%01101110 + .byte $A1,%10001111; + .byte $A1,%01101110 + .byte $9F,%10001111; + .byte $9F,%01101110 + .byte $9D,%10001111; + .byte $9D,%01101110 + .byte $9B,%10001111; + .byte $9B,%01101110 + .byte $1D,%00110000 + .byte $19,%11110001 + .byte $1F,%00110010 + .byte $61,%10001001; + .byte $61,%01101000 + .byte $59,%11100101 + .byte $57,%11000111 + .byte $57,%11100111 + .byte $55,%01001000 + .byte $55,%10001001; + .byte $55,%01101000 + .byte $53,%00101010 + .byte $51,%10101011 + .byte $51,%11001011 + .byte $4F,%01001100 + .byte $99,%10001111; + .byte $99,%01101110 + .byte $97,%10001111; + .byte $97,%01101110 + .byte $87,%10101111 + .byte $85,%10101111 + .byte $83,%10101111 + .byte $81,%10101111 + .byte $7F,%10101111 + .byte $7D,%10101111 + .byte $15,%10110001 + .byte $21,%01010010 + .byte $23,%10010011; + .byte $23,%01110010 + .byte $27,%10110011 + .byte $29,%11010011 + .byte $2B,%11110011 + .byte $A9,%11001111 + .byte $AD,%10001111; + .byte $AD,%01101110 + .byte $1B,%11110001 + .byte $21,%00110010 + .byte $5D,%10000111; + .byte $5D,%01100110 + .byte $5B,%11100101 + .byte $59,%01000110 + .byte $57,%00001000 + .byte $57,%00101000 + .byte $55,%10101001 + .byte $4F,%10001101; + .byte $4F,%01101100 + .byte $95,%10101111 + .byte $91,%10101111 + .byte $0F,%00110000 + .byte $17,%10110001 + .byte $63,%11001001 + .byte $5F,%11000111 + .byte $5B,%00000110 + .byte $59,%10100111 + .byte $55,%11001001 + .byte $53,%01001010 + .byte $53,%10001011; + .byte $53,%01101010 + .byte $51,%11101011 + .byte $51,%00001100 + .byte $4F,%10101101 + .byte $A5,%00010000 + .byte $AB,%10001111; + .byte $AB,%01101110 + .byte $99,%10101111 + .byte $97,%10101111 + .byte $93,%10101111 + .byte $8F,%10101111 + .byte $8D,%10101111 + .byte $8B,%10101111 + .byte $89,%10101111 + .byte $11,%01010000 + .byte $13,%10010001; + .byte $13,%01110000 + .byte $19,%11010001 + .byte $23,%01010010 + .byte $25,%10010011; + .byte $25,%01110010 + .byte $2D,%11110011 + .byte $AD,%10101111 + .byte $A3,%10101111 + .byte $A1,%10101111 + .byte $9F,%10101111 + .byte $21,%00010000 + .byte $11,%00110000 + .byte $13,%01010000 + .byte $63,%10101001 + .byte $5B,%00100110 + .byte $59,%11000111 + .byte $59,%11100111 + .byte $55,%11101001 + .byte $53,%10101011 + .byte $A9,%10101111 + .byte $A7,%10101111 + .byte $A5,%10101111 + .byte $9D,%10101111 + .byte $1F,%00010010 + .byte $29,%10110011 + .byte $55,%00001010 + .byte $51,%00101100 + .byte $4F,%11001101 + .byte $AB,%10101111 + .byte $7F,%11001111 + .byte $7D,%11001111 + .byte $1B,%11010001 + .byte $1D,%11110001 + .byte $25,%01010010 + .byte $27,%10010011; + .byte $27,%01110010 + .byte $2B,%11010011 + .byte $9F,%11001111 + .byte $9D,%11001111 + .byte $11,%00010000 + .byte $17,%10010001; + .byte $17,%01110000 + .byte $23,%00110010 + .byte $2F,%11110011 + .byte $5D,%00000110 + .byte $5B,%10100111 + .byte $A1,%10010001; + .byte $A1,%01110000 + .byte $A7,%00010000 + .byte $AB,%11001111 + .byte $9B,%11001111 + .byte $15,%00010000 + .byte $1D,%11010001 + .byte $21,%00010010 + .byte $2D,%11010011 + .byte $5B,%10000111; + .byte $5B,%01100110 + .byte $59,%00001000 + .byte $59,%00101000 + .byte $57,%10101001 + .byte $57,%11001001 + .byte $55,%00101010 + .byte $55,%01001010 + .byte $53,%11001011 + .byte $53,%11101011 + .byte $51,%01001100 + .byte $4F,%11101101 + .byte $A1,%11001111 + .byte $99,%11001111 + .byte $97,%11001111 + .byte $95,%11001111 + .byte $93,%11001111 + .byte $91,%11001111 + .byte $8F,%11001111 + .byte $8D,%11001111 + .byte $8B,%11001111 + .byte $89,%11001111 + .byte $87,%11001111 + .byte $85,%11001111 + .byte $83,%11001111 + .byte $81,%11001111 + .byte $17,%00010000 + .byte $13,%00110000 + .byte $15,%01010000 + .byte $1F,%11110001 + .byte $2B,%10110011 + .byte $13,%00010000 + .byte $57,%00001010 + .byte $55,%10001011; + .byte $55,%01101010 + .byte $15,%00110000 + .byte $17,%01010000 + .byte $19,%10010001; + .byte $19,%01110000 + .byte $25,%00110010 + .byte $27,%01010010 + .byte $29,%10010011; + .byte $29,%01110010 + .byte $61,%11100111 + .byte $5D,%01000110 + .byte $5B,%11100111 + .byte $59,%01001000 + .byte $59,%10001001; + .byte $59,%01101000 + .byte $57,%11101001 + .byte $53,%00001100 + .byte $51,%10001101; + .byte $51,%01101100 + .byte $51,%10101101 + .byte $21,%11110001 + .byte $23,%00010010 + .byte $31,%11110011 + .byte $A9,%11101111 + .byte $A7,%11101111 + .byte $9B,%11101111 + .byte $15,%11101111 + .byte $13,%11101111 + .byte $1F,%11010001 + .byte $2F,%11010011 + .byte $63,%00101000 + .byte $5B,%00001000 + .byte $5B,%00101000 + .byte $59,%10101001 + .byte $59,%11001001 + .byte $57,%00101010 + .byte $55,%11001011 + .byte $99,%11101111 + .byte $17,%11101111 + .byte $1B,%10010001; + .byte $1B,%01110000 + .byte $27,%00110010 + .byte $2D,%10110011 + .byte $61,%10100111 + .byte $5F,%00100110 + .byte $5D,%10100111 + .byte $5D,%11000111 + .byte $55,%10101011 + .byte $53,%00101100 + .byte $51,%11001101 + .byte $A9,%00010000 + .byte $AB,%11101111 + .byte $A5,%11101111 + .byte $A3,%11101111 + .byte $A1,%11101111 + .byte $9F,%11101111 + .byte $9D,%11101111 + .byte $97,%11101111 + .byte $95,%11101111 + .byte $93,%11101111 + .byte $91,%11101111 + .byte $8F,%11101111 + .byte $8D,%11101111 + .byte $8B,%11101111 + .byte $89,%11101111 + .byte $87,%11101111 + .byte $85,%11101111 + .byte $83,%11101111 + .byte $81,%11101111 + .byte $7F,%11101111 + .byte $7D,%11101111 + .byte $1F,%11101111 + .byte $17,%00110000 + .byte $19,%01010000 + .byte $1D,%10110001 + .byte $29,%01010010 + .byte $2B,%10010011; + .byte $2B,%01110010 + .byte $5D,%11100111 + .byte $59,%11101001 + .byte $57,%01001010 + .byte $19,%00110000 + .byte $1F,%10110001 + .byte $25,%00010010 + .byte $2D,%10010011; + .byte $2D,%01110010 + .byte $5F,%10000111; + .byte $5F,%01100110 + .byte $5B,%10001001; + .byte $5B,%01101000 + .byte $57,%10001011; + .byte $57,%01101010 + .byte $55,%11101011 + .byte $53,%01001100 + .byte $53,%10001101; + .byte $53,%01101100 + .byte $51,%11101101 + .byte $AB,%00010000 + .byte $1B,%01010000 + .byte $1D,%10010001; + .byte $1D,%01110000 + .byte $21,%11010001 + .byte $23,%11110001 + .byte $2F,%10110011 + .byte $31,%11010011 + .byte $33,%11110011 + .byte $1B,%00110000 + .byte $5F,%10100111 + .byte $59,%00001010 + .byte $55,%00001100 + .byte $99,%00010000 + .byte $97,%00010000 + .byte $93,%00010000 + .byte $8D,%00010000 + .byte $1D,%01010000 + .byte $21,%10110001 + .byte $63,%11000111 + .byte $61,%01000110 + .byte $5D,%00101000 + .byte $5B,%10101001 + .byte $5B,%11001001 + .byte $59,%00101010 + .byte $57,%10101011 + .byte $55,%00101100 + .byte $53,%10101101 + .byte $51,%00001110 + .byte $A7,%01010000 + .byte $A1,%00010000 + .byte $9F,%00010000 + .byte $9D,%00010000 + .byte $9B,%00010000 + .byte $95,%00010000 + .byte $91,%00010000 + .byte $8F,%00010000 + .byte $8B,%00010000 + .byte $89,%00010000 + .byte $15,%11001111 + .byte $1F,%10010001; + .byte $1F,%01110000 + .byte $23,%11010001 + .byte $25,%11110001 + .byte $27,%00010010 + .byte $29,%00110010 + .byte $2B,%01010010 + .byte $AB,%00110000 + .byte $65,%01001000 + .byte $61,%10000111; + .byte $61,%01100110 + .byte $5D,%01001000 + .byte $5D,%10001001; + .byte $5D,%01101000 + .byte $57,%11001011 + .byte $A3,%00110000 + .byte $A1,%00110000 + .byte $9F,%00110000 + .byte $9D,%00110000 + .byte $5F,%11100111 + .byte $5F,%00001000 + .byte $5B,%11101001 + .byte $59,%01001010 + .byte $57,%11101011 + .byte $55,%01001100 + .byte $53,%11001101 + .byte $A9,%00110000 + .byte $A7,%00110000 + .byte $A5,%00110000 + .byte $87,%00010000 + .byte $85,%00010000 + .byte $83,%00010000 + .byte $81,%00010000 + .byte $7F,%00010000 + .byte $7D,%00010000 + .byte $1D,%11001111 + .byte $19,%00010000 + .byte $27,%11110001 + .byte $29,%00010010 + .byte $2B,%00110010 + .byte $2D,%01010010 + .byte $2F,%10010011; + .byte $2F,%01110010 + .byte $31,%10110011 + .byte $33,%11010011 + .byte $35,%11110011 + .byte $17,%11001111 + .byte $19,%11101111 + .byte $1F,%01010000 + .byte $23,%10110001 + .byte $63,%01000110 + .byte $5D,%10101001 + .byte $5D,%11001001 + .byte $59,%10101011 + .byte $A9,%01010000 + .byte $97,%00110000 + .byte $8F,%00110000 + .byte $1B,%00010000 + .byte $21,%10010001; + .byte $21,%01110000 + .byte $63,%10000111; + .byte $63,%01100110 + .byte $61,%11000111 + .byte $5B,%00001010 + .byte $5B,%00101010 + .byte $59,%10001011; + .byte $59,%01101010 + .byte $57,%00001100 + .byte $55,%10001101; + .byte $55,%01101100 + .byte $53,%11101101 + .byte $99,%00110000 + .byte $95,%00110000 + .byte $93,%00110000 + .byte $91,%00110000 + .byte $8D,%00110000 + .byte $25,%11010001 + .byte $65,%11000111 + .byte $63,%10100111 + .byte $A5,%01010000 + .byte $A3,%01010000 + .byte $A1,%01010000 + .byte $9F,%01010000 + .byte $9D,%01010000 + .byte $17,%10101111 + .byte $1F,%00110000 + .byte $23,%10010001; + .byte $23,%01110000 + .byte $37,%11110011 + .byte $65,%11100111 + .byte $61,%00001000 + .byte $5F,%10001001; + .byte $5F,%01101000 + .byte $5B,%01001010 + .byte $59,%11001011 + .byte $57,%00101100 + .byte $55,%10101101 + .byte $53,%00001110 + .byte $9B,%01010000 + .byte $99,%01010000 + .byte $8B,%00110000 + .byte $89,%00110000 + .byte $87,%00110000 + .byte $85,%00110000 + .byte $83,%00110000 + .byte $1D,%10101111 + .byte $19,%11001111 + .byte $1B,%11101111 + .byte $1D,%00010000 + .byte $21,%01010000 + .byte $25,%10110001 + .byte $27,%11010001 + .byte $29,%11110001 + .byte $2B,%00010010 + .byte $2D,%00110010 + .byte $2F,%01010010 + .byte $31,%10010011; + .byte $31,%01110010 + .byte $33,%10110011 + .byte $35,%11010011 + .byte $A5,%10010001; + .byte $A5,%01110000 + .byte $A3,%10010001; + .byte $A3,%01110000 + .byte $1B,%11001111 + .byte $25,%10010001; + .byte $25,%01110000 + .byte $65,%10000111; + .byte $65,%01100110 + .byte $61,%00101000 + .byte $61,%01001000 + .byte $5F,%10101001 + .byte $A1,%11110001 + .byte $A9,%10010001; + .byte $A9,%01110000 + .byte $A7,%10010001; + .byte $A7,%01110000 + .byte $95,%01010000 + .byte $1D,%11101111 + .byte $23,%01010000 + .byte $63,%11100111 + .byte $5D,%00001010 + .byte $5B,%10001011; + .byte $5B,%01101010 + .byte $59,%11101011 + .byte $57,%01001100 + .byte $55,%11001101 + .byte $9F,%00010010 + .byte $97,%01010000 + .byte $93,%01010000 + .byte $91,%01010000 + .byte $8F,%01010000 + .byte $81,%00110000 + .byte $7F,%00110000 + .byte $7D,%00110000 + .byte $19,%10101111 + .byte $1F,%00010000 + .byte $21,%00110000 + .byte $29,%11010001 + .byte $7B,%00110000 + .byte $2D,%00010010 + .byte $63,%00001000 + .byte $5F,%11001001 + .byte $5F,%11101001 + .byte $5D,%01001010 + .byte $5B,%10101011 + .byte $9B,%10010001; + .byte $9B,%01110000 + .byte $99,%10010001; + .byte $99,%01110000 + .byte $97,%10010001; + .byte $97,%01110000 + .byte $19,%10001111; + .byte $19,%01101110 + .byte $1B,%10101111 + .byte $2F,%00110010 + .byte $39,%11110011 + .byte $67,%00001000 + .byte $65,%10100111 + .byte $59,%00001100 + .byte $57,%10001101; + .byte $57,%01101100 + .byte $55,%11101101 + .byte $53,%00101110 + .byte $A9,%10110001 + .byte $9F,%10010001; + .byte $9F,%01110000 + .byte $9D,%10010001; + .byte $9D,%01110000 + .byte $8D,%01010000 + .byte $8B,%01010000 + .byte $89,%01010000 + .byte $87,%01010000 + .byte $27,%10110001 + .byte $2B,%11110001 + .byte $31,%01010010 + .byte $33,%10010011; + .byte $33,%01110010 + .byte $35,%10110011 + .byte $37,%11010011 + .byte $A7,%10110001 + .byte $25,%01010000 + .byte $67,%10100111 + .byte $5F,%00001010 + .byte $5D,%10001011; + .byte $5D,%01101010 + .byte $5B,%11101011 + .byte $63,%01001000 + .byte $61,%10101001 + .byte $5B,%11001011 + .byte $59,%00101100 + .byte $57,%10101101 + .byte $A5,%10110001 + .byte $A3,%10110001 + .byte $A1,%10110001 + .byte $9F,%10110001 + .byte $95,%10010001; + .byte $95,%01110000 + .byte $93,%10010001; + .byte $93,%01110000 + .byte $91,%10010001; + .byte $91,%01110000 + .byte $85,%01010000 + .byte $83,%01010000 + .byte $81,%01010000 + .byte $1B,%10001111; + .byte $1B,%01101110 + .byte $23,%00110000 + .byte $27,%10010001; + .byte $27,%01110000 + .byte $29,%10110001 + .byte $2B,%11010001 + .byte $2D,%11110001 + .byte $2F,%00010010 + .byte $A9,%11010001 + .byte $1F,%11001111 + .byte $65,%00101000 + .byte $63,%10001001; + .byte $63,%01101000 + .byte $5F,%00101010 + .byte $A5,%11010001 + .byte $97,%10110001 + .byte $21,%10001111; + .byte $21,%01101110 + .byte $21,%11101111 + .byte $25,%00110000 + .byte $67,%11000111 + .byte $65,%00001000 + .byte $61,%11001001 + .byte $61,%11101001 + .byte $5D,%10101011 + .byte $59,%01001100 + .byte $55,%00001110 + .byte $A7,%11010001 + .byte $9D,%10110001 + .byte $9B,%10110001 + .byte $99,%10110001 + .byte $8F,%10010001; + .byte $8F,%01110000 + .byte $8D,%10010001; + .byte $8D,%01110000 + .byte $8B,%10010001; + .byte $8B,%01110000 + .byte $89,%10010001; + .byte $89,%01110000 + .byte $7F,%01010000 + .byte $7D,%01010000 + .byte $23,%00010000 + .byte $27,%01010000 + .byte $29,%10010001; + .byte $29,%01110000 + .byte $31,%00110010 + .byte $33,%01010010 + .byte $35,%10010011; + .byte $35,%01110010 + .byte $37,%10110011 + .byte $23,%11101111 + .byte $3B,%11110011 + .byte $67,%11100111 + .byte $5F,%01001010 + .byte $57,%11001101 + .byte $A3,%11010001 + .byte $A1,%11010001 + .byte $9F,%11010001 + .byte $9D,%11010001 + .byte $1D,%10001111; + .byte $1D,%01101110 + .byte $1F,%10101111 + .byte $25,%00010000 + .byte $39,%11010011 + .byte $61,%00001010 + .byte $5D,%11001011 + .byte $5B,%00001100 + .byte $59,%10001101; + .byte $59,%01101100 + .byte $55,%00101110 + .byte $95,%10110001 + .byte $93,%10110001 + .byte $91,%10110001 + .byte $87,%10010001; + .byte $87,%01110000 + .byte $85,%10010001; + .byte $85,%01110000 + .byte $7B,%01010000 + .byte $29,%10001111; + .byte $29,%01101110 + .byte $21,%11001111 + .byte $2B,%10110001 + .byte $2D,%11010001 + .byte $2F,%11110001 + .byte $31,%00010010 + .byte $A3,%11110001 + .byte $27,%00110000 + .byte $69,%11000111 + .byte $61,%00101010 + .byte $5F,%10001011; + .byte $5F,%01101010 + .byte $5B,%00101100 + .byte $A7,%11110001 + .byte $A5,%11110001 + .byte $9B,%11010001 + .byte $8F,%10110001 + .byte $21,%01001110 + .byte $23,%11001111 + .byte $33,%00110010 + .byte $6B,%10101001 + .byte $69,%11100111 + .byte $67,%00101000 + .byte $65,%10001001; + .byte $65,%01101000 + .byte $63,%11101001 + .byte $5F,%10101011 + .byte $5D,%11101011 + .byte $59,%10101101 + .byte $57,%11101101 + .byte $55,%01001110 + .byte $A5,%00010010 + .byte $99,%11010001 + .byte $97,%11010001 + .byte $8D,%10110001 + .byte $8B,%10110001 + .byte $83,%10010001; + .byte $83,%01110000 + .byte $81,%10010001; + .byte $81,%01110000 + .byte $1D,%01001110 + .byte $1F,%10001111; + .byte $1F,%01101110 + .byte $21,%10101111 + .byte $29,%01010000 + .byte $2B,%10010001; + .byte $2B,%01110000 + .byte $2D,%10110001 + .byte $35,%01010010 + .byte $37,%10010011; + .byte $37,%01110010 + .byte $39,%10110011 + .byte $9B,%11110001 + .byte $1F,%01001110 + .byte $69,%00001000 + .byte $67,%01001000 + .byte $65,%10101001 + .byte $65,%11001001 + .byte $61,%01001010 + .byte $95,%11010001 + .byte $91,%11010001 + .byte $27,%00010000 + .byte $31,%11110001 + .byte $3B,%11010011 + .byte $3D,%11110011 + .byte $6B,%01001000 + .byte $63,%00001010 + .byte $5D,%00001100 + .byte $5B,%01001100 + .byte $59,%11001101 + .byte $57,%00001110 + .byte $A3,%00110010 + .byte $A7,%00010010 + .byte $9F,%11110001 + .byte $9D,%11110001 + .byte $93,%11010001 + .byte $89,%10110001 + .byte $87,%10110001 + .byte $7F,%10010001; + .byte $7F,%01110000 + .byte $7D,%10010001; + .byte $7D,%01110000 + .byte $25,%11101111 + .byte $29,%00110000 + .byte $2B,%01010000 + .byte $2F,%11010001 + .byte $33,%00010010 + .byte $6B,%11100111 + .byte $61,%10001011; + .byte $61,%01101010 + .byte $99,%11110001 + .byte $1F,%00101110 + .byte $23,%10101111 + .byte $27,%11101111 + .byte $6B,%00101000 + .byte $69,%00101000 + .byte $67,%10001001; + .byte $67,%01101000 + .byte $67,%10101001 + .byte $65,%11101001 + .byte $63,%00101010 + .byte $5F,%11001011 + .byte $5F,%11101011 + .byte $5D,%00101100 + .byte $5B,%10001101; + .byte $5B,%01101100 + .byte $A3,%00010010 + .byte $A1,%00010010 + .byte $97,%11110001 + .byte $8F,%11010001 + .byte $8D,%11010001 + .byte $85,%10110001 + .byte $83,%10110001 + .byte $7B,%10010001; + .byte $7B,%01110000 + .byte $25,%11001111 + .byte $2D,%10010001; + .byte $2D,%01110000 + .byte $2F,%10110001 + .byte $31,%11010001 + .byte $35,%00110010 + .byte $37,%01010010 + .byte $69,%01001000 + .byte $69,%10001001; + .byte $69,%01101000 + .byte $67,%11001001 + .byte $63,%01001010 + .byte $61,%10101011 + .byte $57,%00101110 + .byte $A5,%00110010 + .byte $93,%11110001 + .byte $27,%11001111 + .byte $3B,%10110011 + .byte $6B,%00001000 + .byte $65,%00001010 + .byte $5D,%01001100 + .byte $5B,%10101101 + .byte $59,%11101101 + .byte $9D,%00010010 + .byte $9B,%00010010 + .byte $95,%11110001 + .byte $8B,%11010001 + .byte $89,%11010001 + .byte $81,%10110001 + .byte $23,%10001111; + .byte $23,%01101110 + .byte $25,%10101111 + .byte $29,%00010000 + .byte $2B,%00110000 + .byte $2D,%01010000 + .byte $33,%11110001 + .byte $35,%00010010 + .byte $39,%10010011; + .byte $39,%01110010 + .byte $91,%11110001 + .byte $3D,%11010011 + .byte $67,%11101001 + .byte $63,%10001011; + .byte $63,%01101010 + .byte $5F,%00001100 + .byte $A1,%00110010 + .byte $9F,%00110010 + .byte $25,%00101110 + .byte $25,%10001111; + .byte $25,%01101110 + .byte $2F,%10010001; + .byte $2F,%01110000 + .byte $3F,%11110011 + .byte $69,%10101001 + .byte $65,%00101010 + .byte $61,%11001011 + .byte $59,%00001110 + .byte $57,%01001110 + .byte $99,%00010010 + .byte $97,%00010010 + .byte $8F,%11110001 + .byte $87,%11010001 + .byte $7F,%10110001 + .byte $7D,%10110001 + .byte $21,%00101110 + .byte $23,%01001110 + .byte $29,%11101111 + .byte $2B,%00010000 + .byte $31,%10110001 + .byte $37,%00110010 + .byte $A5,%01010010 + .byte $9D,%00110010 + .byte $33,%11010001 + .byte $39,%01010010 + .byte $63,%10101011 + .byte $5D,%10001101; + .byte $5D,%01101100 + .byte $9B,%00110010 + .byte $99,%00110010 + .byte $95,%00010010 + .byte $8D,%11110001 + .byte $23,%00101110 + .byte $25,%01001110 + .byte $27,%10101111 + .byte $2D,%00110000 + .byte $2F,%01010000 + .byte $3B,%10010011; + .byte $3B,%01110010 + .byte $6D,%00101000 + .byte $6B,%10001001; + .byte $6B,%01101000 + .byte $69,%11001001 + .byte $67,%00001010 + .byte $65,%01001010 + .byte $61,%11101011 + .byte $5F,%00101100 + .byte $5B,%11001101 + .byte $A3,%01010010 + .byte $A1,%01010010 + .byte $93,%00010010 + .byte $8B,%11110001 + .byte $85,%11010001 + .byte $83,%11010001 + .byte $7B,%10110001 + .byte $29,%11001111 + .byte $35,%11110001 + .byte $A5,%10010011; + .byte $A5,%01110010 + .byte $29,%10101111 + .byte $6D,%01001000 + .byte $69,%11101001 + .byte $65,%10001011; + .byte $65,%01101010 + .byte $91,%00010010 + .byte $23,%00001110 + .byte $2B,%11101111 + .byte $2D,%00010000 + .byte $31,%10010001; + .byte $31,%01110000 + .byte $3D,%10110011 + .byte $3F,%11010011 + .byte $67,%00101010 + .byte $63,%11001011 + .byte $61,%00001100 + .byte $5F,%01001100 + .byte $5D,%10101101 + .byte $5B,%11101101 + .byte $59,%00101110 + .byte $57,%10001111; + .byte $57,%01101110 + .byte $9F,%01010010 + .byte $9D,%01010010 + .byte $97,%00110010 + .byte $8F,%00010010 + .byte $89,%11110001 + .byte $87,%11110001 + .byte $81,%11010001 + .byte $79,%10110001 + .byte $27,%10001111; + .byte $27,%01101110 + .byte $33,%10110001 + .byte $37,%00010010 + .byte $39,%00110010 + .byte $95,%00110010 + .byte $2F,%00110000 + .byte $6F,%11001001 + .byte $65,%10101011 + .byte $9D,%11010011 + .byte $A3,%10010011; + .byte $A3,%01110010 + .byte $A1,%10010011; + .byte $A1,%01110010 + .byte $93,%00110010 + .byte $2B,%11001111 + .byte $35,%11010001 + .byte $6F,%00001010 + .byte $6D,%10001001; + .byte $6D,%01101000 + .byte $6B,%11001001 + .byte $69,%00001010 + .byte $67,%01001010 + .byte $63,%11101011 + .byte $61,%00101100 + .byte $5F,%10001101; + .byte $5F,%01101100 + .byte $5D,%11001101 + .byte $99,%11110011 + .byte $9B,%01010010 + .byte $99,%01010010 + .byte $8D,%00010010 + .byte $8B,%00010010 + .byte $85,%11110001 + .byte $7F,%11010001 + .byte $27,%01001110 + .byte $2D,%11101111 + .byte $31,%01010000 + .byte $37,%11110001 + .byte $3B,%01010010 + .byte $6F,%01001000 + .byte $6D,%10101001 + .byte $6B,%11101001 + .byte $67,%10001011; + .byte $67,%01101010 + .byte $5B,%00001110 + .byte $9F,%10010011; + .byte $9F,%01110010 + .byte $9D,%10010011; + .byte $9D,%01110010 + .byte $8F,%00110010 + .byte $7D,%11010001 + .byte $29,%01001110 + .byte $33,%10010001; + .byte $33,%01110000 + .byte $3D,%10010011; + .byte $3D,%01110010 + .byte $69,%00101010 + .byte $65,%11001011 + .byte $63,%00001100 + .byte $59,%01001110 + .byte $A3,%10110011 + .byte $97,%01010010 + .byte $91,%00110010 + .byte $89,%00010010 + .byte $83,%11110001 + .byte $25,%00001110 + .byte $27,%00101110 + .byte $2B,%10101111 + .byte $2F,%00010000 + .byte $31,%00110000 + .byte $35,%10110001 + .byte $39,%00010010 + .byte $2D,%11001111 + .byte $67,%10101011 + .byte $63,%00101100 + .byte $9B,%10010011; + .byte $9B,%01110010 + .byte $99,%10010011; + .byte $99,%01110010 + .byte $95,%01010010 + .byte $7B,%11010001 + .byte $27,%00001110 + .byte $3F,%10110011 + .byte $6F,%10001001; + .byte $6F,%01101000 + .byte $6D,%11001001 + .byte $6B,%00001010 + .byte $69,%01001010 + .byte $61,%01001100 + .byte $5F,%10101101 + .byte $5D,%11101101 + .byte $5B,%00101110 + .byte $59,%10001111; + .byte $59,%01101110 + .byte $A1,%10110011 + .byte $9F,%10110011 + .byte $93,%01010010 + .byte $8D,%00110010 + .byte $87,%00010010 + .byte $81,%11110001 + .byte $2B,%10001111; + .byte $2B,%01101110 + .byte $2F,%11101111 + .byte $33,%01010000 + .byte $37,%11010001 + .byte $3B,%00110010 + .byte $2D,%10101111 + .byte $71,%10001001; + .byte $71,%01101000 + .byte $6F,%10101001 + .byte $6D,%11101001 + .byte $69,%10001011; + .byte $69,%01101010 + .byte $67,%11001011 + .byte $65,%11101011 + .byte $61,%10001101; + .byte $61,%01101100 + .byte $A1,%11010011 + .byte $97,%10010011; + .byte $97,%01110010 + .byte $27,%11101101 + .byte $29,%00101110 + .byte $35,%10010001; + .byte $35,%01110000 + .byte $3D,%01010010 + .byte $41,%11010011 + .byte $6B,%00101010 + .byte $5F,%11001101 + .byte $9D,%10110011 + .byte $9B,%10110011 + .byte $95,%10010011; + .byte $95,%01110010 + .byte $91,%01010010 + .byte $8B,%00110010 + .byte $85,%00010010 + .byte $7F,%11110001 + .byte $79,%11010001 + .byte $2B,%01001110 + .byte $2F,%11001111 + .byte $31,%00010000 + .byte $33,%00110000 + .byte $39,%11110001 + .byte $89,%00110010 + .byte $3B,%00010010 + .byte $3F,%10010011; + .byte $3F,%01110010 + .byte $6B,%01001010 + .byte $69,%10101011 + .byte $67,%11101011 + .byte $65,%00001100 + .byte $5D,%00001110 + .byte $9F,%11010011 + .byte $2D,%10001111; + .byte $2D,%01101110 + .byte $71,%10101001 + .byte $6D,%00001010 + .byte $63,%01001100 + .byte $61,%10101101 + .byte $5B,%01001110 + .byte $99,%10110011 + .byte $93,%10010011; + .byte $93,%01110010 + .byte $8F,%01010010 + .byte $8D,%01010010 + .byte $87,%00110010 + .byte $83,%00010010 + .byte $7D,%11110001 + .byte $29,%00001110 + .byte $2B,%00101110 + .byte $2F,%10101111 + .byte $31,%11101111 + .byte $35,%01010000 + .byte $37,%10110001 + .byte $39,%11010001 + .byte $A1,%11110011 + .byte $2B,%00001110 + .byte $71,%11001001 + .byte $6F,%11101001 + .byte $6B,%10001011; + .byte $6B,%01101010 + .byte $5F,%11101101 + .byte $9B,%11010011 + .byte $95,%10110011 + .byte $91,%10010011; + .byte $91,%01110010 + .byte $2D,%01001110 + .byte $31,%11001111 + .byte $33,%00010000 + .byte $41,%10110011 + .byte $6D,%00101010 + .byte $65,%00101100 + .byte $5D,%00101110 + .byte $59,%10101111 + .byte $97,%10110011 + .byte $8B,%01010010 + .byte $85,%00110010 + .byte $81,%00010010 + .byte $7B,%11110001 + .byte $29,%11101101 + .byte $37,%10010001; + .byte $37,%01110000 + .byte $3B,%11110001 + .byte $3D,%00110010 + .byte $6D,%01001010 + .byte $99,%11010011 + .byte $93,%10110011 + .byte $2D,%00101110 + .byte $2F,%10001111; + .byte $2F,%01101110 + .byte $35,%00110000 + .byte $3F,%01010010 + .byte $43,%11010011 + .byte $71,%11101001 + .byte $6B,%10101011 + .byte $69,%11001011 + .byte $67,%00001100 + .byte $65,%01001100 + .byte $63,%10001101; + .byte $63,%01101100 + .byte $61,%11001101 + .byte $5B,%10001111; + .byte $5B,%01101110 + .byte $9F,%11110011 + .byte $9D,%11110011 + .byte $8F,%10010011; + .byte $8F,%01110010 + .byte $8D,%10010011; + .byte $8D,%01110010 + .byte $89,%01010010 + .byte $83,%00110010 + .byte $7F,%00010010 + .byte $79,%11110001 + .byte $33,%11101111 + .byte $37,%01010000 + .byte $39,%10110001 + .byte $3D,%00010010 + .byte $2B,%11101101 + .byte $31,%10101111 + .byte $73,%11001001 + .byte $71,%00001010 + .byte $5F,%00001110 + .byte $97,%11010011 + .byte $2B,%11001101 + .byte $2D,%00001110 + .byte $3F,%00110010 + .byte $41,%10010011; + .byte $41,%01110010 + .byte $6F,%00101010 + .byte $6D,%10001011; + .byte $6D,%01101010 + .byte $6B,%11001011 + .byte $69,%11101011 + .byte $67,%00101100 + .byte $63,%10101101 + .byte $5D,%01001110 + .byte $9B,%11110011 + .byte $95,%11010011 + .byte $91,%10110011 + .byte $8B,%10010011; + .byte $8B,%01110010 + .byte $87,%01010010 + .byte $81,%00110010 + .byte $7D,%00010010 + .byte $2F,%01001110 + .byte $33,%11001111 + .byte $35,%00010000 + .byte $39,%10010001; + .byte $39,%01110000 + .byte $3B,%11010001 + .byte $8F,%10110011 + .byte $31,%10001111; + .byte $31,%01101110 + .byte $6F,%01001010 + .byte $61,%11101101 + .byte $77,%11110001 + .byte $2D,%11101101 + .byte $37,%00110000 + .byte $73,%11101001 + .byte $71,%00101010 + .byte $6D,%10101011 + .byte $69,%00001100 + .byte $65,%10001101; + .byte $65,%01101100 + .byte $5F,%00101110 + .byte $5B,%10101111 + .byte $97,%11110011 + .byte $93,%11010011 + .byte $89,%10010011; + .byte $89,%01110010 + .byte $85,%01010010 + .byte $7B,%00010010 + .byte $2F,%00101110 + .byte $33,%10101111 + .byte $35,%11101111 + .byte $3D,%11110001 + .byte $7F,%00110010 + .byte $3B,%10110001 + .byte $73,%00001010 + .byte $71,%01001010 + .byte $6B,%11101011 + .byte $67,%01001100 + .byte $2D,%11001101 + .byte $35,%11001111 + .byte $41,%01010010 + .byte $43,%10110011 + .byte $6F,%10001011; + .byte $6F,%01101010 + .byte $69,%00101100 + .byte $63,%11001101 + .byte $61,%00001110 + .byte $5D,%10001111; + .byte $5D,%01101110 + .byte $95,%11110011 + .byte $91,%11010011 + .byte $8D,%10110011 + .byte $87,%10010011; + .byte $87,%01110010 + .byte $83,%01010010 + .byte $2F,%00001110 + .byte $31,%01001110 + .byte $37,%00010000 + .byte $39,%01010000 + .byte $3F,%00010010 + .byte $6D,%11001011 + .byte $65,%10101101 + .byte $8F,%11010011 + .byte $8B,%10110011 + .byte $79,%00010010 + .byte $33,%10001111; + .byte $33,%01101110 + .byte $3D,%11010001 + .byte $73,%00101010 + .byte $6F,%10101011 + .byte $6B,%00001100 + .byte $67,%10001101; + .byte $67,%01101100 + .byte $63,%11101101 + .byte $5F,%01001110 + .byte $5B,%11001111 + .byte $93,%11110011 + .byte $85,%10010011; + .byte $85,%01110010 + .byte $81,%01010010 + .byte $7D,%00110010 + .byte $2F,%11101101 + .byte $31,%00101110 + .byte $39,%00110000 + .byte $3B,%10010001; + .byte $3B,%01110000 + .byte $89,%10110011 + .byte $35,%10101111 + .byte $37,%11101111 + .byte $41,%00110010 + .byte $43,%10010011; + .byte $43,%01110010 + .byte $75,%00001010 + .byte $73,%01001010 + .byte $6F,%11001011 + .byte $6D,%11101011 + .byte $6B,%00101100 + .byte $33,%01001110 + .byte $71,%10001011; + .byte $71,%01101010 + .byte $69,%01001100 + .byte $65,%11001101 + .byte $61,%00101110 + .byte $5D,%10101111 + .byte $91,%11110011 + .byte $8D,%11010011 + .byte $7B,%00110010 + .byte $77,%00010010 + .byte $2F,%11001101 + .byte $31,%00001110 + .byte $39,%00010000 + .byte $3B,%01010000 + .byte $3D,%10110001 + .byte $3F,%11110001 + .byte $7F,%01010010 + .byte $71,%10101011 + .byte $8F,%11110011 + .byte $8B,%11010011 + .byte $33,%00101110 + .byte $43,%01010010 + .byte $45,%10110011 + .byte $75,%00101010 + .byte $6D,%00001100 + .byte $69,%10001101; + .byte $69,%01101100 + .byte $67,%10101101 + .byte $63,%00001110 + .byte $87,%10110011 + .byte $83,%10010011; + .byte $83,%01110010 + .byte $31,%11101101 + .byte $35,%10001111; + .byte $35,%01101110 + .byte $37,%11001111 + .byte $33,%00001110 + .byte $3D,%10010001; + .byte $3D,%01110000 + .byte $41,%00010010 + .byte $75,%01001010 + .byte $71,%11001011 + .byte $65,%11101101 + .byte $37,%10101111 + .byte $3F,%11010001 + .byte $73,%10001011; + .byte $73,%01101010 + .byte $6F,%11101011 + .byte $6B,%01001100 + .byte $61,%01001110 + .byte $5F,%10001111; + .byte $5F,%01101110 + .byte $8D,%11110011 + .byte $89,%11010011 + .byte $85,%10110011 + .byte $81,%10010011; + .byte $81,%01110010 + .byte $7D,%01010010 + .byte $79,%00110010 + .byte $31,%11001101 + .byte $35,%01001110 + .byte $39,%11101111 + .byte $3B,%00110000 + .byte $33,%11101101 + .byte $77,%01001010 + .byte $73,%10101011 + .byte $37,%10001111; + .byte $37,%01101110 + .byte $39,%11001111 + .byte $43,%00110010 + .byte $45,%10010011; + .byte $45,%01110010 + .byte $75,%10001011; + .byte $75,%01101010 + .byte $6F,%00001100 + .byte $6D,%00101100 + .byte $69,%10101101 + .byte $67,%11001101 + .byte $63,%00101110 + .byte $5D,%11001111 + .byte $8B,%11110011 + .byte $87,%11010011 + .byte $83,%10110011 + .byte $7F,%10010011; + .byte $7F,%01110010 + .byte $35,%00101110 + .byte $3B,%00010000 + .byte $3D,%01010000 + .byte $3F,%10110001 + .byte $41,%11110001 + .byte $7B,%01010010 + .byte $33,%11001101 + .byte $75,%10101011 + .byte $71,%11101011 + .byte $6F,%00101100 + .byte $35,%00001110 + .byte $73,%11001011 + .byte $6D,%01001100 + .byte $6B,%10001101; + .byte $6B,%01101100 + .byte $67,%11101101 + .byte $65,%00001110 + .byte $5F,%10101111 + .byte $89,%11110011 + .byte $85,%11010011 + .byte $77,%00110010 + .byte $37,%01001110 + .byte $39,%10101111 + .byte $3B,%11101111 + .byte $3D,%00110000 + .byte $3F,%10010001; + .byte $3F,%01110000 + .byte $81,%10110011 + .byte $73,%11101011 + .byte $71,%00001100 + .byte $35,%11101101 + .byte $43,%00010010 + .byte $45,%01010010 + .byte $47,%10110011 + .byte $77,%10001011; + .byte $77,%01101010 + .byte $6B,%10101101 + .byte $69,%11001101 + .byte $63,%01001110 + .byte $61,%10001111; + .byte $61,%01101110 + .byte $7D,%10010011; + .byte $7D,%01110010 + .byte $79,%01010010 + .byte $37,%00101110 + .byte $39,%10001111; + .byte $39,%01101110 + .byte $3B,%11001111 + .byte $41,%11010001 + .byte $77,%10101011 + .byte $6D,%10001101; + .byte $6D,%01101100 + .byte $65,%00101110 + .byte $35,%10101101 + .byte $35,%11001101 + .byte $39,%01001110 + .byte $3B,%10101111 + .byte $3D,%00010000 + .byte $75,%11001011 + .byte $6F,%01001100 + .byte $67,%00001110 + .byte $5F,%11001111 + .byte $5D,%11101111 + .byte $87,%11110011 + .byte $83,%11010011 + .byte $7F,%10110011 + .byte $75,%00110010 + .byte $37,%00001110 + .byte $3F,%01010000 + .byte $41,%10110001 + .byte $43,%11110001 + .byte $75,%11101011 + .byte $45,%00110010 + .byte $47,%10010011; + .byte $47,%01110010 + .byte $73,%00001100 + .byte $71,%00101100 + .byte $6D,%10101101 + .byte $6B,%11001101 + .byte $69,%11101101 + .byte $63,%10001111; + .byte $63,%01101110 + .byte $61,%10101111 + .byte $85,%11110011 + .byte $81,%11010011 + .byte $7B,%10010011; + .byte $7B,%01110010 + .byte $77,%01010010 + .byte $37,%11101101 + .byte $39,%00101110 + .byte $3B,%10001111; + .byte $3B,%01101110 + .byte $3D,%11101111 + .byte $3F,%00110000 + .byte $41,%10010001; + .byte $41,%01110000 + .byte $77,%11001011 + .byte $37,%11001101 + .byte $3B,%01001110 + .byte $73,%00101100 + .byte $71,%01001100 + .byte $6F,%10001101; + .byte $6F,%01101100 + .byte $69,%00001110 + .byte $67,%00101110 + .byte $65,%01001110 + .byte $83,%11110011 + .byte $7D,%10110011 + .byte $39,%00001110 + .byte $3D,%11001111 + .byte $3F,%00010000 + .byte $43,%11010001 + .byte $79,%11001011 + .byte $75,%00001100 + .byte $37,%10101101 + .byte $45,%00010010 + .byte $47,%01010010 + .byte $77,%11101011 + .byte $6F,%10101101 + .byte $6D,%11001101 + .byte $6B,%11101101 + .byte $61,%11001111 + .byte $5F,%11101111 + .byte $5D,%00010000 + .byte $7F,%11010011 + .byte $79,%10010011; + .byte $79,%01110010 + .byte $39,%11101101 + .byte $3B,%00101110 + .byte $3D,%10101111 + .byte $3F,%11101111 + .byte $41,%01010000 + .byte $43,%10110001 + .byte $77,%00001100 + .byte $39,%11001101 + .byte $45,%11110001 + .byte $49,%10110011 + .byte $75,%00101100 + .byte $73,%01001100 + .byte $71,%10001101; + .byte $71,%01101100 + .byte $67,%01001110 + .byte $65,%10001111; + .byte $65,%01101110 + .byte $63,%10101111 + .byte $81,%11110011 + .byte $7B,%10110011 + .byte $75,%01010010 + .byte $3B,%00001110 + .byte $3D,%10001111; + .byte $3D,%01101110 + .byte $3F,%11001111 + .byte $41,%00110000 + .byte $79,%11101011 + .byte $69,%00101110 + .byte $39,%10101101 + .byte $47,%00110010 + .byte $6F,%11001101 + .byte $6D,%11101101 + .byte $6B,%00001110 + .byte $7D,%11010011 + .byte $77,%10010011; + .byte $77,%01110010 + .byte $3B,%11101101 + .byte $3D,%01001110 + .byte $41,%00010000 + .byte $43,%10010001; + .byte $43,%01110000 + .byte $45,%11010001 + .byte $75,%01001100 + .byte $73,%10001101; + .byte $73,%01101100 + .byte $71,%10101101 + .byte $3D,%00101110 + .byte $3F,%10101111 + .byte $43,%01010000 + .byte $47,%00010010 + .byte $49,%10010011; + .byte $49,%01110010 + .byte $79,%00001100 + .byte $77,%00101100 + .byte $63,%11001111 + .byte $61,%11101111 + .byte $5F,%00010000 + .byte $7F,%11110011 + .byte $79,%10110011 + .byte $3B,%11001101 + .byte $3F,%10001111; + .byte $3F,%01101110 + .byte $41,%11101111 + .byte $79,%00101100 + .byte $3B,%10101101 + .byte $45,%10110001 + .byte $75,%10001101; + .byte $75,%01101100 + .byte $73,%10101101 + .byte $71,%11001101 + .byte $6F,%11101101 + .byte $6D,%00001110 + .byte $6B,%00101110 + .byte $69,%01001110 + .byte $67,%10001111; + .byte $67,%01101110 + .byte $65,%10101111 + .byte $7B,%11010011 + .byte $75,%10010011; + .byte $75,%01110010 + .byte $3D,%00001110 + .byte $3F,%01001110 + .byte $41,%11001111 + .byte $43,%00110000 + .byte $7D,%11110011 + .byte $3D,%11001101 + .byte $3D,%11101101 + .byte $3F,%00101110 + .byte $47,%11110001 + .byte $49,%01010010 + .byte $77,%01001100 + .byte $77,%10110011 + .byte $41,%10101111 + .byte $43,%00010000 + .byte $45,%10010001; + .byte $45,%01110000 + .byte $77,%10001101; + .byte $77,%01101100 + .byte $75,%10101101 + .byte $3D,%10101101 + .byte $41,%10001111; + .byte $41,%01101110 + .byte $49,%00110010 + .byte $79,%01001100 + .byte $73,%11001101 + .byte $71,%11101101 + .byte $6F,%00001110 + .byte $6D,%00101110 + .byte $6B,%01001110 + .byte $69,%10001111; + .byte $69,%01101110 + .byte $67,%10101111 + .byte $65,%11001111 + .byte $63,%11101111 + .byte $61,%00010000 + .byte $5F,%00110000 + .byte $79,%11010011 + .byte $3F,%00001110 + .byte $43,%11101111 + .byte $45,%01010000 + .byte $47,%11010001 + .byte $7B,%01001100 + .byte $3F,%11001101 + .byte $49,%00010010 + .byte $7B,%11110011 + .byte $73,%10010011; + .byte $73,%01110010 + .byte $3F,%11101101 + .byte $41,%01001110 + .byte $43,%11001111 + .byte $45,%00110000 + .byte $47,%10110001 + .byte $3F,%10101101 + .byte $41,%00101110 + .byte $4B,%10010011; + .byte $4B,%01110010 + .byte $79,%10001101; + .byte $79,%01101100 + .byte $77,%10101101 + .byte $75,%11001101 + .byte $73,%11101101 + .byte $71,%00001110 + .byte $6F,%00101110 + .byte $6D,%01001110 + .byte $6B,%10001111; + .byte $6B,%01101110 + .byte $75,%10110011 + .byte $43,%10101111 + .byte $45,%00010000 + .byte $47,%10010001; + .byte $47,%01110000 + .byte $79,%10101101 + .byte $77,%11010011 + .byte $41,%11101101 + .byte $41,%00001110 + .byte $43,%10001111; + .byte $43,%01101110 + .byte $49,%11110001 + .byte $4B,%01010010 + .byte $7B,%10001101; + .byte $7B,%01101100 + .byte $69,%10101111 + .byte $67,%11001111 + .byte $65,%11101111 + .byte $63,%00010000 + .byte $61,%00110000 + .byte $79,%11110011 + .byte $45,%11101111 + .byte $73,%00001110 + .byte $41,%11001101 + .byte $43,%01001110 + .byte $77,%11001101 + .byte $75,%11101101 + .byte $71,%00101110 + .byte $5F,%01010000 + .byte $43,%00101110 + .byte $45,%11001111 + .byte $47,%01010000 + .byte $49,%11010001 + .byte $47,%00110000 + .byte $4B,%00110010 + .byte $77,%11101101 + .byte $6F,%01001110 + .byte $7B,%10101101 + .byte $79,%11001101 + .byte $75,%00001110 + .byte $6D,%10001111; + .byte $6D,%01101110 + .byte $6B,%10101111 + .byte $69,%11001111 + .byte $75,%11010011 + .byte $73,%10110011 + .byte $43,%00001110 + .byte $45,%10101111 + .byte $47,%00010000 + .byte $49,%10110001 + .byte $67,%11101111 + .byte $43,%11101101 + .byte $4B,%00010010 + .byte $73,%00101110 + .byte $71,%01001110 + .byte $6F,%10001111; + .byte $6F,%01101110 + .byte $65,%00010000 + .byte $77,%11110011 + .byte $43,%11001101 + .byte $45,%01001110 + .byte $45,%10001111; + .byte $45,%01101110 + .byte $47,%11101111 + .byte $49,%10010001; + .byte $49,%01110000 + .byte $4B,%11110001 + .byte $4D,%10010011; + .byte $4D,%01110010 + .byte $7B,%11001101 + .byte $79,%11101101 + .byte $77,%00001110 + .byte $6D,%10101111 + .byte $63,%00110000 + .byte $61,%01010000 + .byte $45,%00101110 + .byte $47,%11001111 + .byte $49,%01010000 + .byte $75,%00101110 + .byte $6B,%11001111 + .byte $45,%00001110 + .byte $4D,%01010010 + .byte $73,%01001110 + .byte $69,%11101111 + .byte $71,%10110011 + .byte $45,%11101101 + .byte $47,%10101111 + .byte $49,%00110000 + .byte $4B,%11010001 + .byte $71,%10001111; + .byte $71,%01101110 + .byte $73,%11010011 + .byte $47,%10001111; + .byte $47,%01101110 + .byte $7B,%11101101 + .byte $79,%00001110 + .byte $77,%00101110 + .byte $6F,%10101111 + .byte $67,%00010000 + .byte $65,%00110000 + .byte $75,%11110011 + .byte $45,%11001101 + .byte $47,%01001110 + .byte $49,%00010000 + .byte $4B,%10110001 + .byte $49,%11101111 + .byte $4D,%00110010 + .byte $6D,%11001111 + .byte $47,%00101110 + .byte $75,%01001110 + .byte $73,%10001111; + .byte $73,%01101110 + .byte $6B,%11101111 + .byte $63,%01010000 + .byte $47,%00001110 + .byte $49,%11001111 + .byte $4B,%10010001; + .byte $4B,%01110000 + .byte $4D,%00010010 + .byte $47,%11001101 + .byte $7B,%00001110 + .byte $79,%00101110 + .byte $71,%10101111 + .byte $6F,%11001111 + .byte $69,%00010000 + .byte $61,%10010001; + .byte $61,%01110000 + .byte $47,%11101101 + .byte $49,%10101111 + .byte $4B,%01010000 + .byte $49,%10001111; + .byte $49,%01101110 + .byte $4D,%11110001 + .byte $7B,%00101110 + .byte $77,%01001110 + .byte $75,%10001111; + .byte $75,%01101110 + .byte $6D,%11101111 + .byte $67,%00110000 + .byte $73,%11110011 + .byte $71,%11010011 + .byte $49,%01001110 + .byte $4B,%00010000 + .byte $4B,%00110000 + .byte $4D,%11010001 + .byte $73,%10101111 + .byte $79,%01001110 + .byte $71,%11001111 + .byte $6B,%00010000 + .byte $65,%01010000 + .byte $49,%00001110 + .byte $49,%00101110 + .byte $4B,%11101111 + .byte $4D,%10110001 + .byte $4B,%11001111 + .byte $4F,%01010010 + .byte $7B,%01001110 + .byte $77,%10001111; + .byte $77,%01101110 + .byte $75,%10101111 + .byte $6F,%11101111 + .byte $69,%00110000 + .byte $63,%10010001; + .byte $63,%01110000 + .byte $49,%11101101 + .byte $4B,%10101111 + .byte $4D,%10010001; + .byte $4D,%01110000 + .byte $4F,%00110010 + .byte $79,%10001111; + .byte $79,%01101110 + .byte $73,%11001111 + .byte $6D,%00010000 + .byte $67,%01010000 + .byte $4B,%01001110 + .byte $4B,%10001111; + .byte $4B,%01101110 + .byte $4D,%00110000 + .byte $4D,%01010000 + .byte $4B,%00101110 + .byte $4F,%11110001 + .byte $4F,%00010010 + .byte $77,%10101111 + .byte $71,%11101111 + .byte $6B,%00110000 + .byte $4F,%10010011; + .byte $4F,%01110010 + .byte $71,%11110011 + .byte $4B,%11101101 + .byte $4B,%00001110 + .byte $4D,%00010000 + .byte $65,%10010001; + .byte $65,%01110000 + .byte $7B,%10001111; + .byte $7B,%01101110 + .byte $79,%10101111 + .byte $75,%11001111 + .byte $6F,%00010000 + .byte $69,%01010000 + .byte $61,%10110001 + .byte $4D,%10101111 + .byte $4D,%11001111 + .byte $4D,%11101111 + .byte $4F,%11010001 + .byte $73,%11101111 + .byte $4D,%01001110 + .byte $77,%11001111 + .byte $6D,%00110000 + .byte $63,%10110001 + .byte $4D,%10001111; + .byte $4D,%01101110 + .byte $4F,%10010001; + .byte $4F,%01110000 + .byte $4F,%10110001 + .byte $7B,%10101111 + .byte $75,%11101111 + .byte $71,%00010000 + .byte $67,%10010001; + .byte $67,%01110000 + .byte $4D,%00001110 + .byte $4D,%00101110 + .byte $4F,%00110000 + .byte $4F,%01010000 + .byte $79,%11001111 + .byte $6B,%01010000 + .byte $51,%00110010 + .byte $51,%01010010 + .byte $73,%00010000 + .byte $6F,%00110000 + .byte $6F,%11110011 + .byte $4F,%11101111 + .byte $4F,%00010000 + .byte $77,%11101111 + .byte $4F,%11001111 + .byte $51,%11110001 + .byte $51,%00010010 + .byte $7B,%11001111 + .byte $6D,%01010000 + .byte $69,%10010001; + .byte $69,%01110000 + .byte $65,%10110001 + .byte $4F,%10001111; + .byte $4F,%01101110 + .byte $4F,%10101111 + .byte $71,%00110000 + .byte $4F,%00001110 + .byte $79,%11101111 + .byte $75,%00010000 + .byte $4F,%00101110 + .byte $4F,%01001110 + .byte $51,%10110001 + .byte $51,%11010001 + .byte $63,%11010001 + .byte $5F,%10010001; + .byte $5F,%01110000 + .byte $7B,%11101111 + .byte $77,%00010000 + .byte $73,%00110000 + .byte $6F,%01010000 + .byte $6B,%10010001; + .byte $6B,%01110000 + .byte $67,%10110001 + .byte $51,%00110000 + .byte $51,%01010000 + .byte $51,%10010001; + .byte $51,%01110000 + .byte $6F,%11010011 + .byte $51,%00010000 + .byte $79,%00010000 + .byte $75,%00110000 + .byte $51,%10101111 + .byte $51,%11001111 + .byte $51,%11101111 + .byte $7B,%00010000 + .byte $51,%10001111; + .byte $51,%01101110 + .byte $71,%01010000 + .byte $6D,%10010001; + .byte $6D,%01110000 + .byte $69,%10110001 + .byte $65,%11010001 + .byte $51,%00101110 + .byte $51,%01001110 + .byte $53,%11110001 + .byte $53,%00010010 + .byte $53,%00110010 + .byte $53,%01010010 + .byte $77,%00110000 + .byte $73,%01010000 + .byte $6F,%10010001; + .byte $6F,%01110000 + .byte $79,%00110000 + .byte $75,%01010000 + .byte $6B,%10110001 + .byte $67,%11010001 + .byte $53,%00110000 + .byte $53,%01010000 + .byte $53,%10010001; + .byte $53,%01110000 + .byte $53,%10110001 + .byte $53,%11010001 + .byte $53,%10101111 + .byte $53,%00010000 + .byte $71,%10010001; + .byte $71,%01110000 + .byte $6D,%10110001 + .byte $63,%11110001 + .byte $53,%01001110 + .byte $53,%10001111; + .byte $53,%01101110 + .byte $53,%11001111 + .byte $53,%11101111 + .byte $77,%01010000 + .byte $73,%10010001; + .byte $73,%01110000 + .byte $69,%11010001 + .byte $51,%10010011; + .byte $51,%01110010 + .byte $65,%11110001 + .byte $79,%01010000 + .byte $75,%10010001; + .byte $75,%01110000 + .byte $6F,%10110001 + .byte $6B,%11010001 + .byte $77,%10010001; + .byte $77,%01110000 + .byte $71,%10110001 + .byte $67,%11110001 + .byte $55,%10001111; + .byte $55,%01101110 + .byte $55,%10101111 + .byte $55,%11001111 + .byte $55,%11101111 + .byte $55,%00010010 + .byte $55,%00110010 + .byte $55,%01010010 + .byte $79,%10010001; + .byte $79,%01110000 + .byte $73,%10110001 + .byte $6D,%11010001 + .byte $55,%00010000 + .byte $55,%00110000 + .byte $55,%01010000 + .byte $55,%10010001; + .byte $55,%01110000 + .byte $55,%10110001 + .byte $55,%11010001 + .byte $55,%11110001 + .byte $75,%10110001 + .byte $6F,%11010001 + .byte $69,%11110001 + .byte $6D,%11110011 + .byte $61,%11010001 + .byte $77,%10110001 + .byte $71,%11010001 + .byte $6B,%11110001 + .byte $73,%11010001 + .byte $65,%00010010 + .byte $41,%11110011 + .byte $57,%10101111 + .byte $57,%11001111 + .byte $57,%11101111 + .byte $63,%00010010 + .byte $75,%11010001 + .byte $6D,%11110001 + .byte $67,%00010010 + .byte $57,%00010000 + .byte $57,%00110000 + .byte $57,%01010000 + .byte $57,%10010001; + .byte $57,%01110000 + .byte $53,%10010011; + .byte $53,%01110010 + .byte $77,%11010001 + .byte $6F,%11110001 + .byte $69,%00010010 + .byte $43,%11110011 + .byte $57,%10110001 + .byte $57,%11010001 + .byte $57,%11110001 + .byte $57,%00010010 + .byte $57,%00110010 + .byte $71,%11110001 + .byte $45,%11110011 + .byte $59,%11001111 + .byte $57,%01010010 + .byte $75,%11110001 + .byte $73,%11110001 + .byte $6B,%00010010 + .byte $59,%11101111 + .byte $6D,%00010010 + .byte $65,%00110010 + .byte $47,%11110011 + .byte $59,%00010000 + .byte $59,%00110000 + .byte $6F,%00010010 + .byte $71,%00010010 + .byte $67,%00110010 + .byte $55,%10010011; + .byte $55,%01110010 + .byte $45,%11010011 + .byte $59,%01010000 + .byte $59,%10010001; + .byte $59,%01110000 + .byte $5B,%11101111 + .byte $73,%00010010 + .byte $69,%00110010 + .byte $49,%11110011 + .byte $59,%10110001 + .byte $59,%11010001 + .byte $75,%00010010 + .byte $6B,%00110010 + .byte $47,%11010011 + .byte $63,%00110010 + .byte $59,%11110001 + .byte $6F,%00110010 + .byte $6D,%00110010 + .byte $57,%10010011; + .byte $57,%01110010 + .byte $4B,%11110011 + .byte $5B,%00010000 + .byte $59,%00010010 + .byte $59,%00110010 + .byte $71,%00110010 + .byte $65,%01010010 + .byte $49,%11010011 + .byte $5B,%00110000 + .byte $5B,%01010000 + .byte $59,%01010010 + .byte $73,%00110010 + .byte $67,%01010010 + .byte $4D,%11110011 + .byte $5B,%10010001; + .byte $5B,%01110000 + .byte $59,%10010011; + .byte $59,%01110010 + .byte $6B,%01010010 + .byte $69,%01010010 + .byte $4B,%11010011 + .byte $5D,%00110000 + .byte $5B,%10110001 + .byte $73,%01010010 + .byte $6F,%01010010 + .byte $6D,%01010010 + .byte $61,%11110001 + .byte $5B,%11010001 + .byte $71,%01010010 + .byte $4B,%10110011 + .byte $4F,%11110011 + .byte $63,%01010010 + .byte $5B,%11110001 + .byte $4D,%11010011 + .byte $5D,%01010000 + .byte $5B,%00010010 + .byte $67,%10010011; + .byte $67,%01110010 + .byte $65,%10010011; + .byte $65,%01110010 + .byte $5D,%10010001; + .byte $5D,%01110000 + .byte $5B,%00110010 + .byte $71,%10010011; + .byte $71,%01110010 + .byte $6F,%10010011; + .byte $6F,%01110010 + .byte $6D,%10010011; + .byte $6D,%01110010 + .byte $6B,%10010011; + .byte $6B,%01110010 + .byte $69,%10010011; + .byte $69,%01110010 + .byte $4D,%10110011 + .byte $51,%11110011 + .byte $5D,%10110001 + .byte $4F,%11010011 + .byte $5B,%01010010 + .byte $5D,%11010001 + .byte $5B,%10010011; + .byte $5B,%01110010 + .byte $6B,%11110011 + .byte $63,%10010011; + .byte $63,%01110010 + .byte $5D,%11110001 + .byte $6F,%10110011 + .byte $4F,%10110011 + .byte $53,%11110011 + .byte $5F,%10110001 + .byte $51,%11010011 + .byte $5D,%00010010 + .byte $61,%00010010 + .byte $6D,%10110011 + .byte $6B,%10110011 + .byte $69,%10110011 + .byte $67,%10110011 + .byte $65,%10110011 + .byte $63,%10110011 + .byte $5D,%00110010 + .byte $6D,%11010011 + .byte $5B,%10110011 + .byte $51,%10110011 + .byte $5F,%11010001 + .byte $59,%10110011 + .byte $53,%11010011 + .byte $55,%11110011 + .byte $5D,%01010010 + .byte $57,%10110011 + .byte $5F,%11110001 + .byte $53,%10110011 + .byte $5F,%00010010 + .byte $6B,%11010011 + .byte $69,%11010011 + .byte $55,%10110011 + .byte $61,%00110010 + .byte $5D,%10010011; + .byte $5D,%01110010 + .byte $67,%11010011 + .byte $65,%11010011 + .byte $55,%11010011 + .byte $57,%11110011 + .byte $5F,%00110010 + .byte $5D,%10110011 + .byte $63,%11010011 + .byte $69,%11110011 + .byte $61,%01010010 + .byte $5F,%01010010 + .byte $57,%11010011 + .byte $67,%11110011 + .byte $5D,%11010011 + .byte $59,%11110011 + .byte $61,%10010011; + .byte $61,%01110010 + .byte $5F,%10010011; + .byte $5F,%01110010 + .byte $65,%11110011 + .byte $5B,%11010011 + .byte $61,%10110011 + .byte $63,%11110011 + .byte $59,%11010011 + .byte $61,%11010011 + .byte $5F,%10110011 + .byte $61,%11110011 + .byte $5B,%11110011 + .byte $5F,%11010011 + .byte $5D,%11110011 + .byte $5F,%11110011 diff --git a/graphics/hgr/wipes/star/fx.hgr.star.in.s b/graphics/hgr/wipes/star/fx.hgr.star.in.s new file mode 100644 index 00000000..c82536d8 --- /dev/null +++ b/graphics/hgr/wipes/star/fx.hgr.star.in.s @@ -0,0 +1,34 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; + +;!cpu 6502 +;!to "build/FX.INDEXED/STAR.IN",plain +;*=$6000 + +; !source "src/fx/fx.hgr.precomputed.2bit.a" + + .include "fx.hgr.precomputed.2bit.s" + +; +FX_INITONCE_2BIT FXCodeFile, CoordinatesFile, Start + +InitOnce: + bit Start + lda #$4C + sta InitOnce + + lda #$0 + sta EndCoordinates2Bit + + + jsr ReverseCoordinates2Bit + +Start: +; jmp FXCode + + .include "code.hgr.precomputed.2bit.s" + +;FXCodeFile +; +PSTRING "HGR2" +;CoordinatesFile +; +PSTRING "STAR.DATA" diff --git a/graphics/hgr/wipes/star/wipe_star_bloom.s b/graphics/hgr/wipes/star/wipe_star_bloom.s new file mode 100644 index 00000000..1c695082 --- /dev/null +++ b/graphics/hgr/wipes/star/wipe_star_bloom.s @@ -0,0 +1,89 @@ +; test some of the 4cade wipes + +; Star Bloom + +.include "../zp.inc" +.include "../hardware.inc" + +Coordinates2Bit=$8100 +EndCoordinates2Bit = Coordinates2Bit + (origEndCoordinates2Bit-origCoordinates2Bit) + +wipe_star_bloom: + + ; from code.hgr.precomputed.2bit + + jsr BuildHGRTables + jsr BuildHGRMirrorCols + jsr BuildHGRSparseBitmasks2Bit + + + bit SET_GR + bit HIRES + bit FULLGR + bit PAGE1 + + ;================================= + ; intro + ;================================= + + + ; copy data table to $8100 + + ldx #((>origEndCoordinates2Bit)-(>origCoordinates2Bit)) + +outer_copy_coords_loop: + ldy #0 +copy_coords_loop: + +col_smc1: + lda origCoordinates2Bit,Y +col_smc2: + sta Coordinates2Bit,Y + iny + bne copy_coords_loop + + inc col_smc1+2 + inc col_smc2+2 + + dex + bpl outer_copy_coords_loop + + jsr HGR2 + jsr HGR + bit FULLGR + +do_it_again: + + + +oog: + lda #$FF + jsr BKGND0 + + jsr wait_until_keypress + + ;================================= + ; test wipe... + ;================================= +test_loop: + + jsr InitOnce + + jsr wait_until_keypress + + dec oog+1 + + jmp do_it_again + +.include "../wait_keypress.s" + +.include "../fx.lib.s" + +.include "fx.hgr.star.s" + +; possibly some bytes before get chewed on with some effects? + +.align $100 +origCoordinates2Bit: + .incbin "fx.hgr.star_bloom.data" +origEndCoordinates2Bit: diff --git a/graphics/hgr/wipes/star/wipe_star_in.s b/graphics/hgr/wipes/star/wipe_star_in.s new file mode 100644 index 00000000..13dafea6 --- /dev/null +++ b/graphics/hgr/wipes/star/wipe_star_in.s @@ -0,0 +1,114 @@ +; test some of the 4cade wipes + +.include "../zp.inc" +.include "../hardware.inc" + +Coordinates2Bit=$8100 +EndCoordinates2Bit = Coordinates2Bit + (origEndCoordinates2Bit-origCoordinates2Bit) + +wipe_test: +; jmp after +test_graphic: +; .incbin "../graphics/a2_dating.hgr.zx02" + +;.include "../zx02_optim.s" + +after: + + ; from code.hgr.precomputed.2bit + + jsr BuildHGRTables + jsr BuildHGRMirrorCols + jsr BuildHGRSparseBitmasks2Bit + + + bit SET_GR + bit HIRES + bit FULLGR + bit PAGE1 + + ;================================= + ; intro + ;================================= + + + ; copy data table to $8100 + + ldx #((>origEndCoordinates2Bit)-(>origCoordinates2Bit)) + +outer_copy_coords_loop: + ldy #0 +copy_coords_loop: + +col_smc1: + lda origCoordinates2Bit,Y +col_smc2: + sta Coordinates2Bit,Y + iny + bne copy_coords_loop + + inc col_smc1+2 + inc col_smc2+2 + + dex + bpl outer_copy_coords_loop + +; lda #test_graphic +; sta zx_src_h+1 +; lda #$20 +; jsr zx02_full_decomp + +; ldy #0 +;fake_hgr2: +; lda #$0 +; sta $4000,Y +; dey +; bne fake_hgr2 +; +; inc fake_hgr2+2 +; lda fake_hgr2+2 +; cmp #$60 +; bne fake_hgr2 + + + jsr HGR2 + jsr HGR + bit FULLGR + +do_it_again: + + + +oog: + lda #$FF + jsr BKGND0 + + jsr wait_until_keypress + + ;================================= + ; test wipe... + ;================================= +test_loop: + + jsr InitOnce + + jsr wait_until_keypress + + dec oog+1 + + jmp do_it_again + +.include "../wait_keypress.s" + +.include "../fx.lib.2bit.s" + +.include "fx.hgr.star.in.s" + +; possibly some bytes before get chewed on with some effects? + +.align $100 +origCoordinates2Bit: + .incbin "fx.hgr.star.data" +origEndCoordinates2Bit: