Split (1)

train · ~2.3M rows (showing the first 1.36M)

name stringlengths 1 473k	code stringlengths 7 647k	asm stringlengths 4 3.39M	file stringlengths 8 196
PPC_alias_insn	bool PPC_alias_insn(const char name, struct ppc_alias alias) { size_t i; #ifndef CAPSTONE_DIET int x; #endif for(i = 0; i < ARR_SIZE(alias_insn_name_maps); i++) { if (!strcmp(name, alias_insn_name_maps[i].mnem)) { alias->id = alias_insn_name_maps[i].id; alias->cc = alias_insn_name_maps[i].cc; return true; } } #ifndef CAPSTONE_DIET // not really an alias insn x = name2id(&insn_name_maps[1], ARR_SIZE(insn_name_maps) - 1, name); if (x != -1) { alias->id = insn_name_maps[x].id; alias->cc = PPC_BC_INVALID; return true; } #endif // not found return false; }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 pushq $-0x10 popq %rcx leaq 0xfa172(%rip), %r15 # 0x198c20 leaq 0x10(%rcx), %r12 cmpq $0x500, %r12 # imm = 0x500 je 0x9eada movq 0x18(%rcx,%r15), %rsi movq %r14, %rdi callq 0x440d0 movq %r12, %rcx testl %eax, %eax jne 0x9eaae movl (%r12,%r15), %ecx movl 0x4(%r12,%r15), %eax jmp 0x9eb08 leaq 0x18849f(%rip), %rdi # 0x226f80 movl $0x3a5, %esi # imm = 0x3A5 movq %r14, %rdx callq 0x484c6 movl %eax, %ecx xorl %eax, %eax cmpl $-0x1, %ecx je 0x9eb0f movslq %ecx, %rcx shlq $0x4, %rcx leaq 0x18846b(%rip), %rdx # 0x226f70 movl (%rcx,%rdx), %ecx movl %ecx, (%rbx) movl %eax, 0x4(%rbx) movb $0x1, %al addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq	/radare[P]capstone/arch/PowerPC/PPCMapping.c
X86_getInstruction	bool X86_getInstruction(csh ud, const uint8_t code, size_t code_len, MCInst instr, uint16_t size, uint64_t address, void _info) { cs_struct handle = (cs_struct )(uintptr_t)ud; InternalInstruction insn; struct reader_info info; int ret; bool result; info.code = code; info.size = code_len; info.offset = address; memset(&insn, 0, offsetof(InternalInstruction, reader)); if (instr->flat_insn->detail) { instr->flat_insn->detail->x86.op_count = 0; instr->flat_insn->detail->x86.sse_cc = X86_SSE_CC_INVALID; instr->flat_insn->detail->x86.avx_cc = X86_AVX_CC_INVALID; instr->flat_insn->detail->x86.avx_sae = false; instr->flat_insn->detail->x86.avx_rm = X86_AVX_RM_INVALID; memset(instr->flat_insn->detail->x86.prefix, 0, sizeof(instr->flat_insn->detail->x86.prefix)); memset(instr->flat_insn->detail->x86.opcode, 0, sizeof(instr->flat_insn->detail->x86.opcode)); memset(instr->flat_insn->detail->x86.operands, 0, sizeof(instr->flat_insn->detail->x86.operands)); } if (handle->mode & CS_MODE_16) ret = decodeInstruction(&insn, reader, &info, address, MODE_16BIT); else if (handle->mode & CS_MODE_32) ret = decodeInstruction(&insn, reader, &info, address, MODE_32BIT); else ret = decodeInstruction(&insn, reader, &info, address, MODE_64BIT); if (ret) { size = (uint16_t)(insn.readerCursor - address); return false; } else { size = (uint16_t)insn.length; result = (!translateInstruction(instr, &insn)) ? true : false; if (result) { instr->imm_size = insn.immSize; if (handle->detail) { update_pub_insn(instr->flat_insn, &insn, instr->x86_prefix); } else { // still copy all prefixes instr->x86_prefix[0] = insn.prefix0; instr->x86_prefix[1] = insn.prefix1; instr->x86_prefix[2] = insn.prefix2; instr->x86_prefix[3] = insn.prefix3; } } return result; } }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xa08, %rsp # imm = 0xA08 movq %r9, %r12 movq %r8, %r15 movq %rcx, %rbx movq %rdi, %r14 movq %rsi, 0x8(%rsp) movq %rdx, 0x10(%rsp) movq %r9, 0x18(%rsp) leaq 0x20(%rsp), %rdi xorl %ebp, %ebp movl $0x938, %edx # imm = 0x938 xorl %esi, %esi callq 0x440c0 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax testq %rax, %rax je 0x9ec88 xorl %ecx, %ecx movb %cl, 0x5c(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax andl $0x0, 0x4c(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax andl $0x0, 0x50(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movb %cl, 0x54(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax andl $0x0, 0x58(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax andl $0x0, 0x30(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax andl $0x0, 0x34(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rdi addq $0x60, %rdi movl $0x180, %edx # imm = 0x180 xorl %esi, %esi callq 0x440c0 movl 0x4(%r14), %eax movl %eax, %ecx andl $0x4, %ecx cmpl $0x1, %ecx movl $0x0, %r8d adcl $0x1, %r8d testb $0x2, %al cmovnel %ebp, %r8d leaq 0x9e7(%rip), %rsi # 0x9f692 leaq 0x20(%rsp), %rdi leaq 0x8(%rsp), %rdx movq %r12, %rcx callq 0x9f6c0 testl %eax, %eax je 0x9ece3 movl 0x968(%rsp), %eax subl %r12d, %eax movw %ax, (%r15) xorl %eax, %eax addq $0xa08, %rsp # imm = 0xA08 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movzwl 0x990(%rsp), %eax movw %ax, (%r15) cmpq $0x0, 0x9b8(%rsp) je 0x9eccf movq %r14, (%rsp) movzwl 0x9b4(%rsp), %esi movq %rbx, %rdi callq 0x45579 cmpb $0x1, 0x149(%rsp) jne 0x9ed48 movq %rbx, %rdi callq 0x45580 movl $0x186f, %esi # imm = 0x186F cmpl $0x943, %eax # imm = 0x943 je 0x9ed40 movq %rbx, %rdi callq 0x45580 movl $0x1828, %esi # imm = 0x1828 cmpl $0x93b, %eax # imm = 0x93B jne 0x9ed48 movq %rbx, %rdi callq 0x45579 movb $0x0, 0x9ca(%rsp) xorl %r12d, %r12d leaq 0x4aaae(%rip), %r13 # 0xe9808 cmpq $0x5, %r12 je 0x9f527 movq 0xa00(%rsp), %rax movb (%rax,%r12,2), %cl testb %cl, %cl je 0x9f49f leaq (%rax,%r12,2), %r14 addq $-0xa2, %rax movzbl %cl, %ecx decl %ecx cmpl $0x1e, %ecx ja 0x9eccf movslq (%r13,%rcx,4), %rcx addq %r13, %rcx jmpq %rcx movzbl 0x1(%r14), %ecx leaq (%rax,%rcx,2), %r14 movb (%r14), %cl jmp 0x9ed82 movzbl 0x1(%r14), %ecx xorl %eax, %eax addl $-0x8, %ecx cmpl $0x4e, %ecx ja 0x9ecd1 leaq 0x4aac2(%rip), %rdx # 0xe9884 movslq (%rdx,%rcx,4), %rcx addq %rdx, %rcx jmpq %rcx movl 0x9f0(%rsp), %ecx xorl %eax, %eax cmpl $0x15, %ecx je 0x9ecd1 cmpl $0x25, %ecx je 0x9ecd1 addl $-0x31, %ecx cmpl $0xd3, %ecx jae 0x9eccf movl %ecx, %eax leaq 0x4ac8e(%rip), %rcx # 0xe9a8c movl (%rcx,%rax,4), %esi jmp 0x9f497 movzbl 0x9ca(%rsp), %eax leal 0x1(%rax), %ecx movb %cl, 0x9ca(%rsp) movq 0x9d0(%rsp,%rax,8), %r15 movzbl 0x1(%r14), %ebp leal -0xc(%rbp), %eax cmpl $0x4, %eax jae 0x9f037 movq %rbx, %rdi callq 0x45580 movzbl (%r14), %ecx cmpl $0x13, %ecx je 0x9f133 cmpl $0x12, %ecx je 0x9f124 cmpl $0x11, %ecx jne 0x9f14a movl %eax, %ecx andl $-0x5, %ecx addl $0xfffff41d, %ecx # imm = 0xFFFFF41D cmpl $-0x3, %ecx ja 0x9f14a leal -0xcf9(%rax), %ecx cmpl $0x3, %ecx jb 0x9f14a cmpl $0xfc, %eax je 0x9f14a cmpl $0xfe, %eax je 0x9f14a cmpl $0x2d8, %eax # imm = 0x2D8 je 0x9f14a cmpl $0x2da, %eax # imm = 0x2DA je 0x9f14a cmpl $0x390, %eax # imm = 0x390 je 0x9f14a cmpl $0x395, %eax # imm = 0x395 je 0x9f14a cmpl $0x6df, %eax # imm = 0x6DF je 0x9f14a cmpl $0x79d, %eax # imm = 0x79D je 0x9f14a cmpl $0xf1b, %eax # imm = 0xF1B je 0x9f14a cmpl $0x1181, %eax # imm = 0x1181 je 0x9f14a cmpl $0x1268, %eax # imm = 0x1268 je 0x9f14a movq %r15, %rax orq $-0x100, %rax testb %r15b, %r15b jmp 0x9f146 movl 0x9e0(%rsp), %esi movq %rbx, %rdi callq 0x9f6ab jmp 0x9f49f movl 0x9f0(%rsp), %eax cmpq $0x30, %rax ja 0x9eccf leaq 0x4aa8f(%rip), %rcx # 0xe99c0 movslq (%rcx,%rax,4), %rax addq %rcx, %rax pushq $0x1 popq %r15 pushq $0xe popq %r14 pushq $0x2d popq %rbp jmpq *%rax movl 0x144(%rsp), %eax cmpq $0x20, %rax ja 0x9eccf leaq 0x4ae7b(%rip), %rcx # 0xe9dd8 movl (%rcx,%rax,4), %esi movq %rbx, %rdi callq 0x4560d movq %rbx, %rdi callq 0x45580 cmpl $0xef8, %eax # imm = 0xEF8 sete %cl cmpl $0xeed, %eax # imm = 0xEED sete %dl movl %eax, %esi andl $-0x11, %esi cmpl $0xeeb, %esi # imm = 0xEEB sete %sil cmpl $0x13eb, %eax # imm = 0x13EB sete %dil movl %eax, %r8d andl $-0x5, %r8d cmpl $0x13e2, %r8d # imm = 0x13E2 sete %r10b cmpl $0x13e8, %eax # imm = 0x13E8 sete %r8b leal -0xeea(%rax), %r9d cmpl $0x13, %r9d ja 0x9efcc movl $0xfc03f, %r11d # imm = 0xFC03F btl %r9d, %r11d jb 0x9efdd leal -0x13e2(%rax), %r9d cmpl $0xc, %r9d jae 0x9f51e xorl %r9d, %r9d cmpb $0x8, 0x9a9(%rsp) setne %r11b pushq $0x71 popq %rbp leal -0xeee(%rax), %r14d cmpl $0xe, %r14d jbe 0x9f4a7 addl $0xffffec1d, %eax # imm = 0xFFFFEC1D cmpl $0x9, %eax ja 0x9f01a movl $0x241, %r14d # imm = 0x241 btl %eax, %r14d jb 0x9f4b7 orb %dl, %cl orb %sil, %cl orb %dil, %r8b orb %r10b, %r8b orb %cl, %r8b movzbl %r8b, %ebp shll $0x5, %ebp addl $0x31, %ebp jmp 0x9f4b7 cmpl $0x10, %ebp je 0x9f1aa cmpl $0x4f, %ebp je 0x9ee31 cmpl $0x50, %ebp jne 0x9f1d3 movzbl 0x9aa(%rsp), %eax cmpl $0x4, %eax je 0x9f192 cmpl $0x2, %eax je 0x9f26c cmpl $0x1, %eax jne 0x9f27d jmp 0x9f211 movzbl 0x9c8(%rsp), %esi andl $0x7, %esi addl $0x6a, %esi jmp 0x9f497 movl 0x980(%rsp), %ecx movb 0x88(%rsp), %al cmpl $0x1, %ecx je 0x9f22c cmpl $0x2, %ecx jne 0x9f236 testb %al, %al pushq $0x1d popq %rsi pushq $0x2b popq %rax cmovel %eax, %esi jmp 0x9f244 movl 0x980(%rsp), %ecx movb 0x88(%rsp), %al cmpl $0x1, %ecx je 0x9f251 cmpl $0x2, %ecx jne 0x9f25a xorl %esi, %esi testb %al, %al sete %sil shll $0x4, %esi addl $0x17, %esi jmp 0x9f497 movl 0x9c0(%rsp), %esi jmp 0x9ef0c movl 0x9f8(%rsp), %esi jmp 0x9ef0c movl 0x9c4(%rsp), %esi testb $-0x8, %sil jne 0x9eccf addl $0x52, %esi andl $0x5f, %esi jmp 0x9f497 movq %r15, %rax orq $-0x10000, %rax # imm = 0xFFFF0000 testw %r15w, %r15w jmp 0x9f146 movq %r15, %rax movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000 orq %rcx, %rax testl %r15d, %r15d cmovsq %rax, %r15 leal -0x3d(%rbp), %eax cmpl $0x3, %eax jb 0x9f185 leal -0x3(%rbp), %eax cmpl $0x2, %eax jb 0x9f192 cmpl $0x1, %ebp je 0x9f211 cmpl $0x40, %ebp je 0x9f21f cmpl $0x41, %ebp jne 0x9f27d shrl $0x4, %r15d addl $0xb2, %r15d jmp 0x9f2a9 shrl $0x4, %r15d addl $0x72, %r15d jmp 0x9f2a9 movq %r15, %rax movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000 orq %rcx, %rax testl %r15d, %r15d jmp 0x9f279 cmpq $0x8, %r15 jb 0x9f27d movq %rbx, %rdi callq 0x45580 addl $0xfffffdda, %eax # imm = 0xFFFFFDDA xorl %esi, %esi cmpl $0x11, %eax ja 0x9f207 movl %eax, %eax leaq 0x4ae8b(%rip), %rcx # 0xea05c jmp 0x9f204 cmpq $0x20, %r15 jb 0x9f14a cmpb $0x11, %bpl jne 0x9f14a movq %rbx, %rdi callq 0x45580 addl $0xfffff3ff, %eax # imm = 0xFFFFF3FF xorl %esi, %esi cmpl $0x28, %eax ja 0x9f207 movl %eax, %eax leaq 0x4aea0(%rip), %rcx # 0xea0a4 movl (%rcx,%rax,4), %esi movq %rbx, %rdi callq 0x45579 jmp 0x9f27d movq %r15, %rax orq $-0x100, %rax testb %r15b, %r15b jmp 0x9f279 shrl $0x4, %r15d addl $0x92, %r15d jmp 0x9f2a9 xorl %esi, %esi testb %al, %al setne %sil jmp 0x9f23e xorl %esi, %esi testb %al, %al sete %sil shll $0x4, %esi addl $0x1d, %esi movq %rbx, %rdi callq 0x4560d jmp 0x9f485 xorl %ecx, %ecx testb %al, %al sete %cl jmp 0x9f261 xorl %ecx, %ecx testb %al, %al setne %cl leal (%rcx,%rcx,8), %esi addl $0xe, %esi jmp 0x9f497 movq %r15, %rax orq $-0x10000, %rax # imm = 0xFFFF0000 testw %r15w, %r15w cmovsq %rax, %r15 movq %rbx, %rdi movq %r15, %rsi callq 0x4563a addb $-0x2d, %bpl cmpb $0x3, %bpl ja 0x9f49f movl 0x128(%rsp), %eax leaq 0x4a7e0(%rip), %rcx # 0xe9a84 movzbl (%rax,%rcx), %r15d movq %rbx, %rdi movl %r15d, %esi jmp 0x9f49a pushq $0x64 jmp 0x9f455 pushq $0x25 jmp 0x9f455 pushq $0x68 jmp 0x9f455 pushq $0x26 jmp 0x9f455 pushq $0x28 jmp 0x9f455 movq %rbx, %rdi movl $0xdb, %esi jmp 0x9f459 pushq $0x23 jmp 0x9f455 movq %rbx, %rdi movl $0xe9, %esi jmp 0x9f459 pushq $0x65 jmp 0x9f455 movq %rbx, %rdi movl $0xe1, %esi jmp 0x9f459 movq %rbx, %rdi movl $0xe7, %esi jmp 0x9f459 pushq $0x69 jmp 0x9f455 movq %rbx, %rdi movl $0xe4, %esi jmp 0x9f459 pushq $0x27 jmp 0x9f455 pushq $0x6 jmp 0x9f362 pushq $0x17 jmp 0x9f455 pushq $0x1d jmp 0x9f455 movq %rbx, %rdi movl $0xe5, %esi jmp 0x9f459 movq %rbx, %rdi movl $0xe2, %esi jmp 0x9f459 pushq $0x8 popq %rsi movq %rbx, %rdi callq 0x4560d movl %r14d, %ebp jmp 0x9f460 movq %rbx, %rdi movl $0xe8, %esi jmp 0x9f459 pushq $0x6 jmp 0x9f3cb movq %rbx, %rdi movl $0xdf, %esi jmp 0x9f459 pushq $0x6 jmp 0x9f455 cmpl $0x0, 0x9f4(%rsp) je 0x9eccf cmpl $0x2, 0x980(%rsp) jne 0x9f50b cmpb $0x67, 0x124(%rsp) jne 0x9f517 pushq $0x1a jmp 0x9f455 pushq $0x8 popq %rsi movq %rbx, %rdi callq 0x4560d jmp 0x9f460 pushq $0x62 jmp 0x9f455 pushq $0x13 jmp 0x9f455 pushq $0x15 jmp 0x9f455 pushq $0x2d jmp 0x9f455 movq %rbx, %rdi movl $0xe6, %esi jmp 0x9f459 movq %rbx, %rdi movl $0xde, %esi jmp 0x9f459 movq %rbx, %rdi movl $0xe0, %esi jmp 0x9f459 pushq $0xe jmp 0x9f455 pushq $0x16 jmp 0x9f455 movq %rbx, %rdi movl $0xe3, %esi jmp 0x9f459 pushq $0x8 jmp 0x9f455 pushq $0x66 jmp 0x9f455 pushq $0x2b jmp 0x9f455 pushq $0x63 jmp 0x9f455 pushq $0x14 jmp 0x9f455 pushq $0x18 jmp 0x9f455 movq %rbx, %rdi movl $0xdc, %esi jmp 0x9f459 movq %rbx, %rdi movl $0xdd, %esi jmp 0x9f459 pushq $0x24 jmp 0x9f455 movq %rbx, %rdi movl $0xda, %esi jmp 0x9f459 pushq $0x67 popq %rsi movq %rbx, %rdi callq 0x4560d xorl %ebp, %ebp movq %rbx, %rdi movq %r15, %rsi callq 0x4563a movq %rbx, %rdi movl %ebp, %esi callq 0x4560d movslq 0x134(%rsp), %rsi movq %rbx, %rdi callq 0x4563a movl 0x128(%rsp), %eax leaq 0x4a5f1(%rip), %rcx # 0xe9a84 movzbl (%rax,%rcx), %esi movq %rbx, %rdi callq 0x4560d incq %r12 jmp 0x9ed5a movl $0x4801, %r15d # imm = 0x4801 btl %r14d, %r15d jae 0x9f000 movl 0x13c(%rsp), %eax movb %r11b, %r9b shll $0x4, %r9d leal (%r9,%rax), %ecx addl $-0x21, %ecx testl %eax, %eax pushq $0x4 popq %rax cmovnel %ecx, %eax addl %ebp, %eax movl %eax, 0x13c(%rsp) testl %eax, %eax je 0x9f4fb addl $-0x11, %eax cmpl $0x7f, %eax ja 0x9eccf movl %eax, %eax leaq 0x4a966(%rip), %rcx # 0xe9e5c movl (%rcx,%rax,4), %ebp jmp 0x9f4fd xorl %ebp, %ebp movzbl 0x140(%rsp), %r15d jmp 0x9f460 xorl %ebp, %ebp movq %rbx, %rdi xorl %esi, %esi jmp 0x9f3cf pushq $0x29 jmp 0x9f455 movl 0x13c(%rsp), %eax jmp 0x9f4dd movb 0x9ac(%rsp), %al movb %al, 0x32d(%rbx) movq (%rsp), %rax cmpl $0x0, 0xe0(%rax) je 0x9f60c movq 0x310(%rbx), %r14 movl 0x121(%rsp), %eax movl %eax, 0x329(%rbx) cmpl $0x0, 0x998(%rsp) je 0x9f620 movq 0xe8(%r14), %rax movl 0x950(%rsp), %ecx movl %ecx, 0x34(%rax) movb 0x125(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x38(%rcx) movb 0x9a9(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x39(%rcx) movb 0x12d(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x3a(%rcx) movb 0x12f(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x3b(%rcx) movl 0x134(%rsp), %eax movq 0xe8(%r14), %rcx movl %eax, 0x3c(%rcx) movl 0x13c(%rsp), %edi callq 0xa3c02 movq 0xe8(%r14), %rcx movl %eax, 0x40(%rcx) movb 0x140(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x44(%rcx) movl 0x144(%rsp), %edi callq 0xa3bf4 movq 0xe8(%r14), %rcx movl %eax, 0x48(%rcx) jmp 0x9f619 movl 0x121(%rsp), %eax movl %eax, 0x329(%rbx) movb $0x1, %al jmp 0x9ecd1 movb 0x138(%rsp), %al testb %al, %al je 0x9f666 cmpb $0x0, 0x139(%rsp) movq 0xe8(%r14), %rcx movb %al, 0x34(%rcx) je 0x9f67c movb 0x139(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x35(%rcx) movb 0x9af(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x36(%rcx) jmp 0x9f578 movb 0x9af(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x34(%rcx) jmp 0x9f578 movb 0x9af(%rsp), %al movq 0xe8(%r14), %rcx movb %al, 0x35(%rcx) jmp 0x9f578	/radare[P]capstone/arch/X86/X86Disassembler.c
decodeInstruction	int decodeInstruction(struct InternalInstruction insn, byteReader_t reader, const void readerArg, uint64_t startLoc, DisassemblerMode mode) { insn->reader = reader; insn->readerArg = readerArg; insn->startLocation = startLoc; insn->readerCursor = startLoc; insn->mode = mode; if (readPrefixes(insn) \|\| readOpcode(insn) \|\| getID(insn) \|\| insn->instructionID == 0 \|\| invalidPrefix(insn) \|\| readOperands(insn)) return -1; insn->length = (size_t)(insn->readerCursor - insn->startLocation); // instruction length must be <= 15 to be valid if (insn->length > 15) return -1; if (insn->operandSize == 0) insn->operandSize = insn->registerSize; insn->operands = &x86OperandSets[insn->spec->operands][0]; // dbgprintf(insn, "Read from 0x%llx to 0x%llx: length %zu", // startLoc, insn->readerCursor, insn->length); //if (insn->length > 15) // dbgprintf(insn, "Instruction exceeds 15-byte limit"); #if 0 printf("\n>>> x86OperandSets = %lu\n", sizeof(x86OperandSets)); printf(">>> x86DisassemblerInstrSpecifiers = %lu\n", sizeof(x86DisassemblerInstrSpecifiers)); printf(">>> x86DisassemblerContexts = %lu\n", sizeof(x86DisassemblerContexts)); printf(">>> modRMTable = %lu\n", sizeof(modRMTable)); printf(">>> x86DisassemblerOneByteOpcodes = %lu\n", sizeof(x86DisassemblerOneByteOpcodes)); printf(">>> x86DisassemblerTwoByteOpcodes = %lu\n", sizeof(x86DisassemblerTwoByteOpcodes)); printf(">>> x86DisassemblerThreeByte38Opcodes = %lu\n", sizeof(x86DisassemblerThreeByte38Opcodes)); printf(">>> x86DisassemblerThreeByte3AOpcodes = %lu\n", sizeof(x86DisassemblerThreeByte3AOpcodes)); printf(">>> x86DisassemblerThreeByteA6Opcodes = %lu\n", sizeof(x86DisassemblerThreeByteA6Opcodes)); printf(">>> x86DisassemblerThreeByteA7Opcodes= %lu\n", sizeof(x86DisassemblerThreeByteA7Opcodes)); printf(">>> x86DisassemblerXOP8Opcodes = %lu\n", sizeof(x86DisassemblerXOP8Opcodes)); printf(">>> x86DisassemblerXOP9Opcodes = %lu\n", sizeof(x86DisassemblerXOP9Opcodes)); printf(">>> x86DisassemblerXOPAOpcodes = %lu\n\n", sizeof(x86DisassemblerXOPAOpcodes)); #endif return 0; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx movq %rsi, 0x938(%rdi) movq %rdx, 0x940(%rdi) movq %rcx, 0x968(%rdi) movq %rcx, 0x948(%rdi) movl %r8d, 0x960(%rdi) leaq 0xd(%rsp), %r14 movb $0x0, (%r14) movb $0x1, %al xorl %r12d, %r12d leaq 0x4afa7(%rip), %r13 # 0xea6b0 xorl %ecx, %ecx movl $0x0, 0x18(%rsp) movl $0x0, 0x14(%rsp) pushq $-0x1 popq %rbp testb $0x1, %al je 0x9fad2 cmpl $0x2, 0x960(%rbx) jne 0x9f7bf movq %rbx, %rdi movq %r14, %rsi callq 0xa09cc testl %eax, %eax jne 0xa0307 movb 0xd(%rsp), %al andb $-0x10, %al cmpb $0x40, %al jne 0x9f7b8 movq 0x940(%rbx), %rdi movq 0x948(%rbx), %rdx movq %r14, %rsi callq 0x938(%rbx) testl %eax, %eax jne 0xa0307 movzbl 0xd(%rsp), %eax movl %eax, %ecx andb $-0x10, %cl cmpb $0x40, %cl jne 0x9f78b movq %rbx, %rdi movq %r14, %rsi callq 0xa09cc jmp 0x9f750 leal -0x2e(%rax), %ecx cmpl $0x39, %ecx ja 0x9f7a3 movabsq $0x3c0000000010101, %rdx # imm = 0x3C0000000010101 btq %rcx, %rdx jb 0x9f7bf leal -0xf0(%rax), %ecx cmpl $0x3, %ecx ja 0x9f7b3 cmpl $0x1, %ecx jne 0x9f7bf cmpl $0x26, %eax je 0x9f7bf decq 0x948(%rbx) movq 0x948(%rbx), %r15 movq %rbx, %rdi movq %r14, %rsi callq 0xa09cc testl %eax, %eax jne 0x9face movq 0x948(%rbx), %rdx leaq -0x1(%rdx), %rax cmpq 0x968(%rbx), %rax sete %al movb 0xd(%rsp), %cl movl %ecx, %esi andb $-0x2, %sil cmpb $-0xe, %sil sete %sil andb %al, %sil cmpb $0x1, %sil jne 0x9f8da movq 0x940(%rbx), %rdi leaq 0xf(%rsp), %rsi callq 0x938(%rbx) movb 0xd(%rsp), %cl testl %eax, %eax jne 0x9f8da movl %ecx, %eax andb $-0x2, %al cmpb $-0xe, %al jne 0x9f886 movzbl 0xf(%rsp), %eax cmpl $0xf0, %eax je 0x9f859 movl %eax, %edx andl $-0x2, %edx cmpl $0x86, %edx je 0x9f859 movl %eax, %edx andl $-0x8, %edx cmpl $0x90, %edx jne 0x9f860 movb $0x1, 0x129(%rbx) cmpb $-0xd, %cl jne 0x9f886 addl $0xffffff78, %eax # imm = 0xFFFFFF78 cmpl $0x3f, %eax ja 0x9f886 movabsq $-0x3ffffffffffffffd, %rdx # imm = 0xC000000000000003 btq %rax, %rdx jae 0x9f886 movb $0x1, 0x129(%rbx) cmpl $0x2, 0x960(%rbx) jne 0x9f8da movb 0xf(%rsp), %al andb $-0x10, %al cmpb $0x40, %al jne 0x9f8da movq %rbx, %rdi leaq 0xf(%rsp), %rsi callq 0xa09cc testl %eax, %eax jne 0xa0307 movq 0x940(%rbx), %rdi movq 0x948(%rbx), %rdx leaq 0xf(%rsp), %rsi callq 0x938(%rbx) testl %eax, %eax jne 0xa0307 decq 0x948(%rbx) movb 0xd(%rsp), %cl movzbl %cl, %edx leal -0x64(%rdx), %eax cmpl $0x3, %eax jbe 0x9f94e leal -0xf0(%rdx), %eax cmpl $0x3, %eax jbe 0x9f98d cmpl $0x26, %edx je 0x9f9bf cmpl $0x2e, %edx je 0x9fa66 cmpl $0x36, %edx je 0x9fa9a xorl %eax, %eax cmpl $0x3e, %edx jne 0x9f71e movl $0x3, 0x108(%rbx) movb %r12b, 0x2f(%rbx) movb %r12b, 0x37(%rbx) movb %r12b, 0x27(%rbx) andw $0x0, 0x65(%rbx) movb $0x1, 0x3f(%rbx) movq %r15, 0x320(%rbx) movb $0x3e, 0x102(%rbx) movb $0x1, %al jmp 0x9f71e movslq (%r13,%rax,4), %rax addq %r13, %rax jmpq %rax movl $0x5, 0x108(%rbx) movb %r12b, 0x2f(%rbx) movb %r12b, 0x37(%rbx) movb %r12b, 0x3f(%rbx) movb %r12b, 0x27(%rbx) movw $0x1, 0x65(%rbx) movq %r15, 0x450(%rbx) movb $0x64, 0x102(%rbx) movb $0x1, %al jmp 0x9f71e cmpl $0x1, %eax je 0x9f8f4 andw $0x0, 0xf3(%rbx) movb $0x0, 0xf1(%rbx) movb $0x1, 0x1(%rbx,%rdx) movq %r15, 0x130(%rbx,%rdx,8) movb %dl, 0x101(%rbx) movb $0x1, %al jmp 0x9f71e movl $0x4, 0x108(%rbx) movb %r12b, 0x2f(%rbx) movb %r12b, 0x37(%rbx) movb %r12b, 0x3f(%rbx) andw $0x0, 0x65(%rbx) movb $0x1, 0x27(%rbx) movq %r15, 0x260(%rbx) movb $0x26, 0x102(%rbx) movb $0x1, %al jmp 0x9f71e movb $0x1, 0x67(%rbx) movq %r15, 0x460(%rbx) movb $0x66, 0x103(%rbx) movb $0x1, %al movb $0x1, %dl movl %edx, 0x14(%rsp) jmp 0x9f71e movb $0x1, 0x68(%rbx) movq %r15, 0x468(%rbx) movb $0x67, 0x104(%rbx) movb $0x1, %al movb $0x1, %dl movl %edx, 0x18(%rsp) jmp 0x9f71e movl $0x6, 0x108(%rbx) movb %r12b, 0x2f(%rbx) movb %r12b, 0x37(%rbx) movb %r12b, 0x3f(%rbx) movb %r12b, 0x27(%rbx) movw $0x100, 0x65(%rbx) # imm = 0x100 movq %r15, 0x458(%rbx) movb $0x65, 0x102(%rbx) movb $0x1, %al jmp 0x9f71e movl $0x1, 0x108(%rbx) movb %r12b, 0x37(%rbx) movb %r12b, 0x3f(%rbx) movb %r12b, 0x27(%rbx) andw $0x0, 0x65(%rbx) movb $0x1, 0x2f(%rbx) movq %r15, 0x2a0(%rbx) movb $0x2e, 0x102(%rbx) movb $0x1, %al jmp 0x9f71e movl $0x2, 0x108(%rbx) movb %r12b, 0x2f(%rbx) movb %r12b, 0x3f(%rbx) movb %r12b, 0x27(%rbx) andw $0x0, 0x65(%rbx) movb $0x1, 0x37(%rbx) movq %r15, 0x2e0(%rbx) movb $0x36, 0x102(%rbx) movb $0x1, %al jmp 0x9f71e movb 0xd(%rsp), %cl andl $0x0, 0x978(%rbx) pushq $0x1 popq %r13 movl 0x14(%rsp), %r12d movzbl %r12b, %r14d cmpb $-0x3b, %cl je 0x9fc65 movzbl %cl, %eax cmpl $0x8f, %eax je 0x9fbac cmpl $0xc4, %eax je 0x9fbf8 cmpl $0x62, %eax movl 0x18(%rsp), %r14d jne 0x9fcb7 leaq 0x13(%rsp), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 cmpl $0x2, 0x960(%rbx) sete %al movb 0x13(%rsp), %cl cmpb $-0x40, %cl setae %dl orb %al, %dl testb $0xc, %cl sete %al andb %dl, %al cmpb $0x1, %al jne 0x9fdf9 movq 0x940(%rbx), %rdi movq 0x948(%rbx), %rdx leaq 0x23(%rsp), %rsi callq 0x938(%rbx) testl %eax, %eax jne 0xa0307 testb $0x4, 0x23(%rsp) jne 0xa0282 movq 0x948(%rbx), %rax leaq -0x2(%rax), %rcx movq %rcx, 0x948(%rbx) addq $-0x4, %rax movq %rax, 0x980(%rbx) cmpl $0x3, 0x978(%rbx) jne 0x9fe91 jmp 0xa028c movq 0x940(%rbx), %rdi movq 0x948(%rbx), %rdx leaq 0x20(%rsp), %rsi callq 0x938(%rbx) testl %eax, %eax jne 0xa0307 testb $0x38, 0x20(%rsp) je 0x9fe06 movl $0x4, 0x978(%rbx) movq 0x948(%rbx), %rax decq %rax movq %rax, 0x980(%rbx) jmp 0x9fe2c movq 0x940(%rbx), %rdi movq 0x948(%rbx), %rdx leaq 0x22(%rsp), %rsi callq 0x938(%rbx) testl %eax, %eax movl 0x18(%rsp), %r14d jne 0xa0307 cmpl $0x2, 0x960(%rbx) je 0x9fd2e cmpb $-0x40, 0x22(%rsp) jae 0x9fd2e movq 0x948(%rbx), %rax leaq -0x1(%rax), %rcx movq %rcx, 0x948(%rbx) addq $-0x2, %rax movq %rax, 0x980(%rbx) cmpl $0x2, 0x978(%rbx) je 0x9fd49 jmp 0x9fe91 movq 0x940(%rbx), %rdi movq 0x948(%rbx), %rdx leaq 0x21(%rsp), %rsi callq 0x938(%rbx) testl %eax, %eax jne 0xa0307 cmpl $0x2, 0x960(%rbx) je 0x9fda4 cmpb $-0x40, 0x21(%rsp) jae 0x9fda4 decq 0x948(%rbx) cmpl $0x1, 0x978(%rbx) je 0x9fdae jmp 0x9fe8c cmpl $0x2, 0x960(%rbx) jne 0x9fd0c andb $-0x10, %cl cmpb $0x40, %cl jne 0x9fd0c leaq 0x1f(%rsp), %r14 leaq 0xd(%rsp), %r15 movq 0x940(%rbx), %rdi movq 0x948(%rbx), %rdx movq %r14, %rsi callq 0x938(%rbx) testl %eax, %eax jne 0xa0307 movb 0x1f(%rsp), %al andb $-0x10, %al cmpb $0x40, %al jne 0xa00a3 movq %rbx, %rdi movq %r15, %rsi callq 0xa09cc jmp 0x9fcd2 movq 0x948(%rbx), %rax leaq -0x1(%rax), %rcx movq %rcx, 0x948(%rbx) addq $-0x2, %rax movq %rax, 0x980(%rbx) jmp 0x9fe91 movl $0x2, 0x978(%rbx) movq 0x948(%rbx), %rax decq %rax movq %rax, 0x980(%rbx) movb 0xd(%rsp), %al movb %al, 0x930(%rbx) leaq 0x931(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc leaq 0x932(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc cmpl $0x2, 0x960(%rbx) jne 0x9fe91 movb 0x931(%rbx), %al movb 0x932(%rbx), %cl shrb $0x4, %cl andb $0x8, %cl notb %al shrb $0x5, %al orb %cl, %al orb $0x40, %al movb %al, 0x105(%rbx) jmp 0x9fe91 movl $0x1, 0x978(%rbx) movb 0xd(%rsp), %al movb %al, 0x930(%rbx) leaq 0x931(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc cmpl $0x2, 0x960(%rbx) movb 0x931(%rbx), %al jne 0x9fde9 movl %eax, %ecx notb %cl shrb $0x5, %cl andb $0x4, %cl orb $0x40, %cl movb %cl, 0x105(%rbx) andb $0x3, %al cmpb $0x1, %al pushq $0x1 popq %rax cmovel %eax, %r14d jmp 0x9fe89 addq $-0x2, 0x948(%rbx) jmp 0x9fe91 movq 0x948(%rbx), %rax leaq -0x1(%rax), %rcx movq %rcx, 0x948(%rbx) addq $-0x2, %rax movq %rax, 0x980(%rbx) cmpl $0x4, 0x978(%rbx) jne 0x9fe8c movb 0xd(%rsp), %al movb %al, 0x930(%rbx) leaq 0x931(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc leaq 0x932(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc cmpl $0x2, 0x960(%rbx) movb 0x932(%rbx), %al jne 0x9fe81 movl %eax, %ecx shrb $0x4, %cl andb $0x8, %cl movb 0x931(%rbx), %dl notb %dl shrb $0x5, %dl orb %cl, %dl orb $0x40, %dl movb %dl, 0x105(%rbx) andb $0x3, %al cmpb $0x1, %al cmovel %r13d, %r14d movl %r14d, %r12d movl 0x18(%rsp), %r14d movl 0x960(%rbx), %edx movl %r14d, %eax notb %al movl %r12d, %ecx notb %cl cmpl $0x2, %edx je 0x9fef1 cmpl $0x1, %edx je 0x9fed5 testl %edx, %edx jne 0x9ff6e andb $0x1, %r12b addb %r12b, %r12b addb $0x2, %r12b movb %r12b, 0x988(%rbx) andb $0x1, %r14b addb %r14b, %r14b addb $0x2, %r14b movl %r14d, %eax jmp 0x9ff53 andb $0x1, %cl addb %cl, %cl addb $0x2, %cl movb %cl, 0x988(%rbx) andb $0x1, %al addb %al, %al addb $0x2, %al movl %eax, %r14d movl %ecx, %r12d jmp 0x9ff53 movb 0x105(%rbx), %dl testb $0x8, %dl jne 0x9ff3d andb $0x1, %cl leal (%rcx,%rcx), %esi addb $0x2, %sil andb $0x1, %al shlb $0x2, %al addb $0x4, %al shlb $0x2, %cl addb $0x4, %cl testb %dl, %dl movb %sil, 0x988(%rbx) movb %al, 0x989(%rbx) movb %sil, 0x98a(%rbx) movb %sil, 0x98b(%rbx) movzbl %cl, %eax movzbl %sil, %r12d cmovel %eax, %r12d jmp 0x9ff67 movb $0x8, 0x988(%rbx) andb $0x1, %al shlb $0x2, %al addb $0x4, %al movb $0x4, %r12b movl %eax, %r14d movb $0x4, %al movb %r14b, 0x989(%rbx) movb %al, 0x98a(%rbx) movb %r12b, 0x98b(%rbx) movb %r12b, 0x98c(%rbx) andl $0x0, 0x990(%rbx) movl 0x978(%rbx), %eax decl %eax cmpl $0x3, %eax ja 0xa000c leaq 0x4a633(%rip), %rcx # 0xea5c0 movslq (%rcx,%rax,4), %rdx addq %rcx, %rdx pushq $0x2 popq %rax pushq $0x3 popq %rcx jmpq %rdx movb $0xf, 0x118(%rbx) jmp 0xa00de movzbl 0x931(%rbx), %r13d andl $0x3, %r13d leaq 0x4a615(%rip), %rdx # 0xea5d0 movslq (%rdx,%r13,4), %rsi addq %rdx, %rsi jmpq %rsi movzbl 0x931(%rbx), %r13d andl $0x1f, %r13d leal -0x8(%r13), %eax cmpb $0x3, %al jae 0xa0307 addl $-0x4, %r13d jmp 0xa00de movzbl 0x931(%rbx), %edx andl $0x1f, %edx cmpl $0x3, %edx je 0xa00d2 cmpl $0x2, %edx je 0xa00c4 cmpl $0x1, %edx jne 0xa0307 jmp 0x9ff9c leaq 0xe(%rsp), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 movb 0xe(%rsp), %al movb %al, 0x9a9(%rbx) cmpb $0xf, %al jne 0xa06d2 movb $0xf, 0x118(%rbx) leaq 0xe(%rsp), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 movzbl 0xe(%rsp), %eax cmpl $0xe, %eax je 0xa06b5 cmpl $0xf, %eax je 0xa065c cmpl $0x3a, %eax je 0xa068d cmpl $0x38, %eax jne 0xa06c8 movb $0x38, 0x119(%rbx) leaq 0xe(%rsp), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 movl $0x2, 0x990(%rbx) jmp 0xa06d2 movb 0xd(%rsp), %al movb %al, 0x105(%rbx) movq 0x948(%rbx), %rax addq $-0x2, %rax movq %rax, 0x980(%rbx) jmp 0x9fe8c movw $0x380f, 0x118(%rbx) # imm = 0x380F movl %eax, %r13d jmp 0xa00de movw $0x3a0f, 0x118(%rbx) # imm = 0x3A0F movl %ecx, %r13d movl %r13d, 0x990(%rbx) leaq 0x98f(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 movl 0x960(%rbx), %eax movl 0x978(%rbx), %edx xorl %r14d, %r14d cmpl $0x2, %eax sete %r14b movzwl %r14w, %ecx testl %edx, %edx je 0xa0154 cmpl $0x3, %edx movl $0x100, %esi # imm = 0x100 pushq $0x40 popq %rax cmovel %esi, %eax orl %ecx, %eax movzwl %ax, %ecx cmpl $0x3, %edx jne 0xa018e movzbl 0x932(%rbx), %edx andl $0x3, %edx leaq 0x4a4cd(%rip), %rsi # 0xea610 movslq (%rsi,%rdx,4), %rdx addq %rsi, %rdx jmpq %rdx orl $0x10, %ecx jmp 0xa021e testl %eax, %eax je 0xa0173 cmpb $0x1, 0x67(%rbx) jne 0xa0173 movq 0x460(%rbx), %rax cmpq 0x980(%rbx), %rax jne 0xa0173 orl $0x10, %ecx jmp 0xa01f2 movq 0x980(%rbx), %rax cmpb $0x1, 0x68(%rbx) jne 0xa01c1 cmpq %rax, 0x468(%rbx) jne 0xa01c1 orl $0x20, %ecx jmp 0xa01f2 cmpl $0x1, %edx je 0xa0261 cmpl $0x4, %edx je 0xa01ff cmpl $0x2, %edx jne 0xa0307 movzbl 0x932(%rbx), %edx movl %edx, %esi andl $0x3, %esi leaq 0x4a448(%rip), %rdi # 0xea600 movslq (%rdi,%rsi,4), %rsi addq %rdi, %rsi jmpq %rsi cmpb $0x1, 0xf4(%rbx) jne 0xa01d8 cmpq %rax, 0x8c8(%rbx) jne 0xa01d8 orl $0x2, %ecx jmp 0xa01f2 cmpb $0x1, 0xf3(%rbx) jne 0xa02e5 cmpq %rax, 0x8c0(%rbx) leal 0x4(%rcx), %eax cmovel %eax, %ecx movl %ecx, %r14d jmp 0xa02e5 orl $0x2, %ecx jmp 0xa021e movzbl 0x932(%rbx), %edx movl %edx, %esi andl $0x3, %esi leaq 0x4a3ce(%rip), %rdi # 0xea5e0 movslq (%rdi,%rsi,4), %rsi addq %rdi, %rsi jmpq %rsi orl $0x4, %ecx movl %ecx, %eax movzbl 0x933(%rbx), %r14d movzwl %ax, %eax leal 0x1000(%rax), %ecx testb %r14b, %r14b cmovsl %ecx, %eax movl %r14d, %ecx andl $0x10, %ecx shll $0x9, %ecx leal (%rcx,%rax), %edx testb $0x7, %r14b leal 0x800(%rcx,%rax), %eax cmovel %edx, %eax andl $0x60, %r14d shll $0x4, %r14d orl %eax, %r14d jmp 0xa02e5 movzbl 0x931(%rbx), %edx movl %edx, %esi andl $0x3, %esi leaq 0x4a37c(%rip), %rdi # 0xea5f0 movslq (%rdi,%rsi,4), %rsi addq %rdi, %rsi jmpq %rsi orl $0x10, %ecx jmp 0xa02d3 movl $0x3, 0x978(%rbx) movb 0xd(%rsp), %al movb %al, 0x930(%rbx) movb 0x13(%rsp), %al movb %al, 0x931(%rbx) leaq 0x932(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 leaq 0x933(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 jmp 0x9fd71 orl $0x2, %ecx jmp 0xa02d3 orl $0x4, %ecx movl %ecx, %eax movzwl %dx, %ecx andl $0x4, %ecx shll $0x5, %ecx movzwl %ax, %r14d orl %ecx, %r14d movzbl 0x105(%rbx), %eax andl $0x8, %eax orl %eax, %r14d movzwl %r14w, %edx leaq 0x10(%rsp), %rdi movq %rbx, %rsi callq 0xa0fa2 testl %eax, %eax je 0xa0318 movl %ebp, %eax addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq cmpl $0x0, 0x960(%rbx) je 0xa0380 cmpb $0x0, 0x67(%rbx) je 0xa03d1 movl %r14d, %eax andl $0x10, %eax jne 0xa03d1 movzwl 0x10(%rsp), %r15d leaq 0x922dc(%rip), %r13 # 0x132620 leaq (,%r15,2), %r12 addq %r13, %r12 orl $0x10, %r14d movzwl %r14w, %edx leaq 0x26(%rsp), %rdi movq %rbx, %rsi callq 0xa0fa2 testl %eax, %eax je 0xa04f5 movw %r15w, 0x994(%rbx) movq %r12, 0x998(%rbx) jmp 0xa0410 cmpb $-0x1d, 0x98f(%rbx) jne 0xa03c7 movzwl 0x10(%rsp), %eax leaq 0x9228b(%rip), %rcx # 0x132620 cmpw $0x9c, (%rcx,%rax,2) jne 0xa03c7 xorl $0x20, %r14d movzwl %r14w, %edx leaq 0x10(%rsp), %rdi movq %rbx, %rsi callq 0xa0fa2 testl %eax, %eax jne 0xa0307 cmpl $0x0, 0x960(%rbx) jne 0xa0321 testb $0x10, %r14b je 0xa0337 cmpl $0x0, 0x990(%rbx) jne 0xa03f0 cmpb $-0x70, 0x98f(%rbx) jne 0xa03f0 testb $0x1, 0x105(%rbx) jne 0xa05b9 movzwl 0x10(%rsp), %r15d movw %r15w, 0x994(%rbx) leaq 0x9221b(%rip), %rax # 0x132620 leaq (%rax,%r15,2), %rax movq %rax, 0x998(%rbx) testw %r15w, %r15w je 0xa0307 cmpb $0x0, 0xf1(%rbx) je 0xa070d movzwl %r15w, %eax leal -0x1829(%rax), %ecx cmpl $0x3c, %ecx jbe 0xa056e leal -0x133(%rax), %ecx cmpl $0x21, %ecx jbe 0xa0587 leal -0x21(%rax), %ecx cmpl $0x34, %ecx jbe 0xa05a0 leal -0x70e(%rax), %ecx cmpl $0x3d, %ecx jbe 0xa060a leal -0xac(%rax), %ecx cmpl $0x1c, %ecx jbe 0xa0649 leal -0x9d0(%rax), %ecx cmpl $0x1c, %ecx jbe 0xa0623 leal -0xad3(%rax), %ecx cmpl $0x1c, %ecx jbe 0xa0636 leal -0x28e(%rax), %ecx cmpl $0xc, %ecx jbe 0xa06e1 leal -0x380(%rax), %ecx cmpl $0xc, %ecx jbe 0xa06f0 leal -0x5f(%rax), %ecx cmpl $0xd, %ecx jbe 0xa06ff leal -0x23b(%rax), %ecx cmpl $0x7, %ecx ja 0xa04d4 movl $0xd5, %edx btl %ecx, %edx jb 0xa070d addl $0xfffff8ae, %eax # imm = 0xFFFFF8AE cmpl $0xa, %eax ja 0xa0307 movl $0x607, %ecx # imm = 0x607 btl %eax, %ecx jb 0xa070d jmp 0xa0307 leaq 0x96034(%rip), %rax # 0x136530 movzwl (%rax,%r15,2), %edx testq %rdx, %rdx je 0xa036c movzwl 0x26(%rsp), %eax movzwl %ax, %ecx decl %edx leaq 0x95205(%rip), %rsi # 0x135720 cmpq $0x380, %rdx # imm = 0x380 ja 0xa036c cmpw %r15w, (%rsi,%rdx,4) jne 0xa036c leaq 0x1(%rdx), %rdi cmpw %ax, 0x2(%rsi,%rdx,4) movq %rdi, %rdx jne 0xa051b cmpl $0x0, 0x960(%rbx) sete %dl cmpb %dl, 0x67(%rbx) je 0xa036c movw %ax, 0x994(%rbx) leaq (,%rcx,2), %r12 addq %r13, %r12 movl %eax, %r15d jmp 0xa0374 movabsq $0x181c0e0700148855, %rdx # imm = 0x181C0E0700148855 btq %rcx, %rdx jb 0xa070d jmp 0xa043a movabsq $0x333333333, %rdx # imm = 0x333333333 btq %rcx, %rdx jb 0xa070d jmp 0xa0449 movabsq $0x1c01c0181c0e07, %rdx # imm = 0x1C01C0181C0E07 btq %rcx, %rdx jb 0xa070d jmp 0xa0455 movzwl 0x10(%rsp), %r15d movb $-0x6f, 0x98f(%rbx) movzwl %r14w, %edx leaq 0x24(%rsp), %rdi movq %rbx, %rsi callq 0xa0fa2 testl %eax, %eax jne 0xa05e1 movzwl 0x24(%rsp), %r15d movzwl %r15w, %eax leaq 0x92034(%rip), %rcx # 0x132620 leaq (%rcx,%rax,2), %rcx movb $-0x70, 0x98f(%rbx) movw %ax, 0x994(%rbx) movq %rcx, 0x998(%rbx) jmp 0xa0410 movabsq $0x3c0e550000000055, %rdx # imm = 0x3C0E550000000055 btq %rcx, %rdx jb 0xa070d jmp 0xa0464 movl $0x181c0e07, %edx # imm = 0x181C0E07 btl %ecx, %edx jb 0xa070d jmp 0xa0482 movl $0x181c0e07, %edx # imm = 0x181C0E07 btl %ecx, %edx jb 0xa070d jmp 0xa0491 movl $0x181c0e07, %edx # imm = 0x181C0E07 btl %ecx, %edx jb 0xa070d jmp 0xa0473 movq %rbx, %rdi callq 0xa09f1 testl %eax, %eax jne 0xa0307 leaq 0xe(%rsp), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 movl $0x7, 0x990(%rbx) jmp 0xa06d2 movb $0x3a, 0x119(%rbx) leaq 0xe(%rsp), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0307 movl $0x3, 0x990(%rbx) jmp 0xa06d2 movl $0x7, 0x990(%rbx) movb $0x1, 0x10c(%rbx) jmp 0xa06d2 movl $0x1, 0x990(%rbx) movb 0xe(%rsp), %al movb %al, 0x98f(%rbx) jmp 0xa00fc movl $0x1551, %edx # imm = 0x1551 btl %ecx, %edx jb 0xa070d jmp 0xa04a0 movl $0x1551, %edx # imm = 0x1551 btl %ecx, %edx jb 0xa070d jmp 0xa04af movl $0x3007, %edx # imm = 0x3007 btl %ecx, %edx jae 0xa04bb movl 0x978(%rbx), %eax decl %eax cmpl $0x3, %eax ja 0xa09b4 leaq 0x49efb(%rip), %rcx # 0xea620 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax movl $0x0, 0x14(%rsp) movb 0x932(%rbx), %al jmp 0xa074c movl $0x0, 0x14(%rsp) movb 0x931(%rbx), %al notb %al shrb $0x3, %al andb $0xf, %al jmp 0xa0777 movl $0x0, 0x14(%rsp) movb 0x932(%rbx), %al movb 0x933(%rbx), %cl addb %cl, %cl andb $0x10, %cl shrb $0x3, %al andb $0xf, %al orb %cl, %al xorb $0x1f, %al movzbl %al, %eax movl %eax, %ecx andl $0x7, %ecx cmpl $0x2, 0x960(%rbx) cmovel %eax, %ecx movl %ecx, 0x9a0(%rbx) xorl %r12d, %r12d testl %ecx, %ecx setne %r12b movb $0x1, %al movl %eax, 0x18(%rsp) leaq 0x4a0bb(%rip), %r13 # 0xea860 pushq $0x5 popq %r15 leaq 0x49e80(%rip), %r14 # 0xea630 subq $0x1, %r15 jb 0xa0959 movq 0x998(%rbx), %rax movzwl (%rax), %eax imulq $0xc, %rax, %rsi movzbl (%r13,%rsi), %eax cmpq $0x1f, %rax ja 0xa0307 movslq (%r14,%rax,4), %rax addq %r14, %rax jmpq *%rax movq %rbx, %rdi callq 0xa09f1 testl %eax, %eax jne 0xa0307 movq 0x998(%rbx), %rax movzwl (%rax), %eax imulq $0xc, %rax, %rsi addq %r13, %rsi movq %rbx, %rdi callq 0xa1270 testl %eax, %eax jne 0xa0307 movq 0x998(%rbx), %rax movzwl (%rax), %eax imulq $0xc, %rax, %rax movzbl (%r13,%rax), %ecx cmpl $0x1, %ecx je 0xa091b cmpl $0x1, 0x9d4(%rbx) jne 0xa091b addb $-0x2, %cl shll %cl, 0x114(%rbx) jmp 0xa091b cmpl $0x3, 0x978(%rbx) jne 0xa0307 movzbl 0x933(%rbx), %eax andl $0x7, %eax movl %eax, 0x9a4(%rbx) jmp 0xa091b movq %rbx, %rdi pushq $0x2 jmp 0xa08a0 movzbl 0x989(%rbx), %esi jmp 0xa090b movq %rbx, %rdi pushq $0x8 jmp 0xa08a0 movq %rbx, %rdi xorl %esi, %esi jmp 0xa08cb movq %rbx, %rdi pushq $0x4 jmp 0xa08ca movq %rbx, %rdi pushq $0x2 jmp 0xa08ca movq %rbx, %rdi pushq $0x4 popq %rsi jmp 0xa090e cmpb $0x0, 0x18(%rsp) je 0xa0307 addq %r13, %rsi movq %rbx, %rdi callq 0xa1270 xorl %r12d, %r12d jmp 0xa0913 movq %rbx, %rdi pushq $0x8 jmp 0xa08ca movq %rbx, %rdi pushq $0x1 popq %rsi callq 0xa15d8 jmp 0xa091b cmpl $0x0, 0x14(%rsp) je 0xa0924 movzbl 0x128(%rbx), %eax movq 0x9a8(%rbx,%rax,8), %rcx andl $0xf, %ecx movq %rcx, 0x9b0(%rbx,%rax,8) incl %eax movb %al, 0x128(%rbx) pushq $0x1 popq %rax movl %eax, 0x14(%rsp) jmp 0xa091b movzbl 0x98b(%rbx), %esi movq %rbx, %rdi callq 0xa141b testl %eax, %eax jne 0xa0307 addq $0x2, %r13 jmp 0xa07b0 movq %rbx, %rdi pushq $0x1 popq %rsi callq 0xa141b testl %eax, %eax jne 0xa0307 movq 0x998(%rbx), %rax movzwl (%rax), %eax imulq $0xc, %rax, %rax movb 0x1(%r13,%rax), %al addb $-0x3f, %al xorl %ecx, %ecx cmpb $0x2, %al setb %cl movl %ecx, 0x14(%rsp) jmp 0xa091b testl %r12d, %r12d jne 0xa0307 movq 0x948(%rbx), %rax subq 0x968(%rbx), %rax movq %rax, 0x970(%rbx) cmpq $0xf, %rax ja 0xa0307 cmpb $0x0, (%rbx) jne 0xa098e movb 0x988(%rbx), %al movb %al, (%rbx) movq 0x998(%rbx), %rax movzwl (%rax), %eax imulq $0xc, %rax, %rax leaq 0x49ebd(%rip), %rcx # 0xea860 addq %rax, %rcx movq %rcx, 0x9e0(%rbx) xorl %ebp, %ebp jmp 0xa0307 movl $0x0, 0x14(%rsp) movl $0x0, 0x18(%rsp) xorl %r12d, %r12d jmp 0xa079e	/radare[P]capstone/arch/X86/X86DisassemblerDecoder.c
readModRM	static int readModRM(struct InternalInstruction insn) { uint8_t mod, rm, reg; // dbgprintf(insn, "readModRM()"); // already got ModRM byte? if (insn->consumedModRM) return 0; if (consumeByte(insn, &insn->modRM)) return -1; // mark that we already got ModRM insn->consumedModRM = true; // save original ModRM for later reference insn->orgModRM = insn->modRM; // handle MOVcr, MOVdr, MOVrc, MOVrd by pretending they have MRM.mod = 3 if ((insn->firstByte == 0x0f && insn->opcodeType == TWOBYTE) && (insn->opcode >= 0x20 && insn->opcode <= 0x23 )) insn->modRM \|= 0xC0; mod = modFromModRM(insn->modRM); rm = rmFromModRM(insn->modRM); reg = regFromModRM(insn->modRM); / * This goes by insn->registerSize to pick the correct register, which messes * up if we're using (say) XMM or 8-bit register operands. That gets fixed in * fixupReg(). / switch (insn->registerSize) { case 2: insn->regBase = MODRM_REG_AX; insn->eaRegBase = EA_REG_AX; break; case 4: insn->regBase = MODRM_REG_EAX; insn->eaRegBase = EA_REG_EAX; break; case 8: insn->regBase = MODRM_REG_RAX; insn->eaRegBase = EA_REG_RAX; break; } reg \|= rFromREX(insn->rexPrefix) << 3; rm \|= bFromREX(insn->rexPrefix) << 3; if (insn->vectorExtensionType == TYPE_EVEX) { reg \|= r2FromEVEX2of4(insn->vectorExtensionPrefix[1]) << 4; rm \|= xFromEVEX2of4(insn->vectorExtensionPrefix[1]) << 4; } insn->reg = (Reg)(insn->regBase + reg); switch (insn->addressSize) { case 2: insn->eaBaseBase = EA_BASE_BX_SI; switch (mod) { case 0x0: if (rm == 0x6) { insn->eaBase = EA_BASE_NONE; insn->eaDisplacement = EA_DISP_16; if (readDisplacement(insn)) return -1; } else { insn->eaBase = (EABase)(insn->eaBaseBase + rm); insn->eaDisplacement = EA_DISP_NONE; } break; case 0x1: insn->eaBase = (EABase)(insn->eaBaseBase + rm); insn->eaDisplacement = EA_DISP_8; insn->displacementSize = 1; if (readDisplacement(insn)) return -1; break; case 0x2: insn->eaBase = (EABase)(insn->eaBaseBase + rm); insn->eaDisplacement = EA_DISP_16; if (readDisplacement(insn)) return -1; break; case 0x3: insn->eaBase = (EABase)(insn->eaRegBase + rm); if (readDisplacement(insn)) return -1; break; } break; case 4: case 8: insn->eaBaseBase = (insn->addressSize == 4 ? EA_BASE_EAX : EA_BASE_RAX); switch (mod) { case 0x0: insn->eaDisplacement = EA_DISP_NONE; / readSIB may override this / switch (rm) { case 0x14: case 0x4: case 0xc: / in case REXW.b is set / insn->eaBase = (insn->addressSize == 4 ? EA_BASE_sib : EA_BASE_sib64); if (readSIB(insn) \|\| readDisplacement(insn)) return -1; break; case 0x5: case 0xd: insn->eaBase = EA_BASE_NONE; insn->eaDisplacement = EA_DISP_32; if (readDisplacement(insn)) return -1; break; default: insn->eaBase = (EABase)(insn->eaBaseBase + rm); break; } break; case 0x1: insn->displacementSize = 1; / FALLTHROUGH / case 0x2: insn->eaDisplacement = (mod == 0x1 ? EA_DISP_8 : EA_DISP_32); switch (rm) { case 0x14: case 0x4: case 0xc: / in case REXW.b is set / insn->eaBase = EA_BASE_sib; if (readSIB(insn) \|\| readDisplacement(insn)) return -1; break; default: insn->eaBase = (EABase)(insn->eaBaseBase + rm); if (readDisplacement(insn)) return -1; break; } break; case 0x3: insn->eaDisplacement = EA_DISP_NONE; insn->eaBase = (EABase)(insn->eaRegBase + rm); break; } break; } / switch (insn->addressSize) */ return 0; }	pushq %r15 pushq %r14 pushq %rbx xorl %ebx, %ebx cmpb $0x0, 0x10c(%rdi) jne 0xa0ca1 movq %rdi, %r14 leaq 0x9a8(%rdi), %r15 movq %r15, %rsi callq 0xa09cc pushq $-0x1 popq %rbx testl %eax, %eax jne 0xa0ca1 movb $0x1, 0x10c(%r14) movb 0x9a8(%r14), %al movb 0x9a9(%r14), %cl movb %al, 0x10d(%r14) cmpb $0xf, %cl jne 0xa0a62 cmpl $0x1, 0x990(%r14) jne 0xa0a62 movb 0x98f(%r14), %cl andb $-0x4, %cl cmpb $0x20, %cl jne 0xa0a62 orb $-0x40, %al movb %al, (%r15) movl %eax, %edx andb $0x7, %dl movl %eax, %esi shrb $0x3, %sil andb $0x7, %sil movzbl 0x988(%r14), %ecx cmpl $0x2, %ecx je 0xa0a9c cmpl $0x8, %ecx je 0xa0a92 cmpl $0x4, %ecx jne 0xa0aac movsd 0x98bf0(%rip), %xmm0 # 0x139680 jmp 0xa0aa4 movsd 0x98bd6(%rip), %xmm0 # 0x139670 jmp 0xa0aa4 movsd 0x98bbc(%rip), %xmm0 # 0x139660 movlps %xmm0, 0x9c8(%r14) movb 0x105(%r14), %cl leal (%rcx,%rcx), %edi andb $0x8, %dil orb %sil, %dil shlb $0x3, %cl andb $0x8, %cl orb %dl, %cl cmpl $0x3, 0x978(%r14) jne 0xa0aed movb 0x931(%r14), %dl notb %dl movl %edx, %esi andb $0x10, %sil orb %dil, %sil shrb $0x2, %dl andb $0x10, %dl orb %cl, %dl movl %edx, %ecx movl %esi, %edi movzbl %dil, %edx addl 0x9cc(%r14), %edx shrb $0x6, %al movl %edx, 0x9d8(%r14) movzbl 0x989(%r14), %esi cmpl $0x8, %esi je 0xa0b50 cmpl $0x4, %esi je 0xa0b50 cmpl $0x2, %esi jne 0xa0c9f movl $0x1, 0x9c4(%r14) movzbl %al, %eax leaq 0x49bc6(%rip), %rdx # 0xea6f8 movslq (%rdx,%rax,4), %rax addq %rdx, %rax jmpq %rax cmpb $0x6, %cl jne 0xa0ca9 movabsq $0x200000000, %rax # imm = 0x200000000 jmp 0xa0baa xorl %edx, %edx cmpb $0x4, %sil setne %dl shll $0x4, %edx addl $0x11, %edx movl %edx, 0x9c4(%r14) movzbl %al, %edi leaq 0x49b50(%rip), %r8 # 0xea6c0 movslq (%r8,%rdi,4), %rdi addq %r8, %rdi jmpq %rdi andl $0x0, 0x9d4(%r14) movzbl %cl, %eax leal -0x4(%rax), %ecx cmpl $0x9, %ecx ja 0xa0c6c leaq 0x49b39(%rip), %rdi # 0xea6d0 movslq (%rdi,%rcx,4), %rcx addq %rdi, %rcx jmpq *%rcx movabsq $0x300000000, %rax # imm = 0x300000000 movq %rax, 0x9d0(%r14) jmp 0xa0c93 movb $0x1, 0x98a(%r14) xorl %esi, %esi cmpb $0x1, %al setne %sil leal 0x1(,%rsi,2), %eax movl %eax, 0x9d4(%r14) movzbl %cl, %eax cmpb $0x14, %cl ja 0xa0c2d movl $0x101010, %ecx # imm = 0x101010 btl %eax, %ecx jae 0xa0c2d movl $0x15, 0x9d0(%r14) jmp 0xa0c87 andl $0x0, 0x9d4(%r14) movzbl %cl, %eax addl 0x9c8(%r14), %eax movl %eax, 0x9d0(%r14) jmp 0xa0c9f movzbl %cl, %eax incl %eax movl %eax, 0x9d0(%r14) movl $0x2, 0x9d4(%r14) jmp 0xa0c93 addl %eax, %edx movl %edx, 0x9d0(%r14) jmp 0xa0c93 movzbl %cl, %eax addl 0x9c8(%r14), %eax movl %eax, 0x9d0(%r14) jmp 0xa0c93 movzbl %cl, %eax incl %eax movl %eax, 0x9d0(%r14) movl $0x1, 0x9d4(%r14) movb $0x1, 0x98a(%r14) jmp 0xa0c93 cmpl $0x14, %eax jne 0xa0cbf xorl %eax, %eax cmpb $0x4, %sil setne %al shll $0x4, %eax addl $0x15, %eax movl %eax, 0x9d0(%r14) movq %r14, %rdi callq 0xa0e3b testl %eax, %eax jne 0xa0ca1 movq %r14, %rdi callq 0xa0cca testl %eax, %eax jne 0xa0ca1 xorl %ebx, %ebx movl %ebx, %eax popq %rbx popq %r14 popq %r15 retq movzbl %cl, %eax incl %eax movl %eax, 0x9d0(%r14) andl $0x0, 0x9d4(%r14) jmp 0xa0c9f addl %eax, %edx movl %edx, 0x9d0(%r14) jmp 0xa0c9f	/radare[P]capstone/arch/X86/X86DisassemblerDecoder.c
readSIB	static int readSIB(struct InternalInstruction *insn) { SIBIndex sibIndexBase = SIB_INDEX_NONE; SIBBase sibBaseBase = SIB_BASE_NONE; uint8_t index, base; // dbgprintf(insn, "readSIB()"); if (insn->consumedSIB) return 0; insn->consumedSIB = true; switch (insn->addressSize) { case 2: // dbgprintf(insn, "SIB-based addressing doesn't work in 16-bit mode"); return -1; case 4: sibIndexBase = SIB_INDEX_EAX; sibBaseBase = SIB_BASE_EAX; break; case 8: sibIndexBase = SIB_INDEX_RAX; sibBaseBase = SIB_BASE_RAX; break; } if (consumeByte(insn, &insn->sib)) return -1; index = indexFromSIB(insn->sib) \| (xFromREX(insn->rexPrefix) << 3); if (insn->vectorExtensionType == TYPE_EVEX) index \|= v2FromEVEX4of4(insn->vectorExtensionPrefix[3]) << 4; switch (index) { case 0x4: insn->sibIndex = SIB_INDEX_NONE; break; default: insn->sibIndex = (SIBIndex)(sibIndexBase + index); if (insn->sibIndex == SIB_INDEX_sib \|\| insn->sibIndex == SIB_INDEX_sib64) insn->sibIndex = SIB_INDEX_NONE; break; } switch (scaleFromSIB(insn->sib)) { case 0: insn->sibScale = 1; break; case 1: insn->sibScale = 2; break; case 2: insn->sibScale = 4; break; case 3: insn->sibScale = 8; break; } base = baseFromSIB(insn->sib) \| (bFromREX(insn->rexPrefix) << 3); switch (base) { case 0x5: case 0xd: switch (modFromModRM(insn->modRM)) { case 0x0: insn->eaDisplacement = EA_DISP_32; insn->sibBase = SIB_BASE_NONE; break; case 0x1: insn->eaDisplacement = EA_DISP_8; insn->sibBase = (SIBBase)(sibBaseBase + base); break; case 0x2: insn->eaDisplacement = EA_DISP_32; insn->sibBase = (SIBBase)(sibBaseBase + base); break; case 0x3: //debug("Cannot have Mod = 0b11 and a SIB byte"); return -1; } break; default: insn->sibBase = (SIBBase)(sibBaseBase + base); break; } return 0; }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax xorl %ebp, %ebp cmpb $0x0, 0x10e(%rdi) jne 0xa0f95 movq %rdi, %rbx movb $0x1, 0x10e(%rdi) movzbl 0x989(%rdi), %eax pushq $-0x1 popq %rbp cmpl $0x2, %eax je 0xa0f95 cmpl $0x8, %eax je 0xa0e89 xorl %r15d, %r15d movl $0x0, %r14d cmpl $0x4, %eax jne 0xa0e91 pushq $0x1 popq %r14 pushq $0x11 jmp 0xa0e8f pushq $0x11 popq %r14 pushq $0x21 popq %r15 leaq 0x10f(%rbx), %rsi movq %rbx, %rdi callq 0xa09cc testl %eax, %eax jne 0xa0f95 movzbl 0x10f(%rbx), %eax movl %eax, %esi shrb $0x3, %sil andb $0x7, %sil movb 0x105(%rbx), %dl leal (,%rdx,4), %ecx andb $0x8, %cl orb %sil, %cl cmpl $0x3, 0x978(%rbx) jne 0xa0eec movb 0x933(%rbx), %sil addb %sil, %sil andb $0x10, %sil orb %cl, %sil xorb $0x10, %sil movl %esi, %ecx cmpb $0x4, %cl jne 0xa0efa leaq 0x11c(%rbx), %rcx jmp 0xa0f1a movzbl %cl, %ecx addl %ecx, %r15d leaq 0x11c(%rbx), %rcx movl %r15d, 0x11c(%rbx) cmpl $0x25, %r15d je 0xa0f1a cmpl $0x15, %r15d jne 0xa0f1d andl $0x0, (%rcx) movl %eax, %ecx shrb $0x3, %cl andb $0x18, %cl movl $0x8040201, %esi # imm = 0x8040201 shrl %cl, %esi movb %sil, 0x120(%rbx) andb $0x7, %al shlb $0x3, %dl andb $0x8, %dl orb %al, %dl movzbl %dl, %eax movl %eax, %ecx orl $0x8, %ecx cmpl $0xd, %ecx jne 0xa0f89 movzbl 0x9a8(%rbx), %ecx shrl $0x6, %ecx leaq 0x497ad(%rip), %rdx # 0xea708 movslq (%rdx,%rcx,4), %rcx addq %rdx, %rcx jmpq *%rcx movl $0x3, 0x9d4(%rbx) xorl %r14d, %r14d jmp 0xa0f8c movl $0x1, 0x9d4(%rbx) jmp 0xa0f89 movl $0x3, 0x9d4(%rbx) addl %eax, %r14d movl %r14d, 0x124(%rbx) xorl %ebp, %ebp movl %ebp, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/radare[P]capstone/arch/X86/X86DisassemblerDecoder.c
getIDWithAttrMask	static int getIDWithAttrMask(uint16_t instructionID, struct InternalInstruction insn, uint16_t attrMask) { bool hasModRMExtension; InstructionContext instructionClass; #ifndef CAPSTONE_X86_REDUCE // HACK for femms. to be handled properly in next version 3.x if (insn->opcode == 0x0e && insn->opcodeType == T3DNOW_MAP) { instructionID = X86_FEMMS; return 0; } #endif if (insn->opcodeType == T3DNOW_MAP) instructionClass = IC_OF; else instructionClass = contextForAttrs(attrMask); hasModRMExtension = modRMRequired(insn->opcodeType, instructionClass, insn->opcode); if (hasModRMExtension) { if (readModRM(insn)) return -1; instructionID = decode(insn->opcodeType, instructionClass, insn->opcode, insn->modRM); } else { *instructionID = decode(insn->opcodeType, instructionClass, insn->opcode, 0); } return 0; }	pushq %rbp pushq %r14 pushq %rbx movl %edx, %ecx movq %rsi, %r14 movq %rdi, %rbx movzbl 0x98f(%rsi), %edx movl 0x990(%rsi), %edi cmpq $0xe, %rdx jne 0xa0fcf movw $0x2fc, %ax # imm = 0x2FC cmpl $0x7, %edi jne 0xa0fd9 jmp 0xa106c cmpl $0x7, %edi jne 0xa0fd9 pushq $0x4 popq %rbp jmp 0xa1037 movzwl %cx, %eax leaq 0x4bb9d(%rip), %rcx # 0xecb80 movzbl (%rax,%rcx), %ebp leal -0x1(%rdi), %eax cmpl $0x5, %eax ja 0xa100f movl %eax, %ecx leaq 0x98630(%rip), %rsi # 0x139628 movslq (%rsi,%rcx,4), %rax addq %rsi, %rax leaq 0x9863a(%rip), %rsi # 0x139640 movslq (%rsi,%rcx,4), %rcx addq %rsi, %rcx jmp 0xa101d leaq 0x539aa(%rip), %rcx # 0xf49c0 leaq 0x4fb63(%rip), %rax # 0xf0b80 movl %ebp, %esi movzbl (%rcx,%rsi), %ecx testq %rcx, %rcx je 0xa1048 decl %ecx shlq $0xa, %rcx addq %rcx, %rax cmpb $0x0, (%rax,%rdx,4) je 0xa1048 movq %r14, %rdi callq 0xa09f1 testl %eax, %eax je 0xa104e pushq $-0x1 popq %rax jmp 0xa1071 movl %ebp, %esi xorl %ecx, %ecx jmp 0xa1067 movl 0x990(%r14), %edi movzbl 0x98f(%r14), %edx movzbl 0x9a8(%r14), %ecx movl %ebp, %esi callq 0xa1076 movw %ax, (%rbx) xorl %eax, %eax popq %rbx popq %r14 popq %rbp retq	/radare[P]capstone/arch/X86/X86DisassemblerDecoder.c
decode	static InstrUID decode(OpcodeType type, InstructionContext insnContext, uint8_t opcode, uint8_t modRM) { const struct ModRMDecision dec = NULL; const uint8_t indextable = NULL; uint8_t index; switch (type) { default: case ONEBYTE: indextable = index_x86DisassemblerOneByteOpcodes; index = indextable[insnContext]; if (index) dec = &ONEBYTE_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; case TWOBYTE: indextable = index_x86DisassemblerTwoByteOpcodes; index = indextable[insnContext]; if (index) dec = &TWOBYTE_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; case THREEBYTE_38: indextable = index_x86DisassemblerThreeByte38Opcodes; index = indextable[insnContext]; if (index) dec = &THREEBYTE38_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; case THREEBYTE_3A: indextable = index_x86DisassemblerThreeByte3AOpcodes; index = indextable[insnContext]; if (index) dec = &THREEBYTE3A_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; #ifndef CAPSTONE_X86_REDUCE case XOP8_MAP: indextable = index_x86DisassemblerXOP8Opcodes; index = indextable[insnContext]; if (index) dec = &XOP8_MAP_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; case XOP9_MAP: indextable = index_x86DisassemblerXOP9Opcodes; index = indextable[insnContext]; if (index) dec = &XOP9_MAP_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; case XOPA_MAP: indextable = index_x86DisassemblerXOPAOpcodes; index = indextable[insnContext]; if (index) dec = &XOPA_MAP_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; case T3DNOW_MAP: indextable = index_x86DisassemblerT3DNOWOpcodes; index = indextable[insnContext]; if (index) dec = &T3DNOW_MAP_SYM[index - 1].modRMDecisions[opcode]; else dec = &emptyTable.modRMDecisions[opcode]; break; #endif } switch (dec->modrm_type) { default: //debug("Corrupt table! Unknown modrm_type"); return 0; case MODRM_ONEENTRY: return modRMTable[dec->instructionIDs]; case MODRM_SPLITRM: if (modFromModRM(modRM) == 0x3) return modRMTable[dec->instructionIDs+1]; return modRMTable[dec->instructionIDs]; case MODRM_SPLITREG: if (modFromModRM(modRM) == 0x3) return modRMTable[dec->instructionIDs+((modRM & 0x38) >> 3)+8]; return modRMTable[dec->instructionIDs+((modRM & 0x38) >> 3)]; case MODRM_SPLITMISC: if (modFromModRM(modRM) == 0x3) return modRMTable[dec->instructionIDs+(modRM & 0x3f)+8]; return modRMTable[dec->instructionIDs+((modRM & 0x38) >> 3)]; case MODRM_FULL: return modRMTable[dec->instructionIDs+modRM]; } }	movl %esi, %eax decl %edi cmpl $0x6, %edi ja 0xa113f leaq 0x4968e(%rip), %rsi # 0xea718 movslq (%rsi,%rdi,4), %rdi addq %rsi, %rdi jmpq %rdi leaq 0x536e6(%rip), %rsi # 0xf4780 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x539c7(%rip), %rax # 0xf4a80 jmp 0xa11d1 leaq 0x885bb(%rip), %rsi # 0x129680 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x8719c(%rip), %rax # 0x128280 jmp 0xa11d1 leaq 0x53810(%rip), %rsi # 0xf4900 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x7e571(%rip), %rax # 0x11f680 jmp 0xa11d1 leaq 0x88565(%rip), %rsi # 0x129680 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x85d46(%rip), %rax # 0x126e80 jmp 0xa11d1 leaq 0x5387a(%rip), %rsi # 0xf49c0 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x4fa1b(%rip), %rax # 0xf0b80 jmp 0xa11d1 leaq 0x536d2(%rip), %rsi # 0xf4840 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x70cf7(%rip), %rax # 0x111e80 jmp 0xa11d1 leaq 0x891ae(%rip), %rsi # 0x12a340 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x88593(%rip), %rax # 0x129740 jmp 0xa11d1 leaq 0x8d3aa(%rip), %rsi # 0x12e560 movzbl (%rax,%rsi), %esi testq %rsi, %rsi je 0xa11d6 movl $0xffffffff, %eax # imm = 0xFFFFFFFF addl %eax, %esi shlq $0xa, %rsi leaq 0x8d44f(%rip), %rax # 0x12e620 addq %rsi, %rax jmp 0xa11dd leaq 0x89217(%rip), %rax # 0x12a3f4 movzbl %dl, %edx movzbl (%rax,%rdx,4), %esi cmpq $0x4, %rsi ja 0xa1252 leaq 0x49543(%rip), %rdi # 0xea734 movslq (%rdi,%rsi,4), %rsi addq %rdi, %rsi jmpq %rsi movzwl 0x2(%rax,%rdx,4), %ecx jmp 0xa1264 movzwl 0x2(%rax,%rdx,4), %eax movzbl %cl, %ecx addq %rax, %rcx jmp 0xa1264 movzbl %cl, %ecx movl %ecx, %esi notl %esi movzwl 0x2(%rax,%rdx,4), %eax testb $-0x40, %sil jne 0xa1255 andl $0x3f, %ecx addl %eax, %ecx addl $0x8, %ecx jmp 0xa1264 movzbl %cl, %ecx movl %ecx, %esi notl %esi shrl $0x3, %ecx movzwl 0x2(%rax,%rdx,4), %eax testb $-0x40, %sil jne 0xa125f andl $0xf, %ecx jmp 0xa1262 cmpb $-0x40, %cl movzwl 0x2(%rax,%rdx,4), %ecx sbbq $-0x1, %rcx jmp 0xa1264 xorl %eax, %eax retq shrl $0x3, %ecx andl $0x7, %ecx addl %eax, %ecx jmp 0xa1264 andl $0x7, %ecx addl %eax, %ecx leaq 0x89595(%rip), %rax # 0x12a800 movzwl (%rax,%rcx,2), %eax retq	/radare[P]capstone/arch/X86/X86DisassemblerDecoder.c
readOpcodeRegister	static int readOpcodeRegister(struct InternalInstruction *insn, uint8_t size) { // dbgprintf(insn, "readOpcodeRegister()"); if (size == 0) size = insn->registerSize; insn->operandSize = size; switch (size) { case 1: insn->opcodeRegister = (Reg)(MODRM_REG_AL + ((bFromREX(insn->rexPrefix) << 3) \| (insn->opcode & 7))); if (insn->rexPrefix && insn->opcodeRegister >= MODRM_REG_AL + 0x4 && insn->opcodeRegister < MODRM_REG_AL + 0x8) { insn->opcodeRegister = (Reg)(MODRM_REG_SPL + (insn->opcodeRegister - MODRM_REG_AL - 4)); } break; case 2: insn->opcodeRegister = (Reg)(MODRM_REG_AX + ((bFromREX(insn->rexPrefix) << 3) \| (insn->opcode & 7))); break; case 4: insn->opcodeRegister = (Reg)(MODRM_REG_EAX + ((bFromREX(insn->rexPrefix) << 3) \| (insn->opcode & 7))); break; case 8: insn->opcodeRegister = (Reg)(MODRM_REG_RAX + ((bFromREX(insn->rexPrefix) << 3) \| (insn->opcode & 7))); break; } return 0; }	testl %esi, %esi jne 0xa15e3 movb 0x988(%rdi), %sil movb %sil, (%rdi) movzbl %sil, %eax decl %eax cmpl $0x7, %eax ja 0xa1691 leaq 0x491d4(%rip), %rcx # 0xea7d0 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movzbl 0x105(%rdi), %ecx leal (,%rcx,8), %edx andl $0x8, %edx movzbl 0x98f(%rdi), %eax andl $0x7, %eax orl %edx, %eax movl %eax, 0x9c0(%rdi) testl %edx, %edx jne 0xa1691 testb %cl, %cl je 0xa1691 cmpb $0x4, %al jb 0xa1691 addl $0xc, %eax jmp 0xa168b movzbl 0x105(%rdi), %eax andl $0x1, %eax movzbl 0x98f(%rdi), %ecx andl $0x7, %ecx leal (%rcx,%rax,8), %eax addl $0x24, %eax jmp 0xa168b movzbl 0x105(%rdi), %eax andl $0x1, %eax movzbl 0x98f(%rdi), %ecx andl $0x7, %ecx leal (%rcx,%rax,8), %eax addl $0x14, %eax jmp 0xa168b movzbl 0x105(%rdi), %eax andl $0x1, %eax movzbl 0x98f(%rdi), %ecx andl $0x7, %ecx leal (%rcx,%rax,8), %eax addl $0x34, %eax movl %eax, 0x9c0(%rdi) retq	/radare[P]capstone/arch/X86/X86DisassemblerDecoder.c
printSrcIdx	static void printSrcIdx(MCInst MI, unsigned Op, SStream O) { MCOperand *SegReg; int reg; if (MI->csh->detail) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0; } SegReg = MCInst_getOperand(MI, Op+1); reg = MCOperand_getReg(SegReg); // If this has a segment register, print it. if (reg) { _printOperand(MI, Op+1, O); if (MI->csh->detail) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = reg; } SStream_concat0(O, ":"); } SStream_concat0(O, "["); set_mem_access(MI, true); printOperand(MI, Op, O); SStream_concat0(O, "]"); set_mem_access(MI, false); }	pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdx, %r14 movl %esi, %r15d movq %rdi, %rbx movq 0x320(%rdi), %rax cmpl $0x0, 0xe0(%rax) je 0xa1872 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl $0x3, 0x60(%rax,%rcx) movb 0x328(%rbx), %al movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %edx imulq $0x30, %rdx, %rdx movb %al, 0x80(%rcx,%rdx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andl $0x0, 0x68(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andl $0x0, 0x6c(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andl $0x0, 0x70(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl $0x1, 0x74(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andq $0x0, 0x78(%rax,%rcx) leal 0x1(%r15), %r12d movq %rbx, %rdi movl %r12d, %esi callq 0x45587 movq %rax, %rdi callq 0x455da testl %eax, %eax je 0xa18d6 movl %eax, %ebp movq %rbx, %rdi movl %r12d, %esi movq %r14, %rdx callq 0xa2f66 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa18c7 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl %ebp, 0x68(%rax,%rcx) leaq 0x40ef0(%rip), %rsi # 0xe27be movq %r14, %rdi callq 0x4565f leaq 0x3b76a(%rip), %rsi # 0xdd047 movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x3, 0xe0(%rax) jne 0xa18fc movb $0x1, 0xe8(%rax) movq %rbx, %rdi movl %r15d, %esi movq %r14, %rdx callq 0xa3034 leaq 0x3c32d(%rip), %rsi # 0xddc3e movq %r14, %rdi callq 0x4565f movq %rbx, %rdi xorl %esi, %esi popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmp 0xa3006	/radare[P]capstone/arch/X86/X86IntelInstPrinter.c
printDstIdx	static void printDstIdx(MCInst MI, unsigned Op, SStream O) { if (MI->csh->detail) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0; } // DI accesses are always ES-based on non-64bit mode if (MI->csh->mode != CS_MODE_64) { SStream_concat(O, "es:["); if (MI->csh->detail) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_ES; } } else SStream_concat(O, "["); set_mem_access(MI, true); printOperand(MI, Op, O); SStream_concat0(O, "]"); set_mem_access(MI, false); }	pushq %rbp pushq %r14 pushq %rbx movq %rdx, %r14 movl %esi, %ebp movq %rdi, %rbx movq 0x320(%rdi), %rax cmpl $0x0, 0xe0(%rax) je 0xa1aeb movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl $0x3, 0x60(%rax,%rcx) movb 0x328(%rbx), %al movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %edx imulq $0x30, %rdx, %rdx movb %al, 0x80(%rcx,%rdx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andl $0x0, 0x68(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andl $0x0, 0x6c(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andl $0x0, 0x70(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl $0x1, 0x74(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andq $0x0, 0x78(%rax,%rcx) movq 0x320(%rbx), %rax cmpl $0x8, 0x4(%rax) jne 0xa1b04 leaq 0x3b54f(%rip), %rsi # 0xdd047 movq %r14, %rdi xorl %eax, %eax callq 0x456a6 jmp 0xa1b43 leaq 0xa4685(%rip), %rsi # 0x146190 movq %r14, %rdi xorl %eax, %eax callq 0x456a6 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa1b43 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl $0x1c, 0x68(%rax,%rcx) movq 0x320(%rbx), %rax cmpl $0x3, 0xe0(%rax) jne 0xa1b5a movb $0x1, 0xe8(%rax) movq %rbx, %rdi movl %ebp, %esi movq %r14, %rdx callq 0xa3034 leaq 0x3c0d0(%rip), %rsi # 0xddc3e movq %r14, %rdi callq 0x4565f movq %rbx, %rdi xorl %esi, %esi popq %rbx popq %r14 popq %rbp jmp 0xa3006	/radare[P]capstone/arch/X86/X86IntelInstPrinter.c
printOperand	static void _printOperand(MCInst MI, unsigned OpNo, SStream O) { MCOperand *Op = MCInst_getOperand(MI, OpNo); if (MCOperand_isReg(Op)) { printRegName(O, MCOperand_getReg(Op)); } else if (MCOperand_isImm(Op)) { int64_t imm = MCOperand_getImm(Op); if (imm < 0) { if (imm < -HEX_THRESHOLD) SStream_concat(O, "-0x%"PRIx64, -imm); else SStream_concat(O, "-%"PRIu64, -imm); } else { if (imm > HEX_THRESHOLD) SStream_concat(O, "0x%"PRIx64, imm); else SStream_concat(O, "%"PRIu64, imm); } } }	pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx callq 0x45587 movq %rax, %r14 movq %rax, %rdi callq 0x455c2 testb %al, %al je 0xa2f9a movq %r14, %rdi callq 0x455da movq %rbx, %rdi movl %eax, %esi addq $0x8, %rsp popq %rbx popq %r14 jmp 0xa32e1 movq %r14, %rdi callq 0x455ca testb %al, %al je 0xa2fc2 movq %r14, %rdi callq 0x455e2 testq %rax, %rax js 0xa2fca cmpq $0xa, %rax jb 0xa2fdf leaq 0xa3245(%rip), %rsi # 0x146205 jmp 0xa2fe6 addq $0x8, %rsp popq %rbx popq %r14 retq movq %rax, %rdx negq %rdx cmpq $-0xa, %rax ja 0xa2fee leaq 0x1e482(%rip), %rsi # 0xc145f jmp 0xa2ff5 leaq 0xa3228(%rip), %rsi # 0x14620e movq %rbx, %rdi movq %rax, %rdx jmp 0xa2ff8 leaq 0x1e472(%rip), %rsi # 0xc1467 movq %rbx, %rdi xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r14 jmp 0x456a6	/radare[P]capstone/arch/X86/X86IntelInstPrinter.c
printOperand	static void printOperand(MCInst MI, unsigned OpNo, SStream O) { MCOperand *Op = MCInst_getOperand(MI, OpNo); if (MCOperand_isReg(Op)) { unsigned int reg = MCOperand_getReg(Op); printRegName(O, reg); if (MI->csh->detail) { if (MI->csh->doing_mem) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = reg; } else { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_REG; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].reg = reg; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->csh->regsize_map[reg]; MI->flat_insn->detail->x86.op_count++; } } if (MI->op1_size == 0) MI->op1_size = MI->csh->regsize_map[reg]; } else if (MCOperand_isImm(Op)) { int64_t imm = MCOperand_getImm(Op); switch(MI->flat_insn->id) { default: if (imm >= 0) { if (imm > HEX_THRESHOLD) SStream_concat(O, "0x%"PRIx64, imm); else SStream_concat(O, "%"PRIu64, imm); } else { if (imm < -HEX_THRESHOLD) SStream_concat(O, "-0x%"PRIx64, -imm); else SStream_concat(O, "-%"PRIu64, -imm); } break; case X86_INS_AND: case X86_INS_OR: case X86_INS_XOR: // do not print number in negative form if (imm >= 0 && imm <= HEX_THRESHOLD) SStream_concat(O, "%u", imm); else SStream_concat(O, "0x%"PRIx64, arch_masks[MI->op1_size? MI->op1_size : MI->imm_size] & imm); break; case X86_INS_RET: // RET imm16 if (imm >= 0 && imm <= HEX_THRESHOLD) SStream_concat(O, "%u", imm); else { imm = 0xffff & imm; SStream_concat(O, "0x%x", 0xffff & imm); } break; } if (MI->csh->detail) { if (MI->csh->doing_mem) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = imm; } else { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_IMM; if (MI->flat_insn->detail->x86.op_count > 0) MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->flat_insn->detail->x86.operands[0].size; else MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->imm_size; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].imm = imm; MI->flat_insn->detail->x86.op_count++; } } //if (MI->op1_size == 0) // MI->op1_size = MI->imm_size; } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %r15 movq %rdi, %rbx callq 0x45587 movq %rax, %r14 movq %rax, %rdi callq 0x455c2 testb %al, %al je 0xa30af movq %r14, %rdi callq 0x455da movl %eax, %ebp movq %r15, %rdi movl %eax, %esi callq 0xa32e1 movq 0x320(%rbx), %rcx cmpl $0x0, 0xe0(%rcx) movl %ebp, %eax je 0xa3190 movq 0x310(%rbx), %rdx movq 0xe8(%rdx), %rdx movzbl 0x5c(%rdx), %esi addq $0x60, %rdx cmpb $0x1, 0xe8(%rcx) jne 0xa312c imulq $0x30, %rsi, %rcx movl %ebp, 0xc(%rdx,%rcx) jmp 0xa3190 movq %r14, %rdi callq 0x455ca testb %al, %al je 0xa3296 movq %r14, %rdi callq 0x455e2 movq %rax, %r14 movq 0x310(%rbx), %rax movl (%rax), %eax cmpl $0x19, %eax je 0xa30f5 cmpl $0x95, %eax je 0xa31b3 cmpl $0x145, %eax # imm = 0x145 je 0xa30f5 cmpl $0x147, %eax # imm = 0x147 jne 0xa3247 cmpq $0x9, %r14 jbe 0xa31bd movb 0x6(%rbx), %al testb %al, %al jne 0xa310c movb 0x32d(%rbx), %al movzbl %al, %eax leaq 0x19a0ea(%rip), %rcx # 0x23d200 movq (%rcx,%rax,8), %rdx andq %r14, %rdx leaq 0xa30e1(%rip), %rsi # 0x146205 movq %r15, %rdi jmp 0xa31ca imulq $0x30, %rsi, %rcx movl $0x1, (%rdx,%rcx) movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %edx imulq $0x30, %rdx, %rdx movl %ebp, 0x68(%rcx,%rdx) movq 0x310(%rbx), %rcx movq 0x320(%rbx), %rdx movq 0x120(%rdx), %rdx movb (%rdx,%rax), %dl movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %esi imulq $0x30, %rsi, %rsi movb %dl, 0x80(%rcx,%rsi) movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx incb 0x5c(%rcx) cmpb $0x0, 0x6(%rbx) jne 0xa3296 movq 0x320(%rbx), %rcx movq 0x120(%rcx), %rcx movb (%rcx,%rax), %al movb %al, 0x6(%rbx) jmp 0xa3296 cmpq $0x9, %r14 ja 0xa32a1 leaq 0x27d62(%rip), %rsi # 0xcaf26 movq %r15, %rdi movq %r14, %rdx xorl %eax, %eax callq 0x456a6 movq 0x320(%rbx), %rcx cmpl $0x0, 0xe0(%rcx) je 0xa3296 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %edx addq $0x60, %rax cmpb $0x1, 0xe8(%rcx) jne 0xa3212 imulq $0x30, %rdx, %rcx movq %r14, 0x18(%rax,%rcx) jmp 0xa3296 imulq $0x30, %rdx, %rcx movl $0x2, (%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx testq %rcx, %rcx je 0xa325e movb 0x80(%rax), %dl imulq $0x30, %rcx, %rcx movb %dl, 0x80(%rax,%rcx) jmp 0xa326a testq %r14, %r14 js 0xa32b1 cmpq $0xa, %r14 jb 0xa32c9 leaq 0xa2fac(%rip), %rsi # 0x146205 jmp 0xa31c4 movb 0x32d(%rbx), %cl movb %cl, 0x80(%rax) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movq %r14, 0x68(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax incb 0x5c(%rax) addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movzwl %r14w, %r14d leaq 0x43279(%rip), %rsi # 0xe6525 jmp 0xa31c4 movq %r14, %rdx negq %rdx cmpq $-0xa, %r14 ja 0xa32d5 leaq 0x1e19b(%rip), %rsi # 0xc145f jmp 0xa3124 leaq 0xa2f3e(%rip), %rsi # 0x14620e jmp 0xa31c4 leaq 0x1e18b(%rip), %rsi # 0xc1467 jmp 0xa3124	/radare[P]capstone/arch/X86/X86IntelInstPrinter.c
printopaquemem	static void printopaquemem(MCInst MI, unsigned OpNo, SStream O) { SStream_concat0(O, "ptr "); switch(MI->csh->mode) { case CS_MODE_16: MI->x86opsize = 2; break; case CS_MODE_32: MI->x86opsize = 4; break; case CS_MODE_64: MI->x86opsize = 8; break; default: // never reach break; } printMemReference(MI, OpNo, O); }	pushq %rbp pushq %r14 pushq %rbx movq %rdx, %rbx movl %esi, %ebp movq %rdi, %r14 leaq 0xa2cc6(%rip), %rsi # 0x146180 movq %rdx, %rdi callq 0x4565f movq 0x320(%r14), %rax movl 0x4(%rax), %eax cmpl $0x2, %eax je 0xa34e3 cmpl $0x8, %eax je 0xa34df cmpl $0x4, %eax jne 0xa34ec movb $0x4, %al jmp 0xa34e5 movb $0x8, %al jmp 0xa34e5 movb $0x2, %al movb %al, 0x328(%r14) movq %r14, %rdi movl %ebp, %esi movq %rbx, %rdx popq %rbx popq %r14 popq %rbp jmp 0xa3639	/radare[P]capstone/arch/X86/X86IntelInstPrinter.c
printAVXCC	static void printAVXCC(MCInst MI, unsigned Op, SStream O) { int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0x1f; switch (Imm) { default: break;//printf("Invalid avxcc argument!\n"); break; case 0: SStream_concat0(O, "eq"); op_addAvxCC(MI, X86_AVX_CC_EQ); break; case 1: SStream_concat0(O, "lt"); op_addAvxCC(MI, X86_AVX_CC_LT); break; case 2: SStream_concat0(O, "le"); op_addAvxCC(MI, X86_AVX_CC_LE); break; case 3: SStream_concat0(O, "unord"); op_addAvxCC(MI, X86_AVX_CC_UNORD); break; case 4: SStream_concat0(O, "neq"); op_addAvxCC(MI, X86_AVX_CC_NEQ); break; case 5: SStream_concat0(O, "nlt"); op_addAvxCC(MI, X86_AVX_CC_NLT); break; case 6: SStream_concat0(O, "nle"); op_addAvxCC(MI, X86_AVX_CC_NLE); break; case 7: SStream_concat0(O, "ord"); op_addAvxCC(MI, X86_AVX_CC_ORD); break; case 8: SStream_concat0(O, "eq_uq"); op_addAvxCC(MI, X86_AVX_CC_EQ_UQ); break; case 9: SStream_concat0(O, "nge"); op_addAvxCC(MI, X86_AVX_CC_NGE); break; case 0xa: SStream_concat0(O, "ngt"); op_addAvxCC(MI, X86_AVX_CC_NGT); break; case 0xb: SStream_concat0(O, "false"); op_addAvxCC(MI, X86_AVX_CC_FALSE); break; case 0xc: SStream_concat0(O, "neq_oq"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OQ); break; case 0xd: SStream_concat0(O, "ge"); op_addAvxCC(MI, X86_AVX_CC_GE); break; case 0xe: SStream_concat0(O, "gt"); op_addAvxCC(MI, X86_AVX_CC_GT); break; case 0xf: SStream_concat0(O, "true"); op_addAvxCC(MI, X86_AVX_CC_TRUE); break; case 0x10: SStream_concat0(O, "eq_os"); op_addAvxCC(MI, X86_AVX_CC_EQ_OS); break; case 0x11: SStream_concat0(O, "lt_oq"); op_addAvxCC(MI, X86_AVX_CC_LT_OQ); break; case 0x12: SStream_concat0(O, "le_oq"); op_addAvxCC(MI, X86_AVX_CC_LE_OQ); break; case 0x13: SStream_concat0(O, "unord_s"); op_addAvxCC(MI, X86_AVX_CC_UNORD_S); break; case 0x14: SStream_concat0(O, "neq_us"); op_addAvxCC(MI, X86_AVX_CC_NEQ_US); break; case 0x15: SStream_concat0(O, "nlt_uq"); op_addAvxCC(MI, X86_AVX_CC_NLT_UQ); break; case 0x16: SStream_concat0(O, "nle_uq"); op_addAvxCC(MI, X86_AVX_CC_NLE_UQ); break; case 0x17: SStream_concat0(O, "ord_s"); op_addAvxCC(MI, X86_AVX_CC_ORD_S); break; case 0x18: SStream_concat0(O, "eq_us"); op_addAvxCC(MI, X86_AVX_CC_EQ_US); break; case 0x19: SStream_concat0(O, "nge_uq"); op_addAvxCC(MI, X86_AVX_CC_NGE_UQ); break; case 0x1a: SStream_concat0(O, "ngt_uq"); op_addAvxCC(MI, X86_AVX_CC_NGT_UQ); break; case 0x1b: SStream_concat0(O, "false_os"); op_addAvxCC(MI, X86_AVX_CC_FALSE_OS); break; case 0x1c: SStream_concat0(O, "neq_os"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OS); break; case 0x1d: SStream_concat0(O, "ge_oq"); op_addAvxCC(MI, X86_AVX_CC_GE_OQ); break; case 0x1e: SStream_concat0(O, "gt_oq"); op_addAvxCC(MI, X86_AVX_CC_GT_OQ); break; case 0x1f: SStream_concat0(O, "true_us"); op_addAvxCC(MI, X86_AVX_CC_TRUE_US); break; } }	pushq %rbp pushq %r14 pushq %rbx movq %rdx, %rbx movq %rdi, %r14 callq 0x45587 movq %rax, %rdi callq 0x455e2 andl $0x1f, %eax leaq 0xa2bd2(%rip), %rcx # 0x1460f0 movslq (%rcx,%rax,4), %rsi addq %rcx, %rsi leal 0x1(%rax), %ebp movq %rbx, %rdi callq 0x4565f movq %r14, %rdi movl %ebp, %esi popq %rbx popq %r14 popq %rbp jmp 0xa43a8	/radare[P]capstone/arch/X86/X86IntelInstPrinter.c
printMemReference	static void printMemReference(MCInst MI, unsigned Op, SStream O) { bool NeedPlus = false; MCOperand BaseReg = MCInst_getOperand(MI, Op + X86_AddrBaseReg); uint64_t ScaleVal = MCOperand_getImm(MCInst_getOperand(MI, Op + X86_AddrScaleAmt)); MCOperand IndexReg = MCInst_getOperand(MI, Op + X86_AddrIndexReg); MCOperand DispSpec = MCInst_getOperand(MI, Op + X86_AddrDisp); MCOperand SegReg = MCInst_getOperand(MI, Op + X86_AddrSegmentReg); int reg; if (MI->csh->detail) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = MCOperand_getReg(BaseReg); MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = MCOperand_getReg(IndexReg); MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = (int)ScaleVal; MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0; } // If this has a segment register, print it. reg = MCOperand_getReg(SegReg); if (reg) { _printOperand(MI, Op + X86_AddrSegmentReg, O); if (MI->csh->detail) { MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = reg; } SStream_concat0(O, ":"); } SStream_concat0(O, "["); if (MCOperand_getReg(BaseReg)) { _printOperand(MI, Op + X86_AddrBaseReg, O); NeedPlus = true; } if (MCOperand_getReg(IndexReg)) { if (NeedPlus) SStream_concat0(O, " + "); _printOperand(MI, Op + X86_AddrIndexReg, O); if (ScaleVal != 1) SStream_concat(O, "*%u", ScaleVal); NeedPlus = true; } if (MCOperand_isImm(DispSpec)) { int64_t DispVal = MCOperand_getImm(DispSpec); if (MI->csh->detail) MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = DispVal; if (DispVal) { if (NeedPlus) { if (DispVal < 0) { if (DispVal < -HEX_THRESHOLD) SStream_concat(O, " - 0x%"PRIx64, -DispVal); else SStream_concat(O, " - %"PRIu64, -DispVal); } else { if (DispVal > HEX_THRESHOLD) SStream_concat(O, " + 0x%"PRIx64, DispVal); else SStream_concat(O, " + %"PRIu64, DispVal); } } else { // memory reference to an immediate address if (DispVal < 0) { SStream_concat(O, "0x%"PRIx64, arch_masks[MI->csh->mode] & DispVal); } else { if (DispVal > HEX_THRESHOLD) SStream_concat(O, "0x%"PRIx64, DispVal); else SStream_concat(O, "%"PRIu64, DispVal); } } } else { // DispVal = 0 if (!NeedPlus) // [0] SStream_concat0(O, "0"); } } SStream_concat0(O, "]"); if (MI->csh->detail) MI->flat_insn->detail->x86.op_count++; if (MI->op1_size == 0) MI->op1_size = MI->x86opsize; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdx, 0x18(%rsp) movl %esi, %ebp movq %rdi, %rbx callq 0x45587 movq %rax, %r12 leal 0x1(%rbp), %esi movq %rbx, %rdi callq 0x45587 movq %rax, %rdi callq 0x455e2 movq %rax, %r13 leal 0x2(%rbp), %esi movq %rbx, %rdi movl %esi, 0xc(%rsp) callq 0x45587 movq %rax, %r14 leal 0x3(%rbp), %esi movq %rbx, %rdi callq 0x45587 movq %rax, 0x10(%rsp) leal 0x4(%rbp), %esi movq %rbx, %rdi movl %esi, 0x8(%rsp) callq 0x45587 movq %rax, %r15 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa378e movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl $0x3, 0x60(%rax,%rcx) movb 0x328(%rbx), %al movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %edx imulq $0x30, %rdx, %rdx movb %al, 0x80(%rcx,%rdx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andl $0x0, 0x68(%rax,%rcx) movq %r12, %rdi callq 0x455da movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %edx imulq $0x30, %rdx, %rdx movl %eax, 0x6c(%rcx,%rdx) movq %r14, %rdi callq 0x455da movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %edx imulq $0x30, %rdx, %rdx movl %eax, 0x70(%rcx,%rdx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl %r13d, 0x74(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx andq $0x0, 0x78(%rax,%rcx) movq %r13, 0x20(%rsp) movq %r15, %rdi callq 0x455da testl %eax, %eax movq 0x18(%rsp), %r13 je 0xa37f5 movl %eax, %r15d movq %rbx, %rdi movl 0x8(%rsp), %esi movq %r13, %rdx callq 0xa2f66 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa37e1 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x5c(%rax), %ecx imulq $0x30, %rcx, %rcx movl %r15d, 0x68(%rax,%rcx) leaq 0x3efd6(%rip), %rsi # 0xe27be movq 0x18(%rsp), %r13 movq %r13, %rdi callq 0x4565f leaq 0x3984b(%rip), %rsi # 0xdd047 movq %r13, %rdi callq 0x4565f movq %r12, %rdi callq 0x455da testl %eax, %eax je 0xa3822 movq %rbx, %rdi movl %ebp, %esi movq %r13, %rdx callq 0xa2f66 movb $0x1, %bpl jmp 0xa3824 xorl %ebp, %ebp movq 0x10(%rsp), %r15 movq %r14, %rdi callq 0x455da testl %eax, %eax je 0xa3877 testb %bpl, %bpl je 0xa3849 leaq 0xa29a9(%rip), %rsi # 0x1461ea movq %r13, %rdi callq 0x4565f movq %rbx, %rdi movl 0xc(%rsp), %esi movq %r13, %rdx callq 0xa2f66 movb $0x1, %bpl movq 0x20(%rsp), %rdx cmpq $0x1, %rdx je 0xa3877 leaq 0xa2981(%rip), %rsi # 0x1461ee movq %r13, %rdi xorl %eax, %eax callq 0x456a6 movq %r15, %rdi callq 0x455ca testb %al, %al je 0xa3966 movq %r15, %rdi callq 0x455e2 movq 0x320(%rbx), %rcx cmpl $0x0, 0xe0(%rcx) je 0xa38ba movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x5c(%rcx), %edx imulq $0x30, %rdx, %rdx movq %rax, 0x78(%rcx,%rdx) testq %rax, %rax je 0xa38d8 testb %bpl, %bpl je 0xa38f2 testq %rax, %rax js 0xa3906 cmpq $0xa, %rax jb 0xa393d leaq 0xa292c(%rip), %rsi # 0x146202 jmp 0xa394d testb %bpl, %bpl jne 0xa3966 leaq 0x4367b(%rip), %rsi # 0xe6f63 movq %r13, %rdi callq 0x4565f jmp 0xa3966 testq %rax, %rax js 0xa391b cmpq $0xa, %rax jb 0xa3946 leaq 0xa2901(%rip), %rsi # 0x146205 jmp 0xa394d movq %rax, %rdx negq %rdx cmpq $-0xa, %rax ja 0xa3955 leaq 0xa28d9(%rip), %rsi # 0x1461f2 jmp 0xa395c movq 0x320(%rbx), %rcx movslq 0x4(%rcx), %rcx leaq 0x1998d3(%rip), %rdx # 0x23d200 movq (%rdx,%rcx,8), %rdx andq %rax, %rdx leaq 0xa28ca(%rip), %rsi # 0x146205 jmp 0xa395c leaq 0xa28c7(%rip), %rsi # 0x14620b jmp 0xa394d leaq 0xa28c1(%rip), %rsi # 0x14620e movq %r13, %rdi movq %rax, %rdx jmp 0xa395f leaq 0xa289f(%rip), %rsi # 0x1461fb movq %r13, %rdi xorl %eax, %eax callq 0x456a6 leaq 0x3a2d1(%rip), %rsi # 0xddc3e movq %r13, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa3996 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax incb 0x5c(%rax) cmpb $0x0, 0x6(%rbx) jne 0xa39a5 movb 0x328(%rbx), %al movb %al, 0x6(%rbx) addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/radare[P]capstone/arch/X86/X86IntelInstPrinter.c
X86_reg_name	const char X86_reg_name(csh handle, unsigned int reg) { #ifndef CAPSTONE_DIET cs_struct ud = (cs_struct *)handle; if (reg >= X86_REG_ENDING) return NULL; if (reg == X86_REG_EFLAGS) { if (ud->mode & CS_MODE_32) return "eflags"; if (ud->mode & CS_MODE_64) return "rflags"; } return reg_name_maps[reg].name; #else return NULL; #endif }	cmpl $0xe9, %esi jbe 0xa3c29 xorl %eax, %eax retq cmpl $0x19, %esi jne 0xa3c39 movl 0x4(%rdi), %eax testb $0x4, %al jne 0xa3c4c testb $0x8, %al jne 0xa3c54 movl %esi, %eax shlq $0x4, %rax leaq 0xf54da(%rip), %rcx # 0x199120 movq 0x8(%rax,%rcx), %rax retq leaq 0xa2fc5(%rip), %rax # 0x146c18 retq leaq 0xa2fc4(%rip), %rax # 0x146c1f retq	/radare[P]capstone/arch/X86/X86Mapping.c
DecodeFPRegsRegisterClass	static DecodeStatus DecodeFPRegsRegisterClass(MCInst Inst, unsigned RegNo, uint64_t Address, const void Decoder) { unsigned Reg; if (RegNo > 31) return MCDisassembler_Fail; Reg = FPRegDecoderTable[RegNo]; MCOperand_CreateReg0(Inst, Reg); return MCDisassembler_Success; }	xorl %eax, %eax cmpl $0x1f, %esi ja 0xa52c9 pushq %rax movl %esi, %eax leaq 0xa3ec6(%rip), %rcx # 0x149180 movl (%rcx,%rax,4), %esi callq 0x4560d pushq $0x3 popq %rax addq $0x8, %rsp retq	/radare[P]capstone/arch/Sparc/SparcDisassembler.c
Sparc_post_printer	void Sparc_post_printer(csh ud, cs_insn insn, char insn_asm, MCInst mci) { if (((cs_struct )ud)->detail != CS_OPT_ON) return; // fix up some instructions if (insn->id == SPARC_INS_CASX) { // first op is actually a memop, not regop insn->detail->sparc.operands[0].type = SPARC_OP_MEM; insn->detail->sparc.operands[0].mem.base = insn->detail->sparc.operands[0].reg; insn->detail->sparc.operands[0].mem.disp = 0; } }	cmpl $0x3, 0xe0(%rdi) jne 0xa5417 cmpl $0x1c, (%rsi) jne 0xa5417 movq 0xe8(%rsi), %rax movl $0x3, 0x3c(%rax) movq 0xe8(%rsi), %rax andl $0x0, 0x44(%rax) retq	/radare[P]capstone/arch/Sparc/SparcInstPrinter.c
Sparc_printInst	void Sparc_printInst(MCInst MI, SStream O, void Info) { char mnem, p; char instr[64]; // Sparc has no instruction this long mnem = printAliasInstr(MI, O, Info); if (mnem) { // fixup instruction id due to the change in alias instruction strncpy(instr, mnem, strlen(mnem)); instr[strlen(mnem)] = '\0'; // does this contains hint with a coma? p = strchr(instr, ','); if (p) p = '\0'; // now instr only has instruction mnemonic MCInst_setOpcodePub(MI, Sparc_map_insn(instr)); switch(MCInst_getOpcode(MI)) { case SP_BCOND: case SP_BCONDA: case SP_BPICCANT: case SP_BPICCNT: case SP_BPXCCANT: case SP_BPXCCNT: case SP_TXCCri: case SP_TXCCrr: if (MI->csh->detail) { // skip 'b', 't' MI->flat_insn->detail->sparc.cc = Sparc_map_ICC(instr + 1); MI->flat_insn->detail->sparc.hint = Sparc_map_hint(mnem); } break; case SP_BPFCCANT: case SP_BPFCCNT: if (MI->csh->detail) { // skip 'fb' MI->flat_insn->detail->sparc.cc = Sparc_map_FCC(instr + 2); MI->flat_insn->detail->sparc.hint = Sparc_map_hint(mnem); } break; case SP_FMOVD_ICC: case SP_FMOVD_XCC: case SP_FMOVQ_ICC: case SP_FMOVQ_XCC: case SP_FMOVS_ICC: case SP_FMOVS_XCC: if (MI->csh->detail) { // skip 'fmovd', 'fmovq', 'fmovs' MI->flat_insn->detail->sparc.cc = Sparc_map_ICC(instr + 5); MI->flat_insn->detail->sparc.hint = Sparc_map_hint(mnem); } break; case SP_MOVICCri: case SP_MOVICCrr: case SP_MOVXCCri: case SP_MOVXCCrr: if (MI->csh->detail) { // skip 'mov' MI->flat_insn->detail->sparc.cc = Sparc_map_ICC(instr + 3); MI->flat_insn->detail->sparc.hint = Sparc_map_hint(mnem); } break; case SP_V9FMOVD_FCC: case SP_V9FMOVQ_FCC: case SP_V9FMOVS_FCC: if (MI->csh->detail) { // skip 'fmovd', 'fmovq', 'fmovs' MI->flat_insn->detail->sparc.cc = Sparc_map_FCC(instr + 5); MI->flat_insn->detail->sparc.hint = Sparc_map_hint(mnem); } break; case SP_V9MOVFCCri: case SP_V9MOVFCCrr: if (MI->csh->detail) { // skip 'mov' MI->flat_insn->detail->sparc.cc = Sparc_map_FCC(instr + 3); MI->flat_insn->detail->sparc.hint = Sparc_map_hint(mnem); } break; default: break; } cs_mem_free(mnem); } else { if (!printSparcAliasInstr(MI, O)) printInstruction(MI, O, NULL); } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x48, %rsp movq %rsi, %r14 movq %rdi, %rbx callq 0xa5e6e testq %rax, %rax je 0xa54e1 movq %rax, %r15 movq %rax, %rdi callq 0x44080 movq %rsp, %r14 movq %r14, %rdi movq %r15, %rsi movq %rax, %rdx callq 0x44040 movq %r15, %rdi callq 0x44080 movb $0x0, (%rsp,%rax) pushq $0x2c popq %rsi movq %r14, %rdi callq 0x44090 testq %rax, %rax je 0xa5471 movb $0x0, (%rax) movq %rsp, %rdi callq 0xbad18 movq %rbx, %rdi movl %eax, %esi callq 0x4557d movq %rbx, %rdi callq 0x45580 leal -0x48(%rax), %ecx cmpl $0x24, %ecx jbe 0xa5584 leal -0x1c4(%rax), %ecx cmpl $0x18, %ecx jbe 0xa55c1 leal -0xb9(%rax), %ecx cmpl $0x1b, %ecx ja 0xa5771 movl $0xc000033, %edx # imm = 0xC000033 btl %ecx, %edx jae 0xa5771 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa57e5 leaq 0x5(%rsp), %rdi jmp 0xa579a movq %rbx, %rdi callq 0x45580 leal -0x1d2(%rax), %ecx cmpl $0x6, %ecx jae 0xa5621 movq 0x320(%rbx), %rax testb $0x10, 0x4(%rax) jne 0xa56f3 movq %rbx, %rdi callq 0x45595 cmpl $0x3, %eax jne 0xa56f3 movq %rbx, %rdi xorl %esi, %esi callq 0x45587 movq %rax, %rdi callq 0x455c2 testb %al, %al je 0xa56f3 movq %rbx, %rdi xorl %esi, %esi callq 0x45587 movq %rax, %rdi callq 0x455da cmpl $0x43, %eax jne 0xa56f3 movq %rbx, %rdi callq 0x45580 addl $0xfffffe2e, %eax # imm = 0xFFFFFE2E cmpl $0x4, %eax ja 0xa5ce6 movl %eax, %eax leaq 0xa48f6(%rip), %rcx # 0x149e64 movslq (%rcx,%rax,4), %rsi addq %rcx, %rsi leaq 0xa48fc(%rip), %rcx # 0x149e78 movl (%rcx,%rax,4), %ebp jmp 0xa5cf0 movabsq $0x1800180003, %rdx # imm = 0x1800180003 btq %rcx, %rdx jb 0xa5603 movl $0x180, %edx # imm = 0x180 btq %rcx, %rdx jae 0xa5497 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa57e5 leaq 0x2(%rsp), %rdi jmp 0xa57b6 movl $0x700000, %edx # imm = 0x700000 btl %ecx, %edx jb 0xa57a1 pushq $0x3 popq %rdx btl %ecx, %edx jb 0xa5603 movl $0x1800000, %edx # imm = 0x1800000 btl %ecx, %edx jae 0xa54a6 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa57e5 leaq 0x3(%rsp), %rdi jmp 0xa57b6 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa57e5 leaq 0x1(%rsp), %rdi jmp 0xa579a addl $0xfffffed5, %eax # imm = 0xFFFFFED5 cmpl $0x1, %eax ja 0xa56f3 movq %rbx, %rdi callq 0x45595 cmpl $0x3, %eax jne 0xa56f3 movq %rbx, %rdi xorl %esi, %esi callq 0x45587 movq %rax, %rdi callq 0x455c2 testb %al, %al je 0xa56f3 movq %rbx, %rdi xorl %esi, %esi callq 0x45587 movq %rax, %rdi callq 0x455da cmpl $0x66, %eax je 0xa5d24 cmpl $0x47, %eax jne 0xa56f3 pushq $0x2 popq %rsi movq %rbx, %rdi callq 0x45587 movq %rax, %rdi callq 0x455ca testb %al, %al je 0xa5d37 pushq $0x2 popq %rsi movq %rbx, %rdi callq 0x45587 movq %rax, %rdi callq 0x455e2 cmpq $0x8, %rax jne 0xa5d37 pushq $0x1 popq %rsi movq %rbx, %rdi callq 0x45587 movq %rax, %rdi callq 0x455da cmpl $0x66, %eax je 0xa5e48 cmpl $0x56, %eax jne 0xa5d37 leaq 0xa966d(%rip), %rsi # 0x14ed4b movq %r14, %rdi callq 0x4565f movq %rbx, %rdi movl $0x115, %esi # imm = 0x115 jmp 0xa5e5f movq %rbx, %rdi callq 0x45580 movl %eax, %eax leaq 0xa3fac(%rip), %rcx # 0x1496b0 movl (%rcx,%rax,4), %r15d movl %r15d, %eax andl $0xfff, %eax # imm = 0xFFF leaq 0x1dcec9(%rip), %rcx # 0x2825e0 leaq (%rax,%rcx), %rsi decq %rsi movq %r14, %rdi callq 0x4565f movl %r15d, %eax shrl $0xc, %eax andl $0xf, %eax decl %eax cmpl $0xa, %eax ja 0xa57f1 leaq 0xa3c2f(%rip), %rcx # 0x149370 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 movl %r15d, %eax shrl $0x10, %eax andl $0xf, %eax leaq 0xa3c34(%rip), %rcx # 0x14939c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax addl $0xfffffeb8, %eax # imm = 0xFFFFFEB8 cmpl $0x12, %eax ja 0xa57e5 movl $0x60003, %ecx # imm = 0x60003 btl %eax, %ecx jae 0xa57e5 movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa57e5 leaq 0x3(%rsp), %rdi callq 0xbad37 jmp 0xa57bb movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa57e5 leaq 0x5(%rsp), %rdi callq 0xbad54 movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movl %eax, 0x30(%rcx) movq %r15, %rdi callq 0xbad71 movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movl %eax, 0x34(%rcx) leaq 0xff8dc(%rip), %rax # 0x1a50c8 movq %r15, %rdi callq (%rax) addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xbaa61 movl %r15d, %eax shrl $0x10, %eax andl $0xf, %eax leaq 0xa3b82(%rip), %rcx # 0x14939c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx xorl %ecx, %ecx callq 0xba92c movl %r15d, %eax shrl $0x10, %eax andl $0xf, %eax leaq 0xa3b59(%rip), %rcx # 0x14939c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax movq %rbx, %rdi xorl %esi, %esi movq %r14, %rdx callq 0xba750 movl %r15d, %eax shrl $0x10, %eax andl $0xf, %eax leaq 0xa3b33(%rip), %rcx # 0x14939c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0xa5f0c(%rip), %rcx # 0x14b785 pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba92c jmp 0xa5be4 pushq $0x2 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 leaq 0x377a4(%rip), %rsi # 0xdd045 movq %r14, %rdi callq 0x4565f movq %rbx, %rdi xorl %esi, %esi movq %r14, %rdx xorl %ecx, %ecx callq 0xba92c leaq 0x3837f(%rip), %rsi # 0xddc3e movq %r14, %rdi addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x4565f movq %rbx, %rdi xorl %esi, %esi jmp 0xa5d57 pushq $0x3 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xbaa61 movl %r15d, %eax shrl $0x10, %eax andl $0xf, %eax leaq 0xa3aa3(%rip), %rcx # 0x14939c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax pushq $0x4 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xbaa61 leaq 0x3ceff(%rip), %rsi # 0xe2816 movq %r14, %rdi callq 0x4565f pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 leaq 0x2e992(%rip), %r15 # 0xd42c6 movq %r14, %rdi movq %r15, %rsi callq 0x4565f pushq $0x2 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 movq %r14, %rdi movq %r15, %rsi jmp 0xa5bee pushq $0x2 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xbaa61 movl %r15d, %eax shrl $0x10, %eax andl $0xf, %eax leaq 0xa3a26(%rip), %rcx # 0x14939c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0x2e940(%rip), %rsi # 0xd42c6 movq %r14, %rdi callq 0x4565f movl %r15d, %eax shrl $0x14, %eax andl $0x3, %eax xorl %esi, %esi leaq 0xa3a3c(%rip), %rcx # 0x1493dc movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0x2e932(%rip), %rsi # 0xd42e2 movq %r14, %rdi callq 0x4565f movl %r15d, %eax shrl $0x14, %eax andl $0x3, %eax xorl %esi, %esi leaq 0xa3a12(%rip), %rcx # 0x1493dc movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0xa5dd3(%rip), %rsi # 0x14b7ad movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5c2c movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x1, 0x34(%rax) jmp 0xa5c2c leaq 0xa5d78(%rip), %rsi # 0x14b78f movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5bd6 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x5, 0x34(%rax) jmp 0xa5bd6 leaq 0xa5d63(%rip), %rsi # 0x14b7b7 movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5c2c movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x5, 0x34(%rax) jmp 0xa5c2c leaq 0xa5d11(%rip), %rsi # 0x14b7a2 movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5cd1 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x4, 0x34(%rax) jmp 0xa5cd1 leaq 0x3cd48(%rip), %rsi # 0xe2816 movq %r14, %rdi callq 0x4565f movl %r15d, %eax shrl $0x14, %eax andl $0x3, %eax xorl %esi, %esi leaq 0xa38f4(%rip), %rcx # 0x1493dc movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0xa5ccc(%rip), %rsi # 0x14b7c4 movq %r14, %rdi callq 0x4565f pushq $0x31 popq %rsi movq %rbx, %rdi callq 0xbab2e pushq $0x1 jmp 0xa5bd8 leaq 0xa5c72(%rip), %rsi # 0x14b78b movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5d6b movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x1, 0x34(%rax) movl %r15d, %eax shrl $0x14, %eax andl $0x3, %eax xorl %esi, %esi leaq 0xa3880(%rip), %rcx # 0x1493dc movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0xa5c2a(%rip), %rsi # 0x14b796 movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5cd1 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x1, 0x34(%rax) jmp 0xa5cd1 leaq 0xa5be8(%rip), %rsi # 0x14b791 movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5bd6 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x4, 0x34(%rax) pushq $0x2 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 leaq 0x2e6db(%rip), %rsi # 0xd42c6 movq %r14, %rdi callq 0x4565f jmp 0xa5cdc leaq 0xa5bba(%rip), %rsi # 0x14b7b9 movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5c2c movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x4, 0x34(%rax) pushq $0x57 jmp 0xa5cd3 leaq 0xa5b5e(%rip), %rsi # 0x14b798 movq %r14, %rdi callq 0x4565f pushq $0x45 popq %rsi movq %rbx, %rdi callq 0xbab2e movl %r15d, %eax shrl $0x14, %eax andl $0x3, %eax xorl %esi, %esi leaq 0xa377d(%rip), %rcx # 0x1493dc movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0xa5b40(%rip), %rsi # 0x14b7af movq %r14, %rdi callq 0x4565f pushq $0x57 popq %rsi movq %rbx, %rdi callq 0xbab2e movl %r15d, %eax shrl $0x14, %eax andl $0x3, %eax xorl %esi, %esi leaq 0xa3748(%rip), %rcx # 0x1493dc movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0xa5afc(%rip), %rsi # 0x14b7a0 movq %r14, %rdi callq 0x4565f movq 0x320(%rbx), %rax cmpl $0x0, 0xe0(%rax) je 0xa5cd1 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movl $0x5, 0x34(%rax) pushq $0x45 popq %rsi movq %rbx, %rdi callq 0xbab2e movq %rbx, %rdi xorl %esi, %esi jmp 0xa5e12 pushq $0x46 popq %rbp leaq 0xa5a68(%rip), %rsi # 0x14b758 movq %r14, %rdi callq 0x4565f movq %rbx, %rdi movl %ebp, %esi callq 0x4557d pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 leaq 0x2e5af(%rip), %rsi # 0xd42c6 movq %r14, %rdi callq 0x4565f jmp 0xa5df9 leaq 0xa5a27(%rip), %rsi # 0x14b752 movq %r14, %rdi callq 0x4565f pushq $0x1b jmp 0xa5d48 leaq 0xa5a0f(%rip), %rsi # 0x14b74d movq %r14, %rdi callq 0x4565f pushq $0x11 popq %rsi movq %rbx, %rdi callq 0x4557d pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx xorl %ecx, %ecx addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0xba92c movl %r15d, %eax shrl $0x14, %eax andl $0x3, %eax xorl %esi, %esi leaq 0xa365f(%rip), %rcx # 0x1493dc movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax pushq $0x2 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 leaq 0x2e52b(%rip), %rsi # 0xd42c6 movq %r14, %rdi callq 0x4565f xorl %esi, %esi jmp 0xa5daa pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xba750 movl %r15d, %eax shrl $0x16, %eax andl $0x3, %eax leaq 0xa3627(%rip), %rcx # 0x1493ec movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax leaq 0x2e4f1(%rip), %rsi # 0xd42c6 movq %r14, %rdi callq 0x4565f shrl $0x18, %r15d andl $0x3, %r15d cmpl $0x1, %r15d je 0xa5cdc cmpl $0x2, %r15d jne 0xa5df9 pushq $0x3 jmp 0xa5e0e pushq $0x2 jmp 0xa5e0e leaq 0xa03e6(%rip), %rsi # 0x1461ea movq %r14, %rdi callq 0x4565f pushq $0x1 popq %rsi movq %rbx, %rdi movq %r14, %rdx addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0xba750 leaq 0xa59a2(%rip), %rsi # 0x14b7cd movq %r14, %rdi callq 0x4565f pushq $0x56 popq %rsi movq %rbx, %rdi addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0xbab2e leaq 0xa522a(%rip), %rsi # 0x14b079 movq %r14, %rdi callq 0x4565f movq %rbx, %rdi movl $0x116, %esi # imm = 0x116 addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x4557d	/radare[P]capstone/arch/Sparc/SparcInstPrinter.c
printOperand	static void printOperand(MCInst MI, int opNum, SStream O) { int Imm; unsigned reg; MCOperand MO = MCInst_getOperand(MI, opNum); if (MCOperand_isReg(MO)) { reg = MCOperand_getReg(MO); printRegName(O, reg); reg = Sparc_map_register(reg); if (MI->csh->detail) { if (MI->csh->doing_mem) { if (MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.base) MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.index = reg; else MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.base = reg; } else { MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].type = SPARC_OP_REG; MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].reg = reg; MI->flat_insn->detail->sparc.op_count++; } } return; } if (MCOperand_isImm(MO)) { Imm = (int)MCOperand_getImm(MO); // get absolute address for CALL/Bxx if (MI->Opcode == SP_CALL) Imm += (uint32_t)MI->address; else if (MI->flat_insn->id == SPARC_INS_B) // pc + (disp30 4) Imm = (uint32_t)MI->address + Imm * 4; if (Imm >= 0) { if (Imm > HEX_THRESHOLD) SStream_concat(O, "0x%x", Imm); else SStream_concat(O, "%u", Imm); } else { if (Imm < -HEX_THRESHOLD) SStream_concat(O, "-0x%x", -Imm); else SStream_concat(O, "-%u", -Imm); } if (MI->csh->detail) { if (MI->csh->doing_mem) { MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.disp = Imm; } else { MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].type = SPARC_OP_IMM; MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].imm = Imm; MI->flat_insn->detail->sparc.op_count++; } } } return; }	pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r14 movq %rdi, %rbx callq 0x45587 movq %rax, %r15 movq %rax, %rdi callq 0x455c2 testb %al, %al je 0xba804 movq %r15, %rdi callq 0x455da movl %eax, %r15d leaq 0x90fc6(%rip), %rsi # 0x14b74b movq %r14, %rdi callq 0x4565f leal -0x1(%r15), %eax leaq 0x8ed38(%rip), %rcx # 0x1494d0 movl (%rcx,%rax,4), %eax leaq 0x1c7d0e(%rip), %rsi # 0x2824b0 addq %rax, %rsi movq %r14, %rdi callq 0x4565f movl %r15d, %edi callq 0xbad04 movq 0x320(%rbx), %rdx cmpl $0x0, 0xe0(%rdx) je 0xba926 movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x38(%rcx), %esi addq $0x3c, %rcx cmpb $0x1, 0xe8(%rdx) jne 0xba850 imulq $0xc, %rsi, %rdx addq %rdx, %rcx addq $0x4, %rcx cmpb $0x0, (%rcx) je 0xba89d movb %al, 0x1(%rcx) jmp 0xba926 movq %r15, %rdi callq 0x455ca testb %al, %al je 0xba926 movq %r15, %rdi callq 0x455e2 movq %rax, %r15 cmpl $0x72, 0x8(%rbx) je 0xba835 movq 0x310(%rbx), %rax cmpl $0x10, (%rax) jne 0xba83c shll $0x2, %r15d addl 0x318(%rbx), %r15d testl %r15d, %r15d js 0xba87a cmpl $0xa, %r15d jb 0xba88e leaq 0x2bcd7(%rip), %rsi # 0xe6525 jmp 0xba895 imulq $0xc, %rsi, %rdx movl $0x1, (%rcx,%rdx) movq 0x310(%rbx), %rcx movq 0xe8(%rcx), %rcx movzbl 0x38(%rcx), %edx imulq $0xc, %rdx, %rdx movl %eax, 0x40(%rcx,%rdx) jmp 0xba915 movl %r15d, %edx negl %edx cmpl $-0xa, %r15d ja 0xba8a4 leaq 0x19b1f(%rip), %rsi # 0xd43ab jmp 0xba8ab leaq 0x10691(%rip), %rsi # 0xcaf26 movq %r14, %rdi movl %r15d, %edx jmp 0xba8ae movb %al, (%rcx) jmp 0xba926 leaq 0x19b09(%rip), %rsi # 0xd43b4 movq %r14, %rdi xorl %eax, %eax callq 0x456a6 movq 0x320(%rbx), %rcx cmpl $0x0, 0xe0(%rcx) je 0xba926 movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x38(%rax), %edx addq $0x3c, %rax cmpb $0x1, 0xe8(%rcx) jne 0xba8ef imulq $0xc, %rdx, %rcx movl %r15d, 0x8(%rax,%rcx) jmp 0xba926 imulq $0xc, %rdx, %rcx movl $0x2, (%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax movzbl 0x38(%rax), %ecx imulq $0xc, %rcx, %rcx movl %r15d, 0x40(%rax,%rcx) movq 0x310(%rbx), %rax movq 0xe8(%rax), %rax incb 0x38(%rax) popq %rbx popq %r14 popq %r15 retq	/radare[P]capstone/arch/Sparc/SparcInstPrinter.c
Decode2RUSBitpInstruction	static DecodeStatus Decode2RUSBitpInstruction(MCInst Inst, unsigned Insn, uint64_t Address, void Decoder) { unsigned Op1, Op2, Op3; DecodeStatus S = Decode3OpInstruction(Insn, &Op1, &Op2, &Op3); if (S == MCDisassembler_Success) { DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder); DecodeGRRegsRegisterClass(Inst, Op2, Address, Decoder); DecodeBitpOperand(Inst, Op3, Address, Decoder); } return S; }	pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %r14 movl %esi, %eax movq %rdi, %rbx leaq 0xc(%rsp), %rsi leaq 0x8(%rsp), %rdx leaq 0x4(%rsp), %rcx movl %eax, %edi callq 0xbf8de movl %eax, %ebp cmpl $0x3, %eax jne 0xbf1ea movl 0xc(%rsp), %esi movq %rbx, %rdi movq %r14, %rdx callq 0xbeda6 movl 0x8(%rsp), %esi movq %rbx, %rdi movq %r14, %rdx callq 0xbeda6 movl 0x4(%rsp), %esi movq %rbx, %rdi callq 0xbf947 movl %ebp, %eax addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq	/radare[P]capstone/arch/XCore/XCoreDisassembler.c
mbedtls_md_info_from_string	const mbedtls_md_info_t mbedtls_md_info_from_string( const char md_name ) { if( NULL == md_name ) return( NULL ); /* Get the appropriate digest information */ #if defined(MBEDTLS_MD2_C) if( !strcmp( "MD2", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_MD2 ); #endif #if defined(MBEDTLS_MD4_C) if( !strcmp( "MD4", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_MD4 ); #endif #if defined(MBEDTLS_MD5_C) if( !strcmp( "MD5", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_MD5 ); #endif #if defined(MBEDTLS_RIPEMD160_C) if( !strcmp( "RIPEMD160", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_RIPEMD160 ); #endif #if defined(MBEDTLS_SHA1_C) if( !strcmp( "SHA1", md_name ) \|\| !strcmp( "SHA", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ); #endif #if defined(MBEDTLS_SHA256_C) if( !strcmp( "SHA224", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_SHA224 ); if( !strcmp( "SHA256", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 ); #endif #if defined(MBEDTLS_SHA512_C) if( !strcmp( "SHA384", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_SHA384 ); if( !strcmp( "SHA512", md_name ) ) return mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 ); #endif return( NULL ); }	pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0xa540 movq %rdi, %rbx leaq 0x22d05(%rip), %rdi # 0x2d19c movq %rbx, %rsi callq 0xa0f0 testl %eax, %eax je 0xa545 leaq 0x1fd12(%rip), %rdi # 0x2a1c0 movq %rbx, %rsi callq 0xa0f0 testl %eax, %eax je 0xa54e leaq 0x22dff(%rip), %rdi # 0x2d2c4 movq %rbx, %rsi callq 0xa0f0 leaq 0x2f8e4(%rip), %r14 # 0x39db8 testl %eax, %eax je 0xa555 leaq 0x1fceb(%rip), %rdi # 0x2a1ca movq %rbx, %rsi callq 0xa0f0 testl %eax, %eax je 0xa555 leaq 0x22dfd(%rip), %rdi # 0x2d2ef movq %rbx, %rsi callq 0xa0f0 testl %eax, %eax je 0xa560 leaq 0x22e17(%rip), %rdi # 0x2d31c movq %rbx, %rsi callq 0xa0f0 testl %eax, %eax je 0xa569 leaq 0x22e31(%rip), %rdi # 0x2d349 movq %rbx, %rsi callq 0xa0f0 testl %eax, %eax je 0xa572 leaq 0x22e4b(%rip), %rdi # 0x2d376 movq %rbx, %rsi callq 0xa0f0 testl %eax, %eax jne 0xa540 leaq 0x2f9da(%rip), %r14 # 0x39f18 jmp 0xa555 xorl %r14d, %r14d jmp 0xa555 leaq 0x2f7bc(%rip), %r14 # 0x39d08 jmp 0xa555 leaq 0x2f80b(%rip), %r14 # 0x39d60 movq %r14, %rax addq $0x8, %rsp popq %rbx popq %r14 retq leaq 0x2f8a9(%rip), %r14 # 0x39e10 jmp 0xa555 leaq 0x2f8f8(%rip), %r14 # 0x39e68 jmp 0xa555 leaq 0x2f947(%rip), %r14 # 0x39ec0 jmp 0xa555	/Dragonchang[P]https_client/mbedtls/library/md.c
mbedtls_pk_load_file	int mbedtls_pk_load_file( const char path, unsigned char buf, size_t n ) { FILE f; long size; if( ( f = fopen( path, "rb" ) ) == NULL ) return( MBEDTLS_ERR_PK_FILE_IO_ERROR ); fseek( f, 0, SEEK_END ); if( ( size = ftell( f ) ) == -1 ) { fclose( f ); return( MBEDTLS_ERR_PK_FILE_IO_ERROR ); } fseek( f, 0, SEEK_SET ); n = (size_t) size; if( n + 1 == 0 \|\| ( buf = mbedtls_calloc( 1, n + 1 ) ) == NULL ) { fclose( f ); return( MBEDTLS_ERR_PK_ALLOC_FAILED ); } if( fread( buf, 1, n, f ) != n ) { fclose( f ); mbedtls_free( buf ); return( MBEDTLS_ERR_PK_FILE_IO_ERROR ); } fclose( f ); (buf)[n] = '\0'; if( strstr( (const char ) buf, "-----BEGIN " ) != NULL ) ++n; return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %r15 leaq 0x1e921(%rip), %rsi # 0x2a089 callq 0xa150 movl $0xffffc200, %ebx # imm = 0xFFFFC200 testq %rax, %rax je 0xb82e movq %rax, %r12 movq %rax, %rdi xorl %esi, %esi movl $0x2, %edx callq 0xa140 movq %r12, %rdi callq 0xa100 cmpq $-0x1, %rax je 0xb810 movq %rax, %r13 movq %r12, %rdi xorl %esi, %esi xorl %edx, %edx callq 0xa140 movq %r13, (%r14) movq %r13, %rsi incq %rsi movl $0x1, %edi callq 0xa0e0 movq %rax, (%r15) testq %rax, %rax je 0xb81a movl $0x1, %esi movq %rax, %rdi movq %r13, %rdx movq %r12, %rcx callq 0xa070 movq %rax, %r13 movq (%r14), %rbp movq %r12, %rdi callq 0xa080 movq (%r15), %rdi cmpq %rbp, %r13 jne 0xb829 movq (%r14), %rax movb $0x0, (%rdi,%rax) movq (%r15), %rdi leaq 0x1ea20(%rip), %rsi # 0x2a21f callq 0xa170 xorl %ebx, %ebx testq %rax, %rax je 0xb82e incq (%r14) jmp 0xb82e movq %r12, %rdi callq 0xa080 jmp 0xb82e movq %r12, %rdi callq 0xa080 movl $0xffffc080, %ebx # imm = 0xFFFFC080 jmp 0xb82e callq 0xa030 movl %ebx, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/pkparse.c
mbedtls_ripemd160_process	void mbedtls_ripemd160_process( mbedtls_ripemd160_context *ctx, const unsigned char data[64] ) { uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16]; GET_UINT32_LE( X[ 0], data, 0 ); GET_UINT32_LE( X[ 1], data, 4 ); GET_UINT32_LE( X[ 2], data, 8 ); GET_UINT32_LE( X[ 3], data, 12 ); GET_UINT32_LE( X[ 4], data, 16 ); GET_UINT32_LE( X[ 5], data, 20 ); GET_UINT32_LE( X[ 6], data, 24 ); GET_UINT32_LE( X[ 7], data, 28 ); GET_UINT32_LE( X[ 8], data, 32 ); GET_UINT32_LE( X[ 9], data, 36 ); GET_UINT32_LE( X[10], data, 40 ); GET_UINT32_LE( X[11], data, 44 ); GET_UINT32_LE( X[12], data, 48 ); GET_UINT32_LE( X[13], data, 52 ); GET_UINT32_LE( X[14], data, 56 ); GET_UINT32_LE( X[15], data, 60 ); A = Ap = ctx->state[0]; B = Bp = ctx->state[1]; C = Cp = ctx->state[2]; D = Dp = ctx->state[3]; E = Ep = ctx->state[4]; #define F1( x, y, z ) ( x ^ y ^ z ) #define F2( x, y, z ) ( ( x & y ) \| ( ~x & z ) ) #define F3( x, y, z ) ( ( x \| ~y ) ^ z ) #define F4( x, y, z ) ( ( x & z ) \| ( y & ~z ) ) #define F5( x, y, z ) ( x ^ ( y \| ~z ) ) #define S( x, n ) ( ( x << n ) \| ( x >> (32 - n) ) ) #define P( a, b, c, d, e, r, s, f, k ) \ a += f( b, c, d ) + X[r] + k; \ a = S( a, s ) + e; \ c = S( c, 10 ); #define P2( a, b, c, d, e, r, s, rp, sp ) \ P( a, b, c, d, e, r, s, F, K ); \ P( a ## p, b ## p, c ## p, d ## p, e ## p, rp, sp, Fp, Kp ); #define F F1 #define K 0x00000000 #define Fp F5 #define Kp 0x50A28BE6 P2( A, B, C, D, E, 0, 11, 5, 8 ); P2( E, A, B, C, D, 1, 14, 14, 9 ); P2( D, E, A, B, C, 2, 15, 7, 9 ); P2( C, D, E, A, B, 3, 12, 0, 11 ); P2( B, C, D, E, A, 4, 5, 9, 13 ); P2( A, B, C, D, E, 5, 8, 2, 15 ); P2( E, A, B, C, D, 6, 7, 11, 15 ); P2( D, E, A, B, C, 7, 9, 4, 5 ); P2( C, D, E, A, B, 8, 11, 13, 7 ); P2( B, C, D, E, A, 9, 13, 6, 7 ); P2( A, B, C, D, E, 10, 14, 15, 8 ); P2( E, A, B, C, D, 11, 15, 8, 11 ); P2( D, E, A, B, C, 12, 6, 1, 14 ); P2( C, D, E, A, B, 13, 7, 10, 14 ); P2( B, C, D, E, A, 14, 9, 3, 12 ); P2( A, B, C, D, E, 15, 8, 12, 6 ); #undef F #undef K #undef Fp #undef Kp #define F F2 #define K 0x5A827999 #define Fp F4 #define Kp 0x5C4DD124 P2( E, A, B, C, D, 7, 7, 6, 9 ); P2( D, E, A, B, C, 4, 6, 11, 13 ); P2( C, D, E, A, B, 13, 8, 3, 15 ); P2( B, C, D, E, A, 1, 13, 7, 7 ); P2( A, B, C, D, E, 10, 11, 0, 12 ); P2( E, A, B, C, D, 6, 9, 13, 8 ); P2( D, E, A, B, C, 15, 7, 5, 9 ); P2( C, D, E, A, B, 3, 15, 10, 11 ); P2( B, C, D, E, A, 12, 7, 14, 7 ); P2( A, B, C, D, E, 0, 12, 15, 7 ); P2( E, A, B, C, D, 9, 15, 8, 12 ); P2( D, E, A, B, C, 5, 9, 12, 7 ); P2( C, D, E, A, B, 2, 11, 4, 6 ); P2( B, C, D, E, A, 14, 7, 9, 15 ); P2( A, B, C, D, E, 11, 13, 1, 13 ); P2( E, A, B, C, D, 8, 12, 2, 11 ); #undef F #undef K #undef Fp #undef Kp #define F F3 #define K 0x6ED9EBA1 #define Fp F3 #define Kp 0x6D703EF3 P2( D, E, A, B, C, 3, 11, 15, 9 ); P2( C, D, E, A, B, 10, 13, 5, 7 ); P2( B, C, D, E, A, 14, 6, 1, 15 ); P2( A, B, C, D, E, 4, 7, 3, 11 ); P2( E, A, B, C, D, 9, 14, 7, 8 ); P2( D, E, A, B, C, 15, 9, 14, 6 ); P2( C, D, E, A, B, 8, 13, 6, 6 ); P2( B, C, D, E, A, 1, 15, 9, 14 ); P2( A, B, C, D, E, 2, 14, 11, 12 ); P2( E, A, B, C, D, 7, 8, 8, 13 ); P2( D, E, A, B, C, 0, 13, 12, 5 ); P2( C, D, E, A, B, 6, 6, 2, 14 ); P2( B, C, D, E, A, 13, 5, 10, 13 ); P2( A, B, C, D, E, 11, 12, 0, 13 ); P2( E, A, B, C, D, 5, 7, 4, 7 ); P2( D, E, A, B, C, 12, 5, 13, 5 ); #undef F #undef K #undef Fp #undef Kp #define F F4 #define K 0x8F1BBCDC #define Fp F2 #define Kp 0x7A6D76E9 P2( C, D, E, A, B, 1, 11, 8, 15 ); P2( B, C, D, E, A, 9, 12, 6, 5 ); P2( A, B, C, D, E, 11, 14, 4, 8 ); P2( E, A, B, C, D, 10, 15, 1, 11 ); P2( D, E, A, B, C, 0, 14, 3, 14 ); P2( C, D, E, A, B, 8, 15, 11, 14 ); P2( B, C, D, E, A, 12, 9, 15, 6 ); P2( A, B, C, D, E, 4, 8, 0, 14 ); P2( E, A, B, C, D, 13, 9, 5, 6 ); P2( D, E, A, B, C, 3, 14, 12, 9 ); P2( C, D, E, A, B, 7, 5, 2, 12 ); P2( B, C, D, E, A, 15, 6, 13, 9 ); P2( A, B, C, D, E, 14, 8, 9, 12 ); P2( E, A, B, C, D, 5, 6, 7, 5 ); P2( D, E, A, B, C, 6, 5, 10, 15 ); P2( C, D, E, A, B, 2, 12, 14, 8 ); #undef F #undef K #undef Fp #undef Kp #define F F5 #define K 0xA953FD4E #define Fp F1 #define Kp 0x00000000 P2( B, C, D, E, A, 4, 9, 12, 8 ); P2( A, B, C, D, E, 0, 15, 15, 5 ); P2( E, A, B, C, D, 5, 5, 10, 12 ); P2( D, E, A, B, C, 9, 11, 4, 9 ); P2( C, D, E, A, B, 7, 6, 1, 12 ); P2( B, C, D, E, A, 12, 8, 5, 5 ); P2( A, B, C, D, E, 2, 13, 8, 14 ); P2( E, A, B, C, D, 10, 12, 7, 6 ); P2( D, E, A, B, C, 14, 5, 6, 8 ); P2( C, D, E, A, B, 1, 12, 2, 13 ); P2( B, C, D, E, A, 3, 13, 13, 6 ); P2( A, B, C, D, E, 8, 14, 14, 5 ); P2( E, A, B, C, D, 11, 11, 0, 15 ); P2( D, E, A, B, C, 6, 8, 3, 13 ); P2( C, D, E, A, B, 15, 5, 9, 11 ); P2( B, C, D, E, A, 13, 6, 11, 11 ); #undef F #undef K #undef Fp #undef Kp C = ctx->state[1] + C + Dp; ctx->state[1] = ctx->state[2] + D + Ep; ctx->state[2] = ctx->state[3] + E + Ap; ctx->state[3] = ctx->state[4] + A + Bp; ctx->state[4] = ctx->state[0] + B + Cp; ctx->state[0] = C; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, (%rsp) movl (%rsi), %ebp movl 0x4(%rsi), %r12d movq %r12, -0x58(%rsp) movl 0x14(%rsi), %r11d movq %r11, -0x60(%rsp) movl 0x8(%rdi), %ecx movl 0xc(%rdi), %r10d movl 0x10(%rdi), %edx movl 0x14(%rdi), %r13d movl 0x18(%rdi), %r8d movl %edx, -0x1c(%rsp) movl %edx, %ebx xorl %r10d, %ebx xorl %r13d, %ebx movq %rcx, -0x8(%rsp) movq %rbp, -0x28(%rsp) addl %ecx, %ebx addl %ebp, %ebx roll $0xb, %ebx addl %r8d, %ebx movl %edx, %edi roll $0xa, %edi movl %r13d, %eax notl %eax orl %edx, %eax xorl %r10d, %eax leal (%r11,%rcx), %r14d movl $0x50a28be6, %ecx # imm = 0x50A28BE6 addl %ecx, %r14d movl $0x50a28be6, %edx # imm = 0x50A28BE6 addl %eax, %r14d movl %edi, %r11d xorl %r10d, %r11d xorl %ebx, %r11d addl %r8d, %r11d addl %r12d, %r11d roll $0x8, %r14d addl %r8d, %r14d movq %r8, -0x10(%rsp) movl %edi, %ecx notl %ecx movl %r10d, -0x20(%rsp) orl %r10d, %ecx xorl %r14d, %ecx movl 0x38(%rsi), %eax movq %rax, -0x38(%rsp) leal (%rax,%r8), %r15d addl %edx, %r15d addl %ecx, %r15d roll $0xe, %r11d addl %r13d, %r11d movl %r10d, %edx roll $0xa, %edx movl %ebx, %r12d xorl %edx, %r12d xorl %r11d, %r12d movl 0x8(%rsi), %eax movq %rax, -0x40(%rsp) addl %r13d, %r12d addl %eax, %r12d roll $0x9, %r15d roll $0xf, %r12d addl %r13d, %r15d movq %r13, -0x18(%rsp) movl %edx, %ecx notl %ecx orl %r14d, %ecx xorl %r15d, %ecx movl 0x1c(%rsi), %eax movq %rax, -0x30(%rsp) addl %eax, %r13d movl $0x50a28be6, %eax # imm = 0x50A28BE6 addl %eax, %r13d addl %ecx, %r13d addl %edi, %r12d roll $0xa, %ebx movl %r11d, %r9d xorl %ebx, %r9d xorl %r12d, %r9d movl 0xc(%rsi), %ecx movq %rcx, -0x48(%rsp) addl %edi, %ecx addl %ecx, %r9d roll $0x9, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r14d, %ecx notl %ecx orl %r15d, %ecx xorl %r13d, %ecx addl %ebp, %edi addl %eax, %edi movl $0x50a28be6, %ebp # imm = 0x50A28BE6 addl %ecx, %edi roll $0xc, %r9d addl %edx, %r9d roll $0xa, %r11d movl %r12d, %ecx xorl %r11d, %ecx xorl %r9d, %ecx movl 0x10(%rsi), %eax movq %rax, -0x50(%rsp) addl %edx, %ecx addl %eax, %ecx roll $0xb, %edi addl %edx, %edi roll $0xa, %r15d movl %r15d, %r8d notl %r8d orl %r13d, %r8d xorl %edi, %r8d movl 0x24(%rsi), %r10d movl %r10d, -0x78(%rsp) addl %r10d, %edx addl %ebp, %edx addl %r8d, %edx roll $0x5, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %r9d, %r8d xorl %r12d, %r8d xorl %ecx, %r8d addl -0x60(%rsp), %ebx addl %r8d, %ebx roll $0xd, %edx roll $0xa, %r13d addl %r14d, %edx movl %r13d, %r8d notl %r8d orl %edi, %r8d xorl %edx, %r8d addl -0x40(%rsp), %r14d addl %ebp, %r14d addl %r8d, %r14d roll $0x8, %ebx roll $0xa, %r9d addl %r11d, %ebx roll $0xf, %r14d movl %ecx, %r8d xorl %r9d, %r8d xorl %ebx, %r8d movl 0x18(%rsi), %r10d addl %r10d, %r11d movl %r10d, %ebp movl %r10d, -0x7c(%rsp) addl %r8d, %r11d addl %r15d, %r14d roll $0xa, %edi movl %edi, %r8d notl %r8d orl %edx, %r8d xorl %r14d, %r8d movl 0x2c(%rsi), %r10d movl %r10d, -0x6c(%rsp) addl %r10d, %r15d movl $0x50a28be6, %r10d # imm = 0x50A28BE6 addl %r10d, %r15d addl %r8d, %r15d roll $0x7, %r11d roll $0xa, %ecx addl %r12d, %r11d movl %ebx, %r8d xorl %ecx, %r8d xorl %r11d, %r8d addl -0x30(%rsp), %r12d addl %r8d, %r12d roll $0xf, %r15d addl %r13d, %r15d roll $0xa, %edx movl %edx, %r8d notl %r8d orl %r14d, %r8d xorl %r15d, %r8d addl %eax, %r13d addl %r10d, %r13d addl %r8d, %r13d roll $0x9, %r12d addl %r9d, %r12d roll $0xa, %ebx movl %r11d, %r8d xorl %ebx, %r8d xorl %r12d, %r8d movl 0x20(%rsi), %r10d addl %r10d, %r9d movl %r10d, %eax movl %r10d, -0x70(%rsp) addl %r8d, %r9d roll $0x5, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r14d, %r8d notl %r8d orl %r15d, %r8d xorl %r13d, %r8d movl 0x34(%rsi), %r10d movl %r10d, -0x64(%rsp) addl %r10d, %edi movl $0x50a28be6, %r10d # imm = 0x50A28BE6 addl %r10d, %edi addl %r8d, %edi roll $0xb, %r9d addl %ecx, %r9d roll $0xa, %r11d movl %r12d, %r8d xorl %r11d, %r8d xorl %r9d, %r8d addl -0x78(%rsp), %ecx addl %r8d, %ecx roll $0x7, %edi roll $0xa, %r15d addl %edx, %edi movl %r15d, %r8d notl %r8d orl %r13d, %r8d xorl %edi, %r8d addl %ebp, %edx addl %r10d, %edx addl %r8d, %edx roll $0xd, %ecx roll $0xa, %r12d addl %ebx, %ecx roll $0x7, %edx movl %r9d, %r8d xorl %r12d, %r8d xorl %ecx, %r8d movl 0x28(%rsi), %r10d addl %r10d, %ebx movl %r10d, %ebp movl %r10d, -0x74(%rsp) addl %r8d, %ebx addl %r14d, %edx roll $0xa, %r13d movl %r13d, %r8d notl %r8d orl %edi, %r8d xorl %edx, %r8d movl 0x3c(%rsi), %r10d movl %r10d, -0x80(%rsp) addl %r10d, %r14d movl $0x50a28be6, %r10d # imm = 0x50A28BE6 addl %r10d, %r14d addl %r8d, %r14d roll $0xe, %ebx roll $0xa, %r9d addl %r11d, %ebx movl %ecx, %r8d xorl %r9d, %r8d xorl %ebx, %r8d addl -0x6c(%rsp), %r11d addl %r8d, %r11d roll $0x8, %r14d addl %r15d, %r14d roll $0xa, %edi movl %edi, %r8d notl %r8d orl %edx, %r8d xorl %r14d, %r8d addl %eax, %r15d addl %r10d, %r15d movl $0x50a28be6, %eax # imm = 0x50A28BE6 addl %r8d, %r15d roll $0xf, %r11d movl 0x30(%rsi), %r8d addl %r12d, %r11d roll $0xa, %ecx movl %ebx, %esi xorl %ecx, %esi xorl %r11d, %esi addl %r8d, %r12d movl %r8d, -0x68(%rsp) addl %esi, %r12d roll $0xb, %r15d addl %r13d, %r15d roll $0xa, %edx movl %edx, %esi notl %esi orl %r14d, %esi xorl %r15d, %esi addl -0x58(%rsp), %r13d addl %eax, %r13d addl %esi, %r13d roll $0x6, %r12d addl %r9d, %r12d roll $0xa, %ebx roll $0xe, %r13d movl %r11d, %esi xorl %ebx, %esi xorl %r12d, %esi addl -0x64(%rsp), %r9d addl %esi, %r9d addl %edi, %r13d roll $0xa, %r14d roll $0x7, %r9d movl %r14d, %esi notl %esi orl %r15d, %esi xorl %r13d, %esi addl %ebp, %edi addl %eax, %edi addl %esi, %edi addl %ecx, %r9d roll $0xa, %r11d movl %r12d, %esi xorl %r11d, %esi xorl %r9d, %esi addl -0x38(%rsp), %ecx addl %esi, %ecx roll $0xe, %edi addl %edx, %edi roll $0xa, %r15d movl %r15d, %esi notl %esi orl %r13d, %esi xorl %edi, %esi movq -0x48(%rsp), %rbp addl %ebp, %edx addl %eax, %edx addl %esi, %edx roll $0x9, %ecx addl %ebx, %ecx roll $0xa, %r12d roll $0xc, %edx movl %r9d, %esi xorl %r12d, %esi xorl %ecx, %esi addl -0x80(%rsp), %ebx addl %esi, %ebx addl %r14d, %edx addl %r8d, %r14d addl %eax, %r14d roll $0xa, %r13d roll $0x8, %ebx movl %r13d, %esi notl %esi orl %edi, %esi xorl %edx, %esi addl %esi, %r14d addl %r11d, %ebx roll $0xa, %r9d movl %ecx, %esi xorl %r9d, %esi andl %ebx, %esi xorl %r9d, %esi movq -0x30(%rsp), %rax addl %eax, %r11d movl $0x5a827999, %r10d # imm = 0x5A827999 addl %r10d, %r11d addl %esi, %r11d roll $0x6, %r14d roll $0xa, %edi addl %r15d, %r14d movl %r14d, %r10d xorl %edx, %r10d andl %edi, %r10d xorl %edx, %r10d addl -0x7c(%rsp), %r15d movl $0x5c4dd124, %esi # imm = 0x5C4DD124 addl %esi, %r15d addl %r10d, %r15d roll $0x7, %r11d addl %r12d, %r11d roll $0xa, %ecx movl %ebx, %r10d xorl %ecx, %r10d andl %r11d, %r10d xorl %ecx, %r10d addl -0x50(%rsp), %r12d movl $0x5a827999, %r8d # imm = 0x5A827999 addl %r8d, %r12d addl %r10d, %r12d roll $0x9, %r15d addl %r13d, %r15d roll $0xa, %edx movl %r15d, %r10d xorl %r14d, %r10d andl %edx, %r10d xorl %r14d, %r10d addl -0x6c(%rsp), %r13d addl %esi, %r13d addl %r10d, %r13d roll $0x6, %r12d addl %r9d, %r12d roll $0xa, %ebx movl %r11d, %r10d xorl %ebx, %r10d andl %r12d, %r10d xorl %ebx, %r10d movl -0x64(%rsp), %esi addl %esi, %r9d addl %r8d, %r9d addl %r10d, %r9d roll $0xd, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r13d, %r10d xorl %r15d, %r10d andl %r14d, %r10d xorl %r15d, %r10d addl %ebp, %edi movl $0x5c4dd124, %ebp # imm = 0x5C4DD124 addl %ebp, %edi addl %r10d, %edi roll $0x8, %r9d addl %ecx, %r9d roll $0xa, %r11d movl %r12d, %r10d xorl %r11d, %r10d andl %r9d, %r10d xorl %r11d, %r10d addl -0x58(%rsp), %ecx addl %r8d, %ecx addl %r10d, %ecx roll $0xf, %edi addl %edx, %edi roll $0xa, %r15d movl %edi, %r10d xorl %r13d, %r10d andl %r15d, %r10d xorl %r13d, %r10d addl %eax, %edx addl %ebp, %edx addl %r10d, %edx roll $0xd, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %r9d, %r10d xorl %r12d, %r10d andl %ecx, %r10d xorl %r12d, %r10d movl -0x74(%rsp), %eax addl %eax, %ebx addl %r8d, %ebx addl %r10d, %ebx roll $0x7, %edx addl %r14d, %edx roll $0xa, %r13d movl %edx, %r10d xorl %edi, %r10d andl %r13d, %r10d xorl %edi, %r10d movq -0x28(%rsp), %r8 addl %r8d, %r14d addl %ebp, %r14d addl %r10d, %r14d roll $0xb, %ebx addl %r11d, %ebx roll $0xa, %r9d movl %ecx, %r10d xorl %r9d, %r10d andl %ebx, %r10d xorl %r9d, %r10d addl -0x7c(%rsp), %r11d movl $0x5a827999, %ebp # imm = 0x5A827999 addl %ebp, %r11d addl %r10d, %r11d roll $0xc, %r14d addl %r15d, %r14d roll $0xa, %edi movl %r14d, %r10d xorl %edx, %r10d andl %edi, %r10d xorl %edx, %r10d addl %esi, %r15d movl $0x5c4dd124, %esi # imm = 0x5C4DD124 addl %esi, %r15d addl %r10d, %r15d roll $0x9, %r11d addl %r12d, %r11d roll $0xa, %ecx movl %ebx, %r10d xorl %ecx, %r10d andl %r11d, %r10d xorl %ecx, %r10d movl -0x80(%rsp), %ebp addl %ebp, %r12d movl $0x5a827999, %esi # imm = 0x5A827999 addl %esi, %r12d addl %r10d, %r12d roll $0x8, %r15d addl %r13d, %r15d roll $0xa, %edx movl %r15d, %r10d xorl %r14d, %r10d andl %edx, %r10d xorl %r14d, %r10d addl -0x60(%rsp), %r13d movl $0x5c4dd124, %esi # imm = 0x5C4DD124 addl %esi, %r13d addl %r10d, %r13d roll $0x7, %r12d addl %r9d, %r12d roll $0xa, %ebx movl %r11d, %r10d xorl %ebx, %r10d andl %r12d, %r10d xorl %ebx, %r10d addl -0x48(%rsp), %r9d movl $0x5a827999, %esi # imm = 0x5A827999 addl %esi, %r9d addl %r10d, %r9d roll $0x9, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r13d, %r10d xorl %r15d, %r10d andl %r14d, %r10d xorl %r15d, %r10d addl %eax, %edi movl $0x5c4dd124, %eax # imm = 0x5C4DD124 addl %eax, %edi addl %r10d, %edi roll $0xf, %r9d addl %ecx, %r9d roll $0xa, %r11d movl %r12d, %r10d xorl %r11d, %r10d andl %r9d, %r10d xorl %r11d, %r10d movl -0x68(%rsp), %eax addl %eax, %ecx addl %esi, %ecx addl %r10d, %ecx roll $0xb, %edi addl %edx, %edi roll $0xa, %r15d movl %edi, %r10d xorl %r13d, %r10d andl %r15d, %r10d xorl %r13d, %r10d addl -0x38(%rsp), %edx movl $0x5c4dd124, %esi # imm = 0x5C4DD124 addl %esi, %edx addl %r10d, %edx roll $0x7, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %r9d, %r10d xorl %r12d, %r10d andl %ecx, %r10d xorl %r12d, %r10d addl %r8d, %ebx movl $0x5a827999, %esi # imm = 0x5A827999 addl %esi, %ebx movl $0x5a827999, %r8d # imm = 0x5A827999 addl %r10d, %ebx roll $0x7, %edx addl %r14d, %edx roll $0xa, %r13d movl %edx, %r10d xorl %edi, %r10d andl %r13d, %r10d xorl %edi, %r10d addl %ebp, %r14d movl $0x5c4dd124, %esi # imm = 0x5C4DD124 addl %esi, %r14d addl %r10d, %r14d roll $0xc, %ebx addl %r11d, %ebx roll $0xa, %r9d movl %ecx, %r10d xorl %r9d, %r10d andl %ebx, %r10d xorl %r9d, %r10d movl -0x78(%rsp), %ebp addl %ebp, %r11d addl %r8d, %r11d addl %r10d, %r11d roll $0x7, %r14d addl %r15d, %r14d roll $0xa, %edi movl %r14d, %r10d xorl %edx, %r10d andl %edi, %r10d xorl %edx, %r10d movl -0x70(%rsp), %r8d addl %r8d, %r15d addl %esi, %r15d addl %r10d, %r15d roll $0xf, %r11d addl %r12d, %r11d roll $0xa, %ecx movl %ebx, %r10d xorl %ecx, %r10d andl %r11d, %r10d xorl %ecx, %r10d addl -0x60(%rsp), %r12d movl $0x5a827999, %esi # imm = 0x5A827999 addl %esi, %r12d addl %r10d, %r12d roll $0xc, %r15d addl %r13d, %r15d roll $0xa, %edx movl %r15d, %r10d xorl %r14d, %r10d andl %edx, %r10d xorl %r14d, %r10d addl %eax, %r13d movl $0x5c4dd124, %eax # imm = 0x5C4DD124 addl %eax, %r13d addl %r10d, %r13d roll $0x9, %r12d addl %r9d, %r12d roll $0xa, %ebx movl %r11d, %r10d xorl %ebx, %r10d andl %r12d, %r10d xorl %ebx, %r10d movq -0x40(%rsp), %rsi addl %esi, %r9d movl $0x5a827999, %eax # imm = 0x5A827999 addl %eax, %r9d addl %r10d, %r9d roll $0x7, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r13d, %r10d xorl %r15d, %r10d andl %r14d, %r10d xorl %r15d, %r10d addl -0x50(%rsp), %edi movl $0x5c4dd124, %eax # imm = 0x5C4DD124 addl %eax, %edi addl %r10d, %edi roll $0xb, %r9d addl %ecx, %r9d roll $0xa, %r11d movl %r12d, %r10d xorl %r11d, %r10d andl %r9d, %r10d xorl %r11d, %r10d addl -0x38(%rsp), %ecx movl $0x5a827999, %eax # imm = 0x5A827999 addl %eax, %ecx addl %r10d, %ecx roll $0x6, %edi addl %edx, %edi roll $0xa, %r15d movl %edi, %r10d xorl %r13d, %r10d andl %r15d, %r10d xorl %r13d, %r10d addl %ebp, %edx movl $0x5c4dd124, %eax # imm = 0x5C4DD124 addl %eax, %edx movl $0x5c4dd124, %ebp # imm = 0x5C4DD124 addl %r10d, %edx roll $0x7, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %r9d, %r10d xorl %r12d, %r10d andl %ecx, %r10d xorl %r12d, %r10d addl -0x6c(%rsp), %ebx movl $0x5a827999, %eax # imm = 0x5A827999 addl %eax, %ebx addl %r10d, %ebx roll $0xf, %edx addl %r14d, %edx movq %rdx, %rax roll $0xa, %r13d movl %eax, %r10d xorl %edi, %r10d andl %r13d, %r10d xorl %edi, %r10d addl -0x58(%rsp), %r14d addl %ebp, %r14d addl %r10d, %r14d roll $0xd, %ebx addl %r11d, %ebx roll $0xa, %r9d movl %ebx, %edx andl %ecx, %edx movl %ebx, %r10d notl %r10d movl %r9d, %ebp andl %r10d, %ebp orl %edx, %ebp addl %r8d, %r11d movl $0x5a827999, %edx # imm = 0x5A827999 addl %edx, %r11d addl %ebp, %r11d roll $0xd, %r14d addl %r15d, %r14d addl %esi, %r15d movl $0x5c4dd124, %edx # imm = 0x5C4DD124 addl %edx, %r15d roll $0xa, %edi movl %r14d, %edx xorl %eax, %edx andl %edi, %edx xorl %eax, %edx addl %edx, %r15d roll $0xc, %r11d roll $0xa, %ecx addl %r12d, %r11d roll $0xb, %r15d orl %r11d, %r10d xorl %ecx, %r10d movq -0x48(%rsp), %rbp addl %ebp, %r12d movl $0x6ed9eba1, %edx # imm = 0x6ED9EBA1 addl %edx, %r12d addl %r10d, %r12d addl %r13d, %r15d roll $0xa, %eax movl %r14d, %edx notl %edx orl %r15d, %edx xorl %eax, %edx addl -0x80(%rsp), %r13d movl $0x6d703ef3, %r8d # imm = 0x6D703EF3 addl %r8d, %r13d addl %edx, %r13d roll $0xb, %r12d roll $0xa, %ebx addl %r9d, %r12d movl %r11d, %edx notl %edx orl %r12d, %edx xorl %ebx, %edx addl -0x74(%rsp), %r9d movl $0x6ed9eba1, %r10d # imm = 0x6ED9EBA1 addl %r10d, %r9d addl %edx, %r9d roll $0x9, %r13d roll $0xa, %r14d addl %edi, %r13d movl %r15d, %edx notl %edx orl %r13d, %edx xorl %r14d, %edx addl -0x60(%rsp), %edi addl %r8d, %edi addl %edx, %edi roll $0xd, %r9d roll $0xa, %r11d addl %ecx, %r9d movl %r12d, %edx notl %edx orl %r9d, %edx xorl %r11d, %edx movq -0x38(%rsp), %r8 addl %r8d, %ecx addl %r10d, %ecx addl %edx, %ecx roll $0x7, %edi roll $0xa, %r15d addl %eax, %edi movl %r13d, %edx notl %edx orl %edi, %edx xorl %r15d, %edx movq -0x58(%rsp), %r10 addl %r10d, %eax movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %eax addl %edx, %eax roll $0x6, %ecx roll $0xa, %r12d addl %ebx, %ecx movl %r9d, %edx notl %edx orl %ecx, %edx xorl %r12d, %edx addl -0x50(%rsp), %ebx movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1 addl %esi, %ebx addl %edx, %ebx roll $0xf, %eax roll $0xa, %r13d addl %r14d, %eax movl %edi, %edx notl %edx orl %eax, %edx xorl %r13d, %edx addl %ebp, %r14d movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %r14d addl %edx, %r14d roll $0x7, %ebx roll $0xa, %r9d addl %r11d, %ebx movl %ecx, %edx notl %edx orl %ebx, %edx xorl %r9d, %edx movl -0x78(%rsp), %ebp addl %ebp, %r11d movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1 addl %esi, %r11d addl %edx, %r11d roll $0xb, %r14d roll $0xa, %edi addl %r15d, %r14d movl %eax, %edx notl %edx orl %r14d, %edx xorl %edi, %edx addl -0x30(%rsp), %r15d movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %r15d addl %edx, %r15d roll $0xe, %r11d roll $0xa, %ecx addl %r12d, %r11d movl %ebx, %edx notl %edx orl %r11d, %edx xorl %ecx, %edx addl -0x80(%rsp), %r12d movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1 addl %esi, %r12d addl %edx, %r12d roll $0x8, %r15d roll $0xa, %eax addl %r13d, %r15d movl %r14d, %edx notl %edx orl %r15d, %edx xorl %eax, %edx addl %r8d, %r13d movl $0x6d703ef3, %r8d # imm = 0x6D703EF3 addl %r8d, %r13d addl %edx, %r13d roll $0x9, %r12d roll $0xa, %ebx addl %r9d, %r12d movl %r11d, %edx notl %edx orl %r12d, %edx xorl %ebx, %edx movl -0x70(%rsp), %r8d addl %r8d, %r9d addl %esi, %r9d addl %edx, %r9d roll $0x6, %r13d roll $0xa, %r14d addl %edi, %r13d movl %r15d, %edx notl %edx orl %r13d, %edx xorl %r14d, %edx addl -0x7c(%rsp), %edi movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %edi addl %edx, %edi roll $0xd, %r9d roll $0xa, %r11d addl %ecx, %r9d movl %r12d, %edx notl %edx orl %r9d, %edx xorl %r11d, %edx addl %r10d, %ecx movl $0x6ed9eba1, %r10d # imm = 0x6ED9EBA1 addl %r10d, %ecx addl %edx, %ecx roll $0x6, %edi roll $0xa, %r15d addl %eax, %edi movl %r13d, %edx notl %edx orl %edi, %edx xorl %r15d, %edx addl %ebp, %eax addl %esi, %eax addl %edx, %eax roll $0xf, %ecx roll $0xa, %r12d addl %ebx, %ecx movl %r9d, %edx notl %edx orl %ecx, %edx xorl %r12d, %edx movq -0x40(%rsp), %rbp addl %ebp, %ebx addl %r10d, %ebx addl %edx, %ebx roll $0xe, %eax roll $0xa, %r13d addl %r14d, %eax movl %edi, %edx notl %edx orl %eax, %edx xorl %r13d, %edx movl -0x6c(%rsp), %r10d addl %r10d, %r14d addl %esi, %r14d addl %edx, %r14d roll $0xe, %ebx roll $0xa, %r9d addl %r11d, %ebx movl %ecx, %edx notl %edx orl %ebx, %edx xorl %r9d, %edx addl -0x30(%rsp), %r11d movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1 addl %esi, %r11d addl %edx, %r11d roll $0xc, %r14d roll $0xa, %edi addl %r15d, %r14d movl %eax, %edx notl %edx orl %r14d, %edx xorl %edi, %edx addl %r8d, %r15d movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %r15d addl %edx, %r15d roll $0x8, %r11d roll $0xa, %ecx addl %r12d, %r11d movl %ebx, %edx notl %edx orl %r11d, %edx xorl %ecx, %edx movq -0x28(%rsp), %r8 addl %r8d, %r12d movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1 addl %esi, %r12d addl %edx, %r12d roll $0xd, %r15d roll $0xa, %eax addl %r13d, %r15d movl %r14d, %edx notl %edx orl %r15d, %edx xorl %eax, %edx addl -0x68(%rsp), %r13d movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %r13d addl %edx, %r13d roll $0xd, %r12d roll $0xa, %ebx addl %r9d, %r12d movl %r11d, %edx notl %edx orl %r12d, %edx xorl %ebx, %edx addl -0x7c(%rsp), %r9d movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1 addl %esi, %r9d addl %edx, %r9d roll $0x5, %r13d roll $0xa, %r14d addl %edi, %r13d movl %r15d, %edx notl %edx orl %r13d, %edx xorl %r14d, %edx addl %ebp, %edi movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %edi addl %edx, %edi roll $0x6, %r9d roll $0xa, %r11d addl %ecx, %r9d movl %r12d, %edx notl %edx orl %r9d, %edx xorl %r11d, %edx movl -0x64(%rsp), %ebp addl %ebp, %ecx movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1 addl %esi, %ecx addl %edx, %ecx roll $0xe, %edi roll $0xa, %r15d addl %eax, %edi movl %r13d, %edx notl %edx orl %edi, %edx xorl %r15d, %edx addl -0x74(%rsp), %eax movl $0x6d703ef3, %esi # imm = 0x6D703EF3 addl %esi, %eax addl %edx, %eax roll $0x5, %ecx roll $0xa, %r12d addl %ebx, %ecx movl %r9d, %edx notl %edx orl %ecx, %edx xorl %r12d, %edx addl %r10d, %ebx movl $0x6ed9eba1, %r10d # imm = 0x6ED9EBA1 addl %r10d, %ebx addl %edx, %ebx roll $0xd, %eax roll $0xa, %r13d addl %r14d, %eax movl %edi, %edx notl %edx orl %eax, %edx xorl %r13d, %edx addl %r8d, %r14d addl %esi, %r14d addl %edx, %r14d roll $0xc, %ebx roll $0xa, %r9d addl %r11d, %ebx movl %ecx, %edx notl %edx orl %ebx, %edx xorl %r9d, %edx addl -0x60(%rsp), %r11d addl %r10d, %r11d addl %edx, %r11d roll $0xd, %r14d roll $0xa, %edi addl %r15d, %r14d movl %eax, %edx notl %edx orl %r14d, %edx xorl %edi, %edx addl -0x50(%rsp), %r15d addl %esi, %r15d addl %edx, %r15d roll $0x7, %r11d addl %r12d, %r11d addl -0x68(%rsp), %r12d addl %r10d, %r12d roll $0xa, %ecx movl %ebx, %edx notl %edx orl %r11d, %edx xorl %ecx, %edx addl %edx, %r12d roll $0x7, %r15d addl %r13d, %r15d addl %ebp, %r13d addl %esi, %r13d roll $0xa, %eax movl %r14d, %edx notl %edx orl %r15d, %edx xorl %eax, %edx addl %edx, %r13d roll $0x5, %r12d roll $0xa, %ebx addl %r9d, %r12d movl %r12d, %edx xorl %r11d, %edx andl %ebx, %edx xorl %r11d, %edx movq -0x58(%rsp), %r8 addl %r8d, %r9d movl $0x8f1bbcdc, %ebp # imm = 0x8F1BBCDC addl %ebp, %r9d addl %edx, %r9d roll $0x5, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r15d, %edx xorl %r14d, %edx andl %r13d, %edx xorl %r14d, %edx addl -0x70(%rsp), %edi movl $0x7a6d76e9, %ebp # imm = 0x7A6D76E9 addl %ebp, %edi addl %edx, %edi roll $0xb, %r9d addl %ecx, %r9d roll $0xa, %r11d movl %r9d, %edx xorl %r12d, %edx andl %r11d, %edx xorl %r12d, %edx addl -0x78(%rsp), %ecx movl $0x8f1bbcdc, %r10d # imm = 0x8F1BBCDC addl %r10d, %ecx addl %edx, %ecx roll $0xf, %edi addl %eax, %edi roll $0xa, %r15d movl %r13d, %edx xorl %r15d, %edx andl %edi, %edx xorl %r15d, %edx addl -0x7c(%rsp), %eax addl %ebp, %eax addl %edx, %eax roll $0xc, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %ecx, %edx xorl %r9d, %edx andl %r12d, %edx xorl %r9d, %edx movl -0x6c(%rsp), %esi addl %esi, %ebx addl %r10d, %ebx addl %edx, %ebx roll $0x5, %eax addl %r14d, %eax roll $0xa, %r13d movl %edi, %edx xorl %r13d, %edx andl %eax, %edx xorl %r13d, %edx addl -0x50(%rsp), %r14d addl %ebp, %r14d movl $0x7a6d76e9, %r10d # imm = 0x7A6D76E9 addl %edx, %r14d roll $0xe, %ebx addl %r11d, %ebx roll $0xa, %r9d movl %ebx, %edx xorl %ecx, %edx andl %r9d, %edx xorl %ecx, %edx addl -0x74(%rsp), %r11d movl $0x8f1bbcdc, %ebp # imm = 0x8F1BBCDC addl %ebp, %r11d addl %edx, %r11d roll $0x8, %r14d addl %r15d, %r14d roll $0xa, %edi movl %eax, %edx xorl %edi, %edx andl %r14d, %edx xorl %edi, %edx addl %r8d, %r15d addl %r10d, %r15d movl $0x7a6d76e9, %ebp # imm = 0x7A6D76E9 addl %edx, %r15d roll $0xf, %r11d addl %r12d, %r11d roll $0xa, %ecx movl %r11d, %edx xorl %ebx, %edx andl %ecx, %edx xorl %ebx, %edx movq -0x28(%rsp), %r8 addl %r8d, %r12d movl $0x8f1bbcdc, %r10d # imm = 0x8F1BBCDC addl %r10d, %r12d addl %edx, %r12d roll $0xb, %r15d addl %r13d, %r15d roll $0xa, %eax movl %r14d, %edx xorl %eax, %edx andl %r15d, %edx xorl %eax, %edx addl -0x48(%rsp), %r13d addl %ebp, %r13d addl %edx, %r13d roll $0xe, %r12d addl %r9d, %r12d roll $0xa, %ebx movl %r12d, %edx xorl %r11d, %edx andl %ebx, %edx xorl %r11d, %edx addl -0x70(%rsp), %r9d addl %r10d, %r9d addl %edx, %r9d roll $0xe, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r15d, %edx xorl %r14d, %edx andl %r13d, %edx xorl %r14d, %edx addl %esi, %edi addl %ebp, %edi movl $0x7a6d76e9, %esi # imm = 0x7A6D76E9 addl %edx, %edi roll $0xf, %r9d addl %ecx, %r9d roll $0xa, %r11d movl %r9d, %edx xorl %r12d, %edx andl %r11d, %edx xorl %r12d, %edx movl -0x68(%rsp), %ebp addl %ebp, %ecx addl %r10d, %ecx addl %edx, %ecx roll $0xe, %edi addl %eax, %edi roll $0xa, %r15d movl %r13d, %edx xorl %r15d, %edx andl %edi, %edx xorl %r15d, %edx addl -0x80(%rsp), %eax addl %esi, %eax addl %edx, %eax roll $0x9, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %ecx, %edx xorl %r9d, %edx andl %r12d, %edx xorl %r9d, %edx addl -0x50(%rsp), %ebx movl $0x8f1bbcdc, %esi # imm = 0x8F1BBCDC addl %esi, %ebx addl %edx, %ebx movq %rax, %r10 roll $0x6, %r10d addl %r14d, %r10d roll $0xa, %r13d movl %edi, %edx xorl %r13d, %edx andl %r10d, %edx xorl %r13d, %edx addl %r8d, %r14d movl $0x7a6d76e9, %r8d # imm = 0x7A6D76E9 addl %r8d, %r14d addl %edx, %r14d roll $0x8, %ebx addl %r11d, %ebx roll $0xa, %r9d movl %ebx, %edx xorl %ecx, %edx andl %r9d, %edx xorl %ecx, %edx movl -0x64(%rsp), %esi addl %esi, %r11d movl $0x8f1bbcdc, %eax # imm = 0x8F1BBCDC addl %eax, %r11d addl %edx, %r11d roll $0xe, %r14d addl %r15d, %r14d roll $0xa, %edi movl %r10d, %edx xorl %edi, %edx andl %r14d, %edx xorl %edi, %edx addl -0x60(%rsp), %r15d addl %r8d, %r15d addl %edx, %r15d roll $0x9, %r11d addl %r12d, %r11d roll $0xa, %ecx movl %r11d, %edx xorl %ebx, %edx andl %ecx, %edx xorl %ebx, %edx addl -0x48(%rsp), %r12d addl %eax, %r12d addl %edx, %r12d roll $0x6, %r15d addl %r13d, %r15d roll $0xa, %r10d movl %r14d, %edx xorl %r10d, %edx andl %r15d, %edx xorl %r10d, %edx addl %ebp, %r13d addl %r8d, %r13d addl %edx, %r13d roll $0xe, %r12d addl %r9d, %r12d roll $0xa, %ebx movl %r12d, %edx xorl %r11d, %edx andl %ebx, %edx xorl %r11d, %edx movq -0x30(%rsp), %rax addl %eax, %r9d movl $0x8f1bbcdc, %ebp # imm = 0x8F1BBCDC addl %ebp, %r9d addl %edx, %r9d roll $0x9, %r13d addl %edi, %r13d roll $0xa, %r14d movl %r15d, %edx xorl %r14d, %edx andl %r13d, %edx xorl %r14d, %edx movq -0x40(%rsp), %rbp addl %ebp, %edi addl %r8d, %edi addl %edx, %edi roll $0x5, %r9d addl %ecx, %r9d roll $0xa, %r11d movl %r9d, %edx xorl %r12d, %edx andl %r11d, %edx xorl %r12d, %edx addl -0x80(%rsp), %ecx movl $0x8f1bbcdc, %ebp # imm = 0x8F1BBCDC addl %ebp, %ecx addl %edx, %ecx roll $0xc, %edi addl %r10d, %edi roll $0xa, %r15d movl %r13d, %edx xorl %r15d, %edx andl %edi, %edx xorl %r15d, %edx addl %esi, %r10d addl %r8d, %r10d addl %edx, %r10d roll $0x6, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %ecx, %edx xorl %r9d, %edx andl %r12d, %edx xorl %r9d, %edx movq -0x38(%rsp), %rsi addl %esi, %ebx addl %ebp, %ebx addl %edx, %ebx roll $0x9, %r10d addl %r14d, %r10d roll $0xa, %r13d movl %edi, %edx xorl %r13d, %edx andl %r10d, %edx xorl %r13d, %edx addl -0x78(%rsp), %r14d addl %r8d, %r14d addl %edx, %r14d roll $0x8, %ebx addl %r11d, %ebx roll $0xa, %r9d movl %ebx, %edx xorl %ecx, %edx andl %r9d, %edx xorl %ecx, %edx addl -0x60(%rsp), %r11d movl $0x8f1bbcdc, %r8d # imm = 0x8F1BBCDC addl %r8d, %r11d addl %edx, %r11d roll $0xc, %r14d addl %r15d, %r14d roll $0xa, %edi movl %r10d, %edx xorl %edi, %edx andl %r14d, %edx xorl %edi, %edx addl %eax, %r15d movl $0x7a6d76e9, %ebp # imm = 0x7A6D76E9 addl %ebp, %r15d addl %edx, %r15d roll $0x6, %r11d addl %r12d, %r11d roll $0xa, %ecx movl %r11d, %edx xorl %ebx, %edx andl %ecx, %edx xorl %ebx, %edx addl -0x7c(%rsp), %r12d addl %r8d, %r12d addl %edx, %r12d roll $0x5, %r15d addl %r13d, %r15d roll $0xa, %r10d movl %r14d, %edx xorl %r10d, %edx andl %r15d, %edx xorl %r10d, %edx addl -0x74(%rsp), %r13d addl %ebp, %r13d movl $0x7a6d76e9, %eax # imm = 0x7A6D76E9 addl %edx, %r13d roll $0x5, %r12d addl %r9d, %r12d roll $0xa, %ebx addl -0x40(%rsp), %r9d addl %r8d, %r9d movl %r12d, %edx xorl %r11d, %edx andl %ebx, %edx xorl %r11d, %edx addl %edx, %r9d roll $0xf, %r13d addl %edi, %r13d roll $0xa, %r14d addl %esi, %edi addl %eax, %edi movl %r15d, %edx xorl %r14d, %edx andl %r13d, %edx xorl %r14d, %edx addl %edx, %edi roll $0xc, %r9d roll $0xa, %r11d roll $0x8, %edi addl %ecx, %r9d movl %r11d, %edx notl %edx orl %r12d, %edx xorl %r9d, %edx movq -0x50(%rsp), %rax addl %eax, %ecx movl $0xa953fd4e, %esi # imm = 0xA953FD4E addl %esi, %ecx addl %edx, %ecx addl %r10d, %edi roll $0xa, %r15d movl %r13d, %edx xorl %r15d, %edx xorl %edi, %edx addl -0x68(%rsp), %r10d addl %edx, %r10d roll $0x9, %ecx addl %ebx, %ecx roll $0xa, %r12d movl %r12d, %edx notl %edx orl %r9d, %edx xorl %ecx, %edx addl -0x28(%rsp), %ebx addl %esi, %ebx addl %edx, %ebx roll $0x8, %r10d addl %r14d, %r10d roll $0xa, %r13d roll $0xf, %ebx movl %edi, %edx xorl %r13d, %edx xorl %r10d, %edx addl -0x80(%rsp), %r14d addl %edx, %r14d addl %r11d, %ebx roll $0xa, %r9d roll $0x5, %r14d movl %r9d, %edx notl %edx orl %ecx, %edx xorl %ebx, %edx movq -0x60(%rsp), %r8 addl %r8d, %r11d addl %esi, %r11d addl %edx, %r11d addl %r15d, %r14d roll $0xa, %edi movl %r10d, %edx xorl %edi, %edx xorl %r14d, %edx addl -0x74(%rsp), %r15d addl %edx, %r15d roll $0x5, %r11d addl %r12d, %r11d roll $0xa, %ecx movl %ecx, %edx notl %edx orl %ebx, %edx xorl %r11d, %edx addl -0x78(%rsp), %r12d addl %esi, %r12d addl %edx, %r12d roll $0xc, %r15d addl %r13d, %r15d roll $0xa, %r10d roll $0xb, %r12d addl %eax, %r13d movl %r14d, %edx xorl %r10d, %edx xorl %r15d, %edx addl %edx, %r13d addl %r9d, %r12d roll $0xa, %ebx roll $0x9, %r13d movl %ebx, %edx notl %edx orl %r11d, %edx xorl %r12d, %edx movq -0x30(%rsp), %rbp addl %ebp, %r9d addl %esi, %r9d addl %edx, %r9d addl %edi, %r13d roll $0xa, %r14d movl %r15d, %edx xorl %r14d, %edx xorl %r13d, %edx addl -0x58(%rsp), %edi addl %edx, %edi roll $0x6, %r9d addl %ecx, %r9d addl -0x68(%rsp), %ecx roll $0xa, %r11d movl %r11d, %edx notl %edx orl %r12d, %edx xorl %r9d, %edx addl %esi, %ecx addl %edx, %ecx movq %rdi, %rsi roll $0xc, %esi addl %r10d, %esi roll $0xa, %r15d roll $0x8, %ecx addl %r8d, %r10d movl %r13d, %edx xorl %r15d, %edx xorl %esi, %edx addl %edx, %r10d addl %ebx, %ecx roll $0xa, %r12d roll $0x5, %r10d movl %r12d, %edx notl %edx orl %r9d, %edx xorl %ecx, %edx movq -0x40(%rsp), %rax addl %eax, %ebx movl $0xa953fd4e, %edi # imm = 0xA953FD4E addl %edi, %ebx movl $0xa953fd4e, %r8d # imm = 0xA953FD4E addl %edx, %ebx addl %r14d, %r10d roll $0xa, %r13d movl %esi, %edx xorl %r13d, %edx xorl %r10d, %edx addl -0x70(%rsp), %r14d addl %edx, %r14d roll $0xd, %ebx addl %r11d, %ebx addl -0x74(%rsp), %r11d roll $0xa, %r9d movl %r9d, %edx notl %edx orl %ecx, %edx xorl %ebx, %edx addl %r8d, %r11d addl %edx, %r11d roll $0xe, %r14d addl %r15d, %r14d roll $0xa, %esi roll $0xc, %r11d addl %ebp, %r15d movl %r10d, %edx xorl %esi, %edx xorl %r14d, %edx addl %edx, %r15d addl %r12d, %r11d roll $0xa, %ecx roll $0x6, %r15d movl %ecx, %edx notl %edx orl %ebx, %edx xorl %r11d, %edx movq -0x38(%rsp), %rbp addl %ebp, %r12d addl %r8d, %r12d addl %edx, %r12d addl %r13d, %r15d roll $0xa, %r10d movl %r14d, %edx xorl %r10d, %edx xorl %r15d, %edx addl -0x7c(%rsp), %r13d addl %edx, %r13d roll $0x5, %r12d addl %r9d, %r12d addl -0x58(%rsp), %r9d roll $0xa, %ebx movl %ebx, %edx notl %edx orl %r11d, %edx xorl %r12d, %edx addl %edi, %r9d addl %edx, %r9d roll $0x8, %r13d addl %esi, %r13d roll $0xa, %r14d roll $0xc, %r9d addl %eax, %esi movl %r15d, %edx xorl %r14d, %edx xorl %r13d, %edx addl %edx, %esi addl %ecx, %r9d roll $0xa, %r11d roll $0xd, %esi movl %r11d, %edx notl %edx orl %r12d, %edx xorl %r9d, %edx movq -0x48(%rsp), %rdi addl %edi, %ecx addl %r8d, %ecx addl %edx, %ecx addl %r10d, %esi roll $0xa, %r15d movl %r13d, %edx xorl %r15d, %edx xorl %esi, %edx movl -0x64(%rsp), %eax addl %eax, %r10d addl %edx, %r10d roll $0xd, %ecx addl %ebx, %ecx addl -0x70(%rsp), %ebx roll $0xa, %r12d movl %r12d, %edx notl %edx orl %r9d, %edx xorl %ecx, %edx addl %r8d, %ebx addl %edx, %ebx roll $0x6, %r10d addl %r14d, %r10d roll $0xa, %r13d roll $0xe, %ebx addl %ebp, %r14d movl %esi, %edx xorl %r13d, %edx xorl %r10d, %edx addl %edx, %r14d addl %r11d, %ebx roll $0xa, %r9d roll $0x5, %r14d movl %r9d, %edx notl %edx orl %ecx, %edx xorl %ebx, %edx movl -0x6c(%rsp), %ebp addl %ebp, %r11d addl %r8d, %r11d addl %edx, %r11d addl %r15d, %r14d roll $0xa, %esi addl -0x28(%rsp), %r15d movl %r10d, %edx xorl %esi, %edx xorl %r14d, %edx addl %edx, %r15d roll $0xb, %r11d addl %r12d, %r11d addl -0x7c(%rsp), %r12d roll $0xa, %ecx movl %ecx, %edx notl %edx orl %ebx, %edx xorl %r11d, %edx addl %r8d, %r12d addl %edx, %r12d roll $0xf, %r15d addl %r13d, %r15d roll $0xa, %r10d roll $0x8, %r12d addl %edi, %r13d movl %r14d, %edx xorl %r10d, %edx xorl %r15d, %edx addl %edx, %r13d addl %r9d, %r12d roll $0xa, %ebx addl -0x80(%rsp), %r9d roll $0xd, %r13d movl %ebx, %edx notl %edx orl %r11d, %edx xorl %r12d, %edx addl %r8d, %r9d addl %edx, %r9d addl %esi, %r13d roll $0xa, %r14d addl -0x78(%rsp), %esi movl %r15d, %edx xorl %r14d, %edx xorl %r13d, %edx addl %edx, %esi roll $0x5, %r9d addl %ecx, %r9d addl %eax, %ecx addl %r8d, %ecx roll $0xa, %r11d roll $0xb, %esi movq -0x18(%rsp), %rdx addl %r14d, %edx addl %r11d, %edx movq %rdx, %r8 notl %r11d orl %r12d, %r11d xorl %r9d, %r11d addl %r11d, %ecx addl %r10d, %esi roll $0xa, %r15d addl %ebp, %r10d movl %r13d, %edx xorl %r15d, %edx xorl %esi, %edx addl %edx, %r10d roll $0xa, %r13d addl -0x20(%rsp), %r13d addl %r9d, %r13d addl -0x1c(%rsp), %r15d roll $0xa, %r12d addl %r12d, %r15d movq (%rsp), %rax movl %r15d, 0xc(%rax) movl %r8d, 0x10(%rax) movq -0x10(%rsp), %rdx addl %ebx, %edx addl %r14d, %edx roll $0xb, %r10d addl %r10d, %edx movl %edx, 0x14(%rax) addl -0x8(%rsp), %ebx roll $0x6, %ecx addl %esi, %ebx addl %ecx, %ebx movl %ebx, 0x18(%rax) movl %r13d, 0x8(%rax) addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/ripemd160.c
mbedtls_rsa_check_pub_priv	int mbedtls_rsa_check_pub_priv( const mbedtls_rsa_context pub, const mbedtls_rsa_context prv ) { if( mbedtls_rsa_check_pubkey( pub ) != 0 \|\| mbedtls_rsa_check_privkey( prv ) != 0 ) { return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED ); } if( mbedtls_mpi_cmp_mpi( &pub->N, &prv->N ) != 0 \|\| mbedtls_mpi_cmp_mpi( &pub->E, &prv->E ) != 0 ) { return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED ); } return( 0 ); }	pushq %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 callq 0xe87f movl $0xffffbe00, %ebp # imm = 0xFFFFBE00 testl %eax, %eax jne 0xece8 movq %rbx, %rdi callq 0xe8fd testl %eax, %eax jne 0xece8 leaq 0x10(%r14), %rdi leaq 0x10(%rbx), %rsi callq 0x15449 testl %eax, %eax jne 0xece8 addq $0x28, %r14 addq $0x28, %rbx movq %r14, %rdi movq %rbx, %rsi callq 0x15449 testl %eax, %eax movl $0xffffbe00, %ebp # imm = 0xFFFFBE00 cmovel %eax, %ebp movl %ebp, %eax popq %rbx popq %r14 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/rsa.c
mgf_mask	static void mgf_mask( unsigned char dst, size_t dlen, unsigned char src, size_t slen, mbedtls_md_context_t md_ctx ) { unsigned char mask[MBEDTLS_MD_MAX_SIZE]; unsigned char counter[4]; unsigned char p; unsigned int hlen; size_t i, use_len; memset( mask, 0, MBEDTLS_MD_MAX_SIZE ); memset( counter, 0, 4 ); hlen = mbedtls_md_get_size( md_ctx->md_info ); /* Generate and apply dbMask / p = dst; while( dlen > 0 ) { use_len = hlen; if( dlen < hlen ) use_len = dlen; mbedtls_md_starts( md_ctx ); mbedtls_md_update( md_ctx, src, slen ); mbedtls_md_update( md_ctx, counter, 4 ); mbedtls_md_finish( md_ctx, mask ); for( i = 0; i < use_len; ++i ) p++ ^= mask[i]; counter[3]++; dlen -= use_len; } }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %r8, %rbx movq %rcx, 0x18(%rsp) movq %rdx, 0x10(%rsp) movq %rsi, %r12 movq %rdi, %r13 xorps %xmm0, %xmm0 movaps %xmm0, 0x20(%rsp) movaps %xmm0, 0x30(%rsp) movaps %xmm0, 0x40(%rsp) movaps %xmm0, 0x50(%rsp) movl $0x0, 0xc(%rsp) movq (%r8), %rdi callq 0xab31 testq %r12, %r12 je 0xf43a movl %eax, %ebp movzbl %al, %r15d cmpq %r15, %r12 movq %r15, %r14 cmovbq %r12, %r14 movq %rbx, %rdi callq 0xa6b0 movq %rbx, %rdi movq 0x10(%rsp), %rsi movq 0x18(%rsp), %rdx callq 0xa6d1 movl $0x4, %edx movq %rbx, %rdi leaq 0xc(%rsp), %rsi callq 0xa6d1 movq %rbx, %rdi leaq 0x20(%rsp), %rsi callq 0xa6f2 testb %bpl, %bpl je 0xf431 cmpq $0x1, %r14 movq %r14, %rax adcq $0x0, %rax xorl %ecx, %ecx movb 0x20(%rsp,%rcx), %dl xorb %dl, (%r13,%rcx) incq %rcx cmpq %rcx, %rax jne 0xf41d addq %rcx, %r13 incb 0xf(%rsp) subq %r14, %r12 jne 0xf3c8 addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/rsa.c
mbedtls_rsa_pkcs1_encrypt	int mbedtls_rsa_pkcs1_encrypt( mbedtls_rsa_context ctx, int (f_rng)(void , unsigned char , size_t), void p_rng, int mode, size_t ilen, const unsigned char input, unsigned char *output ) { switch( ctx->padding ) { #if defined(MBEDTLS_PKCS1_V15) case MBEDTLS_RSA_PKCS_V15: return mbedtls_rsa_rsaes_pkcs1_v15_encrypt( ctx, f_rng, p_rng, mode, ilen, input, output ); #endif #if defined(MBEDTLS_PKCS1_V21) case MBEDTLS_RSA_PKCS_V21: return mbedtls_rsa_rsaes_oaep_encrypt( ctx, f_rng, p_rng, mode, NULL, 0, ilen, input, output ); #endif default: return( MBEDTLS_ERR_RSA_INVALID_PADDING ); } }	movq %r9, %r10 movq %r8, %rax movl 0x148(%rdi), %r8d cmpl $0x1, %r8d je 0xf629 testl %r8d, %r8d jne 0xf646 movq %rax, %r8 movq %r10, %r9 jmp 0xf449 pushq %rax subq $0x8, %rsp xorl %r8d, %r8d xorl %r9d, %r9d pushq 0x18(%rsp) pushq %r10 pushq %rax callq 0xf12f addq $0x20, %rsp popq %rcx retq movl $0xffffbf00, %eax # imm = 0xFFFFBF00 retq	/Dragonchang[P]https_client/mbedtls/library/rsa.c
mbedtls_rsa_rsassa_pss_verify_ext	int mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_rsa_context ctx, int (f_rng)(void , unsigned char , size_t), void p_rng, int mode, mbedtls_md_type_t md_alg, unsigned int hashlen, const unsigned char hash, mbedtls_md_type_t mgf1_hash_id, int expected_salt_len, const unsigned char sig ) { int ret; size_t siglen; unsigned char p; unsigned char result[MBEDTLS_MD_MAX_SIZE]; unsigned char zeros[8]; unsigned int hlen; size_t slen, msb; const mbedtls_md_info_t md_info; mbedtls_md_context_t md_ctx; unsigned char buf[MBEDTLS_MPI_MAX_SIZE]; if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 ) return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA ); siglen = ctx->len; if( siglen < 16 \|\| siglen > sizeof( buf ) ) return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA ); ret = ( mode == MBEDTLS_RSA_PUBLIC ) ? mbedtls_rsa_public( ctx, sig, buf ) : mbedtls_rsa_private( ctx, f_rng, p_rng, sig, buf ); if( ret != 0 ) return( ret ); p = buf; if( buf[siglen - 1] != 0xBC ) return( MBEDTLS_ERR_RSA_INVALID_PADDING ); if( md_alg != MBEDTLS_MD_NONE ) { / Gather length of hash to sign / md_info = mbedtls_md_info_from_type( md_alg ); if( md_info == NULL ) return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA ); hashlen = mbedtls_md_get_size( md_info ); } md_info = mbedtls_md_info_from_type( mgf1_hash_id ); if( md_info == NULL ) return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA ); hlen = mbedtls_md_get_size( md_info ); slen = siglen - hlen - 1; / Currently length of salt + padding / memset( zeros, 0, 8 ); / * Note: EMSA-PSS verification is over the length of N - 1 bits / msb = mbedtls_mpi_bitlen( &ctx->N ) - 1; / Compensate for boundary condition when applying mask / if( msb % 8 == 0 ) { p++; siglen -= 1; } if( buf[0] >> ( 8 - siglen 8 + msb ) ) return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA ); mbedtls_md_init( &md_ctx ); if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 ) { mbedtls_md_free( &md_ctx ); return( ret ); } mgf_mask( p, siglen - hlen - 1, p + siglen - hlen - 1, hlen, &md_ctx ); buf[0] &= 0xFF >> ( siglen * 8 - msb ); while( p < buf + siglen && p == 0 ) p++; if( p == buf + siglen \|\| p++ != 0x01 ) { mbedtls_md_free( &md_ctx ); return( MBEDTLS_ERR_RSA_INVALID_PADDING ); } /* Actual salt len / slen -= p - buf; if( expected_salt_len != MBEDTLS_RSA_SALT_LEN_ANY && slen != (size_t) expected_salt_len ) { mbedtls_md_free( &md_ctx ); return( MBEDTLS_ERR_RSA_INVALID_PADDING ); } / * Generate H = Hash( M' ) */ mbedtls_md_starts( &md_ctx ); mbedtls_md_update( &md_ctx, zeros, 8 ); mbedtls_md_update( &md_ctx, hash, hashlen ); mbedtls_md_update( &md_ctx, p, slen ); mbedtls_md_finish( &md_ctx, result ); mbedtls_md_free( &md_ctx ); if( memcmp( p + slen, result, hlen ) == 0 ) return( 0 ); else return( MBEDTLS_ERR_RSA_VERIFY_FAILED ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x488, %rsp # imm = 0x488 movl %r9d, %ebx movl %r8d, %ebp movq %rdi, %r14 cmpl $0x1, %ecx jne 0xff7d movl $0xffffbf80, %r15d # imm = 0xFFFFBF80 cmpl $0x1, 0x148(%r14) jne 0x1016f movq 0x8(%r14), %r12 leaq -0x401(%r12), %rax cmpq $-0x3f1, %rax # imm = 0xFC0F jae 0xff9c movl $0xffffbf80, %r15d # imm = 0xFFFFBF80 jmp 0x1016f movq 0x4d8(%rsp), %rax testl %ecx, %ecx je 0xffbd leaq 0x80(%rsp), %r8 movq %r14, %rdi movq %rax, %rcx callq 0xeda3 jmp 0xffd0 leaq 0x80(%rsp), %rdx movq %r14, %rdi movq %rax, %rsi callq 0xecef movl %eax, %r15d testl %eax, %eax jne 0x1016f movl $0xffffbf00, %r15d # imm = 0xFFFFBF00 cmpb $-0x44, 0x7f(%rsp,%r12) jne 0x1016f testl %ebp, %ebp je 0x10008 movl %ebp, %edi callq 0xa57b testq %rax, %rax je 0xff91 movq %rax, %rdi callq 0xab31 movzbl %al, %ebx movl 0x4c8(%rsp), %edi callq 0xa57b testq %rax, %rax je 0xff91 movq %rax, %r13 leaq -0x1(%r12), %rbp movq %rax, %rdi callq 0xab31 movb %al, 0x10(%rsp) movq $0x0, 0x38(%rsp) addq $0x10, %r14 movq %r14, %rdi callq 0x147ba leaq -0x1(%rax), %rsi testb $0x7, %sil sete %dil cmovneq %r12, %rbp movzbl 0x80(%rsp), %edx leaq (,%rbp,8), %r14 subl %r14d, %eax leal 0x7(%rax), %ecx shrl %cl, %edx movl $0xffffbf80, %r15d # imm = 0xFFFFBF80 testl %edx, %edx jne 0x1016f movb %dil, 0x8(%rsp) movq %rsi, 0x18(%rsp) leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0xa594 movq %r15, %rdi movq %r13, %rsi xorl %edx, %edx callq 0xa642 testl %eax, %eax je 0x100b6 movl %eax, %r15d leaq 0x20(%rsp), %rdi callq 0xa5a3 jmp 0x1016f movzbl 0x10(%rsp), %ecx movq %rcx, %rax notq %rax xorl %r13d, %r13d movb 0x8(%rsp), %dl movb %dl, %r13b leaq (%rsp,%r13), %r15 addq $0x80, %r15 leaq (%rax,%rbp), %rsi leaq (%r15,%rbp), %rdx movq %rax, 0x10(%rsp) addq %rax, %rdx leaq 0x20(%rsp), %r8 movq %r15, %rdi movq %rcx, 0x8(%rsp) callq 0xf375 subl 0x18(%rsp), %r14d movl $0xff, %eax movl %r14d, %ecx shrl %cl, %eax andb %al, 0x80(%rsp) leaq (%rsp,%rbp), %rax addq $0x80, %rax cmpq %r13, %rbp jle 0x1012b cmpb $0x0, (%r15) jne 0x1012b incq %r15 cmpq %rax, %r15 jb 0x1011d cmpq %rax, %r15 je 0x1015f cmpb $0x1, (%r15) jne 0x1015f movl 0x4d0(%rsp), %eax addq 0x10(%rsp), %r12 incq %r15 leaq 0x80(%rsp), %rbp subq %r15, %rbp addq %r12, %rbp cmpl $-0x1, %eax je 0x10184 cltq cmpq %rax, %rbp je 0x10184 leaq 0x20(%rsp), %rdi callq 0xa5a3 movl $0xffffbf00, %r15d # imm = 0xFFFFBF00 movl %r15d, %eax addq $0x488, %rsp # imm = 0x488 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x4c0(%rsp), %r12 leaq 0x20(%rsp), %r14 movq %r14, %rdi callq 0xa6b0 leaq 0x38(%rsp), %rsi movl $0x8, %edx movq %r14, %rdi callq 0xa6d1 movl %ebx, %edx movq %r14, %rdi movq %r12, %rsi callq 0xa6d1 movq %r14, %rdi movq %r15, %rsi movq %rbp, %rdx callq 0xa6d1 leaq 0x40(%rsp), %rbx movq %r14, %rdi movq %rbx, %rsi callq 0xa6f2 movq %r14, %rdi callq 0xa5a3 addq %rbp, %r15 movq %r15, %rdi movq %rbx, %rsi movq 0x8(%rsp), %rdx callq 0xa130 testl %eax, %eax movl $0xffffbc80, %r15d # imm = 0xFFFFBC80 cmovel %eax, %r15d jmp 0x1016f	/Dragonchang[P]https_client/mbedtls/library/rsa.c
mbedtls_sha256_starts	void mbedtls_sha256_starts( mbedtls_sha256_context ctx, int is224 ) { ctx->total[0] = 0; ctx->total[1] = 0; if( is224 == 0 ) { / SHA-256 / ctx->state[0] = 0x6A09E667; ctx->state[1] = 0xBB67AE85; ctx->state[2] = 0x3C6EF372; ctx->state[3] = 0xA54FF53A; ctx->state[4] = 0x510E527F; ctx->state[5] = 0x9B05688C; ctx->state[6] = 0x1F83D9AB; ctx->state[7] = 0x5BE0CD19; } else { / SHA-224 */ ctx->state[0] = 0xC1059ED8; ctx->state[1] = 0x367CD507; ctx->state[2] = 0x3070DD17; ctx->state[3] = 0xF70E5939; ctx->state[4] = 0xFFC00B31; ctx->state[5] = 0x68581511; ctx->state[6] = 0x64F98FA7; ctx->state[7] = 0xBEFA4FA4; } ctx->is224 = is224; }	pushq %rbp pushq %rbx movq $0x0, (%rdi) testl %esi, %esi movl $0x6a09e667, %ecx # imm = 0x6A09E667 movl $0xc1059ed8, %eax # imm = 0xC1059ED8 cmovel %ecx, %eax movl $0xbb67ae85, %ecx # imm = 0xBB67AE85 movl $0x367cd507, %edx # imm = 0x367CD507 cmovel %ecx, %edx movl $0x3c6ef372, %ecx # imm = 0x3C6EF372 movl $0x3070dd17, %r8d # imm = 0x3070DD17 cmovel %ecx, %r8d movl $0xa54ff53a, %ecx # imm = 0xA54FF53A movl $0xf70e5939, %r9d # imm = 0xF70E5939 cmovel %ecx, %r9d movl $0x510e527f, %ecx # imm = 0x510E527F movl $0xffc00b31, %r10d # imm = 0xFFC00B31 cmovel %ecx, %r10d movl $0x9b05688c, %ecx # imm = 0x9B05688C movl $0x68581511, %r11d # imm = 0x68581511 cmovel %ecx, %r11d movl $0x1f83d9ab, %ecx # imm = 0x1F83D9AB movl $0x64f98fa7, %ebx # imm = 0x64F98FA7 cmovel %ecx, %ebx movl $0x5be0cd19, %ecx # imm = 0x5BE0CD19 movl $0xbefa4fa4, %ebp # imm = 0xBEFA4FA4 cmovel %ecx, %ebp movl %eax, 0x8(%rdi) movl %edx, 0xc(%rdi) movl %r8d, 0x10(%rdi) movl %r9d, 0x14(%rdi) movl %r10d, 0x18(%rdi) movl %r11d, 0x1c(%rdi) movl %ebx, 0x20(%rdi) movl %ebp, 0x24(%rdi) movl %esi, 0x68(%rdi) popq %rbx popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/sha256.c
mbedtls_sha512_update	void mbedtls_sha512_update( mbedtls_sha512_context ctx, const unsigned char input, size_t ilen ) { size_t fill; unsigned int left; if( ilen == 0 ) return; left = (unsigned int) (ctx->total[0] & 0x7F); fill = 128 - left; ctx->total[0] += (uint64_t) ilen; if( ctx->total[0] < (uint64_t) ilen ) ctx->total[1]++; if( left && ilen >= fill ) { memcpy( (void ) (ctx->buffer + left), input, fill ); mbedtls_sha512_process( ctx, ctx->buffer ); input += fill; ilen -= fill; left = 0; } while( ilen >= 128 ) { mbedtls_sha512_process( ctx, input ); input += 128; ilen -= 128; } if( ilen > 0 ) memcpy( (void ) (ctx->buffer + left), input, ilen ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax testq %rdx, %rdx je 0x135b1 movq %rsi, %rbx movq %rdi, %r14 movq (%rdi), %rax movl %eax, %ecx andl $0x7f, %ecx movq %rax, %rsi addq %rdx, %rsi movq %rsi, (%rdi) jae 0x1351c incq 0x8(%r14) xorl %ebp, %ebp testl %ecx, %ecx je 0x1353a movl $0x80, %r12d subl %ecx, %r12d movq %rdx, %r15 subq %r12, %r15 jae 0x1353f movq %rdx, %r15 movl %ecx, %ebp jmp 0x13567 movq %rdx, %r15 jmp 0x13567 leaq 0x50(%r14), %r13 andl $0x7f, %eax leaq (%r14,%rax), %rdi addq $0x50, %rdi movq %rbx, %rsi movq %r12, %rdx callq 0xa110 movq %r14, %rdi movq %r13, %rsi callq 0x13006 addq %r12, %rbx cmpq $0x80, %r15 jb 0x13589 movq %r14, %rdi movq %rbx, %rsi callq 0x13006 subq $-0x80, %rbx addq $-0x80, %r15 cmpq $0x7f, %r15 ja 0x13570 testq %r15, %r15 je 0x135b1 movl %ebp, %eax leaq (%r14,%rax), %rdi addq $0x50, %rdi movq %rbx, %rsi movq %r15, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0xa110 addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/sha512.c
mbedtls_sha512	void mbedtls_sha512( const unsigned char *input, size_t ilen, unsigned char output[64], int is384 ) { mbedtls_sha512_context ctx; mbedtls_sha512_init( &ctx ); mbedtls_sha512_starts( &ctx, is384 ); mbedtls_sha512_update( &ctx, input, ilen ); mbedtls_sha512_finish( &ctx, output ); mbedtls_sha512_free( &ctx ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xd8, %rsp movl %ecx, %ebp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r12 movq %rsp, %r14 xorl %r13d, %r13d movl $0xd8, %edx movq %r14, %rdi xorl %esi, %esi callq 0xa0c0 testl %ebp, %ebp movabsq $0x6a09e667f3bcc908, %rcx # imm = 0x6A09E667F3BCC908 movabsq $-0x344462a23efa6128, %rax # imm = 0xCBBB9D5DC1059ED8 cmoveq %rcx, %rax movabsq $-0x4498517a7b3558c5, %rcx # imm = 0xBB67AE8584CAA73B movabsq $0x629a292a367cd507, %rdx # imm = 0x629A292A367CD507 cmoveq %rcx, %rdx movabsq $0x3c6ef372fe94f82b, %rcx # imm = 0x3C6EF372FE94F82B movabsq $-0x6ea6fea5cf8f22e9, %rsi # imm = 0x9159015A3070DD17 cmoveq %rcx, %rsi movabsq $-0x5ab00ac5a0e2c90f, %rcx # imm = 0xA54FF53A5F1D36F1 movabsq $0x152fecd8f70e5939, %rdi # imm = 0x152FECD8F70E5939 cmoveq %rcx, %rdi movabsq $0x510e527fade682d1, %rcx # imm = 0x510E527FADE682D1 movabsq $0x67332667ffc00b31, %r8 # imm = 0x67332667FFC00B31 cmoveq %rcx, %r8 movabsq $-0x64fa9773d4c193e1, %rcx # imm = 0x9B05688C2B3E6C1F movabsq $-0x714bb57897a7eaef, %r9 # imm = 0x8EB44A8768581511 cmoveq %rcx, %r9 movabsq $0x1f83d9abfb41bd6b, %rcx # imm = 0x1F83D9ABFB41BD6B movabsq $-0x24f3d1f29b067059, %r10 # imm = 0xDB0C2E0D64F98FA7 cmoveq %rcx, %r10 movabsq $0x5be0cd19137e2179, %rcx # imm = 0x5BE0CD19137E2179 movabsq $0x47b5481dbefa4fa4, %r11 # imm = 0x47B5481DBEFA4FA4 cmoveq %rcx, %r11 movq %rax, 0x10(%r14) movq %rdx, 0x18(%r14) movq %rsi, 0x20(%r14) movq %rdi, 0x28(%r14) movq %r8, 0x30(%r14) movq %r9, 0x38(%r14) movq %r10, 0x40(%r14) movq %r11, 0x48(%r14) movl %ebp, 0xd0(%r14) movq %r14, %rdi movq %r12, %rsi movq %r15, %rdx callq 0x134eb movq %r14, %rdi movq %rbx, %rsi callq 0x135c0 movb $0x0, (%rsp,%r13) incq %r13 cmpq $0xd8, %r13 jne 0x139ac addq $0xd8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/sha512.c
mbedtls_asn1_get_tag	int mbedtls_asn1_get_tag( unsigned char *p, const unsigned char end, size_t len, int tag ) { if( ( end - p ) < 1 ) return( MBEDTLS_ERR_ASN1_OUT_OF_DATA ); if( *p != tag ) return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ); (p)++; return( mbedtls_asn1_get_len( p, end, len ) ); }	movq (%rdi), %r8 movq %rsi, %rax subq %r8, %rax testq %rax, %rax jle 0x13d9d movzbl (%r8), %r9d movl $0xffffff9e, %eax # imm = 0xFFFFFF9E cmpl %ecx, %r9d jne 0x13da2 incq %r8 movq %r8, (%rdi) jmp 0x13ca4 movl $0xffffffa0, %eax # imm = 0xFFFFFFA0 retq	/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
mbedtls_asn1_get_alg	int mbedtls_asn1_get_alg( unsigned char *p, const unsigned char end, mbedtls_asn1_buf alg, mbedtls_asn1_buf params ) { int ret; size_t len; if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_CONSTRUCTED \| MBEDTLS_ASN1_SEQUENCE ) ) != 0 ) return( ret ); if( ( end - p ) < 1 ) return( MBEDTLS_ERR_ASN1_OUT_OF_DATA ); alg->tag = p; end = p + len; if( ( ret = mbedtls_asn1_get_tag( p, end, &alg->len, MBEDTLS_ASN1_OID ) ) != 0 ) return( ret ); alg->p = p; p += alg->len; if( p == end ) { mbedtls_zeroize( params, sizeof(mbedtls_asn1_buf) ); return( 0 ); } params->tag = p; (p)++; if( ( ret = mbedtls_asn1_get_len( p, end, &params->len ) ) != 0 ) return( ret ); params->p = p; p += params->len; if( *p != end ) return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ); return( 0 ); }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rcx, %rbx movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %r14 movq (%rdi), %rcx movq %rsi, %rax subq %rcx, %rax testq %rax, %rax jle 0x14158 movl $0xffffff9e, %eax # imm = 0xFFFFFF9E cmpb $0x30, (%rcx) jne 0x1415d incq %rcx movq %rcx, (%r14) movq %rsp, %rdx movq %r14, %rdi movq %r12, %rsi callq 0x13ca4 jmp 0x1415d movl $0xffffffa0, %eax # imm = 0xFFFFFFA0 testl %eax, %eax je 0x1416d addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq (%r14), %rcx subq %rcx, %r12 testq %r12, %r12 jle 0x141ac movzbl (%rcx), %eax movl %eax, (%r15) movq (%rsp), %rax leaq (%rcx,%rax), %r12 testq %rax, %rax jle 0x141b3 movl $0xffffff9e, %eax # imm = 0xFFFFFF9E cmpb $0x6, (%rcx) jne 0x141b8 leaq 0x8(%r15), %rdx incq %rcx movq %rcx, (%r14) movq %r14, %rdi movq %r12, %rsi callq 0x13ca4 jmp 0x141b8 movl $0xffffffa0, %eax # imm = 0xFFFFFFA0 jmp 0x14161 movl $0xffffffa0, %eax # imm = 0xFFFFFFA0 testl %eax, %eax jne 0x14161 movq (%r14), %rax movq %rax, 0x10(%r15) movq (%r14), %rax addq 0x8(%r15), %rax movq %rax, (%r14) cmpq %r12, %rax je 0x14217 movzbl (%rax), %ecx movl %ecx, (%rbx) incq %rax movq %rax, (%r14) leaq 0x8(%rbx), %rdx movq %r14, %rdi movq %r12, %rsi callq 0x13ca4 testl %eax, %eax jne 0x14161 movq (%r14), %rax movq %rax, 0x10(%rbx) movq (%r14), %rax addq 0x8(%rbx), %rax movq %rax, (%r14) xorl %ecx, %ecx cmpq %r12, %rax movl $0xffffff9a, %eax # imm = 0xFFFFFF9A cmovel %ecx, %eax jmp 0x14161 xorl %eax, %eax xorl %ecx, %ecx movb $0x0, (%rbx,%rcx) incq %rcx cmpq $0x18, %rcx jne 0x1421b jmp 0x14161	/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
mbedtls_mpi_set_bit	int mbedtls_mpi_set_bit( mbedtls_mpi X, size_t pos, unsigned char val ) { int ret = 0; size_t off = pos / biL; size_t idx = pos % biL; if( val != 0 && val != 1 ) return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA ); if( X->n biL <= pos ) { if( val == 0 ) return( 0 ); MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, off + 1 ) ); } X->p[off] &= ~( (mbedtls_mpi_uint) 0x01 << idx ); X->p[off] \|= (mbedtls_mpi_uint) val << idx; cleanup: return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %edx, %ebp movl $0xfffffffc, %eax # imm = 0xFFFFFFFC cmpb $0x1, %bpl ja 0x1476e movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %r15 shrq $0x6, %r15 movq 0x8(%rdi), %rax shlq $0x6, %rax cmpq %rsi, %rax jbe 0x14755 andl $0x3f, %ebx movq 0x10(%r14), %rax movq (%rax,%r15,8), %rdx movzbl %bpl, %esi movl %ebx, %ecx shlq %cl, %rsi btrq %rbx, %rdx orq %rdx, %rsi movq %rsi, (%rax,%r15,8) jmp 0x1476c testb %bpl, %bpl je 0x1476c leaq 0x1(%r15), %rsi movq %r14, %rdi callq 0x14364 testl %eax, %eax jne 0x1476e jmp 0x14734 xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_read_string	int mbedtls_mpi_read_string( mbedtls_mpi X, int radix, const char s ) { int ret; size_t i, j, slen, n; mbedtls_mpi_uint d; mbedtls_mpi T; if( radix < 2 \|\| radix > 16 ) return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA ); mbedtls_mpi_init( &T ); slen = strlen( s ); if( radix == 16 ) { if( slen > MPI_SIZE_T_MAX >> 2 ) return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA ); n = BITS_TO_LIMBS( slen << 2 ); MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) ); for( i = slen, j = 0; i > 0; i--, j++ ) { if( i == 1 && s[i - 1] == '-' ) { X->s = -1; break; } MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) ); X->p[j / ( 2 * ciL )] \|= d << ( ( j % ( 2 * ciL ) ) << 2 ); } } else { MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) ); for( i = 0; i < slen; i++ ) { if( i == 0 && s[i] == '-' ) { X->s = -1; continue; } MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i] ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T, X, radix ) ); if( X->s == 1 ) { MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, &T, d ) ); } else { MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( X, &T, d ) ); } } } cleanup: mbedtls_mpi_free( &T ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movl %esi, %r13d leal -0x11(%r13), %eax movl $0xfffffffc, %r12d # imm = 0xFFFFFFFC cmpl $-0xf, %eax jb 0x149c0 movq %rdx, %rbx movq %rdi, %r14 movl $0x1, 0x40(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x48(%rsp) movq %rdx, %rdi callq 0xa090 movq %rax, %r15 cmpl $0x10, %r13d jne 0x1496f movq %r15, %rax shrq $0x3e, %rax jne 0x149c0 movq %r15, %rsi shrq $0x4, %rsi movl %r15d, %eax andl $0xf, %eax cmpq $0x1, %rax sbbq $-0x1, %rsi movq %r14, %rdi callq 0x14364 testl %eax, %eax jne 0x14980 movl $0x1, %esi movq %r14, %rdi callq 0x14364 testl %eax, %eax jne 0x14980 movq 0x8(%r14), %rdx movq 0x10(%r14), %rdi shlq $0x3, %rdx xorl %r12d, %r12d xorl %esi, %esi callq 0xa0c0 movq 0x10(%r14), %rax movq $0x0, (%rax) movl $0x1, (%r14) movl $0xff, %eax xorl %edx, %edx xorl %esi, %esi cmpq $0x1, %r15 je 0x1490a testq %r15, %r15 jne 0x14913 jmp 0x14983 cmpb $0x2d, (%rbx) je 0x14b54 movsbl -0x1(%rbx,%r15), %edi leal -0x30(%rdi), %ecx leal -0x30(%rdi), %r8d cmpb $0xa, %cl cmovaeq %rax, %r8 leal -0x41(%rdi), %ecx leal -0x37(%rdi), %r9d cmpb $0x6, %cl cmovaeq %r8, %r9 leal -0x61(%rdi), %ecx addl $-0x57, %edi cmpb $0x6, %cl cmovaeq %r9, %rdi cmpq $0xf, %rdi ja 0x14b49 movl %edx, %ecx andb $0x3c, %cl shlq %cl, %rdi movq 0x10(%r14), %rcx movq %rsi, %r8 shrq $0x4, %r8 orq %rdi, (%rcx,%r8,8) decq %r15 incq %rsi addq $0x4, %rdx jmp 0x148fd movl $0x1, %esi movq %r14, %rdi callq 0x14364 testl %eax, %eax je 0x149d2 movl %eax, %r12d leaq 0x48(%rsp), %rbx movq 0x8(%rbx), %rdi testq %rdi, %rdi je 0x149b2 movq 0x48(%rsp), %rax testq %rax, %rax je 0x149ad xorl %ecx, %ecx movq $0x0, (%rdi,%rcx,8) incq %rcx cmpq %rcx, %rax jne 0x1499d callq 0xa030 movl $0x1, 0x40(%rsp) xorps %xmm0, %xmm0 movups %xmm0, (%rbx) movl %r12d, %eax addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x8(%r14), %rdx movq 0x10(%r14), %rdi shlq $0x3, %rdx xorl %r12d, %r12d xorl %esi, %esi callq 0xa0c0 movq 0x10(%r14), %rax movq $0x0, (%rax) movl $0x1, (%r14) testq %r15, %r15 je 0x14983 movq %r14, 0x38(%rsp) movl %r13d, %esi xorl %ebp, %ebp leaq 0x40(%rsp), %r14 movq %r15, 0x30(%rsp) movq %rbx, 0x28(%rsp) testq %rbp, %rbp jne 0x14a32 cmpb $0x2d, (%rbx) jne 0x14a32 movq 0x38(%rsp), %rax movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF jmp 0x14b35 movsbl (%rbx,%rbp), %r13d leal -0x30(%r13), %eax leal -0x30(%r13), %ecx cmpb $0xa, %al movl $0xff, %eax cmovaeq %rax, %rcx leal -0x41(%r13), %eax leal -0x37(%r13), %edx cmpb $0x6, %al cmovaeq %rcx, %rdx leal -0x61(%r13), %eax addl $-0x57, %r13d cmpb $0x6, %al cmovaeq %rdx, %r13 cmpq %rsi, %r13 jae 0x14b49 movl $0x1, 0x10(%rsp) movq $0x1, 0x18(%rsp) leaq 0x8(%rsp), %rax movq %rax, 0x20(%rsp) movq %rsi, %rbx movq %rsi, 0x8(%rsp) movq %r14, %r15 movq %r14, %rdi movq 0x38(%rsp), %r14 movq %r14, %rsi leaq 0x10(%rsp), %rdx callq 0x15851 testl %eax, %eax jne 0x14980 cmpl $0x1, (%r14) jne 0x14aed movq %r13, 0x8(%rsp) movl $0x1, 0x10(%rsp) movq $0x1, 0x18(%rsp) leaq 0x8(%rsp), %rax movq %rax, 0x20(%rsp) movq %r14, %rdi movq %r15, %r14 movq %r15, %rsi leaq 0x10(%rsp), %rdx callq 0x15775 jmp 0x14b20 movq %r13, 0x8(%rsp) movl $0x1, 0x10(%rsp) movq $0x1, 0x18(%rsp) leaq 0x8(%rsp), %rax movq %rax, 0x20(%rsp) movq %r14, %rdi movq %r15, %r14 movq %r15, %rsi leaq 0x10(%rsp), %rdx callq 0x157e3 testl %eax, %eax movq %rbx, %rsi movq 0x28(%rsp), %rbx movq 0x30(%rsp), %r15 jne 0x14980 incq %rbp cmpq %rbp, %r15 jne 0x14a18 xorl %r12d, %r12d jmp 0x14983 movl $0xfffffffa, %r12d # imm = 0xFFFFFFFA jmp 0x14983 movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF jmp 0x14983	/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_add_int	int mbedtls_mpi_add_int( mbedtls_mpi X, const mbedtls_mpi A, mbedtls_mpi_sint b ) { mbedtls_mpi _B; mbedtls_mpi_uint p[1]; p[0] = ( b < 0 ) ? -b : b; _B.s = ( b < 0 ) ? -1 : 1; _B.n = 1; _B.p = p; return( mbedtls_mpi_add_mpi( X, A, &_B ) ); }	subq $0x28, %rsp movq %rdx, %rax negq %rax cmovsq %rdx, %rax leaq 0x8(%rsp), %rcx movq %rax, (%rcx) sarq $0x3f, %rdx orl $0x1, %edx leaq 0x10(%rsp), %rax movl %edx, (%rax) movq $0x1, 0x8(%rax) movq %rcx, 0x10(%rax) movq %rax, %rdx callq 0x15775 addq $0x28, %rsp retq	/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_cmp_abs	int mbedtls_mpi_cmp_abs( const mbedtls_mpi X, const mbedtls_mpi Y ) { size_t i, j; for( i = X->n; i > 0; i-- ) if( X->p[i - 1] != 0 ) break; for( j = Y->n; j > 0; j-- ) if( Y->p[j - 1] != 0 ) break; if( i == 0 && j == 0 ) return( 0 ); if( i > j ) return( 1 ); if( j > i ) return( -1 ); for( ; i > 0; i-- ) { if( X->p[i - 1] > Y->p[i - 1] ) return( 1 ); if( X->p[i - 1] < Y->p[i - 1] ) return( -1 ); } return( 0 ); }	movq 0x8(%rdi), %rcx testq %rcx, %rcx je 0x153f6 movq 0x10(%rdi), %rax cmpq $0x0, -0x8(%rax,%rcx,8) jne 0x153f6 decq %rcx jne 0x153e7 xorl %ecx, %ecx movq 0x8(%rsi), %rdx testq %rdx, %rdx je 0x15412 movq 0x10(%rsi), %rax cmpq $0x0, -0x8(%rax,%rdx,8) jne 0x15412 decq %rdx jne 0x15403 xorl %edx, %edx xorl %eax, %eax movq %rdx, %r8 orq %rcx, %r8 je 0x15448 cmpq %rdx, %rcx jbe 0x15427 movl $0x1, %eax retq jb 0x15443 subq $0x1, %rcx jb 0x15448 movq 0x10(%rdi), %rdx movq 0x10(%rsi), %r8 movq (%r8,%rcx,8), %r8 cmpq %r8, (%rdx,%rcx,8) ja 0x15421 jae 0x15429 movl $0xffffffff, %eax # imm = 0xFFFFFFFF retq	/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_is_prime	int mbedtls_mpi_is_prime( const mbedtls_mpi X, int (f_rng)(void , unsigned char , size_t), void *p_rng ) { int ret; mbedtls_mpi XX; XX.s = 1; XX.n = X->n; XX.p = X->p; if( mbedtls_mpi_cmp_int( &XX, 0 ) == 0 \|\| mbedtls_mpi_cmp_int( &XX, 1 ) == 0 ) return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE ); if( mbedtls_mpi_cmp_int( &XX, 2 ) == 0 ) return( 0 ); if( ( ret = mpi_check_small_factors( &XX ) ) != 0 ) { if( ret == 1 ) return( 0 ); return( ret ); } return( mpi_miller_rabin( &XX, f_rng, p_rng ) ); }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x38, %rsp movq %rdx, %rbx movq %rsi, %r14 movl $0x1, %ecx leaq 0x8(%rsp), %rax movl %ecx, (%rax) movq 0x8(%rdi), %rdx movq %rdx, 0x8(%rax) movq 0x10(%rdi), %rdx movq %rdx, 0x10(%rax) movq %rsp, %r15 movq $0x0, (%r15) leaq 0x20(%rsp), %rsi movl %ecx, (%rsi) movq $0x1, 0x8(%rsi) movq %r15, 0x10(%rsi) movq %rax, %rdi callq 0x15449 movl $0xfffffff2, %ebp # imm = 0xFFFFFFF2 testl %eax, %eax je 0x17b40 movl $0x1, %eax movq %rax, (%rsp) leaq 0x20(%rsp), %rsi movl $0x1, (%rsi) movq %rax, 0x8(%rsi) movq %r15, 0x10(%rsi) leaq 0x8(%rsp), %rdi callq 0x15449 testl %eax, %eax je 0x17b40 movq $0x2, (%rsp) leaq 0x20(%rsp), %rsi movl $0x1, (%rsi) movq $0x1, 0x8(%rsi) movq %r15, 0x10(%rsi) leaq 0x8(%rsp), %rdi callq 0x15449 xorl %ebp, %ebp testl %eax, %eax je 0x17b40 leaq 0x8(%rsp), %rdi callq 0x17b4d testl %eax, %eax je 0x17b2e cmpl $0x1, %eax je 0x17b40 jmp 0x17b3e leaq 0x8(%rsp), %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x17bf7 movl %eax, %ebp movl %ebp, %eax addq $0x38, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_mpi_gen_prime	int mbedtls_mpi_gen_prime( mbedtls_mpi X, size_t nbits, int dh_flag, int (f_rng)(void , unsigned char , size_t), void p_rng ) { int ret; size_t k, n; mbedtls_mpi_uint r; mbedtls_mpi Y; if( nbits < 3 \|\| nbits > MBEDTLS_MPI_MAX_BITS ) return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA ); mbedtls_mpi_init( &Y ); n = BITS_TO_LIMBS( nbits ); MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( X, n ciL, f_rng, p_rng ) ); k = mbedtls_mpi_bitlen( X ); if( k > nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( X, k - nbits + 1 ) ); mbedtls_mpi_set_bit( X, nbits-1, 1 ); X->p[0] \|= 1; if( dh_flag == 0 ) { while( ( ret = mbedtls_mpi_is_prime( X, f_rng, p_rng ) ) != 0 ) { if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE ) goto cleanup; MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 2 ) ); } } else { /* * An necessary condition for Y and X = 2Y + 1 to be prime * is X = 2 mod 3 (which is equivalent to Y = 2 mod 3). * Make sure it is satisfied, while keeping X = 3 mod 4 / X->p[0] \|= 2; MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, 3 ) ); if( r == 0 ) MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 8 ) ); else if( r == 1 ) MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 4 ) ); / Set Y = (X-1) / 2, which is X / 2 because X is odd / MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, X ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, 1 ) ); while( 1 ) { / * First, check small factors for X and Y * before doing Miller-Rabin on any of them / if( ( ret = mpi_check_small_factors( X ) ) == 0 && ( ret = mpi_check_small_factors( &Y ) ) == 0 && ( ret = mpi_miller_rabin( X, f_rng, p_rng ) ) == 0 && ( ret = mpi_miller_rabin( &Y, f_rng, p_rng ) ) == 0 ) { break; } if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE ) goto cleanup; / * Next candidates. We want to preserve Y = (X-1) / 2 and * Y = 1 mod 2 and Y = 2 mod 3 (eq X = 3 mod 4 and X = 2 mod 3) * so up Y by 6 and X by 12. */ MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 12 ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &Y, &Y, 6 ) ); } } cleanup: mbedtls_mpi_free( &Y ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x438, %rsp # imm = 0x438 leaq -0x2001(%rsi), %rax movl $0xfffffffc, %ebp # imm = 0xFFFFFFFC cmpq $-0x1ffe, %rax # imm = 0xE002 jb 0x183e9 movq %rcx, %r14 movl %edx, %r12d movq %rsi, %rbx movq %rdi, %r15 movq %r8, 0x8(%rsp) movl $0x1, 0x10(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x18(%rsp) movq %rsi, %r13 shrq $0x6, %r13 movl %ebx, %eax andl $0x3f, %eax cmpq $0x1, %rax sbbq $-0x1, %r13 cmpq $0x80, %r13 ja 0x1826b shlq $0x3, %r13 leaq 0x30(%rsp), %rsi movq 0x8(%rsp), %rdi movq %r13, %rdx callq *%r14 movl %eax, %ebp testl %eax, %eax jne 0x1826b leaq 0x30(%rsp), %rsi movq %r15, %rdi movq %r13, %rdx callq 0x15077 movl %eax, %ebp testl %ebp, %ebp jne 0x183ac movq %r15, %rdi callq 0x147ba subq %rbx, %rax jbe 0x18296 incq %rax movq %r15, %rdi movq %rax, %rsi callq 0x152ce testl %eax, %eax jne 0x183aa decq %rbx movq %r15, %rdi movq %rbx, %rsi movl $0x1, %edx callq 0x14706 movq 0x10(%r15), %rax movq (%rax), %rcx movq %rcx, %rdx orq $0x1, %rdx movq %rdx, (%rax) testl %r12d, %r12d je 0x18300 orq $0x3, %rcx movq %rcx, (%rax) leaq 0x28(%rsp), %rdi movl $0x3, %edx movq %r15, %rsi callq 0x16654 testl %eax, %eax jne 0x183aa movq 0x28(%rsp), %rax cmpq $0x1, %rax je 0x18356 testq %rax, %rax jne 0x18386 movq %rsp, %rax movq $0x8, (%rax) jmp 0x18360 movq %rsp, %r12 leaq 0x30(%rsp), %rbx movq 0x8(%rsp), %r13 movq %r15, %rdi movq %r14, %rsi movq %r13, %rdx callq 0x17a62 cmpl $-0xe, %eax jne 0x183aa movq $0x2, (%rsp) movl $0x1, 0x30(%rsp) movq $0x1, 0x38(%rsp) movq %r12, 0x40(%rsp) movq %r15, %rdi movq %r15, %rsi movq %rbx, %rdx callq 0x15775 testl %eax, %eax je 0x1830d jmp 0x183aa movq %rsp, %rax movq $0x4, (%rax) leaq 0x30(%rsp), %rdx movl $0x1, (%rdx) movq $0x1, 0x8(%rdx) movq %rax, 0x10(%rdx) movq %r15, %rdi movq %r15, %rsi callq 0x15775 testl %eax, %eax jne 0x183aa leaq 0x10(%rsp), %rdi movq %r15, %rsi callq 0x144b4 testl %eax, %eax jne 0x183aa leaq 0x10(%rsp), %rdi movl $0x1, %esi callq 0x152ce testl %eax, %eax je 0x183fd movl %eax, %ebp leaq 0x18(%rsp), %rbx movq 0x8(%rbx), %rdi testq %rdi, %rdi je 0x183db movq 0x18(%rsp), %rax testq %rax, %rax je 0x183d6 xorl %ecx, %ecx movq $0x0, (%rdi,%rcx,8) incq %rcx cmpq %rcx, %rax jne 0x183c6 callq 0xa030 movl $0x1, 0x10(%rsp) xorps %xmm0, %xmm0 movups %xmm0, (%rbx) movl %ebp, %eax addq $0x438, %rsp # imm = 0x438 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x10(%rsp), %r12 movq %rsp, %rbx leaq 0x30(%rsp), %r13 movq %r15, %rdi callq 0x17b4d testl %eax, %eax jne 0x18422 movq %r12, %rdi callq 0x17b4d testl %eax, %eax je 0x18498 movl %eax, %ebp cmpl $-0xe, %ebp jne 0x183ac movq $0xc, (%rsp) movl $0x1, 0x30(%rsp) movq $0x1, 0x38(%rsp) movq %rbx, 0x40(%rsp) movq %r15, %rdi movq %r15, %rsi movq %r13, %rdx callq 0x15775 testl %eax, %eax jne 0x183aa movq $0x6, (%rsp) movl $0x1, 0x30(%rsp) movq $0x1, 0x38(%rsp) movq %rbx, 0x40(%rsp) movq %r12, %rdi movq %r12, %rsi movq %r13, %rdx callq 0x15775 movl %eax, %ebp testl %eax, %eax je 0x1840a jmp 0x183ac movq %r15, %rdi movq %r14, %rsi movq 0x8(%rsp), %rbx movq %rbx, %rdx callq 0x17bf7 testl %eax, %eax je 0x184b9 movl %eax, %ebp movq %rsp, %rbx jmp 0x18424 movq %r12, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x17bf7 cmpl $-0xe, %eax movq %rsp, %rbx je 0x18429 jmp 0x183aa	/Dragonchang[P]https_client/mbedtls/library/bignum.c
mbedtls_ecdsa_sign_det	int mbedtls_ecdsa_sign_det( mbedtls_ecp_group grp, mbedtls_mpi r, mbedtls_mpi s, const mbedtls_mpi d, const unsigned char buf, size_t blen, mbedtls_md_type_t md_alg ) { int ret; mbedtls_hmac_drbg_context rng_ctx; unsigned char data[2 MBEDTLS_ECP_MAX_BYTES]; size_t grp_len = ( grp->nbits + 7 ) / 8; const mbedtls_md_info_t md_info; mbedtls_mpi h; if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL ) return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA ); mbedtls_mpi_init( &h ); mbedtls_hmac_drbg_init( &rng_ctx ); / Use private key and message hash (reduced) to initialize HMAC_DRBG / MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( d, data, grp_len ) ); MBEDTLS_MPI_CHK( derive_mpi( grp, &h, buf, blen ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &h, data + grp_len, grp_len ) ); mbedtls_hmac_drbg_seed_buf( &rng_ctx, md_info, data, 2 grp_len ); ret = mbedtls_ecdsa_sign( grp, r, s, d, buf, blen, mbedtls_hmac_drbg_random, &rng_ctx ); cleanup: mbedtls_hmac_drbg_free( &rng_ctx ); mbedtls_mpi_free( &h ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x148, %rsp # imm = 0x148 movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movq %rdx, 0x20(%rsp) movq %rsi, 0x18(%rsp) movq %rdi, %rbp movl 0x180(%rsp), %edi movq 0xb8(%rbp), %r12 callq 0xa57b testq %rax, %rax je 0x18ec9 movq %rax, %r13 movq %r14, 0x8(%rsp) movq %rbx, 0x10(%rsp) addq $0x7, %r12 shrq $0x3, %r12 leaq 0x28(%rsp), %rdi callq 0x14310 leaq 0xc8(%rsp), %r14 movq %r14, %rdi callq 0x1e484 leaq 0x40(%rsp), %rsi movq %r15, %rdi movq %r12, %rdx callq 0x15153 testl %eax, %eax jne 0x18eae leaq 0x28(%rsp), %rsi movq %rbp, %rdi movq 0x8(%rsp), %rdx movq 0x10(%rsp), %rcx callq 0x18d2f testl %eax, %eax jne 0x18eae leaq (%rsp,%r12), %rsi addq $0x40, %rsi leaq 0x28(%rsp), %rdi movq %r12, %rdx callq 0x15153 testl %eax, %eax jne 0x18eae addq %r12, %r12 leaq 0x40(%rsp), %rdx movq %r14, %rdi movq %r13, %rsi movq %r12, %rcx callq 0x1e588 leaq 0x5a07(%rip), %rax # 0x1e88f movq %rbp, %rdi movq 0x18(%rsp), %rsi movq 0x20(%rsp), %rdx movq %r15, %rcx movq 0x8(%rsp), %r8 movq 0x10(%rsp), %r9 pushq %r14 pushq %rax callq 0x18a54 addq $0x10, %rsp movl %eax, %ebx leaq 0xc8(%rsp), %rdi callq 0x1e899 leaq 0x28(%rsp), %rdi callq 0x14323 jmp 0x18ece movl $0xffffb080, %ebx # imm = 0xFFFFB080 movl %ebx, %eax addq $0x148, %rsp # imm = 0x148 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/ecdsa.c
mbedtls_ecdsa_write_signature	int mbedtls_ecdsa_write_signature( mbedtls_ecdsa_context ctx, mbedtls_md_type_t md_alg, const unsigned char hash, size_t hlen, unsigned char sig, size_t slen, int (f_rng)(void , unsigned char , size_t), void p_rng ) { int ret; mbedtls_mpi r, s; mbedtls_mpi_init( &r ); mbedtls_mpi_init( &s ); #if defined(MBEDTLS_ECDSA_DETERMINISTIC) (void) f_rng; (void) p_rng; MBEDTLS_MPI_CHK( mbedtls_ecdsa_sign_det( &ctx->grp, &r, &s, &ctx->d, hash, hlen, md_alg ) ); #else (void) md_alg; MBEDTLS_MPI_CHK( mbedtls_ecdsa_sign( &ctx->grp, &r, &s, &ctx->d, hash, hlen, f_rng, p_rng ) ); #endif MBEDTLS_MPI_CHK( ecdsa_signature_to_asn1( &r, &s, sig, slen ) ); cleanup: mbedtls_mpi_free( &r ); mbedtls_mpi_free( &s ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xe8, %rsp movq %r9, 0x18(%rsp) movq %r8, 0x10(%rsp) movq %rcx, %r15 movq %rdx, %r12 movl %esi, %ebp movq %rdi, %r13 leaq 0x38(%rsp), %rbx movq %rbx, %rdi callq 0x14310 leaq 0x20(%rsp), %r14 movq %r14, %rdi callq 0x14310 leaq 0xf8(%r13), %rcx movl %ebp, (%rsp) movq %r13, %rdi movq %rbx, %rsi movq %r14, %rdx movq %r12, %r8 movq %r15, %r9 callq 0x18db1 movl %eax, %ebp testl %eax, %eax je 0x1918e leaq 0x38(%rsp), %rdi callq 0x14323 leaq 0x20(%rsp), %rdi callq 0x14323 movl %ebp, %eax addq $0xe8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbx leaq 0xdd(%rsp), %rax leaq 0x8(%rsp), %rdi movq %rax, (%rdi) leaq 0x50(%rsp), %rsi leaq 0x20(%rsp), %rdx callq 0x23a02 movl %eax, %ebp testl %eax, %eax js 0x19166 leaq 0x8(%rsp), %rdi leaq 0x50(%rsp), %rsi leaq 0x38(%rsp), %rdx callq 0x23a02 movl %eax, %r15d testl %eax, %eax js 0x19233 addl %ebp, %r15d leaq 0x8(%rsp), %rdi leaq 0x50(%rsp), %rsi movq %r15, %rdx callq 0x23838 movl %eax, %ebp testl %eax, %eax js 0x19166 leaq 0x8(%rsp), %rdi leaq 0x50(%rsp), %rsi movl $0x30, %edx callq 0x239a5 testl %eax, %eax js 0x1923b movl %ebp, %ecx movl %eax, %eax addq %rax, %r15 addq %rcx, %r15 movq 0x8(%rsp), %rsi movq %r14, %rdi movq %r15, %rdx callq 0xa110 movq %r15, (%rbx) xorl %ebp, %ebp jmp 0x19166 movl %r15d, %ebp jmp 0x19166 movl %eax, %ebp jmp 0x19166	/Dragonchang[P]https_client/mbedtls/library/ecdsa.c
mbedtls_ecp_tls_write_point	int mbedtls_ecp_tls_write_point( const mbedtls_ecp_group grp, const mbedtls_ecp_point pt, int format, size_t olen, unsigned char buf, size_t blen ) { int ret; /* * buffer length must be at least one, for our length byte / if( blen < 1 ) return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA ); if( ( ret = mbedtls_ecp_point_write_binary( grp, pt, format, olen, buf + 1, blen - 1) ) != 0 ) return( ret ); / * write length to the first byte and update total length / buf[0] = (unsigned char) olen; ++*olen; return( 0 ); }	testq %r9, %r9 je 0x199ad pushq %r14 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %rbx incq %r8 decq %r9 callq 0x1978f testl %eax, %eax jne 0x199a5 movb (%rbx), %al movb %al, (%r14) incq (%rbx) xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r14 retq movl $0xffffb080, %eax # imm = 0xFFFFB080 retq	/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_tls_read_group	int mbedtls_ecp_tls_read_group( mbedtls_ecp_group grp, const unsigned char buf, size_t len ) { uint16_t tls_id; const mbedtls_ecp_curve_info curve_info; /* * We expect at least three bytes (see below) / if( len < 3 ) return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA ); / * First byte is curve_type; only named_curve is handled / if( (buf)++ != MBEDTLS_ECP_TLS_NAMED_CURVE ) return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA ); / * Next two bytes are the namedcurve value / tls_id = (buf)++; tls_id <<= 8; tls_id \|= (*buf)++; if( ( curve_info = mbedtls_ecp_curve_info_from_tls_id( tls_id ) ) == NULL ) return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE ); return mbedtls_ecp_group_load( grp, curve_info->grp_id ); }	movl $0xffffb080, %eax # imm = 0xFFFFB080 cmpq $0x3, %rdx jb 0x19a12 movq (%rsi), %rcx leaq 0x1(%rcx), %rdx movq %rdx, (%rsi) cmpb $0x3, (%rcx) jne 0x19a12 leaq 0x2(%rcx), %rax movq %rax, (%rsi) movzbl 0x1(%rcx), %eax shll $0x8, %eax leaq 0x3(%rcx), %rdx movq %rdx, (%rsi) movzbl 0x2(%rcx), %ecx orl %eax, %ecx leaq 0x207c1(%rip), %rax # 0x3a1b0 cmpw %cx, 0x4(%rax) je 0x19a01 cmpl $0x0, 0x10(%rax) leaq 0x10(%rax), %rax jne 0x199ef xorl %eax, %eax testq %rax, %rax je 0x19a0d movl (%rax), %esi jmp 0x1cee4 movl $0xffffb180, %eax # imm = 0xFFFFB180 retq	/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_gen_keypair_base	int mbedtls_ecp_gen_keypair_base( mbedtls_ecp_group grp, const mbedtls_ecp_point G, mbedtls_mpi d, mbedtls_ecp_point Q, int (f_rng)(void , unsigned char , size_t), void p_rng ) { int ret; size_t n_size = ( grp->nbits + 7 ) / 8; #if defined(ECP_MONTGOMERY) if( ecp_get_type( grp ) == ECP_TYPE_MONTGOMERY ) { /* [M225] page 5 / size_t b; do { MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( d, n_size, f_rng, p_rng ) ); } while( mbedtls_mpi_bitlen( d ) == 0); / Make sure the most significant bit is nbits / b = mbedtls_mpi_bitlen( d ) - 1; / mbedtls_mpi_bitlen is one-based / if( b > grp->nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( d, b - grp->nbits ) ); else MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, grp->nbits, 1 ) ); / Make sure the last three bits are unset / MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 0, 0 ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 1, 0 ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_set_bit( d, 2, 0 ) ); } else #endif / ECP_MONTGOMERY / #if defined(ECP_SHORTWEIERSTRASS) if( ecp_get_type( grp ) == ECP_TYPE_SHORT_WEIERSTRASS ) { / SEC1 3.2.1: Generate d such that 1 <= n < N / int count = 0; unsigned char rnd[MBEDTLS_ECP_MAX_BYTES]; / * Match the procedure given in RFC 6979 (deterministic ECDSA): * - use the same byte ordering; * - keep the leftmost nbits bits of the generated octet string; * - try until result is in the desired range. * This also avoids any biais, which is especially important for ECDSA. / do { MBEDTLS_MPI_CHK( f_rng( p_rng, rnd, n_size ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( d, rnd, n_size ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( d, 8 n_size - grp->nbits ) ); /* * Each try has at worst a probability 1/2 of failing (the msb has * a probability 1/2 of being 0, and then the result will be < N), * so after 30 tries failure probability is a most 2*(-30). * For most curves, 1 try is enough with overwhelming probability, * since N starts with a lot of 1s in binary, but some curves * such as secp224k1 are actually very close to the worst case. / if( ++count > 30 ) return( MBEDTLS_ERR_ECP_RANDOM_FAILED ); } while( mbedtls_mpi_cmp_int( d, 1 ) < 0 \|\| mbedtls_mpi_cmp_mpi( d, &grp->N ) >= 0 ); } else #endif / ECP_SHORTWEIERSTRASS */ return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA ); cleanup: if( ret != 0 ) return( ret ); return( mbedtls_ecp_mul( grp, Q, d, G, f_rng, p_rng ) ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %rdx, %r12 movq 0x60(%rdi), %rax movl $0xffffb080, %edx # imm = 0xFFFFB080 testq %rax, %rax je 0x1b647 movq %r9, %rbx movq %r8, %r14 movq %rsi, %rbp movq %rcx, 0x28(%rsp) movq 0xb8(%rdi), %r13 addq $0x7, %r13 movq %r13, %r15 shrq $0x3, %r15 cmpq $0x0, 0x78(%rdi) je 0x1b540 testq %rax, %rax je 0x1b647 cmpq $0x0, 0x78(%rdi) je 0x1b647 movq %rdi, 0x8(%rsp) leaq 0x30(%rsp), %rsi movq %rbx, %rdi movq %r15, %rdx callq %r14 movl $0x6, %ecx testl %eax, %eax jne 0x1b60f movq %rbx, 0x10(%rsp) movq %rbp, 0x18(%rsp) andq $-0x8, %r13 movq 0x8(%rsp), %rax addq $0x98, %rax movq %rax, 0x20(%rsp) movl $0x1f, %ebp leaq 0x30(%rsp), %rsi movq %r12, %rdi movq %rsi, %rbx movq %r15, %rdx callq 0x15077 testl %eax, %eax jne 0x1b531 movq %r13, %rsi movq 0x8(%rsp), %rax subq 0xb8(%rax), %rsi movq %r12, %rdi callq 0x152ce testl %eax, %eax jne 0x1b531 decl %ebp je 0x1b5f8 movl $0x1, %esi movq %r12, %rdi callq 0x154da testl %eax, %eax js 0x1b51c movq %r12, %rdi movq 0x20(%rsp), %rsi callq 0x15449 testl %eax, %eax js 0x1b601 movq 0x10(%rsp), %rdi movq %rbx, %rsi movq %r15, %rdx callq %r14 movq %rbx, %rsi testl %eax, %eax je 0x1b4c1 movq 0x18(%rsp), %rbp movl $0x6, %ecx jmp 0x1b60a movq %rdi, 0x8(%rsp) movl $0x6, %r13d movq %r12, %rdi movq %r15, %rsi movq %r14, %rdx movq %rbx, %rcx callq 0x1731e testl %eax, %eax jne 0x1b5e6 movq %r12, %rdi callq 0x147ba testq %rax, %rax je 0x1b54b movq %r12, %rdi callq 0x147ba decq %rax movq 0x8(%rsp), %rcx movq 0xb8(%rcx), %rsi movq %r12, %rdi subq %rsi, %rax jbe 0x1b59a movq %rax, %rsi callq 0x152ce jmp 0x1b5a4 movl $0x1, %edx callq 0x14706 testl %eax, %eax jne 0x1b5e6 movq %r12, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x14706 testl %eax, %eax jne 0x1b5e6 movl $0x1, %esi movq %r12, %rdi xorl %edx, %edx callq 0x14706 testl %eax, %eax jne 0x1b5e6 movl $0x2, %esi movq %r12, %rdi xorl %edx, %edx callq 0x14706 testl %eax, %eax movl $0x6, %r13d cmovel %eax, %r13d testl %r13d, %r13d movq 0x8(%rsp), %rdi je 0x1b629 cmpl $0x6, %r13d je 0x1b629 jmp 0x1b647 xorl %eax, %eax movl $0x1, %ecx jmp 0x1b605 xorl %eax, %eax xorl %ecx, %ecx movq 0x18(%rsp), %rbp movq 0x10(%rsp), %rbx cmpl $0x6, %ecx je 0x1b624 movl $0xffffb300, %edx # imm = 0xFFFFB300 testl %ecx, %ecx movq 0x8(%rsp), %rdi je 0x1b629 jmp 0x1b647 movq 0x8(%rsp), %rdi movl %eax, %edx testl %eax, %eax jne 0x1b647 movq 0x28(%rsp), %rsi movq %r12, %rdx movq %rbp, %rcx movq %r14, %r8 movq %rbx, %r9 callq 0x19a65 movl %eax, %edx movl %edx, %eax addq $0x78, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/ecp.c
mbedtls_ecp_self_test	int mbedtls_ecp_self_test( int verbose ) { int ret; size_t i; mbedtls_ecp_group grp; mbedtls_ecp_point R, P; mbedtls_mpi m; unsigned long add_c_prev, dbl_c_prev, mul_c_prev; /* exponents especially adapted for secp192r1 / const char exponents[] = { "000000000000000000000000000000000000000000000001", /* one / "FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22830", / N - 1 / "5EA6F389A38B8BC81E767753B15AA5569E1782E30ABE7D25", / random / "400000000000000000000000000000000000000000000000", / one and zeros / "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", / all ones / "555555555555555555555555555555555555555555555555", / 101010... / }; mbedtls_ecp_group_init( &grp ); mbedtls_ecp_point_init( &R ); mbedtls_ecp_point_init( &P ); mbedtls_mpi_init( &m ); / Use secp192r1 if available, or any available curve / #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED) MBEDTLS_MPI_CHK( mbedtls_ecp_group_load( &grp, MBEDTLS_ECP_DP_SECP192R1 ) ); #else MBEDTLS_MPI_CHK( mbedtls_ecp_group_load( &grp, mbedtls_ecp_curve_list()->grp_id ) ); #endif if( verbose != 0 ) mbedtls_printf( " ECP test #1 (constant op_count, base point G): " ); / Do a dummy multiplication first to trigger precomputation / MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &m, 2 ) ); MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &P, &m, &grp.G, NULL, NULL ) ); add_count = 0; dbl_count = 0; mul_count = 0; MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[0] ) ); MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) ); for( i = 1; i < sizeof( exponents ) / sizeof( exponents[0] ); i++ ) { add_c_prev = add_count; dbl_c_prev = dbl_count; mul_c_prev = mul_count; add_count = 0; dbl_count = 0; mul_count = 0; MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[i] ) ); MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) ); if( add_count != add_c_prev \|\| dbl_count != dbl_c_prev \|\| mul_count != mul_c_prev ) { if( verbose != 0 ) mbedtls_printf( "failed (%u)\n", (unsigned int) i ); ret = 1; goto cleanup; } } if( verbose != 0 ) mbedtls_printf( "passed\n" ); if( verbose != 0 ) mbedtls_printf( " ECP test #2 (constant op_count, other point): " ); / We computed P = 2G last time, use it */ add_count = 0; dbl_count = 0; mul_count = 0; MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[0] ) ); MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &P, NULL, NULL ) ); for( i = 1; i < sizeof( exponents ) / sizeof( exponents[0] ); i++ ) { add_c_prev = add_count; dbl_c_prev = dbl_count; mul_c_prev = mul_count; add_count = 0; dbl_count = 0; mul_count = 0; MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[i] ) ); MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &P, NULL, NULL ) ); if( add_count != add_c_prev \|\| dbl_count != dbl_c_prev \|\| mul_count != mul_c_prev ) { if( verbose != 0 ) mbedtls_printf( "failed (%u)\n", (unsigned int) i ); ret = 1; goto cleanup; } } if( verbose != 0 ) mbedtls_printf( "passed\n" ); cleanup: if( ret < 0 && verbose != 0 ) mbedtls_printf( "Unexpected error, return code = %08X\n", ret ); mbedtls_ecp_group_free( &grp ); mbedtls_ecp_point_free( &R ); mbedtls_ecp_point_free( &P ); mbedtls_mpi_free( &m ); if( verbose != 0 ) mbedtls_printf( "\n" ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1b8, %rsp # imm = 0x1B8 movl %edi, %ebx leaq 0xc0(%rsp), %r14 movl $0xf8, %edx movq %r14, %rdi xorl %esi, %esi callq 0xa0c0 leaq 0x30(%rsp), %rdi callq 0x14310 leaq 0x48(%rsp), %r15 movq %r15, %rdi callq 0x14310 leaq 0x60(%rsp), %r12 movq %r12, %rdi callq 0x14310 leaq 0x78(%rsp), %rdi callq 0x14310 leaq 0x90(%rsp), %r13 movq %r13, %rdi callq 0x14310 leaq 0xa8(%rsp), %rdi callq 0x14310 leaq 0x18(%rsp), %rdi callq 0x14310 movq %r14, %rdi movl $0x1, %esi callq 0x1cee4 testl %eax, %eax jne 0x1b932 testl %ebx, %ebx je 0x1b896 leaq 0x10517(%rip), %rdi # 0x2bda6 xorl %eax, %eax callq 0xa0a0 leaq 0x18(%rsp), %rdi movl $0x2, %esi callq 0x1468f testl %eax, %eax jne 0x1b932 leaq 0x110(%rsp), %r14 leaq 0xc0(%rsp), %rdi leaq 0x78(%rsp), %rsi leaq 0x18(%rsp), %rdx movq %r14, %rcx xorl %r8d, %r8d xorl %r9d, %r9d callq 0x19a65 testl %eax, %eax jne 0x1b932 xorl %eax, %eax movq %rax, 0x2086e(%rip) # 0x3c150 movq %rax, 0x2086f(%rip) # 0x3c158 movq %rax, 0x20870(%rip) # 0x3c160 leaq 0x10389(%rip), %rdx # 0x2bc80 leaq 0x18(%rsp), %rdi movl $0x10, %esi callq 0x14836 testl %eax, %eax jne 0x1b932 leaq 0xc0(%rsp), %rdi leaq 0x30(%rsp), %rsi leaq 0x18(%rsp), %rdx movq %r14, %rcx xorl %r8d, %r8d xorl %r9d, %r9d callq 0x19a65 testl %eax, %eax je 0x1b9be movl %eax, %ebp testl %ebx, %ebx je 0x1b94c testl %ebp, %ebp jns 0x1b94c leaq 0x1003b(%rip), %rdi # 0x2b97e movl %ebp, %esi xorl %eax, %eax callq 0xa0a0 leaq 0xc0(%rsp), %rdi callq 0x1956b leaq 0x30(%rsp), %rdi callq 0x14323 movq %r15, %rdi callq 0x14323 movq %r12, %rdi callq 0x14323 leaq 0x78(%rsp), %rdi callq 0x14323 movq %r13, %rdi callq 0x14323 leaq 0xa8(%rsp), %rdi callq 0x14323 leaq 0x18(%rsp), %rdi callq 0x14323 testl %ebx, %ebx je 0x1b9aa movl $0xa, %edi callq 0xa040 movl %ebp, %eax addq $0x1b8, %rsp # imm = 0x1B8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x1, %r14d leaq 0x18(%rsp), %r15 movq 0x20780(%rip), %r13 # 0x3c150 movq 0x20781(%rip), %rax # 0x3c158 movq %rax, 0x10(%rsp) movq 0x2077d(%rip), %rax # 0x3c160 movq %rax, 0x8(%rsp) xorl %eax, %eax movq %rax, 0x2075f(%rip) # 0x3c150 movq %rax, 0x20760(%rip) # 0x3c158 movq %rax, 0x20761(%rip) # 0x3c160 leaq 0x1e86a(%rip), %rax # 0x3a270 movq (%rax,%r14,8), %rdx movq %r15, %rdi movl $0x10, %esi callq 0x14836 testl %eax, %eax jne 0x1bbf2 leaq 0xc0(%rsp), %rdi leaq 0x30(%rsp), %rsi movq %r15, %r12 movq %r15, %rdx leaq 0x110(%rsp), %rcx xorl %r8d, %r8d xorl %r9d, %r9d callq 0x19a65 testl %eax, %eax jne 0x1bbf2 cmpq %r13, 0x206fc(%rip) # 0x3c150 jne 0x1bc0b movq 0x10(%rsp), %rax cmpq %rax, 0x206f2(%rip) # 0x3c158 jne 0x1bc0b movq 0x8(%rsp), %rax cmpq %rax, 0x206e8(%rip) # 0x3c160 jne 0x1bc0b incq %r14 cmpq $0x6, %r14 movq %r12, %r15 jne 0x1b9c9 testl %ebx, %ebx je 0x1baac leaq 0xea08(%rip), %rdi # 0x2a4a1 callq 0xa050 leaq 0x10340(%rip), %rdi # 0x2bde5 xorl %eax, %eax callq 0xa0a0 xorl %eax, %eax movq %rax, 0x2069b(%rip) # 0x3c150 movq %rax, 0x2069c(%rip) # 0x3c158 movq %rax, 0x2069d(%rip) # 0x3c160 leaq 0x101b6(%rip), %rdx # 0x2bc80 leaq 0x18(%rsp), %rdi movl $0x10, %esi callq 0x14836 testl %eax, %eax leaq 0x48(%rsp), %r15 leaq 0x60(%rsp), %r12 leaq 0x90(%rsp), %r13 jne 0x1b932 leaq 0xc0(%rsp), %rdi leaq 0x30(%rsp), %rsi leaq 0x18(%rsp), %rdx leaq 0x78(%rsp), %rcx xorl %r8d, %r8d xorl %r9d, %r9d callq 0x19a65 testl %eax, %eax jne 0x1b932 movl $0x1, %r14d leaq 0x18(%rsp), %r15 movq 0x20621(%rip), %r13 # 0x3c150 movq 0x20622(%rip), %rax # 0x3c158 movq %rax, 0x10(%rsp) movq 0x2061e(%rip), %rax # 0x3c160 movq %rax, 0x8(%rsp) xorl %eax, %eax movq %rax, 0x20600(%rip) # 0x3c150 movq %rax, 0x20601(%rip) # 0x3c158 movq %rax, 0x20602(%rip) # 0x3c160 leaq 0x1e70b(%rip), %rax # 0x3a270 movq (%rax,%r14,8), %rdx movq %r15, %rdi movl $0x10, %esi callq 0x14836 testl %eax, %eax jne 0x1bbf2 leaq 0xc0(%rsp), %rdi leaq 0x30(%rsp), %rsi movq %r15, %r12 movq %r15, %rdx leaq 0x78(%rsp), %rcx xorl %r8d, %r8d xorl %r9d, %r9d callq 0x19a65 testl %eax, %eax jne 0x1bbf2 cmpq %r13, 0x205a8(%rip) # 0x3c150 jne 0x1bc40 movq 0x10(%rsp), %rax cmpq %rax, 0x2059e(%rip) # 0x3c158 jne 0x1bc40 movq 0x8(%rsp), %rax cmpq %rax, 0x20594(%rip) # 0x3c160 jne 0x1bc40 incq %r14 cmpq $0x6, %r14 movq %r12, %r15 jne 0x1bb28 xorl %ebp, %ebp testl %ebx, %ebx je 0x1bbf4 leaq 0xe8b6(%rip), %rdi # 0x2a4a1 callq 0xa050 jmp 0x1bbf4 movl %eax, %ebp leaq 0x48(%rsp), %r15 leaq 0x60(%rsp), %r12 leaq 0x90(%rsp), %r13 jmp 0x1b934 movl $0x1, %ebp testl %ebx, %ebx leaq 0x48(%rsp), %r15 leaq 0x60(%rsp), %r12 leaq 0x90(%rsp), %r13 je 0x1b934 leaq 0x101a7(%rip), %rdi # 0x2bdd8 movl %r14d, %esi xorl %eax, %eax callq 0xa0a0 jmp 0x1b934 movl $0x1, %ebp testl %ebx, %ebx je 0x1bbf4 leaq 0x10188(%rip), %rdi # 0x2bdd8 movl %r14d, %esi xorl %eax, %eax callq 0xa0a0 jmp 0x1bbf4	/Dragonchang[P]https_client/mbedtls/library/ecp.c
ecp_safe_invert_jac	static int ecp_safe_invert_jac( const mbedtls_ecp_group grp, mbedtls_ecp_point Q, unsigned char inv ) { int ret; unsigned char nonzero; mbedtls_mpi mQY; mbedtls_mpi_init( &mQY ); /* Use the fact that -Q.Y mod P = P - Q.Y unless Q.Y == 0 */ MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &mQY, &grp->P, &Q->Y ) ); nonzero = mbedtls_mpi_cmp_int( &Q->Y, 0 ) != 0; MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &Q->Y, &mQY, inv & nonzero ) ); cleanup: mbedtls_mpi_free( &mQY ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x18, %rsp movl %edx, %ebp movq %rsi, %rbx movq %rdi, %r14 movq %rsp, %r15 movq %r15, %rdi callq 0x14310 addq $0x8, %r14 addq $0x18, %rbx movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x157e3 movl %eax, %r14d testl %eax, %eax jne 0x1c380 movq %rbx, %rdi xorl %esi, %esi callq 0x154da andb $0x1, %bpl testl %eax, %eax movzbl %bpl, %ecx cmovel %eax, %ecx movzbl %cl, %edx movq %rsp, %rsi movq %rbx, %rdi callq 0x1457a movl %eax, %r14d movq %rsp, %rdi callq 0x14323 movl %r14d, %eax addq $0x18, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/ecp.c
ecp_mod_p224k1	static int ecp_mod_p224k1( mbedtls_mpi *N ) { static mbedtls_mpi_uint Rp[] = { BYTES_TO_T_UINT_8( 0x93, 0x1A, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 ) }; #if defined(MBEDTLS_HAVE_INT64) return( ecp_mod_koblitz( N, Rp, 4, 1, 32, 0xFFFFFFFF ) ); #else return( ecp_mod_koblitz( N, Rp, 224 / 8 / sizeof( mbedtls_mpi_uint ), 0, 0, 0 ) ); #endif }	leaq 0x1df4f(%rip), %rsi # 0x3c0e8 movl $0x4, %edx movl $0x1, %ecx movl $0x20, %r8d movl $0xffffffff, %r9d # imm = 0xFFFFFFFF jmp 0x1e2a7	/Dragonchang[P]https_client/mbedtls/library/ecp_curves.c
mbedtls_hmac_drbg_seed	int mbedtls_hmac_drbg_seed( mbedtls_hmac_drbg_context ctx, const mbedtls_md_info_t md_info, int (f_entropy)(void , unsigned char , size_t), void p_entropy, const unsigned char custom, size_t len ) { int ret; size_t entropy_len, md_size; if( ( ret = mbedtls_md_setup( &ctx->md_ctx, md_info, 1 ) ) != 0 ) return( ret ); md_size = mbedtls_md_get_size( md_info ); / * Set initial working state. * Use the V memory location, which is currently all 0, to initialize the * MD context with an all-zero key. Then set V to its initial value. / mbedtls_md_hmac_starts( &ctx->md_ctx, ctx->V, md_size ); memset( ctx->V, 0x01, md_size ); ctx->f_entropy = f_entropy; ctx->p_entropy = p_entropy; ctx->reseed_interval = MBEDTLS_HMAC_DRBG_RESEED_INTERVAL; / * See SP800-57 5.6.1 (p. 65-66) for the security strength provided by * each hash function, then according to SP800-90A rev1 10.1 table 2, * min_entropy_len (in bits) is security_strength. * * (This also matches the sizes used in the NIST test vectors.) / entropy_len = md_size <= 20 ? 16 : / 160-bits hash -> 128 bits / md_size <= 28 ? 24 : / 224-bits hash -> 192 bits / 32; / better (256+) -> 256 bits / / * For initialisation, use more entropy to emulate a nonce * (Again, matches test vectors.) / ctx->entropy_len = entropy_len 3 / 2; if( ( ret = mbedtls_hmac_drbg_reseed( ctx, custom, len ) ) != 0 ) return( ret ); ctx->entropy_len = entropy_len; return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r9, %r14 movq %r8, %r15 movq %rcx, %r12 movq %rdx, %r13 movq %rsi, %rbp movq %rdi, %rbx movl $0x1, %edx callq 0xa642 testl %eax, %eax jne 0x1e75e movq %rbp, %rdi callq 0xab31 movzbl %al, %ebp movq %r14, (%rsp) leaq 0x18(%rbx), %r14 movq %rbx, %rdi movq %r14, %rsi movq %rbp, %rdx callq 0xa841 movq %r14, %rdi movl $0x1, %esi movq %rbp, %rdx callq 0xa0c0 movq %r13, 0x70(%rbx) movq %r12, 0x78(%rbx) movl $0x2710, 0x6c(%rbx) # imm = 0x2710 xorl %eax, %eax cmpb $0x1d, %bpl setae %al cmpb $0x15, %bpl leaq 0x18(,%rax,8), %rax movl $0x10, %r14d cmovaeq %rax, %r14 movl %r14d, %eax shrl %eax addq %r14, %rax movq %rax, 0x60(%rbx) movq %rbx, %rdi movq %r15, %rsi movq (%rsp), %rdx callq 0x1e5f7 testl %eax, %eax jne 0x1e75e movq %r14, 0x60(%rbx) xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c
mbedtls_md5_update	void mbedtls_md5_update( mbedtls_md5_context ctx, const unsigned char input, size_t ilen ) { size_t fill; uint32_t left; if( ilen == 0 ) return; left = ctx->total[0] & 0x3F; fill = 64 - left; ctx->total[0] += (uint32_t) ilen; ctx->total[0] &= 0xFFFFFFFF; if( ctx->total[0] < (uint32_t) ilen ) ctx->total[1]++; if( left && ilen >= fill ) { memcpy( (void ) (ctx->buffer + left), input, fill ); mbedtls_md5_process( ctx, ctx->buffer ); input += fill; ilen -= fill; left = 0; } while( ilen >= 64 ) { mbedtls_md5_process( ctx, input ); input += 64; ilen -= 64; } if( ilen > 0 ) { memcpy( (void ) (ctx->buffer + left), input, ilen ); } }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax testq %rdx, %rdx je 0x1f574 movq %rsi, %rbx movq %rdi, %r14 movl (%rdi), %ecx movl %ecx, %eax andl $0x3f, %eax movl %edx, %esi addl %ecx, %esi movl %esi, (%rdi) jae 0x1f4e3 incl 0x4(%r14) xorl %ebp, %ebp testl %eax, %eax je 0x1f501 movl $0x40, %r12d subq %rax, %r12 movq %rdx, %r15 subq %r12, %r15 jae 0x1f506 movq %rdx, %r15 movl %eax, %ebp jmp 0x1f52d movq %rdx, %r15 jmp 0x1f52d leaq 0x18(%r14), %r13 movl %eax, %eax leaq (%r14,%rax), %rdi addq $0x18, %rdi movq %rbx, %rsi movq %r12, %rdx callq 0xa110 movq %r14, %rdi movq %r13, %rsi callq 0x1ed01 addq %r12, %rbx cmpq $0x40, %r15 jb 0x1f54c movq %r14, %rdi movq %rbx, %rsi callq 0x1ed01 addq $0x40, %rbx addq $-0x40, %r15 cmpq $0x3f, %r15 ja 0x1f533 testq %r15, %r15 je 0x1f574 movl %ebp, %eax leaq (%r14,%rax), %rdi addq $0x18, %rdi movq %rbx, %rsi movq %r15, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0xa110 addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/md5.c
mbedtls_md5_finish	void mbedtls_md5_finish( mbedtls_md5_context *ctx, unsigned char output[16] ) { uint32_t last, padn; uint32_t high, low; unsigned char msglen[8]; high = ( ctx->total[0] >> 29 ) \| ( ctx->total[1] << 3 ); low = ( ctx->total[0] << 3 ); PUT_UINT32_LE( low, msglen, 0 ); PUT_UINT32_LE( high, msglen, 4 ); last = ctx->total[0] & 0x3F; padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); mbedtls_md5_update( ctx, md5_padding, padn ); mbedtls_md5_update( ctx, msglen, 8 ); PUT_UINT32_LE( ctx->state[0], output, 0 ); PUT_UINT32_LE( ctx->state[1], output, 4 ); PUT_UINT32_LE( ctx->state[2], output, 8 ); PUT_UINT32_LE( ctx->state[3], output, 12 ); }	pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rsi, %rbx movq %rdi, %r14 movl (%rdi), %eax movl 0x4(%rdi), %ecx shldl $0x3, %eax, %ecx leal (,%rax,8), %edx leaq 0x8(%rsp), %r15 movb %dl, (%r15) movl %eax, %edx shrl $0x5, %edx movb %dl, 0x1(%r15) movl %eax, %edx shrl $0xd, %edx movb %dl, 0x2(%r15) movl %eax, %edx shrl $0x15, %edx movb %dl, 0x3(%r15) movb %cl, 0x4(%r15) movb %ch, 0xd(%rsp) movl %ecx, %edx shrl $0x10, %edx movb %dl, 0x6(%r15) shrl $0x18, %ecx movb %cl, 0x7(%r15) andl $0x3f, %eax xorl %edx, %edx cmpl $0x38, %eax setae %dl shll $0x6, %edx orl $0x38, %edx subl %eax, %edx leaq 0xd699(%rip), %rsi # 0x2cc90 callq 0x1f4b6 movl $0x8, %edx movq %r14, %rdi movq %r15, %rsi callq 0x1f4b6 movb 0x8(%r14), %al movb %al, (%rbx) movb 0x9(%r14), %al movb %al, 0x1(%rbx) movb 0xa(%r14), %al movb %al, 0x2(%rbx) movb 0xb(%r14), %al movb %al, 0x3(%rbx) movb 0xc(%r14), %al movb %al, 0x4(%rbx) movb 0xd(%r14), %al movb %al, 0x5(%rbx) movb 0xe(%r14), %al movb %al, 0x6(%rbx) movb 0xf(%r14), %al movb %al, 0x7(%rbx) movb 0x10(%r14), %al movb %al, 0x8(%rbx) movb 0x11(%r14), %al movb %al, 0x9(%rbx) movb 0x12(%r14), %al movb %al, 0xa(%rbx) movb 0x13(%r14), %al movb %al, 0xb(%rbx) movb 0x14(%r14), %al movb %al, 0xc(%rbx) movb 0x15(%r14), %al movb %al, 0xd(%rbx) movb 0x16(%r14), %al movb %al, 0xe(%rbx) movb 0x17(%r14), %al movb %al, 0xf(%rbx) addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq	/Dragonchang[P]https_client/mbedtls/library/md5.c
mbedtls_md5_self_test	int mbedtls_md5_self_test( int verbose ) { int i; unsigned char md5sum[16]; for( i = 0; i < 7; i++ ) { if( verbose != 0 ) mbedtls_printf( " MD5 test #%d: ", i + 1 ); mbedtls_md5( md5_test_buf[i], md5_test_buflen[i], md5sum ); if( memcmp( md5sum, md5_test_sum[i], 16 ) != 0 ) { if( verbose != 0 ) mbedtls_printf( "failed\n" ); return( 1 ); } if( verbose != 0 ) mbedtls_printf( "passed\n" ); } if( verbose != 0 ) mbedtls_printf( "\n" ); return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edi, %ebx movl $0x1, %ebp leaq 0xd503(%rip), %r12 # 0x2cc20 leaq 0xd29c(%rip), %r14 # 0x2c9c0 movq %rsp, %r15 xorl %r13d, %r13d testl %ebx, %ebx je 0x1f73e leaq 0xd26b(%rip), %rdi # 0x2c9a0 movl %ebp, %esi xorl %eax, %eax callq 0xa0a0 leaq 0xd4bb(%rip), %rax # 0x2cc00 movslq (%r13,%rax), %rsi movq %r14, %rdi movq %r15, %rdx callq 0x1f685 movdqu (%r12), %xmm0 pcmpeqb (%rsp), %xmm0 pmovmskb %xmm0, %eax cmpl $0xffff, %eax # imm = 0xFFFF jne 0x1f7a1 testl %ebx, %ebx je 0x1f77b leaq 0xad2b(%rip), %rdi # 0x2a4a1 callq 0xa050 incl %ebp addq $0x10, %r12 addq $0x4, %r13 addq $0x51, %r14 cmpq $0x1c, %r13 jne 0x1f72a xorl %ebp, %ebp testl %ebx, %ebx je 0x1f7b6 movl $0xa, %edi callq 0xa040 jmp 0x1f7b6 movl $0x1, %ebp testl %ebx, %ebx je 0x1f7b6 leaq 0xb795(%rip), %rdi # 0x2af46 callq 0xa050 movl %ebp, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop	/Dragonchang[P]https_client/mbedtls/library/md5.c
pem_pbkdf1	static void pem_pbkdf1( unsigned char key, size_t keylen, unsigned char iv, const unsigned char pwd, size_t pwdlen ) { mbedtls_md5_context md5_ctx; unsigned char md5sum[16]; size_t use_len; mbedtls_md5_init( &md5_ctx ); / * key[ 0..15] = MD5(pwd \|\| IV) / mbedtls_md5_starts( &md5_ctx ); mbedtls_md5_update( &md5_ctx, pwd, pwdlen ); mbedtls_md5_update( &md5_ctx, iv, 8 ); mbedtls_md5_finish( &md5_ctx, md5sum ); if( keylen <= 16 ) { memcpy( key, md5sum, keylen ); mbedtls_md5_free( &md5_ctx ); mbedtls_zeroize( md5sum, 16 ); return; } memcpy( key, md5sum, 16 ); / * key[16..23] = MD5(key[ 0..15] \|\| pwd \|\| IV]) */ mbedtls_md5_starts( &md5_ctx ); mbedtls_md5_update( &md5_ctx, md5sum, 16 ); mbedtls_md5_update( &md5_ctx, pwd, pwdlen ); mbedtls_md5_update( &md5_ctx, iv, 8 ); mbedtls_md5_finish( &md5_ctx, md5sum ); use_len = 16; if( keylen < 32 ) use_len = keylen - 16; memcpy( key + 16, md5sum, use_len ); mbedtls_md5_free( &md5_ctx ); mbedtls_zeroize( md5sum, 16 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %r8, %r12 movq %rcx, %r13 movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbx leaq 0x10(%rsp), %rbp movq %rbp, %rdi callq 0x1ecac movq %rbp, %rdi callq 0x1ece8 movq %rbp, %rdi movq %r13, %rsi movq %r12, %rdx callq 0x1f4b6 movl $0x8, %edx movq %rbp, %rdi movq %r15, %rsi callq 0x1f4b6 movq %rsp, %rsi movq %rbp, %rdi callq 0x1f583 cmpq $0x10, %r14 ja 0x20808 movq %rsp, %rsi movq %rbx, %rdi movq %r14, %rdx callq 0xa110 leaq 0x10(%rsp), %rdi callq 0x1eccb xorl %eax, %eax movb $0x0, (%rsp,%rax) incq %rax cmpq $0x10, %rax jne 0x207f6 jmp 0x2088e movq %rsp, %rax movaps (%rax), %xmm0 movups %xmm0, (%rbx) leaq 0x10(%rsp), %rbp movq %rbp, %rdi callq 0x1ece8 movl $0x10, %edx movq %rbp, %rdi movq %rsp, %rsi callq 0x1f4b6 movq %rbp, %rdi movq %r13, %rsi movq %r12, %rdx callq 0x1f4b6 movl $0x8, %edx movq %rbp, %rdi movq %r15, %rsi callq 0x1f4b6 movq %rbp, %rdi movq %rsp, %rsi callq 0x1f583 leaq -0x10(%r14), %rdx cmpq $0x20, %r14 movl $0x10, %eax cmovaeq %rax, %rdx addq $0x10, %rbx movq %rbx, %rdi movq %rsp, %rsi callq 0xa110 movq %rbp, %rdi callq 0x1eccb xorl %eax, %eax movb $0x0, (%rsp,%rax) incq %rax cmpq $0x10, %rax jne 0x20881 addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nopl (%rax)	/Dragonchang[P]https_client/mbedtls/library/pem.c
mbedtls_pkcs12_derivation	int mbedtls_pkcs12_derivation( unsigned char data, size_t datalen, const unsigned char pwd, size_t pwdlen, const unsigned char salt, size_t saltlen, mbedtls_md_type_t md_type, int id, int iterations ) { int ret; unsigned int j; unsigned char diversifier[128]; unsigned char salt_block[128], pwd_block[128], hash_block[128]; unsigned char hash_output[MBEDTLS_MD_MAX_SIZE]; unsigned char p; unsigned char c; size_t hlen, use_len, v, i; const mbedtls_md_info_t *md_info; mbedtls_md_context_t md_ctx; // This version only allows max of 64 bytes of password or salt if( datalen > 128 \|\| pwdlen > 64 \|\| saltlen > 64 ) return( MBEDTLS_ERR_PKCS12_BAD_INPUT_DATA ); md_info = mbedtls_md_info_from_type( md_type ); if( md_info == NULL ) return( MBEDTLS_ERR_PKCS12_FEATURE_UNAVAILABLE ); mbedtls_md_init( &md_ctx ); if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 ) return( ret ); hlen = mbedtls_md_get_size( md_info ); if( hlen <= 32 ) v = 64; else v = 128; memset( diversifier, (unsigned char) id, v ); pkcs12_fill_buffer( salt_block, v, salt, saltlen ); pkcs12_fill_buffer( pwd_block, v, pwd, pwdlen ); p = data; while( datalen > 0 ) { // Calculate hash( diversifier \|\| salt_block \|\| pwd_block ) if( ( ret = mbedtls_md_starts( &md_ctx ) ) != 0 ) goto exit; if( ( ret = mbedtls_md_update( &md_ctx, diversifier, v ) ) != 0 ) goto exit; if( ( ret = mbedtls_md_update( &md_ctx, salt_block, v ) ) != 0 ) goto exit; if( ( ret = mbedtls_md_update( &md_ctx, pwd_block, v ) ) != 0 ) goto exit; if( ( ret = mbedtls_md_finish( &md_ctx, hash_output ) ) != 0 ) goto exit; // Perform remaining ( iterations - 1 ) recursive hash calculations for( i = 1; i < (size_t) iterations; i++ ) { if( ( ret = mbedtls_md( md_info, hash_output, hlen, hash_output ) ) != 0 ) goto exit; } use_len = ( datalen > hlen ) ? hlen : datalen; memcpy( p, hash_output, use_len ); datalen -= use_len; p += use_len; if( datalen == 0 ) break; // Concatenating copies of hash_output into hash_block (B) pkcs12_fill_buffer( hash_block, v, hash_output, hlen ); // B += 1 for( i = v; i > 0; i-- ) if( ++hash_block[i - 1] != 0 ) break; // salt_block += B c = 0; for( i = v; i > 0; i-- ) { j = salt_block[i - 1] + hash_block[i - 1] + c; c = (unsigned char) (j >> 8); salt_block[i - 1] = j & 0xFF; } // pwd_block += B c = 0; for( i = v; i > 0; i-- ) { j = pwd_block[i - 1] + hash_block[i - 1] + c; c = (unsigned char) (j >> 8); pwd_block[i - 1] = j & 0xFF; } } ret = 0; exit: mbedtls_zeroize( salt_block, sizeof( salt_block ) ); mbedtls_zeroize( pwd_block, sizeof( pwd_block ) ); mbedtls_zeroize( hash_block, sizeof( hash_block ) ); mbedtls_zeroize( hash_output, sizeof( hash_output ) ); mbedtls_md_free( &md_ctx ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x298, %rsp # imm = 0x298 movq %rcx, %r13 movq %rdx, 0x20(%rsp) cmpq $0x81, %rsi setae %al cmpq $0x41, %rcx setae %cl orb %al, %cl cmpq $0x41, %r9 setae %al orb %cl, %al movl $0xffffe080, %r14d # imm = 0xFFFFE080 jne 0x20fbb movq %r9, %rbx movq %r8, %r15 movq %rsi, %r12 movq %rdi, 0x30(%rsp) movl 0x2d0(%rsp), %edi callq 0xa57b testq %rax, %rax je 0x20dac movq %rax, %rbp leaq 0x38(%rsp), %r14 movq %r14, %rdi callq 0xa594 movq %r14, %rdi movq %rbp, %rsi xorl %edx, %edx callq 0xa642 movl %eax, %r14d testl %eax, %eax jne 0x20fbb movq %r12, 0x18(%rsp) movl 0x2d8(%rsp), %r14d movq %rbp, 0x28(%rsp) movq %rbp, %rdi callq 0xab31 xorl %ebp, %ebp movb %al, 0xf(%rsp) cmpb $0x21, %al setae %bpl shll $0x6, %ebp addq $0x40, %rbp leaq 0x210(%rsp), %rdi movl %r14d, %esi movq %rbp, %rdx callq 0xa0c0 leaq 0x150(%rsp), %r14 movq %rbp, 0x10(%rsp) cmpq %rbx, %rbp movq %rbx, %r12 cmovbq %rbp, %r12 movq %r14, %rdi movq %r15, %rsi movq %r12, %rdx callq 0xa110 addq %r12, %r14 subq %r12, %rbp jne 0x20d36 leaq 0xd0(%rsp), %r14 movq 0x10(%rsp), %r15 movq 0x20(%rsp), %r12 cmpq %r13, %r15 movq %r13, %rbx cmovbq %r15, %rbx movq %r14, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0xa110 addq %rbx, %r14 subq %rbx, %r15 jne 0x20d68 movq 0x18(%rsp), %rbx testq %rbx, %rbx je 0x20f5f leaq 0x38(%rsp), %rdi callq 0xa6b0 testl %eax, %eax je 0x20db7 movl %eax, %r14d jmp 0x20f62 movl $0xffffe100, %r14d # imm = 0xFFFFE100 jmp 0x20fbb movzbl 0xf(%rsp), %r13d movslq 0x2e0(%rsp), %rax decq %rax movq %rax, 0x20(%rsp) leaq 0x38(%rsp), %rbx leaq 0x210(%rsp), %rsi leaq 0x1d0(%rsp), %rbp movq 0x28(%rsp), %r15 movq 0x10(%rsp), %r12 movq %rbx, %rdi movq %r12, %rdx callq 0xa6d1 testl %eax, %eax jne 0x20da4 movq %rbx, %rdi leaq 0x150(%rsp), %rsi movq %r12, %rdx callq 0xa6d1 testl %eax, %eax jne 0x20da4 movq %rbx, %rdi leaq 0xd0(%rsp), %rsi movq %r12, %rdx callq 0xa6d1 testl %eax, %eax jne 0x20da4 movq %rbx, %rdi movq %rbp, %rsi callq 0xa6f2 testl %eax, %eax jne 0x20da4 movq 0x20(%rsp), %rbx cmpl $0x2, 0x2e0(%rsp) jb 0x20e6d movq %r15, %rdi movq %rbp, %rsi movq %r13, %rdx movq %rbp, %rcx callq 0xa713 testl %eax, %eax jne 0x20da4 decq %rbx jne 0x20e4f movq 0x18(%rsp), %r15 cmpq %r13, %r15 movq %r13, %r14 cmovbq %r15, %r14 movq 0x30(%rsp), %rbx movq %rbx, %rdi movq %rbp, %rsi movq %r14, %rdx callq 0xa110 subq %r14, %r15 je 0x20f5f addq %r14, %rbx movq %rbx, 0x30(%rsp) movq 0x10(%rsp), %r12 leaq 0x50(%rsp), %r14 cmpq %r13, %r12 movq %r13, %rbx cmovbq %r12, %rbx movq %r14, %rdi movq %rbp, %rsi movq %rbx, %rdx callq 0xa110 addq %rbx, %r14 subq %rbx, %r12 jne 0x20eaa movq 0x10(%rsp), %rsi movq %rsi, %rcx movq %rsi, %rax subq $0x1, %rax jb 0x20ee4 incb 0x4f(%rsp,%rcx) movq %rax, %rcx je 0x20ed5 xorl %ecx, %ecx movq %rsi, %rax movq %r15, 0x18(%rsp) movzbl 0x14f(%rsp,%rax), %edx addl %ecx, %edx movzbl 0x4f(%rsp,%rax), %ecx addl %edx, %ecx movb %cl, 0x14f(%rsp,%rax) shrl $0x8, %ecx decq %rax jne 0x20eee xorl %ecx, %ecx movq %rsi, %r12 movq %rsi, %rax movq 0x28(%rsp), %r15 movzbl 0xcf(%rsp,%rax), %edx addl %ecx, %edx movzbl 0x4f(%rsp,%rax), %ecx addl %edx, %ecx movb %cl, 0xcf(%rsp,%rax) shrl $0x8, %ecx decq %rax jne 0x20f1b leaq 0x38(%rsp), %rdi callq 0xa6b0 leaq 0x38(%rsp), %rbx movl %eax, %r14d testl %eax, %eax leaq 0x210(%rsp), %rsi je 0x20dec jmp 0x20f62 xorl %r14d, %r14d xorl %eax, %eax movb $0x0, 0x150(%rsp,%rax) incq %rax cmpq $0x80, %rax jne 0x20f64 xorl %eax, %eax movb $0x0, 0xd0(%rsp,%rax) incq %rax cmpq $0x80, %rax jne 0x20f79 xorl %eax, %eax movb $0x0, 0x50(%rsp,%rax) incq %rax cmpq $0x80, %rax jne 0x20f8e xorl %eax, %eax movb $0x0, 0x1d0(%rsp,%rax) incq %rax cmpq $0x40, %rax jne 0x20fa0 leaq 0x38(%rsp), %rdi callq 0xa5a3 movl %r14d, %eax addq $0x298, %rsp # imm = 0x298 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/pkcs12.c
mbedtls_aes_crypt_ecb	int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx, int mode, const unsigned char input[16], unsigned char output[16] ) { #if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64) if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) ) return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) ); #endif #if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86) if( aes_padlock_ace ) { if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 ) return( 0 ); // If padlock data misaligned, we just fall back to // unaccelerated mode // } #endif if( mode == MBEDTLS_AES_ENCRYPT ) mbedtls_aes_encrypt( ctx, input, output ); else mbedtls_aes_decrypt( ctx, input, output ); return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rcx, %rbx movq %rdx, %r14 movl %esi, %ebp movq %rdi, %r15 movl $0x2000000, %edi # imm = 0x2000000 callq 0x23200 movq %r15, %rdi testl %eax, %eax je 0x22873 movl %ebp, %esi movq %r14, %rdx movq %rbx, %rcx addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x2322b movq %r14, %rsi movq %rbx, %rdx cmpl $0x1, %ebp jne 0x22885 callq 0x21f29 jmp 0x2288a callq 0x223ad xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/aes.c
mbedtls_aesni_inverse_key	void mbedtls_aesni_inverse_key( unsigned char invkey, const unsigned char fwdkey, int nr ) { unsigned char ik = invkey; const unsigned char fk = fwdkey + 16 * nr; memcpy( ik, fk, 16 ); for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 ) asm( "movdqu (%0), %%xmm0 \n\t" AESIMC xmm0_xmm0 "\n\t" "movdqu %%xmm0, (%1) \n\t" : : "r" (fk), "r" (ik) : "memory", "xmm0" ); memcpy( ik, fk, 16 ); }	shll $0x4, %edx movslq %edx, %rax addq %rsi, %rax addq $-0x10, %rax movups 0x10(%rax), %xmm0 movups %xmm0, (%rdi) addq $0x10, %rdi cmpq %rsi, %rax jbe 0x23405 movdqu (%rax), %xmm0 aesimc %xmm0, %xmm0 movdqu %xmm0, (%rdi) addq $-0x10, %rax jmp 0x233e9 movups (%rax), %xmm0 movups %xmm0, (%rdi) retq	/Dragonchang[P]https_client/mbedtls/library/aesni.c
mbedtls_asn1_write_len	int mbedtls_asn1_write_len( unsigned char *p, unsigned char start, size_t len ) { if( len < 0x80 ) { if( p - start < 1 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); --(p) = (unsigned char) len; return( 1 ); } if( len <= 0xFF ) { if( p - start < 2 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); --(p) = (unsigned char) len; --(p) = 0x81; return( 2 ); } if( len <= 0xFFFF ) { if( p - start < 3 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); --(p) = ( len ) & 0xFF; --(p) = ( len >> 8 ) & 0xFF; --(p) = 0x82; return( 3 ); } if( len <= 0xFFFFFF ) { if( p - start < 4 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); --(p) = ( len ) & 0xFF; --(p) = ( len >> 8 ) & 0xFF; --(p) = ( len >> 16 ) & 0xFF; --(p) = 0x83; return( 4 ); } if( len <= 0xFFFFFFFF ) { if( p - start < 5 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); --(p) = ( len ) & 0xFF; --(p) = ( len >> 8 ) & 0xFF; --(p) = ( len >> 16 ) & 0xFF; --(p) = ( len >> 24 ) & 0xFF; --(*p) = 0x84; return( 5 ); } return( MBEDTLS_ERR_ASN1_INVALID_LENGTH ); }	cmpq $0x7f, %rdx ja 0x2385a movq (%rdi), %rcx movq %rcx, %rax subq %rsi, %rax testq %rax, %rax jle 0x238db movl $0x1, %eax jmp 0x2399a cmpq $0xff, %rdx ja 0x23894 movq (%rdi), %rcx movq %rcx, %r8 subq %rsi, %r8 movl $0xffffff94, %eax # imm = 0xFFFFFF94 cmpq $0x2, %r8 jl 0x239a4 leaq -0x1(%rcx), %rax movq %rax, (%rdi) movb %dl, -0x1(%rcx) movq (%rdi), %rcx movl $0x2, %eax movb $-0x7f, %dl jmp 0x2399a cmpq $0xffff, %rdx # imm = 0xFFFF ja 0x238e1 movq (%rdi), %rcx movq %rcx, %r8 subq %rsi, %r8 movl $0xffffff94, %eax # imm = 0xFFFFFF94 cmpq $0x3, %r8 jl 0x239a4 leaq -0x1(%rcx), %rax movq %rax, (%rdi) movb %dl, -0x1(%rcx) movq (%rdi), %rax leaq -0x1(%rax), %rcx movq %rcx, (%rdi) movb %dh, -0x1(%rax) movq (%rdi), %rcx movl $0x3, %eax movb $-0x7e, %dl jmp 0x2399a movl $0xffffff94, %eax # imm = 0xFFFFFF94 retq cmpq $0xffffff, %rdx # imm = 0xFFFFFF ja 0x23935 movq (%rdi), %rcx movq %rcx, %r8 subq %rsi, %r8 movl $0xffffff94, %eax # imm = 0xFFFFFF94 cmpq $0x4, %r8 jl 0x239a4 leaq -0x1(%rcx), %rax movq %rax, (%rdi) movb %dl, -0x1(%rcx) movq (%rdi), %rax leaq -0x1(%rax), %rcx movq %rcx, (%rdi) movb %dh, -0x1(%rax) shrl $0x10, %edx movq (%rdi), %rax leaq -0x1(%rax), %rcx movq %rcx, (%rdi) movb %dl, -0x1(%rax) movq (%rdi), %rcx movl $0x4, %eax movb $-0x7d, %dl jmp 0x2399a movq %rdx, %rax shrq $0x20, %rax movl $0xffffff9c, %eax # imm = 0xFFFFFF9C jne 0x239a4 movq (%rdi), %rcx movq %rcx, %r8 subq %rsi, %r8 movl $0xffffff94, %eax # imm = 0xFFFFFF94 cmpq $0x5, %r8 jl 0x239a4 leaq -0x1(%rcx), %rax movq %rax, (%rdi) movb %dl, -0x1(%rcx) movq (%rdi), %rax leaq -0x1(%rax), %rcx movq %rcx, (%rdi) movb %dh, -0x1(%rax) movl %edx, %eax shrl $0x10, %eax movq (%rdi), %rcx leaq -0x1(%rcx), %rsi movq %rsi, (%rdi) movb %al, -0x1(%rcx) shrl $0x18, %edx movq (%rdi), %rax leaq -0x1(%rax), %rcx movq %rcx, (%rdi) movb %dl, -0x1(%rax) movq (%rdi), %rcx movl $0x5, %eax movb $-0x7c, %dl leaq -0x1(%rcx), %rsi movq %rsi, (%rdi) movb %dl, -0x1(%rcx) retq	/Dragonchang[P]https_client/mbedtls/library/asn1write.c
mbedtls_asn1_write_bool	int mbedtls_asn1_write_bool( unsigned char *p, unsigned char start, int boolean ) { int ret; size_t len = 0; if( p - start < 1 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); --(*p) = (boolean) ? 255 : 0; len++; MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) ); MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_BOOLEAN ) ); return( (int) len ); }	movq (%rdi), %rax movq %rax, %rcx subq %rsi, %rcx testq %rcx, %rcx jle 0x23cb5 xorl %ecx, %ecx negl %edx sbbl %ecx, %ecx leaq -0x1(%rax), %rdx movq %rdx, (%rdi) movb %cl, -0x1(%rax) movq (%rdi), %rax movq %rax, %rcx subq %rsi, %rcx testq %rcx, %rcx jle 0x23cbb leaq -0x1(%rax), %rdx movq %rdx, (%rdi) movb $0x1, -0x1(%rax) movl $0x1, %eax jmp 0x23cc0 movl $0xffffff94, %eax # imm = 0xFFFFFF94 retq movl $0xffffff94, %eax # imm = 0xFFFFFF94 testq %rcx, %rcx jle 0x23cba movq (%rdi), %rdx movq %rdx, %rcx subq %rsi, %rcx testq %rcx, %rcx jle 0x23ce5 leaq -0x1(%rdx), %rsi movq %rsi, (%rdi) movb $0x1, -0x1(%rdx) movl $0x1, %edx jmp 0x23cea movl $0xffffff94, %edx # imm = 0xFFFFFF94 testq %rcx, %rcx jle 0x23cf4 addl %edx, %eax incl %eax retq movl %edx, %eax retq	/Dragonchang[P]https_client/mbedtls/library/asn1write.c
mbedtls_asn1_write_int	int mbedtls_asn1_write_int( unsigned char *p, unsigned char start, int val ) { int ret; size_t len = 0; // TODO negative values and values larger than 128 // DER format assumes 2s complement for numbers, so the leftmost bit // should be 0 for positive numbers and 1 for negative numbers. // if( p - start < 1 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); len += 1; --(p) = val; if( val > 0 && p & 0x80 ) { if( p - start < 1 ) return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); --(p) = 0x00; len += 1; } MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) ); MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_INTEGER ) ); return( (int) len ); }	pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq (%rdi), %rcx movq %rcx, %rsi subq %r14, %rsi movl $0xffffff94, %eax # imm = 0xFFFFFF94 testq %rsi, %rsi jle 0x23d97 movq %rdi, %rbx leaq -0x1(%rcx), %rsi movq %rsi, (%rdi) movb %dl, -0x1(%rcx) movl $0x1, %r15d testl %edx, %edx jle 0x23d51 movq (%rbx), %rcx cmpb $0x0, (%rcx) jns 0x23d51 movq %rcx, %rdx subq %r14, %rdx testq %rdx, %rdx jle 0x23d97 leaq -0x1(%rcx), %rax movq %rax, (%rbx) movb $0x0, -0x1(%rcx) movl $0x2, %r15d movq %rbx, %rdi movq %r14, %rsi movq %r15, %rdx callq 0x23838 movl %eax, %ecx testl %eax, %eax js 0x23d95 movq (%rbx), %rax movq %rax, %rdx subq %r14, %rdx testq %rdx, %rdx jle 0x23d85 leaq -0x1(%rax), %rsi movq %rsi, (%rbx) movb $0x2, -0x1(%rax) movl $0x1, %eax jmp 0x23d8a movl $0xffffff94, %eax # imm = 0xFFFFFF94 testq %rdx, %rdx jle 0x23d97 addl %eax, %r15d addl %r15d, %ecx movl %ecx, %eax popq %rbx popq %r14 popq %r15 retq	/Dragonchang[P]https_client/mbedtls/library/asn1write.c
mbedtls_asn1_store_named_data	mbedtls_asn1_named_data mbedtls_asn1_store_named_data( mbedtls_asn1_named_data head, const char oid, size_t oid_len, const unsigned char val, size_t val_len ) { mbedtls_asn1_named_data cur; if( ( cur = mbedtls_asn1_find_named_data( head, oid, oid_len ) ) == NULL ) { // Add new entry if not present yet based on OID // cur = (mbedtls_asn1_named_data)mbedtls_calloc( 1, sizeof(mbedtls_asn1_named_data) ); if( cur == NULL ) return( NULL ); cur->oid.len = oid_len; cur->oid.p = mbedtls_calloc( 1, oid_len ); if( cur->oid.p == NULL ) { mbedtls_free( cur ); return( NULL ); } memcpy( cur->oid.p, oid, oid_len ); cur->val.len = val_len; cur->val.p = mbedtls_calloc( 1, val_len ); if( cur->val.p == NULL ) { mbedtls_free( cur->oid.p ); mbedtls_free( cur ); return( NULL ); } cur->next = head; head = cur; } else if( cur->val.len < val_len ) { /* * Enlarge existing value buffer if needed * Preserve old data until the allocation succeeded, to leave list in * a consistent state in case allocation fails. / void p = mbedtls_calloc( 1, val_len ); if( p == NULL ) return( NULL ); mbedtls_free( cur->val.p ); cur->val.p = p; cur->val.len = val_len; } if( val != NULL ) memcpy( cur->val.p, val, val_len ); return( cur ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r13 movq %rsi, %rbp movq %rdi, %r12 movq (%rdi), %rdi callq 0x142d0 testq %rax, %rax je 0x2407f movq %rax, %rbx cmpq %r14, 0x20(%rax) jae 0x240f3 movq %r15, %r12 movl $0x1, %edi movq %r14, %rsi callq 0xa0e0 testq %rax, %rax je 0x24119 movq %rax, %r15 movq 0x28(%rbx), %rdi callq 0xa030 movq %r15, 0x28(%rbx) movq %r14, 0x20(%rbx) movq %r12, %r15 jmp 0x240f3 movl $0x1, %edi movl $0x40, %esi callq 0xa0e0 testq %rax, %rax je 0x24119 movq %rax, %rbx movq %r15, (%rsp) movq %r13, 0x8(%rax) movl $0x1, %edi movq %r13, %rsi callq 0xa0e0 movq %rax, 0x10(%rbx) testq %rax, %rax je 0x24111 movq %rax, %r15 movq %rax, %rdi movq %rbp, %rsi movq %r13, %rdx callq 0xa110 movq %r14, 0x20(%rbx) movl $0x1, %edi movq %r14, %rsi callq 0xa0e0 movq %rax, 0x28(%rbx) testq %rax, %rax je 0x24109 movq (%r12), %rax movq %rax, 0x30(%rbx) movq %rbx, (%r12) movq (%rsp), %r15 testq %r15, %r15 je 0x2411b movq 0x28(%rbx), %rdi movq %r15, %rsi movq %r14, %rdx callq 0xa110 jmp 0x2411b movq %r15, %rdi callq 0xa030 movq %rbx, %rdi callq 0xa030 xorl %ebx, %ebx movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nopl (%rax)	/Dragonchang[P]https_client/mbedtls/library/asn1write.c
mbedtls_cipher_info_from_values	const mbedtls_cipher_info_t mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id, int key_bitlen, const mbedtls_cipher_mode_t mode ) { const mbedtls_cipher_definition_t def; for( def = mbedtls_cipher_definitions; def->info != NULL; def++ ) if( def->info->base->cipher == cipher_id && def->info->key_bitlen == (unsigned) key_bitlen && def->info->mode == mode ) return( def->info ); return( NULL ); }	leaq 0x17152(%rip), %rcx # 0x3b780 movq 0x8(%rcx), %rax testq %rax, %rax je 0x2465a addq $0x18, %rcx movq 0x28(%rax), %r8 cmpl %edi, (%r8) jne 0x2464e cmpl %esi, 0x8(%rax) jne 0x2464e cmpl %edx, 0x4(%rax) je 0x2465c movq (%rcx), %rax addq $0x10, %rcx testq %rax, %rax jne 0x2463b xorl %eax, %eax retq	/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_update_ad	int mbedtls_cipher_update_ad( mbedtls_cipher_context_t ctx, const unsigned char ad, size_t ad_len ) { if( NULL == ctx \|\| NULL == ctx->cipher_info ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode ) { return mbedtls_gcm_starts( (mbedtls_gcm_context *) ctx->cipher_ctx, ctx->operation, ctx->iv, ctx->iv_size, ad, ad_len ); } return( 0 ); }	movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x24874 movq %rdx, %r9 movq %rdi, %rdx movq (%rdi), %rcx testq %rcx, %rcx je 0x24874 xorl %eax, %eax cmpl $0x6, 0x4(%rcx) jne 0x24874 movq %rsi, %r8 movq 0x50(%rdx), %rdi movl 0xc(%rdx), %esi movq 0x48(%rdx), %rcx addq $0x38, %rdx jmp 0x26adc retq	/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_finish	int mbedtls_cipher_finish( mbedtls_cipher_context_t ctx, unsigned char output, size_t olen ) { if( NULL == ctx \|\| NULL == ctx->cipher_info \|\| NULL == olen ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); olen = 0; if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode \|\| MBEDTLS_MODE_CTR == ctx->cipher_info->mode \|\| MBEDTLS_MODE_GCM == ctx->cipher_info->mode \|\| MBEDTLS_MODE_STREAM == ctx->cipher_info->mode ) { return( 0 ); } if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode ) { if( ctx->unprocessed_len != 0 ) return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED ); return( 0 ); } #if defined(MBEDTLS_CIPHER_MODE_CBC) if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode ) { int ret = 0; if( MBEDTLS_ENCRYPT == ctx->operation ) { /* check for 'no padding' mode / if( NULL == ctx->add_padding ) { if( 0 != ctx->unprocessed_len ) return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED ); return( 0 ); } ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ), ctx->unprocessed_len ); } else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len ) { / * For decrypt operations, expect a full block, * or an empty block if no padding / if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len ) return( 0 ); return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED ); } / cipher block / if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx, ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv, ctx->unprocessed_data, output ) ) ) { return( ret ); } / Set output size for decryption / if( MBEDTLS_DECRYPT == ctx->operation ) return ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ), olen ); / Set output size for encryption / olen = mbedtls_cipher_get_block_size( ctx ); return( 0 ); } #else ((void) output); #endif /* MBEDTLS_CIPHER_MODE_CBC */ return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE ); }	pushq %r15 pushq %r14 pushq %rbx movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x24c75 movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq (%rdi), %rcx testq %rcx, %rcx sete %dl testq %rbx, %rbx sete %sil orb %dl, %sil jne 0x24c75 movq $0x0, (%rbx) movl 0x4(%rcx), %edx decl %edx cmpl $0x6, %edx ja 0x24bfe xorl %eax, %eax leaq 0x94de(%rip), %rsi # 0x2e094 movslq (%rsi,%rdx,4), %rdx addq %rsi, %rdx jmpq %rdx xorl %ecx, %ecx cmpq $0x0, 0x30(%r15) movl $0xffff9d80, %eax # imm = 0xFFFF9D80 cmovel %ecx, %eax jmp 0x24c75 cmpl $0x1, 0xc(%r15) jne 0x24c05 movq 0x10(%r15), %rax testq %rax, %rax je 0x24bbf leaq 0x20(%r15), %rdi movq 0x48(%r15), %rdx testq %rdx, %rdx jne 0x24bf3 movl 0x18(%rcx), %edx movslq %edx, %rsi movq 0x30(%r15), %rdx callq %rax jmp 0x24c11 movl $0xffff9f80, %eax # imm = 0xFFFF9F80 jmp 0x24c75 movl 0x20(%rcx), %ecx movq 0x30(%r15), %rax cmpq %rcx, %rax jne 0x24c2e movq (%r15), %rcx movq 0x28(%rcx), %rax movq 0x10(%rax), %rax movq 0x50(%r15), %rdi movl 0xc(%r15), %esi testq %rcx, %rcx je 0x24c36 movl 0x20(%rcx), %edx jmp 0x24c38 xorl %ecx, %ecx orq 0x10(%r15), %rax jmp 0x24bc6 xorl %edx, %edx leaq 0x38(%r15), %rcx leaq 0x20(%r15), %r8 movq %r14, %r9 callq %rax testl %eax, %eax jne 0x24c75 cmpl $0x0, 0xc(%r15) je 0x24c5f movq (%r15), %rcx xorl %eax, %eax testq %rcx, %rcx je 0x24c70 movl 0x20(%rcx), %ecx jmp 0x24c72 movq (%r15), %rcx movq 0x18(%r15), %rax testq %rcx, %rcx je 0x24c7b movl 0x20(%rcx), %esi jmp 0x24c7d xorl %ecx, %ecx movq %rcx, (%rbx) popq %rbx popq %r14 popq %r15 retq xorl %esi, %esi movq %r14, %rdi movq %rbx, %rdx popq %rbx popq %r14 popq %r15 jmpq %rax	/Dragonchang[P]https_client/mbedtls/library/cipher.c
get_pkcs_padding	static int get_pkcs_padding( unsigned char input, size_t input_len, size_t data_len ) { size_t i, pad_idx; unsigned char padding_len, bad = 0; if( NULL == input \|\| NULL == data_len ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); padding_len = input[input_len - 1]; data_len = input_len - padding_len; / Avoid logical \|\| since it results in a branch / bad \|= padding_len > input_len; bad \|= padding_len == 0; / The number of bytes checked must be independent of padding_len, * so pick input_len, which is usually 8 or 16 (one block) / pad_idx = input_len - padding_len; for( i = 0; i < input_len; i++ ) bad \|= ( input[i] ^ padding_len ) ( i >= pad_idx ); return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) ); }	testq %rdi, %rdi sete %al testq %rdx, %rdx sete %cl orb %al, %cl movl $0xffff9f00, %eax # imm = 0xFFFF9F00 jne 0x24d07 movzbl -0x1(%rdi,%rsi), %ecx testq %rcx, %rcx sete %r9b movq %rsi, %r8 subq %rcx, %r8 setb %al movq %r8, (%rdx) orb %r9b, %al testq %rsi, %rsi je 0x24cfb xorl %edx, %edx xorl %r9d, %r9d movb (%rdi,%r9), %r10b xorb %cl, %r10b cmpq %r8, %r9 movzbl %r10b, %r10d cmovbl %edx, %r10d orb %r10b, %al incq %r9 cmpq %r9, %rsi jne 0x24cde xorl %ecx, %ecx testb %al, %al movl $0xffff9e00, %eax # imm = 0xFFFF9E00 cmovel %ecx, %eax retq	/Dragonchang[P]https_client/mbedtls/library/cipher.c
get_one_and_zeros_padding	static int get_one_and_zeros_padding( unsigned char input, size_t input_len, size_t data_len ) { size_t i; unsigned char done = 0, prev_done, bad; if( NULL == input \|\| NULL == data_len ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); bad = 0xFF; data_len = 0; for( i = input_len; i > 0; i-- ) { prev_done = done; done \|= ( input[i-1] != 0 ); data_len \|= ( i - 1 ) * ( done != prev_done ); bad &= ( input[i-1] ^ 0x80 ) \| ( done == prev_done ); } return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) ); }	testq %rdi, %rdi sete %al testq %rdx, %rdx sete %cl orb %al, %cl movl $0xffff9f00, %eax # imm = 0xFFFF9F00 jne 0x24da1 movq $0x0, (%rdx) testq %rsi, %rsi je 0x24da2 movq (%rdx), %rax decq %rsi xorl %r8d, %r8d movb $-0x1, %cl xorl %r9d, %r9d cmpb $0x0, (%rdi,%rsi) setne %r9b orl %r8d, %r9d cmpl %r8d, %r9d sete %r8b movl $0x0, %r10d cmovneq %rsi, %r10 orq %r10, %rax movq %rax, (%rdx) orb (%rdi,%rsi), %r8b addb $-0x80, %r8b andb %r8b, %cl movl %r9d, %r8d addq $-0x1, %rsi jb 0x24d5c xorl %edx, %edx testb %cl, %cl movl $0xffff9e00, %eax # imm = 0xFFFF9E00 cmovel %edx, %eax retq movl $0xffff9e00, %eax # imm = 0xFFFF9E00 retq	/Dragonchang[P]https_client/mbedtls/library/cipher.c
mbedtls_cipher_write_tag	int mbedtls_cipher_write_tag( mbedtls_cipher_context_t ctx, unsigned char tag, size_t tag_len ) { if( NULL == ctx \|\| NULL == ctx->cipher_info \|\| NULL == tag ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); if( MBEDTLS_ENCRYPT != ctx->operation ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode ) return mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx, tag, tag_len ); return( 0 ); }	movl $0xffff9f00, %eax # imm = 0xFFFF9F00 testq %rdi, %rdi je 0x24ef9 movq (%rdi), %rcx testq %rcx, %rcx sete %r8b testq %rsi, %rsi sete %r9b orb %r8b, %r9b jne 0x24ef9 cmpl $0x1, 0xc(%rdi) jne 0x24ef9 xorl %eax, %eax cmpl $0x6, 0x4(%rcx) jne 0x24ef9 movq 0x50(%rdi), %rdi jmp 0x26f45 retq	/Dragonchang[P]https_client/mbedtls/library/cipher.c
blowfish_ctx_alloc	static void * blowfish_ctx_alloc( void ) { mbedtls_blowfish_context *ctx; ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) ); if( ctx == NULL ) return( NULL ); mbedtls_blowfish_init( ctx ); return( ctx ); }	pushq %rbx movl $0x1, %edi movl $0x1048, %esi # imm = 0x1048 callq 0xa0e0 testq %rax, %rax je 0x2530b movq %rax, %rbx movq %rax, %rdi callq 0x277c4 jmp 0x2530d xorl %ebx, %ebx movq %rbx, %rax popq %rbx retq	/Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c
mbedtls_des_setkey	void mbedtls_des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] ) { int i; uint32_t X, Y, T; GET_UINT32_BE( X, key, 0 ); GET_UINT32_BE( Y, key, 4 ); /* * Permuted Choice 1 / T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4); T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T ); X = (LHs[ (X ) & 0xF] << 3) \| (LHs[ (X >> 8) & 0xF ] << 2) \| (LHs[ (X >> 16) & 0xF] << 1) \| (LHs[ (X >> 24) & 0xF ] ) \| (LHs[ (X >> 5) & 0xF] << 7) \| (LHs[ (X >> 13) & 0xF ] << 6) \| (LHs[ (X >> 21) & 0xF] << 5) \| (LHs[ (X >> 29) & 0xF ] << 4); Y = (RHs[ (Y >> 1) & 0xF] << 3) \| (RHs[ (Y >> 9) & 0xF ] << 2) \| (RHs[ (Y >> 17) & 0xF] << 1) \| (RHs[ (Y >> 25) & 0xF ] ) \| (RHs[ (Y >> 4) & 0xF] << 7) \| (RHs[ (Y >> 12) & 0xF ] << 6) \| (RHs[ (Y >> 20) & 0xF] << 5) \| (RHs[ (Y >> 28) & 0xF ] << 4); X &= 0x0FFFFFFF; Y &= 0x0FFFFFFF; / * calculate subkeys / for( i = 0; i < 16; i++ ) { if( i < 2 \|\| i == 8 \|\| i == 15 ) { X = ((X << 1) \| (X >> 27)) & 0x0FFFFFFF; Y = ((Y << 1) \| (Y >> 27)) & 0x0FFFFFFF; } else { X = ((X << 2) \| (X >> 26)) & 0x0FFFFFFF; Y = ((Y << 2) \| (Y >> 26)) & 0x0FFFFFFF; } SK++ = ((X << 4) & 0x24000000) \| ((X << 28) & 0x10000000) \| ((X << 14) & 0x08000000) \| ((X << 18) & 0x02080000) \| ((X << 6) & 0x01000000) \| ((X << 9) & 0x00200000) \| ((X >> 1) & 0x00100000) \| ((X << 10) & 0x00040000) \| ((X << 2) & 0x00020000) \| ((X >> 10) & 0x00010000) \| ((Y >> 13) & 0x00002000) \| ((Y >> 4) & 0x00001000) \| ((Y << 6) & 0x00000800) \| ((Y >> 1) & 0x00000400) \| ((Y >> 14) & 0x00000200) \| ((Y ) & 0x00000100) \| ((Y >> 5) & 0x00000020) \| ((Y >> 10) & 0x00000010) \| ((Y >> 3) & 0x00000008) \| ((Y >> 18) & 0x00000004) \| ((Y >> 26) & 0x00000002) \| ((Y >> 24) & 0x00000001); *SK++ = ((X << 15) & 0x20000000) \| ((X << 17) & 0x10000000) \| ((X << 10) & 0x08000000) \| ((X << 22) & 0x04000000) \| ((X >> 2) & 0x02000000) \| ((X << 1) & 0x01000000) \| ((X << 16) & 0x00200000) \| ((X << 11) & 0x00100000) \| ((X << 3) & 0x00080000) \| ((X >> 6) & 0x00040000) \| ((X << 15) & 0x00020000) \| ((X >> 4) & 0x00010000) \| ((Y >> 2) & 0x00002000) \| ((Y << 8) & 0x00001000) \| ((Y >> 14) & 0x00000808) \| ((Y >> 9) & 0x00000400) \| ((Y ) & 0x00000200) \| ((Y << 7) & 0x00000100) \| ((Y >> 7) & 0x00000020) \| ((Y >> 3) & 0x00000011) \| ((Y << 2) & 0x00000004) \| ((Y >> 21) & 0x00000002); } }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdi, -0x8(%rsp) movzbl (%rsi), %ecx movl %ecx, %eax shll $0x18, %eax movzbl 0x1(%rsi), %edx shll $0x10, %edx orl %eax, %edx movzbl 0x2(%rsi), %eax shll $0x8, %eax movzbl 0x3(%rsi), %r8d orl %edx, %r8d orl %eax, %r8d movl 0x4(%rsi), %edx bswapl %edx movl %edx, %eax shrl $0x4, %eax xorl %r8d, %eax andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F movl %eax, %esi xorl %r8d, %esi shll $0x4, %eax xorl %edx, %eax andl $0x10101010, %r8d # imm = 0x10101010 andl $0xefefefef, %eax # imm = 0xEFEFEFEF orl %r8d, %eax movl %esi, %edx andl $0xf, %edx leaq 0x8eec(%rip), %r8 # 0x2e470 movl (%r8,%rdx,4), %edx shll $0x3, %edx movl %esi, %r9d shrl $0x6, %r9d andl $0x3c, %r9d movl (%r9,%r8), %r9d shll $0x2, %r9d orl %edx, %r9d movl %esi, %edx shrl $0xe, %edx andl $0x3c, %edx movl (%rdx,%r8), %edx addl %edx, %edx orl %r9d, %edx movl %esi, %r9d shrl $0x16, %r9d andl $0x3c, %r9d orl (%r9,%r8), %edx movl %esi, %r9d shrl $0x3, %r9d andl $0x3c, %r9d movl (%r9,%r8), %r9d shll $0x7, %r9d movl %esi, %r10d shrl $0xb, %r10d andl $0x3c, %r10d movl (%r10,%r8), %r10d shll $0x6, %r10d orl %r9d, %r10d shrl $0x13, %esi andl $0x3c, %esi movl (%rsi,%r8), %esi shll $0x5, %esi orl %r10d, %esi shrl $0x5, %ecx movl (%r8,%rcx,4), %r13d shll $0x4, %r13d orl %esi, %r13d movl %eax, %esi andl $0x1e, %esi leaq 0x8e9c(%rip), %rcx # 0x2e4b0 movl (%rcx,%rsi,2), %esi shll $0x3, %esi movl %eax, %r8d shrl $0x7, %r8d andl $0x3c, %r8d movl (%r8,%rcx), %r8d shll $0x2, %r8d orl %esi, %r8d movl %eax, %esi shrl $0xf, %esi andl $0x3c, %esi movl (%rsi,%rcx), %esi addl %esi, %esi orl %r8d, %esi movl %eax, %r8d shrl $0x17, %r8d andl $0x3c, %r8d orl (%r8,%rcx), %esi orl %edx, %r13d movl %eax, %edx shrl $0x2, %edx andl $0x3c, %edx movl (%rdx,%rcx), %edx shll $0x7, %edx movl %eax, %r8d shrl $0xa, %r8d andl $0x3c, %r8d movl (%r8,%rcx), %r8d shll $0x6, %r8d orl %edx, %r8d movl %eax, %edx shrl $0x12, %edx andl $0x3c, %edx movl (%rdx,%rcx), %edx shll $0x5, %edx orl %r8d, %edx shrl $0x1c, %eax movl (%rcx,%rax,4), %r15d shll $0x4, %r15d orl %edx, %r15d orl %esi, %r15d movl $0xfffffff, %ecx # imm = 0xFFFFFFF andl %ecx, %r13d andl %ecx, %r15d xorl %r8d, %r8d cmpl $0xf, %r8d ja 0x25974 movl $0x8103, %eax # imm = 0x8103 btl %r8d, %eax jae 0x25974 movl $0xffffffe, %r14d # imm = 0xFFFFFFE movl $0x1b, %esi movl $0x1, %edx movl %r13d, %r11d movl %edx, %ecx shll %cl, %r11d movl %esi, %ecx shrl %cl, %r13d movl %r11d, %ebx andl %r14d, %ebx movl %ebx, %ebp orl %r13d, %ebp movl %r15d, %eax movl %edx, %ecx shll %cl, %eax movl %esi, %ecx shrl %cl, %r15d andl %eax, %r14d movl %r14d, %r12d orl %r15d, %r12d movl %ebx, %ecx shll $0x4, %ecx andl $0x24000000, %ecx # imm = 0x24000000 andl $0x1, %r13d shll $0x1c, %r13d orl %ecx, %r13d movl %r11d, %ecx shll $0xe, %ecx movl $0x8000000, %edx # imm = 0x8000000 andl %edx, %ecx orl %r13d, %ecx movl %ebp, %edx movl %ebp, %esi shll $0x12, %esi andl $0x2080000, %esi # imm = 0x2080000 orl %ecx, %esi movl %r11d, %ecx shll $0x6, %ecx andl $0x1000000, %ecx # imm = 0x1000000 orl %esi, %ecx movl %r11d, %esi shll $0x9, %esi andl $0x200000, %esi # imm = 0x200000 orl %ecx, %esi movl %r11d, %r13d shrl %r13d movl $0x100000, %ecx # imm = 0x100000 andl %ecx, %r13d orl %esi, %r13d shll $0xa, %edx movl %edx, %ecx movl $0x40000, %esi # imm = 0x40000 andl %esi, %ecx leal (,%rbx,4), %esi movl $0x20000, %edi # imm = 0x20000 andl %edi, %esi orl %ecx, %esi movl %r11d, %ecx shrl $0xa, %ecx movl $0x10000, %edi # imm = 0x10000 andl %edi, %ecx orl %esi, %ecx movl %r12d, %esi andl $0x20, %esi shll $0x6, %esi movl %eax, %r9d shrl %r9d movl $0x400, %edi # imm = 0x400 andl %edi, %r9d orl %esi, %r9d shrl $0xe, %r14d movl %r14d, %r10d movl $0x200, %esi # imm = 0x200 andl %esi, %r10d orl %r9d, %r10d movl %eax, %esi andl $0x100, %esi # imm = 0x100 orl %ecx, %esi movl %eax, %ecx shrl $0xd, %ecx movl $0x2000, %edi # imm = 0x2000 andl %edi, %ecx orl %ecx, %esi movl %eax, %ecx shrl $0x4, %ecx andl $0x1000, %ecx # imm = 0x1000 orl %ecx, %esi movl %r12d, %ecx orl %r13d, %esi movl %eax, %r9d shrl $0x5, %r9d andl $0x20, %r9d orl %r10d, %r9d movl %eax, %r10d shrl $0xa, %r10d andl $0x10, %r10d orl %r9d, %r10d shrl $0x3, %ecx movl %ecx, %r9d andl $0x8, %r9d orl %r10d, %r9d movl %eax, %r10d shrl $0x12, %r10d andl $0x4, %r10d orl %r9d, %r10d orl %esi, %r10d movl %eax, %esi shrl $0x1a, %esi andl $0x2, %esi movl %eax, %r9d shrl $0x18, %r9d andl $0x1, %r9d orl %esi, %r9d movl %ebp, %r13d orl %r10d, %r9d movq -0x8(%rsp), %rdi movl %r9d, (%rdi,%r8,8) shll $0xf, %r13d movl %r13d, %esi andl $0x20000000, %esi # imm = 0x20000000 movl %r11d, %r9d shll $0x11, %r9d andl $0x10000000, %r9d # imm = 0x10000000 orl %esi, %r9d movl $0x8000000, %esi # imm = 0x8000000 andl %esi, %edx orl %r9d, %edx movl %ebp, %esi andl $0x10, %esi shll $0x16, %esi orl %edx, %esi movl %r11d, %edx shrl $0x2, %edx andl $0x2000000, %edx # imm = 0x2000000 orl %esi, %edx movl %ebx, %esi andl $0x800000, %esi # imm = 0x800000 leal (%rdx,%rsi,2), %esi movl %ebp, %edx andl $0x20, %edx shll $0x10, %edx orl %esi, %edx movl %r11d, %esi shll $0xb, %esi movl $0x100000, %r9d # imm = 0x100000 andl %r9d, %esi shll $0x3, %ebx andl $0x80000, %ebx # imm = 0x80000 orl %esi, %ebx movl %r11d, %esi shrl $0x6, %esi movl $0x40000, %r9d # imm = 0x40000 andl %r9d, %esi orl %ebx, %esi movl $0x20000, %r9d # imm = 0x20000 andl %r9d, %r13d orl %esi, %r13d shrl $0x4, %r11d movl $0x10000, %esi # imm = 0x10000 andl %esi, %r11d orl %r13d, %r11d andl $0x808, %r14d # imm = 0x808 movl %eax, %r9d shrl $0x9, %r9d movl $0x400, %esi # imm = 0x400 andl %esi, %r9d orl %r14d, %r9d movl %eax, %esi movl $0x200, %r10d # imm = 0x200 andl %r10d, %esi orl %r11d, %esi movl %eax, %r10d shrl $0x2, %r10d movl $0x2000, %r11d # imm = 0x2000 andl %r11d, %r10d orl %r10d, %esi movl %r12d, %r10d andl $0x10, %r10d shll $0x8, %r10d orl %r10d, %esi orl %edx, %esi movl %r12d, %edx andl $0x2, %edx shll $0x7, %edx orl %r9d, %edx movl %eax, %r9d shrl $0x7, %r9d andl $0x20, %r9d orl %edx, %r9d andl $0x11, %ecx orl %r9d, %ecx shll $0x2, %r15d andl $0x4, %r15d orl %ecx, %r15d shrl $0x15, %eax andl $0x2, %eax orl %r15d, %eax orl %esi, %eax movl %eax, 0x4(%rdi,%r8,8) movl %r12d, %r15d movl %ebp, %r13d incq %r8 cmpl $0x10, %r8d jne 0x256a6 jmp 0x25989 movl $0xffffffc, %r14d # imm = 0xFFFFFFC movl $0x1a, %esi movl $0x2, %edx jmp 0x256cf popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/des.c
mbedtls_des_setkey_dec	int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] ) { int i; mbedtls_des_setkey( ctx->sk, key ); for( i = 0; i < 16; i += 2 ) { SWAP( ctx->sk[i ], ctx->sk[30 - i] ); SWAP( ctx->sk[i + 1], ctx->sk[31 - i] ); } return( 0 ); }	pushq %rbx movq %rdi, %rbx callq 0x2551b leaq 0x7c(%rbx), %rax movq $-0x2, %rcx movl 0x8(%rbx,%rcx,4), %edx movl -0x4(%rax), %esi movl %esi, 0x8(%rbx,%rcx,4) movl %edx, -0x4(%rax) movl 0xc(%rbx,%rcx,4), %edx movl (%rax), %esi movl %esi, 0xc(%rbx,%rcx,4) movl %edx, (%rax) addq $0x2, %rcx addq $-0x8, %rax cmpq $0xe, %rcx jb 0x259b2 xorl %eax, %eax popq %rbx retq	/Dragonchang[P]https_client/mbedtls/library/des.c
mbedtls_des_crypt_ecb	int mbedtls_des_crypt_ecb( mbedtls_des_context ctx, const unsigned char input[8], unsigned char output[8] ) { int i; uint32_t X, Y, T, SK; SK = ctx->sk; GET_UINT32_BE( X, input, 0 ); GET_UINT32_BE( Y, input, 4 ); DES_IP( X, Y ); for( i = 0; i < 8; i++ ) { DES_ROUND( Y, X ); DES_ROUND( X, Y ); } DES_FP( Y, X ); PUT_UINT32_BE( Y, output, 0 ); PUT_UINT32_BE( X, output, 4 ); return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, -0x10(%rsp) movq %rdi, -0x8(%rsp) movl (%rsi), %ecx movl 0x4(%rsi), %eax bswapl %ecx bswapl %eax movl %ecx, %edx shrl $0x4, %edx xorl %eax, %edx andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F xorl %edx, %eax shll $0x4, %edx xorl %ecx, %edx movl %edx, %esi shrl $0x10, %esi movzwl %ax, %ecx xorl %esi, %ecx xorl %ecx, %eax shll $0x10, %ecx xorl %edx, %ecx movl %eax, %edx shrl $0x2, %edx xorl %ecx, %edx andl $0x33333333, %edx # imm = 0x33333333 xorl %edx, %ecx shll $0x2, %edx xorl %eax, %edx movl %edx, %ebp shrl $0x8, %ebp xorl %ecx, %ebp andl $0xff00ff, %ebp # imm = 0xFF00FF xorl %ebp, %ecx shll $0x8, %ebp xorl %edx, %ebp roll %ebp movl %ebp, %eax xorl %ecx, %eax andl $0xaaaaaaaa, %eax # imm = 0xAAAAAAAA xorl %eax, %ebp xorl %ecx, %eax roll %eax xorl %ecx, %ecx movl $0xfc, %r13d movq -0x8(%rsp), %r8 leaq 0x8a92(%rip), %r11 # 0x2e6f0 leaq 0x8b8b(%rip), %rbx # 0x2e7f0 leaq 0x8c84(%rip), %r14 # 0x2e8f0 leaq 0x8d7d(%rip), %r15 # 0x2e9f0 leaq 0x8e76(%rip), %r12 # 0x2eaf0 movl %ebp, %edx movl (%r8,%rcx), %ebp xorl %edx, %ebp movl %edx, %edi movl %ebp, %edx andl $0x3f, %edx movl %ebp, %esi shrl $0x6, %esi andl %r13d, %esi leaq 0x8858(%rip), %r9 # 0x2e4f0 xorl (%r9,%rdx,4), %eax movl %ebp, %edx shrl $0xe, %edx andl %r13d, %edx shrl $0x16, %ebp andl %r13d, %ebp leaq 0x893f(%rip), %r10 # 0x2e5f0 xorl (%rsi,%r10), %eax movl %edi, %esi movl %edi, %r10d roll $0x1c, %esi xorl 0x4(%r8,%rcx), %esi xorl (%rdx,%r11), %eax movl %esi, %edx andl $0x3f, %edx xorl (%rbp,%rbx), %eax movl %esi, %ebp shrl $0x6, %ebp andl %r13d, %ebp xorl (%r14,%rdx,4), %eax movl %esi, %edx shrl $0xe, %edx andl %r13d, %edx shrl $0x16, %esi andl %r13d, %esi xorl (%rbp,%r15), %eax xorl (%rdx,%r12), %eax leaq 0x8ef7(%rip), %rdi # 0x2ebf0 xorl (%rsi,%rdi), %eax movl 0x8(%r8,%rcx), %esi xorl %eax, %esi movl %esi, %edx andl $0x3f, %edx movl (%r9,%rdx,4), %ebp movl %esi, %edx shrl $0x6, %edx andl %r13d, %edx leaq 0x88d5(%rip), %r9 # 0x2e5f0 xorl (%rdx,%r9), %ebp movl %esi, %edx shrl $0xe, %edx andl %r13d, %edx shrl $0x16, %esi andl %r13d, %esi xorl (%rdx,%r11), %ebp movl %eax, %edx roll $0x1c, %edx xorl 0xc(%r8,%rcx), %edx xorl (%rsi,%rbx), %ebp movl %edx, %esi andl $0x3f, %esi xorl (%r14,%rsi,4), %ebp movl %edx, %esi shrl $0x6, %esi andl %r13d, %esi xorl (%rsi,%r15), %ebp movl %edx, %esi shrl $0xe, %esi andl %r13d, %esi xorl (%rsi,%r12), %ebp shrl $0x16, %edx andl %r13d, %edx xorl (%rdx,%rdi), %ebp xorl %r10d, %ebp addq $0x10, %rcx cmpl $0x80, %ecx jne 0x25c7a rorl %ebp movl %ebp, %ecx xorl %eax, %ecx andl $0xaaaaaaaa, %ecx # imm = 0xAAAAAAAA xorl %ecx, %ebp xorl %eax, %ecx rorl %ecx movl %ecx, %edx shrl $0x8, %edx xorl %ebp, %edx andl $0xff00ff, %edx # imm = 0xFF00FF xorl %edx, %ebp shll $0x8, %edx xorl %ecx, %edx movl %edx, %eax shrl $0x2, %eax xorl %ebp, %eax andl $0x33333333, %eax # imm = 0x33333333 xorl %eax, %ebp shll $0x2, %eax xorl %edx, %eax movl %ebp, %ecx shrl $0x10, %ecx movzwl %ax, %edx xorl %ecx, %edx xorl %edx, %eax shll $0x10, %edx xorl %ebp, %edx movl %edx, %ecx shrl $0x4, %ecx xorl %eax, %ecx andl $0xf0f0f0f, %ecx # imm = 0xF0F0F0F xorl %ecx, %eax shll $0x4, %ecx xorl %edx, %ecx movl %ecx, %edx shrl $0x18, %edx movq -0x10(%rsp), %rsi movb %dl, (%rsi) movl %ecx, %edx shrl $0x10, %edx movb %dl, 0x1(%rsi) movb %ch, 0x2(%rsi) movb %cl, 0x3(%rsi) movl %eax, %ecx shrl $0x18, %ecx movb %cl, 0x4(%rsi) movl %eax, %ecx shrl $0x10, %ecx movb %cl, 0x5(%rsi) movb %ah, 0x6(%rsi) movb %al, 0x7(%rsi) xorl %eax, %eax popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/des.c
mbedtls_des_crypt_cbc	int mbedtls_des_crypt_cbc( mbedtls_des_context ctx, int mode, size_t length, unsigned char iv[8], const unsigned char input, unsigned char output ) { int i; unsigned char temp[8]; if( length % 8 ) return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH ); if( mode == MBEDTLS_DES_ENCRYPT ) { while( length > 0 ) { for( i = 0; i < 8; i++ ) output[i] = (unsigned char)( input[i] ^ iv[i] ); mbedtls_des_crypt_ecb( ctx, output, output ); memcpy( iv, output, 8 ); input += 8; output += 8; length -= 8; } } else / MBEDTLS_DES_DECRYPT */ { while( length > 0 ) { memcpy( temp, input, 8 ); mbedtls_des_crypt_ecb( ctx, input, output ); for( i = 0; i < 8; i++ ) output[i] = (unsigned char)( output[i] ^ iv[i] ); memcpy( iv, temp, 8 ); input += 8; output += 8; length -= 8; } } return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r12 movl $0xffffffce, %eax # imm = 0xFFFFFFCE testb $0x7, %r12b jne 0x25ebe movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movq %rdi, %r13 cmpl $0x1, %esi jne 0x25e83 testq %r12, %r12 je 0x25ebc xorl %eax, %eax movb (%r15,%rax), %cl xorb (%r14,%rax), %cl movb %cl, (%rbx,%rax) incq %rax cmpq $0x8, %rax jne 0x25e4b movq %r13, %rdi movq %rbx, %rsi movq %rbx, %rdx callq 0x25bcf movq (%rbx), %rax movq %rax, (%r15) addq $0x8, %r14 addq $0x8, %rbx addq $-0x8, %r12 jne 0x25e49 jmp 0x25ebc testq %r12, %r12 je 0x25ebc movq (%r14), %rbp movq %r13, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x25bcf xorl %eax, %eax movb (%r15,%rax), %cl xorb %cl, (%rbx,%rax) incq %rax cmpq $0x8, %rax jne 0x25e9b movq %rbp, (%r15) addq $0x8, %r14 addq $0x8, %rbx addq $-0x8, %r12 jne 0x25e88 xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/des.c
mbedtls_des3_crypt_ecb	int mbedtls_des3_crypt_ecb( mbedtls_des3_context ctx, const unsigned char input[8], unsigned char output[8] ) { int i; uint32_t X, Y, T, SK; SK = ctx->sk; GET_UINT32_BE( X, input, 0 ); GET_UINT32_BE( Y, input, 4 ); DES_IP( X, Y ); for( i = 0; i < 8; i++ ) { DES_ROUND( Y, X ); DES_ROUND( X, Y ); } for( i = 0; i < 8; i++ ) { DES_ROUND( X, Y ); DES_ROUND( Y, X ); } for( i = 0; i < 8; i++ ) { DES_ROUND( Y, X ); DES_ROUND( X, Y ); } DES_FP( Y, X ); PUT_UINT32_BE( Y, output, 0 ); PUT_UINT32_BE( X, output, 4 ); return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, -0x8(%rsp) movl (%rsi), %eax movl 0x4(%rsi), %ecx bswapl %eax bswapl %ecx movl %eax, %edx shrl $0x4, %edx xorl %ecx, %edx andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F xorl %edx, %ecx shll $0x4, %edx xorl %eax, %edx movl %edx, %esi shrl $0x10, %esi movzwl %cx, %eax xorl %esi, %eax xorl %eax, %ecx shll $0x10, %eax xorl %edx, %eax movl %ecx, %edx shrl $0x2, %edx xorl %eax, %edx andl $0x33333333, %edx # imm = 0x33333333 xorl %edx, %eax shll $0x2, %edx xorl %ecx, %edx movl %edx, %r14d shrl $0x8, %r14d xorl %eax, %r14d andl $0xff00ff, %r14d # imm = 0xFF00FF xorl %r14d, %eax shll $0x8, %r14d xorl %edx, %r14d roll %r14d movl %r14d, %ebp xorl %eax, %ebp andl $0xaaaaaaaa, %ebp # imm = 0xAAAAAAAA xorl %ebp, %r14d xorl %eax, %ebp roll %ebp xorl %r15d, %r15d movl $0xfc, %r12d leaq 0x8892(%rip), %r8 # 0x2e7f0 leaq 0x8a8b(%rip), %r10 # 0x2e9f0 leaq 0x8b84(%rip), %rax # 0x2eaf0 leaq 0x8c7d(%rip), %rcx # 0x2ebf0 movl %r14d, %r13d movl (%rdi,%r15), %r14d xorl %r13d, %r14d movq %rcx, %rsi movl %r14d, %edx andl $0x3f, %edx movq %rax, %rbx movl %r14d, %eax shrl $0x6, %eax andl %r12d, %eax leaq 0x8557(%rip), %rcx # 0x2e4f0 xorl (%rcx,%rdx,4), %ebp movl %r14d, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %r14d andl %r12d, %r14d leaq 0x863d(%rip), %r9 # 0x2e5f0 xorl (%rax,%r9), %ebp movl %r13d, %eax roll $0x1c, %eax xorl 0x4(%rdi,%r15), %eax movq %r8, %r9 leaq 0x8724(%rip), %r8 # 0x2e6f0 xorl (%rdx,%r8), %ebp movl %eax, %edx andl $0x3f, %edx xorl (%r14,%r9), %ebp movl %eax, %r14d shrl $0x6, %r14d andl %r12d, %r14d movq %r10, %r11 leaq 0x8903(%rip), %r10 # 0x2e8f0 xorl (%r10,%rdx,4), %ebp movl %eax, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %eax andl %r12d, %eax xorl (%r14,%r11), %ebp xorl (%rdx,%rbx), %ebp xorl (%rax,%rsi), %ebp movl 0x8(%rdi,%r15), %eax xorl %ebp, %eax movl %eax, %edx andl $0x3f, %edx movl (%rcx,%rdx,4), %r14d leaq 0x85d0(%rip), %rcx # 0x2e5f0 movl %eax, %edx shrl $0x6, %edx andl %r12d, %edx xorl (%rdx,%rcx), %r14d movl %eax, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %eax andl %r12d, %eax xorl (%rdx,%r8), %r14d movq %r9, %r8 movl %ebp, %edx roll $0x1c, %edx xorl 0xc(%rdi,%r15), %edx xorl (%rax,%r9), %r14d movl %edx, %eax andl $0x3f, %eax xorl (%r10,%rax,4), %r14d movq %r11, %r10 movl %edx, %eax shrl $0x6, %eax andl %r12d, %eax xorl (%rax,%r11), %r14d movl %edx, %eax shrl $0xe, %eax andl %r12d, %eax xorl (%rax,%rbx), %r14d movq %rbx, %rax shrl $0x16, %edx andl %r12d, %edx xorl (%rdx,%rsi), %r14d movq %rsi, %rcx xorl %r13d, %r14d addq $0x10, %r15 cmpl $0x80, %r15d jne 0x25f73 xorl %r15d, %r15d movl $0xfc, %r12d leaq 0x8849(%rip), %r10 # 0x2e8f0 movl %ebp, %r13d movl 0x80(%rdi,%r15), %ebp xorl %r13d, %ebp movl %ebp, %edx andl $0x3f, %edx movl %ebp, %eax shrl $0x6, %eax andl %r12d, %eax leaq 0x8427(%rip), %rcx # 0x2e4f0 xorl (%rcx,%rdx,4), %r14d movl %ebp, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %ebp andl %r12d, %ebp leaq 0x850e(%rip), %r8 # 0x2e5f0 xorl (%rax,%r8), %r14d movl %r13d, %eax roll $0x1c, %eax xorl 0x84(%rdi,%r15), %eax leaq 0x85f5(%rip), %r8 # 0x2e6f0 xorl (%rdx,%r8), %r14d movl %eax, %edx andl $0x3f, %edx xorl (%rbp,%r9), %r14d movl %eax, %ebp shrl $0x6, %ebp andl %r12d, %ebp xorl (%r10,%rdx,4), %r14d movl %eax, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %eax andl %r12d, %eax xorl (%rbp,%r11), %r14d xorl (%rdx,%rbx), %r14d xorl (%rax,%rsi), %r14d movl 0x88(%rdi,%r15), %eax xorl %r14d, %eax movl %eax, %edx andl $0x3f, %edx movl (%rcx,%rdx,4), %ebp movl %eax, %edx shrl $0x6, %edx andl %r12d, %edx leaq 0x849e(%rip), %rcx # 0x2e5f0 xorl (%rdx,%rcx), %ebp movl %eax, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %eax andl %r12d, %eax xorl (%rdx,%r8), %ebp movl %r14d, %edx roll $0x1c, %edx xorl 0x8c(%rdi,%r15), %edx xorl (%rax,%r9), %ebp movl %edx, %eax andl $0x3f, %eax xorl (%r10,%rax,4), %ebp movl %edx, %eax shrl $0x6, %eax andl %r12d, %eax xorl (%rax,%r11), %ebp movl %edx, %eax shrl $0xe, %eax andl %r12d, %eax xorl (%rax,%rbx), %ebp shrl $0x16, %edx andl %r12d, %edx xorl (%rdx,%rsi), %ebp xorl %r13d, %ebp addq $0x10, %r15 cmpl $0x80, %r15d jne 0x260a7 xorl %r15d, %r15d movl $0xfc, %r12d leaq 0x872a(%rip), %r10 # 0x2e8f0 movl %r14d, %r13d movl 0x100(%rdi,%r15), %r14d xorl %r13d, %r14d movl %r14d, %edx andl $0x3f, %edx movl %r14d, %eax shrl $0x6, %eax andl %r12d, %eax leaq 0x8306(%rip), %rcx # 0x2e4f0 xorl (%rcx,%rdx,4), %ebp movl %r14d, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %r14d andl %r12d, %r14d leaq 0x83ec(%rip), %r8 # 0x2e5f0 xorl (%rax,%r8), %ebp movl %r13d, %eax roll $0x1c, %eax xorl 0x104(%rdi,%r15), %eax leaq 0x84d3(%rip), %r8 # 0x2e6f0 xorl (%rdx,%r8), %ebp movl %eax, %edx andl $0x3f, %edx xorl (%r14,%r9), %ebp movl %eax, %r14d shrl $0x6, %r14d andl %r12d, %r14d xorl (%r10,%rdx,4), %ebp movl %eax, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %eax andl %r12d, %eax xorl (%r14,%r11), %ebp xorl (%rdx,%rbx), %ebp xorl (%rax,%rsi), %ebp movl 0x108(%rdi,%r15), %eax xorl %ebp, %eax movl %eax, %edx andl $0x3f, %edx movl (%rcx,%rdx,4), %r14d movl %eax, %edx shrl $0x6, %edx andl %r12d, %edx leaq 0x837e(%rip), %rcx # 0x2e5f0 xorl (%rdx,%rcx), %r14d movl %eax, %edx shrl $0xe, %edx andl %r12d, %edx shrl $0x16, %eax andl %r12d, %eax xorl (%rdx,%r8), %r14d movl %ebp, %edx roll $0x1c, %edx xorl 0x10c(%rdi,%r15), %edx xorl (%rax,%r9), %r14d movl %edx, %eax andl $0x3f, %eax xorl (%r10,%rax,4), %r14d movl %edx, %eax shrl $0x6, %eax andl %r12d, %eax xorl (%rax,%r11), %r14d movl %edx, %eax shrl $0xe, %eax andl %r12d, %eax xorl (%rax,%rbx), %r14d shrl $0x16, %edx andl %r12d, %edx xorl (%rdx,%rsi), %r14d xorl %r13d, %r14d addq $0x10, %r15 cmpl $0x80, %r15d jne 0x261c6 rorl %r14d movl %r14d, %eax xorl %ebp, %eax andl $0xaaaaaaaa, %eax # imm = 0xAAAAAAAA xorl %eax, %r14d xorl %ebp, %eax rorl %eax movl %eax, %ecx shrl $0x8, %ecx xorl %r14d, %ecx andl $0xff00ff, %ecx # imm = 0xFF00FF xorl %ecx, %r14d shll $0x8, %ecx xorl %eax, %ecx movl %ecx, %eax shrl $0x2, %eax xorl %r14d, %eax andl $0x33333333, %eax # imm = 0x33333333 xorl %eax, %r14d shll $0x2, %eax xorl %ecx, %eax movl %r14d, %ecx shrl $0x10, %ecx movzwl %ax, %edx xorl %ecx, %edx xorl %edx, %eax shll $0x10, %edx xorl %r14d, %edx movl %edx, %ecx shrl $0x4, %ecx xorl %eax, %ecx andl $0xf0f0f0f, %ecx # imm = 0xF0F0F0F xorl %ecx, %eax shll $0x4, %ecx xorl %edx, %ecx movl %ecx, %edx shrl $0x18, %edx movq -0x8(%rsp), %rsi movb %dl, (%rsi) movl %ecx, %edx shrl $0x10, %edx movb %dl, 0x1(%rsi) movb %ch, 0x2(%rsi) movb %cl, 0x3(%rsi) movl %eax, %ecx shrl $0x18, %ecx movb %cl, 0x4(%rsi) movl %eax, %ecx shrl $0x10, %ecx movb %cl, 0x5(%rsi) movb %ah, 0x6(%rsi) movb %al, 0x7(%rsi) xorl %eax, %eax popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/des.c
mbedtls_gcm_starts	int mbedtls_gcm_starts( mbedtls_gcm_context ctx, int mode, const unsigned char iv, size_t iv_len, const unsigned char add, size_t add_len ) { int ret; unsigned char work_buf[16]; size_t i; const unsigned char p; size_t use_len, olen = 0; /* IV and AD are limited to 2^64 bits, so 2^61 bytes / if( ( (uint64_t) iv_len ) >> 61 != 0 \|\| ( (uint64_t) add_len ) >> 61 != 0 ) { return( MBEDTLS_ERR_GCM_BAD_INPUT ); } memset( ctx->y, 0x00, sizeof(ctx->y) ); memset( ctx->buf, 0x00, sizeof(ctx->buf) ); ctx->mode = mode; ctx->len = 0; ctx->add_len = 0; if( iv_len == 12 ) { memcpy( ctx->y, iv, iv_len ); ctx->y[15] = 1; } else { memset( work_buf, 0x00, 16 ); PUT_UINT32_BE( iv_len 8, work_buf, 12 ); p = iv; while( iv_len > 0 ) { use_len = ( iv_len < 16 ) ? iv_len : 16; for( i = 0; i < use_len; i++ ) ctx->y[i] ^= p[i]; gcm_mult( ctx, ctx->y, ctx->y ); iv_len -= use_len; p += use_len; } for( i = 0; i < 16; i++ ) ctx->y[i] ^= work_buf[i]; gcm_mult( ctx, ctx->y, ctx->y ); } if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctx->y, 16, ctx->base_ectr, &olen ) ) != 0 ) { return( ret ); } ctx->add_len = add_len; p = add; while( add_len > 0 ) { use_len = ( add_len < 16 ) ? add_len : 16; for( i = 0; i < use_len; i++ ) ctx->buf[i] ^= p[i]; gcm_mult( ctx, ctx->buf, ctx->buf ); add_len -= use_len; p += use_len; } return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq $0x0, 0x20(%rsp) movq %r9, %rax orq %rcx, %rax shrq $0x3d, %rax movl $0xffffffec, %eax # imm = 0xFFFFFFEC jne 0x26c85 movq %r9, %rbx movq %r8, %r14 movq %rcx, %rbp movq %rdx, %r13 movq %rdi, %r15 leaq 0x178(%rdi), %r9 xorps %xmm0, %xmm0 movups %xmm0, 0x188(%rdi) movups %xmm0, 0x178(%rdi) movl %esi, 0x198(%rdi) movups %xmm0, 0x158(%rdi) cmpq $0xc, %rcx jne 0x26b5e movl 0x8(%r13), %eax movl %eax, 0x8(%r9) movq (%r13), %rax movq %rax, (%r9) movb $0x1, 0x187(%r15) jmp 0x26c0b movaps %xmm0, (%rsp) movl %ebp, %eax shrl $0x15, %eax movb %al, 0xc(%rsp) movl %ebp, %eax shrl $0xd, %eax movb %al, 0xd(%rsp) movl %ebp, %eax shrl $0x5, %eax movb %al, 0xe(%rsp) leal (,%rbp,8), %eax movb %al, 0xf(%rsp) testq %rbp, %rbp movq %r9, 0x18(%rsp) je 0x26bdd cmpq $0x10, %rbp movl $0x10, %r12d cmovbq %rbp, %r12 cmpq $0x1, %r12 movq %r12, %rax adcq $0x0, %rax xorl %ecx, %ecx movb (%r13,%rcx), %dl xorb %dl, 0x178(%r15,%rcx) incq %rcx cmpq %rcx, %rax jne 0x26bad movq %r15, %rdi movq %r9, %rsi movq %r9, %rdx callq 0x26c94 movq 0x18(%rsp), %r9 addq %r12, %r13 subq %r12, %rbp jne 0x26b92 movl $0x178, %eax # imm = 0x178 movb -0x178(%rsp,%rax), %cl xorb %cl, (%r15,%rax) incq %rax cmpq $0x188, %rax # imm = 0x188 jne 0x26be2 movq %r15, %rdi movq %r9, %rsi movq %r9, %rdx callq 0x26c94 movq 0x18(%rsp), %r9 leaq 0x168(%r15), %rcx leaq 0x20(%rsp), %r8 movl $0x10, %edx movq %r15, %rdi movq %r9, %rsi callq 0x24875 testl %eax, %eax jne 0x26c85 movq %rbx, 0x160(%r15) testq %rbx, %rbx je 0x26c83 leaq 0x188(%r15), %r12 cmpq $0x10, %rbx movl $0x10, %r13d cmovbq %rbx, %r13 cmpq $0x1, %r13 movq %r13, %rax adcq $0x0, %rax xorl %ecx, %ecx movb (%r14,%rcx), %dl xorb %dl, 0x188(%r15,%rcx) incq %rcx cmpq %rcx, %rax jne 0x26c59 movq %r15, %rdi movq %r12, %rsi movq %r12, %rdx callq 0x26c94 addq %r13, %r14 subq %r13, %rbx jne 0x26c3e xorl %eax, %eax addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/gcm.c
mbedtls_gcm_update	int mbedtls_gcm_update( mbedtls_gcm_context ctx, size_t length, const unsigned char input, unsigned char output ) { int ret; unsigned char ectr[16]; size_t i; const unsigned char p; unsigned char out_p = output; size_t use_len, olen = 0; if( output > input && (size_t) ( output - input ) < length ) return( MBEDTLS_ERR_GCM_BAD_INPUT ); / Total length is restricted to 2^39 - 256 bits, ie 2^36 - 2^5 bytes * Also check for possible overflow */ if( ctx->len + length < ctx->len \|\| (uint64_t) ctx->len + length > 0xFFFFFFFE0ull ) { return( MBEDTLS_ERR_GCM_BAD_INPUT ); } ctx->len += length; p = input; while( length > 0 ) { use_len = ( length < 16 ) ? length : 16; for( i = 16; i > 12; i-- ) if( ++ctx->y[i - 1] != 0 ) break; if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctx->y, 16, ectr, &olen ) ) != 0 ) { return( ret ); } for( i = 0; i < use_len; i++ ) { if( ctx->mode == MBEDTLS_GCM_DECRYPT ) ctx->buf[i] ^= p[i]; out_p[i] = ectr[i] ^ p[i]; if( ctx->mode == MBEDTLS_GCM_ENCRYPT ) ctx->buf[i] ^= out_p[i]; } gcm_mult( ctx, ctx->buf, ctx->buf ); length -= use_len; p += use_len; out_p += use_len; } return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, %rbx movq %rdx, %r14 movq $0x0, 0x8(%rsp) movq %rcx, %rax subq %rdx, %rax seta %cl cmpq %rsi, %rax setb %dl movl $0xffffffec, %eax # imm = 0xFFFFFFEC testb %dl, %cl jne 0x26f36 movq %rsi, %r15 movq %rdi, %r12 movq 0x158(%rdi), %rcx addq %rsi, %rcx setb %dl movabsq $0xfffffffe0, %rsi # imm = 0xFFFFFFFE0 cmpq %rsi, %rcx seta %sil orb %dl, %sil jne 0x26f36 movq %rcx, 0x158(%r12) testq %r15, %r15 je 0x26f34 leaq 0x178(%r12), %rax movq %rax, (%rsp) leaq 0x188(%r12), %rbp cmpq $0x10, %r15 movl $0x10, %r13d cmovbq %r15, %r13 movl $0x187, %eax # imm = 0x187 leaq -0x177(%rax), %rcx cmpq $0xd, %rcx jb 0x26eae incb (%r12,%rax) leaq -0x1(%rax), %rax je 0x26e97 movl $0x10, %edx movq %r12, %rdi movq (%rsp), %rsi leaq 0x10(%rsp), %rcx leaq 0x8(%rsp), %r8 callq 0x24875 testl %eax, %eax jne 0x26f36 cmpq $0x1, %r13 movq %r13, %rax adcq $0x0, %rax xorl %ecx, %ecx cmpl $0x0, 0x198(%r12) jne 0x26ef1 movb (%r14,%rcx), %dl xorb %dl, 0x188(%r12,%rcx) movb (%r14,%rcx), %dl xorb 0x10(%rsp,%rcx), %dl movb %dl, (%rbx,%rcx) cmpl $0x1, 0x198(%r12) jne 0x26f0f xorb %dl, 0x188(%r12,%rcx) incq %rcx cmpq %rcx, %rax jne 0x26eda movq %r12, %rdi movq %rbp, %rsi movq %rbp, %rdx callq 0x26c94 addq %r13, %r14 addq %r13, %rbx subq %r13, %r15 jne 0x26e84 xorl %eax, %eax addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/gcm.c
mbedtls_gcm_finish	int mbedtls_gcm_finish( mbedtls_gcm_context ctx, unsigned char tag, size_t tag_len ) { unsigned char work_buf[16]; size_t i; uint64_t orig_len = ctx->len * 8; uint64_t orig_add_len = ctx->add_len * 8; if( tag_len > 16 \|\| tag_len < 4 ) return( MBEDTLS_ERR_GCM_BAD_INPUT ); memcpy( tag, ctx->base_ectr, tag_len ); if( orig_len \|\| orig_add_len ) { memset( work_buf, 0x00, 16 ); PUT_UINT32_BE( ( orig_add_len >> 32 ), work_buf, 0 ); PUT_UINT32_BE( ( orig_add_len ), work_buf, 4 ); PUT_UINT32_BE( ( orig_len >> 32 ), work_buf, 8 ); PUT_UINT32_BE( ( orig_len ), work_buf, 12 ); for( i = 0; i < 16; i++ ) ctx->buf[i] ^= work_buf[i]; gcm_mult( ctx, ctx->buf, ctx->buf ); for( i = 0; i < tag_len; i++ ) tag[i] ^= ctx->buf[i]; } return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp leaq -0x11(%rdx), %rax movl $0xffffffec, %r15d # imm = 0xFFFFFFEC cmpq $-0xd, %rax jb 0x27085 movq %rdx, %rbp movq %rsi, %r14 movq %rdi, %r12 movq 0x158(%rdi), %r15 movq 0x160(%rdi), %rbx shlq $0x3, %r15 shlq $0x3, %rbx leaq 0x168(%rdi), %rsi movq %r14, %rdi callq 0xa110 movq %r15, %rdx xorl %r15d, %r15d movq %rdx, %rax orq %rbx, %rax je 0x27085 xorps %xmm0, %xmm0 movaps %xmm0, (%rsp) movq %rbx, %rax shrq $0x20, %rax movq %rbx, %rcx shrq $0x38, %rcx movb %cl, (%rsp) movq %rbx, %rcx shrq $0x30, %rcx movb %cl, 0x1(%rsp) movq %rbx, %rcx shrq $0x28, %rcx movb %cl, 0x2(%rsp) movb %al, 0x3(%rsp) movl %ebx, %eax shrl $0x18, %eax movb %al, 0x4(%rsp) movl %ebx, %eax shrl $0x10, %eax movb %al, 0x5(%rsp) movb %bh, 0x6(%rsp) movb %bl, 0x7(%rsp) movq %rdx, %rax shrq $0x20, %rax movq %rdx, %rcx shrq $0x38, %rcx movb %cl, 0x8(%rsp) movq %rdx, %rcx shrq $0x30, %rcx movb %cl, 0x9(%rsp) movq %rdx, %rcx shrq $0x28, %rcx movb %cl, 0xa(%rsp) movb %al, 0xb(%rsp) movl %edx, %eax shrl $0x18, %eax movb %al, 0xc(%rsp) movl %edx, %eax shrl $0x10, %eax movb %al, 0xd(%rsp) movb %dh, 0xe(%rsp) movb %dl, 0xf(%rsp) movl $0x188, %eax # imm = 0x188 movb -0x188(%rsp,%rax), %cl xorb %cl, (%r12,%rax) incq %rax cmpq $0x198, %rax # imm = 0x198 jne 0x2703e leaq 0x188(%r12), %r13 movq %r12, %rdi movq %r13, %rsi movq %r13, %rdx callq 0x26c94 testq %rbp, %rbp je 0x27085 xorl %r15d, %r15d xorl %eax, %eax movb (%r13,%rax), %cl xorb %cl, (%r14,%rax) incq %rax cmpq %rax, %rbp jne 0x27074 movl %r15d, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/gcm.c
mbedtls_gcm_auth_decrypt	int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context ctx, size_t length, const unsigned char iv, size_t iv_len, const unsigned char add, size_t add_len, const unsigned char tag, size_t tag_len, const unsigned char input, unsigned char output ) { int ret; unsigned char check_tag[16]; size_t i; int diff; if( ( ret = mbedtls_gcm_crypt_and_tag( ctx, MBEDTLS_GCM_DECRYPT, length, iv, iv_len, add, add_len, input, output, tag_len, check_tag ) ) != 0 ) { return( ret ); } /* Check tag in "constant-time" */ for( diff = 0, i = 0; i < tag_len; i++ ) diff \|= tag[i] ^ check_tag[i]; if( diff != 0 ) { mbedtls_zeroize( output, length ); return( MBEDTLS_ERR_GCM_AUTH_FAILED ); } return( 0 ); }	pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %r9, %rax movq %r8, %r9 movq %rcx, %r8 movq %rdx, %rcx movq %rsi, %rbx movq 0x48(%rsp), %r14 movq 0x38(%rsp), %r15 subq $0x8, %rsp leaq 0x8(%rsp), %r10 xorl %esi, %esi movq %rbx, %rdx pushq %r10 pushq %r15 pushq %r14 pushq 0x60(%rsp) pushq %rax callq 0x27097 addq $0x30, %rsp testl %eax, %eax je 0x27168 addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq movl $0x0, %eax testq %r15, %r15 je 0x2715e movq 0x30(%rsp), %rcx xorl %eax, %eax xorl %edx, %edx movb (%rsp,%rdx), %sil xorb (%rcx,%rdx), %sil movzbl %sil, %esi orl %esi, %eax incq %rdx cmpq %rdx, %r15 jne 0x2717b testl %eax, %eax je 0x271b0 movl $0xffffffee, %eax # imm = 0xFFFFFFEE testq %rbx, %rbx je 0x2715e xorl %ecx, %ecx movb $0x0, (%r14,%rcx) incq %rcx cmpq %rcx, %rbx jne 0x271a1 jmp 0x2715e xorl %eax, %eax jmp 0x2715e	/Dragonchang[P]https_client/mbedtls/library/gcm.c
mbedtls_blowfish_crypt_ecb	int mbedtls_blowfish_crypt_ecb( mbedtls_blowfish_context ctx, int mode, const unsigned char input[MBEDTLS_BLOWFISH_BLOCKSIZE], unsigned char output[MBEDTLS_BLOWFISH_BLOCKSIZE] ) { uint32_t X0, X1; GET_UINT32_BE( X0, input, 0 ); GET_UINT32_BE( X1, input, 4 ); if( mode == MBEDTLS_BLOWFISH_DECRYPT ) { blowfish_dec( ctx, &X0, &X1 ); } else / MBEDTLS_BLOWFISH_ENCRYPT */ { blowfish_enc( ctx, &X0, &X1 ); } PUT_UINT32_BE( X0, output, 0 ); PUT_UINT32_BE( X1, output, 4 ); return( 0 ); }	pushq %rbx subq $0x10, %rsp movq %rcx, %rbx movl (%rdx), %ecx bswapl %ecx movl %ecx, 0xc(%rsp) movl 0x4(%rdx), %eax bswapl %eax movl %eax, 0x8(%rsp) testl %esi, %esi je 0x279d3 leaq 0xc(%rsp), %rsi leaq 0x8(%rsp), %rdx callq 0x27936 jmp 0x27a3d movl $0x12, %edx movl $0xff, %esi movl %eax, %r8d movl %ecx, %eax xorl -0x4(%rdi,%rdx,4), %eax movl %eax, %r9d movl %eax, %r10d shrl $0x18, %r10d movl %eax, %ecx shrl $0xe, %ecx andl $0x3fc, %ecx # imm = 0x3FC movl 0x448(%rdi,%rcx), %ecx addl 0x48(%rdi,%r10,4), %ecx andl %esi, %r9d movl %eax, %r10d shrl $0x8, %r10d andl %esi, %r10d xorl 0x848(%rdi,%r10,4), %ecx addl 0xc48(%rdi,%r9,4), %ecx xorl %r8d, %ecx decq %rdx cmpq $0x2, %rdx ja 0x279dd xorl 0x4(%rdi), %ecx xorl (%rdi), %eax movl %eax, 0xc(%rsp) movl %ecx, 0x8(%rsp) movl 0xc(%rsp), %eax bswapl %eax movl %eax, (%rbx) movl 0x8(%rsp), %eax bswapl %eax movl %eax, 0x4(%rbx) xorl %eax, %eax addq $0x10, %rsp popq %rbx retq	/Dragonchang[P]https_client/mbedtls/library/blowfish.c
mbedtls_blowfish_crypt_cbc	int mbedtls_blowfish_crypt_cbc( mbedtls_blowfish_context ctx, int mode, size_t length, unsigned char iv[MBEDTLS_BLOWFISH_BLOCKSIZE], const unsigned char input, unsigned char *output ) { int i; unsigned char temp[MBEDTLS_BLOWFISH_BLOCKSIZE]; if( length % MBEDTLS_BLOWFISH_BLOCKSIZE ) return( MBEDTLS_ERR_BLOWFISH_INVALID_INPUT_LENGTH ); if( mode == MBEDTLS_BLOWFISH_DECRYPT ) { while( length > 0 ) { memcpy( temp, input, MBEDTLS_BLOWFISH_BLOCKSIZE ); mbedtls_blowfish_crypt_ecb( ctx, mode, input, output ); for( i = 0; i < MBEDTLS_BLOWFISH_BLOCKSIZE;i++ ) output[i] = (unsigned char)( output[i] ^ iv[i] ); memcpy( iv, temp, MBEDTLS_BLOWFISH_BLOCKSIZE ); input += MBEDTLS_BLOWFISH_BLOCKSIZE; output += MBEDTLS_BLOWFISH_BLOCKSIZE; length -= MBEDTLS_BLOWFISH_BLOCKSIZE; } } else { while( length > 0 ) { for( i = 0; i < MBEDTLS_BLOWFISH_BLOCKSIZE; i++ ) output[i] = (unsigned char)( input[i] ^ iv[i] ); mbedtls_blowfish_crypt_ecb( ctx, mode, output, output ); memcpy( iv, output, MBEDTLS_BLOWFISH_BLOCKSIZE ); input += MBEDTLS_BLOWFISH_BLOCKSIZE; output += MBEDTLS_BLOWFISH_BLOCKSIZE; length -= MBEDTLS_BLOWFISH_BLOCKSIZE; } } return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r12 movl $0xffffffe8, %eax # imm = 0xFFFFFFE8 testb $0x7, %r12b jne 0x27b08 movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movl %esi, %ebp movq %rdi, %r13 testl %esi, %esi je 0x27ac6 testq %r12, %r12 je 0x27b06 xorl %eax, %eax movb (%r15,%rax), %cl xorb (%r14,%rax), %cl movb %cl, (%rbx,%rax) incq %rax cmpq $0x8, %rax jne 0x27a8c movq %r13, %rdi movl %ebp, %esi movq %rbx, %rdx movq %rbx, %rcx callq 0x279a5 movq (%rbx), %rax movq %rax, (%r15) addq $0x8, %r14 addq $0x8, %rbx addq $-0x8, %r12 jne 0x27a8a jmp 0x27b06 testq %r12, %r12 je 0x27b06 movq %r13, (%rsp) movq (%r14), %r13 movq (%rsp), %rdi movl %ebp, %esi movq %r14, %rdx movq %rbx, %rcx callq 0x279a5 xorl %eax, %eax movb (%r15,%rax), %cl xorb %cl, (%rbx,%rax) incq %rax cmpq $0x8, %rax jne 0x27ae5 movq %r13, (%r15) addq $0x8, %r14 addq $0x8, %rbx addq $-0x8, %r12 jne 0x27acf xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/blowfish.c
mbedtls_camellia_setkey_dec	int mbedtls_camellia_setkey_dec( mbedtls_camellia_context ctx, const unsigned char key, unsigned int keybits ) { int idx, ret; size_t i; mbedtls_camellia_context cty; uint32_t RK; uint32_t SK; mbedtls_camellia_init( &cty ); /* Also checks keybits / if( ( ret = mbedtls_camellia_setkey_enc( &cty, key, keybits ) ) != 0 ) goto exit; ctx->nr = cty.nr; idx = ( ctx->nr == 4 ); RK = ctx->rk; SK = cty.rk + 24 2 + 8 * idx * 2; RK++ = SK++; RK++ = SK++; RK++ = SK++; RK++ = SK++; for( i = 22 + 8 * idx, SK -= 6; i > 0; i--, SK -= 4 ) { RK++ = SK++; RK++ = SK++; } SK -= 2; RK++ = SK++; RK++ = SK++; RK++ = SK++; RK++ = SK++; exit: mbedtls_camellia_free( &cty ); return( ret ); }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x118, %rsp # imm = 0x118 movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx leaq 0x4(%rsp), %r15 movl $0x114, %edx # imm = 0x114 movq %r15, %rdi xorl %esi, %esi callq 0xa0c0 movq %r15, %rdi movq %r14, %rsi movl %ebp, %edx callq 0x27c9b testl %eax, %eax jne 0x284aa movl 0x4(%rsp), %ecx movl %ecx, (%rbx) xorl %edx, %edx cmpl $0x4, %ecx sete %dl leal (,%rdx,8), %ecx shll $0x6, %edx movl 0xc8(%rsp,%rdx), %esi movl %esi, 0x4(%rbx) movl 0xcc(%rsp,%rdx), %esi movl %esi, 0x8(%rbx) movl 0xd0(%rsp,%rdx), %esi movl %esi, 0xc(%rbx) movl 0xd4(%rsp,%rdx), %edx movl %edx, 0x10(%rbx) addq $0x14, %rbx movq %rbx, %rdx movl 0xc0(%rsp,%rcx,8), %esi movl %esi, (%rbx) movl 0xc4(%rsp,%rcx,8), %esi movl %esi, 0x4(%rbx) decq %rcx addq $0x8, %rbx cmpq $-0x16, %rcx jne 0x2845f movl 0xb8(%rsp,%rcx,8), %esi movl %esi, 0x8(%rdx) movl 0xbc(%rsp,%rcx,8), %esi movl %esi, 0xc(%rdx) movl 0xc0(%rsp,%rcx,8), %esi movl %esi, 0x10(%rdx) movl 0xc4(%rsp,%rcx,8), %ecx movl %ecx, 0x14(%rdx) xorl %ecx, %ecx movb $0x0, 0x4(%rsp,%rcx) incq %rcx cmpq $0x114, %rcx # imm = 0x114 jne 0x284ac addq $0x118, %rsp # imm = 0x118 popq %rbx popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/camellia.c
mbedtls_camellia_crypt_ecb	int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context ctx, int mode, const unsigned char input[16], unsigned char output[16] ) { int NR; uint32_t RK, X[4]; ( (void) mode ); NR = ctx->nr; RK = ctx->rk; GET_UINT32_BE( X[0], input, 0 ); GET_UINT32_BE( X[1], input, 4 ); GET_UINT32_BE( X[2], input, 8 ); GET_UINT32_BE( X[3], input, 12 ); X[0] ^= RK++; X[1] ^= RK++; X[2] ^= RK++; X[3] ^= RK++; while( NR ) { --NR; camellia_feistel( X, RK, X + 2 ); RK += 2; camellia_feistel( X + 2, RK, X ); RK += 2; camellia_feistel( X, RK, X + 2 ); RK += 2; camellia_feistel( X + 2, RK, X ); RK += 2; camellia_feistel( X, RK, X + 2 ); RK += 2; camellia_feistel( X + 2, RK, X ); RK += 2; if( NR ) { FL(X[0], X[1], RK[0], RK[1]); RK += 2; FLInv(X[2], X[3], RK[0], RK[1]); RK += 2; } } X[2] ^= RK++; X[3] ^= RK++; X[0] ^= RK++; X[1] ^= RK++; PUT_UINT32_BE( X[2], output, 0 ); PUT_UINT32_BE( X[3], output, 4 ); PUT_UINT32_BE( X[0], output, 8 ); PUT_UINT32_BE( X[1], output, 12 ); return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r14 movl (%rdi), %ebp movl (%rdx), %eax bswapl %eax movl %eax, (%rsp) movl 0x4(%rdx), %esi bswapl %esi movl %esi, 0x4(%rsp) movl 0x8(%rdx), %edi bswapl %edi movl %edi, 0x8(%rsp) movl 0xc(%rdx), %edx bswapl %edx movl %edx, 0xc(%rsp) xorl 0x4(%r14), %eax movl %eax, (%rsp) xorl 0x8(%r14), %esi movl %esi, 0x4(%rsp) xorl 0xc(%r14), %edi movl %edi, 0x8(%rsp) xorl 0x10(%r14), %edx movq %rcx, %r13 addq $0x14, %r14 movl %edx, 0xc(%rsp) testl %ebp, %ebp je 0x285e0 leaq 0x8(%rsp), %r15 movq %rsp, %r12 movq %r12, %rdi movq %r14, %rsi movq %r15, %rdx callq 0x28305 leaq 0x8(%r14), %rsi movq %r15, %rdi movq %r12, %rdx callq 0x28305 leaq 0x10(%r14), %rsi movq %r12, %rdi movq %r15, %rdx callq 0x28305 leaq 0x18(%r14), %rsi movq %r15, %rdi movq %r12, %rdx callq 0x28305 leaq 0x20(%r14), %rsi movq %r12, %rdi movq %r15, %rdx callq 0x28305 leaq 0x28(%r14), %rsi movq %r15, %rdi movq %r12, %rdx callq 0x28305 cmpl $0x1, %ebp jne 0x2859a addq $0x30, %r14 jmp 0x285d8 movl (%rsp), %eax movl 0x30(%r14), %ecx andl %eax, %ecx roll %ecx xorl 0x4(%rsp), %ecx movl 0xc(%rsp), %edx movl %ecx, 0x4(%rsp) orl 0x34(%r14), %ecx xorl %eax, %ecx movl %ecx, (%rsp) movl 0x3c(%r14), %eax orl %edx, %eax xorl 0x8(%rsp), %eax movl %eax, 0x8(%rsp) andl 0x38(%r14), %eax roll %eax xorl %edx, %eax movl %eax, 0xc(%rsp) addq $0x40, %r14 decl %ebp jne 0x28536 movl 0x8(%rsp), %ebx xorl (%r14), %ebx movl %ebx, 0x8(%rsp) movl 0xc(%rsp), %edx xorl 0x4(%r14), %edx movl %edx, 0xc(%rsp) movl (%rsp), %ecx xorl 0x8(%r14), %ecx movl 0x4(%rsp), %eax movl %ecx, (%rsp) xorl 0xc(%r14), %eax movl %eax, 0x4(%rsp) movl %ebx, %esi shrl $0x18, %esi movq %r13, %rdi movb %sil, (%r13) movl %ebx, %esi shrl $0x10, %esi movb %sil, 0x1(%r13) movb %bh, 0x2(%rdi) movb %bl, 0x3(%r13) movl %edx, %esi shrl $0x18, %esi movb %sil, 0x4(%r13) movl %edx, %esi shrl $0x10, %esi movb %sil, 0x5(%r13) movb %dh, 0x6(%rdi) movb %dl, 0x7(%r13) movl %ecx, %edx shrl $0x18, %edx movb %dl, 0x8(%r13) movl %ecx, %edx shrl $0x10, %edx movb %dl, 0x9(%r13) movb %ch, 0xa(%rdi) movb %cl, 0xb(%r13) movl %eax, %ecx shrl $0x18, %ecx movb %cl, 0xc(%r13) movl %eax, %ecx shrl $0x10, %ecx movb %cl, 0xd(%r13) movb %ah, 0xe(%rdi) movb %al, 0xf(%r13) xorl %eax, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/Dragonchang[P]https_client/mbedtls/library/camellia.c
main	int main(int argc, char *argv) { char URL; int result; #ifdef O_BINARY # ifdef __HIGHC__ _setmode(stdout, O_BINARY); # else setmode(fileno(stdout), O_BINARY); # endif #endif memory_tracking_init(); /* * Setup proper locale from environment. This is needed to enable locale- * specific behaviour by the C library in order to test for undesired side * effects that could cause in libcurl. / #ifdef HAVE_SETLOCALE setlocale(LC_ALL, ""); #endif if(argc< 2) { fprintf(stderr, "Pass URL as argument please\n"); return 1; } test_argc = argc; test_argv = argv; if(argc>2) libtest_arg2=argv[2]; if(argc>3) libtest_arg3=argv[3]; URL = argv[1]; / provide this to the rest / fprintf(stderr, "URL: %s\n", URL); result = test(URL); #ifdef USE_NSS if(PR_Initialized()) / prevent valgrind from reporting possibly lost memory (fd cache, ...) */ PR_Cleanup(); #endif return result; }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movl $0x0, -0x4(%rbp) movl %edi, -0x8(%rbp) movq %rsi, -0x10(%rbp) jmp 0x2a88 movl $0x6, %edi leaq 0x604(%rip), %rsi # 0x3098 callq 0x20a0 cmpl $0x2, -0x8(%rbp) jge 0x2ac0 movq 0x253a(%rip), %rax # 0x4fe0 movq (%rax), %rdi leaq 0x6b7(%rip), %rsi # 0x3167 movb $0x0, %al callq 0x20f0 movl $0x1, -0x4(%rbp) jmp 0x2b38 movl -0x8(%rbp), %eax movl %eax, 0x2873(%rip) # 0x533c movq -0x10(%rbp), %rax movq %rax, 0x286c(%rip) # 0x5340 cmpl $0x2, -0x8(%rbp) jle 0x2ae9 movq -0x10(%rbp), %rax movq 0x10(%rax), %rax movq %rax, 0x25e7(%rip) # 0x50d0 cmpl $0x3, -0x8(%rbp) jle 0x2afe movq -0x10(%rbp), %rax movq 0x18(%rax), %rax movq %rax, 0x25da(%rip) # 0x50d8 movq -0x10(%rbp), %rax movq 0x8(%rax), %rax movq %rax, -0x18(%rbp) movq 0x24cf(%rip), %rax # 0x4fe0 movq (%rax), %rdi movq -0x18(%rbp), %rdx leaq 0x665(%rip), %rsi # 0x3184 movb $0x0, %al callq 0x20f0 movq -0x18(%rbp), %rdi callq 0x2240 movl %eax, -0x1c(%rbp) movl -0x1c(%rbp), %eax movl %eax, -0x4(%rbp) movl -0x4(%rbp), %eax addq $0x20, %rsp popq %rbp retq nopw %cs:(%rax,%rax) nopl (%rax,%rax)	/pelya[P]curl/tests/libtest/first.c
curlx_uitouc	unsigned char curlx_uitouc(unsigned int uinum) { #ifdef __INTEL_COMPILER # pragma warning(push) # pragma warning(disable:810) /* conversion may lose significant bits */ #endif DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR); return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR); #ifdef __INTEL_COMPILER # pragma warning(pop) #endif }	pushq %rbp movq %rsp, %rbp movl %edi, -0x4(%rbp) jmp 0x2d19 movl -0x4(%rbp), %eax andl $0xff, %eax popq %rbp retq nopw %cs:(%rax,%rax)	/pelya[P]curl/lib/warnless.c
curlx_uitosi	int curlx_uitosi(unsigned int uinum) { #ifdef __INTEL_COMPILER # pragma warning(push) # pragma warning(disable:810) /* conversion may lose significant bits */ #endif DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT); return (int) (uinum & (unsigned int) CURL_MASK_SINT); #ifdef __INTEL_COMPILER # pragma warning(pop) #endif }	pushq %rbp movq %rsp, %rbp movl %edi, -0x4(%rbp) jmp 0x2d39 movl -0x4(%rbp), %eax andl $0x7fffffff, %eax # imm = 0x7FFFFFFF popq %rbp retq nopw %cs:(%rax,%rax)	/pelya[P]curl/lib/warnless.c
api_dynamic_suite::dynamic_remove_back_n()	void dynamic_remove_back_n() { int array[4] = { 11, 22, 33, 44 }; vista::span<int> span(array); BOOST_TEST_EQ(span.size(), 4); BOOST_TEST_EQ(span.back(), 44); span.remove_back(2); BOOST_TEST_EQ(span.size(), 2); BOOST_TEST_EQ(span.back(), 22); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movaps 0x39a4(%rip), %xmm0 # 0x5d10 leaq 0x2c(%rsp), %r13 movaps %xmm0, -0xc(%r13) leaq 0x10(%rsp), %r12 movq $0x4, (%r12) leaq 0x1c(%rsp), %r15 movl $0x4, (%r15) movq %r15, (%rsp) leaq 0x30cf(%rip), %rdi # 0x5469 leaq 0x2fb7(%rip), %rsi # 0x5358 leaq 0x2c5e(%rip), %r14 # 0x5006 leaq 0x3194(%rip), %rbx # 0x5543 movq %r14, %rdx movl $0xf1, %ecx movq %rbx, %r8 movq %r12, %r9 callq 0x3c2c movl $0x2c, (%r12) movq %r12, (%rsp) leaq 0x2f76(%rip), %rbp # 0x534b leaq 0x2f7b(%rip), %rsi # 0x5357 movq %rbp, %rdi movq %r14, %rdx movl $0xf2, %ecx movq %rbx, %r8 movq %r13, %r9 callq 0x46a3 movq $0x2, (%r12) movl $0x2, (%r15) movq %r15, (%rsp) leaq 0x2fe4(%rip), %rsi # 0x53f0 leaq 0x10(%rsp), %r12 leaq 0x3051(%rip), %rdi # 0x5469 movq %r14, %rdx movl $0xf4, %ecx movq %rbx, %r8 movq %r12, %r9 callq 0x3c2c leaq 0x24(%rsp), %r9 movl $0x16, (%r12) movq %r12, (%rsp) leaq 0x2fac(%rip), %rsi # 0x53ef movq %rbp, %rdi movq %r14, %rdx movl $0xf5, %ecx movq %rbx, %r8 callq 0x46a3 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/breese[P]vista/test/span_suite.cpp
QtMWidgets::ScrollArea::qt_metacall(QMetaObject::Call, int, void**)	int QtMWidgets::ScrollArea::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = AbstractScrollArea::qt_metacall(_c, _id, _a); if (_id < 0) return _id; #ifndef QT_NO_PROPERTIES if (_c == QMetaObject::ReadProperty \|\| _c == QMetaObject::WriteProperty \|\| _c == QMetaObject::ResetProperty \|\| _c == QMetaObject::BindableProperty \|\| _c == QMetaObject::RegisterPropertyMetaType) { qt_static_metacall(this, _c, _id, _a); _id -= 2; } #endif // QT_NO_PROPERTIES return _id; }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rcx, %r14 movl %esi, %ebp movq %rdi, %r15 callq 0x5fea2 movl %eax, %ebx testl %eax, %eax js 0x61a27 cmpl $0x8, %ebp ja 0x61a27 movl $0x14e, %eax # imm = 0x14E btl %ebp, %eax jae 0x61a27 movq %r15, %rdi movl %ebp, %esi movl %ebx, %edx movq %r14, %rcx callq 0x6194c addl $-0x2, %ebx movl %ebx, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/igormironchik[P]qtmwidgets/build_O2/src/QtMWidgets_autogen/EWIEGA46WW/moc_scrollarea.cpp
QtMWidgets::Stepper::mouseReleaseEvent(QMouseEvent*)	void Stepper::mouseReleaseEvent( QMouseEvent * event ) { if( event->button() == Qt::LeftButton ) { d->button = StepperPrivate::NoButton; d->timer->stop(); event->accept(); } else event->ignore(); }	pushq %rbx movq %rsi, %rbx cmpl $0x1, 0x40(%rsi) jne 0x66171 movq 0x28(%rdi), %rax andl $0x0, 0x30(%rax) movq 0x38(%rax), %rdi callq 0x5cea0 movb $0x1, %al jmp 0x66173 xorl %eax, %eax movb %al, 0xc(%rbx) popq %rbx retq	/igormironchik[P]qtmwidgets/src/stepper.cpp
QtMWidgets::ScrollIndicator::ScrollIndicator(QColor const&, Qt::Orientation, QWidget*)	ScrollIndicator::ScrollIndicator( const QColor & c, Qt::Orientation o, QWidget * parent ) : QWidget( parent ) , policy( AbstractScrollArea::ScrollIndicatorAsNeeded ) , minimumSize( 10 ) , size( minimumSize ) , width( 3 ) , orientation( o ) , needPaint( false ) , color( c ) , animate( false ) , alpha( 255 ) { }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %edx, %ebx movq %rsi, %r14 movq %rdi, %r15 xorl %ebp, %ebp movq %rcx, %rsi xorl %edx, %edx callq 0x5ccb0 leaq 0x447a2(%rip), %rax # 0xaab30 leaq 0x10(%rax), %rcx movq %rcx, (%r15) addq $0x1c0, %rax # imm = 0x1C0 movq %rax, 0x10(%r15) movaps 0x2534a(%rip), %xmm0 # 0x8b6f0 movups %xmm0, 0x28(%r15) movabsq $0x300000000, %rax # imm = 0x300000000 movq %rax, 0x38(%r15) movl %ebx, 0x40(%r15) movb %bpl, 0x44(%r15) movups (%r14), %xmm0 movups %xmm0, 0x48(%r15) movb %bpl, 0x58(%r15) movl $0xff, 0x5c(%r15) addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::ScrollIndicator::drawIndicator(QPainter*, QColor const&)	void ScrollIndicator::drawIndicator( QPainter * p, const QColor & c ) { if( policy != AbstractScrollArea::ScrollIndicatorAlwaysOff ) { QColor paintColor = c; if( animate && policy != AbstractScrollArea::ScrollIndicatorAlwaysOn ) paintColor.setAlpha( alpha ); p->setPen( QPen( paintColor, width, Qt::SolidLine, Qt::RoundCap ) ); const int middle = width / 2; if( orientation == Qt::Horizontal ) p->drawLine( 0, middle, size, middle ); else p->drawLine( middle, 0, middle, size ); } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl 0x28(%rdi), %eax cmpl $0x1, %eax je 0x66532 movq %rsi, %rbx movq %rdi, %r14 movups (%rdx), %xmm0 movaps %xmm0, 0x10(%rsp) cmpl $0x2, %eax je 0x664b2 cmpb $0x0, 0x58(%r14) je 0x664b2 movl 0x5c(%r14), %esi leaq 0x10(%rsp), %rdi callq 0x5c180 leaq 0x8(%rsp), %r15 leaq 0x10(%rsp), %rsi pushq $0x1 popq %rbp movq %r15, %rdi movl %ebp, %edx callq 0x5c9f0 cvtsi2sdl 0x3c(%r14), %xmm0 movq %rsp, %rdi pushq $0x20 popq %rcx pushq $0x40 popq %r8 movq %r15, %rsi movl %ebp, %edx callq 0x5d9a0 movq %rsp, %rsi movq %rbx, %rdi callq 0x5da20 movq %rsp, %rdi callq 0x5c2f0 leaq 0x8(%rsp), %rdi callq 0x5daa0 movl 0x30(%r14), %r8d movl 0x3c(%r14), %eax pushq $0x2 popq %rcx cltd idivl %ecx cmpl $0x1, 0x40(%r14) jne 0x66524 movq %rbx, %rdi xorl %esi, %esi movl %eax, %edx movl %r8d, %ecx movl %eax, %r8d jmp 0x6652d movq %rbx, %rdi movl %eax, %esi xorl %edx, %edx movl %eax, %ecx callq 0x662e4 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq %rsp, %rdi callq 0x5c2f0 jmp 0x6654d movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x5daa0 movq %rbx, %rdi callq 0x5c7f0 nop	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::BlurEffect::BlurEffect(QColor const&, Qt::Orientation, QWidget*)	BlurEffect::BlurEffect( const QColor & c, Qt::Orientation o, QWidget * parent ) : QWidget( parent ) , policy( AbstractScrollArea::BlurAlwaysOff ) , orientation( o ) , color( c ) , pressure( 0 ) , darkBlurWidth( 4 ) , maxPressure( 20.0 ) { }	pushq %r15 pushq %r14 pushq %rbx movl %edx, %ebx movq %rsi, %r14 movq %rdi, %r15 movq %rcx, %rsi xorl %edx, %edx callq 0x5ccb0 leaq 0x447b2(%rip), %rax # 0xaad30 leaq 0x10(%rax), %rcx movq %rcx, (%r15) addq $0x1c0, %rax # imm = 0x1C0 movq %rax, 0x10(%r15) movl $0x3, 0x28(%r15) movl %ebx, 0x2c(%r15) movups (%r14), %xmm0 movups %xmm0, 0x30(%r15) movabsq $0x400000000, %rax # imm = 0x400000000 movq %rax, 0x40(%r15) movabsq $0x4034000000000000, %rax # imm = 0x4034000000000000 movq %rax, 0x48(%r15) popq %rbx popq %r14 popq %r15 retq	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::BlurEffect::drawBlur(QPainter*, QColor const&)	void BlurEffect::drawBlur( QPainter * p, const QColor & c ) { const QRect r = rect(); const qreal realPressure = qMin( (qreal) qAbs( pressure ) / maxPressure, 1.0 ); QColor c1 = c; c1.setAlpha( 255 * realPressure ); const QRect dark( ( orientation == Qt::Vertical ? r.x() + r.width() / 2 - 2 : r.x() ), ( orientation == Qt::Horizontal ? r.y() + r.height() / 2 - 2 : r.y() ), ( orientation == Qt::Vertical ? 4 : r.width() ), ( orientation == Qt::Horizontal ? 4 : r.height() ) ); p->setPen( Qt::NoPen ); p->setBrush( c1 ); p->drawEllipse( dark ); }	pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x30, %rsp movq %rdx, %r12 movq %rsi, %rbx movq %rdi, %r13 callq 0x5ed0a movq %rax, %r14 movl 0x40(%r13), %eax movl %eax, %ecx negl %ecx cmovsl %eax, %ecx cvtsi2sd %ecx, %xmm0 divsd 0x48(%r13), %xmm0 minsd 0x24f45(%rip), %xmm0 # 0x8b660 movq %rdx, %r15 movups (%r12), %xmm1 leaq 0x20(%rsp), %rdi movaps %xmm1, (%rdi) mulsd 0x24fcd(%rip), %xmm0 # 0x8b700 cvttsd2si %xmm0, %esi callq 0x5c180 movl 0x2c(%r13), %eax cmpl $0x2, %eax je 0x66778 cmpl $0x1, %eax jne 0x66792 movq %r14, %rcx shrq $0x20, %rcx movq %r15, %rax shrq $0x20, %rax subl %ecx, %eax incl %eax pushq $0x2 popq %rsi cltd idivl %esi addl %eax, %ecx addl $-0x2, %ecx subl %r14d, %r15d incl %r15d movl %r15d, %eax pushq $0x4 popq %rdx movl %edx, %r15d jmp 0x667b1 movl %r15d, %eax subl %r14d, %eax incl %eax pushq $0x2 popq %rcx cltd idivl %ecx leal (%r14,%rax), %edx addl $-0x2, %edx pushq $0x4 popq %rax jmp 0x6679d movl %r15d, %eax subl %r14d, %eax incl %eax movl %r14d, %edx shrq $0x20, %r14 movl %r14d, %ecx shrq $0x20, %r15 subl %r14d, %r15d incl %r15d movl %edx, %r14d movl %r14d, 0x10(%rsp) movl %ecx, 0x14(%rsp) addl %r14d, %eax decl %eax movl %eax, 0x18(%rsp) leal (%rcx,%r15), %eax decl %eax movl %eax, 0x1c(%rsp) movq %rbx, %rdi xorl %esi, %esi callq 0x5d2b0 leaq 0x8(%rsp), %r14 leaq 0x20(%rsp), %rsi pushq $0x1 popq %rdx movq %r14, %rdi callq 0x5c9f0 movq %rbx, %rdi movq %r14, %rsi callq 0x5cb80 leaq 0x8(%rsp), %rdi callq 0x5daa0 leaq 0x10(%rsp), %rsi movq %rbx, %rdi callq 0x5c060 addq $0x30, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x5daa0 movq %rbx, %rdi callq 0x5c7f0 nop	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollAreaPrivate::init()	void AbstractScrollAreaPrivate::init() { QStyleOption opt; opt.initFrom( q ); const QColor ic = opt.palette.color( QPalette::Highlight ); viewport = new QWidget( q ); viewport->setObjectName( QLatin1String( "qt_scrollarea_viewport" ) ); viewport->setBackgroundRole( QPalette::Base ); viewport->setAutoFillBackground( true ); viewport->setFocusProxy( q ); viewport->setContentsMargins( 0, 0, 0, 0 ); horIndicator = new ScrollIndicator( ic, Qt::Horizontal, viewport ); vertIndicator = new ScrollIndicator( ic, Qt::Vertical, viewport ); horBlur = new BlurEffect( ic, Qt::Vertical, viewport ); vertBlur = new BlurEffect( ic, Qt::Horizontal, viewport ); horBlurAnim = new QVariantAnimation( q ); horBlurAnim->setDuration( 300 ); horBlurAnim->setLoopCount( 1 ); vertBlurAnim = new QVariantAnimation( q ); vertBlurAnim->setDuration( 300 ); vertBlurAnim->setLoopCount( 1 ); animationTimer = new QTimer( q ); animationTimer->setSingleShot( true ); startBlurAnimTimer = new QTimer( q ); startBlurAnimTimer->setSingleShot( true ); scroller = new Scroller( q, q ); q->setFocusPolicy( Qt::WheelFocus ); q->setFrameStyle( QFrame::NoFrame \| QFrame::Plain ); q->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ); layoutChildren( opt ); }	pushq %r14 pushq %rbx subq $0x68, %rsp movq %rdi, %rbx leaq 0x28(%rsp), %r14 pushq $0x1 popq %rsi movq %r14, %rdi xorl %edx, %edx callq 0x5dc50 movq 0x8(%rbx), %rsi movq %r14, %rdi callq 0x5c160 leaq 0x50(%rsp), %rdi pushq $0xc popq %rsi callq 0x5f828 movups (%rax), %xmm0 movaps %xmm0, (%rsp) pushq $0x28 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x8(%rbx), %rsi movq %rax, %rdi xorl %edx, %edx callq 0x5d9c0 movq %r14, 0x20(%rbx) leaq 0x24e76(%rip), %rdx # 0x8b708 leaq 0x10(%rsp), %rdi pushq $0x16 popq %rsi callq 0x68596 leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x5c490 leaq 0x10(%rsp), %rdi callq 0x5edf4 movq 0x20(%rbx), %rdi pushq $0x9 popq %rsi callq 0x5d330 movq 0x20(%rbx), %rdi pushq $0x1 popq %rsi callq 0x5d130 movq 0x8(%rbx), %rsi movq 0x20(%rbx), %rdi callq 0x5cd80 movq 0x20(%rbx), %rdi xorl %esi, %esi xorl %edx, %edx xorl %ecx, %ecx xorl %r8d, %r8d callq 0x5d950 pushq $0x60 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x20(%rbx), %rcx movq %rsp, %rsi pushq $0x1 popq %rdx movq %rax, %rdi callq 0x6636c movq %r14, 0x58(%rbx) pushq $0x60 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x20(%rbx), %rcx movq %rsp, %rsi pushq $0x2 popq %rdx movq %rax, %rdi callq 0x6636c movq %r14, 0x60(%rbx) pushq $0x50 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x20(%rbx), %rcx movq %rsp, %rsi pushq $0x2 popq %rdx movq %rax, %rdi callq 0x66560 movq %r14, 0x88(%rbx) pushq $0x50 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x20(%rbx), %rcx movq %rsp, %rsi pushq $0x1 popq %rdx movq %rax, %rdi callq 0x66560 movq %r14, 0x90(%rbx) pushq $0x10 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x8(%rbx), %rsi movq %rax, %rdi callq 0x5d4b0 movq %r14, 0x98(%rbx) movq %r14, %rdi movl $0x12c, %esi # imm = 0x12C callq 0x5d030 movq 0x98(%rbx), %rdi pushq $0x1 popq %rsi callq 0x5c2b0 pushq $0x10 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x8(%rbx), %rsi movq %rax, %rdi callq 0x5d4b0 movq %r14, 0xa0(%rbx) movq %r14, %rdi movl $0x12c, %esi # imm = 0x12C callq 0x5d030 movq 0xa0(%rbx), %rdi pushq $0x1 popq %rsi callq 0x5c2b0 pushq $0x10 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x8(%rbx), %rsi movq %rax, %rdi callq 0x5d470 movq %r14, 0x68(%rbx) pushq $0x1 popq %rsi movq %r14, %rdi callq 0x5dad0 pushq $0x10 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x8(%rbx), %rsi movq %rax, %rdi callq 0x5d470 movq %r14, 0x70(%rbx) pushq $0x1 popq %rsi movq %r14, %rdi callq 0x5dad0 pushq $0x18 popq %rdi callq 0x5d090 movq %rax, %r14 movq 0x8(%rbx), %rdx movq %rax, %rdi movq %rdx, %rsi callq 0x6c8c8 movq %r14, 0x80(%rbx) movq 0x8(%rbx), %rdi pushq $0xf popq %rsi callq 0x5d3e0 movq 0x8(%rbx), %rdi pushq $0x10 popq %rsi callq 0x5dba0 movq 0x8(%rbx), %rdi movl $0x770000, %esi # imm = 0x770000 callq 0x5c1d0 leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x66afc leaq 0x28(%rsp), %rdi callq 0x5c500 addq $0x68, %rsp popq %rbx popq %r14 retq movq %rax, %rbx pushq $0x18 jmp 0x66ad9 jmp 0x66aaa jmp 0x66aaa jmp 0x66aaa movq %rax, %rbx pushq $0x10 jmp 0x66ad9 jmp 0x66ab3 movq %rax, %rbx pushq $0x50 jmp 0x66ad9 jmp 0x66abc movq %rax, %rbx pushq $0x60 jmp 0x66ad9 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x5edf4 jmp 0x66ae9 jmp 0x66ae6 movq %rax, %rbx pushq $0x28 popq %rsi movq %r14, %rdi callq 0x5c190 jmp 0x66ae9 jmp 0x66ae6 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x5c500 movq %rbx, %rdi callq 0x5c7f0 nop	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollAreaPrivate::layoutChildren(QStyleOption const&)	void AbstractScrollAreaPrivate::layoutChildren( const QStyleOption & opt ) { QRect viewportRect = q->contentsRect(); if( q->isRightToLeft() ) viewportRect.adjust( right, top, -left, -bottom ); else viewportRect.adjust( left, top, -right, -bottom ); viewport->setGeometry( QStyle::visualRect( opt.direction, opt.rect, viewportRect ) ); horBlur->resize( horBlur->sizeHint().width(), viewportRect.height() * 0.75 ); vertBlur->resize( viewportRect.width() * 0.75, vertBlur->sizeHint().height() ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r15 movq %rdi, %rbx movq 0x8(%rdi), %rdi callq 0x5c970 movq %rax, %r13 movq %rdx, %r12 leaq 0x18(%rsp), %r14 movq %rax, (%r14) movq %rdx, 0x8(%r14) movq 0x8(%rbx), %rdi callq 0x685fc movzbl %al, %ecx xorb $0x1, %al movzbl %al, %eax movl 0x40(%rbx,%rax,4), %eax addl %r13d, %eax movq %r12, %rdx shrq $0x20, %rdx subl 0x3c(%rbx), %edx shrq $0x20, %r13 addl 0x38(%rbx), %r13d subl 0x40(%rbx,%rcx,4), %r12d movl %eax, (%r14) movl %r13d, 0x4(%r14) movl %r12d, 0x8(%r14) movl %edx, 0xc(%r14) movq 0x20(%rbx), %r12 movl 0xc(%r15), %edi addq $0x10, %r15 movq %r15, %rsi movq %r14, %rdx callq 0x5d710 leaq 0x8(%rsp), %rsi movq %rax, (%rsi) movq %rdx, 0x8(%rsi) movq %r12, %rdi callq 0x5c790 movq 0x88(%rbx), %r15 movq (%r15), %rax movq %r15, %rdi callq 0x70(%rax) movl 0xc(%r14), %ecx subl 0x4(%r14), %ecx incl %ecx cvtsi2sd %ecx, %xmm0 mulsd 0x24af6(%rip), %xmm0 # 0x8b6b0 cvttsd2si %xmm0, %edx movq %r15, %rdi movl %eax, %esi callq 0x5ecb8 movl 0x8(%r14), %eax subl (%r14), %eax movq 0x90(%rbx), %rbx incl %eax cvtsi2sd %eax, %xmm0 mulsd 0x24acc(%rip), %xmm0 # 0x8b6b0 cvttsd2si %xmm0, %ebp movq (%rbx), %rax movq %rbx, %rdi callq 0x70(%rax) shrq $0x20, %rax movq %rbx, %rdi movl %ebp, %esi movl %eax, %edx callq 0x5ecb8 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollAreaPrivate::normalizePosition()	void AbstractScrollAreaPrivate::normalizePosition() { if( topLeftCorner.x() < 0 ) topLeftCorner.setX( 0 ); if( topLeftCorner.y() < 0 ) topLeftCorner.setY( 0 ); const QSize s = viewport->size(); const QPoint maxPos = QPoint( scrolledAreaSize.width() - s.width(), scrolledAreaSize.height() - s.height() ); if( scrolledAreaSize.width() > s.width() ) { if( maxPos.x() < topLeftCorner.x() ) topLeftCorner.setX( maxPos.x() ); } else topLeftCorner.setX( 0 ); if( scrolledAreaSize.height() > s.height() ) { if( maxPos.y() < topLeftCorner.y() ) topLeftCorner.setY( maxPos.y() ); } else topLeftCorner.setY( 0 ); }	pushq %rbx movq %rdi, %rbx cmpl $0x0, 0x30(%rdi) jns 0x66c1e andl $0x0, 0x30(%rbx) cmpl $0x0, 0x34(%rbx) jns 0x66c28 andl $0x0, 0x34(%rbx) movq 0x20(%rbx), %rdi callq 0x6860a movq %rax, %rcx shrq $0x20, %rcx movl 0x28(%rbx), %edi movl 0x2c(%rbx), %edx xorl %esi, %esi subl %eax, %edi jle 0x66c4b movl %edi, %esi cmpl 0x30(%rbx), %edi jge 0x66c4e movl %esi, 0x30(%rbx) xorl %eax, %eax cmpl %ecx, %edx jle 0x66c5d subl %ecx, %edx movl %edx, %eax cmpl 0x34(%rbx), %edx jge 0x66c60 movl %eax, 0x34(%rbx) popq %rbx retq	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollAreaPrivate::calcIndicator(Qt::Orientation, int, int, bool&, int&, QPoint&)	void AbstractScrollAreaPrivate::calcIndicator( Qt::Orientation orient, int minSize, int width, bool & needPaint, int & indicatorSize, QPoint & indicatorPos ) { int viewportSize = 0; int scrolledSize = 0; int x = 0; int y = 0; double posRatio = 0.0; int totalIndicatorSize = 0; double ratio = 0.0; double deltaRatio = 0.0; switch( orient ) { case Qt::Horizontal : { viewportSize = viewport->width(); scrolledSize = scrolledAreaSize.width(); x = 2 * width; y = qMin( viewport->height(), scrolledAreaSize.height() ) - x; y += ( horIndicator->parent() == viewport ? 0 : topLeftCorner.y() ); posRatio = (double) topLeftCorner.x() / (double) scrolledSize; totalIndicatorSize = qMin( viewportSize, scrolledSize ) - 4 * width; ratio = (double) viewportSize / (double) scrolledSize; deltaRatio = posRatio; if( ratio < 1.0 ) { indicatorSize = (double) totalIndicatorSize * ratio; if( indicatorSize < minSize ) { deltaRatio = ( (double) indicatorSize / (double) minSize ); indicatorSize = minSize; } x += totalIndicatorSize deltaRatio + ( horIndicator->parent() == viewport ? 0 : scrolledSize ) * posRatio; } else { needPaint = false; indicatorSize = totalIndicatorSize; } indicatorPos = QPoint( x, y ); } break; case Qt::Vertical : { viewportSize = viewport->height(); scrolledSize = scrolledAreaSize.height(); y = 2 * width; x = qMin( viewport->width(), scrolledAreaSize.width() ) - y; x += ( vertIndicator->parent() == viewport ? 0 : topLeftCorner.x() ); posRatio = (double) topLeftCorner.y() / (double) scrolledSize; totalIndicatorSize = qMin( viewportSize, scrolledSize ) - 4 * width; ratio = (double) viewportSize / (double) scrolledSize; deltaRatio = posRatio; if( ratio < 1.0 ) { indicatorSize = (double) totalIndicatorSize * ratio; if( indicatorSize < minSize ) { deltaRatio = ( (double) indicatorSize / (double) minSize ); indicatorSize = minSize; } y += totalIndicatorSize deltaRatio + ( vertIndicator->parent() == viewport ? 0 : scrolledSize ) * posRatio; } else { needPaint = false; indicatorSize = totalIndicatorSize; } indicatorPos = QPoint( x, y ); } break; } }	pushq %rbp pushq %r14 pushq %rbx cmpl $0x2, %esi je 0x66dd5 cmpl $0x1, %esi jne 0x66eed movq 0x20(%rdi), %r10 movq 0x20(%r10), %rsi movl 0x1c(%rsi), %ebp movl 0x20(%rsi), %eax subl 0x14(%rsi), %ebp incl %ebp movl 0x28(%rdi), %ebx subl 0x18(%rsi), %eax leal (%rcx,%rcx), %esi incl %eax movl 0x2c(%rdi), %r11d cmpl %r11d, %eax cmovgel %r11d, %eax subl %esi, %eax movq 0x58(%rdi), %r11 movq 0x8(%r11), %r11 movq 0x10(%r11), %r11 xorl %r14d, %r14d cmpq %r10, %r11 je 0x66d65 movl 0x34(%rdi), %r14d cvtsi2sd %ebx, %xmm0 addl %r14d, %eax cmpl %ebx, %ebp cmovll %ebp, %ebx shll $0x2, %ecx subl %ecx, %ebx cvtsi2sd %ebp, %xmm2 divsd %xmm0, %xmm2 movsd 0x248da(%rip), %xmm1 # 0x8b660 ucomisd %xmm2, %xmm1 jbe 0x66e7d cvtsi2sd %ebx, %xmm1 mulsd %xmm1, %xmm2 cvttsd2si %xmm2, %ecx cvtsi2sd %edx, %xmm3 movd %ecx, %xmm2 movd 0x30(%rdi), %xmm4 punpckldq %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1] cvtdq2pd %xmm2, %xmm2 unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0] divpd %xmm3, %xmm2 movapd %xmm2, %xmm3 unpckhpd %xmm2, %xmm3 # xmm3 = xmm3[1],xmm2[1] cmpl %edx, %ecx cmovgl %ecx, %edx jl 0x66e85 movapd %xmm3, %xmm2 jmp 0x66e89 movq 0x20(%rdi), %r10 movq 0x20(%r10), %rax movl 0x1c(%rax), %esi movl 0x20(%rax), %ebp subl 0x18(%rax), %ebp incl %ebp movl 0x2c(%rdi), %ebx subl 0x14(%rax), %esi leal (%rcx,%rcx), %eax incl %esi movl 0x28(%rdi), %r11d cmpl %r11d, %esi cmovgel %r11d, %esi subl %eax, %esi movq 0x60(%rdi), %r11 movq 0x8(%r11), %r11 movq 0x10(%r11), %r11 xorl %r14d, %r14d cmpq %r10, %r11 je 0x66e18 movl 0x30(%rdi), %r14d cvtsi2sd %ebx, %xmm0 addl %r14d, %esi cmpl %ebx, %ebp cmovll %ebp, %ebx shll $0x2, %ecx subl %ecx, %ebx cvtsi2sd %ebp, %xmm2 divsd %xmm0, %xmm2 movsd 0x24827(%rip), %xmm1 # 0x8b660 ucomisd %xmm2, %xmm1 jbe 0x66e7d cvtsi2sd %ebx, %xmm1 mulsd %xmm1, %xmm2 cvttsd2si %xmm2, %ecx cvtsi2sd %edx, %xmm3 movd %ecx, %xmm2 movd 0x34(%rdi), %xmm4 punpckldq %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1] cvtdq2pd %xmm2, %xmm2 unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0] divpd %xmm3, %xmm2 movapd %xmm2, %xmm3 unpckhpd %xmm2, %xmm3 # xmm3 = xmm3[1],xmm2[1] cmpl %edx, %ecx cmovgl %ecx, %edx jl 0x66eb0 movapd %xmm3, %xmm2 jmp 0x66eb4 movb $0x0, (%r8) movl %ebx, %edx jmp 0x66ed9 mulsd %xmm3, %xmm2 pxor %xmm4, %xmm4 cmpq %r10, %r11 je 0x66e96 movapd %xmm0, %xmm4 mulsd %xmm3, %xmm4 mulsd %xmm2, %xmm1 cvtsi2sd %esi, %xmm0 addsd %xmm4, %xmm1 addsd %xmm1, %xmm0 cvttsd2si %xmm0, %esi jmp 0x66ed9 mulsd %xmm3, %xmm2 pxor %xmm4, %xmm4 cmpq %r10, %r11 je 0x66ec1 movapd %xmm0, %xmm4 mulsd %xmm3, %xmm4 mulsd %xmm2, %xmm1 cvtsi2sd %eax, %xmm0 addsd %xmm4, %xmm1 addsd %xmm1, %xmm0 cvttsd2si %xmm0, %eax movq 0x20(%rsp), %rcx movl %edx, (%r9) shlq $0x20, %rax movl %esi, %edx orq %rax, %rdx movq %rdx, (%rcx) popq %rbx popq %r14 popq %rbp retq	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollAreaPrivate::makeBlurEffectIfNeeded()	void AbstractScrollAreaPrivate::makeBlurEffectIfNeeded() { if( horBlur->policy != AbstractScrollArea::BlurAlwaysOff ) { const QRect r = viewport->rect(); const QPoint p = topLeftCorner; normalizePosition(); const QSize s = viewport->size(); const QPoint maxPos = QPoint( scrolledAreaSize.width() - s.width(), scrolledAreaSize.height() - s.height() ); if( p.x() < 0 \|\| ( horBlur->pressure < 0 && maxPos.x() >= p.x() ) ) { if( horBlur->pressure <= 0 && horBlur->pressure + p.x() > 0 ) horBlur->pressure = 0; else if( qAbs( horBlur->pressure + p.x() ) > horBlur->maxPressure ) horBlur->pressure = ( horBlur->pressure < 0 ? - horBlur->maxPressure : horBlur->maxPressure ); else horBlur->pressure += p.x(); horBlur->move( ( horBlur->parent() == viewport ? r.x() : topLeftCorner.x() ) - horBlur->width() / 2, ( horBlur->parent() == viewport ? r.y() : topLeftCorner.y() ) + ( r.height() - horBlur->height() ) / 2 ); } if( p.y() < 0 \|\| ( vertBlur->pressure < 0 && maxPos.y() >= p.y() ) ) { if( vertBlur->pressure <= 0 && vertBlur->pressure + p.y() > 0 ) vertBlur->pressure = 0; else if( qAbs( vertBlur->pressure + p.y() ) > vertBlur->maxPressure ) vertBlur->pressure = ( vertBlur->pressure < 0 ? - vertBlur->maxPressure : vertBlur->maxPressure ); else vertBlur->pressure += p.y(); vertBlur->move( ( vertBlur->parent() == viewport ? r.x() : topLeftCorner.x() ) + ( r.width() - vertBlur->width() ) / 2, ( vertBlur->parent() == viewport ? r.y() : topLeftCorner.y() ) - vertBlur->height() / 2 ); } if( maxPos.x() < p.x() \|\| ( horBlur->pressure > 0 && p.x() > 0 ) ) { if( horBlur->pressure >= 0 && horBlur->pressure + p.x() - maxPos.x() < 0 ) horBlur->pressure = 0; else if( qAbs( horBlur->pressure + p.x() - maxPos.x() ) > horBlur->maxPressure ) horBlur->pressure = ( horBlur->pressure < 0 ? - horBlur->maxPressure : horBlur->maxPressure ); else horBlur->pressure += ( p.x() - maxPos.x() ); horBlur->move( ( horBlur->parent() == viewport ? r.x() : topLeftCorner.x() ) + r.width() - horBlur->width() / 2, ( horBlur->parent() == viewport ? r.y() : topLeftCorner.y() ) + ( r.height() - horBlur->height() ) / 2 ); } if( maxPos.y() < p.y() \|\| ( vertBlur->pressure > 0 && p.y() > 0 ) ) { if( vertBlur->pressure >= 0 && vertBlur->pressure + p.y() - maxPos.y() < 0 ) vertBlur->pressure = 0; else if( qAbs( vertBlur->pressure + p.y() - maxPos.y() ) > vertBlur->maxPressure ) vertBlur->pressure = ( vertBlur->pressure < 0 ? - vertBlur->maxPressure : vertBlur->maxPressure ); else vertBlur->pressure += ( p.y() - maxPos.y() ); vertBlur->move( ( vertBlur->parent() == viewport ? r.x() : topLeftCorner.x() ) + ( r.width() - vertBlur->width() ) / 2, ( vertBlur->parent() == viewport ? r.y() : topLeftCorner.y() ) + r.height() - vertBlur->height() / 2 ); } if( horBlur->pressure != 0 ) { horBlur->raise(); horBlur->show(); horBlur->update(); } else horBlur->hide(); if( vertBlur->pressure != 0 ) { vertBlur->raise(); vertBlur->show(); vertBlur->update(); } else vertBlur->hide(); } else normalizePosition(); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx movq 0x88(%rdi), %rax cmpl $0x3, 0x28(%rax) jne 0x66ffe movq %rbx, %rdi addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x66c10 movq 0x20(%rbx), %rdi callq 0x5ed0a movq %rax, %r15 movq %rdx, %r14 movq 0x30(%rbx), %r13 movq %r13, %rax shrq $0x20, %rax movq %rax, 0x10(%rsp) movq %rbx, %rdi callq 0x66c10 movq 0x20(%rbx), %rdi callq 0x6860a movq %rax, %r12 movl 0x28(%rbx), %ebp subl %r12d, %ebp shrq $0x20, %r12 movl 0x2c(%rbx), %r9d movq 0x88(%rbx), %rdi movl 0x40(%rdi), %eax testl %r13d, %r13d js 0x6705f testl %eax, %eax jns 0x67107 cmpl %ebp, %r13d jg 0x67107 movl %r9d, 0xc(%rsp) testl %eax, %eax setle %sil leal (%rax,%r13), %ecx testl %ecx, %ecx setg %r8b xorl %edx, %edx testb %r8b, %sil jne 0x670a3 movl %ecx, %edx negl %edx cmovsl %ecx, %edx cvtsi2sd %edx, %xmm1 movsd 0x48(%rdi), %xmm0 ucomisd %xmm0, %xmm1 movl %ecx, %edx jbe 0x670a3 testl %eax, %eax jns 0x6709f xorpd 0x20311(%rip), %xmm0 # 0x873b0 cvttsd2si %xmm0, %edx movl %edx, 0x40(%rdi) movq 0x8(%rdi), %rax movq 0x20(%rdi), %r8 movq 0x10(%rax), %rcx movl 0x1c(%r8), %eax subl 0x14(%r8), %eax incl %eax cltd pushq $-0x2 popq %rsi idivl %esi movq %r15, %r9 shrq $0x20, %r9 cmpq 0x20(%rbx), %rcx movl 0x30(%rbx), %esi cmovel %r15d, %esi movl 0x34(%rbx), %ecx cmovel %r9d, %ecx movq %r14, %rdx shrq $0x20, %rdx subl %r9d, %edx subl 0x20(%r8), %edx addl %eax, %esi addl 0x18(%r8), %edx movl %edx, %eax cltd pushq $0x2 popq %r8 idivl %r8d addl %eax, %ecx movl %ecx, %edx callq 0x68618 movl 0xc(%rsp), %r9d subl %r12d, %r9d movq 0x90(%rbx), %rdi movl 0x40(%rdi), %eax testq %r13, %r13 pushq $-0x2 popq %r10 js 0x67130 testl %eax, %eax jns 0x671cb cmpl %r9d, 0x10(%rsp) jg 0x671cb movl %r9d, 0xc(%rsp) movq 0x10(%rsp), %rcx addl %eax, %ecx testl %eax, %eax jg 0x67146 xorl %edx, %edx testl %ecx, %ecx jg 0x6716e movl %ecx, %edx negl %edx cmovsl %ecx, %edx cvtsi2sd %edx, %xmm1 movsd 0x48(%rdi), %xmm0 ucomisd %xmm0, %xmm1 movl %ecx, %edx jbe 0x6716e testl %eax, %eax jns 0x6716a xorpd 0x20246(%rip), %xmm0 # 0x873b0 cvttsd2si %xmm0, %edx movl %edx, 0x40(%rdi) movq 0x8(%rdi), %rcx movq 0x20(%rdi), %r8 movl %r14d, %eax subl %r15d, %eax subl 0x1c(%r8), %eax addl 0x14(%r8), %eax movq 0x10(%rcx), %rsi cltd pushq $0x2 popq %rcx idivl %ecx movq %r15, %rcx shrq $0x20, %rcx cmpq 0x20(%rbx), %rsi movl 0x30(%rbx), %esi cmovel %r15d, %esi cmovnel 0x34(%rbx), %ecx addl %eax, %esi movl 0x20(%r8), %eax subl 0x18(%r8), %eax incl %eax cltd idivl %r10d addl %eax, %ecx movl %ecx, %edx movl %r10d, %r12d callq 0x68618 movl %r12d, %r10d movl 0xc(%rsp), %r9d movl %r13d, %ecx movq 0x88(%rbx), %rdi movl 0x40(%rdi), %eax subl %ebp, %ecx jg 0x671f5 testl %eax, %eax setg %dl testl %r13d, %r13d setg %sil andb %dl, %sil cmpb $0x1, %sil jne 0x672a2 movl %r9d, %r12d testl %eax, %eax js 0x67206 leal (%rax,%r13), %esi xorl %edx, %edx cmpl %ebp, %esi jl 0x67230 addl %eax, %ecx movl %ecx, %edx negl %edx cmovsl %ecx, %edx cvtsi2sd %edx, %xmm1 movsd 0x48(%rdi), %xmm0 ucomisd %xmm0, %xmm1 movl %ecx, %edx jbe 0x67230 testl %eax, %eax jns 0x6722c xorpd 0x20184(%rip), %xmm0 # 0x873b0 cvttsd2si %xmm0, %edx movl %edx, 0x40(%rdi) movq 0x8(%rdi), %rax movq 0x20(%rdi), %r8 movq 0x10(%rax), %rax movl %r14d, %edx subl %r15d, %edx movq %r15, %rsi shrq $0x20, %rsi cmpq 0x20(%rbx), %rax movl 0x30(%rbx), %r9d cmovel %r15d, %r9d movl 0x1c(%r8), %eax movl 0x34(%rbx), %ecx cmovel %esi, %ecx addl %edx, %r9d subl 0x14(%r8), %eax incl %eax cltd idivl %r10d movq %r14, %rdx shrq $0x20, %rdx subl %esi, %edx subl 0x20(%r8), %edx leal (%rax,%r9), %esi incl %esi addl 0x18(%r8), %edx movl %edx, %eax cltd pushq $0x2 popq %r8 idivl %r8d addl %eax, %ecx movl %ecx, %edx movl %r10d, %ebp callq 0x68618 movl %ebp, %r10d movl %r12d, %r9d movq 0x10(%rsp), %r8 movl %r8d, %ecx movq 0x90(%rbx), %rdi movl 0x40(%rdi), %eax subl %r9d, %ecx jg 0x672d2 testl %eax, %eax setg %dl testl %r8d, %r8d setg %sil andb %dl, %sil cmpb $0x1, %sil jne 0x6736a testl %eax, %eax js 0x672e0 addl %eax, %r8d xorl %edx, %edx cmpl %r9d, %r8d jl 0x6730a addl %eax, %ecx movl %ecx, %edx negl %edx cmovsl %ecx, %edx cvtsi2sd %edx, %xmm1 movsd 0x48(%rdi), %xmm0 ucomisd %xmm0, %xmm1 movl %ecx, %edx jbe 0x6730a testl %eax, %eax jns 0x67306 xorpd 0x200aa(%rip), %xmm0 # 0x873b0 cvttsd2si %xmm0, %edx movl %edx, 0x40(%rdi) movq 0x8(%rdi), %rdx movq 0x20(%rdi), %rcx movl %r14d, %eax subl %r15d, %eax subl 0x1c(%rcx), %eax addl 0x14(%rcx), %eax movq 0x10(%rdx), %rsi cltd pushq $0x2 popq %r8 idivl %r8d movq %r15, %rdx shrq $0x20, %rdx cmpq 0x20(%rbx), %rsi movl 0x30(%rbx), %esi cmovel %r15d, %esi movl 0x34(%rbx), %r8d cmovel %edx, %r8d addl %eax, %esi shrq $0x20, %r14 subl %edx, %r14d addl %r8d, %r14d movl 0x20(%rcx), %eax subl 0x18(%rcx), %eax incl %eax cltd idivl %r10d leal (%rax,%r14), %edx incl %edx callq 0x68618 movq 0x88(%rbx), %rdi cmpl $0x0, 0x40(%rdi) je 0x67396 callq 0x5c270 movq 0x88(%rbx), %rdi callq 0x5ce30 movq 0x88(%rbx), %rdi callq 0x5c4d0 jmp 0x6739b callq 0x5d580 movq 0x90(%rbx), %rdi cmpl $0x0, 0x40(%rdi) je 0x673d3 callq 0x5c270 movq 0x90(%rbx), %rdi callq 0x5ce30 movq 0x90(%rbx), %rdi addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x5c4d0 addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x5d580	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollAreaPrivate::animateScrollIndicators()	void AbstractScrollAreaPrivate::animateScrollIndicators() { animationTimer->stop(); horIndicator->alpha = horIndicator->color.alpha(); vertIndicator->alpha = vertIndicator->color.alpha(); animationTimer->start( animationTimeout ); if( horIndicator->needPaint ) { horIndicator->animate = true; horIndicator->update(); } if( vertIndicator->needPaint ) { vertIndicator->animate = true; vertIndicator->update(); } }	pushq %rbx movq %rdi, %rbx movq 0x68(%rdi), %rdi callq 0x5cea0 movq 0x58(%rbx), %rdi addq $0x48, %rdi callq 0x5c470 movq 0x58(%rbx), %rcx movl %eax, 0x5c(%rcx) movq 0x60(%rbx), %rdi addq $0x48, %rdi callq 0x5c470 movq 0x60(%rbx), %rcx movl %eax, 0x5c(%rcx) movq 0x68(%rbx), %rdi movl 0x78(%rbx), %esi callq 0x5cfa0 movq 0x58(%rbx), %rdi cmpb $0x1, 0x44(%rdi) jne 0x6756a movb $0x1, 0x58(%rdi) callq 0x5c4d0 movq 0x60(%rbx), %rdi cmpb $0x1, 0x44(%rdi) jne 0x6757e movb $0x1, 0x58(%rdi) popq %rbx jmp 0x5c4d0 popq %rbx retq	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollArea::AbstractScrollArea(QWidget*)	AbstractScrollArea::AbstractScrollArea( QWidget * parent ) : QFrame( parent ) , d( new AbstractScrollAreaPrivate( this ) ) { d->init(); connect( d->animationTimer, &QTimer::timeout, this, &AbstractScrollArea::_q_animateScrollIndicators ); connect( d->startBlurAnimTimer, &QTimer::timeout, this, &AbstractScrollArea::_q_startBlurAnim ); connect( d->scroller, &Scroller::scroll, this, &AbstractScrollArea::_q_kineticScrolling ); connect( d->scroller, &Scroller::aboutToStart, this, &AbstractScrollArea::_q_kineticScrollingAboutToStart ); connect( d->scroller, &Scroller::finished, this, &AbstractScrollArea::_q_kineticScrollingFinished ); connect( d->horBlurAnim, &QVariantAnimation::valueChanged, this, &AbstractScrollArea::_q_horBlurAnim ); connect( d->horBlurAnim, &QVariantAnimation::finished, this, &AbstractScrollArea::_q_horBlurAnimFinished ); connect( d->vertBlurAnim, &QVariantAnimation::valueChanged, this, &AbstractScrollArea::_q_vertBlurAnim ); connect( d->vertBlurAnim, &QVariantAnimation::finished, this, &AbstractScrollArea::_q_vertBlurAnimFinished ); }	pushq %r14 pushq %rbx subq $0x68, %rsp movq %rdi, %rbx xorl %edx, %edx callq 0x5d7f0 leaq 0x3f8ae(%rip), %rax # 0xa6e78 leaq 0x10(%rax), %rcx movq %rcx, (%rbx) addq $0x1d8, %rax # imm = 0x1D8 movq %rax, 0x10(%rbx) movl $0xa8, %edi callq 0x5d090 movq %rax, %r14 movq %rax, %rdi movq %rbx, %rsi callq 0x6862c movq %r14, 0x28(%rbx) movq %r14, %rdi callq 0x66832 movq 0x28(%rbx), %rax movq 0x68(%rax), %rsi leaq 0x2ac(%rip), %rax # 0x678ba movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x4484f(%rip), %rdx # 0xabe78 leaq 0x60(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6868e leaq 0x60(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x70(%rax), %rsi leaq 0x2d0(%rip), %rax # 0x67924 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x44809(%rip), %rdx # 0xabe78 leaq 0x58(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6868e leaq 0x58(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x80(%rax), %rsi leaq 0x291(%rip), %rax # 0x6792e movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) leaq -0x5b3a(%rip), %rdx # 0x61b7e leaq 0x50(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x68734 leaq 0x50(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x80(%rax), %rsi leaq 0x274(%rip), %rax # 0x6795a movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) leaq -0x5b4d(%rip), %rdx # 0x61bb4 leaq 0x48(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x687e8 leaq 0x48(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x80(%rax), %rsi leaq 0x243(%rip), %rax # 0x67972 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) leaq -0x5b84(%rip), %rdx # 0x61bc6 leaq 0x40(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x687e8 leaq 0x40(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x98(%rax), %rsi leaq 0x236(%rip), %rax # 0x679ae movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x44735(%rip), %rdx # 0xabec8 leaq 0x38(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6888e leaq 0x38(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x98(%rax), %rsi leaq 0x20f(%rip), %rax # 0x679d0 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x447fc(%rip), %rdx # 0xabfd8 leaq 0x30(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x68942 leaq 0x30(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0xa0(%rax), %rsi leaq 0x1d6(%rip), %rax # 0x679e0 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x446a3(%rip), %rdx # 0xabec8 leaq 0x28(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6888e leaq 0x28(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0xa0(%rax), %rsi leaq 0x1af(%rip), %rax # 0x67a02 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x4476a(%rip), %rdx # 0xabfd8 leaq 0x20(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x68942 leaq 0x20(%rsp), %rdi callq 0x5c7d0 addq $0x68, %rsp popq %rbx popq %r14 retq movq %rax, %r14 jmp 0x678a9 movq %rax, %r14 movq 0x28(%rbx), %rdi testq %rdi, %rdi je 0x678a9 movq (%rdi), %rax callq *0x8(%rax) movq %rbx, %rdi callq 0x5cd40 movq %r14, %rdi callq 0x5c7f0 nop	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollArea::AbstractScrollArea(QtMWidgets::AbstractScrollAreaPrivate, QWidget)	AbstractScrollArea::AbstractScrollArea( AbstractScrollAreaPrivate * dd, QWidget * parent ) : QFrame( parent ) , d( dd ) { d->init(); connect( d->animationTimer, &QTimer::timeout, this, &AbstractScrollArea::_q_animateScrollIndicators ); connect( d->startBlurAnimTimer, &QTimer::timeout, this, &AbstractScrollArea::_q_startBlurAnim ); connect( d->scroller, &Scroller::scroll, this, &AbstractScrollArea::_q_kineticScrolling ); connect( d->scroller, &Scroller::aboutToStart, this, &AbstractScrollArea::_q_kineticScrollingAboutToStart ); connect( d->scroller, &Scroller::finished, this, &AbstractScrollArea::_q_kineticScrollingFinished ); connect( d->horBlurAnim, &QVariantAnimation::valueChanged, this, &AbstractScrollArea::_q_horBlurAnim ); connect( d->horBlurAnim, &QVariantAnimation::finished, this, &AbstractScrollArea::_q_horBlurAnimFinished ); connect( d->vertBlurAnim, &QVariantAnimation::valueChanged, this, &AbstractScrollArea::_q_vertBlurAnim ); connect( d->vertBlurAnim, &QVariantAnimation::finished, this, &AbstractScrollArea::_q_vertBlurAnimFinished ); }	pushq %r14 pushq %rbx subq $0x68, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rdx, %rsi xorl %edx, %edx callq 0x5d7f0 leaq 0x3f448(%rip), %rax # 0xa6e78 leaq 0x10(%rax), %rcx movq %rcx, (%rbx) addq $0x1d8, %rax # imm = 0x1D8 movq %rax, 0x10(%rbx) movq %r14, 0x28(%rbx) movq %r14, %rdi callq 0x66832 movq 0x28(%rbx), %rax movq 0x68(%rax), %rsi leaq -0x1a2(%rip), %rax # 0x678ba movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x44401(%rip), %rdx # 0xabe78 leaq 0x60(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6868e leaq 0x60(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x70(%rax), %rsi leaq -0x17e(%rip), %rax # 0x67924 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x443bb(%rip), %rdx # 0xabe78 leaq 0x58(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6868e leaq 0x58(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x80(%rax), %rsi leaq -0x1bd(%rip), %rax # 0x6792e movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) leaq -0x5f88(%rip), %rdx # 0x61b7e leaq 0x50(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x68734 leaq 0x50(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x80(%rax), %rsi leaq -0x1da(%rip), %rax # 0x6795a movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) leaq -0x5f9b(%rip), %rdx # 0x61bb4 leaq 0x48(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x687e8 leaq 0x48(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x80(%rax), %rsi leaq -0x20b(%rip), %rax # 0x67972 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) leaq -0x5fd2(%rip), %rdx # 0x61bc6 leaq 0x40(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x687e8 leaq 0x40(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x98(%rax), %rsi leaq -0x218(%rip), %rax # 0x679ae movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x442e7(%rip), %rdx # 0xabec8 leaq 0x38(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6888e leaq 0x38(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0x98(%rax), %rsi leaq -0x23f(%rip), %rax # 0x679d0 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x443ae(%rip), %rdx # 0xabfd8 leaq 0x30(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x68942 leaq 0x30(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0xa0(%rax), %rsi leaq -0x278(%rip), %rax # 0x679e0 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x44255(%rip), %rdx # 0xabec8 leaq 0x28(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x6888e leaq 0x28(%rsp), %rdi callq 0x5c7d0 movq 0x28(%rbx), %rax movq 0xa0(%rax), %rsi leaq -0x29f(%rip), %rax # 0x67a02 movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) movups 0x10(%rsp), %xmm0 movups %xmm0, (%rsp) movq 0x4431c(%rip), %rdx # 0xabfd8 leaq 0x20(%rsp), %rdi xorl %ecx, %ecx movq %rbx, %r8 xorl %r9d, %r9d callq 0x68942 leaq 0x20(%rsp), %rdi callq 0x5c7d0 addq $0x68, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq 0x28(%rbx), %rdi testq %rdi, %rdi je 0x67cf2 movq (%rdi), %rax callq *0x8(%rax) movq %rbx, %rdi callq 0x5cd40 movq %r14, %rdi callq 0x5c7f0	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollArea::setViewportMargins(int, int, int, int)	void AbstractScrollArea::setViewportMargins( int left, int top, int right, int bottom ) { d->left = left; d->top = top; d->right = right; d->bottom = bottom; QStyleOption opt; opt.initFrom( this ); d->layoutChildren( opt ); d->normalizePosition(); d->calcIndicators(); update(); d->horIndicator->update(); d->vertIndicator->update(); }	pushq %r14 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx movq 0x28(%rdi), %rax movl %esi, 0x44(%rax) movl %edx, 0x38(%rax) movl %ecx, 0x40(%rax) movl %r8d, 0x3c(%rax) leaq 0x8(%rsp), %r14 pushq $0x1 popq %rsi movq %r14, %rdi xorl %edx, %edx callq 0x5dc50 movq %r14, %rdi movq %rbx, %rsi callq 0x5c160 movq 0x28(%rbx), %rdi leaq 0x8(%rsp), %rsi callq 0x66afc movq 0x28(%rbx), %rdi callq 0x66c10 movq 0x28(%rbx), %rdi callq 0x66c62 movq %rbx, %rdi callq 0x5c4d0 movq 0x28(%rbx), %rax movq 0x58(%rax), %rdi callq 0x5c4d0 movq 0x28(%rbx), %rax movq 0x60(%rax), %rdi callq 0x5c4d0 leaq 0x8(%rsp), %rdi callq 0x5c500 addq $0x48, %rsp popq %rbx popq %r14 retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x5c500 movq %rbx, %rdi callq 0x5c7f0 nop	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollArea::resizeEvent(QResizeEvent*)	void AbstractScrollArea::resizeEvent( QResizeEvent * e ) { QStyleOption opt; opt.initFrom( this ); d->layoutChildren( opt ); d->normalizePosition(); d->calcIndicators(); update(); e->accept(); }	pushq %r15 pushq %r14 pushq %rbx subq $0x40, %rsp movq %rsi, %rbx movq %rdi, %r14 movq %rsp, %r15 pushq $0x1 popq %rsi movq %r15, %rdi xorl %edx, %edx callq 0x5dc50 movq %r15, %rdi movq %r14, %rsi callq 0x5c160 movq 0x28(%r14), %rdi movq %rsp, %rsi callq 0x66afc movq 0x28(%r14), %rdi callq 0x66c10 movq 0x28(%r14), %rdi callq 0x66c62 movq %r14, %rdi callq 0x5c4d0 movb $0x1, 0xc(%rbx) movq %rsp, %rdi callq 0x5c500 addq $0x40, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movq %rsp, %rdi callq 0x5c500 movq %rbx, %rdi callq 0x5c7f0 nop	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
QtMWidgets::AbstractScrollArea::mouseReleaseEvent(QMouseEvent*)	void AbstractScrollArea::mouseReleaseEvent( QMouseEvent * e ) { if( e->button() == Qt::LeftButton ) { d->leftMouseButtonPressed = false; if( ( d->horIndicator->needPaint \|\| d->vertIndicator->needPaint ) && ( d->horIndicator->policy == ScrollIndicatorAsNeeded \|\| d->vertIndicator->policy == ScrollIndicatorAsNeeded ) ) d->animateScrollIndicators(); else d->stopScrollIndicatorsAnimation(); d->animateHiddingBlurEffect(); e->accept(); } else e->ignore(); }	pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx cmpl $0x1, 0x40(%rsi) jne 0x683f5 movq %rdi, %r14 movq 0x28(%rdi), %rdi movb $0x0, 0x48(%rdi) movq 0x58(%rdi), %rax cmpb $0x0, 0x44(%rax) jne 0x683de movq 0x60(%rdi), %rcx cmpb $0x1, 0x44(%rcx) jne 0x683ee cmpl $0x0, 0x28(%rax) je 0x683f9 movq 0x60(%rdi), %rax cmpl $0x0, 0x28(%rax) je 0x683f9 callq 0x67580 jmp 0x683fe xorl %eax, %eax jmp 0x68409 callq 0x67516 movq 0x28(%r14), %rdi callq 0x673e6 movb $0x1, %al movb %al, 0xc(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq	/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.