📄 gs.lss
字号:
8f2: 20 e0 ldi r18, 0x00 ; 0
8f4: 30 e0 ldi r19, 0x00 ; 0
8f6: 4f e0 ldi r20, 0x0F ; 15
8f8: aa 0f add r26, r26
8fa: bb 1f adc r27, r27
8fc: a9 58 subi r26, 0x89 ; 137
8fe: bf 4f sbci r27, 0xFF ; 255
{
for(k=0;k<16;k++)
{
t1=ss[4*i+j];
900: e8 81 ld r30, Y
t2=16*k+2*j+256*i;
if(t1!=0xff)
902: ef 3f cpi r30, 0xFF ; 255
904: d1 f0 breq .+52 ; 0x93a <w16+0x8a>
{
disbuf[t2] =pgm_read_byte(C1+32*t1+2*k);
906: ce 2e mov r12, r30
908: dd 24 eor r13, r13
90a: 84 e0 ldi r24, 0x04 ; 4
90c: cc 0c add r12, r12
90e: dd 1c adc r13, r13
910: 8a 95 dec r24
912: e1 f7 brne .-8 ; 0x90c <w16+0x5c>
914: c2 0e add r12, r18
916: d3 1e adc r13, r19
918: cc 0c add r12, r12
91a: dd 1c adc r13, r13
91c: c6 01 movw r24, r12
91e: 8c 58 subi r24, 0x8C ; 140
920: 9f 4f sbci r25, 0xFF ; 255
922: fc 01 movw r30, r24
924: 84 91 lpm r24, Z
926: 8c 93 st X, r24
disbuf[t2+1]=pgm_read_byte(C1+32*t1+2*k+1);
928: 85 e7 ldi r24, 0x75 ; 117
92a: 90 e0 ldi r25, 0x00 ; 0
92c: c8 0e add r12, r24
92e: d9 1e adc r13, r25
930: f6 01 movw r30, r12
932: 84 91 lpm r24, Z
934: fd 01 movw r30, r26
936: 81 83 std Z+1, r24 ; 0x01
938: 03 c0 rjmp .+6 ; 0x940 <w16+0x90>
}
else
{
disbuf[t2]=0x00;
93a: 1c 92 st X, r1
disbuf[t2+1]=0x00;
93c: fd 01 movw r30, r26
93e: 11 82 std Z+1, r1 ; 0x01
940: 41 50 subi r20, 0x01 ; 1
942: 2f 5f subi r18, 0xFF ; 255
944: 3f 4f sbci r19, 0xFF ; 255
946: 50 96 adiw r26, 0x10 ; 16
948: 47 ff sbrs r20, 7
94a: da cf rjmp .-76 ; 0x900 <w16+0x50>
94c: 5f 5f subi r21, 0xFF ; 255
94e: 54 30 cpi r21, 0x04 ; 4
950: 08 f4 brcc .+2 ; 0x954 <w16+0xa4>
952: c5 cf rjmp .-118 ; 0x8de <w16+0x2e>
954: 6f 5f subi r22, 0xFF ; 255
956: 64 30 cpi r22, 0x04 ; 4
958: 08 f4 brcc .+2 ; 0x95c <w16+0xac>
95a: b3 cf rjmp .-154 ; 0x8c2 <w16+0x12>
95c: df 91 pop r29
95e: cf 91 pop r28
960: 1f 91 pop r17
962: 0f 91 pop r16
964: ff 90 pop r15
966: ef 90 pop r14
968: df 90 pop r13
96a: cf 90 pop r12
96c: 08 95 ret
0000096e <wsor>:
}
}
}
} //*/
}
void wsor(void) //write the cursor
{
96e: 1f 93 push r17
970: cf 93 push r28
uchar x,y,k;
uint t2;
x=sor%4;
972: 10 91 64 00 lds r17, 0x0064
976: 13 70 andi r17, 0x03 ; 3
y=sor/4;
978: c0 91 64 00 lds r28, 0x0064
97c: c6 95 lsr r28
97e: c6 95 lsr r28
if(sorf) //已选定
980: 80 91 66 00 lds r24, 0x0066
984: 88 23 and r24, r24
986: 01 f1 breq .+64 ; 0x9c8 <wsor+0x5a>
{
w16();
988: 0e 94 58 04 call 0x8b0 <w16>
98c: ec 2f mov r30, r28
98e: ff 27 eor r31, r31
990: f6 95 lsr r31
992: fe 2f mov r31, r30
994: ee 27 eor r30, r30
996: f7 95 ror r31
998: e7 95 ror r30
99a: e1 0f add r30, r17
99c: f1 1d adc r31, r1
99e: 9f e0 ldi r25, 0x0F ; 15
9a0: ee 0f add r30, r30
9a2: ff 1f adc r31, r31
9a4: e9 58 subi r30, 0x89 ; 137
9a6: ff 4f sbci r31, 0xFF ; 255
for(k=0;k<16;k++)
{
t2=16*k+2*x+256*y;
disbuf[t2]^=0xff; //反白
9a8: 80 81 ld r24, Z
9aa: 80 95 com r24
9ac: 80 83 st Z, r24
disbuf[t2+1]^=0xff;
9ae: 81 81 ldd r24, Z+1 ; 0x01
9b0: 80 95 com r24
9b2: 81 83 std Z+1, r24 ; 0x01
9b4: 91 50 subi r25, 0x01 ; 1
9b6: 70 96 adiw r30, 0x10 ; 16
9b8: 97 ff sbrs r25, 7
9ba: f6 cf rjmp .-20 ; 0x9a8 <wsor+0x3a>
}
set(1);
9bc: 81 e0 ldi r24, 0x01 ; 1
9be: 0e 94 44 02 call 0x488 <set>
wp();
9c2: 0e 94 ee 03 call 0x7dc <wp>
9c6: 0b c0 rjmp .+22 ; 0x9de <wsor+0x70>
}
else //未选定, 显示光标
{
w16();
9c8: 0e 94 58 04 call 0x8b0 <w16>
wp();
9cc: 0e 94 ee 03 call 0x7dc <wp>
go(x,y);
9d0: 6c 2f mov r22, r28
9d2: 81 2f mov r24, r17
9d4: 0e 94 4c 03 call 0x698 <go>
set(2);
9d8: 82 e0 ldi r24, 0x02 ; 2
9da: 0e 94 44 02 call 0x488 <set>
9de: cf 91 pop r28
9e0: 1f 91 pop r17
9e2: 08 95 ret
000009e4 <rk>:
volatile uchar kp; //some key is press
uchar rk(void)
{uchar u1,u2,u3;
PORTA=0xf0;
9e4: 30 ef ldi r19, 0xF0 ; 240
9e6: 3b bb out 0x1b, r19 ; 27
DDRA =0x0f;
9e8: 2f e0 ldi r18, 0x0F ; 15
9ea: 2a bb out 0x1a, r18 ; 26
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
9ec: 82 e1 ldi r24, 0x12 ; 18
9ee: 90 e0 ldi r25, 0x00 ; 0
__asm__ volatile (
9f0: 01 97 sbiw r24, 0x01 ; 1
9f2: f1 f7 brne .-4 ; 0x9f0 <rk+0xc>
dy(10);
u1=PINA&0xf0; //get high 4 bits
9f4: 89 b3 in r24, 0x19 ; 25
u1>>=4;
9f6: 82 95 swap r24
9f8: 8f 70 andi r24, 0x0F ; 15
u1=pgm_read_byte(tk1+u1);
9fa: e8 2f mov r30, r24
9fc: ff 27 eor r31, r31
9fe: ec 59 subi r30, 0x9C ; 156
a00: ff 4f sbci r31, 0xFF ; 255
a02: 44 91 lpm r20, Z
PORTA=0x0f;
a04: 2b bb out 0x1b, r18 ; 27
DDRA=0xf0;
a06: 3a bb out 0x1a, r19 ; 26
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
a08: 82 e1 ldi r24, 0x12 ; 18
a0a: 90 e0 ldi r25, 0x00 ; 0
__asm__ volatile (
a0c: 01 97 sbiw r24, 0x01 ; 1
a0e: f1 f7 brne .-4 ; 0xa0c <rk+0x28>
dy(10);
u2=pgm_read_byte(tk1+(PINA&0x0f));
a10: 89 b3 in r24, 0x19 ; 25
a12: e8 2f mov r30, r24
a14: ff 27 eor r31, r31
a16: ef 70 andi r30, 0x0F ; 15
a18: f0 70 andi r31, 0x00 ; 0
a1a: ec 59 subi r30, 0x9C ; 156
a1c: ff 4f sbci r31, 0xFF ; 255
a1e: 84 91 lpm r24, Z
if(u1!=0xff&&u2!=0xff) //some key press
a20: 4f 3f cpi r20, 0xFF ; 255
a22: 71 f0 breq .+28 ; 0xa40 <rk+0x5c>
a24: 8f 3f cpi r24, 0xFF ; 255
a26: 61 f0 breq .+24 ; 0xa40 <rk+0x5c>
u3=pgm_read_byte(*(tk2+u1)+u2);
a28: e4 2f mov r30, r20
a2a: ff 27 eor r31, r31
a2c: ee 0f add r30, r30
a2e: ff 1f adc r31, r31
a30: ee 0f add r30, r30
a32: ff 1f adc r31, r31
a34: e8 0f add r30, r24
a36: f1 1d adc r31, r1
a38: ec 5a subi r30, 0xAC ; 172
a3a: ff 4f sbci r31, 0xFF ; 255
a3c: e4 91 lpm r30, Z
a3e: 01 c0 rjmp .+2 ; 0xa42 <rk+0x5e>
else
u3=0xff; //no key press
a40: ef ef ldi r30, 0xFF ; 255
PORTA=0x00;
a42: 1b ba out 0x1b, r1 ; 27
DDRA=0xff; //resume PA
a44: 8f ef ldi r24, 0xFF ; 255
a46: 8a bb out 0x1a, r24 ; 26
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
a48: 82 e1 ldi r24, 0x12 ; 18
a4a: 90 e0 ldi r25, 0x00 ; 0
__asm__ volatile (
a4c: 01 97 sbiw r24, 0x01 ; 1
a4e: f1 f7 brne .-4 ; 0xa4c <rk+0x68>
dy(10);
return(u3);
}
a50: 8e 2f mov r24, r30
a52: 99 27 eor r25, r25
a54: 08 95 ret
00000a56 <key>:
uchar key(void)
{
a56: cf 93 push r28
uchar ret;
if(kp==0)
a58: 80 91 77 04 lds r24, 0x0477
a5c: 88 23 and r24, r24
a5e: 99 f4 brne .+38 ; 0xa86 <key+0x30>
{
ret=rk();
a60: 0e 94 f2 04 call 0x9e4 <rk>
a64: c8 2f mov r28, r24
if(ret!=0xff)
a66: 8f 3f cpi r24, 0xFF ; 255
a68: f9 f0 breq .+62 ; 0xaa8 <key+0x52>
{
delay(10);
a6a: 8a e0 ldi r24, 0x0A ; 10
a6c: 90 e0 ldi r25, 0x00 ; 0
a6e: 0e 94 23 02 call 0x446 <delay>
if(ret==rk())
a72: 0e 94 f2 04 call 0x9e4 <rk>
a76: c8 17 cp r28, r24
a78: 21 f4 brne .+8 ; 0xa82 <key+0x2c>
kp=1;
a7a: 81 e0 ldi r24, 0x01 ; 1
a7c: 80 93 77 04 sts 0x0477, r24
a80: 13 c0 rjmp .+38 ; 0xaa8 <key+0x52>
else ret=0xff;
a82: cf ef ldi r28, 0xFF ; 255
a84: 11 c0 rjmp .+34 ; 0xaa8 <key+0x52>
}
return(ret);
}
else
{
if(rk()==0xff)
a86: 0e 94 f2 04 call 0x9e4 <rk>
a8a: 8f 3f cpi r24, 0xFF ; 255
a8c: 61 f4 brne .+24 ; 0xaa6 <key+0x50>
{delay(10);
a8e: 8a e0 ldi r24, 0x0A ; 10
a90: 90 e0 ldi r25, 0x00 ; 0
a92: 0e 94 23 02 call 0x446 <delay>
if(rk()==0xff)
a96: 0e 94 f2 04 call 0x9e4 <rk>
a9a: 8f 3f cpi r24, 0xFF ; 255
a9c: 21 f4 brne .+8 ; 0xaa6 <key+0x50>
kp=0, ret=0xff;
a9e: 10 92 77 04 sts 0x0477, r1
aa2: c8 2f mov r28, r24
aa4: 01 c0 rjmp .+2 ; 0xaa8 <key+0x52>
else
ret=0x80;
}
else ret=0x80;
aa6: c0 e8 ldi r28, 0x80 ; 128
}
return(ret);
aa8: 8c 2f mov r24, r28
aaa: 99 27 eor r25, r25
aac: cf 91 pop r28
aae: 08 95 ret
00000ab0 <d_ini>:
volatile uchar su;
void d_ini(void)
{
ab0: 0f 93 push r16
ab2: 1f 93 push r17
uint tmp;
sor=0;
ab4: 10 92 64 00 sts 0x0064, r1
sorf=0;
ab8: 10 92 66 00 sts 0x0066, r1
su=0;
abc: 10 92 65 00 sts 0x0065, r1
/** \ingroup avr_eeprom
Read one 16-bit word (little endian) from EEPROM address \c addr. */
uint16_t
eeprom_read_word (const uint16_t *addr)
{
ac0: a1 e0 ldi r26, 0x01 ; 1
ac2: b0 e0 ldi r27, 0x00 ; 0
uint16_t result;
asm (
ac4: 0e 94 c3 07 call 0xf86 <__eeprom_read_word_1C1D1E>
ac8: 8f 01 movw r16, r30
tmp=eeprom_read_word(&SEEK);
srand(tmp);
aca: cf 01 movw r24, r30
acc: 0e 94 99 07 call 0xf32 <srand>
Write a byte \c value to EEPROM address \c addr. */
void
eeprom_write_byte (uint8_t *addr,uint8_t value)
{
ad0: a1 e0 ldi r26, 0x01 ; 1
ad2: b0 e0 ldi r27, 0x00 ; 0
ad4: 80 2f mov r24, r16
ad6: 8f 5f subi r24, 0xFF ; 255
asm volatile (
ad8: 08 2e mov r0, r24
ada: 0e 94 c8 07 call 0xf90 <__eeprom_write_byte_1C1D1E>
ade: 1f 91 pop r17
ae0: 0f 91 pop r16
ae2: 08 95 ret
00000ae4 <s_ini>:
tmp++; //每次启动+1, 使随机数的种子不同
eeprom_write_byte(&SEEK,tmp);
}//*/
void s_ini(void)
{
PORTD=0x00;
ae4: 12 ba out 0x12, r1 ; 18
DDRD=0xf0;
ae6: 80 ef ldi r24, 0xF0 ; 240
ae8: 81 bb out 0x11, r24 ; 17
PORTC=0x00;
aea: 15 ba out 0x15, r1 ; 21
DDRC=0x03;
aec: 83 e0 ldi r24, 0x03 ; 3
aee: 84 bb out 0x14, r24 ; 20
PORTB=0x00;
af0: 18 ba out 0x18, r1 ; 24
DDRB=0xff;
af2: 8f ef ldi r24, 0xFF ; 255
af4: 87 bb out 0x17, r24 ; 23
PORTA=0x00;
af6: 1b ba out 0x1b, r1 ; 27
DDRA=0xff;
af8: 8a bb out 0x1a, r24 ; 26
d_ini();
afa: 0e 94 58 05 call 0xab0 <d_ini>
afe: 08 95 ret
00000b00 <RAND>:
}
uchar RAND(uchar n) //
{
b00: 1f 93 push r17
b02: 18 2f mov r17, r24
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
b04: 82 e1 ldi r24, 0x12 ; 18
b06: 90 e0 ldi r25, 0x00 ; 0
__asm__ volatile (
b08: 01 97 sbiw r24, 0x01 ; 1
b0a: f1 f7 brne .-4 ; 0xb08 <RAND+0x8>
uchar ret;
ulong tp,tp2;
//srand(15);
dy(10);
tp2=rand(15);
b0c: 8f e0 ldi r24, 0x0F ; 15
b0e: 90 e0 ldi r25, 0x00 ; 0
b10: 0e 94 94 07 call 0xf28 <rand>
b14: aa 27 eor r26, r26
b16: 97 fd sbrc r25, 7
b18: a0 95 com r26
b1a: ba 2f mov r27, r26
tp=(tp2*(n))>>15;
b1c: 21 2f mov r18, r17
b1e: 33 27 eor r19, r19
b20: 44 27 eor r20, r20
b22: 55 27 eor r21, r21
b24: bc 01 movw r22, r24
b26: cd 01 movw r24, r26
b28: 0e 94 a4 07 call 0xf48 <__mulsi3>
b2c: dc 01 movw r26, r24
b2e: cb 01 movw r24, r22
b30: 5f e0 ldi r21, 0x0F ; 15
b32: b6 95 lsr r27
b34: a7 95 ror r26
b36: 97 95 ror r25
b38: 87 95 ror r24
b3a: 5a 95 dec r21
b3c: d1 f7 brne .-12 ; 0xb32 <RAND+0x32>
ret=tp;
return ret;
}
b3e: 99 27 eor r25, r25
b40: 1f 91 pop r17
b42: 08 95 ret
00000b44 <wash>:
void wash(void) //洗牌
{
b44: 0f 93 push r16
b46: 1f 93 push r17
b48: cf 93 push r28
uchar i,j,tmp;
clr(3);
b4a: 83 e0 ldi r24, 0x03 ; 3
b4c: 0e 94 f9 02 call 0x5f2 <clr>
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -