文章目录
1. phase_1 (if语句 + 字符串)
命令：
x/s 0x402400
输出：
Border relations with Canada have never been better.
2. phase_2 （循环）
通过观察read_six_numbers函数，发现其作用是读取六个整数，并给phase_2的栈帧里面的六个int型变量赋值。
然后返回phase_2函数，首先判断栈顶元素是否等于1，不成立的话直接炸弹引爆，否则：继续比较栈其他5个变量（大小为24的int型数组）的值是否满足条件：1 2 4 8 16 32，直到到达栈帧底部(%rbp)。总体而言就是一个while循环。
3. phase_3 （switch语句）
读取2个整数
通过400f75: ff 24 c5 70 24 40 00 jmpq *0x402470(,%rax,8)可知：
通过0x402470应该是switch跳表的首地址。
然后通过rax的值，0—6进行跳转。
0：0xcf
1：0x2c3
2：0x100
3：0x185
4：0xce
5：0x2aa
6：0x147
细节：
scanf返回值意义为：所输入的数据与格式字符串中匹配次数。
它返回已成功赋值的数据项数；出错时则返回EOF。
4. phase_4 （递归）
也是读取两个整数：
40100c: 48 83 ec 18 sub $0x18,%rsp
401010: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx
401015: 48 8d 54 24 08 lea 0x8(%rsp),%rdx
40101a: be cf 25 40 00 mov $0x4025cf,%esi // %d %d
40101f: b8 00 00 00 00 mov $0x0,%eax
401024: e8 c7 fb ff ff callq 400bf0 <__isoc99_sscanf@plt>
如果输入参数个数小于2，则引爆：
401029: 83 f8 02 cmp $0x2,%eax
40102c: 75 07 jne 401035 <phase_4+0x29> // explode_bomb
比较栈顶的第一个unsigned int变量，如果小于等于14，则调用函数fun4，否则引爆炸弹：
40102e: 83 7c 24 08 0e cmpl $0xe,0x8(%rsp) // 14
401033: 76 05 jbe 40103a <phase_4+0x2e> // <= 14
401035: e8 00 04 00 00 callq 40143a <explode_bomb>
为fun4形参做准备，并将栈顶的第一个变量也传入：
40103a: ba 0e 00 00 00 mov $0xe,%edx // %edx = 14
40103f: be 00 00 00 00 mov $0x0,%esi // %esi = 0
401044: 8b 7c 24 08 mov 0x8(%rsp),%edi
401048: e8 81 ff ff ff callq 400fce <func4> // func4
如果func4的返回参数不等于0，则引爆炸弹：
40104d: 85 c0 test %eax,%eax
40104f: 75 07 jne 401058 <phase_4+0x4c> // explode_bomb
比较栈里面的第二个变量，如果等于0，则返回：
401051: 83 7c 24 0c 00 cmpl $0x0,0xc(%rsp)
401056: 74 05 je 40105d <phase_4+0x51> // ret
不等于0，则引爆炸弹：
401058: e8 dd 03 00 00 callq 40143a <explode_bomb>
40105d: 48 83 c4 18 add $0x18,%rsp
401061: c3 retq
func4：
0000000000400fce <func4>:
400fce: 48 83 ec 08 sub $0x8,%rsp
400fd2: 89 d0 mov %edx,%eax
400fd4: 29 f0 sub %esi,%eax
400fd6: 89 c1 mov %eax,%ecx
400fd8: c1 e9 1f shr $0x1f,%ecx
400fdb: 01 c8 add %ecx,%eax
400fdd: d1 f8 sar %eax
400fdf: 8d 0c 30 lea (%rax,%rsi,1),%ecx
400fe2: 39 f9 cmp %edi,%ecx
400fe4: 7e 0c jle 400ff2 <func4+0x24>
400fe6: 8d 51 ff lea -0x1(%rcx),%edx
400fe9: e8 e0 ff ff ff callq 400fce <func4>
400fee: 01 c0 add %eax,%eax
400ff0: eb 15 jmp 401007 <func4+0x39>
400ff2: b8 00 00 00 00 mov $0x0,%eax
400ff7: 39 f9 cmp %edi,%ecx
400ff9: 7d 0c jge 401007 <func4+0x39>
400ffb: 8d 71 01 lea 0x1(%rcx),%esi
400ffe: e8 cb ff ff ff callq 400fce <func4>
401003: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax
401007: 48 83 c4 08 add $0x8,%rsp
40100b: c3 retq
将fun4写为相应的C版本：
int func4(int y, int x, int z)
{
// int y = 14 (%edx), x = 0 (%esi), z = 输入的第一个数 (%edi);
int ret = y, i;
ret = ret - x;
i = ret; // y - x
i =>> 31; //逻辑右移
ret += i; //负数加一，正数不变
ret = ret / 2; //算术右移
i= ret + x; // i = (y - x) / 2 + x; i为x和y之间的中位数。
if (i <= z) //如果传入参数小于中位数
{
if (i == z)
return 0;
x = i + 1; //递归调用使得中位数越来越大
return 2 * func4(x, y, z) + 1; //奇数
} else { //如果大于中位数
y = i- 1; //每次上界y减小，一定返回0
return 2 * func4(x, y, z); //偶数
}
return ret;
}
综合这个程序，发现当z = 7时，函数直接返回0，跳过炸弹。
故答案为：7 0 或 3 0 或 1 0 或 0 0。
5. phase_5（字符串处理）
400e7c: bf 0b 23 40 00 mov $0x40230b,%edi // 0x40230b
400e81: e8 8a fc ff ff callq 400b10 <puts@plt>
400e86: e8 13 06 00 00 callq 40149e <read_line> // 读取字符串
400e8b: 48 89 c7 mov %rax,%rdi //把返回值放在%rdi
400e8e: e8 79 01 00 00 callq 40100c <phase_4>
400e93: e8 2c 07 00 00 callq 4015c4 <phase_defused>
0000000000401062 <phase_5>:
401062: 53 push %rbx
401063: 48 83 ec 20 sub $0x20,%rsp // 准备阶段
401067: 48 89 fb mov %rdi,%rbx //把字符串开始的地址放到%rbx
40106a: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
401071: 00 00
401073: 48 89 44 24 18 mov %rax,0x18(%rsp) //放置哨兵
401078: 31 c0 xor %eax,%eax //把%eax置为0
40107a: e8 9c 02 00 00 callq 40131b <string_length> //调用string_length函数
40107f: 83 f8 06 cmp $0x6,%eax
401082: 74 4e je 4010d2 <phase_5+0x70> // 如果字符串长度等于6，则跳转到4010d2处
401084: e8 b1 03 00 00 callq 40143a <explode_bomb> //如果不等于6，,则引爆炸弹
401089: eb 47 jmp 4010d2 <phase_5+0x70> //跳转至4010d2处
// 将 输入字符串 进行映射
0x4024b0 <array.3449>: "madui ersnf otvby lSo you think you can stop the bomb with ctrl-c, do you?"
0x40245e: "flyers"
40108b: 0f b6 0c 03 movzbl (%rbx,%rax,1),%ecx //取出一字节内容，%ecx = (%rbx + %rax)（并且int型0扩展）
40108f: 88 0c 24 mov %cl,(%rsp) //取低一位字节
401092: 48 8b 14 24 mov (%rsp),%rdx // %rdx = %cl
401096: 83 e2 0f and $0xf,%edx //取%edx的低4位
/*
9 15 14 5 6 7 偏置
*/
401099: 0f b6 92 b0 24 40 00 movzbl 0x4024b0(%rdx),%edx //把(%rdx + 0x4024b0)地址处的内容0扩展放置与%edx
//
4010a0: 88 54 04 10 mov %dl,0x10(%rsp,%rax,1) //把%rdx低一位字节的值放置到(%rsp + %rax + 16)处
最终字符串：
4010a4: 48 83 c0 01 add $0x1,%rax // %rax加1（依次取出字符串的每一个字符）
4010a8: 48 83 f8 06 cmp $0x6,%rax
4010ac: 75 dd jne 40108b <phase_5+0x29> //如果%rax中的值不等于6则继续循环
4010ae: c6 44 24 16 00 movb $0x0,0x16(%rsp) // 把(%rsp + 0x16)的一个字节内容置为0
4010b3: be 5e 24 40 00 mov $0x40245e,%esi // %esi = 0x40245e （可以推断，此处应该放的是需要比对的字符串）
4010b8: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi // %rdi = %rsp + 0x10
4010bd: e8 76 02 00 00 callq 401338 <strings_not_equal> // 调用strings_not_equal函数
4010c2: 85 c0 test %eax,%eax
4010c4: 74 13 je 4010d9 <phase_5+0x77> // 如果返回值为0则跳转至4010d9处
4010c6: e8 6f 03 00 00 callq 40143a <explode_bomb> // 如果不为0，则引爆炸弹
4010cb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) // nopl指令
4010d0: eb 07 jmp 4010d9 <phase_5+0x77> // 检查栈帧
4010d2: b8 00 00 00 00 mov $0x0,%eax // 把%eax置为0
4010d7: eb b2 jmp 40108b <phase_5+0x29> // 跳转至40108b处
4010d9: 48 8b 44 24 18 mov 0x18(%rsp),%rax //代码正在执行堆栈保护检查
4010de: 64 48 33 04 25 28 00 xor %fs:0x28,%rax
4010e5: 00 00
4010e7: 74 05 je 4010ee <phase_5+0x8c> //如果相等则返回
4010e9: e8 42 fa ff ff callq 400b30 <__stack_chk_fail@plt>
4010ee: 48 83 c4 20 add $0x20,%rsp //结束阶段
4010f2: 5b pop %rbx
4010f3: c3 retq
string_length函数：
000000000040131b <string_length>:
40131b: 80 3f 00 cmpb $0x0,(%rdi)
40131e: 74 12 je 401332 <string_length+0x17> // 如果值为0，返回0
401320: 48 89 fa mov %rdi,%rdx
401323: 48 83 c2 01 add $0x1,%rdx
401327: 89 d0 mov %edx,%eax
401329: 29 f8 sub %edi,%eax
40132b: 80 3a 00 cmpb $0x0,(%rdx)
40132e: 75 f3 jne 401323 <string_length+0x8> // 如果字符还不为空，则继续比较
401330: f3 c3 repz retq // 否则，则返回字符串长度
401332: b8 00 00 00 00 mov $0x0,%eax
401337: c3 retq
(gdb) x/s 0x4024b0
0x4024b0 <array.3449>: "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
(gdb) x/s 0x40245e
0x40245e: "flyers"
结果：
低四位
第一个字符 9 1001
第二个字符 15 1111
第三个字符 14 1100
第四个字符 5 0101
第五个字符 6 0110
第六个字符 7 0111
满足以上情况的字符串即可。如：y, o, n, u, v, w 。
6. phase_6（双重for循环 + 链表）
400eb4: bf 1a 23 40 00 mov $0x40231a,%edi // 0x40231a
400eb9: e8 52 fc ff ff callq 400b10 <puts@plt>
400ebe: e8 db 05 00 00 callq 40149e <read_line>
400ec3: 48 89 c7 mov %rax,%rdi // %rdi = %rax
400ec6: e8 29 02 00 00 callq 4010f4 <phase_6>
400ecb: e8 f4 06 00 00 callq 4015c4 <phase_defused>
00000000004010f4 <phase_6>:
4010f4: 41 56 push %r14
4010f6: 41 55 push %r13
4010f8: 41 54 push %r12
4010fa: 55 push %rbp
4010fb: 53 push %rbx
4010fc: 48 83 ec 50 sub $0x50,%rsp
401100: 49 89 e5 mov %rsp,%r13 // %13 = %rsp
401103: 48 89 e6 mov %rsp,%rsi // %rsi = %rsp
401106: e8 51 03 00 00 callq 40145c <read_six_numbers> //读取六个整数
40110b: 49 89 e6 mov %rsp,%r14 // %r14 = %rsp
40110e: 41 bc 00 00 00 00 mov $0x0,%r12d // %12d = 0
401114: 4c 89 ed mov %r13,%rbp // %rbp = %r13
401117: 41 8b 45 00 mov 0x0(%r13),%eax //%eax = (%r13 + 0)
40111b: 83 e8 01 sub $0x1,%eax // %eax = %eax - 1
40111e: 83 f8 05 cmp $0x5,%eax
401121: 76 05 jbe 401128 <phase_6+0x34> // 如果%eax小于等于5则跳转到401128指令处
401123: e8 12 03 00 00 callq 40143a <explode_bomb> // 如果大于5，则引爆炸弹
401128: 41 83 c4 01 add $0x1,%r12d // %r12d = %r12d + 1
40112c: 41 83 fc 06 cmp $0x6,%r12d
401130: 74 21 je 401153 <phase_6+0x5f> // 如果%r12d等于6则跳转至401153处
401132: 44 89 e3 mov %r12d,%ebx // %ebx = %r12d
401135: 48 63 c3 movslq %ebx,%rax // %rax = %ebx（符号扩展）
401138: 8b 04 84 mov (%rsp,%rax,4),%eax //%eax = (%rsp + 4*%rax)
40113b: 39 45 00 cmp %eax,0x0(%rbp)
40113e: 75 05 jne 401145 <phase_6+0x51> //如果(%rbp)不等于%eax，则跳转至401145处
401140: e8 f5 02 00 00 callq 40143a <explode_bomb> // 否则引爆炸弹
401145: 83 c3 01 add $0x1,%ebx //%ebx = %ebx + 1
401148: 83 fb 05 cmp $0x5,%ebx
40114b: 7e e8 jle 401135 <phase_6+0x41> // 如果%ebx小于等于5，则跳转至401135处
40114d: 49 83 c5 04 add $0x4,%r13 // %r13 = %r13 + 4
401151: eb c1 jmp 401114 <phase_6+0x20> //跳转至401114处
401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi // %rsi = %rsp + 24
401158: 4c 89 f0 mov %r14,%rax // %rax = %r14
40115b: b9 07 00 00 00 mov $0x7,%ecx // %ecx = 7
401160: 89 ca mov %ecx,%edx // %edx = %ecx
401162: 2b 10 sub (%rax),%edx // %edx = %edx - (%rax)
401164: 89 10 mov %edx,(%rax) // (%rax) = %edx
401166: 48 83 c0 04 add $0x4,%rax // %rax = %rax + 4
40116a: 48 39 f0 cmp %rsi,%rax
40116d: 75 f1 jne 401160 <phase_6+0x6c> //如果%rax != %rsi，则跳转至401160处
40116f: be 00 00 00 00 mov $0x0,%esi // 否则，%esi = 0
401174: eb 21 jmp 401197 <phase_6+0xa3> //跳转至401197处
401176: 48 8b 52 08 mov 0x8(%rdx),%rdx // %rdx = (%rdx + 8)
40117a: 83 c0 01 add $0x1,%eax // %eax = %eax + 1
40117d: 39 c8 cmp %ecx,%eax
40117f: 75 f5 jne 401176 <phase_6+0x82> // 如果%ea不等于%ecx，则跳转至401176处
401181: eb 05 jmp 401188 <phase_6+0x94> // 否则跳转至401188处
401183: ba d0 32 60 00 mov $0x6032d0,%edx // %edx = 0x6032d0
401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2) // (%rsp + 2*%rsi + 0x20) = %rdx
40118d: 48 83 c6 04 add $0x4,%rsi // %rsi = %rsi + 4
401191: 48 83 fe 18 cmp $0x18,%rsi
401195: 74 14 je 4011ab <phase_6+0xb7> // 如果%rsi等于0x18则跳转至4011ab处
401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx // %ecx = (%rsp + %rsi)
40119a: 83 f9 01 cmp $0x1,%ecx
40119d: 7e e4 jle 401183 <phase_6+0x8f> // 如果%ecx小于等于1，则跳转至401183处
40119f: b8 01 00 00 00 mov $0x1,%eax // %eax = 1
4011a4: ba d0 32 60 00 mov $0x6032d0,%edx // %edx = 0x6032d0
4011a9: eb cb jmp 401176 <phase_6+0x82> // 跳转至401176处
4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx // %rbx = (%rsp + 0x20)
4011b0: 48 8d 44 24 28 lea 0x28(%rsp),%rax // %rax = %rsp + 0x28
4011b5: 48 8d 74 24 50 lea 0x50(%rsp),%rsi // %rsi = %rsp + 0x50
4011ba: 48 89 d9 mov %rbx,%rcx // %rcx = %rbx
4011bd: 48 8b 10 mov (%rax),%rdx // %rdx = (%rax)
4011c0: 48 89 51 08 mov %rdx,0x8(%rcx) // (%rcx + 8) = %rdx
4011c4: 48 83 c0 08 add $0x8,%rax // %rax = %rax + 8
4011c8: 48 39 f0 cmp %rsi,%rax
4011cb: 74 05 je 4011d2 <phase_6+0xde> // 如果%rax等于%rsi，则跳转至4011d2处
4011cd: 48 89 d1 mov %rdx,%rcx // %rcx = %rdx
4011d0: eb eb jmp 4011bd <phase_6+0xc9> //跳转至4011bd处
4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx) // (%rdx + 8) = 0
4011d9: 00
4011da: bd 05 00 00 00 mov $0x5,%ebp // %ebp = 5
4011df: 48 8b 43 08 mov 0x8(%rbx),%rax // %rax = (%rbx + 8)
4011e3: 8b 00 mov (%rax),%eax // %eax = (%rax)
4011e5: 39 03 cmp %eax,(%rbx)
4011e7: 7d 05 jge 4011ee <phase_6+0xfa> // 如果(%rbx)大于等于%eax，则跳转至4011ee处
4011e9: e8 4c 02 00 00 callq 40143a <explode_bomb> // 否则引爆炸弹
4011ee: 48 8b 5b 08 mov 0x8(%rbx),%rbx // %rbx = (%rbx + 8)
4011f2: 83 ed 01 sub $0x1,%ebp // %ebp = %ebp - 1
4011f5: 75 e8 jne 4011df <phase_6+0xeb> // 如果%ebp不等于0，则跳转至4011df处
4011f7: 48 83 c4 50 add $0x50,%rsp // 回收栈帧
4011fb: 5b pop %rbx
4011fc: 5d pop %rbp
4011fd: 41 5c pop %r12
4011ff: 41 5d pop %r13
401201: 41 5e pop %r14
401203: c3 retq
7. secret_phase （递归调用）
0000000000401242 <secret_phase>:
401242: 53 push %rbx
401243: e8 56 02 00 00 callq 40149e <read_line>
401248: ba 0a 00 00 00 mov $0xa,%edx //base
40124d: be 00 00 00 00 mov $0x0,%esi //endptr
401252: 48 89 c7 mov %rax,%rdi //str
401255: e8 76 f9 ff ff callq 400bd0 <strtol@plt> // long int strtol(const char *str, char **endptr, int base) ；
40125a: 48 89 c3 mov %rax,%rbx // 把函数返回值放入%rbx
40125d: 8d 40 ff lea -0x1(%rax),%eax // %eax = %rax - 1
401260: 3d e8 03 00 00 cmp $0x3e8,%eax
401265: 76 05 jbe 40126c <secret_phase+0x2a> // 如果%eax小于等于0x3e8，则跳转至40126c处
401267: e8 ce 01 00 00 callq 40143a <explode_bomb>
40126c: 89 de mov %ebx,%esi // %esi = %ebx y
40126e: bf f0 30 60 00 mov $0x6030f0,%edi // %edi = 0x6030f0 x
401273: e8 8c ff ff ff callq 401204 <fun7> // 调用函数fun7
401278: 83 f8 02 cmp $0x2,%eax
40127b: 74 05 je 401282 <secret_phase+0x40> // 如果fun7返回值等于2，则跳过炸弹
40127d: e8 b8 01 00 00 callq 40143a <explode_bomb>
401282: bf 38 24 40 00 mov $0x402438,%edi
401287: e8 84 f8 ff ff callq 400b10 <puts@plt>
40128c: e8 33 03 00 00 callq 4015c4 <phase_defused>
401291: 5b pop %rbx
401292: c3 retq
401293: 90 nop
401294: 90 nop
401295: 90 nop
401296: 90 nop
401297: 90 nop
401298: 90 nop
401299: 90 nop
40129a: 90 nop
40129b: 90 nop
40129c: 90 nop
40129d: 90 nop
40129e: 90 nop
40129f: 90 nop
0000000000401204 <fun7>:
401204: 48 83 ec 08 sub $0x8,%rsp
401208: 48 85 ff test %rdi,%rdi // edi = 0x6030f0
40120b: 74 2b je 401238 <fun7+0x34> // 如果str为空，则跳转至401238处
40120d: 8b 17 mov (%rdi),%edx // %edx = (%rdi)
40120f: 39 f2 cmp %esi,%edx // %esi = 输入的整数部分
401211: 7e 0d jle 401220 <fun7+0x1c> // 如果%edx小于等于%esi，则跳转至401220处
401213: 48 8b 7f 08 mov 0x8(%rdi),%rdi // %rdi = (%rdi + 8)
401217: e8 e8 ff ff ff callq 401204 <fun7> // 调用fun7
40121c: 01 c0 add %eax,%eax // %eax = %eax + %eax
40121e: eb 1d jmp 40123d <fun7+0x39> // 跳转至40123d处
401220: b8 00 00 00 00 mov $0x0,%eax // %eax = 0
401225: 39 f2 cmp %esi,%edx
401227: 74 14 je 40123d <fun7+0x39> // 如果%edx等于%esi，则跳转至40123d处，即返回
401229: 48 8b 7f 10 mov 0x10(%rdi),%rdi // %rdi = (%rdi + 16)
40122d: e8 d2 ff ff ff callq 401204 <fun7> // 调用函数fun7
401232: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax // %eax = (%rax + %rax + 1)
401236: eb 05 jmp 40123d <fun7+0x39> //跳转至40123d处
401238: b8 ff ff ff ff mov $0xffffffff,%eax // %eax = 0xffff ffff，返回值为-1
40123d: 48 83 c4 08 add $0x8,%rsp
401241: c3 retq
将fun7写成大概相应的c语句：
int fun7(int x, long int y)
{
if (x == 0)
return -1;
int z = *((int *)x), ret;
if (y <= z)
{
ret = 0;
if (y == z) return ret;
x = *((int *)x + 16);
return 2*fun7(x, y) + 1; // y < z
}
else {
x = *((int*)x + 8);
return 2*fun7(x, y);
}
return -1;
}
(gdb) p /x *(0x6030f0)
$1 = 0x24
(gdb) p /x *(0x6030f0 + 8)
$2 = 0x603110
(gdb) p /x *(0x603110 + 16)
$3 = 0x603150
(gdb) p /x *(0x603150)
$4 = 0x16
正确递归调用顺序：
- 2*fun7(x, y)
- 2*fun7(x, y) + 1
- return 0
故第三次结束递归，值为22。
内存分析：
(gdb) x/60wx 0x6030f0
0x6030f0 <n1>: 0x00000024 0x00000000 0x00603110 0x00000000
0x603100 <n1+16>: 0x00603130 0x00000000 0x00000000 0x00000000
0x603110 <n21>: 0x00000008 0x00000000 0x00603190 0x00000000
0x603120 <n21+16>: 0x00603150 0x00000000 0x00000000 0x00000000
0x603130 <n22>: 0x00000032 0x00000000 0x00603170 0x00000000
0x603140 <n22+16>: 0x006031b0 0x00000000 0x00000000 0x00000000
0x603150 <n32>: 0x00000016 0x00000000 0x00603270 0x00000000
0x603160 <n32+16>: 0x00603230 0x00000000 0x00000000 0x00000000
0x603170 <n33>: 0x0000002d 0x00000000 0x006031d0 0x00000000
0x603180 <n33+16>: 0x00603290 0x00000000 0x00000000 0x00000000
0x603190 <n31>: 0x00000006 0x00000000 0x006031f0 0x00000000
0x6031a0 <n31+16>: 0x00603250 0x00000000 0x00000000 0x00000000
0x6031b0 <n34>: 0x0000006b 0x00000000 0x00603210 0x00000000
0x6031c0 <n34+16>: 0x006032b0 0x00000000 0x00000000 0x00000000
0x6031d0 <n45>: 0x00000028 0x00000000 0x00000000 0x00000000
8. 实验结果
3342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
