index
int64
0
66.5k
func_name
stringlengths
2
5.36k
func_dep
stringlengths
16
2.19k
func
stringlengths
8
55.3k
test
stringlengths
0
7.07k
opt
stringclasses
4 values
language
stringclasses
2 values
asm
stringlengths
0
45.4k
ida_asm
stringlengths
0
44.7k
ida_pseudo
stringlengths
0
44.3k
ghidra_asm
stringlengths
0
49.1k
ghidra_pseudo
stringlengths
0
64.7k
4,582
func0
#include <stdio.h> #include <assert.h>
int func0(const char* s) { int count = 0; int i; int len = 0; while(s[len] != '\0') { len++; } for (i = 0; i < len - 2; i++) { if (s[i] == 's' && s[i + 1] == 't' && s[i + 2] == 'd') { count++; } } return count; }
int main() { assert(func0("letstdlenstdporstd") == 3); assert(func0("truststdsolensporsd") == 1); assert(func0("makestdsostdworthit") == 2); return 0; }
O2
c
func0: endbr64 movzbl (%rdi),%edx test %dl,%dl je 1250 <func0+0x60> xor %eax,%eax nopl (%rax) mov %eax,%esi add $0x1,%rax cmpb $0x0,(%rdi,%rax,1) jne 1200 <func0+0x10> cmp $0x1,%esi jle 1250 <func0+0x60> lea -0x2(%rsi),%eax xor %r8d,%r8d add %rdi,%rax jmp 122d <func0+0x3d> nopl 0x0(%rax) cmp %rax,%rdi je 1249 <func0+0x59> movzbl 0x1(%rdi),%edx add $0x1,%rdi cmp $0x73,%dl jne 1220 <func0+0x30> cmpb $0x74,0x1(%rdi) jne 1220 <func0+0x30> xor %edx,%edx cmpb $0x64,0x2(%rdi) sete %dl add %edx,%r8d cmp %rax,%rdi jne 1225 <func0+0x35> mov %r8d,%eax retq nopl (%rax) xor %r8d,%r8d mov %r8d,%eax retq nopw 0x0(%rax,%rax,1)
func0: endbr64 movzx edx, byte ptr [rdi] test dl, dl jz short loc_1250 xor eax, eax nop dword ptr [rax] loc_1200: mov ecx, eax add rax, 1 cmp byte ptr [rdi+rax], 0 jnz short loc_1200 cmp ecx, 1 jle short loc_1250 lea eax, [rcx-2] xor r8d, r8d add rax, rdi jmp short loc_122D loc_1220: cmp rdi, rax jz short loc_1249 loc_1225: movzx edx, byte ptr [rdi+1] add rdi, 1 loc_122D: cmp dl, 73h ; 's' jnz short loc_1220 cmp byte ptr [rdi+1], 74h ; 't' jnz short loc_1220 xor edx, edx cmp byte ptr [rdi+2], 64h ; 'd' setz dl add r8d, edx cmp rdi, rax jnz short loc_1225 loc_1249: mov eax, r8d retn loc_1250: xor r8d, r8d mov eax, r8d retn
long long func0(char *a1) { char v1; // dl long long v2; // rax int v3; // ecx unsigned int v4; // r8d char *v5; // rax v1 = *a1; if ( *a1 ) { v2 = 0LL; do v3 = v2++; while ( a1[v2] ); if ( v3 > 1 ) { v4 = 0; v5 = &a1[v3 - 2]; while ( 1 ) { if ( v1 == 115 && a1[1] == 116 ) { v4 += a1[2] == 100; if ( a1 == v5 ) return v4; } else if ( a1 == v5 ) { return v4; } v1 = *++a1; } } } return 0LL; }
func0: ENDBR64 MOVZX EDX,byte ptr [RDI] TEST DL,DL JZ 0x00101250 XOR EAX,EAX NOP dword ptr [RAX] LAB_00101200: MOV ECX,EAX ADD RAX,0x1 CMP byte ptr [RDI + RAX*0x1],0x0 JNZ 0x00101200 CMP ECX,0x1 JLE 0x00101250 LEA EAX,[RCX + -0x2] XOR R8D,R8D ADD RAX,RDI JMP 0x0010122d LAB_00101220: CMP RDI,RAX JZ 0x00101249 LAB_00101225: MOVZX EDX,byte ptr [RDI + 0x1] ADD RDI,0x1 LAB_0010122d: CMP DL,0x73 JNZ 0x00101220 CMP byte ptr [RDI + 0x1],0x74 JNZ 0x00101220 XOR EDX,EDX CMP byte ptr [RDI + 0x2],0x64 SETZ DL ADD R8D,EDX CMP RDI,RAX JNZ 0x00101225 LAB_00101249: MOV EAX,R8D RET LAB_00101250: XOR R8D,R8D MOV EAX,R8D RET
int func0(char *param_1) { char cVar1; long lVar2; long lVar3; char *pcVar4; int iVar5; int iVar6; cVar1 = *param_1; if (cVar1 != '\0') { lVar3 = 0; do { lVar2 = lVar3; lVar3 = lVar2 + 1; } while (param_1[lVar3] != '\0'); iVar5 = (int)lVar2; if (1 < iVar5) { iVar6 = 0; pcVar4 = param_1 + (iVar5 - 2); while( true ) { if ((cVar1 == 's') && (param_1[1] == 't')) { iVar6 = iVar6 + (uint)(param_1[2] == 'd'); } if (param_1 == pcVar4) break; cVar1 = param_1[1]; param_1 = param_1 + 1; } return iVar6; } } return 0; }
4,583
func0
#include <stdio.h> #include <assert.h>
int func0(const char* s) { int count = 0; int i; int len = 0; while(s[len] != '\0') { len++; } for (i = 0; i < len - 2; i++) { if (s[i] == 's' && s[i + 1] == 't' && s[i + 2] == 'd') { count++; } } return count; }
int main() { assert(func0("letstdlenstdporstd") == 3); assert(func0("truststdsolensporsd") == 1); assert(func0("makestdsostdworthit") == 2); return 0; }
O3
c
func0: endbr64 cmpb $0x0,(%rdi) je 1250 <func0+0x60> xor %eax,%eax nopl 0x0(%rax,%rax,1) mov %eax,%ecx add $0x1,%rax cmpb $0x0,(%rdi,%rax,1) jne 1200 <func0+0x10> cmp $0x1,%ecx jle 1250 <func0+0x60> lea -0x2(%rcx),%eax xor %r8d,%r8d lea 0x1(%rdi,%rax,1),%rax jmp 1229 <func0+0x39> xchg %ax,%ax add $0x1,%rdi cmp %rdi,%rax je 1249 <func0+0x59> cmpb $0x73,(%rdi) jne 1220 <func0+0x30> cmpb $0x74,0x1(%rdi) jne 1220 <func0+0x30> xor %edx,%edx cmpb $0x64,0x2(%rdi) sete %dl add $0x1,%rdi add %edx,%r8d cmp %rdi,%rax jne 1229 <func0+0x39> mov %r8d,%eax retq nopl (%rax) xor %r8d,%r8d mov %r8d,%eax retq nopw 0x0(%rax,%rax,1)
func0: endbr64 cmp byte ptr [rdi], 0 jz short loc_1250 lea rdx, [rdi+1] xor eax, eax nop loc_1200: add rdx, 1 mov ecx, eax add eax, 1 cmp byte ptr [rdx-1], 0 jnz short loc_1200 lea edx, [rcx-1] cmp eax, 2 jle short loc_1250 xor eax, eax xor ecx, ecx jmp short loc_1228 loc_1220: add rax, 1 cmp edx, eax jle short loc_1247 loc_1228: cmp byte ptr [rdi+rax], 73h ; 's' jnz short loc_1220 cmp byte ptr [rdi+rax+1], 74h ; 't' jnz short loc_1220 cmp byte ptr [rdi+rax+2], 64h ; 'd' jnz short loc_1220 add rax, 1 add ecx, 1 cmp edx, eax jg short loc_1228 loc_1247: mov eax, ecx retn loc_1250: xor ecx, ecx mov eax, ecx retn
long long func0(_BYTE *a1) { _BYTE *v1; // rdx int v2; // eax int v3; // ecx int v4; // edx long long v5; // rax unsigned int v6; // ecx if ( !*a1 ) return 0LL; v1 = a1 + 1; v2 = 0; do { ++v1; v3 = v2++; } while ( *(v1 - 1) ); v4 = v3 - 1; if ( v2 <= 2 ) return 0LL; v5 = 0LL; v6 = 0; do { while ( a1[v5] != 115 || a1[v5 + 1] != 116 || a1[v5 + 2] != 100 ) { if ( v4 <= (int)++v5 ) return v6; } ++v5; ++v6; } while ( v4 > (int)v5 ); return v6; }
func0: ENDBR64 CMP byte ptr [RDI],0x0 JZ 0x00101250 LEA RDX,[RDI + 0x1] XOR EAX,EAX NOP LAB_00101200: ADD RDX,0x1 MOV ECX,EAX ADD EAX,0x1 CMP byte ptr [RDX + -0x1],0x0 JNZ 0x00101200 LEA EDX,[RCX + -0x1] CMP EAX,0x2 JLE 0x00101250 XOR EAX,EAX XOR ECX,ECX JMP 0x00101228 LAB_00101220: ADD RAX,0x1 CMP EDX,EAX JLE 0x00101247 LAB_00101228: CMP byte ptr [RDI + RAX*0x1],0x73 JNZ 0x00101220 CMP byte ptr [RDI + RAX*0x1 + 0x1],0x74 JNZ 0x00101220 CMP byte ptr [RDI + RAX*0x1 + 0x2],0x64 JNZ 0x00101220 ADD RAX,0x1 ADD ECX,0x1 CMP EDX,EAX JG 0x00101228 LAB_00101247: MOV EAX,ECX RET LAB_00101250: XOR ECX,ECX MOV EAX,ECX RET
int func0(char *param_1) { char cVar1; int iVar2; long lVar3; int iVar4; char *pcVar5; if (*param_1 != '\0') { pcVar5 = param_1 + 1; iVar2 = 0; do { iVar4 = iVar2; iVar2 = iVar4 + 1; cVar1 = *pcVar5; pcVar5 = pcVar5 + 1; } while (cVar1 != '\0'); iVar4 = iVar4 + -1; if (2 < iVar2) { lVar3 = 0; iVar2 = 0; do { while (((param_1[lVar3] == 's' && (param_1[lVar3 + 1] == 't')) && (param_1[lVar3 + 2] == 'd'))) { lVar3 = lVar3 + 1; iVar2 = iVar2 + 1; if (iVar4 <= (int)lVar3) { return iVar2; } } lVar3 = lVar3 + 1; } while ((int)lVar3 < iVar4); return iVar2; } } return 0; }
4,584
func0
#include <stdio.h> #include <string.h> #include <ctype.h> #include <assert.h>
char* func0(char* text) { int i=0, j=0; char temp[strlen(text) + 1]; while(text[i]) { if(isalnum(text[i])) { temp[j++] = text[i]; } i++; } temp[j] = '\0'; strcpy(text, temp); return text; }
int main() { char text1[] = "python @#&^%$*program123"; char text2[] = "python %^$@!^&*() programming24%$^^() language"; char text3[] = "python ^%&^()(+_)(_^&67) program"; assert(strcmp(func0(text1), "pythonprogram123") == 0); assert(strcmp(func0(text2), "pythonprogramming24language") == 0); assert(strcmp(func0(text3), "python67program") == 0); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp push %r15 push %r14 push %r13 push %r12 push %rbx sub $0x38,%rsp mov %rdi,-0x58(%rbp) mov %fs:0x28,%rax mov %rax,-0x38(%rbp) xor %eax,%eax mov %rsp,%rax mov %rax,%rbx movl $0x0,-0x4c(%rbp) movl $0x0,-0x50(%rbp) mov -0x58(%rbp),%rax mov %rax,%rdi callq 10b0 <strlen@plt> add $0x1,%rax mov %rax,%rdx sub $0x1,%rdx mov %rdx,-0x48(%rbp) mov %rax,%r14 mov $0x0,%r15d mov %rax,%r12 mov $0x0,%r13d mov $0x10,%edx sub $0x1,%rdx add %rdx,%rax mov $0x10,%edi mov $0x0,%edx div %rdi imul $0x10,%rax,%rax mov %rax,%rdx and $0xfffffffffffff000,%rdx mov %rsp,%rsi sub %rdx,%rsi mov %rsi,%rdx cmp %rdx,%rsp je 1299 <func0+0xb0> sub $0x1000,%rsp orq $0x0,0xff8(%rsp) jmp 1282 <func0+0x99> mov %rax,%rdx and $0xfff,%edx sub %rdx,%rsp mov %rax,%rdx and $0xfff,%edx test %rdx,%rdx je 12c3 <func0+0xda> and $0xfff,%eax sub $0x8,%rax add %rsp,%rax orq $0x0,(%rax) mov %rsp,%rax add $0x0,%rax mov %rax,-0x40(%rbp) jmp 1326 <func0+0x13d> callq 10f0 <__ctype_b_loc@plt> mov (%rax),%rax mov -0x4c(%rbp),%edx movslq %edx,%rcx mov -0x58(%rbp),%rdx add %rcx,%rdx movzbl (%rdx),%edx movsbq %dl,%rdx add %rdx,%rdx add %rdx,%rax movzwl (%rax),%eax movzwl %ax,%eax and $0x8,%eax test %eax,%eax je 1322 <func0+0x139> mov -0x4c(%rbp),%eax movslq %eax,%rdx mov -0x58(%rbp),%rax lea (%rdx,%rax,1),%rcx mov -0x50(%rbp),%eax lea 0x1(%rax),%edx mov %edx,-0x50(%rbp) movzbl (%rcx),%ecx mov -0x40(%rbp),%rdx cltq mov %cl,(%rdx,%rax,1) addl $0x1,-0x4c(%rbp) mov -0x4c(%rbp),%eax movslq %eax,%rdx mov -0x58(%rbp),%rax add %rdx,%rax movzbl (%rax),%eax test %al,%al jne 12d0 <func0+0xe7> mov -0x40(%rbp),%rdx mov -0x50(%rbp),%eax cltq movb $0x0,(%rdx,%rax,1) mov -0x40(%rbp),%rdx mov -0x58(%rbp),%rax mov %rdx,%rsi mov %rax,%rdi callq 10a0 <strcpy@plt> mov -0x58(%rbp),%rax mov %rbx,%rsp mov -0x38(%rbp),%rbx xor %fs:0x28,%rbx je 1375 <func0+0x18c> callq 10c0 <__stack_chk_fail@plt> lea -0x28(%rbp),%rsp pop %rbx pop %r12 pop %r13 pop %r14 pop %r15 pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp push rbx sub rsp, 38h mov [rbp+s], rdi mov rax, fs:28h mov [rbp+var_18], rax xor eax, eax mov rax, rsp mov rbx, rax mov [rbp+var_30], 0 mov [rbp+var_2C], 0 mov rax, [rbp+s] mov rdi, rax; s call _strlen add rax, 1 mov rdx, rax sub rdx, 1 mov [rbp+var_28], rdx mov edx, 10h sub rdx, 1 add rax, rdx mov esi, 10h mov edx, 0 div rsi imul rax, 10h mov rcx, rax and rcx, 0FFFFFFFFFFFFF000h mov rdx, rsp sub rdx, rcx loc_1265: cmp rsp, rdx jz short loc_127C sub rsp, 1000h or [rsp+1040h+var_48], 0 jmp short loc_1265 loc_127C: mov rdx, rax and edx, 0FFFh sub rsp, rdx mov rdx, rax and edx, 0FFFh test rdx, rdx jz short loc_12A6 and eax, 0FFFh sub rax, 8 add rax, rsp or qword ptr [rax], 0 loc_12A6: mov rax, rsp add rax, 0 mov [rbp+src], rax jmp short loc_1309 loc_12B3: call ___ctype_b_loc mov rax, [rax] mov edx, [rbp+var_30] movsxd rcx, edx mov rdx, [rbp+s] add rdx, rcx movzx edx, byte ptr [rdx] movsx rdx, dl add rdx, rdx add rax, rdx movzx eax, word ptr [rax] movzx eax, ax and eax, 8 test eax, eax jz short loc_1305 mov eax, [rbp+var_30] movsxd rdx, eax mov rax, [rbp+s] lea rcx, [rdx+rax] mov eax, [rbp+var_2C] lea edx, [rax+1] mov [rbp+var_2C], edx movzx ecx, byte ptr [rcx] mov rdx, [rbp+src] cdqe mov [rdx+rax], cl loc_1305: add [rbp+var_30], 1 loc_1309: mov eax, [rbp+var_30] movsxd rdx, eax mov rax, [rbp+s] add rax, rdx movzx eax, byte ptr [rax] test al, al jnz short loc_12B3 mov rdx, [rbp+src] mov eax, [rbp+var_2C] cdqe mov byte ptr [rdx+rax], 0 mov rdx, [rbp+src] mov rax, [rbp+s] mov rsi, rdx; src mov rdi, rax; dest call _strcpy mov rax, [rbp+s] mov rsp, rbx mov rdx, [rbp+var_18] sub rdx, fs:28h jz short loc_1358 call ___stack_chk_fail loc_1358: mov rbx, [rbp+var_8] leave retn
char * func0(char *a1) { size_t v1; // rax unsigned long long v2; // rax void *v3; // rsp int v4; // eax _BYTE v6[8]; // [rsp+8h] [rbp-40h] BYREF char *s; // [rsp+10h] [rbp-38h] int v8; // [rsp+18h] [rbp-30h] int v9; // [rsp+1Ch] [rbp-2Ch] size_t v10; // [rsp+20h] [rbp-28h] char *src; // [rsp+28h] [rbp-20h] unsigned long long v12; // [rsp+30h] [rbp-18h] s = a1; v12 = __readfsqword(0x28u); v8 = 0; v9 = 0; v1 = strlen(a1) + 1; v10 = v1 - 1; v2 = 16 * ((v1 + 15) / 0x10); while ( v6 != &v6[-(v2 & 0xFFFFFFFFFFFFF000LL)] ) ; v3 = alloca(v2 & 0xFFF); if ( (v2 & 0xFFF) != 0 ) *(_QWORD *)&v6[(v2 & 0xFFF) - 8] = *(_QWORD *)&v6[(v2 & 0xFFF) - 8]; src = v6; while ( s[v8] ) { if ( ((*__ctype_b_loc())[s[v8]] & 8) != 0 ) { v4 = v9++; src[v4] = s[v8]; } ++v8; } src[v9] = 0; strcpy(s, src); return s; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP PUSH RBX SUB RSP,0x38 MOV qword ptr [RBP + -0x38],RDI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x18],RAX XOR EAX,EAX MOV RAX,RSP MOV RBX,RAX MOV dword ptr [RBP + -0x30],0x0 MOV dword ptr [RBP + -0x2c],0x0 MOV RAX,qword ptr [RBP + -0x38] MOV RDI,RAX CALL 0x001010b0 ADD RAX,0x1 MOV RDX,RAX SUB RDX,0x1 MOV qword ptr [RBP + -0x28],RDX MOV EDX,0x10 SUB RDX,0x1 ADD RAX,RDX MOV ESI,0x10 MOV EDX,0x0 DIV RSI IMUL RAX,RAX,0x10 MOV RCX,RAX AND RCX,-0x1000 MOV RDX,RSP SUB RDX,RCX LAB_00101265: CMP RSP,RDX JZ 0x0010127c SUB RSP,0x1000 OR qword ptr [RSP + 0xff8],0x0 JMP 0x00101265 LAB_0010127c: MOV RDX,RAX AND EDX,0xfff SUB RSP,RDX MOV RDX,RAX AND EDX,0xfff TEST RDX,RDX JZ 0x001012a6 AND EAX,0xfff SUB RAX,0x8 ADD RAX,RSP OR qword ptr [RAX],0x0 LAB_001012a6: MOV RAX,RSP ADD RAX,0x0 MOV qword ptr [RBP + -0x20],RAX JMP 0x00101309 LAB_001012b3: CALL 0x001010f0 MOV RAX,qword ptr [RAX] MOV EDX,dword ptr [RBP + -0x30] MOVSXD RCX,EDX MOV RDX,qword ptr [RBP + -0x38] ADD RDX,RCX MOVZX EDX,byte ptr [RDX] MOVSX RDX,DL ADD RDX,RDX ADD RAX,RDX MOVZX EAX,word ptr [RAX] MOVZX EAX,AX AND EAX,0x8 TEST EAX,EAX JZ 0x00101305 MOV EAX,dword ptr [RBP + -0x30] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x38] LEA RCX,[RDX + RAX*0x1] MOV EAX,dword ptr [RBP + -0x2c] LEA EDX,[RAX + 0x1] MOV dword ptr [RBP + -0x2c],EDX MOVZX ECX,byte ptr [RCX] MOV RDX,qword ptr [RBP + -0x20] CDQE MOV byte ptr [RDX + RAX*0x1],CL LAB_00101305: ADD dword ptr [RBP + -0x30],0x1 LAB_00101309: MOV EAX,dword ptr [RBP + -0x30] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x38] ADD RAX,RDX MOVZX EAX,byte ptr [RAX] TEST AL,AL JNZ 0x001012b3 MOV RDX,qword ptr [RBP + -0x20] MOV EAX,dword ptr [RBP + -0x2c] CDQE MOV byte ptr [RDX + RAX*0x1],0x0 MOV RDX,qword ptr [RBP + -0x20] MOV RAX,qword ptr [RBP + -0x38] MOV RSI,RDX MOV RDI,RAX CALL 0x001010a0 MOV RAX,qword ptr [RBP + -0x38] MOV RSP,RBX MOV RDX,qword ptr [RBP + -0x18] SUB RDX,qword ptr FS:[0x28] JZ 0x00101358 CALL 0x001010c0 LAB_00101358: MOV RBX,qword ptr [RBP + -0x8] LEAVE RET
char * func0(char *param_1) { long lVar1; char *__dest; char *__src; ulong uVar2; ushort **ppuVar3; int *puVar4; long in_FS_OFFSET; int auStack_48 [8]; char *local_40; int local_38; int local_34; size_t local_30; char *local_28; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); local_38 = 0; local_34 = 0; local_40 = param_1; local_30 = strlen(param_1); uVar2 = ((local_30 + 0x10) / 0x10) * 0x10; for (puVar4 = auStack_48; puVar4 != auStack_48 + -(uVar2 & 0xfffffffffffff000); puVar4 = puVar4 + -0x1000) { *(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8); } lVar1 = -(ulong)((uint)uVar2 & 0xfff); local_28 = puVar4 + lVar1; if ((uVar2 & 0xfff) != 0) { *(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) = *(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1); local_28 = puVar4 + lVar1; } for (; __src = local_28, __dest = local_40, local_40[local_38] != '\0'; local_38 = local_38 + 1) { *(int8 *)(puVar4 + lVar1 + -8) = 0x1012b8; ppuVar3 = __ctype_b_loc(); if (((*ppuVar3)[local_40[local_38]] & 8) != 0) { local_28[local_34] = local_40[local_38]; local_34 = local_34 + 1; } } local_28[local_34] = '\0'; *(int8 *)(puVar4 + lVar1 + -8) = 0x10133d; strcpy(__dest,__src); if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return local_40; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,585
func0
#include <stdio.h> #include <string.h> #include <ctype.h> #include <assert.h>
char* func0(char* text) { int i=0, j=0; char temp[strlen(text) + 1]; while(text[i]) { if(isalnum(text[i])) { temp[j++] = text[i]; } i++; } temp[j] = '\0'; strcpy(text, temp); return text; }
int main() { char text1[] = "python @#&^%$*program123"; char text2[] = "python %^$@!^&*() programming24%$^^() language"; char text3[] = "python ^%&^()(+_)(_^&67) program"; assert(strcmp(func0(text1), "pythonprogram123") == 0); assert(strcmp(func0(text2), "pythonprogramming24language") == 0); assert(strcmp(func0(text3), "python67program") == 0); return 0; }
O1
c
func0: endbr64 push %rbp mov %rsp,%rbp push %r13 push %r12 push %rbx sub $0x18,%rsp mov %rdi,%r12 mov %fs:0x28,%rax mov %rax,-0x28(%rbp) xor %eax,%eax mov $0xffffffffffffffff,%rcx repnz scas %es:(%rdi),%al not %rcx add $0xf,%rcx mov %rcx,%rdx and $0xfffffffffffffff0,%rdx and $0xfffffffffffff000,%rcx mov %rsp,%rax sub %rcx,%rax cmp %rax,%rsp je 1207 <func0+0x5e> sub $0x1000,%rsp orq $0x0,0xff8(%rsp) jmp 11f0 <func0+0x47> mov %rdx,%rax and $0xfff,%eax sub %rax,%rsp test %rax,%rax je 121d <func0+0x74> orq $0x0,-0x8(%rsp,%rax,1) mov %rsp,%r13 movzbl (%r12),%ebx test %bl,%bl je 1260 <func0+0xb7> callq 10b0 <__ctype_b_loc@plt> mov (%rax),%rsi lea 0x1(%r12),%rax mov $0x0,%ecx jmp 1249 <func0+0xa0> add $0x1,%rax movzbl -0x1(%rax),%ebx test %bl,%bl je 1265 <func0+0xbc> movsbq %bl,%rdx testb $0x8,(%rsi,%rdx,2) je 123d <func0+0x94> movslq %ecx,%rdx mov %bl,0x0(%r13,%rdx,1) lea 0x1(%rcx),%ecx jmp 123d <func0+0x94> mov $0x0,%ecx movslq %ecx,%rcx movb $0x0,0x0(%r13,%rcx,1) mov %r13,%rsi mov %r12,%rdi callq 1080 <strcpy@plt> mov -0x28(%rbp),%rax xor %fs:0x28,%rax jne 1296 <func0+0xed> mov %r12,%rax lea -0x18(%rbp),%rsp pop %rbx pop %r12 pop %r13 pop %rbp retq callq 1090 <__stack_chk_fail@plt>
func0: endbr64 push rbp mov rbp, rsp push r13 push r12 push rbx sub rsp, 18h mov r12, rdi mov rax, fs:28h mov [rbp+var_28], rax xor eax, eax call _strlen add rax, 10h mov rcx, rax and rcx, 0FFFFFFFFFFFFFFF0h and rax, 0FFFFFFFFFFFFF000h mov rdx, rsp sub rdx, rax loc_1228: cmp rsp, rdx jz short loc_123F sub rsp, 1000h or [rsp+1030h+var_38], 0 jmp short loc_1228 loc_123F: mov rax, rcx and eax, 0FFFh sub rsp, rax test rax, rax jz short loc_1255 or [rsp+rax+30h+var_38], 0 loc_1255: mov r13, rsp movzx ebx, byte ptr [r12] test bl, bl jz short loc_1298 call ___ctype_b_loc mov rsi, [rax] lea rax, [r12+1] mov ecx, 0 jmp short loc_1281 loc_1275: add rax, 1 movzx ebx, byte ptr [rax-1] test bl, bl jz short loc_129D loc_1281: movsx rdx, bl test byte ptr [rsi+rdx*2], 8 jz short loc_1275 movsxd rdx, ecx mov [r13+rdx+0], bl lea ecx, [rcx+1] jmp short loc_1275 loc_1298: mov ecx, 0 loc_129D: movsxd rcx, ecx mov byte ptr [r13+rcx+0], 0 mov rsi, r13 mov rdi, r12 call _strcpy mov rax, [rbp+var_28] sub rax, fs:28h jnz short loc_12CE mov rax, r12 lea rsp, [rbp-18h] pop rbx pop r12 pop r13 pop rbp retn loc_12CE: call ___stack_chk_fail
char * func0(char *a1) { long long v1; // rax __int16 v2; // cx signed long long v3; // rax void *v4; // rsp char v5; // bl long long v6; // rsi char *v7; // rax int v8; // ecx _BYTE v11[8]; // [rsp+8h] [rbp-30h] BYREF unsigned long long v12; // [rsp+10h] [rbp-28h] v12 = __readfsqword(0x28u); v1 = strlen() + 16; v2 = v1 & 0xFFF0; while ( v11 != &v11[-(v1 & 0xFFFFFFFFFFFFF000LL)] ) ; v3 = v1 & 0xFF0; v4 = alloca(v3); if ( (v2 & 0xFFF) != 0 ) *(_QWORD *)&v11[v3 - 8] = *(_QWORD *)&v11[v3 - 8]; v5 = *a1; if ( *a1 ) { v6 = *(_QWORD *)__ctype_b_loc(); v7 = a1 + 1; v8 = 0; do { if ( (*(_BYTE *)(v6 + 2LL * v5) & 8) != 0 ) v11[v8++] = v5; v5 = *v7++; } while ( v5 ); } else { v8 = 0; } v11[v8] = 0; strcpy(a1, v11); return a1; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP PUSH R13 PUSH R12 PUSH RBX SUB RSP,0x18 MOV R12,RDI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x28],RAX XOR EAX,EAX CALL 0x001010b0 ADD RAX,0x10 MOV RCX,RAX AND RCX,-0x10 AND RAX,-0x1000 MOV RDX,RSP SUB RDX,RAX LAB_00101228: CMP RSP,RDX JZ 0x0010123f SUB RSP,0x1000 OR qword ptr [RSP + 0xff8],0x0 JMP 0x00101228 LAB_0010123f: MOV RAX,RCX AND EAX,0xfff SUB RSP,RAX TEST RAX,RAX JZ 0x00101255 OR qword ptr [RSP + RAX*0x1 + -0x8],0x0 LAB_00101255: MOV R13,RSP MOVZX EBX,byte ptr [R12] TEST BL,BL JZ 0x00101298 CALL 0x001010f0 MOV RSI,qword ptr [RAX] LEA RAX,[R12 + 0x1] MOV ECX,0x0 JMP 0x00101281 LAB_00101275: ADD RAX,0x1 MOVZX EBX,byte ptr [RAX + -0x1] TEST BL,BL JZ 0x0010129d LAB_00101281: MOVSX RDX,BL TEST byte ptr [RSI + RDX*0x2],0x8 JZ 0x00101275 MOVSXD RDX,ECX MOV byte ptr [R13 + RDX*0x1],BL LEA ECX,[RCX + 0x1] JMP 0x00101275 LAB_00101298: MOV ECX,0x0 LAB_0010129d: MOVSXD RCX,ECX MOV byte ptr [R13 + RCX*0x1],0x0 MOV RSI,R13 MOV RDI,R12 CALL 0x001010a0 MOV RAX,qword ptr [RBP + -0x28] SUB RAX,qword ptr FS:[0x28] JNZ 0x001012ce MOV RAX,R12 LEA RSP,[RBP + -0x18] POP RBX POP R12 POP R13 POP RBP RET LAB_001012ce: CALL 0x001010c0
char * func0(char *param_1) { ushort *puVar1; long lVar2; size_t sVar3; ulong uVar4; ushort **ppuVar5; char *pcVar6; int iVar7; char cVar8; int1 *puVar9; long in_FS_OFFSET; int1 auStack_38 [8]; long local_30; local_30 = *(long *)(in_FS_OFFSET + 0x28); sVar3 = strlen(param_1); for (puVar9 = auStack_38; puVar9 != auStack_38 + -(sVar3 + 0x10 & 0xfffffffffffff000); puVar9 = puVar9 + -0x1000) { *(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8); } uVar4 = (ulong)((uint)(sVar3 + 0x10) & 0xff0); lVar2 = -uVar4; if (uVar4 != 0) { *(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8); } cVar8 = *param_1; if (cVar8 == '\0') { iVar7 = 0; } else { *(int8 *)(puVar9 + lVar2 + -8) = 0x101266; ppuVar5 = __ctype_b_loc(); puVar1 = *ppuVar5; iVar7 = 0; pcVar6 = param_1 + 1; do { if ((puVar1[cVar8] & 8) != 0) { puVar9[iVar7 + lVar2] = cVar8; iVar7 = iVar7 + 1; } cVar8 = *pcVar6; pcVar6 = pcVar6 + 1; } while (cVar8 != '\0'); } puVar9[iVar7 + lVar2] = 0; *(int8 *)(puVar9 + lVar2 + -8) = 0x1012b1; strcpy(param_1,puVar9 + lVar2); if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) { return param_1; } /* WARNING: Subroutine does not return */ *(code **)(puVar9 + lVar2 + -8) = main; __stack_chk_fail(); }
4,586
func0
#include <stdio.h> #include <string.h> #include <ctype.h> #include <assert.h>
char* func0(char* text) { int i=0, j=0; char temp[strlen(text) + 1]; while(text[i]) { if(isalnum(text[i])) { temp[j++] = text[i]; } i++; } temp[j] = '\0'; strcpy(text, temp); return text; }
int main() { char text1[] = "python @#&^%$*program123"; char text2[] = "python %^$@!^&*() programming24%$^^() language"; char text3[] = "python ^%&^()(+_)(_^&67) program"; assert(strcmp(func0(text1), "pythonprogram123") == 0); assert(strcmp(func0(text2), "pythonprogramming24language") == 0); assert(strcmp(func0(text3), "python67program") == 0); return 0; }
O2
c
func0: endbr64 push %rbp mov %rsp,%rbp push %r13 push %r12 mov %rdi,%r12 push %rbx sub $0x18,%rsp mov %fs:0x28,%rax mov %rax,-0x28(%rbp) xor %eax,%eax callq 10a0 <strlen@plt> mov %rsp,%rdi add $0x10,%rax mov %rax,%rdx and $0xfffffffffffff000,%rax sub %rax,%rdi and $0xfffffffffffffff0,%rdx mov %rdi,%rax cmp %rax,%rsp je 13cc <func0+0x5c> sub $0x1000,%rsp orq $0x0,0xff8(%rsp) cmp %rax,%rsp jne 13b7 <func0+0x47> and $0xfff,%edx sub %rdx,%rsp test %rdx,%rdx jne 1450 <func0+0xe0> movzbl (%r12),%ebx mov %rsp,%r13 test %bl,%bl je 1458 <func0+0xe8> callq 10d0 <__ctype_b_loc@plt> xor %ecx,%ecx mov (%rax),%rsi lea 0x1(%r12),%rax nopl (%rax) movsbq %bl,%rdx testb $0x8,(%rsi,%rdx,2) je 140d <func0+0x9d> movslq %ecx,%rdx add $0x1,%ecx mov %bl,0x0(%r13,%rdx,1) movzbl (%rax),%ebx add $0x1,%rax test %bl,%bl jne 13f8 <func0+0x88> movslq %ecx,%rcx mov %r13,%rsi mov %r12,%rdi movb $0x0,0x0(%r13,%rcx,1) callq 1090 <strcpy@plt> mov -0x28(%rbp),%rax xor %fs:0x28,%rax jne 145c <func0+0xec> lea -0x18(%rbp),%rsp mov %r12,%rax pop %rbx pop %r12 pop %r13 pop %rbp retq nopl 0x0(%rax) orq $0x0,-0x8(%rsp,%rdx,1) jmp 13da <func0+0x6a> xor %ecx,%ecx jmp 1418 <func0+0xa8> callq 10b0 <__stack_chk_fail@plt> nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax,%rax,1)
func0: endbr64 push rbp mov rbp, rsp push r13 push r12 mov r12, rdi push rbx sub rsp, 18h mov rax, fs:28h mov [rbp+var_28], rax xor eax, eax call _strlen mov rcx, rsp add rax, 10h mov rdx, rax and rax, 0FFFFFFFFFFFFF000h sub rcx, rax and rdx, 0FFFFFFFFFFFFFFF0h cmp rsp, rcx jz short loc_13D9 loc_13C4: sub rsp, 1000h or [rsp+1030h+var_38], 0 cmp rsp, rcx jnz short loc_13C4 loc_13D9: and edx, 0FFFh sub rsp, rdx test rdx, rdx jnz short loc_1460 loc_13E7: movzx ebx, byte ptr [r12] mov r13, rsp test bl, bl jz short loc_146B call ___ctype_b_loc xor ecx, ecx mov rsi, [rax] lea rax, [r12+1] nop word ptr [rax+rax+00h] loc_1408: movsx rdx, bl test byte ptr [rsi+rdx*2], 8 jz short loc_141D movsxd rdx, ecx add ecx, 1 mov [r13+rdx+0], bl loc_141D: movzx ebx, byte ptr [rax] add rax, 1 test bl, bl jnz short loc_1408 loc_1428: movsxd rcx, ecx mov rsi, r13 mov rdi, r12 mov byte ptr [r13+rcx+0], 0 call _strcpy mov rax, [rbp+var_28] sub rax, fs:28h jnz short loc_146F lea rsp, [rbp-18h] mov rax, r12 pop rbx pop r12 pop r13 pop rbp retn loc_1460: or [rsp+rdx+1030h+var_1038], 0 jmp loc_13E7 loc_146B: xor ecx, ecx jmp short loc_1428 loc_146F: call ___stack_chk_fail
char * func0(char *a1) { long long v1; // rax _BYTE *v2; // rcx signed long long v3; // rdx void *v4; // rsp char v5; // bl long long *v6; // rax int v7; // ecx long long v8; // rsi char *v9; // rax long long v10; // rdx _BYTE v13[4088]; // [rsp+8h] [rbp-1030h] BYREF _QWORD v14[6]; // [rsp+1008h] [rbp-30h] BYREF v14[1] = __readfsqword(0x28u); v1 = strlen(); v2 = (char *)v14 - ((v1 + 16) & 0xFFFFFFFFFFFFF000LL); if ( v14 != (_QWORD *)v2 ) { while ( v13 != v2 ) ; } v3 = ((_WORD)v1 + 16) & 0xFF0; v4 = alloca(v3); if ( (((_WORD)v1 + 16) & 0xFF0) != 0 ) *(_QWORD *)&v13[v3 - 8] = *(_QWORD *)&v13[v3 - 8]; v5 = *a1; if ( *a1 ) { v6 = (long long *)__ctype_b_loc(); v7 = 0; v8 = *v6; v9 = a1 + 1; do { if ( (*(_BYTE *)(v8 + 2LL * v5) & 8) != 0 ) { v10 = v7++; v13[v10] = v5; } v5 = *v9++; } while ( v5 ); } else { v7 = 0; } v13[v7] = 0; strcpy(a1, v13); return a1; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP PUSH R13 PUSH R12 MOV R12,RDI PUSH RBX SUB RSP,0x18 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x28],RAX XOR EAX,EAX CALL 0x001010b0 MOV RCX,RSP ADD RAX,0x10 MOV RDX,RAX AND RAX,-0x1000 SUB RCX,RAX AND RDX,-0x10 CMP RSP,RCX JZ 0x001013d9 LAB_001013c4: SUB RSP,0x1000 OR qword ptr [RSP + 0xff8],0x0 CMP RSP,RCX JNZ 0x001013c4 LAB_001013d9: AND EDX,0xfff SUB RSP,RDX TEST RDX,RDX JNZ 0x00101460 LAB_001013e7: MOVZX EBX,byte ptr [R12] MOV R13,RSP TEST BL,BL JZ 0x0010146b CALL 0x001010f0 XOR ECX,ECX MOV RSI,qword ptr [RAX] LEA RAX,[R12 + 0x1] NOP word ptr [RAX + RAX*0x1] LAB_00101408: MOVSX RDX,BL TEST byte ptr [RSI + RDX*0x2],0x8 JZ 0x0010141d MOVSXD RDX,ECX ADD ECX,0x1 MOV byte ptr [R13 + RDX*0x1],BL LAB_0010141d: MOVZX EBX,byte ptr [RAX] ADD RAX,0x1 TEST BL,BL JNZ 0x00101408 LAB_00101428: MOVSXD RCX,ECX MOV RSI,R13 MOV RDI,R12 MOV byte ptr [R13 + RCX*0x1],0x0 CALL 0x001010a0 MOV RAX,qword ptr [RBP + -0x28] SUB RAX,qword ptr FS:[0x28] JNZ 0x0010146f LEA RSP,[RBP + -0x18] MOV RAX,R12 POP RBX POP R12 POP R13 POP RBP RET LAB_00101460: OR qword ptr [RSP + RDX*0x1 + -0x8],0x0 JMP 0x001013e7 LAB_0010146b: XOR ECX,ECX JMP 0x00101428 LAB_0010146f: CALL 0x001010c0
char * func0(char *param_1) { ushort *puVar1; long lVar2; int1 *puVar3; size_t sVar4; ushort **ppuVar5; char *pcVar6; int iVar7; ulong uVar8; long lVar9; char cVar10; int1 *puVar11; long in_FS_OFFSET; int1 auStack_38 [8]; long local_30; int1 *puVar12; puVar11 = auStack_38; local_30 = *(long *)(in_FS_OFFSET + 0x28); sVar4 = strlen(param_1); puVar12 = auStack_38; puVar3 = auStack_38; while (puVar12 != auStack_38 + -(sVar4 + 0x10 & 0xfffffffffffff000)) { puVar11 = puVar3 + -0x1000; *(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8); puVar12 = puVar3 + -0x1000; puVar3 = puVar3 + -0x1000; } uVar8 = (ulong)((uint)(sVar4 + 0x10) & 0xff0); lVar2 = -uVar8; if (uVar8 != 0) { *(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8); } cVar10 = *param_1; if (cVar10 == '\0') { iVar7 = 0; } else { *(int8 *)(puVar11 + lVar2 + -8) = 0x1013f8; ppuVar5 = __ctype_b_loc(); iVar7 = 0; puVar1 = *ppuVar5; pcVar6 = param_1 + 1; do { if ((puVar1[cVar10] & 8) != 0) { lVar9 = (long)iVar7; iVar7 = iVar7 + 1; puVar11[lVar9 + lVar2] = cVar10; } cVar10 = *pcVar6; pcVar6 = pcVar6 + 1; } while (cVar10 != '\0'); } puVar11[iVar7 + lVar2] = 0; *(int8 *)(puVar11 + lVar2 + -8) = 0x10143c; strcpy(param_1,puVar11 + lVar2); if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ *(code **)(puVar11 + lVar2 + -8) = _fini; __stack_chk_fail(); } return param_1; }
4,587
func0
#include <stdio.h> #include <string.h> #include <ctype.h> #include <assert.h>
char* func0(char* text) { int i=0, j=0; char temp[strlen(text) + 1]; while(text[i]) { if(isalnum(text[i])) { temp[j++] = text[i]; } i++; } temp[j] = '\0'; strcpy(text, temp); return text; }
int main() { char text1[] = "python @#&^%$*program123"; char text2[] = "python %^$@!^&*() programming24%$^^() language"; char text3[] = "python ^%&^()(+_)(_^&67) program"; assert(strcmp(func0(text1), "pythonprogram123") == 0); assert(strcmp(func0(text2), "pythonprogramming24language") == 0); assert(strcmp(func0(text3), "python67program") == 0); return 0; }
O3
c
func0: endbr64 push %rbp mov %rsp,%rbp push %r13 push %r12 mov %rdi,%r12 push %rbx sub $0x18,%rsp mov %fs:0x28,%rax mov %rax,-0x28(%rbp) xor %eax,%eax callq 10a0 <strlen@plt> mov %rsp,%rdi add $0x10,%rax mov %rax,%rdx and $0xfffffffffffff000,%rax sub %rax,%rdi and $0xfffffffffffffff0,%rdx mov %rdi,%rax cmp %rax,%rsp je 13cc <func0+0x5c> sub $0x1000,%rsp orq $0x0,0xff8(%rsp) cmp %rax,%rsp jne 13b7 <func0+0x47> and $0xfff,%edx sub %rdx,%rsp test %rdx,%rdx jne 1470 <func0+0x100> movzbl (%r12),%ebx mov %rsp,%r13 test %bl,%bl je 147b <func0+0x10b> callq 10d0 <__ctype_b_loc@plt> xor %edx,%edx mov (%rax),%rsi lea 0x1(%r12),%rax nopl (%rax) movsbq %bl,%rcx testb $0x8,(%rsi,%rcx,2) je 142b <func0+0xbb> add $0x1,%rax mov %bl,0x0(%r13,%rdx,1) lea 0x1(%rdx),%ecx movzbl -0x1(%rax),%ebx test %bl,%bl je 1438 <func0+0xc8> movslq %ecx,%rdx movsbq %bl,%rcx testb $0x8,(%rsi,%rcx,2) jne 140a <func0+0x9a> movzbl (%rax),%ebx add $0x1,%rax test %bl,%bl jne 1400 <func0+0x90> mov %edx,%ecx movslq %ecx,%rcx mov %r13,%rsi mov %r12,%rdi movb $0x0,0x0(%r13,%rcx,1) callq 1090 <strcpy@plt> mov -0x28(%rbp),%rax xor %fs:0x28,%rax jne 147f <func0+0x10f> lea -0x18(%rbp),%rsp mov %r12,%rax pop %rbx pop %r12 pop %r13 pop %rbp retq nopl 0x0(%rax) orq $0x0,-0x8(%rsp,%rdx,1) jmpq 13de <func0+0x6e> xor %ecx,%ecx jmp 1438 <func0+0xc8> callq 10b0 <__stack_chk_fail@plt> nopw %cs:0x0(%rax,%rax,1) xchg %ax,%ax
func0: endbr64 push rbp mov rbp, rsp push r13 push r12 mov r12, rdi push rbx sub rsp, 18h mov rax, fs:28h mov [rbp+var_28], rax xor eax, eax call _strlen mov rcx, rsp add rax, 10h mov rdx, rax and rax, 0FFFFFFFFFFFFF000h sub rcx, rax and rdx, 0FFFFFFFFFFFFFFF0h cmp rsp, rcx jz short loc_13B9 loc_13A4: sub rsp, 1000h or [rsp+1030h+var_38], 0 cmp rsp, rcx jnz short loc_13A4 loc_13B9: and edx, 0FFFh sub rsp, rdx test rdx, rdx jnz loc_1450 loc_13CB: movzx ebx, byte ptr [r12] mov r13, rsp test bl, bl jz loc_145B call ___ctype_b_loc xor edx, edx mov rsi, [rax] lea rax, [r12+1] nop word ptr [rax+rax+00h] loc_13F0: movsx rcx, bl test byte ptr [rsi+rcx*2], 8 jz short loc_1440 add rax, 1 mov [r13+rdx+0], bl lea ecx, [rdx+1] movzx ebx, byte ptr [rax-1] movsxd rdx, ecx test bl, bl jnz short loc_13F0 loc_1411: mov byte ptr [r13+rdx+0], 0 mov rsi, r13; src mov rdi, r12; dest call _strcpy mov rax, [rbp+var_28] sub rax, fs:28h jnz short loc_145F lea rsp, [rbp-18h] mov rax, r12 pop rbx pop r12 pop r13 pop rbp retn loc_1440: movzx ebx, byte ptr [rax] add rax, 1 test bl, bl jnz short loc_13F0 jmp short loc_1411 loc_1450: or [rsp+rdx+1030h+var_1038], 0 jmp loc_13CB loc_145B: xor edx, edx jmp short loc_1411 loc_145F: call ___stack_chk_fail
char * func0(char *dest) { size_t v1; // rax char *v2; // rcx signed long long v3; // rdx void *v4; // rsp char v5; // bl const unsigned __int16 **v6; // rax long long v7; // rdx const unsigned __int16 *v8; // rsi char *v9; // rax char v12[4088]; // [rsp+8h] [rbp-1030h] BYREF _QWORD v13[6]; // [rsp+1008h] [rbp-30h] BYREF v13[1] = __readfsqword(0x28u); v1 = strlen(dest); v2 = (char *)v13 - ((v1 + 16) & 0xFFFFFFFFFFFFF000LL); if ( v13 != (_QWORD *)v2 ) { while ( v12 != v2 ) ; } v3 = ((_WORD)v1 + 16) & 0xFF0; v4 = alloca(v3); if ( (((_WORD)v1 + 16) & 0xFF0) != 0 ) *(_QWORD *)&v12[v3 - 8] = *(_QWORD *)&v12[v3 - 8]; v5 = *dest; if ( *dest ) { v6 = __ctype_b_loc(); v7 = 0LL; v8 = *v6; v9 = dest + 1; do { while ( (v8[v5] & 8) != 0 ) { ++v9; v12[v7] = v5; v5 = *(v9 - 1); v7 = (int)v7 + 1; if ( !v5 ) goto LABEL_9; } v5 = *v9++; } while ( v5 ); } else { v7 = 0LL; } LABEL_9: v12[v7] = 0; strcpy(dest, v12); return dest; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP PUSH R13 PUSH R12 MOV R12,RDI PUSH RBX SUB RSP,0x18 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x28],RAX XOR EAX,EAX CALL 0x001010b0 MOV RCX,RSP ADD RAX,0x10 MOV RDX,RAX AND RAX,-0x1000 SUB RCX,RAX AND RDX,-0x10 CMP RSP,RCX JZ 0x001013b9 LAB_001013a4: SUB RSP,0x1000 OR qword ptr [RSP + 0xff8],0x0 CMP RSP,RCX JNZ 0x001013a4 LAB_001013b9: AND EDX,0xfff SUB RSP,RDX TEST RDX,RDX JNZ 0x00101450 LAB_001013cb: MOVZX EBX,byte ptr [R12] MOV R13,RSP TEST BL,BL JZ 0x0010145b CALL 0x001010f0 XOR EDX,EDX MOV RSI,qword ptr [RAX] LEA RAX,[R12 + 0x1] NOP word ptr [RAX + RAX*0x1] LAB_001013f0: MOVSX RCX,BL TEST byte ptr [RSI + RCX*0x2],0x8 JZ 0x00101440 ADD RAX,0x1 MOV byte ptr [R13 + RDX*0x1],BL LEA ECX,[RDX + 0x1] MOVZX EBX,byte ptr [RAX + -0x1] MOVSXD RDX,ECX TEST BL,BL JNZ 0x001013f0 LAB_00101411: MOV byte ptr [R13 + RDX*0x1],0x0 MOV RSI,R13 MOV RDI,R12 CALL 0x001010a0 MOV RAX,qword ptr [RBP + -0x28] SUB RAX,qword ptr FS:[0x28] JNZ 0x0010145f LEA RSP,[RBP + -0x18] MOV RAX,R12 POP RBX POP R12 POP R13 POP RBP RET LAB_00101440: MOVZX EBX,byte ptr [RAX] ADD RAX,0x1 TEST BL,BL JNZ 0x001013f0 JMP 0x00101411 LAB_00101450: OR qword ptr [RSP + RDX*0x1 + -0x8],0x0 JMP 0x001013cb LAB_0010145b: XOR EDX,EDX JMP 0x00101411 LAB_0010145f: CALL 0x001010c0
char * func0(char *param_1) { ushort *puVar1; long lVar2; int *puVar3; size_t sVar4; ushort **ppuVar5; char *pcVar6; ulong uVar7; long lVar8; char cVar9; int *puVar10; long in_FS_OFFSET; int auStack_38 [8]; long local_30; int *puVar11; puVar10 = auStack_38; local_30 = *(long *)(in_FS_OFFSET + 0x28); sVar4 = strlen(param_1); puVar11 = auStack_38; puVar3 = auStack_38; while (puVar11 != auStack_38 + -(sVar4 + 0x10 & 0xfffffffffffff000)) { puVar10 = puVar3 + -0x1000; *(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8); puVar11 = puVar3 + -0x1000; puVar3 = puVar3 + -0x1000; } uVar7 = (ulong)((uint)(sVar4 + 0x10) & 0xff0); lVar2 = -uVar7; if (uVar7 != 0) { *(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8); } cVar9 = *param_1; if (cVar9 == '\0') { lVar8 = 0; } else { *(int8 *)(puVar10 + lVar2 + -8) = 0x1013e0; ppuVar5 = __ctype_b_loc(); lVar8 = 0; puVar1 = *ppuVar5; pcVar6 = param_1 + 1; do { while ((*(byte *)(puVar1 + cVar9) & 8) != 0) { puVar10[lVar8 + lVar2] = cVar9; cVar9 = *pcVar6; lVar8 = (long)((int)lVar8 + 1); pcVar6 = pcVar6 + 1; if (cVar9 == '\0') goto LAB_00101411; } cVar9 = *pcVar6; pcVar6 = pcVar6 + 1; } while (cVar9 != '\0'); } LAB_00101411: puVar10[lVar8 + lVar2] = 0; *(int8 *)(puVar10 + lVar2 + -8) = 0x101422; strcpy(param_1,puVar10 + lVar2); if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) { return param_1; } /* WARNING: Subroutine does not return */ *(code **)(puVar10 + lVar2 + -8) = _fini; __stack_chk_fail(); }
4,588
func0
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> typedef struct Node { int value; struct Node *next; } Node; typedef struct { char *key; Node *values; } KeyValue; typedef struct { KeyValue *pairs; int size; int capacity; } HashMap; void appendValue(Node **list, int value) { Node *new_node = malloc(sizeof(Node)); new_node->value = value; new_node->next = NULL; if (*list == NULL) { *list = new_node; } else { Node *current = *list; while (current->next != NULL) { current = current->next; } current->next = new_node; } } void initHashMap(HashMap *map) { map->size = 0; map->capacity = 10; map->pairs = malloc(map->capacity * sizeof(KeyValue)); } void insertHashMap(HashMap *map, char *key, int value) { for (int i = 0; i < map->size; i++) { if (strcmp(map->pairs[i].key, key) == 0) { appendValue(&map->pairs[i].values, value); return; } } if (map->size == map->capacity) { map->capacity *= 2; map->pairs = realloc(map->pairs, map->capacity * sizeof(KeyValue)); } map->pairs[map->size].key = strdup(key); map->pairs[map->size].values = NULL; appendValue(&map->pairs[map->size].values, value); map->size++; }
HashMap func0(char l[][2][10], int len) { HashMap result; initHashMap(&result); for (int i = 0; i < len; i++) { insertHashMap(&result, l[i][0], atoi(l[i][1])); } return result; }
int main() { char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}}; HashMap result1 = func0(test1, 5); char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}}; HashMap result2 = func0(test2, 5); char test3[][2][10] = {{"yellow", "100"}, {"blue", "200"}, {"yellow", "300"}, {"blue", "400"}, {"red", "100"}}; HashMap result3 = func0(test3, 5); assert(result1.size == 3); // manual check summarizing result comparisons assert(result2.size == 1); // instead of making direct list and map comparisons assert(result3.size == 3); // as in Python, specific to use case and hash map content // Cleanup for (int i = 0; i < result1.size; i++) free(result1.pairs[i].key); free(result1.pairs); for (int i = 0; i < result2.size; i++) free(result2.pairs[i].key); free(result2.pairs); for (int i = 0; i < result3.size; i++) free(result3.pairs[i].key); free(result3.pairs); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x40,%rsp mov %rdi,-0x38(%rbp) mov %esi,-0x3c(%rbp) mov %fs:0x28,%rax mov %rax,-0x8(%rbp) xor %eax,%eax lea -0x20(%rbp),%rax mov %rax,%rdi callq 12ad <initHashMap> movl $0x0,-0x24(%rbp) jmp 14e2 <func0+0x96> mov -0x24(%rbp),%eax movslq %eax,%rdx mov %rdx,%rax shl $0x2,%rax add %rdx,%rax shl $0x2,%rax mov %rax,%rdx mov -0x38(%rbp),%rax add %rdx,%rax add $0xa,%rax mov %rax,%rdi callq 1120 <atoi@plt> mov %eax,%ecx mov -0x24(%rbp),%eax movslq %eax,%rdx mov %rdx,%rax shl $0x2,%rax add %rdx,%rax shl $0x2,%rax mov %rax,%rdx mov -0x38(%rbp),%rax add %rdx,%rax mov %rax,%rsi lea -0x20(%rbp),%rax mov %ecx,%edx mov %rax,%rdi callq 12f5 <insertHashMap> addl $0x1,-0x24(%rbp) mov -0x24(%rbp),%eax cmp -0x3c(%rbp),%eax jl 1483 <func0+0x37> mov -0x20(%rbp),%rax mov -0x18(%rbp),%rdx mov -0x8(%rbp),%rcx xor %fs:0x28,%rcx je 1506 <func0+0xba> callq 10d0 <__stack_chk_fail@plt> leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 40h mov [rbp+var_38], rdi mov [rbp+var_3C], esi mov rax, fs:28h mov [rbp+var_8], rax xor eax, eax lea rax, [rbp+var_20] mov rdi, rax call initHashMap mov [rbp+var_24], 0 jmp short loc_14E1 loc_1482: mov eax, [rbp+var_24] movsxd rdx, eax mov rax, rdx shl rax, 2 add rax, rdx shl rax, 2 mov rdx, rax mov rax, [rbp+var_38] add rax, rdx add rax, 0Ah mov rdi, rax; nptr call _atoi mov ecx, eax mov eax, [rbp+var_24] movsxd rdx, eax mov rax, rdx shl rax, 2 add rax, rdx shl rax, 2 mov rdx, rax mov rax, [rbp+var_38] add rax, rdx mov rsi, rax lea rax, [rbp+var_20] mov edx, ecx mov rdi, rax call insertHashMap add [rbp+var_24], 1 loc_14E1: mov eax, [rbp+var_24] cmp eax, [rbp+var_3C] jl short loc_1482 mov rax, [rbp+var_20] mov rdx, [rbp+var_18] mov rcx, [rbp+var_8] sub rcx, fs:28h jz short locret_1505 call ___stack_chk_fail locret_1505: leave retn
long long func0(long long a1, int a2) { unsigned int v2; // eax int i; // [rsp+1Ch] [rbp-24h] _QWORD v5[4]; // [rsp+20h] [rbp-20h] BYREF v5[3] = __readfsqword(0x28u); initHashMap(v5); for ( i = 0; i < a2; ++i ) { v2 = atoi((const char *)(20LL * i + a1 + 10)); insertHashMap(v5, 20LL * i + a1, v2); } return v5[0]; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x40 MOV qword ptr [RBP + -0x38],RDI MOV dword ptr [RBP + -0x3c],ESI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x8],RAX XOR EAX,EAX LEA RAX,[RBP + -0x20] MOV RDI,RAX CALL 0x001012ad MOV dword ptr [RBP + -0x24],0x0 JMP 0x001014e1 LAB_00101482: MOV EAX,dword ptr [RBP + -0x24] MOVSXD RDX,EAX MOV RAX,RDX SHL RAX,0x2 ADD RAX,RDX SHL RAX,0x2 MOV RDX,RAX MOV RAX,qword ptr [RBP + -0x38] ADD RAX,RDX ADD RAX,0xa MOV RDI,RAX CALL 0x00101120 MOV ECX,EAX MOV EAX,dword ptr [RBP + -0x24] MOVSXD RDX,EAX MOV RAX,RDX SHL RAX,0x2 ADD RAX,RDX SHL RAX,0x2 MOV RDX,RAX MOV RAX,qword ptr [RBP + -0x38] ADD RAX,RDX MOV RSI,RAX LEA RAX,[RBP + -0x20] MOV EDX,ECX MOV RDI,RAX CALL 0x001012f5 ADD dword ptr [RBP + -0x24],0x1 LAB_001014e1: MOV EAX,dword ptr [RBP + -0x24] CMP EAX,dword ptr [RBP + -0x3c] JL 0x00101482 MOV RAX,qword ptr [RBP + -0x20] MOV RDX,qword ptr [RBP + -0x18] MOV RCX,qword ptr [RBP + -0x8] SUB RCX,qword ptr FS:[0x28] JZ 0x00101505 CALL 0x001010d0 LAB_00101505: LEAVE RET
int8 func0(long param_1,int param_2) { int iVar1; long in_FS_OFFSET; int local_2c; int8 local_28 [3]; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); initHashMap(local_28); for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) { iVar1 = atoi((char *)(param_1 + (long)local_2c * 0x14 + 10)); insertHashMap(local_28,param_1 + (long)local_2c * 0x14,iVar1); } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return local_28[0]; }
4,589
func0
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> typedef struct Node { int value; struct Node *next; } Node; typedef struct { char *key; Node *values; } KeyValue; typedef struct { KeyValue *pairs; int size; int capacity; } HashMap; void appendValue(Node **list, int value) { Node *new_node = malloc(sizeof(Node)); new_node->value = value; new_node->next = NULL; if (*list == NULL) { *list = new_node; } else { Node *current = *list; while (current->next != NULL) { current = current->next; } current->next = new_node; } } void initHashMap(HashMap *map) { map->size = 0; map->capacity = 10; map->pairs = malloc(map->capacity * sizeof(KeyValue)); } void insertHashMap(HashMap *map, char *key, int value) { for (int i = 0; i < map->size; i++) { if (strcmp(map->pairs[i].key, key) == 0) { appendValue(&map->pairs[i].values, value); return; } } if (map->size == map->capacity) { map->capacity *= 2; map->pairs = realloc(map->pairs, map->capacity * sizeof(KeyValue)); } map->pairs[map->size].key = strdup(key); map->pairs[map->size].values = NULL; appendValue(&map->pairs[map->size].values, value); map->size++; }
HashMap func0(char l[][2][10], int len) { HashMap result; initHashMap(&result); for (int i = 0; i < len; i++) { insertHashMap(&result, l[i][0], atoi(l[i][1])); } return result; }
int main() { char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}}; HashMap result1 = func0(test1, 5); char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}}; HashMap result2 = func0(test2, 5); char test3[][2][10] = {{"yellow", "100"}, {"blue", "200"}, {"yellow", "300"}, {"blue", "400"}, {"red", "100"}}; HashMap result3 = func0(test3, 5); assert(result1.size == 3); // manual check summarizing result comparisons assert(result2.size == 1); // instead of making direct list and map comparisons assert(result3.size == 3); // as in Python, specific to use case and hash map content // Cleanup for (int i = 0; i < result1.size; i++) free(result1.pairs[i].key); free(result1.pairs); for (int i = 0; i < result2.size; i++) free(result2.pairs[i].key); free(result2.pairs); for (int i = 0; i < result3.size; i++) free(result3.pairs[i].key); free(result3.pairs); return 0; }
O1
c
func0: endbr64 push %r12 push %rbp push %rbx sub $0x20,%rsp mov %rdi,%r12 mov %esi,%ebp mov %fs:0x28,%rax mov %rax,0x18(%rsp) xor %eax,%eax mov %rsp,%rdi callq 1270 <initHashMap> test %ebp,%ebp jle 13dc <func0+0x6b> lea 0xa(%r12),%rbx lea -0x1(%rbp),%eax lea (%rax,%rax,4),%rax lea 0x1e(%r12,%rax,4),%r12 mov %rsp,%rbp mov $0xa,%edx mov $0x0,%esi mov %rbx,%rdi callq 1100 <strtol@plt> mov %rax,%rdx lea -0xa(%rbx),%rsi mov %rbp,%rdi callq 1295 <insertHashMap> add $0x14,%rbx cmp %r12,%rbx jne 13b2 <func0+0x41> mov (%rsp),%rax mov 0x8(%rsp),%rdx mov 0x18(%rsp),%rcx xor %fs:0x28,%rcx jne 13fe <func0+0x8d> add $0x20,%rsp pop %rbx pop %rbp pop %r12 retq callq 10d0 <__stack_chk_fail@plt>
func0: endbr64 push r12 push rbp push rbx sub rsp, 20h mov r12, rdi mov ebp, esi mov rax, fs:28h mov [rsp+38h+var_20], rax xor eax, eax mov rdi, rsp call initHashMap test ebp, ebp jle short loc_13DB lea rbx, [r12+0Ah] lea eax, [rbp-1] lea rax, [rax+rax*4] lea r12, [r12+rax*4+1Eh] mov rbp, rsp loc_13B2: mov edx, 0Ah mov esi, 0 mov rdi, rbx call _strtol lea rsi, [rbx-0Ah] mov edx, eax mov rdi, rbp call insertHashMap add rbx, 14h cmp rbx, r12 jnz short loc_13B2 loc_13DB: mov rax, [rsp+38h+var_38] mov rdx, [rsp+38h+var_30] mov rcx, [rsp+38h+var_20] sub rcx, fs:28h jnz short loc_13FD add rsp, 20h pop rbx pop rbp pop r12 retn loc_13FD: call ___stack_chk_fail
long long func0(long long a1, int a2) { long long v2; // rbx unsigned int v3; // eax _QWORD v5[7]; // [rsp+0h] [rbp-38h] BYREF v5[3] = __readfsqword(0x28u); initHashMap(v5); if ( a2 > 0 ) { v2 = a1 + 10; do { v3 = strtol(v2, 0LL, 10LL); insertHashMap(v5, v2 - 10, v3); v2 += 20LL; } while ( v2 != a1 + 20LL * (unsigned int)(a2 - 1) + 30 ); } return v5[0]; }
4,590
func0
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> typedef struct Node { int value; struct Node *next; } Node; typedef struct { char *key; Node *values; } KeyValue; typedef struct { KeyValue *pairs; int size; int capacity; } HashMap; void appendValue(Node **list, int value) { Node *new_node = malloc(sizeof(Node)); new_node->value = value; new_node->next = NULL; if (*list == NULL) { *list = new_node; } else { Node *current = *list; while (current->next != NULL) { current = current->next; } current->next = new_node; } } void initHashMap(HashMap *map) { map->size = 0; map->capacity = 10; map->pairs = malloc(map->capacity * sizeof(KeyValue)); } void insertHashMap(HashMap *map, char *key, int value) { for (int i = 0; i < map->size; i++) { if (strcmp(map->pairs[i].key, key) == 0) { appendValue(&map->pairs[i].values, value); return; } } if (map->size == map->capacity) { map->capacity *= 2; map->pairs = realloc(map->pairs, map->capacity * sizeof(KeyValue)); } map->pairs[map->size].key = strdup(key); map->pairs[map->size].values = NULL; appendValue(&map->pairs[map->size].values, value); map->size++; }
HashMap func0(char l[][2][10], int len) { HashMap result; initHashMap(&result); for (int i = 0; i < len; i++) { insertHashMap(&result, l[i][0], atoi(l[i][1])); } return result; }
int main() { char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}}; HashMap result1 = func0(test1, 5); char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}}; HashMap result2 = func0(test2, 5); char test3[][2][10] = {{"yellow", "100"}, {"blue", "200"}, {"yellow", "300"}, {"blue", "400"}, {"red", "100"}}; HashMap result3 = func0(test3, 5); assert(result1.size == 3); // manual check summarizing result comparisons assert(result2.size == 1); // instead of making direct list and map comparisons assert(result3.size == 3); // as in Python, specific to use case and hash map content // Cleanup for (int i = 0; i < result1.size; i++) free(result1.pairs[i].key); free(result1.pairs); for (int i = 0; i < result2.size; i++) free(result2.pairs[i].key); free(result2.pairs); for (int i = 0; i < result3.size; i++) free(result3.pairs[i].key); free(result3.pairs); return 0; }
O2
c
func0: endbr64 push %r12 mov %rdi,%r12 mov $0xa0,%edi push %rbp mov %esi,%ebp push %rbx sub $0x20,%rsp mov %fs:0x28,%rax mov %rax,0x18(%rsp) xor %eax,%eax movabs $0xa00000000,%rax mov %rax,0x8(%rsp) callq 1110 <malloc@plt> mov %rax,(%rsp) test %ebp,%ebp jle 17f7 <func0+0x87> lea -0x1(%rbp),%eax lea 0xa(%r12),%rbx mov %rsp,%rbp lea (%rax,%rax,4),%rax lea 0x1e(%r12,%rax,4),%r12 nopw %cs:0x0(%rax,%rax,1) mov %rbx,%rdi mov $0xa,%edx xor %esi,%esi callq 1100 <strtol@plt> lea -0xa(%rbx),%rsi mov %rbp,%rdi add $0x14,%rbx mov %rax,%rdx callq 1680 <insertHashMap> cmp %r12,%rbx jne 17d0 <func0+0x60> mov 0x18(%rsp),%rcx xor %fs:0x28,%rcx mov (%rsp),%rax mov 0x8(%rsp),%rdx jne 1819 <func0+0xa9> add $0x20,%rsp pop %rbx pop %rbp pop %r12 retq callq 10d0 <__stack_chk_fail@plt> xchg %ax,%ax
func0: endbr64 push r12 mov r12, rdi mov edi, 0A0h push rbp mov ebp, esi push rbx sub rsp, 20h mov rax, fs:28h mov [rsp+38h+var_20], rax mov rax, 0A00000000h mov [rsp+38h+var_30], rax call _malloc mov [rsp+38h+var_38], rax test ebp, ebp jle short loc_174E lea eax, [rbp-1] lea rbx, [r12+0Ah] mov rbp, rsp lea rax, [rax+rax*4] lea r12, [r12+rax*4+1Eh] nop dword ptr [rax+00h] loc_1728: mov rdi, rbx mov edx, 0Ah xor esi, esi call _strtol lea rsi, [rbx-0Ah] mov rdi, rbp add rbx, 14h mov edx, eax call insertHashMap cmp rbx, r12 jnz short loc_1728 loc_174E: mov rax, [rsp+38h+var_38] mov rdx, [rsp+38h+var_30] mov rcx, [rsp+38h+var_20] sub rcx, fs:28h jnz short loc_1770 add rsp, 20h pop rbx pop rbp pop r12 retn loc_1770: call ___stack_chk_fail
long long func0(long long a1, int a2) { long long v3; // rbx unsigned int v4; // eax long long v5; // rsi _QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF v7[3] = __readfsqword(0x28u); v7[1] = 0xA00000000LL; v7[0] = malloc(160LL); if ( a2 > 0 ) { v3 = a1 + 10; do { v4 = strtol(v3, 0LL, 10LL); v5 = v3 - 10; v3 += 20LL; insertHashMap(v7, v5, v4); } while ( v3 != a1 + 20LL * (unsigned int)(a2 - 1) + 30 ); } return v7[0]; }
func0: ENDBR64 PUSH R12 MOV R12,RDI MOV EDI,0xa0 PUSH RBP MOV EBP,ESI PUSH RBX SUB RSP,0x20 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x18],RAX MOV RAX,0xa00000000 MOV qword ptr [RSP + 0x8],RAX CALL 0x00101110 MOV qword ptr [RSP],RAX TEST EBP,EBP JLE 0x0010174e LEA EAX,[RBP + -0x1] LEA RBX,[R12 + 0xa] MOV RBP,RSP LEA RAX,[RAX + RAX*0x4] LEA R12,[R12 + RAX*0x4 + 0x1e] NOP dword ptr [RAX] LAB_00101728: MOV RDI,RBX MOV EDX,0xa XOR ESI,ESI CALL 0x00101100 LEA RSI,[RBX + -0xa] MOV RDI,RBP ADD RBX,0x14 MOV EDX,EAX CALL 0x00101560 CMP RBX,R12 JNZ 0x00101728 LAB_0010174e: MOV RAX,qword ptr [RSP] MOV RDX,qword ptr [RSP + 0x8] MOV RCX,qword ptr [RSP + 0x18] SUB RCX,qword ptr FS:[0x28] JNZ 0x00101770 ADD RSP,0x20 POP RBX POP RBP POP R12 RET LAB_00101770: CALL 0x001010d0
void * func0(long param_1,int param_2) { char *pcVar1; ulong uVar2; char *__nptr; long in_FS_OFFSET; void *local_38; int8 local_30; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); local_30 = 0xa00000000; local_38 = malloc(0xa0); if (0 < param_2) { __nptr = (char *)(param_1 + 10); do { uVar2 = strtol(__nptr,(char **)0x0,10); pcVar1 = __nptr + -10; __nptr = __nptr + 0x14; insertHashMap(&local_38,pcVar1,uVar2 & 0xffffffff); } while (__nptr != (char *)(param_1 + 0x1e + (ulong)(param_2 - 1) * 0x14)); } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return local_38; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,591
func0
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> typedef struct Node { int value; struct Node *next; } Node; typedef struct { char *key; Node *values; } KeyValue; typedef struct { KeyValue *pairs; int size; int capacity; } HashMap; void appendValue(Node **list, int value) { Node *new_node = malloc(sizeof(Node)); new_node->value = value; new_node->next = NULL; if (*list == NULL) { *list = new_node; } else { Node *current = *list; while (current->next != NULL) { current = current->next; } current->next = new_node; } } void initHashMap(HashMap *map) { map->size = 0; map->capacity = 10; map->pairs = malloc(map->capacity * sizeof(KeyValue)); } void insertHashMap(HashMap *map, char *key, int value) { for (int i = 0; i < map->size; i++) { if (strcmp(map->pairs[i].key, key) == 0) { appendValue(&map->pairs[i].values, value); return; } } if (map->size == map->capacity) { map->capacity *= 2; map->pairs = realloc(map->pairs, map->capacity * sizeof(KeyValue)); } map->pairs[map->size].key = strdup(key); map->pairs[map->size].values = NULL; appendValue(&map->pairs[map->size].values, value); map->size++; }
HashMap func0(char l[][2][10], int len) { HashMap result; initHashMap(&result); for (int i = 0; i < len; i++) { insertHashMap(&result, l[i][0], atoi(l[i][1])); } return result; }
int main() { char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}}; HashMap result1 = func0(test1, 5); char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}}; HashMap result2 = func0(test2, 5); char test3[][2][10] = {{"yellow", "100"}, {"blue", "200"}, {"yellow", "300"}, {"blue", "400"}, {"red", "100"}}; HashMap result3 = func0(test3, 5); assert(result1.size == 3); // manual check summarizing result comparisons assert(result2.size == 1); // instead of making direct list and map comparisons assert(result3.size == 3); // as in Python, specific to use case and hash map content // Cleanup for (int i = 0; i < result1.size; i++) free(result1.pairs[i].key); free(result1.pairs); for (int i = 0; i < result2.size; i++) free(result2.pairs[i].key); free(result2.pairs); for (int i = 0; i < result3.size; i++) free(result3.pairs[i].key); free(result3.pairs); return 0; }
O3
c
func0: endbr64 push %r12 mov %rdi,%r12 mov $0xa0,%edi push %rbp mov %esi,%ebp push %rbx sub $0x20,%rsp mov %fs:0x28,%rax mov %rax,0x18(%rsp) xor %eax,%eax movabs $0xa00000000,%rax mov %rax,0x8(%rsp) callq 1110 <malloc@plt> mov %rax,(%rsp) test %ebp,%ebp jle 1877 <func0+0x87> lea -0x1(%rbp),%eax lea 0xa(%r12),%rbx mov %rsp,%rbp lea (%rax,%rax,4),%rax lea 0x1e(%r12,%rax,4),%r12 nopw %cs:0x0(%rax,%rax,1) mov %rbx,%rdi mov $0xa,%edx xor %esi,%esi callq 1100 <strtol@plt> lea -0xa(%rbx),%rsi mov %rbp,%rdi add $0x14,%rbx mov %rax,%rdx callq 1680 <insertHashMap> cmp %r12,%rbx jne 1850 <func0+0x60> mov 0x18(%rsp),%rcx xor %fs:0x28,%rcx mov (%rsp),%rax mov 0x8(%rsp),%rdx jne 1899 <func0+0xa9> add $0x20,%rsp pop %rbx pop %rbp pop %r12 retq callq 10d0 <__stack_chk_fail@plt> xchg %ax,%ax
func0: endbr64 push r12 push rbp movsxd rbp, esi push rbx mov rbx, rdi mov edi, 0A0h; size sub rsp, 20h mov rax, fs:28h mov [rsp+38h+var_20], rax mov rax, 0A00000000h mov [rsp+38h+var_30], rax call _malloc mov [rsp+38h+var_38], rax test ebp, ebp jle short loc_170E lea rax, [rbp+rbp*4+0] add rbx, 0Ah mov rbp, rsp lea r12, [rbx+rax*4] nop dword ptr [rax+00000000h] loc_16E8: mov rdi, rbx; nptr mov edx, 0Ah; base xor esi, esi; endptr call _strtol lea rsi, [rbx-0Ah] mov rdi, rbp add rbx, 14h mov edx, eax call insertHashMap cmp rbx, r12 jnz short loc_16E8 loc_170E: mov rax, [rsp+38h+var_38] mov rdx, [rsp+38h+var_30] mov rcx, [rsp+38h+var_20] sub rcx, fs:28h jnz short loc_1730 add rsp, 20h pop rbx pop rbp pop r12 retn loc_1730: call ___stack_chk_fail
long long func0(long long a1, int a2) { const char *v2; // rbx long long v3; // r12 unsigned int v4; // eax const char *v5; // rsi _QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF v7[3] = __readfsqword(0x28u); v7[1] = 0xA00000000LL; v7[0] = malloc(0xA0uLL); if ( a2 > 0 ) { v2 = (const char *)(a1 + 10); v3 = a1 + 10 + 20LL * a2; do { v4 = strtol(v2, 0LL, 10); v5 = v2 - 10; v2 += 20; insertHashMap(v7, v5, v4); } while ( v2 != (const char *)v3 ); } return v7[0]; }
func0: ENDBR64 PUSH R12 PUSH RBP MOVSXD RBP,ESI PUSH RBX MOV RBX,RDI MOV EDI,0xa0 SUB RSP,0x20 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x18],RAX MOV RAX,0xa00000000 MOV qword ptr [RSP + 0x8],RAX CALL 0x00101110 MOV qword ptr [RSP],RAX TEST EBP,EBP JLE 0x0010170e LEA RAX,[RBP + RBP*0x4] ADD RBX,0xa MOV RBP,RSP LEA R12,[RBX + RAX*0x4] NOP dword ptr [RAX] LAB_001016e8: MOV RDI,RBX MOV EDX,0xa XOR ESI,ESI CALL 0x00101100 LEA RSI,[RBX + -0xa] MOV RDI,RBP ADD RBX,0x14 MOV EDX,EAX CALL 0x00101560 CMP RBX,R12 JNZ 0x001016e8 LAB_0010170e: MOV RAX,qword ptr [RSP] MOV RDX,qword ptr [RSP + 0x8] MOV RCX,qword ptr [RSP + 0x18] SUB RCX,qword ptr FS:[0x28] JNZ 0x00101730 ADD RSP,0x20 POP RBX POP RBP POP R12 RET LAB_00101730: CALL 0x001010d0
void * func0(long param_1,int param_2) { char *pcVar1; char *pcVar2; ulong uVar3; char *__nptr; long in_FS_OFFSET; void *local_38; int8 local_30; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); local_30 = 0xa00000000; local_38 = malloc(0xa0); if (0 < param_2) { __nptr = (char *)(param_1 + 10); pcVar2 = __nptr + (long)param_2 * 0x14; do { uVar3 = strtol(__nptr,(char **)0x0,10); pcVar1 = __nptr + -10; __nptr = __nptr + 0x14; insertHashMap(&local_38,pcVar1,uVar3 & 0xffffffff); } while (__nptr != pcVar2); } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return local_38; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,592
func0
#include <stdio.h> #include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(char* str1) { char stack[100]; // Assuming maximum length of input string is 100 int top = -1; for (int i = 0; i < strlen(str1); i++) { char parenthese = str1[i]; if (parenthese == '(' || parenthese == '{' || parenthese == '[') { stack[++top] = parenthese; } else if (top == -1) { return false; } else { char popped = stack[top--]; if ((parenthese == ')' && popped != '(') || (parenthese == '}' && popped != '{') || (parenthese == ']' && popped != '[')) { return false; } } } return top == -1; }
int main() { assert(func0("(){}[]") == true); assert(func0("()[{)}") == false); assert(func0("()") == true); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp push %rbx sub $0x98,%rsp mov %rdi,-0x98(%rbp) mov %fs:0x28,%rax mov %rax,-0x18(%rbp) xor %eax,%eax movl $0xffffffff,-0x88(%rbp) movl $0x0,-0x84(%rbp) jmpq 128e <func0+0x105> mov -0x84(%rbp),%eax movslq %eax,%rdx mov -0x98(%rbp),%rax add %rdx,%rax movzbl (%rax),%eax mov %al,-0x8a(%rbp) cmpb $0x28,-0x8a(%rbp) je 11ff <func0+0x76> cmpb $0x7b,-0x8a(%rbp) je 11ff <func0+0x76> cmpb $0x5b,-0x8a(%rbp) jne 121b <func0+0x92> addl $0x1,-0x88(%rbp) mov -0x88(%rbp),%eax cltq movzbl -0x8a(%rbp),%edx mov %dl,-0x80(%rbp,%rax,1) jmp 1287 <func0+0xfe> cmpl $0xffffffff,-0x88(%rbp) jne 122e <func0+0xa5> mov $0x0,%eax jmpq 12b9 <func0+0x130> mov -0x88(%rbp),%eax lea -0x1(%rax),%edx mov %edx,-0x88(%rbp) cltq movzbl -0x80(%rbp,%rax,1),%eax mov %al,-0x89(%rbp) cmpb $0x29,-0x8a(%rbp) jne 125c <func0+0xd3> cmpb $0x28,-0x89(%rbp) jne 1280 <func0+0xf7> cmpb $0x7d,-0x8a(%rbp) jne 126e <func0+0xe5> cmpb $0x7b,-0x89(%rbp) jne 1280 <func0+0xf7> cmpb $0x5d,-0x8a(%rbp) jne 1287 <func0+0xfe> cmpb $0x5b,-0x89(%rbp) je 1287 <func0+0xfe> mov $0x0,%eax jmp 12b9 <func0+0x130> addl $0x1,-0x84(%rbp) mov -0x84(%rbp),%eax movslq %eax,%rbx mov -0x98(%rbp),%rax mov %rax,%rdi callq 1070 <strlen@plt> cmp %rax,%rbx jb 11c8 <func0+0x3f> cmpl $0xffffffff,-0x88(%rbp) sete %al mov -0x18(%rbp),%rcx xor %fs:0x28,%rcx je 12cd <func0+0x144> callq 1080 <__stack_chk_fail@plt> add $0x98,%rsp pop %rbx pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp push rbx sub rsp, 98h mov [rbp+s], rdi mov rax, fs:28h mov [rbp+var_18], rax xor eax, eax mov [rbp+var_88], 0FFFFFFFFh mov [rbp+var_84], 0 jmp loc_128E loc_11C8: mov eax, [rbp+var_84] movsxd rdx, eax mov rax, [rbp+s] add rax, rdx movzx eax, byte ptr [rax] mov [rbp+var_8A], al cmp [rbp+var_8A], 28h ; '(' jz short loc_11FF cmp [rbp+var_8A], 7Bh ; '{' jz short loc_11FF cmp [rbp+var_8A], 5Bh ; '[' jnz short loc_121B loc_11FF: add [rbp+var_88], 1 mov eax, [rbp+var_88] cdqe movzx edx, [rbp+var_8A] mov [rbp+rax+var_80], dl jmp short loc_1287 loc_121B: cmp [rbp+var_88], 0FFFFFFFFh jnz short loc_122E mov eax, 0 jmp loc_12B9 loc_122E: mov eax, [rbp+var_88] lea edx, [rax-1] mov [rbp+var_88], edx cdqe movzx eax, [rbp+rax+var_80] mov [rbp+var_89], al cmp [rbp+var_8A], 29h ; ')' jnz short loc_125C cmp [rbp+var_89], 28h ; '(' jnz short loc_1280 loc_125C: cmp [rbp+var_8A], 7Dh ; '}' jnz short loc_126E cmp [rbp+var_89], 7Bh ; '{' jnz short loc_1280 loc_126E: cmp [rbp+var_8A], 5Dh ; ']' jnz short loc_1287 cmp [rbp+var_89], 5Bh ; '[' jz short loc_1287 loc_1280: mov eax, 0 jmp short loc_12B9 loc_1287: add [rbp+var_84], 1 loc_128E: mov eax, [rbp+var_84] movsxd rbx, eax mov rax, [rbp+s] mov rdi, rax; s call _strlen cmp rbx, rax jb loc_11C8 cmp [rbp+var_88], 0FFFFFFFFh setz al loc_12B9: mov rdx, [rbp+var_18] sub rdx, fs:28h jz short loc_12CD call ___stack_chk_fail loc_12CD: mov rbx, [rbp+var_8] leave retn
bool func0(const char *a1) { int v2; // eax char v3; // [rsp+16h] [rbp-8Ah] char v4; // [rsp+17h] [rbp-89h] int v5; // [rsp+18h] [rbp-88h] int i; // [rsp+1Ch] [rbp-84h] _BYTE v7[104]; // [rsp+20h] [rbp-80h] unsigned long long v8; // [rsp+88h] [rbp-18h] v8 = __readfsqword(0x28u); v5 = -1; for ( i = 0; i < strlen(a1); ++i ) { v3 = a1[i]; if ( v3 == 40 || v3 == 123 || v3 == 91 ) { v7[++v5] = v3; } else { if ( v5 == -1 ) return 0; v2 = v5--; v4 = v7[v2]; if ( v3 == 41 && v4 != 40 || v3 == 125 && v4 != 123 || v3 == 93 && v4 != 91 ) return 0; } } return v5 == -1; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP PUSH RBX SUB RSP,0x98 MOV qword ptr [RBP + -0x98],RDI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x18],RAX XOR EAX,EAX MOV dword ptr [RBP + -0x88],0xffffffff MOV dword ptr [RBP + -0x84],0x0 JMP 0x0010128e LAB_001011c8: MOV EAX,dword ptr [RBP + -0x84] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x98] ADD RAX,RDX MOVZX EAX,byte ptr [RAX] MOV byte ptr [RBP + -0x8a],AL CMP byte ptr [RBP + -0x8a],0x28 JZ 0x001011ff CMP byte ptr [RBP + -0x8a],0x7b JZ 0x001011ff CMP byte ptr [RBP + -0x8a],0x5b JNZ 0x0010121b LAB_001011ff: ADD dword ptr [RBP + -0x88],0x1 MOV EAX,dword ptr [RBP + -0x88] CDQE MOVZX EDX,byte ptr [RBP + -0x8a] MOV byte ptr [RBP + RAX*0x1 + -0x80],DL JMP 0x00101287 LAB_0010121b: CMP dword ptr [RBP + -0x88],-0x1 JNZ 0x0010122e MOV EAX,0x0 JMP 0x001012b9 LAB_0010122e: MOV EAX,dword ptr [RBP + -0x88] LEA EDX,[RAX + -0x1] MOV dword ptr [RBP + -0x88],EDX CDQE MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x80] MOV byte ptr [RBP + -0x89],AL CMP byte ptr [RBP + -0x8a],0x29 JNZ 0x0010125c CMP byte ptr [RBP + -0x89],0x28 JNZ 0x00101280 LAB_0010125c: CMP byte ptr [RBP + -0x8a],0x7d JNZ 0x0010126e CMP byte ptr [RBP + -0x89],0x7b JNZ 0x00101280 LAB_0010126e: CMP byte ptr [RBP + -0x8a],0x5d JNZ 0x00101287 CMP byte ptr [RBP + -0x89],0x5b JZ 0x00101287 LAB_00101280: MOV EAX,0x0 JMP 0x001012b9 LAB_00101287: ADD dword ptr [RBP + -0x84],0x1 LAB_0010128e: MOV EAX,dword ptr [RBP + -0x84] MOVSXD RBX,EAX MOV RAX,qword ptr [RBP + -0x98] MOV RDI,RAX CALL 0x00101070 CMP RBX,RAX JC 0x001011c8 CMP dword ptr [RBP + -0x88],-0x1 SETZ AL LAB_001012b9: MOV RDX,qword ptr [RBP + -0x18] SUB RDX,qword ptr FS:[0x28] JZ 0x001012cd CALL 0x00101080 LAB_001012cd: MOV RBX,qword ptr [RBP + -0x8] LEAVE RET
bool func0(char *param_1) { int iVar1; char cVar2; char cVar3; size_t sVar4; long in_FS_OFFSET; bool bVar5; int local_90; int local_8c; char acStack_88 [104]; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); local_90 = -1; local_8c = 0; do { sVar4 = strlen(param_1); if (sVar4 <= (ulong)(long)local_8c) { bVar5 = local_90 == -1; LAB_001012b9: if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return bVar5; } cVar2 = param_1[local_8c]; if (((cVar2 == '(') || (cVar2 == '{')) || (cVar2 == '[')) { acStack_88[local_90 + 1] = cVar2; local_90 = local_90 + 1; } else { if (local_90 == -1) { bVar5 = false; goto LAB_001012b9; } iVar1 = local_90 + -1; cVar3 = acStack_88[local_90]; if ((((cVar2 == ')') && (cVar3 != '(')) || ((cVar2 == '}' && (cVar3 != '{')))) || ((local_90 = iVar1, cVar2 == ']' && (cVar3 != '[')))) { bVar5 = false; goto LAB_001012b9; } } local_8c = local_8c + 1; } while( true ); }
4,593
func0
#include <stdio.h> #include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(char* str1) { char stack[100]; // Assuming maximum length of input string is 100 int top = -1; for (int i = 0; i < strlen(str1); i++) { char parenthese = str1[i]; if (parenthese == '(' || parenthese == '{' || parenthese == '[') { stack[++top] = parenthese; } else if (top == -1) { return false; } else { char popped = stack[top--]; if ((parenthese == ')' && popped != '(') || (parenthese == '}' && popped != '{') || (parenthese == ']' && popped != '[')) { return false; } } } return top == -1; }
int main() { assert(func0("(){}[]") == true); assert(func0("()[{)}") == false); assert(func0("()") == true); return 0; }
O1
c
func0: endbr64 push %rbx sub $0x70,%rsp mov %rdi,%r9 mov %fs:0x28,%rax mov %rax,0x68(%rsp) xor %eax,%eax mov $0x0,%esi mov $0xffffffff,%r8d mov $0xffffffffffffffff,%r10 jmp 11e8 <func0+0x7f> cmp $0xffffffff,%r8d je 122b <func0+0xc2> lea -0x1(%r8),%ebx movslq %r8d,%r8 movzbl (%rsp,%r8,1),%r8d cmp $0x29,%cl sete %dil cmp $0x28,%r8b setne %r11b and %r11b,%dil jne 122b <func0+0xc2> cmp $0x7d,%cl sete %dl cmp $0x7b,%r8b setne %r11b and %r11b,%dl jne 1243 <func0+0xda> cmp $0x5d,%cl jne 11e1 <func0+0x78> cmp $0x5b,%r8b jne 122b <func0+0xc2> mov %ebx,%r8d add $0x1,%rsi mov %r10,%rcx mov %r9,%rdi repnz scas %es:(%rdi),%al not %rcx sub $0x1,%rcx cmp %rsi,%rcx jbe 1224 <func0+0xbb> movzbl (%r9,%rsi,1),%ecx mov %ecx,%edx and $0xffffffdf,%edx cmp $0x5b,%dl sete %dl cmp $0x28,%cl sete %dil or %dil,%dl je 1199 <func0+0x30> add $0x1,%r8d movslq %r8d,%rdx mov %cl,(%rsp,%rdx,1) jmp 11e4 <func0+0x7b> cmp $0xffffffff,%r8d sete %dl mov 0x68(%rsp),%rax xor %fs:0x28,%rax jne 1247 <func0+0xde> mov %edx,%eax add $0x70,%rsp pop %rbx retq mov %edi,%edx jmp 122b <func0+0xc2> callq 1060 <__stack_chk_fail@plt>
func0: endbr64 push r12 push rbp push rbx sub rsp, 70h mov rbp, rdi mov rax, fs:28h mov [rsp+88h+var_20], rax xor eax, eax mov ebx, 0 mov r12d, 0FFFFFFFFh jmp short loc_1200 loc_11B5: cmp r12d, 0FFFFFFFFh jz short loc_1239 lea r8d, [r12-1] movsxd r12, r12d movzx esi, [rsp+r12+88h+var_88] cmp dl, 29h ; ')' setz cl cmp sil, 28h ; '(' setnz dil and cl, dil jnz short loc_1239 cmp dl, 7Dh ; '}' setz al cmp sil, 7Bh ; '{' setnz dil and al, dil jnz short loc_1252 cmp dl, 5Dh ; ']' jnz short loc_11F9 cmp sil, 5Bh ; '[' jnz short loc_1239 loc_11F9: mov r12d, r8d loc_11FC: add rbx, 1 loc_1200: mov rdi, rbp call _strlen cmp rax, rbx jbe short loc_1232 movzx edx, byte ptr [rbp+rbx+0] mov eax, edx and eax, 0FFFFFFDFh cmp al, 5Bh ; '[' setz al cmp dl, 28h ; '(' setz cl or al, cl jz short loc_11B5 add r12d, 1 movsxd rax, r12d mov [rsp+rax+88h+var_88], dl jmp short loc_11FC loc_1232: cmp r12d, 0FFFFFFFFh setz al loc_1239: mov rdx, [rsp+88h+var_20] sub rdx, fs:28h jnz short loc_1256 add rsp, 70h pop rbx pop rbp pop r12 retn loc_1252: mov eax, ecx jmp short loc_1239 loc_1256: call ___stack_chk_fail
bool func0(long long a1) { unsigned long long v1; // rbx int v2; // r12d char v3; // si bool result; // al char v5; // dl _BYTE v6[104]; // [rsp+0h] [rbp-88h] unsigned long long v7; // [rsp+68h] [rbp-20h] v7 = __readfsqword(0x28u); v1 = 0LL; v2 = -1; while ( 1 ) { if ( strlen(a1) <= v1 ) return v2 == -1; v5 = *(_BYTE *)(a1 + v1); result = v5 == 40 || (v5 & 0xDF) == 91; if ( result ) { v6[++v2] = v5; goto LABEL_8; } if ( v2 == -1 ) return result; v3 = v6[v2]; if ( v3 != 40 && v5 == 41 ) return result; result = v3 != 123 && v5 == 125; if ( result ) return v3 != 40 && v5 == 41; if ( v5 == 93 && v3 != 91 ) return result; --v2; LABEL_8: ++v1; } }
func0: ENDBR64 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x70 MOV RBP,RDI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x68],RAX XOR EAX,EAX MOV EBX,0x0 MOV R12D,0xffffffff JMP 0x00101200 LAB_001011b5: CMP R12D,-0x1 JZ 0x00101239 LEA R8D,[R12 + -0x1] MOVSXD R12,R12D MOVZX ESI,byte ptr [RSP + R12*0x1] CMP DL,0x29 SETZ CL CMP SIL,0x28 SETNZ DIL AND CL,DIL JNZ 0x00101239 CMP DL,0x7d SETZ AL CMP SIL,0x7b SETNZ DIL AND AL,DIL JNZ 0x00101252 CMP DL,0x5d JNZ 0x001011f9 CMP SIL,0x5b JNZ 0x00101239 LAB_001011f9: MOV R12D,R8D LAB_001011fc: ADD RBX,0x1 LAB_00101200: MOV RDI,RBP CALL 0x00101070 CMP RAX,RBX JBE 0x00101232 MOVZX EDX,byte ptr [RBP + RBX*0x1] MOV EAX,EDX AND EAX,0xffffffdf CMP AL,0x5b SETZ AL CMP DL,0x28 SETZ CL OR AL,CL JZ 0x001011b5 ADD R12D,0x1 MOVSXD RAX,R12D MOV byte ptr [RSP + RAX*0x1],DL JMP 0x001011fc LAB_00101232: CMP R12D,-0x1 SETZ AL LAB_00101239: MOV RDX,qword ptr [RSP + 0x68] SUB RDX,qword ptr FS:[0x28] JNZ 0x00101256 ADD RSP,0x70 POP RBX POP RBP POP R12 RET LAB_00101252: MOV EAX,ECX JMP 0x00101239 LAB_00101256: CALL 0x00101080
bool func0(char *param_1) { byte bVar1; byte bVar2; bool bVar3; bool bVar4; size_t sVar5; ulong uVar6; int iVar7; int iVar8; long in_FS_OFFSET; bool bVar9; byte local_88 [104]; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); iVar8 = -1; for (uVar6 = 0; sVar5 = strlen(param_1), uVar6 < sVar5; uVar6 = uVar6 + 1) { bVar2 = param_1[uVar6]; bVar9 = (bVar2 & 0xdf) == 0x5b; bVar4 = bVar9 || bVar2 == 0x28; if (bVar9 || bVar2 == 0x28) { local_88[iVar8 + 1] = bVar2; iVar8 = iVar8 + 1; } else { if (iVar8 == -1) goto LAB_00101239; iVar7 = iVar8 + -1; bVar1 = local_88[iVar8]; bVar9 = bVar2 == 0x29 && bVar1 != 0x28; if (((bVar9) || (bVar3 = bVar2 == 0x7d && bVar1 != 0x7b, bVar4 = bVar9, bVar3)) || ((iVar8 = iVar7, bVar2 == 0x5d && (bVar4 = bVar3, bVar1 != 0x5b)))) goto LAB_00101239; } } bVar4 = iVar8 == -1; LAB_00101239: if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return bVar4; }
4,594
func0
#include <stdio.h> #include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(char* str1) { char stack[100]; // Assuming maximum length of input string is 100 int top = -1; for (int i = 0; i < strlen(str1); i++) { char parenthese = str1[i]; if (parenthese == '(' || parenthese == '{' || parenthese == '[') { stack[++top] = parenthese; } else if (top == -1) { return false; } else { char popped = stack[top--]; if ((parenthese == ')' && popped != '(') || (parenthese == '}' && popped != '{') || (parenthese == ']' && popped != '[')) { return false; } } } return top == -1; }
int main() { assert(func0("(){}[]") == true); assert(func0("()[{)}") == false); assert(func0("()") == true); return 0; }
O2
c
func0: endbr64 push %rbx mov %rdi,%rbx sub $0x70,%rsp mov %fs:0x28,%rax mov %rax,0x68(%rsp) xor %eax,%eax callq 1070 <strlen@plt> xor %ecx,%ecx mov $0xffffffff,%esi mov %rax,%rdi jmp 126e <func0+0x3e> nopl (%rax) add $0x1,%esi movslq %esi,%r8 mov %dl,(%rsp,%r8,1) add $0x1,%rcx cmp %rdi,%rcx jae 1300 <func0+0xd0> movzbl (%rbx,%rcx,1),%edx mov %edx,%r8d and $0xffffffdf,%r8d cmp $0x5b,%r8b sete %al cmp $0x28,%dl sete %r8b or %r8b,%al jne 1260 <func0+0x30> cmp $0xffffffff,%esi je 12e0 <func0+0xb0> lea -0x1(%rsi),%r10d movslq %esi,%rsi cmp $0x29,%dl movzbl (%rsp,%rsi,1),%esi sete %r9b cmp $0x28,%sil setne %r8b test %r8b,%r9b jne 12e0 <func0+0xb0> cmp $0x7d,%dl sete %al cmp $0x7b,%sil setne %r8b and %r8b,%al jne 12dc <func0+0xac> cmp $0x5d,%dl jne 12d7 <func0+0xa7> cmp $0x5b,%sil jne 12e0 <func0+0xb0> mov %r10d,%esi jmp 126a <func0+0x3a> xor %eax,%eax xchg %ax,%ax mov 0x68(%rsp),%rbx xor %fs:0x28,%rbx jne 1308 <func0+0xd8> add $0x70,%rsp pop %rbx retq nopw %cs:0x0(%rax,%rax,1) cmp $0xffffffff,%esi sete %al jmp 12e0 <func0+0xb0> callq 1080 <__stack_chk_fail@plt> nopl (%rax)
func0: endbr64 push r12 mov r12, rdi push rbp mov ebp, 0FFFFFFFFh push rbx xor ebx, ebx sub rsp, 70h mov rax, fs:28h mov [rsp+88h+var_20], rax xor eax, eax jmp short loc_126D loc_1260: add ebp, 1 movsxd rax, ebp mov [rsp+rax+88h+var_88], dl loc_1269: add rbx, 1 loc_126D: mov rdi, r12 call _strlen cmp rbx, rax jnb short loc_12E0 movzx edx, byte ptr [r12+rbx] mov eax, edx and eax, 0FFFFFFDFh cmp al, 5Bh ; '[' setz al cmp dl, 28h ; '(' setz cl or al, cl jnz short loc_1260 cmp ebp, 0FFFFFFFFh jz short loc_12E6 lea r8d, [rbp-1] movsxd rbp, ebp cmp dl, 29h ; ')' movzx ecx, [rsp+rbp+88h+var_88] setz dil cmp cl, 28h ; '(' setnz sil test dil, sil jnz short loc_12E6 cmp dl, 7Dh ; '}' setz al cmp cl, 7Bh ; '{' setnz sil and al, sil jnz short loc_12FF cmp dl, 5Dh ; ']' jnz short loc_12D2 cmp cl, 5Bh ; '[' jnz short loc_12E6 loc_12D2: mov ebp, r8d jmp short loc_1269 loc_12E0: cmp ebp, 0FFFFFFFFh setz al loc_12E6: mov rdx, [rsp+88h+var_20] sub rdx, fs:28h jnz short loc_1303 add rsp, 70h pop rbx pop rbp pop r12 retn loc_12FF: xor eax, eax jmp short loc_12E6 loc_1303: call ___stack_chk_fail
bool func0(long long a1) { int v1; // ebp unsigned long long v2; // rbx char v3; // dl bool result; // al char v5; // cl _BYTE v6[104]; // [rsp+0h] [rbp-88h] unsigned long long v7; // [rsp+68h] [rbp-20h] v1 = -1; v2 = 0LL; v7 = __readfsqword(0x28u); while ( 1 ) { if ( v2 >= strlen(a1) ) return v1 == -1; v3 = *(_BYTE *)(a1 + v2); result = v3 == 40 || (v3 & 0xDF) == 91; if ( result ) { v6[++v1] = v3; goto LABEL_3; } if ( v1 == -1 ) return result; v5 = v6[v1]; if ( v5 != 40 && v3 == 41 ) return result; result = v5 != 123 && v3 == 125; if ( result ) return 0; if ( v3 == 93 && v5 != 91 ) return result; --v1; LABEL_3: ++v2; } }
func0: ENDBR64 PUSH R12 MOV R12,RDI PUSH RBP MOV EBP,0xffffffff PUSH RBX XOR EBX,EBX SUB RSP,0x70 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x68],RAX XOR EAX,EAX JMP 0x0010126d LAB_00101260: ADD EBP,0x1 MOVSXD RAX,EBP MOV byte ptr [RSP + RAX*0x1],DL LAB_00101269: ADD RBX,0x1 LAB_0010126d: MOV RDI,R12 CALL 0x00101070 CMP RBX,RAX JNC 0x001012e0 MOVZX EDX,byte ptr [R12 + RBX*0x1] MOV EAX,EDX AND EAX,0xffffffdf CMP AL,0x5b SETZ AL CMP DL,0x28 SETZ CL OR AL,CL JNZ 0x00101260 CMP EBP,-0x1 JZ 0x001012e6 LEA R8D,[RBP + -0x1] MOVSXD RBP,EBP CMP DL,0x29 MOVZX ECX,byte ptr [RSP + RBP*0x1] SETZ DIL CMP CL,0x28 SETNZ SIL TEST DIL,SIL JNZ 0x001012e6 CMP DL,0x7d SETZ AL CMP CL,0x7b SETNZ SIL AND AL,SIL JNZ 0x001012ff CMP DL,0x5d JNZ 0x001012d2 CMP CL,0x5b JNZ 0x001012e6 LAB_001012d2: MOV EBP,R8D JMP 0x00101269 LAB_001012e0: CMP EBP,-0x1 SETZ AL LAB_001012e6: MOV RDX,qword ptr [RSP + 0x68] SUB RDX,qword ptr FS:[0x28] JNZ 0x00101303 ADD RSP,0x70 POP RBX POP RBP POP R12 RET LAB_001012ff: XOR EAX,EAX JMP 0x001012e6 LAB_00101303: CALL 0x00101080
bool func0(char *param_1) { byte bVar1; byte bVar2; bool bVar3; size_t sVar4; ulong uVar5; int iVar6; int iVar7; long in_FS_OFFSET; byte local_88 [104]; long local_20; uVar5 = 0; local_20 = *(long *)(in_FS_OFFSET + 0x28); iVar7 = -1; do { sVar4 = strlen(param_1); if (sVar4 <= uVar5) { bVar3 = iVar7 == -1; LAB_001012e6: if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return bVar3; } bVar1 = param_1[uVar5]; bVar3 = (bVar1 & 0xdf) == 0x5b || bVar1 == 0x28; if (bVar3) { iVar6 = iVar7 + 1; local_88[iVar6] = bVar1; } else { if (iVar7 == -1) goto LAB_001012e6; iVar6 = iVar7 + -1; bVar2 = local_88[iVar7]; if (bVar1 == 0x29 && bVar2 != 0x28) goto LAB_001012e6; bVar3 = bVar1 == 0x7d && bVar2 != 0x7b; if (bVar3) { bVar3 = false; goto LAB_001012e6; } if ((bVar1 == 0x5d) && (bVar2 != 0x5b)) goto LAB_001012e6; } uVar5 = uVar5 + 1; iVar7 = iVar6; } while( true ); }
4,595
func0
#include <stdio.h> #include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(char* str1) { char stack[100]; // Assuming maximum length of input string is 100 int top = -1; for (int i = 0; i < strlen(str1); i++) { char parenthese = str1[i]; if (parenthese == '(' || parenthese == '{' || parenthese == '[') { stack[++top] = parenthese; } else if (top == -1) { return false; } else { char popped = stack[top--]; if ((parenthese == ')' && popped != '(') || (parenthese == '}' && popped != '{') || (parenthese == ']' && popped != '[')) { return false; } } } return top == -1; }
int main() { assert(func0("(){}[]") == true); assert(func0("()[{)}") == false); assert(func0("()") == true); return 0; }
O3
c
func0: endbr64 push %rbx mov %rdi,%rbx sub $0x70,%rsp mov %fs:0x28,%rax mov %rax,0x68(%rsp) xor %eax,%eax callq 1070 <strlen@plt> xor %ecx,%ecx mov $0xffffffff,%esi mov %rax,%rdi jmp 126e <func0+0x3e> nopl (%rax) add $0x1,%esi movslq %esi,%r8 mov %dl,(%rsp,%r8,1) add $0x1,%rcx cmp %rdi,%rcx jae 1300 <func0+0xd0> movzbl (%rbx,%rcx,1),%edx mov %edx,%r8d and $0xffffffdf,%r8d cmp $0x5b,%r8b sete %al cmp $0x28,%dl sete %r8b or %r8b,%al jne 1260 <func0+0x30> cmp $0xffffffff,%esi je 12e0 <func0+0xb0> lea -0x1(%rsi),%r10d movslq %esi,%rsi cmp $0x29,%dl movzbl (%rsp,%rsi,1),%esi sete %r9b cmp $0x28,%sil setne %r8b test %r8b,%r9b jne 12e0 <func0+0xb0> cmp $0x7d,%dl sete %al cmp $0x7b,%sil setne %r8b and %r8b,%al jne 12dc <func0+0xac> cmp $0x5d,%dl jne 12d7 <func0+0xa7> cmp $0x5b,%sil jne 12e0 <func0+0xb0> mov %r10d,%esi jmp 126a <func0+0x3a> xor %eax,%eax xchg %ax,%ax mov 0x68(%rsp),%rbx xor %fs:0x28,%rbx jne 1308 <func0+0xd8> add $0x70,%rsp pop %rbx retq nopw %cs:0x0(%rax,%rax,1) cmp $0xffffffff,%esi sete %al jmp 12e0 <func0+0xb0> callq 1080 <__stack_chk_fail@plt> nopl (%rax)
func0: endbr64 push r12 mov r12d, 0FFFFFFFFh push rbp mov rbp, rdi push rbx xor ebx, ebx sub rsp, 70h mov rax, fs:28h mov [rsp+88h+var_20], rax xor eax, eax jmp short loc_126E loc_1260: add r12d, 1 movsxd rax, r12d mov [rsp+rax+88h+var_88], dl loc_126A: add rbx, 1 loc_126E: mov rdi, rbp; s call _strlen cmp rbx, rax jnb short loc_12E0 movzx edx, byte ptr [rbp+rbx+0] mov eax, edx and eax, 0FFFFFFDFh cmp al, 5Bh ; '[' setz al cmp dl, 28h ; '(' setz cl or al, cl jnz short loc_1260 cmp r12d, 0FFFFFFFFh jz short loc_12E7 lea r8d, [r12-1] movsxd r12, r12d cmp dl, 29h ; ')' movzx ecx, [rsp+r12+88h+var_88] setz dil cmp cl, 28h ; '(' setnz sil test dil, sil jnz short loc_12E7 cmp dl, 7Dh ; '}' setz al cmp cl, 7Bh ; '{' setnz sil and al, sil jnz short loc_1300 cmp dl, 5Dh ; ']' jnz short loc_12D6 cmp cl, 5Bh ; '[' jnz short loc_12E7 loc_12D6: mov r12d, r8d jmp short loc_126A loc_12E0: cmp r12d, 0FFFFFFFFh setz al loc_12E7: mov rdx, [rsp+88h+var_20] sub rdx, fs:28h jnz short loc_1304 add rsp, 70h pop rbx pop rbp pop r12 retn loc_1300: xor eax, eax jmp short loc_12E7 loc_1304: call ___stack_chk_fail
bool func0(char *s) { int v1; // r12d size_t v2; // rbx char v3; // dl bool result; // al char v5; // cl _BYTE v6[104]; // [rsp+0h] [rbp-88h] unsigned long long v7; // [rsp+68h] [rbp-20h] v1 = -1; v2 = 0LL; v7 = __readfsqword(0x28u); while ( 1 ) { if ( v2 >= strlen(s) ) return v1 == -1; v3 = s[v2]; result = v3 == 40 || (v3 & 0xDF) == 91; if ( result ) { v6[++v1] = v3; goto LABEL_3; } if ( v1 == -1 ) return result; v5 = v6[v1]; if ( v5 != 40 && v3 == 41 ) return result; result = v5 != 123 && v3 == 125; if ( result ) return 0; if ( v3 == 93 && v5 != 91 ) return result; --v1; LABEL_3: ++v2; } }
func0: ENDBR64 PUSH R12 MOV R12D,0xffffffff PUSH RBP MOV RBP,RDI PUSH RBX XOR EBX,EBX SUB RSP,0x70 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x68],RAX XOR EAX,EAX JMP 0x0010126e LAB_00101260: ADD R12D,0x1 MOVSXD RAX,R12D MOV byte ptr [RSP + RAX*0x1],DL LAB_0010126a: ADD RBX,0x1 LAB_0010126e: MOV RDI,RBP CALL 0x00101070 CMP RBX,RAX JNC 0x001012e0 MOVZX EDX,byte ptr [RBP + RBX*0x1] MOV EAX,EDX AND EAX,0xffffffdf CMP AL,0x5b SETZ AL CMP DL,0x28 SETZ CL OR AL,CL JNZ 0x00101260 CMP R12D,-0x1 JZ 0x001012e7 LEA R8D,[R12 + -0x1] MOVSXD R12,R12D CMP DL,0x29 MOVZX ECX,byte ptr [RSP + R12*0x1] SETZ DIL CMP CL,0x28 SETNZ SIL TEST DIL,SIL JNZ 0x001012e7 CMP DL,0x7d SETZ AL CMP CL,0x7b SETNZ SIL AND AL,SIL JNZ 0x00101300 CMP DL,0x5d JNZ 0x001012d6 CMP CL,0x5b JNZ 0x001012e7 LAB_001012d6: MOV R12D,R8D JMP 0x0010126a LAB_001012e0: CMP R12D,-0x1 SETZ AL LAB_001012e7: MOV RDX,qword ptr [RSP + 0x68] SUB RDX,qword ptr FS:[0x28] JNZ 0x00101304 ADD RSP,0x70 POP RBX POP RBP POP R12 RET LAB_00101300: XOR EAX,EAX JMP 0x001012e7 LAB_00101304: CALL 0x00101080
bool func0(char *param_1) { byte bVar1; byte bVar2; bool bVar3; size_t sVar4; ulong uVar5; int iVar6; int iVar7; long in_FS_OFFSET; byte local_88 [104]; long local_20; uVar5 = 0; local_20 = *(long *)(in_FS_OFFSET + 0x28); iVar7 = -1; do { sVar4 = strlen(param_1); if (sVar4 <= uVar5) { bVar3 = iVar7 == -1; LAB_001012e7: if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return bVar3; } bVar1 = param_1[uVar5]; bVar3 = (bVar1 & 0xdf) == 0x5b || bVar1 == 0x28; if (bVar3) { iVar6 = iVar7 + 1; local_88[iVar6] = bVar1; } else { if (iVar7 == -1) goto LAB_001012e7; iVar6 = iVar7 + -1; bVar2 = local_88[iVar7]; if (bVar1 == 0x29 && bVar2 != 0x28) goto LAB_001012e7; bVar3 = bVar1 == 0x7d && bVar2 != 0x7b; if (bVar3) { bVar3 = false; goto LAB_001012e7; } if ((bVar1 == 0x5d) && (bVar2 != 0x5b)) goto LAB_001012e7; } uVar5 = uVar5 + 1; iVar7 = iVar6; } while( true ); }
4,596
func0
#include <assert.h>
int func0(int a, int b, int c) { int perimeter = a + b + c; return perimeter; }
int main() { assert(func0(10, 20, 30) == 60); assert(func0(3, 4, 5) == 12); assert(func0(25, 35, 45) == 105); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %edi,-0x14(%rbp) mov %esi,-0x18(%rbp) mov %edx,-0x1c(%rbp) mov -0x14(%rbp),%edx mov -0x18(%rbp),%eax add %eax,%edx mov -0x1c(%rbp),%eax add %edx,%eax mov %eax,-0x4(%rbp) mov -0x4(%rbp),%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_14], edi mov [rbp+var_18], esi mov [rbp+var_1C], edx mov edx, [rbp+var_14] mov eax, [rbp+var_18] add edx, eax mov eax, [rbp+var_1C] add eax, edx mov [rbp+var_4], eax mov eax, [rbp+var_4] pop rbp retn
long long func0(int a1, int a2, int a3) { return (unsigned int)(a2 + a1 + a3); }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV dword ptr [RBP + -0x14],EDI MOV dword ptr [RBP + -0x18],ESI MOV dword ptr [RBP + -0x1c],EDX MOV EDX,dword ptr [RBP + -0x14] MOV EAX,dword ptr [RBP + -0x18] ADD EDX,EAX MOV EAX,dword ptr [RBP + -0x1c] ADD EAX,EDX MOV dword ptr [RBP + -0x4],EAX MOV EAX,dword ptr [RBP + -0x4] POP RBP RET
int func0(int param_1,int param_2,int param_3) { return param_3 + param_1 + param_2; }
4,597
func0
#include <assert.h>
int func0(int a, int b, int c) { int perimeter = a + b + c; return perimeter; }
int main() { assert(func0(10, 20, 30) == 60); assert(func0(3, 4, 5) == 12); assert(func0(25, 35, 45) == 105); return 0; }
O1
c
func0: endbr64 add %esi,%edi lea (%rdi,%rdx,1),%eax retq
func0: endbr64 add edi, esi lea eax, [rdi+rdx] retn
long long func0(int a1, int a2, int a3) { return (unsigned int)(a2 + a1 + a3); }
func0: ENDBR64 ADD EDI,ESI LEA EAX,[RDI + RDX*0x1] RET
int func0(int param_1,int param_2,int param_3) { return param_1 + param_2 + param_3; }
4,598
func0
#include <assert.h>
int func0(int a, int b, int c) { int perimeter = a + b + c; return perimeter; }
int main() { assert(func0(10, 20, 30) == 60); assert(func0(3, 4, 5) == 12); assert(func0(25, 35, 45) == 105); return 0; }
O2
c
func0: endbr64 add %esi,%edi lea (%rdi,%rdx,1),%eax retq nopw 0x0(%rax,%rax,1)
func0: endbr64 add edi, esi lea eax, [rdi+rdx] retn
long long func0(int a1, int a2, int a3) { return (unsigned int)(a2 + a1 + a3); }
func0: ENDBR64 ADD EDI,ESI LEA EAX,[RDI + RDX*0x1] RET
int func0(int param_1,int param_2,int param_3) { return param_1 + param_2 + param_3; }
4,599
func0
#include <assert.h>
int func0(int a, int b, int c) { int perimeter = a + b + c; return perimeter; }
int main() { assert(func0(10, 20, 30) == 60); assert(func0(3, 4, 5) == 12); assert(func0(25, 35, 45) == 105); return 0; }
O3
c
func0: endbr64 add %esi,%edi lea (%rdi,%rdx,1),%eax retq nopw 0x0(%rax,%rax,1)
func0: endbr64 add edi, esi lea eax, [rdi+rdx] retn
long long func0(int a1, int a2, int a3) { return (unsigned int)(a2 + a1 + a3); }
func0: ENDBR64 ADD EDI,ESI LEA EAX,[RDI + RDX*0x1] RET
int func0(int param_1,int param_2,int param_3) { return param_1 + param_2 + param_3; }
4,600
func0
#include <stdio.h> #include <assert.h>
int* func0(int L, int R) { static int result[2]; if (2 * L <= R) { result[0] = L; result[1] = 2 * L; return result; } else { return NULL; } }
int main() { int* res; res = func0(3, 8); assert(res[0] == 3 && res[1] == 6); res = func0(2, 6); assert(res[0] == 2 && res[1] == 4); res = func0(1, 3); assert(res[0] == 1 && res[1] == 2); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %edi,-0x4(%rbp) mov %esi,-0x8(%rbp) mov -0x4(%rbp),%eax add %eax,%eax cmp %eax,-0x8(%rbp) jl 117e <func0+0x35> mov -0x4(%rbp),%eax mov %eax,0x2eae(%rip) mov -0x4(%rbp),%eax add %eax,%eax mov %eax,0x2ea7(%rip) lea 0x2e9c(%rip),%rax jmp 1183 <func0+0x3a> mov $0x0,%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_4], edi mov [rbp+var_8], esi mov eax, [rbp+var_4] add eax, eax cmp [rbp+var_8], eax jl short loc_117E mov eax, [rbp+var_4] mov cs:result_1, eax mov eax, [rbp+var_4] add eax, eax mov cs:dword_401C, eax lea rax, result_1 jmp short loc_1183 loc_117E: mov eax, 0 loc_1183: pop rbp retn
int * func0(int a1, int a2) { if ( a2 < 2 * a1 ) return 0LL; result_1 = a1; dword_401C = 2 * a1; return &result_1; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV dword ptr [RBP + -0x4],EDI MOV dword ptr [RBP + -0x8],ESI MOV EAX,dword ptr [RBP + -0x4] ADD EAX,EAX CMP dword ptr [RBP + -0x8],EAX JL 0x0010117e MOV EAX,dword ptr [RBP + -0x4] MOV dword ptr [0x00104018],EAX MOV EAX,dword ptr [RBP + -0x4] ADD EAX,EAX MOV dword ptr [0x0010401c],EAX LEA RAX,[0x104018] JMP 0x00101183 LAB_0010117e: MOV EAX,0x0 LAB_00101183: POP RBP RET
int8 * func0(int param_1,int param_2) { int8 *puVar1; if (param_2 < param_1 * 2) { puVar1 = (int8 *)0x0; } else { result_1._4_4_ = param_1 * 2; puVar1 = &result_1; result_1._0_4_ = param_1; } return puVar1; }
4,601
func0
#include <stdio.h> #include <assert.h>
int* func0(int L, int R) { static int result[2]; if (2 * L <= R) { result[0] = L; result[1] = 2 * L; return result; } else { return NULL; } }
int main() { int* res; res = func0(3, 8); assert(res[0] == 3 && res[1] == 6); res = func0(2, 6); assert(res[0] == 2 && res[1] == 4); res = func0(1, 3); assert(res[0] == 1 && res[1] == 2); return 0; }
O1
c
func0: endbr64 lea (%rdi,%rdi,1),%edx mov $0x0,%eax cmp %esi,%edx jg 114c <func0+0x23> mov %edi,0x2ed9(%rip) mov %edx,0x2ed7(%rip) lea 0x2ecc(%rip),%rax retq
func0: endbr64 lea edx, [rdi+rdi] mov eax, 0 cmp edx, esi jg short locret_114C mov cs:result_1, edi mov cs:dword_401C, edx lea rax, result_1 locret_114C: retn
int * func0(int a1, int a2) { int *result; // rax result = 0LL; if ( 2 * a1 <= a2 ) { result_1 = a1; dword_401C = 2 * a1; return &result_1; } return result; }
func0: ENDBR64 LEA EDX,[RDI + RDI*0x1] MOV EAX,0x0 CMP EDX,ESI JG 0x0010114c MOV dword ptr [0x00104018],EDI MOV dword ptr [0x0010401c],EDX LEA RAX,[0x104018] LAB_0010114c: RET
int8 * func0(int param_1,int param_2) { int8 *puVar1; puVar1 = (int8 *)0x0; if (param_1 * 2 <= param_2) { puVar1 = &result_1; result_1._0_4_ = param_1; result_1._4_4_ = param_1 * 2; } return puVar1; }
4,602
func0
#include <stdio.h> #include <assert.h>
int* func0(int L, int R) { static int result[2]; if (2 * L <= R) { result[0] = L; result[1] = 2 * L; return result; } else { return NULL; } }
int main() { int* res; res = func0(3, 8); assert(res[0] == 3 && res[1] == 6); res = func0(2, 6); assert(res[0] == 2 && res[1] == 4); res = func0(1, 3); assert(res[0] == 1 && res[1] == 2); return 0; }
O2
c
func0: endbr64 lea (%rdi,%rdi,1),%edx xor %eax,%eax cmp %esi,%edx jg 1170 <func0+0x20> mov %edi,0x2eb5(%rip) lea 0x2eae(%rip),%rax mov %edx,0x2eac(%rip) retq nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax,%rax,1)
func0: endbr64 lea edx, [rdi+rdi] xor eax, eax cmp edx, esi jg short locret_1170 mov dword ptr cs:result_1, edi lea rax, result_1 mov dword ptr cs:result_1+4, edx locret_1170: retn
long long * func0(int a1, int a2) { long long *result; // rax result = 0LL; if ( 2 * a1 <= a2 ) { LODWORD(result_1) = a1; result = &result_1; HIDWORD(result_1) = 2 * a1; } return result; }
func0: ENDBR64 LEA EDX,[RDI + RDI*0x1] XOR EAX,EAX CMP EDX,ESI JG 0x00101170 MOV dword ptr [0x00104018],EDI LEA RAX,[0x104018] MOV dword ptr [0x0010401c],EDX LAB_00101170: RET
int8 * func0(int param_1,int param_2) { int8 *puVar1; puVar1 = (int8 *)0x0; if (param_1 * 2 <= param_2) { puVar1 = &result_1; result_1._0_4_ = param_1; result_1._4_4_ = param_1 * 2; } return puVar1; }
4,603
func0
#include <stdio.h> #include <assert.h>
int* func0(int L, int R) { static int result[2]; if (2 * L <= R) { result[0] = L; result[1] = 2 * L; return result; } else { return NULL; } }
int main() { int* res; res = func0(3, 8); assert(res[0] == 3 && res[1] == 6); res = func0(2, 6); assert(res[0] == 2 && res[1] == 4); res = func0(1, 3); assert(res[0] == 1 && res[1] == 2); return 0; }
O3
c
func0: endbr64 lea (%rdi,%rdi,1),%edx xor %eax,%eax cmp %esi,%edx jg 1170 <func0+0x20> mov %edi,0x2eb5(%rip) lea 0x2eae(%rip),%rax mov %edx,0x2eac(%rip) retq nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax,%rax,1)
func0: endbr64 lea edx, [rdi+rdi] xor eax, eax cmp edx, esi jg short locret_1170 mov dword ptr cs:result_1, edi lea rax, result_1 mov dword ptr cs:result_1+4, edx locret_1170: retn
long long * func0(int a1, int a2) { long long *result; // rax result = 0LL; if ( 2 * a1 <= a2 ) { LODWORD(result_1) = a1; result = &result_1; HIDWORD(result_1) = 2 * a1; } return result; }
func0: ENDBR64 LEA EDX,[RDI + RDI*0x1] XOR EAX,EAX CMP EDX,ESI JG 0x00101170 MOV dword ptr [0x00104018],EDI LEA RAX,[0x104018] MOV dword ptr [0x0010401c],EDX LAB_00101170: RET
int8 * func0(int param_1,int param_2) { int8 *puVar1; puVar1 = (int8 *)0x0; if (param_1 * 2 <= param_2) { puVar1 = &result_1; result_1._0_4_ = param_1; result_1._4_4_ = param_1 * 2; } return puVar1; }
4,604
func0
#include <stdio.h> #include <assert.h> #include <regex.h>
char* func0(char* patterns[], int pattern_n, char* text) { regex_t regex; int reti; for (int i = 0; i < pattern_n; i++) { reti = regcomp(&regex, patterns[i], 0); if (reti) { fprintf(stderr, "Could not compile regex\n"); return "Not Matched!"; } reti = regexec(&regex, text, 0, NULL, 0); if (!reti) { regfree(&regex); return "Matched!"; } regfree(&regex); } return "Not Matched!"; }
int main() { char* patterns1[1] = {"language"}; assert(func0(patterns1, 1, "python language") == "Matched!"); char* patterns2[1] = {"program"}; assert(func0(patterns2, 1, "python language") == "Not Matched!"); char* patterns3[1] = {"python"}; assert(func0(patterns3, 1, "programming language") == "Not Matched!"); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp add $0xffffffffffffff80,%rsp mov %rdi,-0x68(%rbp) mov %esi,-0x6c(%rbp) mov %rdx,-0x78(%rbp) mov %fs:0x28,%rax mov %rax,-0x8(%rbp) xor %eax,%eax movl $0x0,-0x58(%rbp) jmpq 12c6 <func0+0xdd> mov -0x58(%rbp),%eax cltq lea 0x0(,%rax,8),%rdx mov -0x68(%rbp),%rax add %rdx,%rax mov (%rax),%rcx lea -0x50(%rbp),%rax mov $0x0,%edx mov %rcx,%rsi mov %rax,%rdi callq 10d0 <regcomp@plt> mov %eax,-0x54(%rbp) cmpl $0x0,-0x54(%rbp) je 1278 <func0+0x8f> mov 0x2dca(%rip),%rax mov %rax,%rcx mov $0x18,%edx mov $0x1,%esi lea 0xd9e(%rip),%rdi callq 10f0 <fwrite@plt> lea 0xdab(%rip),%rax jmp 12d9 <func0+0xf0> mov -0x78(%rbp),%rsi lea -0x50(%rbp),%rax mov $0x0,%r8d mov $0x0,%ecx mov $0x0,%edx mov %rax,%rdi callq 10e0 <regexec@plt> mov %eax,-0x54(%rbp) cmpl $0x0,-0x54(%rbp) jne 12b6 <func0+0xcd> lea -0x50(%rbp),%rax mov %rax,%rdi callq 10a0 <regfree@plt> lea 0xd7a(%rip),%rax jmp 12d9 <func0+0xf0> lea -0x50(%rbp),%rax mov %rax,%rdi callq 10a0 <regfree@plt> addl $0x1,-0x58(%rbp) mov -0x58(%rbp),%eax cmp -0x6c(%rbp),%eax jl 121b <func0+0x32> lea 0xd48(%rip),%rax mov -0x8(%rbp),%rcx xor %fs:0x28,%rcx je 12ed <func0+0x104> callq 10b0 <__stack_chk_fail@plt> leaveq retq
func0: endbr64 push rbp mov rbp, rsp add rsp, 0FFFFFFFFFFFFFF80h mov [rbp+var_68], rdi mov [rbp+var_6C], esi mov [rbp+string], rdx mov rax, fs:28h mov [rbp+var_8], rax xor eax, eax mov [rbp+var_58], 0 jmp loc_12C9 loc_121B: mov eax, [rbp+var_58] cdqe lea rdx, ds:0[rax*8] mov rax, [rbp+var_68] add rax, rdx mov rcx, [rax] lea rax, [rbp+preg] mov edx, 0; cflags mov rsi, rcx; pattern mov rdi, rax; preg call _regcomp mov [rbp+var_54], eax cmp [rbp+var_54], 0 jz short loc_127B mov rax, cs:__bss_start mov rcx, rax; s mov edx, 18h; n mov esi, 1; size lea rax, aCouldNotCompil; "Could not compile regex\n" mov rdi, rax; ptr call _fwrite lea rax, aNotMatched; "Not Matched!" jmp short loc_12DC loc_127B: mov rsi, [rbp+string]; string lea rax, [rbp+preg] mov r8d, 0; eflags mov ecx, 0; pmatch mov edx, 0; nmatch mov rdi, rax; preg call _regexec mov [rbp+var_54], eax cmp [rbp+var_54], 0 jnz short loc_12B9 lea rax, [rbp+preg] mov rdi, rax; preg call _regfree lea rax, aMatched; "Matched!" jmp short loc_12DC loc_12B9: lea rax, [rbp+preg] mov rdi, rax; preg call _regfree add [rbp+var_58], 1 loc_12C9: mov eax, [rbp+var_58] cmp eax, [rbp+var_6C] jl loc_121B lea rax, aNotMatched; "Not Matched!" loc_12DC: mov rdx, [rbp+var_8] sub rdx, fs:28h jz short locret_12F0 call ___stack_chk_fail locret_12F0: leave retn
const char * func0(long long a1, int a2, const char *a3) { int i; // [rsp+28h] [rbp-58h] regex_t preg; // [rsp+30h] [rbp-50h] BYREF unsigned long long v7; // [rsp+78h] [rbp-8h] v7 = __readfsqword(0x28u); for ( i = 0; i < a2; ++i ) { if ( regcomp(&preg, *(const char **)(8LL * i + a1), 0) ) { fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start); return "Not Matched!"; } if ( !regexec(&preg, a3, 0LL, 0LL, 0) ) { regfree(&preg); return "Matched!"; } regfree(&preg); } return "Not Matched!"; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP ADD RSP,-0x80 MOV qword ptr [RBP + -0x68],RDI MOV dword ptr [RBP + -0x6c],ESI MOV qword ptr [RBP + -0x78],RDX MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x8],RAX XOR EAX,EAX MOV dword ptr [RBP + -0x58],0x0 JMP 0x001012c9 LAB_0010121b: MOV EAX,dword ptr [RBP + -0x58] CDQE LEA RDX,[RAX*0x8] MOV RAX,qword ptr [RBP + -0x68] ADD RAX,RDX MOV RCX,qword ptr [RAX] LEA RAX,[RBP + -0x50] MOV EDX,0x0 MOV RSI,RCX MOV RDI,RAX CALL 0x001010d0 MOV dword ptr [RBP + -0x54],EAX CMP dword ptr [RBP + -0x54],0x0 JZ 0x0010127b MOV RAX,qword ptr [0x00104020] MOV RCX,RAX MOV EDX,0x18 MOV ESI,0x1 LEA RAX,[0x102008] MOV RDI,RAX CALL 0x001010f0 LEA RAX,[0x102021] JMP 0x001012dc LAB_0010127b: MOV RSI,qword ptr [RBP + -0x78] LEA RAX,[RBP + -0x50] MOV R8D,0x0 MOV ECX,0x0 MOV EDX,0x0 MOV RDI,RAX CALL 0x001010e0 MOV dword ptr [RBP + -0x54],EAX CMP dword ptr [RBP + -0x54],0x0 JNZ 0x001012b9 LEA RAX,[RBP + -0x50] MOV RDI,RAX CALL 0x001010a0 LEA RAX,[0x10202e] JMP 0x001012dc LAB_001012b9: LEA RAX,[RBP + -0x50] MOV RDI,RAX CALL 0x001010a0 ADD dword ptr [RBP + -0x58],0x1 LAB_001012c9: MOV EAX,dword ptr [RBP + -0x58] CMP EAX,dword ptr [RBP + -0x6c] JL 0x0010121b LEA RAX,[0x102021] LAB_001012dc: MOV RDX,qword ptr [RBP + -0x8] SUB RDX,qword ptr FS:[0x28] JZ 0x001012f0 CALL 0x001010b0 LAB_001012f0: LEAVE RET
char * func0(long param_1,int param_2,char *param_3) { int iVar1; char *pcVar2; long in_FS_OFFSET; int local_60; regex_t local_58; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); local_60 = 0; do { if (param_2 <= local_60) { pcVar2 = "Not Matched!"; LAB_001012dc: if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return pcVar2; } iVar1 = regcomp(&local_58,*(char **)(param_1 + (long)local_60 * 8),0); if (iVar1 != 0) { fwrite("Could not compile regex\n",1,0x18,stderr); pcVar2 = "Not Matched!"; goto LAB_001012dc; } iVar1 = regexec(&local_58,param_3,0,(regmatch_t *)0x0,0); if (iVar1 == 0) { regfree(&local_58); pcVar2 = "Matched!"; goto LAB_001012dc; } regfree(&local_58); local_60 = local_60 + 1; } while( true ); }
4,605
func0
#include <stdio.h> #include <assert.h> #include <regex.h>
char* func0(char* patterns[], int pattern_n, char* text) { regex_t regex; int reti; for (int i = 0; i < pattern_n; i++) { reti = regcomp(&regex, patterns[i], 0); if (reti) { fprintf(stderr, "Could not compile regex\n"); return "Not Matched!"; } reti = regexec(&regex, text, 0, NULL, 0); if (!reti) { regfree(&regex); return "Matched!"; } regfree(&regex); } return "Not Matched!"; }
int main() { char* patterns1[1] = {"language"}; assert(func0(patterns1, 1, "python language") == "Matched!"); char* patterns2[1] = {"program"}; assert(func0(patterns2, 1, "python language") == "Not Matched!"); char* patterns3[1] = {"python"}; assert(func0(patterns3, 1, "programming language") == "Not Matched!"); return 0; }
O1
c
func0: endbr64 push %r13 push %r12 push %rbp push %rbx sub $0x58,%rsp mov %fs:0x28,%rax mov %rax,0x48(%rsp) xor %eax,%eax lea 0xdf6(%rip),%rax test %esi,%esi jle 1298 <func0+0xaf> mov %rdx,%r12 mov %rdi,%rbx lea -0x1(%rsi),%eax lea 0x8(%rdi,%rax,8),%r13 mov %rsp,%rbp mov $0x0,%edx mov (%rbx),%rsi mov %rbp,%rdi callq 10d0 <regcomp@plt> test %eax,%eax jne 1274 <func0+0x8b> mov $0x0,%r8d mov $0x0,%ecx mov $0x0,%edx mov %r12,%rsi mov %rbp,%rdi callq 10e0 <regexec@plt> test %eax,%eax je 12b3 <func0+0xca> mov %rbp,%rdi callq 10a0 <regfree@plt> add $0x8,%rbx cmp %r13,%rbx jne 1227 <func0+0x3e> lea 0xd92(%rip),%rax jmp 1298 <func0+0xaf> mov 0x2da5(%rip),%rcx mov $0x18,%edx mov $0x1,%esi lea 0xd85(%rip),%rdi callq 10f0 <fwrite@plt> lea 0xd6c(%rip),%rax mov 0x48(%rsp),%rcx xor %fs:0x28,%rcx jne 12c4 <func0+0xdb> add $0x58,%rsp pop %rbx pop %rbp pop %r12 pop %r13 retq mov %rsp,%rdi callq 10a0 <regfree@plt> lea 0xd46(%rip),%rax jmp 1298 <func0+0xaf> callq 10b0 <__stack_chk_fail@plt>
func0: endbr64 push r13 push r12 push rbp push rbx sub rsp, 58h mov rax, fs:28h mov [rsp+78h+var_30], rax xor eax, eax lea rax, aNotMatched; "Not Matched!" test esi, esi jle loc_1298 mov r12, rdx mov rbx, rdi lea eax, [rsi-1] lea r13, [rdi+rax*8+8] mov rbp, rsp loc_1227: mov edx, 0 mov rsi, [rbx] mov rdi, rbp call _regcomp test eax, eax jnz short loc_1274 mov r8d, 0 mov ecx, 0 mov edx, 0 mov rsi, r12 mov rdi, rbp call _regexec test eax, eax jz short loc_12B3 mov rdi, rbp call _regfree add rbx, 8 cmp rbx, r13 jnz short loc_1227 lea rax, aNotMatched; "Not Matched!" jmp short loc_1298 loc_1274: mov rcx, cs:stderr@GLIBC_2_2_5 mov edx, 18h mov esi, 1 lea rdi, aCouldNotCompil; "Could not compile regex\n" call _fwrite lea rax, aNotMatched; "Not Matched!" loc_1298: mov rdx, [rsp+78h+var_30] sub rdx, fs:28h jnz short loc_12C4 add rsp, 58h pop rbx pop rbp pop r12 pop r13 retn loc_12B3: mov rdi, rsp call _regfree lea rax, aNotMatched+4; "Matched!" jmp short loc_1298 loc_12C4: call ___stack_chk_fail
char * func0(_QWORD *a1, int a2, long long a3) { char *result; // rax _QWORD *v5; // rbx _QWORD v6[15]; // [rsp+0h] [rbp-78h] BYREF v6[9] = __readfsqword(0x28u); result = "Not Matched!"; if ( a2 > 0 ) { v5 = a1; while ( 1 ) { if ( (unsigned int)regcomp(v6, *v5, 0LL) ) { fwrite("Could not compile regex\n", 1LL, 24LL, stderr); return "Not Matched!"; } if ( !(unsigned int)regexec(v6, a3, 0LL, 0LL, 0LL) ) break; regfree(v6); if ( ++v5 == &a1[(unsigned int)(a2 - 1) + 1] ) return "Not Matched!"; } regfree(v6); return "Matched!"; } return result; }
func0: ENDBR64 PUSH R13 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x58 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x48],RAX XOR EAX,EAX LEA RAX,[0x102004] TEST ESI,ESI JLE 0x00101298 MOV R12,RDX MOV RBX,RDI LEA EAX,[RSI + -0x1] LEA R13,[RDI + RAX*0x8 + 0x8] MOV RBP,RSP LAB_00101227: MOV EDX,0x0 MOV RSI,qword ptr [RBX] MOV RDI,RBP CALL 0x001010d0 TEST EAX,EAX JNZ 0x00101274 MOV R8D,0x0 MOV ECX,0x0 MOV EDX,0x0 MOV RSI,R12 MOV RDI,RBP CALL 0x001010e0 TEST EAX,EAX JZ 0x001012b3 MOV RDI,RBP CALL 0x001010a0 ADD RBX,0x8 CMP RBX,R13 JNZ 0x00101227 LEA RAX,[0x102004] JMP 0x00101298 LAB_00101274: MOV RCX,qword ptr [0x00104020] MOV EDX,0x18 MOV ESI,0x1 LEA RDI,[0x102011] CALL 0x001010f0 LEA RAX,[0x102004] LAB_00101298: MOV RDX,qword ptr [RSP + 0x48] SUB RDX,qword ptr FS:[0x28] JNZ 0x001012c4 ADD RSP,0x58 POP RBX POP RBP POP R12 POP R13 RET LAB_001012b3: MOV RDI,RSP CALL 0x001010a0 LEA RAX,[0x102008] JMP 0x00101298 LAB_001012c4: CALL 0x001010b0
char * func0(int8 *param_1,int param_2,char *param_3) { int8 *puVar1; int iVar2; char *pcVar3; long in_FS_OFFSET; regex_t rStack_78; long local_30; local_30 = *(long *)(in_FS_OFFSET + 0x28); pcVar3 = "Not Matched!"; if (0 < param_2) { puVar1 = param_1 + (ulong)(param_2 - 1) + 1; do { iVar2 = regcomp(&rStack_78,(char *)*param_1,0); if (iVar2 != 0) { fwrite("Could not compile regex\n",1,0x18,stderr); pcVar3 = "Not Matched!"; goto LAB_00101298; } iVar2 = regexec(&rStack_78,param_3,0,(regmatch_t *)0x0,0); if (iVar2 == 0) { regfree(&rStack_78); pcVar3 = "Matched!"; goto LAB_00101298; } regfree(&rStack_78); param_1 = param_1 + 1; } while (param_1 != puVar1); pcVar3 = "Not Matched!"; } LAB_00101298: if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) { return pcVar3; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,606
func0
#include <stdio.h> #include <assert.h> #include <regex.h>
char* func0(char* patterns[], int pattern_n, char* text) { regex_t regex; int reti; for (int i = 0; i < pattern_n; i++) { reti = regcomp(&regex, patterns[i], 0); if (reti) { fprintf(stderr, "Could not compile regex\n"); return "Not Matched!"; } reti = regexec(&regex, text, 0, NULL, 0); if (!reti) { regfree(&regex); return "Matched!"; } regfree(&regex); } return "Not Matched!"; }
int main() { char* patterns1[1] = {"language"}; assert(func0(patterns1, 1, "python language") == "Matched!"); char* patterns2[1] = {"program"}; assert(func0(patterns2, 1, "python language") == "Not Matched!"); char* patterns3[1] = {"python"}; assert(func0(patterns3, 1, "programming language") == "Not Matched!"); return 0; }
O2
c
func0: endbr64 push %r13 push %r12 push %rbp push %rbx sub $0x58,%rsp mov %fs:0x28,%rax mov %rax,0x48(%rsp) xor %eax,%eax test %esi,%esi jle 13d0 <func0+0xc0> lea -0x1(%rsi),%eax mov %rdx,%r12 mov %rdi,%rbx mov %rsp,%rbp lea 0x8(%rdi,%rax,8),%r13 jmp 1377 <func0+0x67> nopl 0x0(%rax) mov %rbp,%rdi xor %r8d,%r8d xor %ecx,%ecx xor %edx,%edx mov %r12,%rsi callq 10e0 <regexec@plt> mov %rbp,%rdi test %eax,%eax je 13e0 <func0+0xd0> callq 10a0 <regfree@plt> add $0x8,%rbx cmp %r13,%rbx je 13d0 <func0+0xc0> mov (%rbx),%rsi xor %edx,%edx mov %rbp,%rdi callq 10d0 <regcomp@plt> test %eax,%eax je 1350 <func0+0x40> mov 0x2c91(%rip),%rcx mov $0x18,%edx mov $0x1,%esi lea 0xc71(%rip),%rdi callq 10f0 <fwrite@plt> lea 0xc58(%rip),%rax mov 0x48(%rsp),%rcx xor %fs:0x28,%rcx jne 13ee <func0+0xde> add $0x58,%rsp pop %rbx pop %rbp pop %r12 pop %r13 retq nopw 0x0(%rax,%rax,1) lea 0xc2d(%rip),%rax jmp 13ac <func0+0x9c> nopl 0x0(%rax) callq 10a0 <regfree@plt> lea 0xc1c(%rip),%rax jmp 13ac <func0+0x9c> callq 10b0 <__stack_chk_fail@plt> nopw %cs:0x0(%rax,%rax,1) nopl (%rax)
func0: endbr64 push r13 push r12 push rbp push rbx sub rsp, 58h mov rax, fs:28h mov [rsp+78h+var_30], rax xor eax, eax test esi, esi jle loc_13D0 lea eax, [rsi-1] mov r12, rdx mov rbx, rdi mov rbp, rsp lea r13, [rdi+rax*8+8] jmp short loc_1377 loc_1350: mov rdi, rbp xor r8d, r8d xor ecx, ecx xor edx, edx mov rsi, r12 call _regexec mov rdi, rbp test eax, eax jz short loc_13E0 call _regfree add rbx, 8 cmp rbx, r13 jz short loc_13D0 loc_1377: mov rsi, [rbx] xor edx, edx mov rdi, rbp call _regcomp test eax, eax jz short loc_1350 mov rcx, cs:stderr@GLIBC_2_2_5 mov edx, 18h mov esi, 1 lea rdi, aCouldNotCompil; "Could not compile regex\n" call _fwrite lea rax, aNotMatched; "Not Matched!" loc_13AC: mov rdx, [rsp+78h+var_30] sub rdx, fs:28h jnz short loc_13EE add rsp, 58h pop rbx pop rbp pop r12 pop r13 retn loc_13D0: lea rax, aNotMatched; "Not Matched!" jmp short loc_13AC loc_13E0: call _regfree lea rax, aNotMatched+4; "Matched!" jmp short loc_13AC loc_13EE: call ___stack_chk_fail
char * func0(_QWORD *a1, int a2, long long a3) { _QWORD *v4; // rbx _QWORD v6[15]; // [rsp+0h] [rbp-78h] BYREF v6[9] = __readfsqword(0x28u); if ( a2 <= 0 ) return "Not Matched!"; v4 = a1; while ( 1 ) { if ( (unsigned int)regcomp(v6, *v4, 0LL) ) { fwrite("Could not compile regex\n", 1LL, 24LL, stderr); return "Not Matched!"; } if ( !(unsigned int)regexec(v6, a3, 0LL, 0LL, 0LL) ) break; regfree(v6); if ( ++v4 == &a1[(unsigned int)(a2 - 1) + 1] ) return "Not Matched!"; } regfree(v6); return "Matched!"; }
func0: ENDBR64 PUSH R13 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x58 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x48],RAX XOR EAX,EAX TEST ESI,ESI JLE 0x001013d0 LEA EAX,[RSI + -0x1] MOV R12,RDX MOV RBX,RDI MOV RBP,RSP LEA R13,[RDI + RAX*0x8 + 0x8] JMP 0x00101377 LAB_00101350: MOV RDI,RBP XOR R8D,R8D XOR ECX,ECX XOR EDX,EDX MOV RSI,R12 CALL 0x001010e0 MOV RDI,RBP TEST EAX,EAX JZ 0x001013e0 CALL 0x001010a0 ADD RBX,0x8 CMP RBX,R13 JZ 0x001013d0 LAB_00101377: MOV RSI,qword ptr [RBX] XOR EDX,EDX MOV RDI,RBP CALL 0x001010d0 TEST EAX,EAX JZ 0x00101350 MOV RCX,qword ptr [0x00104020] MOV EDX,0x18 MOV ESI,0x1 LEA RDI,[0x102011] CALL 0x001010f0 LEA RAX,[0x102004] LAB_001013ac: MOV RDX,qword ptr [RSP + 0x48] SUB RDX,qword ptr FS:[0x28] JNZ 0x001013ee ADD RSP,0x58 POP RBX POP RBP POP R12 POP R13 RET LAB_001013d0: LEA RAX,[0x102004] JMP 0x001013ac LAB_001013e0: CALL 0x001010a0 LEA RAX,[0x102008] JMP 0x001013ac LAB_001013ee: CALL 0x001010b0
char * func0(int8 *param_1,int param_2,char *param_3) { int8 *puVar1; int iVar2; char *pcVar3; long in_FS_OFFSET; regex_t rStack_78; long local_30; local_30 = *(long *)(in_FS_OFFSET + 0x28); if (0 < param_2) { puVar1 = param_1 + (ulong)(param_2 - 1) + 1; do { iVar2 = regcomp(&rStack_78,(char *)*param_1,0); if (iVar2 != 0) { fwrite("Could not compile regex\n",1,0x18,stderr); pcVar3 = "Not Matched!"; goto LAB_001013ac; } iVar2 = regexec(&rStack_78,param_3,0,(regmatch_t *)0x0,0); if (iVar2 == 0) { regfree(&rStack_78); pcVar3 = "Matched!"; goto LAB_001013ac; } regfree(&rStack_78); param_1 = param_1 + 1; } while (param_1 != puVar1); } pcVar3 = "Not Matched!"; LAB_001013ac: if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) { return pcVar3; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,607
func0
#include <stdio.h> #include <assert.h> #include <regex.h>
char* func0(char* patterns[], int pattern_n, char* text) { regex_t regex; int reti; for (int i = 0; i < pattern_n; i++) { reti = regcomp(&regex, patterns[i], 0); if (reti) { fprintf(stderr, "Could not compile regex\n"); return "Not Matched!"; } reti = regexec(&regex, text, 0, NULL, 0); if (!reti) { regfree(&regex); return "Matched!"; } regfree(&regex); } return "Not Matched!"; }
int main() { char* patterns1[1] = {"language"}; assert(func0(patterns1, 1, "python language") == "Matched!"); char* patterns2[1] = {"program"}; assert(func0(patterns2, 1, "python language") == "Not Matched!"); char* patterns3[1] = {"python"}; assert(func0(patterns3, 1, "programming language") == "Not Matched!"); return 0; }
O3
c
func0: endbr64 push %r13 push %r12 push %rbp push %rbx sub $0x58,%rsp mov %fs:0x28,%rax mov %rax,0x48(%rsp) xor %eax,%eax test %esi,%esi jle 13d0 <func0+0xc0> lea -0x1(%rsi),%eax mov %rdx,%r12 mov %rdi,%rbx mov %rsp,%rbp lea 0x8(%rdi,%rax,8),%r13 jmp 1377 <func0+0x67> nopl 0x0(%rax) mov %rbp,%rdi xor %r8d,%r8d xor %ecx,%ecx xor %edx,%edx mov %r12,%rsi callq 10e0 <regexec@plt> mov %rbp,%rdi test %eax,%eax je 13e0 <func0+0xd0> callq 10a0 <regfree@plt> add $0x8,%rbx cmp %r13,%rbx je 13d0 <func0+0xc0> mov (%rbx),%rsi xor %edx,%edx mov %rbp,%rdi callq 10d0 <regcomp@plt> test %eax,%eax je 1350 <func0+0x40> mov 0x2c91(%rip),%rcx mov $0x18,%edx mov $0x1,%esi lea 0xc71(%rip),%rdi callq 10f0 <fwrite@plt> lea 0xc58(%rip),%rax mov 0x48(%rsp),%rcx xor %fs:0x28,%rcx jne 13ee <func0+0xde> add $0x58,%rsp pop %rbx pop %rbp pop %r12 pop %r13 retq nopw 0x0(%rax,%rax,1) lea 0xc2d(%rip),%rax jmp 13ac <func0+0x9c> nopl 0x0(%rax) callq 10a0 <regfree@plt> lea 0xc1c(%rip),%rax jmp 13ac <func0+0x9c> callq 10b0 <__stack_chk_fail@plt> nopw %cs:0x0(%rax,%rax,1) nopl (%rax)
func0: endbr64 push r13 push r12 push rbp push rbx sub rsp, 58h mov rax, fs:28h mov [rsp+78h+var_30], rax xor eax, eax test esi, esi jle short loc_139D movsxd rsi, esi mov r12, rdx mov rbx, rdi mov rbp, rsp lea r13, [rdi+rsi*8] jmp short loc_136F loc_1348: mov rdi, rbp; preg xor r8d, r8d; eflags xor ecx, ecx; pmatch xor edx, edx; nmatch mov rsi, r12; string call _regexec mov rdi, rbp; preg test eax, eax jz short loc_13C0 call _regfree add rbx, 8 cmp rbx, r13 jz short loc_139D loc_136F: mov rsi, [rbx]; pattern xor edx, edx; cflags mov rdi, rbp; preg call _regcomp test eax, eax jz short loc_1348 mov rcx, cs:__bss_start; s mov edx, 18h; n mov esi, 1; size lea rdi, aCouldNotCompil; "Could not compile regex\n" call _fwrite loc_139D: lea rax, aNotMatched; "Not Matched!" loc_13A4: mov rdx, [rsp+78h+var_30] sub rdx, fs:28h jnz short loc_13CE add rsp, 58h pop rbx pop rbp pop r12 pop r13 retn loc_13C0: call _regfree lea rax, aNotMatched+4; "Matched!" jmp short loc_13A4 loc_13CE: call ___stack_chk_fail
char * func0(const char **a1, int a2, const char *a3) { const char **v4; // rbx regex_t v6; // [rsp+0h] [rbp-78h] BYREF unsigned long long v7; // [rsp+48h] [rbp-30h] v7 = __readfsqword(0x28u); if ( a2 <= 0 ) return "Not Matched!"; v4 = a1; while ( 1 ) { if ( regcomp(&v6, *v4, 0) ) { fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start); return "Not Matched!"; } if ( !regexec(&v6, a3, 0LL, 0LL, 0) ) break; regfree(&v6); if ( ++v4 == &a1[a2] ) return "Not Matched!"; } regfree(&v6); return "Matched!"; }
func0: ENDBR64 PUSH R13 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x58 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x48],RAX XOR EAX,EAX TEST ESI,ESI JLE 0x0010139d MOVSXD RSI,ESI MOV R12,RDX MOV RBX,RDI MOV RBP,RSP LEA R13,[RDI + RSI*0x8] JMP 0x0010136f LAB_00101348: MOV RDI,RBP XOR R8D,R8D XOR ECX,ECX XOR EDX,EDX MOV RSI,R12 CALL 0x001010e0 MOV RDI,RBP TEST EAX,EAX JZ 0x001013c0 CALL 0x001010a0 ADD RBX,0x8 CMP RBX,R13 JZ 0x0010139d LAB_0010136f: MOV RSI,qword ptr [RBX] XOR EDX,EDX MOV RDI,RBP CALL 0x001010d0 TEST EAX,EAX JZ 0x00101348 MOV RCX,qword ptr [0x00104020] MOV EDX,0x18 MOV ESI,0x1 LEA RDI,[0x102011] CALL 0x001010f0 LAB_0010139d: LEA RAX,[0x102004] LAB_001013a4: MOV RDX,qword ptr [RSP + 0x48] SUB RDX,qword ptr FS:[0x28] JNZ 0x001013ce ADD RSP,0x58 POP RBX POP RBP POP R12 POP R13 RET LAB_001013c0: CALL 0x001010a0 LEA RAX,[0x102008] JMP 0x001013a4 LAB_001013ce: CALL 0x001010b0
char * func0(int8 *param_1,int param_2,char *param_3) { int8 *puVar1; int iVar2; char *pcVar3; long in_FS_OFFSET; regex_t rStack_78; long local_30; local_30 = *(long *)(in_FS_OFFSET + 0x28); if (0 < param_2) { puVar1 = param_1 + param_2; do { iVar2 = regcomp(&rStack_78,(char *)*param_1,0); if (iVar2 != 0) { fwrite("Could not compile regex\n",1,0x18,stderr); break; } iVar2 = regexec(&rStack_78,param_3,0,(regmatch_t *)0x0,0); if (iVar2 == 0) { regfree(&rStack_78); pcVar3 = "Matched!"; goto LAB_001013a4; } regfree(&rStack_78); param_1 = param_1 + 1; } while (param_1 != puVar1); } pcVar3 = "Not Matched!"; LAB_001013a4: if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) { return pcVar3; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,608
func0
#include <assert.h> #include <stdbool.h> #include <stdio.h>
bool func0(int x) { int terms[100], temp = x, n = 0; while (temp > 0) { terms[n++] = temp % 10; temp /= 10; } for (int left = 0, right = n - 1; left < right; left++, right--) { int temp = terms[left]; terms[left] = terms[right]; terms[right] = temp; } int next_term = 0, i = n; while (next_term < x) { next_term = 0; for (int j = 1; j <= n; j++) { next_term += terms[i - j]; } terms[i++] = next_term; } return (next_term == x); }
int main() { assert(func0(14) == true); assert(func0(12) == false); assert(func0(197) == true); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x1d0,%rsp mov %edi,-0x1c4(%rbp) mov %fs:0x28,%rax mov %rax,-0x8(%rbp) xor %eax,%eax mov -0x1c4(%rbp),%eax mov %eax,-0x1c0(%rbp) movl $0x0,-0x1bc(%rbp) jmp 120f <func0+0xa6> mov -0x1bc(%rbp),%esi lea 0x1(%rsi),%eax mov %eax,-0x1bc(%rbp) mov -0x1c0(%rbp),%ecx movslq %ecx,%rax imul $0x66666667,%rax,%rax shr $0x20,%rax mov %eax,%edx sar $0x2,%edx mov %ecx,%eax sar $0x1f,%eax sub %eax,%edx mov %edx,%eax shl $0x2,%eax add %edx,%eax add %eax,%eax sub %eax,%ecx mov %ecx,%edx movslq %esi,%rax mov %edx,-0x1a0(%rbp,%rax,4) mov -0x1c0(%rbp),%eax movslq %eax,%rdx imul $0x66666667,%rdx,%rdx shr $0x20,%rdx sar $0x2,%edx sar $0x1f,%eax sub %eax,%edx mov %edx,%eax mov %eax,-0x1c0(%rbp) cmpl $0x0,-0x1c0(%rbp) jg 11a5 <func0+0x3c> movl $0x0,-0x1b8(%rbp) mov -0x1bc(%rbp),%eax sub $0x1,%eax mov %eax,-0x1b4(%rbp) jmp 1289 <func0+0x120> mov -0x1b8(%rbp),%eax cltq mov -0x1a0(%rbp,%rax,4),%eax mov %eax,-0x1a4(%rbp) mov -0x1b4(%rbp),%eax cltq mov -0x1a0(%rbp,%rax,4),%edx mov -0x1b8(%rbp),%eax cltq mov %edx,-0x1a0(%rbp,%rax,4) mov -0x1b4(%rbp),%eax cltq mov -0x1a4(%rbp),%edx mov %edx,-0x1a0(%rbp,%rax,4) addl $0x1,-0x1b8(%rbp) subl $0x1,-0x1b4(%rbp) mov -0x1b8(%rbp),%eax cmp -0x1b4(%rbp),%eax jl 1233 <func0+0xca> movl $0x0,-0x1b0(%rbp) mov -0x1bc(%rbp),%eax mov %eax,-0x1ac(%rbp) jmp 1313 <func0+0x1aa> movl $0x0,-0x1b0(%rbp) movl $0x1,-0x1a8(%rbp) jmp 12e7 <func0+0x17e> mov -0x1ac(%rbp),%eax sub -0x1a8(%rbp),%eax cltq mov -0x1a0(%rbp,%rax,4),%eax add %eax,-0x1b0(%rbp) addl $0x1,-0x1a8(%rbp) mov -0x1a8(%rbp),%eax cmp -0x1bc(%rbp),%eax jle 12c5 <func0+0x15c> mov -0x1ac(%rbp),%eax lea 0x1(%rax),%edx mov %edx,-0x1ac(%rbp) cltq mov -0x1b0(%rbp),%edx mov %edx,-0x1a0(%rbp,%rax,4) mov -0x1b0(%rbp),%eax cmp -0x1c4(%rbp),%eax jl 12af <func0+0x146> mov -0x1b0(%rbp),%eax cmp -0x1c4(%rbp),%eax sete %al mov -0x8(%rbp),%rdi xor %fs:0x28,%rdi je 1344 <func0+0x1db> callq 1060 <__stack_chk_fail@plt> leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 1D0h mov [rbp+var_1C4], edi mov rax, fs:28h mov [rbp+var_8], rax xor eax, eax mov eax, [rbp+var_1C4] mov [rbp+var_1C0], eax mov [rbp+var_1BC], 0 jmp short loc_120F loc_11A5: mov esi, [rbp+var_1BC] lea eax, [rsi+1] mov [rbp+var_1BC], eax mov ecx, [rbp+var_1C0] movsxd rax, ecx imul rax, 66666667h shr rax, 20h mov edx, eax sar edx, 2 mov eax, ecx sar eax, 1Fh sub edx, eax mov eax, edx shl eax, 2 add eax, edx add eax, eax sub ecx, eax mov edx, ecx movsxd rax, esi mov [rbp+rax*4+var_1A0], edx mov eax, [rbp+var_1C0] movsxd rdx, eax imul rdx, 66666667h shr rdx, 20h mov ecx, edx sar ecx, 2 cdq mov eax, ecx sub eax, edx mov [rbp+var_1C0], eax loc_120F: cmp [rbp+var_1C0], 0 jg short loc_11A5 mov [rbp+var_1B8], 0 mov eax, [rbp+var_1BC] sub eax, 1 mov [rbp+var_1B4], eax jmp short loc_1289 loc_1233: mov eax, [rbp+var_1B8] cdqe mov eax, [rbp+rax*4+var_1A0] mov [rbp+var_1A4], eax mov eax, [rbp+var_1B4] cdqe mov edx, [rbp+rax*4+var_1A0] mov eax, [rbp+var_1B8] cdqe mov [rbp+rax*4+var_1A0], edx mov eax, [rbp+var_1B4] cdqe mov edx, [rbp+var_1A4] mov [rbp+rax*4+var_1A0], edx add [rbp+var_1B8], 1 sub [rbp+var_1B4], 1 loc_1289: mov eax, [rbp+var_1B8] cmp eax, [rbp+var_1B4] jl short loc_1233 mov [rbp+var_1B0], 0 mov eax, [rbp+var_1BC] mov [rbp+var_1AC], eax jmp short loc_1313 loc_12AF: mov [rbp+var_1B0], 0 mov [rbp+var_1A8], 1 jmp short loc_12E7 loc_12C5: mov eax, [rbp+var_1AC] sub eax, [rbp+var_1A8] cdqe mov eax, [rbp+rax*4+var_1A0] add [rbp+var_1B0], eax add [rbp+var_1A8], 1 loc_12E7: mov eax, [rbp+var_1A8] cmp eax, [rbp+var_1BC] jle short loc_12C5 mov eax, [rbp+var_1AC] lea edx, [rax+1] mov [rbp+var_1AC], edx cdqe mov edx, [rbp+var_1B0] mov [rbp+rax*4+var_1A0], edx loc_1313: mov eax, [rbp+var_1B0] cmp eax, [rbp+var_1C4] jl short loc_12AF mov eax, [rbp+var_1B0] cmp eax, [rbp+var_1C4] setz al mov rdx, [rbp+var_8] sub rdx, fs:28h jz short locret_1344 call ___stack_chk_fail locret_1344: leave retn
bool func0(int a1) { int v1; // esi int v2; // eax int v4; // [rsp+10h] [rbp-1C0h] int v5; // [rsp+14h] [rbp-1BCh] int v6; // [rsp+18h] [rbp-1B8h] int i; // [rsp+1Ch] [rbp-1B4h] int v8; // [rsp+20h] [rbp-1B0h] int v9; // [rsp+24h] [rbp-1ACh] int j; // [rsp+28h] [rbp-1A8h] int v11; // [rsp+2Ch] [rbp-1A4h] _DWORD v12[102]; // [rsp+30h] [rbp-1A0h] unsigned long long v13; // [rsp+1C8h] [rbp-8h] v13 = __readfsqword(0x28u); v4 = a1; v5 = 0; while ( v4 > 0 ) { v1 = v5++; v12[v1] = v4 % 10; v4 /= 10; } v6 = 0; for ( i = v5 - 1; v6 < i; --i ) { v11 = v12[v6]; v12[v6] = v12[i]; v12[i] = v11; ++v6; } v8 = 0; v9 = v5; while ( v8 < a1 ) { v8 = 0; for ( j = 1; j <= v5; ++j ) v8 += v12[v9 - j]; v2 = v9++; v12[v2] = v8; } return v8 == a1; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x1d0 MOV dword ptr [RBP + -0x1c4],EDI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x8],RAX XOR EAX,EAX MOV EAX,dword ptr [RBP + -0x1c4] MOV dword ptr [RBP + -0x1c0],EAX MOV dword ptr [RBP + -0x1bc],0x0 JMP 0x0010120f LAB_001011a5: MOV ESI,dword ptr [RBP + -0x1bc] LEA EAX,[RSI + 0x1] MOV dword ptr [RBP + -0x1bc],EAX MOV ECX,dword ptr [RBP + -0x1c0] MOVSXD RAX,ECX IMUL RAX,RAX,0x66666667 SHR RAX,0x20 MOV EDX,EAX SAR EDX,0x2 MOV EAX,ECX SAR EAX,0x1f SUB EDX,EAX MOV EAX,EDX SHL EAX,0x2 ADD EAX,EDX ADD EAX,EAX SUB ECX,EAX MOV EDX,ECX MOVSXD RAX,ESI MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX MOV EAX,dword ptr [RBP + -0x1c0] MOVSXD RDX,EAX IMUL RDX,RDX,0x66666667 SHR RDX,0x20 MOV ECX,EDX SAR ECX,0x2 CDQ MOV EAX,ECX SUB EAX,EDX MOV dword ptr [RBP + -0x1c0],EAX LAB_0010120f: CMP dword ptr [RBP + -0x1c0],0x0 JG 0x001011a5 MOV dword ptr [RBP + -0x1b8],0x0 MOV EAX,dword ptr [RBP + -0x1bc] SUB EAX,0x1 MOV dword ptr [RBP + -0x1b4],EAX JMP 0x00101289 LAB_00101233: MOV EAX,dword ptr [RBP + -0x1b8] CDQE MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0] MOV dword ptr [RBP + -0x1a4],EAX MOV EAX,dword ptr [RBP + -0x1b4] CDQE MOV EDX,dword ptr [RBP + RAX*0x4 + -0x1a0] MOV EAX,dword ptr [RBP + -0x1b8] CDQE MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX MOV EAX,dword ptr [RBP + -0x1b4] CDQE MOV EDX,dword ptr [RBP + -0x1a4] MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX ADD dword ptr [RBP + -0x1b8],0x1 SUB dword ptr [RBP + -0x1b4],0x1 LAB_00101289: MOV EAX,dword ptr [RBP + -0x1b8] CMP EAX,dword ptr [RBP + -0x1b4] JL 0x00101233 MOV dword ptr [RBP + -0x1b0],0x0 MOV EAX,dword ptr [RBP + -0x1bc] MOV dword ptr [RBP + -0x1ac],EAX JMP 0x00101313 LAB_001012af: MOV dword ptr [RBP + -0x1b0],0x0 MOV dword ptr [RBP + -0x1a8],0x1 JMP 0x001012e7 LAB_001012c5: MOV EAX,dword ptr [RBP + -0x1ac] SUB EAX,dword ptr [RBP + -0x1a8] CDQE MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0] ADD dword ptr [RBP + -0x1b0],EAX ADD dword ptr [RBP + -0x1a8],0x1 LAB_001012e7: MOV EAX,dword ptr [RBP + -0x1a8] CMP EAX,dword ptr [RBP + -0x1bc] JLE 0x001012c5 MOV EAX,dword ptr [RBP + -0x1ac] LEA EDX,[RAX + 0x1] MOV dword ptr [RBP + -0x1ac],EDX CDQE MOV EDX,dword ptr [RBP + -0x1b0] MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX LAB_00101313: MOV EAX,dword ptr [RBP + -0x1b0] CMP EAX,dword ptr [RBP + -0x1c4] JL 0x001012af MOV EAX,dword ptr [RBP + -0x1b0] CMP EAX,dword ptr [RBP + -0x1c4] SETZ AL MOV RDX,qword ptr [RBP + -0x8] SUB RDX,qword ptr FS:[0x28] JZ 0x00101344 CALL 0x00101060 LAB_00101344: LEAVE RET
int4 func0(int param_1) { int iVar1; long in_FS_OFFSET; int local_1c8; int local_1c4; int local_1c0; int local_1bc; int local_1b8; int local_1b4; int local_1b0; int aiStack_1a8 [102]; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); local_1c4 = 0; for (local_1c8 = param_1; 0 < local_1c8; local_1c8 = local_1c8 / 10) { aiStack_1a8[local_1c4] = local_1c8 % 10; local_1c4 = local_1c4 + 1; } local_1bc = local_1c4; for (local_1c0 = 0; local_1bc = local_1bc + -1, local_1c0 < local_1bc; local_1c0 = local_1c0 + 1) { iVar1 = aiStack_1a8[local_1c0]; aiStack_1a8[local_1c0] = aiStack_1a8[local_1bc]; aiStack_1a8[local_1bc] = iVar1; } local_1b8 = 0; local_1b4 = local_1c4; while (local_1b8 < param_1) { local_1b8 = 0; for (local_1b0 = 1; local_1b0 <= local_1c4; local_1b0 = local_1b0 + 1) { local_1b8 = local_1b8 + aiStack_1a8[local_1b4 - local_1b0]; } aiStack_1a8[local_1b4] = local_1b8; local_1b4 = local_1b4 + 1; } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return CONCAT31((int3)((uint)local_1b8 >> 8),local_1b8 == param_1); }
4,609
func0
#include <assert.h> #include <stdbool.h> #include <stdio.h>
bool func0(int x) { int terms[100], temp = x, n = 0; while (temp > 0) { terms[n++] = temp % 10; temp /= 10; } for (int left = 0, right = n - 1; left < right; left++, right--) { int temp = terms[left]; terms[left] = terms[right]; terms[right] = temp; } int next_term = 0, i = n; while (next_term < x) { next_term = 0; for (int j = 1; j <= n; j++) { next_term += terms[i - j]; } terms[i++] = next_term; } return (next_term == x); }
int main() { assert(func0(14) == true); assert(func0(12) == false); assert(func0(197) == true); return 0; }
O1
c
func0: endbr64 sub $0x1a8,%rsp mov %fs:0x28,%rax mov %rax,0x198(%rsp) xor %eax,%eax test %edi,%edi jle 122c <func0+0xc3> mov %rsp,%rcx mov %rcx,%r10 mov %edi,%edx mov $0x0,%esi mov %esi,%r9d add $0x1,%esi movslq %edx,%rax imul $0x66666667,%rax,%rax sar $0x22,%rax mov %edx,%r8d sar $0x1f,%r8d sub %r8d,%eax lea (%rax,%rax,4),%r8d add %r8d,%r8d mov %edx,%r11d sub %r8d,%r11d mov %r11d,(%r10) mov %edx,%r8d mov %eax,%edx add $0x4,%r10 cmp $0x9,%r8d jg 119c <func0+0x33> test %r9d,%r9d jle 120a <func0+0xa1> movslq %r9d,%rax lea (%rsp,%rax,4),%rdx mov %r9d,%eax mov (%rcx),%r8d mov (%rdx),%r10d mov %r10d,(%rcx) mov %r8d,(%rdx) sub $0x1,%eax add $0x4,%rcx sub $0x4,%rdx mov %r9d,%r8d sub %eax,%r8d cmp %r8d,%eax jg 11e8 <func0+0x7f> movslq %esi,%rax shl $0x2,%rax lea (%rsp,%rax,1),%r8 lea -0x4(%rsp,%rax,1),%rcx mov %r9d,%eax shl $0x2,%rax sub %rax,%rcx mov $0x0,%r9d jmp 1242 <func0+0xd9> mov $0x0,%edx jmp 125f <func0+0xf6> movl $0x0,(%r8) add $0x4,%r8 add $0x4,%rcx mov %r8,%rax mov %r9d,%edx test %esi,%esi jle 1233 <func0+0xca> add -0x4(%rax),%edx sub $0x4,%rax cmp %rcx,%rax jne 124c <func0+0xe3> mov %edx,(%r8) cmp %edx,%edi jg 123a <func0+0xd1> cmp %edx,%edi sete %al mov 0x198(%rsp),%rdi xor %fs:0x28,%rdi jne 127f <func0+0x116> add $0x1a8,%rsp retq callq 1060 <__stack_chk_fail@plt>
func0: endbr64 sub rsp, 1A8h mov r8d, edi mov rax, fs:28h mov [rsp+1A8h+var_10], rax xor eax, eax test edi, edi jle loc_1224 mov rcx, rsp mov r10, rcx mov edx, edi mov esi, 0 loc_119F: mov r9d, esi add esi, 1 movsxd rax, edx imul rax, 66666667h sar rax, 22h mov edi, edx sar edi, 1Fh sub eax, edi lea edi, [rax+rax*4] add edi, edi mov r11d, edx sub r11d, edi mov [r10], r11d mov edi, edx mov edx, eax add r10, 4 cmp edi, 9 jg short loc_119F test r9d, r9d jle short loc_1202 movsxd rax, r9d lea rdx, [rsp+rax*4+1A8h+var_1A8] mov eax, r9d loc_11E4: mov edi, [rcx] mov r10d, [rdx] mov [rcx], r10d mov [rdx], edi sub eax, 1 add rcx, 4 sub rdx, 4 mov edi, r9d sub edi, eax cmp eax, edi jg short loc_11E4 loc_1202: movsxd rax, esi shl rax, 2 lea rdi, [rsp+rax+1A8h+var_1A8] lea rcx, [rsp+rax+1A8h+var_1AC] mov eax, r9d shl rax, 2 sub rcx, rax mov r9d, 0 jmp short loc_1239 loc_1224: mov edx, 0 jmp short loc_1256 loc_122B: mov dword ptr [rdi], 0 loc_1231: add rdi, 4 add rcx, 4 loc_1239: mov rax, rdi mov edx, r9d test esi, esi jle short loc_122B loc_1243: add edx, [rax-4] sub rax, 4 cmp rax, rcx jnz short loc_1243 mov [rdi], edx cmp r8d, edx jg short loc_1231 loc_1256: cmp r8d, edx setz al mov rdx, [rsp+1A8h+var_10] sub rdx, fs:28h jnz short loc_1277 add rsp, 1A8h retn loc_1277: call ___stack_chk_fail
bool func0(int a1) { int *v2; // rcx int *v3; // r10 int v4; // edx int v5; // esi int v6; // r9d int v7; // edi int *v8; // rdx int v9; // eax int v10; // edi long long v11; // rax int *v12; // rdi int *i; // rcx int v14; // edx int *v15; // rax _BYTE v17[4]; // [rsp+0h] [rbp-1ACh] BYREF _BYTE v18[408]; // [rsp+4h] [rbp-1A8h] BYREF unsigned long long v19; // [rsp+19Ch] [rbp-10h] v19 = __readfsqword(0x28u); if ( a1 > 0 ) { v2 = (int *)v18; v3 = (int *)v18; v4 = a1; v5 = 0; do { v6 = v5++; *v3 = v4 % 10; v7 = v4; v4 /= 10; ++v3; } while ( v7 > 9 ); if ( v6 > 0 ) { v8 = (int *)&v18[4 * v6]; v9 = v6; do { v10 = *v2; *v2 = *v8; *v8 = v10; --v9; ++v2; --v8; } while ( v9 > v6 - v9 ); } v11 = 4LL * v5; v12 = (int *)&v18[v11]; for ( i = (int *)&v17[v11 + -4 * (unsigned int)v6]; ; ++i ) { v15 = v12; v14 = 0; if ( v5 <= 0 ) { *v12 = 0; } else { do v14 += *--v15; while ( v15 != i ); *v12 = v14; if ( a1 <= v14 ) return a1 == v14; } ++v12; } } v14 = 0; return a1 == v14; }
func0: ENDBR64 SUB RSP,0x1a8 MOV R8D,EDI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x198],RAX XOR EAX,EAX TEST EDI,EDI JLE 0x00101224 MOV RCX,RSP MOV R10,RCX MOV EDX,EDI MOV ESI,0x0 LAB_0010119f: MOV R9D,ESI ADD ESI,0x1 MOVSXD RAX,EDX IMUL RAX,RAX,0x66666667 SAR RAX,0x22 MOV EDI,EDX SAR EDI,0x1f SUB EAX,EDI LEA EDI,[RAX + RAX*0x4] ADD EDI,EDI MOV R11D,EDX SUB R11D,EDI MOV dword ptr [R10],R11D MOV EDI,EDX MOV EDX,EAX ADD R10,0x4 CMP EDI,0x9 JG 0x0010119f TEST R9D,R9D JLE 0x00101202 MOVSXD RAX,R9D LEA RDX,[RSP + RAX*0x4] MOV EAX,R9D LAB_001011e4: MOV EDI,dword ptr [RCX] MOV R10D,dword ptr [RDX] MOV dword ptr [RCX],R10D MOV dword ptr [RDX],EDI SUB EAX,0x1 ADD RCX,0x4 SUB RDX,0x4 MOV EDI,R9D SUB EDI,EAX CMP EAX,EDI JG 0x001011e4 LAB_00101202: MOVSXD RAX,ESI SHL RAX,0x2 LEA RDI,[RSP + RAX*0x1] LEA RCX,[RSP + RAX*0x1 + -0x4] MOV EAX,R9D SHL RAX,0x2 SUB RCX,RAX MOV R9D,0x0 JMP 0x00101239 LAB_00101224: MOV EDX,0x0 JMP 0x00101256 LAB_0010122b: MOV dword ptr [RDI],0x0 LAB_00101231: ADD RDI,0x4 ADD RCX,0x4 LAB_00101239: MOV RAX,RDI MOV EDX,R9D TEST ESI,ESI JLE 0x0010122b LAB_00101243: ADD EDX,dword ptr [RAX + -0x4] SUB RAX,0x4 CMP RAX,RCX JNZ 0x00101243 MOV dword ptr [RDI],EDX CMP R8D,EDX JG 0x00101231 LAB_00101256: CMP R8D,EDX SETZ AL MOV RDX,qword ptr [RSP + 0x198] SUB RDX,qword ptr FS:[0x28] JNZ 0x00101277 ADD RSP,0x1a8 RET LAB_00101277: CALL 0x00101060
int8 func0(int param_1) { bool bVar1; uint uVar2; int *piVar3; int *piVar5; int *piVar6; int iVar7; int iVar8; uint uVar9; long in_FS_OFFSET; int local_1a8 [102]; long local_10; ulong uVar4; ulong uVar10; piVar6 = local_1a8; piVar5 = local_1a8; local_10 = *(long *)(in_FS_OFFSET + 0x28); piVar3 = (int *)0x0; if (0 < param_1) { uVar4 = 0; iVar7 = param_1; do { uVar10 = uVar4; iVar8 = (int)uVar10; uVar9 = iVar8 + 1; *piVar6 = iVar7 % 10; piVar6 = piVar6 + 1; bVar1 = 9 < iVar7; uVar4 = (ulong)uVar9; iVar7 = iVar7 / 10; } while (bVar1); if (0 < iVar8) { piVar3 = local_1a8 + iVar8; uVar4 = uVar10; do { iVar7 = *piVar5; *piVar5 = *piVar3; *piVar3 = iVar7; uVar2 = (int)uVar4 - 1; uVar4 = (ulong)uVar2; piVar5 = piVar5 + 1; piVar3 = piVar3 + -1; } while ((int)(iVar8 - uVar2) < (int)uVar2); } piVar5 = local_1a8 + (int)uVar9; piVar6 = local_1a8 + (long)(int)uVar9 + (-1 - uVar10); do { iVar7 = 0; piVar3 = piVar5; if ((int)uVar9 < 1) { *piVar5 = 0; } else { do { iVar7 = iVar7 + piVar3[-1]; piVar3 = piVar3 + -1; } while (piVar3 != piVar6); *piVar5 = iVar7; if (param_1 <= iVar7) goto LAB_00101256; } piVar5 = piVar5 + 1; piVar6 = piVar6 + 1; } while( true ); } iVar7 = 0; LAB_00101256: if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) { return CONCAT71((int7)((ulong)piVar3 >> 8),param_1 == iVar7); } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,610
func0
#include <assert.h> #include <stdbool.h> #include <stdio.h>
bool func0(int x) { int terms[100], temp = x, n = 0; while (temp > 0) { terms[n++] = temp % 10; temp /= 10; } for (int left = 0, right = n - 1; left < right; left++, right--) { int temp = terms[left]; terms[left] = terms[right]; terms[right] = temp; } int next_term = 0, i = n; while (next_term < x) { next_term = 0; for (int j = 1; j <= n; j++) { next_term += terms[i - j]; } terms[i++] = next_term; } return (next_term == x); }
int main() { assert(func0(14) == true); assert(func0(12) == false); assert(func0(197) == true); return 0; }
O2
c
func0: endbr64 push %rbp push %rbx sub $0x1a8,%rsp mov %fs:0x28,%rax mov %rax,0x198(%rsp) xor %eax,%eax test %edi,%edi jle 12fc <func0+0xec> mov %rsp,%rsi mov %edi,%edx xor %r10d,%r10d mov $0xcccccccd,%ebp mov %rsi,%rcx mov %rsi,%r11 nopl 0x0(%rax,%rax,1) mov %edx,%eax mov %edx,%ebx mov %r10d,%r9d add $0x4,%r11 imul %rbp,%rax add $0x1,%r10d shr $0x23,%rax mov %eax,%r8d lea (%rax,%rax,4),%eax add %eax,%eax sub %eax,%ebx mov %ebx,-0x4(%r11) mov %ebx,%eax mov %edx,%ebx mov %r8d,%edx cmp $0x9,%ebx jg 1250 <func0+0x40> test %r9d,%r9d je 12b8 <func0+0xa8> movslq %r9d,%rdx lea (%rsi,%rdx,4),%r8 mov %r9d,%edx jmp 129b <func0+0x8b> nopw 0x0(%rax,%rax,1) mov (%r8),%eax mov (%rcx),%r11d sub $0x1,%edx mov %eax,(%rcx) mov %r9d,%eax sub %edx,%eax add $0x4,%rcx sub $0x4,%r8 mov %r11d,0x4(%r8) cmp %eax,%edx jg 1298 <func0+0x88> movslq %r10d,%rax shl $0x2,%rax lea -0x4(%rsp,%rax,1),%rcx add %rax,%rsi mov %r9d,%eax shl $0x2,%rax sub %rax,%rcx nopl 0x0(%rax) mov %rsi,%rax xor %edx,%edx nopl (%rax) add -0x4(%rax),%edx sub $0x4,%rax cmp %rcx,%rax jne 12e0 <func0+0xd0> mov %edx,(%rsi) cmp %edx,%edi jle 1300 <func0+0xf0> add $0x4,%rsi add $0x4,%rcx jmp 12d8 <func0+0xc8> xor %edx,%edx xchg %ax,%ax cmp %edx,%edi sete %al mov 0x198(%rsp),%rdi xor %fs:0x28,%rdi jne 1322 <func0+0x112> add $0x1a8,%rsp pop %rbx pop %rbp retq callq 1060 <__stack_chk_fail@plt> nopw 0x0(%rax,%rax,1)
func0: endbr64 push rbp mov r8d, edi push rbx sub rsp, 1A8h mov rax, fs:28h mov [rsp+1B8h+var_20], rax xor eax, eax test edi, edi jle loc_12F5 mov rsi, rsp mov edx, edi xor r11d, r11d mov ebp, 0CCCCCCCDh mov r9, rsi mov rbx, rsi xchg ax, ax loc_1250: mov eax, edx mov r10d, r11d add rbx, 4 add r11d, 1 imul rax, rbp shr rax, 23h lea edi, [rax+rax*4] mov ecx, eax mov eax, edx add edi, edi sub eax, edi mov edi, edx mov edx, ecx mov [rbx-4], eax cmp edi, 9 jg short loc_1250 test r10d, r10d jz short loc_12AF movsxd rdx, r10d lea rcx, [rsi+rdx*4] mov edx, r10d jmp short loc_1292 loc_1290: mov eax, [rcx] loc_1292: mov edi, [r9] sub edx, 1 mov [r9], eax mov eax, r10d sub eax, edx add r9, 4 sub rcx, 4 mov [rcx+4], edi cmp edx, eax jg short loc_1290 loc_12AF: movsxd rax, r11d shl rax, 2 lea rcx, [rsp+rax+1B8h+var_1BC] add rsi, rax mov eax, r10d shl rax, 2 sub rcx, rax nop dword ptr [rax+rax+00000000h] loc_12D0: mov rax, rsi xor edx, edx nop dword ptr [rax] loc_12D8: add edx, [rax-4] sub rax, 4 cmp rax, rcx jnz short loc_12D8 mov [rsi], edx cmp r8d, edx jle short loc_1300 add rsi, 4 add rcx, 4 jmp short loc_12D0 loc_12F5: xor edx, edx nop word ptr [rax+rax+00000000h] loc_1300: cmp r8d, edx setz al mov rdx, [rsp+1B8h+var_20] sub rdx, fs:28h jnz short loc_1323 add rsp, 1A8h pop rbx pop rbp retn loc_1323: call ___stack_chk_fail
bool func0(int a1) { unsigned int v2; // edx unsigned int v3; // r11d unsigned int *v4; // r9 _BYTE *v5; // rbx unsigned int v6; // r10d unsigned int v7; // eax int v8; // edi unsigned int *v9; // rcx int v10; // edx unsigned int v11; // edi long long v12; // rax int *v13; // rsi int *i; // rcx int *v15; // rax int v16; // edx _BYTE v18[4]; // [rsp+0h] [rbp-1BCh] BYREF _BYTE v19[408]; // [rsp+4h] [rbp-1B8h] BYREF unsigned long long v20; // [rsp+19Ch] [rbp-20h] v20 = __readfsqword(0x28u); if ( a1 <= 0 ) { v16 = 0; } else { v2 = a1; v3 = 0; v4 = (unsigned int *)v19; v5 = v19; do { v6 = v3; v5 += 4; ++v3; v7 = v2 % 0xA; v8 = v2; v2 /= 0xAu; *((_DWORD *)v5 - 1) = v7; } while ( v8 > 9 ); if ( v6 ) { v9 = (unsigned int *)&v19[4 * v6]; v10 = v6; while ( 1 ) { v11 = *v4; --v10; *v4++ = v7; --v9; v9[1] = v11; if ( v10 <= (int)(v6 - v10) ) break; v7 = *v9; } } v12 = 4LL * (int)v3; v13 = (int *)&v19[v12]; for ( i = (int *)&v18[v12 + -4 * v6]; ; ++i ) { v15 = v13; v16 = 0; do v16 += *--v15; while ( v15 != i ); *v13 = v16; if ( a1 <= v16 ) break; ++v13; } } return a1 == v16; }
func0: ENDBR64 PUSH RBP MOV R8D,EDI PUSH RBX SUB RSP,0x1a8 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x198],RAX XOR EAX,EAX TEST EDI,EDI JLE 0x001012f5 MOV RSI,RSP MOV EDX,EDI XOR R11D,R11D MOV EBP,0xcccccccd MOV R9,RSI MOV RBX,RSI NOP LAB_00101250: MOV EAX,EDX MOV R10D,R11D ADD RBX,0x4 ADD R11D,0x1 IMUL RAX,RBP SHR RAX,0x23 LEA EDI,[RAX + RAX*0x4] MOV ECX,EAX MOV EAX,EDX ADD EDI,EDI SUB EAX,EDI MOV EDI,EDX MOV EDX,ECX MOV dword ptr [RBX + -0x4],EAX CMP EDI,0x9 JG 0x00101250 TEST R10D,R10D JZ 0x001012af MOVSXD RDX,R10D LEA RCX,[RSI + RDX*0x4] MOV EDX,R10D JMP 0x00101292 LAB_00101290: MOV EAX,dword ptr [RCX] LAB_00101292: MOV EDI,dword ptr [R9] SUB EDX,0x1 MOV dword ptr [R9],EAX MOV EAX,R10D SUB EAX,EDX ADD R9,0x4 SUB RCX,0x4 MOV dword ptr [RCX + 0x4],EDI CMP EDX,EAX JG 0x00101290 LAB_001012af: MOVSXD RAX,R11D SHL RAX,0x2 LEA RCX,[RSP + RAX*0x1 + -0x4] ADD RSI,RAX MOV EAX,R10D SHL RAX,0x2 SUB RCX,RAX NOP dword ptr [RAX + RAX*0x1] LAB_001012d0: MOV RAX,RSI XOR EDX,EDX NOP dword ptr [RAX] LAB_001012d8: ADD EDX,dword ptr [RAX + -0x4] SUB RAX,0x4 CMP RAX,RCX JNZ 0x001012d8 MOV dword ptr [RSI],EDX CMP R8D,EDX JLE 0x00101300 ADD RSI,0x4 ADD RCX,0x4 JMP 0x001012d0 LAB_001012f5: XOR EDX,EDX NOP word ptr [RAX + RAX*0x1] LAB_00101300: CMP R8D,EDX SETZ AL MOV RDX,qword ptr [RSP + 0x198] SUB RDX,qword ptr FS:[0x28] JNZ 0x00101323 ADD RSP,0x1a8 POP RBX POP RBP RET LAB_00101323: CALL 0x00101060
int8 func0(uint param_1) { uint uVar1; uint uVar2; uint *puVar4; uint *puVar5; uint uVar6; ulong uVar7; uint *puVar8; uint uVar9; uint uVar10; long in_FS_OFFSET; uint local_1b8 [102]; long local_20; int iVar3; puVar5 = local_1b8; local_20 = *(long *)(in_FS_OFFSET + 0x28); puVar4 = (uint *)0x0; if ((int)param_1 < 1) { uVar10 = 0; } else { uVar7 = (ulong)param_1; puVar4 = local_1b8; uVar10 = 0; do { uVar9 = uVar10; uVar10 = uVar9 + 1; iVar3 = (int)uVar7; uVar2 = iVar3 + (int)(uVar7 / 10) * -10; *puVar4 = uVar2; uVar7 = uVar7 / 10; puVar4 = puVar4 + 1; } while (9 < iVar3); if (uVar9 != 0) { puVar4 = local_1b8 + (int)uVar9; uVar6 = uVar9; while( true ) { uVar1 = *puVar5; uVar6 = uVar6 - 1; *puVar5 = uVar2; puVar5 = puVar5 + 1; *puVar4 = uVar1; if ((int)uVar6 <= (int)(uVar9 - uVar6)) break; uVar2 = puVar4[-1]; puVar4 = puVar4 + -1; } } puVar8 = local_1b8 + (int)uVar10; puVar5 = local_1b8 + (long)(int)uVar10 + (-1 - (ulong)uVar9); while( true ) { uVar10 = 0; puVar4 = puVar8; do { uVar10 = uVar10 + puVar4[-1]; puVar4 = puVar4 + -1; } while (puVar4 != puVar5); *puVar8 = uVar10; if ((int)param_1 <= (int)uVar10) break; puVar8 = puVar8 + 1; puVar5 = puVar5 + 1; } } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return CONCAT71((int7)((ulong)puVar4 >> 8),param_1 == uVar10); } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,611
func0
#include <assert.h> #include <stdbool.h> #include <stdio.h>
bool func0(int x) { int terms[100], temp = x, n = 0; while (temp > 0) { terms[n++] = temp % 10; temp /= 10; } for (int left = 0, right = n - 1; left < right; left++, right--) { int temp = terms[left]; terms[left] = terms[right]; terms[right] = temp; } int next_term = 0, i = n; while (next_term < x) { next_term = 0; for (int j = 1; j <= n; j++) { next_term += terms[i - j]; } terms[i++] = next_term; } return (next_term == x); }
int main() { assert(func0(14) == true); assert(func0(12) == false); assert(func0(197) == true); return 0; }
O3
c
func0: endbr64 push %r14 push %r12 push %rbp push %rbx sub $0x1a8,%rsp mov %fs:0x28,%rax mov %rax,0x198(%rsp) xor %eax,%eax test %edi,%edi jle 15f9 <func0+0x3e9> mov %rsp,%rbx mov %edi,%edx xor %esi,%esi mov $0xcccccccd,%r10d mov %rbx,%r11 mov %rbx,%r8 mov %edx,%eax mov %edx,%ebp mov %esi,%r9d add $0x4,%r8 imul %r10,%rax add $0x1,%esi shr $0x23,%rax lea (%rax,%rax,4),%ecx add %ecx,%ecx sub %ecx,%ebp mov %edx,%ecx mov %eax,%edx mov %ebp,-0x4(%r8) cmp $0x9,%ecx jg 1250 <func0+0x40> test %r9d,%r9d je 1513 <func0+0x303> lea -0x1(%r9),%ecx movslq %r9d,%r8 mov %ecx,%edx lea 0x4(,%r8,4),%r8 shr %edx lea 0x1(%rdx),%eax mov %rax,%rdx lea 0x0(,%rax,4),%r10 neg %rax lea (%r8,%rax,4),%rax cmp %rax,%r10 jg 1626 <func0+0x416> cmp $0x5,%ecx jbe 1626 <func0+0x416> lea -0x10(%rbx,%r8,1),%rax movdqa (%rsp),%xmm0 mov %edx,%ecx movdqu (%rax),%xmm3 shr $0x2,%ecx pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm3,%xmm1 movaps %xmm1,(%rsp) movups %xmm0,(%rax) cmp $0x1,%ecx je 14b0 <func0+0x2a0> movdqa 0x10(%rsp),%xmm0 movdqu -0x10(%rax),%xmm4 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm4,%xmm1 movaps %xmm1,0x10(%rsp) movups %xmm0,-0x10(%rax) cmp $0x2,%ecx je 14b0 <func0+0x2a0> movdqa 0x20(%rsp),%xmm0 movdqu -0x20(%rax),%xmm5 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm5,%xmm1 movaps %xmm1,0x20(%rsp) movups %xmm0,-0x20(%rax) cmp $0x3,%ecx je 14b0 <func0+0x2a0> movdqa 0x30(%rsp),%xmm0 movdqu -0x30(%rax),%xmm6 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm6,%xmm1 movaps %xmm1,0x30(%rsp) movups %xmm0,-0x30(%rax) cmp $0x4,%ecx je 14b0 <func0+0x2a0> movdqa 0x40(%rsp),%xmm0 movdqu -0x40(%rax),%xmm7 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm7,%xmm1 movaps %xmm1,0x40(%rsp) movups %xmm0,-0x40(%rax) cmp $0x5,%ecx je 14b0 <func0+0x2a0> movdqa 0x50(%rsp),%xmm0 movdqu -0x50(%rax),%xmm7 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm7,%xmm1 movaps %xmm1,0x50(%rsp) movups %xmm0,-0x50(%rax) cmp $0x6,%ecx je 14b0 <func0+0x2a0> movdqa 0x60(%rsp),%xmm0 movdqu -0x60(%rax),%xmm6 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm6,%xmm1 movaps %xmm1,0x60(%rsp) movups %xmm0,-0x60(%rax) cmp $0x7,%ecx je 14b0 <func0+0x2a0> movdqa 0x70(%rsp),%xmm0 movdqu -0x70(%rax),%xmm5 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm5,%xmm1 movaps %xmm1,0x70(%rsp) movups %xmm0,-0x70(%rax) cmp $0x8,%ecx je 14b0 <func0+0x2a0> movdqa 0x80(%rsp),%xmm0 movdqu -0x80(%rax),%xmm7 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm7,%xmm1 movaps %xmm1,0x80(%rsp) movups %xmm0,-0x80(%rax) cmp $0x9,%ecx je 14b0 <func0+0x2a0> movdqa 0x90(%rsp),%xmm0 movdqu -0x90(%rax),%xmm4 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm4,%xmm1 movaps %xmm1,0x90(%rsp) movups %xmm0,-0x90(%rax) cmp $0xa,%ecx je 14b0 <func0+0x2a0> movdqa 0xa0(%rsp),%xmm0 movdqu -0xa0(%rax),%xmm5 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm5,%xmm1 movaps %xmm1,0xa0(%rsp) movups %xmm0,-0xa0(%rax) cmp $0xc,%ecx jne 14b0 <func0+0x2a0> movdqa 0xb0(%rsp),%xmm0 movdqu -0xb0(%rax),%xmm6 pshufd $0x1b,%xmm0,%xmm0 pshufd $0x1b,%xmm6,%xmm1 movaps %xmm1,0xb0(%rsp) movups %xmm0,-0xb0(%rax) mov %edx,%eax mov %r9d,%ecx and $0xfffffffc,%eax sub %eax,%ecx cmp %eax,%edx je 1513 <func0+0x303> movslq %eax,%r8 movslq %ecx,%rdx mov (%rsp,%r8,4),%r10d mov (%rsp,%rdx,4),%r11d mov %r11d,(%rsp,%r8,4) lea 0x1(%rax),%r8d mov %r10d,(%rsp,%rdx,4) lea -0x1(%rcx),%edx cmp %edx,%r8d jge 1513 <func0+0x303> movslq %r8d,%r8 movslq %edx,%rdx add $0x2,%eax sub $0x2,%ecx mov (%rsp,%r8,4),%r10d mov (%rsp,%rdx,4),%r11d mov %r11d,(%rsp,%r8,4) mov %r10d,(%rsp,%rdx,4) cmp %ecx,%eax jge 1513 <func0+0x303> cltq movslq %ecx,%rcx mov (%rsp,%rax,4),%edx mov (%rsp,%rcx,4),%r8d mov %r8d,(%rsp,%rax,4) mov %edx,(%rsp,%rcx,4) movslq %esi,%rax mov %esi,%ebp mov %esi,%edx lea -0x10(%rbx,%rax,4),%r8 mov %esi,%ebx lea 0x1(%rdx),%r11d and $0xfffffffc,%ebp shr $0x2,%ebx lea 0x1(%rbp),%r12d shl $0x4,%rbx cmp $0x3,%r9d jbe 15f0 <func0+0x3e0> nopl (%rax) mov %r8,%rcx mov %r8,%rax pxor %xmm1,%xmm1 sub %rbx,%rcx nopl (%rax) movdqu (%rax),%xmm2 sub $0x10,%rax pshufd $0x1b,%xmm2,%xmm0 paddd %xmm0,%xmm1 cmp %rax,%rcx jne 1550 <func0+0x340> movdqa %xmm1,%xmm0 mov %r12d,%ecx psrldq $0x8,%xmm0 paddd %xmm0,%xmm1 movdqa %xmm1,%xmm0 psrldq $0x4,%xmm0 paddd %xmm0,%xmm1 movd %xmm1,%eax cmp %esi,%ebp je 15d3 <func0+0x3c3> mov %edx,%r10d sub %ecx,%r10d movslq %r10d,%r10 add (%rsp,%r10,4),%eax lea 0x1(%rcx),%r10d cmp %r9d,%ecx jg 15d3 <func0+0x3c3> mov %edx,%r14d sub %r10d,%r14d movslq %r14d,%r10 add (%rsp,%r10,4),%eax lea 0x2(%rcx),%r10d cmp %esi,%r10d jg 15d3 <func0+0x3c3> mov %edx,%r14d add $0x3,%ecx sub %r10d,%r14d movslq %r14d,%r10 add (%rsp,%r10,4),%eax cmp %esi,%ecx jg 15d3 <func0+0x3c3> sub %ecx,%edx movslq %edx,%rdx add (%rsp,%rdx,4),%eax mov %eax,0x10(%r8) cmp %edi,%eax jge 1600 <func0+0x3f0> mov %r11d,%edx add $0x4,%r8 lea 0x1(%rdx),%r11d cmp $0x3,%r9d ja 1540 <func0+0x330> mov $0x1,%ecx xor %eax,%eax jmp 158b <func0+0x37b> xor %eax,%eax nopl 0x0(%rax,%rax,1) cmp %eax,%edi sete %al mov 0x198(%rsp),%rdi xor %fs:0x28,%rdi jne 1656 <func0+0x446> add $0x1a8,%rsp pop %rbx pop %rbp pop %r12 pop %r14 retq lea -0x4(%rbx,%r8,1),%rdx mov %r9d,%eax xchg %ax,%ax mov (%r11),%ecx mov (%rdx),%r8d sub $0x1,%eax add $0x4,%r11 sub $0x4,%rdx mov %r8d,-0x4(%r11) mov %ecx,0x4(%rdx) mov %r9d,%ecx sub %eax,%ecx cmp %ecx,%eax jg 1630 <func0+0x420> jmpq 1513 <func0+0x303> callq 1060 <__stack_chk_fail@plt> nopl 0x0(%rax,%rax,1)
func0: endbr64 push rbp mov r8d, edi push rbx sub rsp, 1A8h mov rax, fs:28h mov [rsp+1B8h+var_20], rax xor eax, eax test edi, edi jle loc_13AE mov r11, rsp mov esi, edi xor edx, edx mov ebp, 0CCCCCCCDh mov rcx, r11 mov r10, r11 nop dword ptr [rax] loc_1250: mov eax, esi mov ebx, esi mov edi, edx add r10, 4 imul rax, rbp add edx, 1 shr rax, 23h lea r9d, [rax+rax*4] add r9d, r9d sub ebx, r9d mov r9d, esi mov esi, eax mov [r10-4], ebx cmp r9d, 9 jg short loc_1250 test edi, edi jz short loc_12B4 movsxd rax, edi lea rsi, [r11+rax*4] mov eax, edi nop dword ptr [rax+rax+00h] loc_1290: mov r9d, [rcx] mov r10d, [rsi] sub eax, 1 add rcx, 4 sub rsi, 4 mov [rcx-4], r10d mov [rsi+4], r9d mov r9d, edi sub r9d, eax cmp eax, r9d jg short loc_1290 loc_12B4: lea r10d, [rdi+1] movsxd rax, edx mov ebx, r10d lea rsi, [r11+rax*4-10h] mov r11d, r10d and r10d, 3 shr r11d, 2 and ebx, 0FFFFFFFCh shl r11, 4 add ebx, 1 nop dword ptr [rax+rax+00000000h] loc_12E0: cmp edi, 2 jle loc_13A5 mov rcx, rsi mov rax, rsi pxor xmm1, xmm1 sub rcx, r11 nop word ptr [rax+rax+00000000h] loc_1300: movdqu xmm2, xmmword ptr [rax] sub rax, 10h pshufd xmm0, xmm2, 1Bh paddd xmm1, xmm0 cmp rcx, rax jnz short loc_1300 movdqa xmm0, xmm1 mov ecx, ebx psrldq xmm0, 8 paddd xmm1, xmm0 movdqa xmm0, xmm1 psrldq xmm0, 4 paddd xmm1, xmm0 movd eax, xmm1 test r10d, r10d jz short loc_136F loc_133B: mov r9d, edx lea ebp, [rcx+1] sub r9d, ecx movsxd r9, r9d add eax, [rsp+r9*4+1B8h+var_1B8] cmp ecx, edi jg short loc_136F mov r9d, edx add ecx, 2 sub r9d, ebp movsxd r9, r9d add eax, [rsp+r9*4+1B8h+var_1B8] cmp ebp, edi jg short loc_136F mov r9d, edx sub r9d, ecx movsxd rcx, r9d add eax, [rsp+rcx*4+1B8h+var_1B8] loc_136F: mov [rsi+10h], eax add edx, 1 add rsi, 4 cmp r8d, eax jg loc_12E0 loc_1382: cmp r8d, eax setz al mov rdx, [rsp+1B8h+var_20] sub rdx, fs:28h jnz short loc_13B2 add rsp, 1A8h pop rbx pop rbp retn loc_13A5: mov ecx, 1 xor eax, eax jmp short loc_133B loc_13AE: xor eax, eax jmp short loc_1382 loc_13B2: call ___stack_chk_fail
bool func0(int a1) { unsigned int v2; // esi int v3; // edx int *v4; // rcx _DWORD *v5; // r10 int v6; // edi unsigned int v7; // ebx int v8; // r9d int *v9; // rsi int v10; // eax int v11; // r9d int v12; // r10d const __m128i *v13; // rsi const __m128i *v14; // rax __m128i v15; // xmm1 __m128i v16; // xmm2 signed int v17; // ecx __m128i v18; // xmm1 int v19; // eax int v20; // ebp int v21; // ecx _DWORD v23[102]; // [rsp+0h] [rbp-1B8h] BYREF unsigned long long v24; // [rsp+198h] [rbp-20h] v24 = __readfsqword(0x28u); if ( a1 > 0 ) { v2 = a1; v3 = 0; v4 = v23; v5 = v23; do { v6 = v3; ++v5; ++v3; v7 = v2 % 0xA; v8 = v2; v2 /= 0xAu; *(v5 - 1) = v7; } while ( v8 > 9 ); if ( v6 ) { v9 = &v23[v6]; v10 = v6; do { v11 = *v4; v12 = *v9; --v10; ++v4; --v9; *(v4 - 1) = v12; v9[1] = v11; } while ( v10 > v6 - v10 ); } v13 = (const __m128i *)&v23[v3 - 4]; while ( v6 > 2 ) { v14 = v13; v15 = 0LL; do { v16 = _mm_loadu_si128(v14--); v15 = _mm_add_epi32(v15, _mm_shuffle_epi32(v16, 27)); } while ( &v13[-((unsigned int)(v6 + 1) >> 2)] != v14 ); v17 = ((v6 + 1) & 0xFFFFFFFC) + 1; v18 = _mm_add_epi32(v15, _mm_srli_si128(v15, 8)); v19 = _mm_cvtsi128_si32(_mm_add_epi32(v18, _mm_srli_si128(v18, 4))); if ( ((v6 + 1) & 3) != 0 ) goto LABEL_12; LABEL_15: v13[1].m128i_i32[0] = v19; ++v3; v13 = (const __m128i *)((char *)v13 + 4); if ( a1 <= v19 ) return a1 == v19; } v17 = 1; v19 = 0; LABEL_12: v20 = v17 + 1; v19 += v23[v3 - v17]; if ( v17 <= v6 ) { v21 = v17 + 2; v19 += v23[v3 - v20]; if ( v20 <= v6 ) v19 += v23[v3 - v21]; } goto LABEL_15; } v19 = 0; return a1 == v19; }
func0: ENDBR64 PUSH RBP MOV R8D,EDI PUSH RBX SUB RSP,0x1a8 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x198],RAX XOR EAX,EAX TEST EDI,EDI JLE 0x001013ae MOV R11,RSP MOV ESI,EDI XOR EDX,EDX MOV EBP,0xcccccccd MOV RCX,R11 MOV R10,R11 NOP dword ptr [RAX] LAB_00101250: MOV EAX,ESI MOV EBX,ESI MOV EDI,EDX ADD R10,0x4 IMUL RAX,RBP ADD EDX,0x1 SHR RAX,0x23 LEA R9D,[RAX + RAX*0x4] ADD R9D,R9D SUB EBX,R9D MOV R9D,ESI MOV ESI,EAX MOV dword ptr [R10 + -0x4],EBX CMP R9D,0x9 JG 0x00101250 TEST EDI,EDI JZ 0x001012b4 MOVSXD RAX,EDI LEA RSI,[R11 + RAX*0x4] MOV EAX,EDI NOP dword ptr [RAX + RAX*0x1] LAB_00101290: MOV R9D,dword ptr [RCX] MOV R10D,dword ptr [RSI] SUB EAX,0x1 ADD RCX,0x4 SUB RSI,0x4 MOV dword ptr [RCX + -0x4],R10D MOV dword ptr [RSI + 0x4],R9D MOV R9D,EDI SUB R9D,EAX CMP EAX,R9D JG 0x00101290 LAB_001012b4: LEA R10D,[RDI + 0x1] MOVSXD RAX,EDX MOV EBX,R10D LEA RSI,[R11 + RAX*0x4 + -0x10] MOV R11D,R10D AND R10D,0x3 SHR R11D,0x2 AND EBX,0xfffffffc SHL R11,0x4 ADD EBX,0x1 NOP dword ptr [RAX + RAX*0x1] LAB_001012e0: CMP EDI,0x2 JLE 0x001013a5 MOV RCX,RSI MOV RAX,RSI PXOR XMM1,XMM1 SUB RCX,R11 NOP word ptr CS:[RAX + RAX*0x1] LAB_00101300: MOVDQU XMM2,xmmword ptr [RAX] SUB RAX,0x10 PSHUFD XMM0,XMM2,0x1b PADDD XMM1,XMM0 CMP RCX,RAX JNZ 0x00101300 MOVDQA XMM0,XMM1 MOV ECX,EBX PSRLDQ XMM0,0x8 PADDD XMM1,XMM0 MOVDQA XMM0,XMM1 PSRLDQ XMM0,0x4 PADDD XMM1,XMM0 MOVD EAX,XMM1 TEST R10D,R10D JZ 0x0010136f LAB_0010133b: MOV R9D,EDX LEA EBP,[RCX + 0x1] SUB R9D,ECX MOVSXD R9,R9D ADD EAX,dword ptr [RSP + R9*0x4] CMP ECX,EDI JG 0x0010136f MOV R9D,EDX ADD ECX,0x2 SUB R9D,EBP MOVSXD R9,R9D ADD EAX,dword ptr [RSP + R9*0x4] CMP EBP,EDI JG 0x0010136f MOV R9D,EDX SUB R9D,ECX MOVSXD RCX,R9D ADD EAX,dword ptr [RSP + RCX*0x4] LAB_0010136f: MOV dword ptr [RSI + 0x10],EAX ADD EDX,0x1 ADD RSI,0x4 CMP R8D,EAX JG 0x001012e0 LAB_00101382: CMP R8D,EAX SETZ AL MOV RDX,qword ptr [RSP + 0x198] SUB RDX,qword ptr FS:[0x28] JNZ 0x001013b2 ADD RSP,0x1a8 POP RBX POP RBP RET LAB_001013a5: MOV ECX,0x1 XOR EAX,EAX JMP 0x0010133b LAB_001013ae: XOR EAX,EAX JMP 0x00101382 LAB_001013b2: CALL 0x00101060
int8 func0(uint param_1) { ulong uVar1; int iVar2; int *piVar3; int *piVar4; int *piVar5; int iVar6; int *piVar7; ulong uVar8; int *piVar9; int iVar10; int iVar11; uint uVar12; long in_FS_OFFSET; uint uVar13; int iVar14; int iVar15; int iVar16; int aiStack_1c8 [106]; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); if ((int)param_1 < 1) { uVar8 = 0; } else { uVar8 = (ulong)param_1; piVar9 = aiStack_1c8 + 4; iVar11 = 0; do { iVar10 = iVar11; iVar11 = iVar10 + 1; uVar1 = uVar8 / 10; iVar6 = (int)uVar8; uVar8 = uVar8 / 10; *piVar9 = iVar6 + (int)uVar1 * -10; piVar9 = piVar9 + 1; } while (9 < iVar6); if (iVar10 != 0) { piVar9 = aiStack_1c8 + 4; piVar7 = aiStack_1c8 + (long)iVar10 + 4; iVar6 = iVar10; do { iVar14 = *piVar9; iVar6 = iVar6 + -1; *piVar9 = *piVar7; *piVar7 = iVar14; piVar9 = piVar9 + 1; piVar7 = piVar7 + -1; } while (iVar10 - iVar6 < iVar6); } uVar12 = iVar10 + 1; piVar9 = aiStack_1c8 + iVar11; do { if (iVar10 < 3) { iVar6 = 1; uVar13 = 0; LAB_0010133b: uVar8 = (ulong)(uVar13 + aiStack_1c8[(long)(iVar11 - iVar6) + 4]); if (iVar6 <= iVar10) { uVar13 = uVar13 + aiStack_1c8[(long)(iVar11 - iVar6) + 4] + aiStack_1c8[(long)(iVar11 - (iVar6 + 1)) + 4]; uVar8 = (ulong)uVar13; if (iVar6 + 1 <= iVar10) { uVar8 = (ulong)(uVar13 + aiStack_1c8[(long)(iVar11 - (iVar6 + 2)) + 4]); } } } else { iVar6 = 0; iVar14 = 0; iVar15 = 0; iVar16 = 0; piVar7 = piVar9; do { iVar2 = *piVar7; piVar3 = piVar7 + 1; piVar4 = piVar7 + 2; piVar5 = piVar7 + 3; piVar7 = piVar7 + -4; iVar6 = iVar6 + *piVar5; iVar14 = iVar14 + *piVar4; iVar15 = iVar15 + *piVar3; iVar16 = iVar16 + iVar2; } while (piVar9 + (ulong)(uVar12 >> 2) * -4 != piVar7); uVar13 = iVar6 + iVar15 + iVar14 + iVar16; uVar8 = (ulong)uVar13; iVar6 = (uVar12 & 0xfffffffc) + 1; if ((uVar12 & 3) != 0) goto LAB_0010133b; } piVar9[4] = (int)uVar8; iVar11 = iVar11 + 1; piVar9 = piVar9 + 1; } while ((int)uVar8 < (int)param_1); } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return CONCAT71((int7)(uVar8 >> 8),param_1 == (uint)uVar8); } aiStack_1c8[2] = 0x1013b7; aiStack_1c8[3] = 0; /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,612
func0
#include <math.h> #include <assert.h>
double func0(double slat, double slon, double elat, double elon) { double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon)); return dist; }
int main() { assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429); assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514); assert(func0(10, 20, 30, 40) == 6783.751974994595); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x40,%rsp movsd %xmm0,-0x18(%rbp) movsd %xmm1,-0x20(%rbp) movsd %xmm2,-0x28(%rbp) movsd %xmm3,-0x30(%rbp) mov -0x18(%rbp),%rax movq %rax,%xmm0 callq 10b0 <sin@plt> movsd %xmm0,-0x38(%rbp) mov -0x28(%rbp),%rax movq %rax,%xmm0 callq 10b0 <sin@plt> movapd %xmm0,%xmm4 mulsd -0x38(%rbp),%xmm4 movsd %xmm4,-0x38(%rbp) mov -0x18(%rbp),%rax movq %rax,%xmm0 callq 1090 <cos@plt> movsd %xmm0,-0x40(%rbp) mov -0x28(%rbp),%rax movq %rax,%xmm0 callq 1090 <cos@plt> movapd %xmm0,%xmm5 mulsd -0x40(%rbp),%xmm5 movsd %xmm5,-0x40(%rbp) movsd -0x20(%rbp),%xmm0 subsd -0x30(%rbp),%xmm0 callq 1090 <cos@plt> mulsd -0x40(%rbp),%xmm0 addsd -0x38(%rbp),%xmm0 callq 10a0 <acos@plt> movsd 0xe9b(%rip),%xmm1 mulsd %xmm1,%xmm0 movsd %xmm0,-0x8(%rbp) movsd -0x8(%rbp),%xmm0 leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 40h movsd [rbp+x], xmm0 movsd [rbp+var_20], xmm1 movsd [rbp+var_28], xmm2 movsd [rbp+var_30], xmm3 mov rax, [rbp+x] movq xmm0, rax; x call _sin movsd [rbp+var_38], xmm0 mov rax, [rbp+var_28] movq xmm0, rax; x call _sin movapd xmm4, xmm0 mulsd xmm4, [rbp+var_38] movsd [rbp+var_38], xmm4 mov rax, [rbp+x] movq xmm0, rax; x call _cos movsd [rbp+var_40], xmm0 mov rax, [rbp+var_28] movq xmm0, rax; x call _cos movapd xmm5, xmm0 mulsd xmm5, [rbp+var_40] movsd [rbp+var_40], xmm5 movsd xmm0, [rbp+var_20] subsd xmm0, [rbp+var_30] movq rax, xmm0 movq xmm0, rax; x call _cos mulsd xmm0, [rbp+var_40] addsd xmm0, [rbp+var_38] movq rax, xmm0 movq xmm0, rax; x call _acos movsd xmm1, cs:qword_20C8 mulsd xmm0, xmm1 movsd [rbp+var_8], xmm0 movsd xmm0, [rbp+var_8] leave retn
double func0(double a1, double a2, double a3, double a4) { double v4; // xmm0_8 double v6; // [rsp+0h] [rbp-40h] double v7; // [rsp+0h] [rbp-40h] double v8; // [rsp+8h] [rbp-38h] double v9; // [rsp+8h] [rbp-38h] v8 = sin(a1); v9 = sin(a3) * v8; v6 = cos(a1); v7 = cos(a3) * v6; v4 = cos(a2 - a4); return acos(v4 * v7 + v9) * 6371.01; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x40 MOVSD qword ptr [RBP + -0x18],XMM0 MOVSD qword ptr [RBP + -0x20],XMM1 MOVSD qword ptr [RBP + -0x28],XMM2 MOVSD qword ptr [RBP + -0x30],XMM3 MOV RAX,qword ptr [RBP + -0x18] MOVQ XMM0,RAX CALL 0x001010b0 MOVSD qword ptr [RBP + -0x38],XMM0 MOV RAX,qword ptr [RBP + -0x28] MOVQ XMM0,RAX CALL 0x001010b0 MOVAPD XMM4,XMM0 MULSD XMM4,qword ptr [RBP + -0x38] MOVSD qword ptr [RBP + -0x38],XMM4 MOV RAX,qword ptr [RBP + -0x18] MOVQ XMM0,RAX CALL 0x00101090 MOVSD qword ptr [RBP + -0x40],XMM0 MOV RAX,qword ptr [RBP + -0x28] MOVQ XMM0,RAX CALL 0x00101090 MOVAPD XMM5,XMM0 MULSD XMM5,qword ptr [RBP + -0x40] MOVSD qword ptr [RBP + -0x40],XMM5 MOVSD XMM0,qword ptr [RBP + -0x20] SUBSD XMM0,qword ptr [RBP + -0x30] MOVQ RAX,XMM0 MOVQ XMM0,RAX CALL 0x00101090 MULSD XMM0,qword ptr [RBP + -0x40] ADDSD XMM0,qword ptr [RBP + -0x38] MOVQ RAX,XMM0 MOVQ XMM0,RAX CALL 0x001010a0 MOVSD XMM1,qword ptr [0x001020c8] MULSD XMM0,XMM1 MOVSD qword ptr [RBP + -0x8],XMM0 MOVSD XMM0,qword ptr [RBP + -0x8] LEAVE RET
double func0(double param_1,double param_2,double param_3,double param_4) { double dVar1; double dVar2; double dVar3; double dVar4; double dVar5; dVar1 = sin(param_1); dVar2 = sin(param_3); dVar3 = cos(param_1); dVar4 = cos(param_3); dVar5 = cos(param_2 - param_4); dVar1 = acos(dVar5 * dVar4 * dVar3 + dVar2 * dVar1); return dVar1 * DAT_001020c8; }
4,613
func0
#include <math.h> #include <assert.h>
double func0(double slat, double slon, double elat, double elon) { double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon)); return dist; }
int main() { assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429); assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514); assert(func0(10, 20, 30, 40) == 6783.751974994595); return 0; }
O1
c
func0: endbr64 push %r13 push %r12 push %rbp push %rbx sub $0x38,%rsp movsd %xmm0,0x8(%rsp) movsd %xmm1,0x10(%rsp) movapd %xmm2,%xmm0 movsd %xmm3,0x18(%rsp) lea 0x28(%rsp),%r12 lea 0x20(%rsp),%r13 mov %r13,%rsi mov %r12,%rdi callq 1090 <sincos@plt> mov 0x20(%rsp),%rbx mov 0x28(%rsp),%rbp mov %r13,%rsi mov %r12,%rdi movsd 0x8(%rsp),%xmm0 callq 1090 <sincos@plt> movsd 0x10(%rsp),%xmm0 subsd 0x18(%rsp),%xmm0 callq 10a0 <cos@plt> movapd %xmm0,%xmm1 movq %rbx,%xmm0 mulsd 0x20(%rsp),%xmm0 mulsd %xmm1,%xmm0 movq %rbp,%xmm1 mulsd 0x28(%rsp),%xmm1 addsd %xmm1,%xmm0 callq 10b0 <acos@plt> mulsd 0xeab(%rip),%xmm0 add $0x38,%rsp pop %rbx pop %rbp pop %r12 pop %r13 retq
func0: endbr64 push r15 push r14 push r13 push r12 push rbp push rbx sub rsp, 28h movq r13, xmm0 movq rbp, xmm1 movapd xmm0, xmm2 movsd [rsp+58h+var_50], xmm3 lea r14, [rsp+58h+var_40] lea r15, [rsp+58h+var_48] mov rsi, r15 mov rdi, r14 call _sincos mov rbx, [rsp+58h+var_48] mov r12, [rsp+58h+var_40] mov rsi, r15 mov rdi, r14 movq xmm0, r13 call _sincos movq xmm0, rbp subsd xmm0, [rsp+58h+var_50] call _cos movapd xmm1, xmm0 movq xmm0, rbx mulsd xmm0, [rsp+58h+var_48] mulsd xmm0, xmm1 movq xmm1, r12 mulsd xmm1, [rsp+58h+var_40] addsd xmm0, xmm1 call _acos mulsd xmm0, cs:qword_20C8 add rsp, 28h pop rbx pop rbp pop r12 pop r13 pop r14 pop r15 retn
double func0(double a1, double a2, double a3, double a4) { double v4; // rbx double v5; // r12 double v6; // xmm1_8 double v8; // [rsp+10h] [rbp-48h] BYREF double v9[8]; // [rsp+18h] [rbp-40h] BYREF sincos(v9, &v8, a3); v4 = v8; v5 = v9[0]; sincos(v9, &v8, a1); v6 = cos(a2 - a4); return acos(v4 * v8 * v6 + v5 * v9[0]) * 6371.01; }
func0: ENDBR64 PUSH R15 PUSH R14 PUSH R13 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x28 MOVQ R13,XMM0 MOVQ RBP,XMM1 MOVAPD XMM0,XMM2 MOVSD qword ptr [RSP + 0x8],XMM3 LEA R14,[RSP + 0x18] LEA R15,[RSP + 0x10] MOV RSI,R15 MOV RDI,R14 CALL 0x00101090 MOV RBX,qword ptr [RSP + 0x10] MOV R12,qword ptr [RSP + 0x18] MOV RSI,R15 MOV RDI,R14 MOVQ XMM0,R13 CALL 0x00101090 MOVQ XMM0,RBP SUBSD XMM0,qword ptr [RSP + 0x8] CALL 0x001010a0 MOVAPD XMM1,XMM0 MOVQ XMM0,RBX MULSD XMM0,qword ptr [RSP + 0x10] MULSD XMM0,XMM1 MOVQ XMM1,R12 MULSD XMM1,qword ptr [RSP + 0x18] ADDSD XMM0,XMM1 CALL 0x001010b0 MULSD XMM0,qword ptr [0x001020c8] ADD RSP,0x28 POP RBX POP RBP POP R12 POP R13 POP R14 POP R15 RET
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ double func0(double param_1,double param_2,double param_3,double param_4) { double dVar1; double dVar2; double dVar3; double local_48; double local_40 [2]; sincos(param_3,local_40,&local_48); dVar1 = local_40[0]; dVar3 = local_48; sincos(param_1,local_40,&local_48); dVar2 = cos(param_2 - param_4); dVar3 = acos(dVar3 * local_48 * dVar2 + dVar1 * local_40[0]); return dVar3 * _DAT_001020c8; }
4,614
func0
#include <math.h> #include <assert.h>
double func0(double slat, double slon, double elat, double elon) { double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon)); return dist; }
int main() { assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429); assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514); assert(func0(10, 20, 30, 40) == 6783.751974994595); return 0; }
O2
c
func0: endbr64 push %r12 push %rbp sub $0x48,%rsp lea 0x38(%rsp),%rbp lea 0x30(%rsp),%r12 movsd %xmm0,0x28(%rsp) movapd %xmm2,%xmm0 mov %r12,%rsi mov %rbp,%rdi movsd %xmm1,0x20(%rsp) movsd %xmm3,0x8(%rsp) callq 1090 <sincos@plt> movsd 0x28(%rsp),%xmm4 mov %r12,%rsi mov %rbp,%rdi movsd 0x30(%rsp),%xmm2 movsd 0x38(%rsp),%xmm3 movapd %xmm4,%xmm0 movsd %xmm2,0x18(%rsp) movsd %xmm3,0x10(%rsp) callq 1090 <sincos@plt> movsd 0x20(%rsp),%xmm1 subsd 0x8(%rsp),%xmm1 movapd %xmm1,%xmm0 callq 10a0 <cos@plt> movsd 0x18(%rsp),%xmm2 mulsd 0x30(%rsp),%xmm2 movsd 0x10(%rsp),%xmm3 mulsd 0x38(%rsp),%xmm3 mulsd %xmm0,%xmm2 movapd %xmm3,%xmm0 addsd %xmm2,%xmm0 callq 10b0 <acos@plt> mulsd 0xd8f(%rip),%xmm0 add $0x48,%rsp pop %rbp pop %r12 retq nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax,%rax,1)
func0: endbr64 push r12 push rbp sub rsp, 48h lea rbp, [rsp+58h+var_20] lea r12, [rsp+58h+var_28] movsd [rsp+58h+var_30], xmm0 movapd xmm0, xmm2 mov rsi, r12 mov rdi, rbp movsd [rsp+58h+var_38], xmm1 movsd [rsp+58h+var_50], xmm3 call _sincos movsd xmm4, [rsp+58h+var_30] mov rsi, r12 mov rdi, rbp movsd xmm2, [rsp+58h+var_28] movsd xmm3, [rsp+58h+var_20] movapd xmm0, xmm4 movsd [rsp+58h+var_40], xmm2 movsd [rsp+58h+var_48], xmm3 call _sincos movsd xmm1, [rsp+58h+var_38] subsd xmm1, [rsp+58h+var_50] movapd xmm0, xmm1 call _cos movsd xmm2, [rsp+58h+var_40] mulsd xmm2, [rsp+58h+var_28] movapd xmm1, xmm0 movsd xmm3, [rsp+58h+var_48] mulsd xmm3, [rsp+58h+var_20] movapd xmm0, xmm2 mulsd xmm0, xmm1 addsd xmm0, xmm3 call _acos mulsd xmm0, cs:qword_20C8 add rsp, 48h pop rbp pop r12 retn
double func0(double a1, double a2, double a3, double a4) { double v4; // xmm0_8 double v6; // [rsp+10h] [rbp-48h] double v7; // [rsp+18h] [rbp-40h] double v8; // [rsp+30h] [rbp-28h] BYREF double v9[4]; // [rsp+38h] [rbp-20h] BYREF sincos(v9, &v8, a3); v7 = v8; v6 = v9[0]; sincos(v9, &v8, a1); v4 = cos(a2 - a4); return acos(v7 * v8 * v4 + v6 * v9[0]) * 6371.01; }
func0: ENDBR64 PUSH R12 PUSH RBP SUB RSP,0x48 LEA RBP,[RSP + 0x38] LEA R12,[RSP + 0x30] MOVSD qword ptr [RSP + 0x28],XMM0 MOVAPD XMM0,XMM2 MOV RSI,R12 MOV RDI,RBP MOVSD qword ptr [RSP + 0x20],XMM1 MOVSD qword ptr [RSP + 0x8],XMM3 CALL 0x00101090 MOVSD XMM4,qword ptr [RSP + 0x28] MOV RSI,R12 MOV RDI,RBP MOVSD XMM2,qword ptr [RSP + 0x30] MOVSD XMM3,qword ptr [RSP + 0x38] MOVAPD XMM0,XMM4 MOVSD qword ptr [RSP + 0x18],XMM2 MOVSD qword ptr [RSP + 0x10],XMM3 CALL 0x00101090 MOVSD XMM1,qword ptr [RSP + 0x20] SUBSD XMM1,qword ptr [RSP + 0x8] MOVAPD XMM0,XMM1 CALL 0x001010a0 MOVSD XMM2,qword ptr [RSP + 0x18] MULSD XMM2,qword ptr [RSP + 0x30] MOVAPD XMM1,XMM0 MOVSD XMM3,qword ptr [RSP + 0x10] MULSD XMM3,qword ptr [RSP + 0x38] MOVAPD XMM0,XMM2 MULSD XMM0,XMM1 ADDSD XMM0,XMM3 CALL 0x001010b0 MULSD XMM0,qword ptr [0x001020c8] ADD RSP,0x48 POP RBP POP R12 RET
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ double func0(double param_1,double param_2,double param_3,double param_4) { double dVar1; double dVar2; double dVar3; double local_28; double local_20 [2]; sincos(param_3,local_20,&local_28); dVar1 = local_20[0]; dVar3 = local_28; sincos(param_1,local_20,&local_28); dVar2 = cos(param_2 - param_4); dVar3 = acos(dVar3 * local_28 * dVar2 + dVar1 * local_20[0]); return dVar3 * _DAT_001020c8; }
4,615
func0
#include <math.h> #include <assert.h>
double func0(double slat, double slon, double elat, double elon) { double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon)); return dist; }
int main() { assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429); assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514); assert(func0(10, 20, 30, 40) == 6783.751974994595); return 0; }
O3
c
func0: endbr64 push %r12 push %rbp sub $0x48,%rsp lea 0x38(%rsp),%rbp lea 0x30(%rsp),%r12 movsd %xmm0,0x28(%rsp) movapd %xmm2,%xmm0 mov %r12,%rsi mov %rbp,%rdi movsd %xmm1,0x20(%rsp) movsd %xmm3,0x8(%rsp) callq 1090 <sincos@plt> movsd 0x28(%rsp),%xmm4 mov %r12,%rsi mov %rbp,%rdi movsd 0x30(%rsp),%xmm2 movsd 0x38(%rsp),%xmm3 movapd %xmm4,%xmm0 movsd %xmm2,0x18(%rsp) movsd %xmm3,0x10(%rsp) callq 1090 <sincos@plt> movsd 0x20(%rsp),%xmm1 subsd 0x8(%rsp),%xmm1 movapd %xmm1,%xmm0 callq 10a0 <cos@plt> movsd 0x18(%rsp),%xmm2 mulsd 0x30(%rsp),%xmm2 movsd 0x10(%rsp),%xmm3 mulsd 0x38(%rsp),%xmm3 mulsd %xmm0,%xmm2 movapd %xmm3,%xmm0 addsd %xmm2,%xmm0 callq 10b0 <acos@plt> mulsd 0xd8f(%rip),%xmm0 add $0x48,%rsp pop %rbp pop %r12 retq nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax,%rax,1)
func0: endbr64 push r14 movq r14, xmm0 movapd xmm0, xmm2; x push rbp push rbx sub rsp, 30h lea rbx, [rsp+48h+sinx] lea rbp, [rsp+48h+cosx] movsd [rsp+48h+var_30], xmm1 mov rsi, rbp; cosx mov rdi, rbx; sinx movsd [rsp+48h+var_48], xmm3 call _sincos mov rsi, rbp; cosx mov rdi, rbx; sinx movq xmm0, r14; x movsd xmm2, [rsp+48h+cosx] movsd xmm3, [rsp+48h+sinx] movsd [rsp+48h+var_38], xmm2 movsd [rsp+48h+var_40], xmm3 call _sincos movsd xmm1, [rsp+48h+var_30] subsd xmm1, [rsp+48h+var_48] movapd xmm0, xmm1; x call _cos movsd xmm2, [rsp+48h+var_38] mulsd xmm2, [rsp+48h+cosx] movapd xmm1, xmm0 movsd xmm3, [rsp+48h+var_40] mulsd xmm3, [rsp+48h+sinx] movapd xmm0, xmm2 mulsd xmm0, xmm1 addsd xmm0, xmm3; x call _acos mulsd xmm0, cs:qword_20C8 add rsp, 30h pop rbx pop rbp pop r14 retn
double func0(double a1, double a2, double a3, double a4) { double v4; // xmm0_8 double v6; // [rsp+8h] [rbp-40h] double v7; // [rsp+10h] [rbp-38h] double cosx; // [rsp+20h] [rbp-28h] BYREF double sinx[4]; // [rsp+28h] [rbp-20h] BYREF sincos(a3, sinx, &cosx); v7 = cosx; v6 = sinx[0]; sincos(a1, sinx, &cosx); v4 = cos(a2 - a4); return acos(v7 * cosx * v4 + v6 * sinx[0]) * 6371.01; }
func0: ENDBR64 PUSH R14 MOVQ R14,XMM0 MOVAPD XMM0,XMM2 PUSH RBP PUSH RBX SUB RSP,0x30 LEA RBX,[RSP + 0x28] LEA RBP,[RSP + 0x20] MOVSD qword ptr [RSP + 0x18],XMM1 MOV RSI,RBP MOV RDI,RBX MOVSD qword ptr [RSP],XMM3 CALL 0x00101090 MOV RSI,RBP MOV RDI,RBX MOVQ XMM0,R14 MOVSD XMM2,qword ptr [RSP + 0x20] MOVSD XMM3,qword ptr [RSP + 0x28] MOVSD qword ptr [RSP + 0x10],XMM2 MOVSD qword ptr [RSP + 0x8],XMM3 CALL 0x00101090 MOVSD XMM1,qword ptr [RSP + 0x18] SUBSD XMM1,qword ptr [RSP] MOVAPD XMM0,XMM1 CALL 0x001010a0 MOVSD XMM2,qword ptr [RSP + 0x10] MULSD XMM2,qword ptr [RSP + 0x20] MOVAPD XMM1,XMM0 MOVSD XMM3,qword ptr [RSP + 0x8] MULSD XMM3,qword ptr [RSP + 0x28] MOVAPD XMM0,XMM2 MULSD XMM0,XMM1 ADDSD XMM0,XMM3 CALL 0x001010b0 MULSD XMM0,qword ptr [0x001020c8] ADD RSP,0x30 POP RBX POP RBP POP R14 RET
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ double func0(double param_1,double param_2,double param_3,double param_4) { double dVar1; double dVar2; double dVar3; double local_28; double local_20; sincos(param_3,&local_20,&local_28); dVar1 = local_20; dVar3 = local_28; sincos(param_1,&local_20,&local_28); dVar2 = cos(param_2 - param_4); dVar3 = acos(dVar3 * local_28 * dVar2 + dVar1 * local_20); return dVar3 * _DAT_001020c8; }
4,616
func0
#include <assert.h> #include <string.h> #include <stdlib.h>
char* func0(char *arr[], int n) { if (n == 0) return ""; char *prefix = strdup(arr[0]); for (int i = 1; i < n; i++) { int j = 0; while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) { j++; } prefix[j] = '\0'; } return prefix; }
int main() { char *arr1[] = {"tablets", "tables", "taxi", "tamarind"}; assert(strcmp(func0(arr1, 4), "ta") == 0); char *arr2[] = {"apples", "ape", "april"}; assert(strcmp(func0(arr2, 3), "ap") == 0); char *arr3[] = {"teens", "teenager", "teenmar"}; assert(strcmp(func0(arr3, 3), "teen") == 0); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x20,%rsp mov %rdi,-0x18(%rbp) mov %esi,-0x1c(%rbp) cmpl $0x0,-0x1c(%rbp) jne 11ce <func0+0x25> lea 0xe3f(%rip),%rax jmpq 128e <func0+0xe5> mov -0x18(%rbp),%rax mov (%rax),%rax mov %rax,%rdi callq 10b0 <strdup@plt> mov %rax,-0x8(%rbp) movl $0x1,-0x10(%rbp) jmpq 127e <func0+0xd5> movl $0x0,-0xc(%rbp) jmp 11fa <func0+0x51> addl $0x1,-0xc(%rbp) mov -0xc(%rbp),%eax movslq %eax,%rdx mov -0x8(%rbp),%rax add %rdx,%rax movzbl (%rax),%eax test %al,%al je 126a <func0+0xc1> mov -0x10(%rbp),%eax cltq lea 0x0(,%rax,8),%rdx mov -0x18(%rbp),%rax add %rdx,%rax mov (%rax),%rdx mov -0xc(%rbp),%eax cltq add %rdx,%rax movzbl (%rax),%eax test %al,%al je 126a <func0+0xc1> mov -0xc(%rbp),%eax movslq %eax,%rdx mov -0x8(%rbp),%rax add %rdx,%rax movzbl (%rax),%edx mov -0x10(%rbp),%eax cltq lea 0x0(,%rax,8),%rcx mov -0x18(%rbp),%rax add %rcx,%rax mov (%rax),%rcx mov -0xc(%rbp),%eax cltq add %rcx,%rax movzbl (%rax),%eax cmp %al,%dl je 11f6 <func0+0x4d> mov -0xc(%rbp),%eax movslq %eax,%rdx mov -0x8(%rbp),%rax add %rdx,%rax movb $0x0,(%rax) addl $0x1,-0x10(%rbp) mov -0x10(%rbp),%eax cmp -0x1c(%rbp),%eax jl 11ed <func0+0x44> mov -0x8(%rbp),%rax leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 20h mov [rbp+var_18], rdi mov [rbp+var_1C], esi cmp [rbp+var_1C], 0 jnz short loc_11CE lea rax, unk_2008 jmp locret_128E loc_11CE: mov rax, [rbp+var_18] mov rax, [rax] mov rdi, rax; s call _strdup mov [rbp+var_8], rax mov [rbp+var_10], 1 jmp loc_127E loc_11ED: mov [rbp+var_C], 0 jmp short loc_11FA loc_11F6: add [rbp+var_C], 1 loc_11FA: mov eax, [rbp+var_C] movsxd rdx, eax mov rax, [rbp+var_8] add rax, rdx movzx eax, byte ptr [rax] test al, al jz short loc_126A mov eax, [rbp+var_10] cdqe lea rdx, ds:0[rax*8] mov rax, [rbp+var_18] add rax, rdx mov rdx, [rax] mov eax, [rbp+var_C] cdqe add rax, rdx movzx eax, byte ptr [rax] test al, al jz short loc_126A mov eax, [rbp+var_C] movsxd rdx, eax mov rax, [rbp+var_8] add rax, rdx movzx edx, byte ptr [rax] mov eax, [rbp+var_10] cdqe lea rcx, ds:0[rax*8] mov rax, [rbp+var_18] add rax, rcx mov rcx, [rax] mov eax, [rbp+var_C] cdqe add rax, rcx movzx eax, byte ptr [rax] cmp dl, al jz short loc_11F6 loc_126A: mov eax, [rbp+var_C] movsxd rdx, eax mov rax, [rbp+var_8] add rax, rdx mov byte ptr [rax], 0 add [rbp+var_10], 1 loc_127E: mov eax, [rbp+var_10] cmp eax, [rbp+var_1C] jl loc_11ED mov rax, [rbp+var_8] locret_128E: leave retn
char * func0(const char **a1, int a2) { int i; // [rsp+10h] [rbp-10h] int j; // [rsp+14h] [rbp-Ch] char *v5; // [rsp+18h] [rbp-8h] if ( !a2 ) return (char *)&unk_2008; v5 = strdup(*a1); for ( i = 1; i < a2; ++i ) { for ( j = 0; v5[j] && a1[i][j] && v5[j] == a1[i][j]; ++j ) ; v5[j] = 0; } return v5; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x20 MOV qword ptr [RBP + -0x18],RDI MOV dword ptr [RBP + -0x1c],ESI CMP dword ptr [RBP + -0x1c],0x0 JNZ 0x001011ce LEA RAX,[0x102008] JMP 0x0010128e LAB_001011ce: MOV RAX,qword ptr [RBP + -0x18] MOV RAX,qword ptr [RAX] MOV RDI,RAX CALL 0x001010b0 MOV qword ptr [RBP + -0x8],RAX MOV dword ptr [RBP + -0x10],0x1 JMP 0x0010127e LAB_001011ed: MOV dword ptr [RBP + -0xc],0x0 JMP 0x001011fa LAB_001011f6: ADD dword ptr [RBP + -0xc],0x1 LAB_001011fa: MOV EAX,dword ptr [RBP + -0xc] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x8] ADD RAX,RDX MOVZX EAX,byte ptr [RAX] TEST AL,AL JZ 0x0010126a MOV EAX,dword ptr [RBP + -0x10] CDQE LEA RDX,[RAX*0x8] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOV RDX,qword ptr [RAX] MOV EAX,dword ptr [RBP + -0xc] CDQE ADD RAX,RDX MOVZX EAX,byte ptr [RAX] TEST AL,AL JZ 0x0010126a MOV EAX,dword ptr [RBP + -0xc] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x8] ADD RAX,RDX MOVZX EDX,byte ptr [RAX] MOV EAX,dword ptr [RBP + -0x10] CDQE LEA RCX,[RAX*0x8] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RCX MOV RCX,qword ptr [RAX] MOV EAX,dword ptr [RBP + -0xc] CDQE ADD RAX,RCX MOVZX EAX,byte ptr [RAX] CMP DL,AL JZ 0x001011f6 LAB_0010126a: MOV EAX,dword ptr [RBP + -0xc] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x8] ADD RAX,RDX MOV byte ptr [RAX],0x0 ADD dword ptr [RBP + -0x10],0x1 LAB_0010127e: MOV EAX,dword ptr [RBP + -0x10] CMP EAX,dword ptr [RBP + -0x1c] JL 0x001011ed MOV RAX,qword ptr [RBP + -0x8] LAB_0010128e: LEAVE RET
char * func0(int8 *param_1,int param_2) { char *pcVar1; int local_18; int local_14; if (param_2 == 0) { pcVar1 = ""; } else { pcVar1 = strdup((char *)*param_1); for (local_18 = 1; local_18 < param_2; local_18 = local_18 + 1) { for (local_14 = 0; ((pcVar1[local_14] != '\0' && (*(char *)((long)local_14 + param_1[local_18]) != '\0')) && (pcVar1[local_14] == *(char *)((long)local_14 + param_1[local_18]))); local_14 = local_14 + 1) { } pcVar1[local_14] = '\0'; } } return pcVar1; }
4,617
func0
#include <assert.h> #include <string.h> #include <stdlib.h>
char* func0(char *arr[], int n) { if (n == 0) return ""; char *prefix = strdup(arr[0]); for (int i = 1; i < n; i++) { int j = 0; while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) { j++; } prefix[j] = '\0'; } return prefix; }
int main() { char *arr1[] = {"tablets", "tables", "taxi", "tamarind"}; assert(strcmp(func0(arr1, 4), "ta") == 0); char *arr2[] = {"apples", "ape", "april"}; assert(strcmp(func0(arr2, 3), "ap") == 0); char *arr3[] = {"teens", "teenager", "teenmar"}; assert(strcmp(func0(arr3, 3), "teen") == 0); return 0; }
O1
c
func0: endbr64 lea 0xe8f(%rip),%rax test %esi,%esi jne 1199 <func0+0x10> retq push %rbp push %rbx sub $0x8,%rsp mov %rdi,%rbp mov %esi,%ebx mov (%rdi),%rdi callq 1090 <strdup@plt> cmp $0x1,%ebx jle 11f9 <func0+0x70> lea 0x8(%rbp),%r8 lea -0x2(%rbx),%edx lea 0x10(%rbp,%rdx,8),%r9 jmp 11ce <func0+0x45> mov %rax,%rcx movb $0x0,(%rcx) add $0x8,%r8 cmp %r9,%r8 je 11f9 <func0+0x70> movzbl (%rax),%edx test %dl,%dl je 11bf <func0+0x36> mov (%r8),%rdi mov %rax,%rcx movzbl (%rdi),%esi cmp %dl,%sil jne 11c2 <func0+0x39> test %sil,%sil je 11c2 <func0+0x39> add $0x1,%rcx movzbl (%rcx),%edx add $0x1,%rdi test %dl,%dl jne 11db <func0+0x52> jmp 11c2 <func0+0x39> add $0x8,%rsp pop %rbx pop %rbp retq
func0: endbr64 lea rax, aTa+2; "" test esi, esi jnz short loc_11B9 retn loc_11B9: push rbp push rbx sub rsp, 8 mov rbp, rdi mov ebx, esi mov rdi, [rdi] call _strdup cmp ebx, 1 jle short loc_1219 lea r8, [rbp+8] lea edx, [rbx-2] lea r9, [rbp+rdx*8+10h] jmp short loc_11EE loc_11DF: mov rcx, rax loc_11E2: mov byte ptr [rcx], 0 add r8, 8 cmp r8, r9 jz short loc_1219 loc_11EE: movzx edx, byte ptr [rax] test dl, dl jz short loc_11DF mov rdi, [r8] mov rcx, rax loc_11FB: movzx esi, byte ptr [rdi] cmp sil, dl jnz short loc_11E2 test sil, sil jz short loc_11E2 add rcx, 1 movzx edx, byte ptr [rcx] add rdi, 1 test dl, dl jnz short loc_11FB jmp short loc_11E2 loc_1219: add rsp, 8 pop rbx pop rbp retn
char * func0(_QWORD *a1, int a2) { char *result; // rax _BYTE **v3; // r8 long long v4; // r9 char *v5; // rcx char v6; // dl _BYTE *v7; // rdi result = ""; if ( a2 ) { result = (char *)strdup(*a1); if ( a2 > 1 ) { v3 = (_BYTE **)(a1 + 1); v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2]; do { v6 = *result; if ( *result ) { v7 = *v3; v5 = result; do { if ( *v7 != v6 ) break; if ( !*v7 ) break; v6 = *++v5; ++v7; } while ( *v5 ); } else { v5 = result; } *v5 = 0; ++v3; } while ( v3 != (_BYTE **)v4 ); } } return result; }
func0: ENDBR64 LEA RAX,[0x102023] TEST ESI,ESI JNZ 0x001011b9 RET LAB_001011b9: PUSH RBP PUSH RBX SUB RSP,0x8 MOV RBP,RDI MOV EBX,ESI MOV RDI,qword ptr [RDI] CALL 0x001010b0 CMP EBX,0x1 JLE 0x00101219 LEA R8,[RBP + 0x8] LEA EDX,[RBX + -0x2] LEA R9,[RBP + RDX*0x8 + 0x10] JMP 0x001011ee LAB_001011df: MOV RCX,RAX LAB_001011e2: MOV byte ptr [RCX],0x0 ADD R8,0x8 CMP R8,R9 JZ 0x00101219 LAB_001011ee: MOVZX EDX,byte ptr [RAX] TEST DL,DL JZ 0x001011df MOV RDI,qword ptr [R8] MOV RCX,RAX LAB_001011fb: MOVZX ESI,byte ptr [RDI] CMP SIL,DL JNZ 0x001011e2 TEST SIL,SIL JZ 0x001011e2 ADD RCX,0x1 MOVZX EDX,byte ptr [RCX] ADD RDI,0x1 TEST DL,DL JNZ 0x001011fb JMP 0x001011e2 LAB_00101219: ADD RSP,0x8 POP RBX POP RBP RET
char * func0(int8 *param_1,int param_2) { char *pcVar1; char *pcVar2; char cVar3; char *pcVar4; int8 *puVar5; if (param_2 == 0) { return ""; } pcVar1 = strdup((char *)*param_1); if (1 < param_2) { puVar5 = param_1 + 1; do { cVar3 = *pcVar1; pcVar2 = pcVar1; if (cVar3 != '\0') { pcVar4 = (char *)*puVar5; do { if ((*pcVar4 != cVar3) || (*pcVar4 == '\0')) break; pcVar2 = pcVar2 + 1; cVar3 = *pcVar2; pcVar4 = pcVar4 + 1; } while (cVar3 != '\0'); } *pcVar2 = '\0'; puVar5 = puVar5 + 1; } while (puVar5 != param_1 + (ulong)(param_2 - 2) + 2); } return pcVar1; }
4,618
func0
#include <assert.h> #include <string.h> #include <stdlib.h>
char* func0(char *arr[], int n) { if (n == 0) return ""; char *prefix = strdup(arr[0]); for (int i = 1; i < n; i++) { int j = 0; while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) { j++; } prefix[j] = '\0'; } return prefix; }
int main() { char *arr1[] = {"tablets", "tables", "taxi", "tamarind"}; assert(strcmp(func0(arr1, 4), "ta") == 0); char *arr2[] = {"apples", "ape", "april"}; assert(strcmp(func0(arr2, 3), "ap") == 0); char *arr3[] = {"teens", "teenager", "teenmar"}; assert(strcmp(func0(arr3, 3), "teen") == 0); return 0; }
O2
c
func0: endbr64 test %esi,%esi jne 13a0 <func0+0x10> lea 0xc81(%rip),%rax retq jmpq 1300 <func0.part.0> nopw %cs:0x0(%rax,%rax,1)
func0_part_0: push rbp mov ebp, esi push rbx mov rbx, rdi sub rsp, 8 mov rdi, [rdi] call _strdup cmp ebp, 1 jle short loc_1389 lea edx, [rbp-2] lea r8, [rbx+8] lea r9, [rbx+rdx*8+10h] nop dword ptr [rax+00h] loc_1348: movzx edx, byte ptr [rax] test dl, dl jz short loc_1390 mov rdi, [r8] mov rcx, rax jmp short loc_1375 loc_1360: test sil, sil jz short loc_137D movzx edx, byte ptr [rcx+1] add rcx, 1 add rdi, 1 test dl, dl jz short loc_137D loc_1375: movzx esi, byte ptr [rdi] cmp sil, dl jz short loc_1360 loc_137D: add r8, 8 mov byte ptr [rcx], 0 cmp r8, r9 jnz short loc_1348 loc_1389: add rsp, 8 pop rbx pop rbp retn loc_1390: mov rcx, rax add r8, 8 mov byte ptr [rcx], 0 cmp r8, r9 jnz short loc_1348 jmp short loc_1389
_BYTE * func0_part_0(_QWORD *a1, int a2) { _BYTE *result; // rax _BYTE **v3; // r8 long long v4; // r9 char v5; // dl _BYTE *v6; // rdi _BYTE *v7; // rcx result = (_BYTE *)strdup(*a1); if ( a2 > 1 ) { v3 = (_BYTE **)(a1 + 1); v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2]; do { while ( 1 ) { v5 = *result; if ( *result ) break; ++v3; *result = 0; if ( v3 == (_BYTE **)v4 ) return result; } v6 = *v3; v7 = result; do { if ( *v6 != v5 ) break; if ( !*v6 ) break; v5 = *++v7; ++v6; } while ( v5 ); ++v3; *v7 = 0; } while ( v3 != (_BYTE **)v4 ); } return result; }
func0.part.0: PUSH RBP MOV EBP,ESI PUSH RBX MOV RBX,RDI SUB RSP,0x8 MOV RDI,qword ptr [RDI] CALL 0x001010b0 CMP EBP,0x1 JLE 0x00101389 LEA EDX,[RBP + -0x2] LEA R8,[RBX + 0x8] LEA R9,[RBX + RDX*0x8 + 0x10] NOP dword ptr [RAX] LAB_00101348: MOVZX EDX,byte ptr [RAX] TEST DL,DL JZ 0x00101390 MOV RDI,qword ptr [R8] MOV RCX,RAX JMP 0x00101375 LAB_00101360: TEST SIL,SIL JZ 0x0010137d MOVZX EDX,byte ptr [RCX + 0x1] ADD RCX,0x1 ADD RDI,0x1 TEST DL,DL JZ 0x0010137d LAB_00101375: MOVZX ESI,byte ptr [RDI] CMP SIL,DL JZ 0x00101360 LAB_0010137d: ADD R8,0x8 MOV byte ptr [RCX],0x0 CMP R8,R9 JNZ 0x00101348 LAB_00101389: ADD RSP,0x8 POP RBX POP RBP RET LAB_00101390: MOV RCX,RAX ADD R8,0x8 MOV byte ptr [RCX],0x0 CMP R8,R9 JNZ 0x00101348 JMP 0x00101389
void func0_part_0(int8 *param_1,int param_2) { char *pcVar1; char *pcVar2; char cVar3; char *pcVar4; int8 *puVar5; pcVar1 = strdup((char *)*param_1); if (1 < param_2) { puVar5 = param_1 + 1; do { while (cVar3 = *pcVar1, cVar3 == '\0') { puVar5 = puVar5 + 1; *pcVar1 = '\0'; if (puVar5 == param_1 + (ulong)(param_2 - 2) + 2) { return; } } pcVar4 = (char *)*puVar5; pcVar2 = pcVar1; do { if ((*pcVar4 != cVar3) || (*pcVar4 == '\0')) break; cVar3 = pcVar2[1]; pcVar2 = pcVar2 + 1; pcVar4 = pcVar4 + 1; } while (cVar3 != '\0'); puVar5 = puVar5 + 1; *pcVar2 = '\0'; } while (puVar5 != param_1 + (ulong)(param_2 - 2) + 2); } return; }
4,619
func0
#include <assert.h> #include <string.h> #include <stdlib.h>
char* func0(char *arr[], int n) { if (n == 0) return ""; char *prefix = strdup(arr[0]); for (int i = 1; i < n; i++) { int j = 0; while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) { j++; } prefix[j] = '\0'; } return prefix; }
int main() { char *arr1[] = {"tablets", "tables", "taxi", "tamarind"}; assert(strcmp(func0(arr1, 4), "ta") == 0); char *arr2[] = {"apples", "ape", "april"}; assert(strcmp(func0(arr2, 3), "ap") == 0); char *arr3[] = {"teens", "teenager", "teenmar"}; assert(strcmp(func0(arr3, 3), "teen") == 0); return 0; }
O3
c
func0: endbr64 lea 0xc55(%rip),%rax test %esi,%esi jne 13d0 <func0+0x10> retq push %rbp mov %rdi,%rbp push %rbx mov %esi,%ebx sub $0x8,%rsp mov (%rdi),%rdi callq 1090 <strdup@plt> cmp $0x1,%ebx jle 1439 <func0+0x79> lea -0x2(%rbx),%edx lea 0x8(%rbp),%r8 lea 0x10(%rbp,%rdx,8),%r9 nopl 0x0(%rax) movzbl (%rax),%edx test %dl,%dl je 1440 <func0+0x80> mov (%r8),%rdi mov %rax,%rcx jmp 1425 <func0+0x65> nopw 0x0(%rax,%rax,1) test %sil,%sil je 142d <func0+0x6d> movzbl 0x1(%rcx),%edx add $0x1,%rcx add $0x1,%rdi test %dl,%dl je 142d <func0+0x6d> movzbl (%rdi),%esi cmp %dl,%sil je 1410 <func0+0x50> add $0x8,%r8 movb $0x0,(%rcx) cmp %r9,%r8 jne 13f8 <func0+0x38> add $0x8,%rsp pop %rbx pop %rbp retq mov %rax,%rcx add $0x8,%r8 movb $0x0,(%rcx) cmp %r9,%r8 jne 13f8 <func0+0x38> jmp 1439 <func0+0x79> nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax,%rax,1)
func0_part_0: push rbp mov ebp, esi push rbx mov rbx, rdi sub rsp, 8 mov rdi, [rdi]; s call _strdup cmp ebp, 1 jle short loc_13A9 lea edx, [rbp-2] lea r8, [rbx+8] lea r9, [rbx+rdx*8+10h] nop dword ptr [rax+00h] loc_1368: movzx edx, byte ptr [rax] test dl, dl jz short loc_13B0 mov rdi, [r8] mov rcx, rax jmp short loc_1395 loc_1380: test sil, sil jz short loc_139D movzx edx, byte ptr [rcx+1] add rcx, 1 add rdi, 1 test dl, dl jz short loc_139D loc_1395: movzx esi, byte ptr [rdi] cmp sil, dl jz short loc_1380 loc_139D: add r8, 8 mov byte ptr [rcx], 0 cmp r9, r8 jnz short loc_1368 loc_13A9: add rsp, 8 pop rbx pop rbp retn loc_13B0: mov rcx, rax add r8, 8 mov byte ptr [rcx], 0 cmp r9, r8 jnz short loc_1368 jmp short loc_13A9
char * func0_part_0(const char **a1, int a2) { char *result; // rax _BYTE **v3; // r8 long long v4; // r9 char v5; // dl _BYTE *v6; // rdi char *v7; // rcx result = strdup(*a1); if ( a2 > 1 ) { v3 = (_BYTE **)(a1 + 1); v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2]; do { while ( 1 ) { v5 = *result; if ( *result ) break; ++v3; *result = 0; if ( (_BYTE **)v4 == v3 ) return result; } v6 = *v3; v7 = result; do { if ( *v6 != v5 ) break; if ( !*v6 ) break; v5 = *++v7; ++v6; } while ( v5 ); ++v3; *v7 = 0; } while ( (_BYTE **)v4 != v3 ); } return result; }
func0.part.0: PUSH RBP MOV EBP,ESI PUSH RBX MOV RBX,RDI SUB RSP,0x8 MOV RDI,qword ptr [RDI] CALL 0x001010b0 CMP EBP,0x1 JLE 0x001013a9 LEA EDX,[RBP + -0x2] LEA R8,[RBX + 0x8] LEA R9,[RBX + RDX*0x8 + 0x10] NOP dword ptr [RAX] LAB_00101368: MOVZX EDX,byte ptr [RAX] TEST DL,DL JZ 0x001013b0 MOV RDI,qword ptr [R8] MOV RCX,RAX JMP 0x00101395 LAB_00101380: TEST SIL,SIL JZ 0x0010139d MOVZX EDX,byte ptr [RCX + 0x1] ADD RCX,0x1 ADD RDI,0x1 TEST DL,DL JZ 0x0010139d LAB_00101395: MOVZX ESI,byte ptr [RDI] CMP SIL,DL JZ 0x00101380 LAB_0010139d: ADD R8,0x8 MOV byte ptr [RCX],0x0 CMP R9,R8 JNZ 0x00101368 LAB_001013a9: ADD RSP,0x8 POP RBX POP RBP RET LAB_001013b0: MOV RCX,RAX ADD R8,0x8 MOV byte ptr [RCX],0x0 CMP R9,R8 JNZ 0x00101368 JMP 0x001013a9
void func0_part_0(int8 *param_1,int param_2) { char *pcVar1; char *pcVar2; char cVar3; char *pcVar4; int8 *puVar5; pcVar1 = strdup((char *)*param_1); if (1 < param_2) { puVar5 = param_1 + 1; do { while (cVar3 = *pcVar1, cVar3 == '\0') { puVar5 = puVar5 + 1; *pcVar1 = '\0'; if (param_1 + (ulong)(param_2 - 2) + 2 == puVar5) { return; } } pcVar4 = (char *)*puVar5; pcVar2 = pcVar1; do { if ((*pcVar4 != cVar3) || (*pcVar4 == '\0')) break; cVar3 = pcVar2[1]; pcVar2 = pcVar2 + 1; pcVar4 = pcVar4 + 1; } while (cVar3 != '\0'); puVar5 = puVar5 + 1; *pcVar2 = '\0'; } while (param_1 + (ulong)(param_2 - 2) + 2 != puVar5); } return; }
4,620
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <ctype.h>
void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) { int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0; int len = strlen(string); for (int i = 0; i < len; i++) { if (isupper(string[i])) { uppercase_characters[upper_idx++] = string[i]; } else if (islower(string[i])) { lowercase_characters[lower_idx++] = string[i]; } else if (isdigit(string[i])) { numerical_characters[num_idx++] = string[i]; } else if (string[i] == ',' || string[i] == '.' || string[i] == '!' || string[i] == '?') { special_characters[special_idx++] = string[i]; } } uppercase_characters[upper_idx] = '\0'; lowercase_characters[lower_idx] = '\0'; numerical_characters[num_idx] = '\0'; special_characters[special_idx] = '\0'; }
int main() { char uppers[100], lowers[100], nums[100], specials[100]; func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials); assert(strcmp(uppers, "TIGG") == 0); assert(strcmp(lowers, "hisseeksforeeks") == 0); assert(strcmp(nums, "") == 0); assert(strcmp(specials, "") == 0); func0("Hithere2", uppers, lowers, nums, specials); assert(strcmp(uppers, "H") == 0); assert(strcmp(lowers, "ithere") == 0); assert(strcmp(nums, "2") == 0); assert(strcmp(specials, "") == 0); func0("HeyFolks32", uppers, lowers, nums, specials); assert(strcmp(uppers, "HF") == 0); assert(strcmp(lowers, "eyolks") == 0); assert(strcmp(nums, "32") == 0); assert(strcmp(specials, "") == 0); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x50,%rsp mov %rdi,-0x28(%rbp) mov %rsi,-0x30(%rbp) mov %rdx,-0x38(%rbp) mov %rcx,-0x40(%rbp) mov %r8,-0x48(%rbp) movl $0x0,-0x18(%rbp) movl $0x0,-0x14(%rbp) movl $0x0,-0x10(%rbp) movl $0x0,-0xc(%rbp) mov -0x28(%rbp),%rax mov %rax,%rdi callq 1090 <strlen@plt> mov %eax,-0x4(%rbp) movl $0x0,-0x8(%rbp) jmpq 13ab <func0+0x1e2> callq 10d0 <__ctype_b_loc@plt> mov (%rax),%rax mov -0x8(%rbp),%edx movslq %edx,%rcx mov -0x28(%rbp),%rdx add %rcx,%rdx movzbl (%rdx),%edx movsbq %dl,%rdx add %rdx,%rdx add %rdx,%rax movzwl (%rax),%eax movzwl %ax,%eax and $0x100,%eax test %eax,%eax je 127c <func0+0xb3> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax lea (%rdx,%rax,1),%rcx mov -0x18(%rbp),%eax lea 0x1(%rax),%edx mov %edx,-0x18(%rbp) movslq %eax,%rdx mov -0x30(%rbp),%rax add %rax,%rdx movzbl (%rcx),%eax mov %al,(%rdx) jmpq 13a7 <func0+0x1de> callq 10d0 <__ctype_b_loc@plt> mov (%rax),%rax mov -0x8(%rbp),%edx movslq %edx,%rcx mov -0x28(%rbp),%rdx add %rcx,%rdx movzbl (%rdx),%edx movsbq %dl,%rdx add %rdx,%rdx add %rdx,%rax movzwl (%rax),%eax movzwl %ax,%eax and $0x200,%eax test %eax,%eax je 12d8 <func0+0x10f> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax lea (%rdx,%rax,1),%rcx mov -0x14(%rbp),%eax lea 0x1(%rax),%edx mov %edx,-0x14(%rbp) movslq %eax,%rdx mov -0x38(%rbp),%rax add %rax,%rdx movzbl (%rcx),%eax mov %al,(%rdx) jmpq 13a7 <func0+0x1de> callq 10d0 <__ctype_b_loc@plt> mov (%rax),%rax mov -0x8(%rbp),%edx movslq %edx,%rcx mov -0x28(%rbp),%rdx add %rcx,%rdx movzbl (%rdx),%edx movsbq %dl,%rdx add %rdx,%rdx add %rdx,%rax movzwl (%rax),%eax movzwl %ax,%eax and $0x800,%eax test %eax,%eax je 1331 <func0+0x168> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax lea (%rdx,%rax,1),%rcx mov -0x10(%rbp),%eax lea 0x1(%rax),%edx mov %edx,-0x10(%rbp) movslq %eax,%rdx mov -0x40(%rbp),%rax add %rax,%rdx movzbl (%rcx),%eax mov %al,(%rdx) jmp 13a7 <func0+0x1de> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax add %rdx,%rax movzbl (%rax),%eax cmp $0x2c,%al je 1381 <func0+0x1b8> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax add %rdx,%rax movzbl (%rax),%eax cmp $0x2e,%al je 1381 <func0+0x1b8> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax add %rdx,%rax movzbl (%rax),%eax cmp $0x21,%al je 1381 <func0+0x1b8> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax add %rdx,%rax movzbl (%rax),%eax cmp $0x3f,%al jne 13a7 <func0+0x1de> mov -0x8(%rbp),%eax movslq %eax,%rdx mov -0x28(%rbp),%rax lea (%rdx,%rax,1),%rcx mov -0xc(%rbp),%eax lea 0x1(%rax),%edx mov %edx,-0xc(%rbp) movslq %eax,%rdx mov -0x48(%rbp),%rax add %rax,%rdx movzbl (%rcx),%eax mov %al,(%rdx) addl $0x1,-0x8(%rbp) mov -0x8(%rbp),%eax cmp -0x4(%rbp),%eax jl 1220 <func0+0x57> mov -0x18(%rbp),%eax movslq %eax,%rdx mov -0x30(%rbp),%rax add %rdx,%rax movb $0x0,(%rax) mov -0x14(%rbp),%eax movslq %eax,%rdx mov -0x38(%rbp),%rax add %rdx,%rax movb $0x0,(%rax) mov -0x10(%rbp),%eax movslq %eax,%rdx mov -0x40(%rbp),%rax add %rdx,%rax movb $0x0,(%rax) mov -0xc(%rbp),%eax movslq %eax,%rdx mov -0x48(%rbp),%rax add %rdx,%rax movb $0x0,(%rax) leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 50h mov [rbp+s], rdi mov [rbp+var_30], rsi mov [rbp+var_38], rdx mov [rbp+var_40], rcx mov [rbp+var_48], r8 mov [rbp+var_18], 0 mov [rbp+var_14], 0 mov [rbp+var_10], 0 mov [rbp+var_C], 0 mov rax, [rbp+s] mov rdi, rax; s call _strlen mov [rbp+var_4], eax mov [rbp+var_8], 0 jmp loc_13AB loc_1220: call ___ctype_b_loc mov rax, [rax] mov edx, [rbp+var_8] movsxd rcx, edx mov rdx, [rbp+s] add rdx, rcx movzx edx, byte ptr [rdx] movsx rdx, dl add rdx, rdx add rax, rdx movzx eax, word ptr [rax] movzx eax, ax and eax, 100h test eax, eax jz short loc_127C mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] lea rcx, [rdx+rax] mov eax, [rbp+var_18] lea edx, [rax+1] mov [rbp+var_18], edx movsxd rdx, eax mov rax, [rbp+var_30] add rdx, rax movzx eax, byte ptr [rcx] mov [rdx], al jmp loc_13A7 loc_127C: call ___ctype_b_loc mov rax, [rax] mov edx, [rbp+var_8] movsxd rcx, edx mov rdx, [rbp+s] add rdx, rcx movzx edx, byte ptr [rdx] movsx rdx, dl add rdx, rdx add rax, rdx movzx eax, word ptr [rax] movzx eax, ax and eax, 200h test eax, eax jz short loc_12D8 mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] lea rcx, [rdx+rax] mov eax, [rbp+var_14] lea edx, [rax+1] mov [rbp+var_14], edx movsxd rdx, eax mov rax, [rbp+var_38] add rdx, rax movzx eax, byte ptr [rcx] mov [rdx], al jmp loc_13A7 loc_12D8: call ___ctype_b_loc mov rax, [rax] mov edx, [rbp+var_8] movsxd rcx, edx mov rdx, [rbp+s] add rdx, rcx movzx edx, byte ptr [rdx] movsx rdx, dl add rdx, rdx add rax, rdx movzx eax, word ptr [rax] movzx eax, ax and eax, 800h test eax, eax jz short loc_1331 mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] lea rcx, [rdx+rax] mov eax, [rbp+var_10] lea edx, [rax+1] mov [rbp+var_10], edx movsxd rdx, eax mov rax, [rbp+var_40] add rdx, rax movzx eax, byte ptr [rcx] mov [rdx], al jmp short loc_13A7 loc_1331: mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] add rax, rdx movzx eax, byte ptr [rax] cmp al, 2Ch ; ',' jz short loc_1381 mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] add rax, rdx movzx eax, byte ptr [rax] cmp al, 2Eh ; '.' jz short loc_1381 mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] add rax, rdx movzx eax, byte ptr [rax] cmp al, 21h ; '!' jz short loc_1381 mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] add rax, rdx movzx eax, byte ptr [rax] cmp al, 3Fh ; '?' jnz short loc_13A7 loc_1381: mov eax, [rbp+var_8] movsxd rdx, eax mov rax, [rbp+s] lea rcx, [rdx+rax] mov eax, [rbp+var_C] lea edx, [rax+1] mov [rbp+var_C], edx movsxd rdx, eax mov rax, [rbp+var_48] add rdx, rax movzx eax, byte ptr [rcx] mov [rdx], al loc_13A7: add [rbp+var_8], 1 loc_13AB: mov eax, [rbp+var_8] cmp eax, [rbp+var_4] jl loc_1220 mov eax, [rbp+var_18] movsxd rdx, eax mov rax, [rbp+var_30] add rax, rdx mov byte ptr [rax], 0 mov eax, [rbp+var_14] movsxd rdx, eax mov rax, [rbp+var_38] add rax, rdx mov byte ptr [rax], 0 mov eax, [rbp+var_10] movsxd rdx, eax mov rax, [rbp+var_40] add rax, rdx mov byte ptr [rax], 0 mov eax, [rbp+var_C] movsxd rdx, eax mov rax, [rbp+var_48] add rax, rdx mov byte ptr [rax], 0 nop leave retn
_BYTE * func0(const char *a1, long long a2, long long a3, long long a4, long long a5) { int v5; // eax int v6; // eax int v7; // eax int v8; // eax _BYTE *result; // rax int v13; // [rsp+38h] [rbp-18h] int v14; // [rsp+3Ch] [rbp-14h] int v15; // [rsp+40h] [rbp-10h] int v16; // [rsp+44h] [rbp-Ch] int i; // [rsp+48h] [rbp-8h] int v18; // [rsp+4Ch] [rbp-4h] v13 = 0; v14 = 0; v15 = 0; v16 = 0; v18 = strlen(a1); for ( i = 0; i < v18; ++i ) { if ( ((*__ctype_b_loc())[a1[i]] & 0x100) != 0 ) { v5 = v13++; *(_BYTE *)(a2 + v5) = a1[i]; } else if ( ((*__ctype_b_loc())[a1[i]] & 0x200) != 0 ) { v6 = v14++; *(_BYTE *)(a3 + v6) = a1[i]; } else if ( ((*__ctype_b_loc())[a1[i]] & 0x800) != 0 ) { v7 = v15++; *(_BYTE *)(a4 + v7) = a1[i]; } else if ( a1[i] == 44 || a1[i] == 46 || a1[i] == 33 || a1[i] == 63 ) { v8 = v16++; *(_BYTE *)(a5 + v8) = a1[i]; } } *(_BYTE *)(v13 + a2) = 0; *(_BYTE *)(v14 + a3) = 0; *(_BYTE *)(v15 + a4) = 0; result = (_BYTE *)(v16 + a5); *result = 0; return result; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x50 MOV qword ptr [RBP + -0x28],RDI MOV qword ptr [RBP + -0x30],RSI MOV qword ptr [RBP + -0x38],RDX MOV qword ptr [RBP + -0x40],RCX MOV qword ptr [RBP + -0x48],R8 MOV dword ptr [RBP + -0x18],0x0 MOV dword ptr [RBP + -0x14],0x0 MOV dword ptr [RBP + -0x10],0x0 MOV dword ptr [RBP + -0xc],0x0 MOV RAX,qword ptr [RBP + -0x28] MOV RDI,RAX CALL 0x00101090 MOV dword ptr [RBP + -0x4],EAX MOV dword ptr [RBP + -0x8],0x0 JMP 0x001013ab LAB_00101220: CALL 0x001010d0 MOV RAX,qword ptr [RAX] MOV EDX,dword ptr [RBP + -0x8] MOVSXD RCX,EDX MOV RDX,qword ptr [RBP + -0x28] ADD RDX,RCX MOVZX EDX,byte ptr [RDX] MOVSX RDX,DL ADD RDX,RDX ADD RAX,RDX MOVZX EAX,word ptr [RAX] MOVZX EAX,AX AND EAX,0x100 TEST EAX,EAX JZ 0x0010127c MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] LEA RCX,[RDX + RAX*0x1] MOV EAX,dword ptr [RBP + -0x18] LEA EDX,[RAX + 0x1] MOV dword ptr [RBP + -0x18],EDX MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x30] ADD RDX,RAX MOVZX EAX,byte ptr [RCX] MOV byte ptr [RDX],AL JMP 0x001013a7 LAB_0010127c: CALL 0x001010d0 MOV RAX,qword ptr [RAX] MOV EDX,dword ptr [RBP + -0x8] MOVSXD RCX,EDX MOV RDX,qword ptr [RBP + -0x28] ADD RDX,RCX MOVZX EDX,byte ptr [RDX] MOVSX RDX,DL ADD RDX,RDX ADD RAX,RDX MOVZX EAX,word ptr [RAX] MOVZX EAX,AX AND EAX,0x200 TEST EAX,EAX JZ 0x001012d8 MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] LEA RCX,[RDX + RAX*0x1] MOV EAX,dword ptr [RBP + -0x14] LEA EDX,[RAX + 0x1] MOV dword ptr [RBP + -0x14],EDX MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x38] ADD RDX,RAX MOVZX EAX,byte ptr [RCX] MOV byte ptr [RDX],AL JMP 0x001013a7 LAB_001012d8: CALL 0x001010d0 MOV RAX,qword ptr [RAX] MOV EDX,dword ptr [RBP + -0x8] MOVSXD RCX,EDX MOV RDX,qword ptr [RBP + -0x28] ADD RDX,RCX MOVZX EDX,byte ptr [RDX] MOVSX RDX,DL ADD RDX,RDX ADD RAX,RDX MOVZX EAX,word ptr [RAX] MOVZX EAX,AX AND EAX,0x800 TEST EAX,EAX JZ 0x00101331 MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] LEA RCX,[RDX + RAX*0x1] MOV EAX,dword ptr [RBP + -0x10] LEA EDX,[RAX + 0x1] MOV dword ptr [RBP + -0x10],EDX MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x40] ADD RDX,RAX MOVZX EAX,byte ptr [RCX] MOV byte ptr [RDX],AL JMP 0x001013a7 LAB_00101331: MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOVZX EAX,byte ptr [RAX] CMP AL,0x2c JZ 0x00101381 MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOVZX EAX,byte ptr [RAX] CMP AL,0x2e JZ 0x00101381 MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOVZX EAX,byte ptr [RAX] CMP AL,0x21 JZ 0x00101381 MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOVZX EAX,byte ptr [RAX] CMP AL,0x3f JNZ 0x001013a7 LAB_00101381: MOV EAX,dword ptr [RBP + -0x8] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x28] LEA RCX,[RDX + RAX*0x1] MOV EAX,dword ptr [RBP + -0xc] LEA EDX,[RAX + 0x1] MOV dword ptr [RBP + -0xc],EDX MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x48] ADD RDX,RAX MOVZX EAX,byte ptr [RCX] MOV byte ptr [RDX],AL LAB_001013a7: ADD dword ptr [RBP + -0x8],0x1 LAB_001013ab: MOV EAX,dword ptr [RBP + -0x8] CMP EAX,dword ptr [RBP + -0x4] JL 0x00101220 MOV EAX,dword ptr [RBP + -0x18] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x30] ADD RAX,RDX MOV byte ptr [RAX],0x0 MOV EAX,dword ptr [RBP + -0x14] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x38] ADD RAX,RDX MOV byte ptr [RAX],0x0 MOV EAX,dword ptr [RBP + -0x10] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x40] ADD RAX,RDX MOV byte ptr [RAX],0x0 MOV EAX,dword ptr [RBP + -0xc] MOVSXD RDX,EAX MOV RAX,qword ptr [RBP + -0x48] ADD RAX,RDX MOV byte ptr [RAX],0x0 NOP LEAVE RET
void func0(char *param_1,long param_2,long param_3,long param_4,long param_5) { size_t sVar1; ushort **ppuVar2; int local_20; int local_1c; int local_18; int local_14; int local_10; local_20 = 0; local_1c = 0; local_18 = 0; local_14 = 0; sVar1 = strlen(param_1); for (local_10 = 0; local_10 < (int)sVar1; local_10 = local_10 + 1) { ppuVar2 = __ctype_b_loc(); if (((*ppuVar2)[param_1[local_10]] & 0x100) == 0) { ppuVar2 = __ctype_b_loc(); if (((*ppuVar2)[param_1[local_10]] & 0x200) == 0) { ppuVar2 = __ctype_b_loc(); if (((*ppuVar2)[param_1[local_10]] & 0x800) == 0) { if ((((param_1[local_10] == ',') || (param_1[local_10] == '.')) || (param_1[local_10] == '!')) || (param_1[local_10] == '?')) { *(char *)(local_14 + param_5) = param_1[local_10]; local_14 = local_14 + 1; } } else { *(char *)(local_18 + param_4) = param_1[local_10]; local_18 = local_18 + 1; } } else { *(char *)(local_1c + param_3) = param_1[local_10]; local_1c = local_1c + 1; } } else { *(char *)(local_20 + param_2) = param_1[local_10]; local_20 = local_20 + 1; } } *(int *)(param_2 + local_20) = 0; *(int *)(param_3 + local_1c) = 0; *(int *)(param_4 + local_18) = 0; *(int *)(param_5 + local_14) = 0; return; }
4,621
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <ctype.h>
void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) { int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0; int len = strlen(string); for (int i = 0; i < len; i++) { if (isupper(string[i])) { uppercase_characters[upper_idx++] = string[i]; } else if (islower(string[i])) { lowercase_characters[lower_idx++] = string[i]; } else if (isdigit(string[i])) { numerical_characters[num_idx++] = string[i]; } else if (string[i] == ',' || string[i] == '.' || string[i] == '!' || string[i] == '?') { special_characters[special_idx++] = string[i]; } } uppercase_characters[upper_idx] = '\0'; lowercase_characters[lower_idx] = '\0'; numerical_characters[num_idx] = '\0'; special_characters[special_idx] = '\0'; }
int main() { char uppers[100], lowers[100], nums[100], specials[100]; func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials); assert(strcmp(uppers, "TIGG") == 0); assert(strcmp(lowers, "hisseeksforeeks") == 0); assert(strcmp(nums, "") == 0); assert(strcmp(specials, "") == 0); func0("Hithere2", uppers, lowers, nums, specials); assert(strcmp(uppers, "H") == 0); assert(strcmp(lowers, "ithere") == 0); assert(strcmp(nums, "2") == 0); assert(strcmp(specials, "") == 0); func0("HeyFolks32", uppers, lowers, nums, specials); assert(strcmp(uppers, "HF") == 0); assert(strcmp(lowers, "eyolks") == 0); assert(strcmp(nums, "32") == 0); assert(strcmp(specials, "") == 0); return 0; }
O1
c
func0: endbr64 push %r15 push %r14 push %r13 push %r12 push %rbp push %rbx sub $0x8,%rsp mov %rdi,%r13 mov %rsi,%rbp mov %rdx,%r12 mov %rcx,%r14 mov %r8,%r15 mov $0xffffffffffffffff,%rcx mov $0x0,%eax repnz scas %es:(%rdi),%al not %rcx lea -0x1(%rcx),%rbx test %ebx,%ebx jle 1263 <func0+0xda> callq 1090 <__ctype_b_loc@plt> mov %r13,%rdx lea -0x1(%rbx),%ecx lea 0x1(%r13,%rcx,1),%r9 mov $0x0,%r11d mov $0x0,%r10d mov $0x0,%r8d mov $0x0,%edi movabs $0x8000500200000000,%rbx jmp 1215 <func0+0x8c> test $0x200,%si je 1237 <func0+0xae> movslq %r8d,%rsi mov %cl,(%r12,%rsi,1) lea 0x1(%r8),%r8d add $0x1,%rdx cmp %r9,%rdx je 127a <func0+0xf1> movzbl (%rdx),%ecx movsbq %cl,%r13 mov (%rax),%rsi movzwl (%rsi,%r13,2),%esi test $0x100,%si je 11fa <func0+0x71> movslq %edi,%rsi mov %cl,0x0(%rbp,%rsi,1) lea 0x1(%rdi),%edi jmp 120c <func0+0x83> test $0x800,%si je 124b <func0+0xc2> movslq %r10d,%rsi mov %cl,(%r14,%rsi,1) lea 0x1(%r10),%r10d jmp 120c <func0+0x83> cmp $0x3f,%cl ja 120c <func0+0x83> bt %rcx,%rbx jae 120c <func0+0x83> movslq %r11d,%rsi mov %cl,(%r15,%rsi,1) lea 0x1(%r11),%r11d jmp 120c <func0+0x83> mov $0x0,%r11d mov $0x0,%r10d mov $0x0,%r8d mov $0x0,%edi movslq %edi,%rdi movb $0x0,0x0(%rbp,%rdi,1) movslq %r8d,%r8 movb $0x0,(%r12,%r8,1) movslq %r10d,%r10 movb $0x0,(%r14,%r10,1) movslq %r11d,%r11 movb $0x0,(%r15,%r11,1) add $0x8,%rsp pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 pop %r15 retq
func0: endbr64 push r15 push r14 push r13 push r12 push rbp push rbx sub rsp, 8 mov r12, rdi mov rbx, rsi mov rbp, rdx mov r13, rcx mov r15, r8 call _strlen test eax, eax jle loc_1294 mov r14, rax call ___ctype_b_loc mov rdi, rax mov rax, r12 lea edx, [r14-1] lea r9, [r12+rdx+1] mov r11d, 0 mov r10d, 0 mov r8d, 0 mov esi, 0 mov r12, 8000500200000000h jmp short loc_124A loc_1231: test ch, 2 jz short loc_1269 movsxd rcx, r8d mov [rbp+rcx+0], dl lea r8d, [r8+1] loc_1241: add rax, 1 cmp rax, r9 jz short loc_12AB loc_124A: movzx edx, byte ptr [rax] movsx r14, dl mov rcx, [rdi] movzx ecx, word ptr [rcx+r14*2] test ch, 1 jz short loc_1231 movsxd rcx, esi mov [rbx+rcx], dl lea esi, [rsi+1] jmp short loc_1241 loc_1269: test ch, 8 jz short loc_127C movsxd rcx, r10d mov [r13+rcx+0], dl lea r10d, [r10+1] jmp short loc_1241 loc_127C: cmp dl, 3Fh ; '?' ja short loc_1241 bt r12, rdx jnb short loc_1241 movsxd rcx, r11d mov [r15+rcx], dl lea r11d, [r11+1] jmp short loc_1241 loc_1294: mov r11d, 0 mov r10d, 0 mov r8d, 0 mov esi, 0 loc_12AB: movsxd rsi, esi mov byte ptr [rbx+rsi], 0 movsxd r8, r8d mov byte ptr [rbp+r8+0], 0 movsxd r10, r10d mov byte ptr [r13+r10+0], 0 movsxd r11, r11d mov byte ptr [r15+r11], 0 add rsp, 8 pop rbx pop rbp pop r12 pop r13 pop r14 pop r15 retn
unsigned __int8 * func0(unsigned __int8 *a1, long long a2, long long a3, long long a4, long long a5) { unsigned __int8 *result; // rax int v11; // r14d _QWORD *v12; // rdi long long v13; // r9 int v14; // r11d int v15; // r10d int v16; // r8d int v17; // esi unsigned long long v18; // r12 unsigned long long v19; // rdx __int16 v20; // cx result = (unsigned __int8 *)strlen(); if ( (int)result <= 0 ) { v14 = 0; v15 = 0; v16 = 0; v17 = 0; } else { v11 = (int)result; v12 = (_QWORD *)__ctype_b_loc(); result = a1; v13 = (long long)&a1[v11 - 1 + 1]; v14 = 0; v15 = 0; v16 = 0; v17 = 0; v18 = 0x8000500200000000LL; do { v19 = *result; v20 = *(_WORD *)(*v12 + 2LL * (char)v19); if ( (v20 & 0x100) != 0 ) { *(_BYTE *)(a2 + v17++) = v19; } else if ( (v20 & 0x200) != 0 ) { *(_BYTE *)(a3 + v16++) = v19; } else if ( (v20 & 0x800) != 0 ) { *(_BYTE *)(a4 + v15++) = v19; } else if ( (unsigned __int8)v19 <= 0x3Fu && _bittest64((const long long *)&v18, v19) ) { *(_BYTE *)(a5 + v14++) = v19; } ++result; } while ( result != (unsigned __int8 *)v13 ); } *(_BYTE *)(a2 + v17) = 0; *(_BYTE *)(a3 + v16) = 0; *(_BYTE *)(a4 + v15) = 0; *(_BYTE *)(a5 + v14) = 0; return result; }
func0: ENDBR64 PUSH R15 PUSH R14 PUSH R13 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x8 MOV R12,RDI MOV RBX,RSI MOV RBP,RDX MOV R13,RCX MOV R15,R8 CALL 0x00101090 TEST EAX,EAX JLE 0x00101294 MOV R14,RAX CALL 0x001010d0 MOV RDI,RAX MOV RAX,R12 LEA EDX,[R14 + -0x1] LEA R9,[R12 + RDX*0x1 + 0x1] MOV R11D,0x0 MOV R10D,0x0 MOV R8D,0x0 MOV ESI,0x0 MOV R12,-0x7fffaffe00000000 JMP 0x0010124a LAB_00101231: TEST CH,0x2 JZ 0x00101269 MOVSXD RCX,R8D MOV byte ptr [RBP + RCX*0x1],DL LEA R8D,[R8 + 0x1] LAB_00101241: ADD RAX,0x1 CMP RAX,R9 JZ 0x001012ab LAB_0010124a: MOVZX EDX,byte ptr [RAX] MOVSX R14,DL MOV RCX,qword ptr [RDI] MOVZX ECX,word ptr [RCX + R14*0x2] TEST CH,0x1 JZ 0x00101231 MOVSXD RCX,ESI MOV byte ptr [RBX + RCX*0x1],DL LEA ESI,[RSI + 0x1] JMP 0x00101241 LAB_00101269: TEST CH,0x8 JZ 0x0010127c MOVSXD RCX,R10D MOV byte ptr [R13 + RCX*0x1],DL LEA R10D,[R10 + 0x1] JMP 0x00101241 LAB_0010127c: CMP DL,0x3f JA 0x00101241 BT R12,RDX JNC 0x00101241 MOVSXD RCX,R11D MOV byte ptr [R15 + RCX*0x1],DL LEA R11D,[R11 + 0x1] JMP 0x00101241 LAB_00101294: MOV R11D,0x0 MOV R10D,0x0 MOV R8D,0x0 MOV ESI,0x0 LAB_001012ab: MOVSXD RSI,ESI MOV byte ptr [RBX + RSI*0x1],0x0 MOVSXD R8,R8D MOV byte ptr [RBP + R8*0x1],0x0 MOVSXD R10,R10D MOV byte ptr [R13 + R10*0x1],0x0 MOVSXD R11,R11D MOV byte ptr [R15 + R11*0x1],0x0 ADD RSP,0x8 POP RBX POP RBP POP R12 POP R13 POP R14 POP R15 RET
void func0(byte *param_1,long param_2,long param_3,long param_4,long param_5) { byte *pbVar1; byte bVar2; ushort uVar3; size_t sVar4; ushort **ppuVar5; int iVar6; int iVar7; int iVar8; int iVar9; sVar4 = strlen((char *)param_1); if ((int)sVar4 < 1) { iVar9 = 0; iVar8 = 0; iVar7 = 0; iVar6 = 0; } else { ppuVar5 = __ctype_b_loc(); pbVar1 = param_1 + (ulong)((int)sVar4 - 1) + 1; iVar9 = 0; iVar8 = 0; iVar7 = 0; iVar6 = 0; do { bVar2 = *param_1; uVar3 = (*ppuVar5)[(char)bVar2]; if ((uVar3 & 0x100) == 0) { if ((uVar3 & 0x200) == 0) { if ((uVar3 & 0x800) == 0) { if ((bVar2 < 0x40) && ((0x8000500200000000U >> ((ulong)bVar2 & 0x3f) & 1) != 0)) { *(byte *)(param_5 + iVar9) = bVar2; iVar9 = iVar9 + 1; } } else { *(byte *)(param_4 + iVar8) = bVar2; iVar8 = iVar8 + 1; } } else { *(byte *)(param_3 + iVar7) = bVar2; iVar7 = iVar7 + 1; } } else { *(byte *)(param_2 + iVar6) = bVar2; iVar6 = iVar6 + 1; } param_1 = param_1 + 1; } while (param_1 != pbVar1); } *(int1 *)(param_2 + iVar6) = 0; *(int1 *)(param_3 + iVar7) = 0; *(int1 *)(param_4 + iVar8) = 0; *(int1 *)(param_5 + iVar9) = 0; return; }
4,622
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <ctype.h>
void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) { int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0; int len = strlen(string); for (int i = 0; i < len; i++) { if (isupper(string[i])) { uppercase_characters[upper_idx++] = string[i]; } else if (islower(string[i])) { lowercase_characters[lower_idx++] = string[i]; } else if (isdigit(string[i])) { numerical_characters[num_idx++] = string[i]; } else if (string[i] == ',' || string[i] == '.' || string[i] == '!' || string[i] == '?') { special_characters[special_idx++] = string[i]; } } uppercase_characters[upper_idx] = '\0'; lowercase_characters[lower_idx] = '\0'; numerical_characters[num_idx] = '\0'; special_characters[special_idx] = '\0'; }
int main() { char uppers[100], lowers[100], nums[100], specials[100]; func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials); assert(strcmp(uppers, "TIGG") == 0); assert(strcmp(lowers, "hisseeksforeeks") == 0); assert(strcmp(nums, "") == 0); assert(strcmp(specials, "") == 0); func0("Hithere2", uppers, lowers, nums, specials); assert(strcmp(uppers, "H") == 0); assert(strcmp(lowers, "ithere") == 0); assert(strcmp(nums, "2") == 0); assert(strcmp(specials, "") == 0); func0("HeyFolks32", uppers, lowers, nums, specials); assert(strcmp(uppers, "HF") == 0); assert(strcmp(lowers, "eyolks") == 0); assert(strcmp(nums, "32") == 0); assert(strcmp(specials, "") == 0); return 0; }
O2
c
func0: endbr64 push %r15 push %r14 push %r13 mov %rdi,%r13 push %r12 push %rbp mov %rdx,%rbp push %rbx mov %rsi,%rbx sub $0x38,%rsp mov %rcx,0x8(%rsp) mov %r8,0x10(%rsp) callq 1080 <strlen@plt> test %eax,%eax jle 1620 <func0+0x170> mov %rax,%r14 xor %r12d,%r12d xor %r15d,%r15d callq 10b0 <__ctype_b_loc@plt> lea -0x1(%r14),%edx mov %r13,%rdi xor %r11d,%r11d lea 0x1(%r13,%rdx,1),%rsi xor %edx,%edx xor %r13d,%r13d movl $0x0,0x2c(%rsp) mov %rsi,0x18(%rsp) movl $0x0,0x28(%rsp) movl $0x0,0x24(%rsp) jmp 1541 <func0+0x91> nopl 0x0(%rax,%rax,1) add $0x1,%r12d mov %r8b,(%r10) movslq %r12d,%r11 lea (%rbx,%r11,1),%r10 add $0x1,%rdi cmp %rdi,0x18(%rsp) je 1596 <func0+0xe6> movsbq (%rdi),%rsi mov (%rax),%rcx lea (%rbx,%r11,1),%r10 mov 0x10(%rsp),%r14 movzwl (%rcx,%rsi,2),%r9d mov 0x8(%rsp),%rcx mov %rsi,%r8 lea 0x0(%rbp,%rdx,1),%rsi add %r15,%r14 add %r13,%rcx test $0x100,%r9w jne 1528 <func0+0x78> test $0x200,%r9w je 15b8 <func0+0x108> addl $0x1,0x24(%rsp) movslq 0x24(%rsp),%rdx add $0x1,%rdi mov %r8b,(%rsi) lea 0x0(%rbp,%rdx,1),%rsi cmp %rdi,0x18(%rsp) jne 1541 <func0+0x91> movb $0x0,(%r10) movb $0x0,(%rsi) movb $0x0,(%rcx) movb $0x0,(%r14) add $0x38,%rsp pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 pop %r15 retq nopl 0x0(%rax,%rax,1) test $0x800,%r9w je 15e0 <func0+0x130> addl $0x1,0x28(%rsp) movslq 0x28(%rsp),%r13 mov %r8b,(%rcx) mov 0x8(%rsp),%rcx add %r13,%rcx jmpq 1536 <func0+0x86> nopw 0x0(%rax,%rax,1) cmp $0x3f,%r8b ja 1536 <func0+0x86> movabs $0x8000500200000000,%r9 bt %r8,%r9 jae 1536 <func0+0x86> mov %r8b,(%r14) mov 0x10(%rsp),%r8 addl $0x1,0x2c(%rsp) movslq 0x2c(%rsp),%r15 lea (%r8,%r15,1),%r14 jmpq 1536 <func0+0x86> nopl 0x0(%rax) mov 0x10(%rsp),%r14 mov 0x8(%rsp),%rcx mov %rbp,%rsi mov %rbx,%r10 jmpq 1596 <func0+0xe6> nopw %cs:0x0(%rax,%rax,1)
func0: endbr64 push r15 push r14 mov r14, rdi push r13 mov r13, r8 push r12 mov r12, rcx push rbp mov rbp, rdx push rbx mov rbx, rsi sub rsp, 8 call _strlen test eax, eax jle loc_1566 mov r15, rax call ___ctype_b_loc mov rdx, r14 xor r8d, r8d xor r11d, r11d mov rdi, rax lea eax, [r15-1] xor r9d, r9d xor esi, esi lea r10, [r14+rax+1] mov r14, 8000500200000000h jmp short loc_1523 loc_1510: movsxd rcx, esi add esi, 1 mov [rbx+rcx], r15b loc_151A: add rdx, 1 cmp r10, rdx jz short loc_154E loc_1523: movsx r15, byte ptr [rdx] mov rcx, [rdi] movzx ecx, word ptr [rcx+r15*2] test ch, 1 jnz short loc_1510 test ch, 2 jz short loc_1590 movsxd rcx, r9d add rdx, 1 add r9d, 1 mov [rbp+rcx+0], r15b cmp r10, rdx jnz short loc_1523 loc_154E: movsxd rsi, esi movsxd r9, r9d movsxd r11, r11d movsxd r8, r8d add rbx, rsi add rbp, r9 add r12, r11 add r13, r8 loc_1566: mov byte ptr [rbx], 0 mov byte ptr [rbp+0], 0 mov byte ptr [r12], 0 mov byte ptr [r13+0], 0 add rsp, 8 pop rbx pop rbp pop r12 pop r13 pop r14 pop r15 retn loc_1590: and ch, 8 jz short loc_15A8 movsxd rcx, r11d add r11d, 1 mov [r12+rcx], r15b jmp loc_151A loc_15A8: cmp r15b, 3Fh ; '?' ja loc_151A bt r14, r15 jnb loc_151A movsxd rcx, r8d add r8d, 1 mov [r13+rcx+0], r15b jmp loc_151A
long long func0(char *a1, _BYTE *a2, _BYTE *a3, _BYTE *a4, _BYTE *a5) { long long result; // rax int v11; // r15d long long v12; // rax char *v13; // rdx int v14; // r8d int v15; // r11d _QWORD *v16; // rdi int v17; // r9d int v18; // esi long long v19; // r10 unsigned long long v20; // r14 long long v21; // rcx unsigned long long v22; // r15 __int16 v23; // cx long long v24; // rcx long long v25; // rcx long long v26; // rcx result = strlen(); if ( (int)result > 0 ) { v11 = result; v12 = __ctype_b_loc(); v13 = a1; v14 = 0; v15 = 0; v16 = (_QWORD *)v12; result = (unsigned int)(v11 - 1); v17 = 0; v18 = 0; v19 = (long long)&a1[result + 1]; v20 = 0x8000500200000000LL; while ( 1 ) { while ( 1 ) { v22 = *v13; v23 = *(_WORD *)(*v16 + 2 * v22); if ( (v23 & 0x100) == 0 ) break; v21 = v18++; a2[v21] = v22; LABEL_4: if ( (char *)v19 == ++v13 ) goto LABEL_8; } if ( (v23 & 0x200) == 0 ) { if ( (v23 & 0x800) != 0 ) { v25 = v15++; a4[v25] = v22; } else if ( (unsigned __int8)v22 <= 0x3Fu && _bittest64((const long long *)&v20, v22) ) { v26 = v14++; a5[v26] = v22; } goto LABEL_4; } v24 = v17; ++v13; ++v17; a3[v24] = v22; if ( (char *)v19 == v13 ) { LABEL_8: a2 += v18; a3 += v17; a4 += v15; a5 += v14; break; } } } *a2 = 0; *a3 = 0; *a4 = 0; *a5 = 0; return result; }
func0: ENDBR64 PUSH R15 PUSH R14 MOV R14,RDI PUSH R13 MOV R13,R8 PUSH R12 MOV R12,RCX PUSH RBP MOV RBP,RDX PUSH RBX MOV RBX,RSI SUB RSP,0x8 CALL 0x00101080 TEST EAX,EAX JLE 0x00101566 MOV R15,RAX CALL 0x001010b0 MOV RDX,R14 XOR R8D,R8D XOR R11D,R11D MOV RDI,RAX LEA EAX,[R15 + -0x1] XOR R9D,R9D XOR ESI,ESI LEA R10,[R14 + RAX*0x1 + 0x1] MOV R14,-0x7fffaffe00000000 JMP 0x00101523 LAB_00101510: MOVSXD RCX,ESI ADD ESI,0x1 MOV byte ptr [RBX + RCX*0x1],R15B LAB_0010151a: ADD RDX,0x1 CMP R10,RDX JZ 0x0010154e LAB_00101523: MOVSX R15,byte ptr [RDX] MOV RCX,qword ptr [RDI] MOVZX ECX,word ptr [RCX + R15*0x2] TEST CH,0x1 JNZ 0x00101510 TEST CH,0x2 JZ 0x00101590 MOVSXD RCX,R9D ADD RDX,0x1 ADD R9D,0x1 MOV byte ptr [RBP + RCX*0x1],R15B CMP R10,RDX JNZ 0x00101523 LAB_0010154e: MOVSXD RSI,ESI MOVSXD R9,R9D MOVSXD R11,R11D MOVSXD R8,R8D ADD RBX,RSI ADD RBP,R9 ADD R12,R11 ADD R13,R8 LAB_00101566: MOV byte ptr [RBX],0x0 MOV byte ptr [RBP],0x0 MOV byte ptr [R12],0x0 MOV byte ptr [R13],0x0 ADD RSP,0x8 POP RBX POP RBP POP R12 POP R13 POP R14 POP R15 RET LAB_00101590: AND CH,0x8 JZ 0x001015a8 MOVSXD RCX,R11D ADD R11D,0x1 MOV byte ptr [R12 + RCX*0x1],R15B JMP 0x0010151a LAB_001015a8: CMP R15B,0x3f JA 0x0010151a BT R14,R15 JNC 0x0010151a MOVSXD RCX,R8D ADD R8D,0x1 MOV byte ptr [R13 + RCX*0x1],R15B JMP 0x0010151a
void func0(byte *param_1,int1 *param_2,int1 *param_3,int1 *param_4, int1 *param_5) { byte *pbVar1; byte bVar2; ushort uVar3; size_t sVar4; ushort **ppuVar5; long lVar6; int iVar7; int iVar8; int iVar9; int iVar10; sVar4 = strlen((char *)param_1); if (0 < (int)sVar4) { ppuVar5 = __ctype_b_loc(); iVar8 = 0; iVar10 = 0; iVar9 = 0; iVar7 = 0; pbVar1 = param_1 + (ulong)((int)sVar4 - 1) + 1; LAB_00101523: do { bVar2 = *param_1; uVar3 = (*ppuVar5)[(char)bVar2]; if ((uVar3 & 0x100) == 0) { if ((uVar3 & 0x200) != 0) { lVar6 = (long)iVar9; param_1 = param_1 + 1; iVar9 = iVar9 + 1; param_3[lVar6] = bVar2; if (pbVar1 == param_1) break; goto LAB_00101523; } if ((uVar3 & 0x800) == 0) { if ((bVar2 < 0x40) && ((0x8000500200000000U >> ((long)(char)bVar2 & 0x3fU) & 1) != 0)) { lVar6 = (long)iVar8; iVar8 = iVar8 + 1; param_5[lVar6] = bVar2; } } else { lVar6 = (long)iVar10; iVar10 = iVar10 + 1; param_4[lVar6] = bVar2; } } else { lVar6 = (long)iVar7; iVar7 = iVar7 + 1; param_2[lVar6] = bVar2; } param_1 = param_1 + 1; } while (pbVar1 != param_1); param_2 = param_2 + iVar7; param_3 = param_3 + iVar9; param_4 = param_4 + iVar10; param_5 = param_5 + iVar8; } *param_2 = 0; *param_3 = 0; *param_4 = 0; *param_5 = 0; return; }
4,623
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <ctype.h>
void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) { int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0; int len = strlen(string); for (int i = 0; i < len; i++) { if (isupper(string[i])) { uppercase_characters[upper_idx++] = string[i]; } else if (islower(string[i])) { lowercase_characters[lower_idx++] = string[i]; } else if (isdigit(string[i])) { numerical_characters[num_idx++] = string[i]; } else if (string[i] == ',' || string[i] == '.' || string[i] == '!' || string[i] == '?') { special_characters[special_idx++] = string[i]; } } uppercase_characters[upper_idx] = '\0'; lowercase_characters[lower_idx] = '\0'; numerical_characters[num_idx] = '\0'; special_characters[special_idx] = '\0'; }
int main() { char uppers[100], lowers[100], nums[100], specials[100]; func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials); assert(strcmp(uppers, "TIGG") == 0); assert(strcmp(lowers, "hisseeksforeeks") == 0); assert(strcmp(nums, "") == 0); assert(strcmp(specials, "") == 0); func0("Hithere2", uppers, lowers, nums, specials); assert(strcmp(uppers, "H") == 0); assert(strcmp(lowers, "ithere") == 0); assert(strcmp(nums, "2") == 0); assert(strcmp(specials, "") == 0); func0("HeyFolks32", uppers, lowers, nums, specials); assert(strcmp(uppers, "HF") == 0); assert(strcmp(lowers, "eyolks") == 0); assert(strcmp(nums, "32") == 0); assert(strcmp(specials, "") == 0); return 0; }
O3
c
func0: endbr64 push %r15 push %r14 push %r13 mov %rdi,%r13 push %r12 push %rbp mov %rdx,%rbp push %rbx mov %rsi,%rbx sub $0x38,%rsp mov %rcx,0x8(%rsp) mov %r8,0x10(%rsp) callq 1080 <strlen@plt> test %eax,%eax jle 1620 <func0+0x170> mov %rax,%r14 xor %r12d,%r12d xor %r15d,%r15d callq 10b0 <__ctype_b_loc@plt> lea -0x1(%r14),%edx mov %r13,%rdi xor %r11d,%r11d lea 0x1(%r13,%rdx,1),%rsi xor %edx,%edx xor %r13d,%r13d movl $0x0,0x2c(%rsp) mov %rsi,0x18(%rsp) movl $0x0,0x28(%rsp) movl $0x0,0x24(%rsp) jmp 1541 <func0+0x91> nopl 0x0(%rax,%rax,1) add $0x1,%r12d mov %r8b,(%r10) movslq %r12d,%r11 lea (%rbx,%r11,1),%r10 add $0x1,%rdi cmp %rdi,0x18(%rsp) je 1596 <func0+0xe6> movsbq (%rdi),%rsi mov (%rax),%rcx lea (%rbx,%r11,1),%r10 mov 0x10(%rsp),%r14 movzwl (%rcx,%rsi,2),%r9d mov 0x8(%rsp),%rcx mov %rsi,%r8 lea 0x0(%rbp,%rdx,1),%rsi add %r15,%r14 add %r13,%rcx test $0x100,%r9w jne 1528 <func0+0x78> test $0x200,%r9w je 15b8 <func0+0x108> addl $0x1,0x24(%rsp) movslq 0x24(%rsp),%rdx add $0x1,%rdi mov %r8b,(%rsi) lea 0x0(%rbp,%rdx,1),%rsi cmp %rdi,0x18(%rsp) jne 1541 <func0+0x91> movb $0x0,(%r10) movb $0x0,(%rsi) movb $0x0,(%rcx) movb $0x0,(%r14) add $0x38,%rsp pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 pop %r15 retq nopl 0x0(%rax,%rax,1) test $0x800,%r9w je 15e0 <func0+0x130> addl $0x1,0x28(%rsp) movslq 0x28(%rsp),%r13 mov %r8b,(%rcx) mov 0x8(%rsp),%rcx add %r13,%rcx jmpq 1536 <func0+0x86> nopw 0x0(%rax,%rax,1) cmp $0x3f,%r8b ja 1536 <func0+0x86> movabs $0x8000500200000000,%r9 bt %r8,%r9 jae 1536 <func0+0x86> mov %r8b,(%r14) mov 0x10(%rsp),%r8 addl $0x1,0x2c(%rsp) movslq 0x2c(%rsp),%r15 lea (%r8,%r15,1),%r14 jmpq 1536 <func0+0x86> nopl 0x0(%rax) mov 0x10(%rsp),%r14 mov 0x8(%rsp),%rcx mov %rbp,%rsi mov %rbx,%r10 jmpq 1596 <func0+0xe6> nopw %cs:0x0(%rax,%rax,1)
func0: endbr64 push r15 push r14 mov r14, rdi push r13 mov r13, r8 push r12 mov r12, rcx push rbp mov rbp, rdx push rbx mov rbx, rsi sub rsp, 8 call _strlen test eax, eax jle short loc_1545 mov r15, rax call ___ctype_b_loc mov rdx, r14 xor r11d, r11d xor r8d, r8d mov r9, rax lea eax, [r15-1] xor r10d, r10d xor edi, edi lea r14, [r14+rax+1] jmp short loc_1503 loc_14F0: movsxd rcx, edi add edi, 1 mov [rbx+rcx], sil loc_14FA: add rdx, 1 cmp r14, rdx jz short loc_152D loc_1503: movsx rsi, byte ptr [rdx] mov rcx, [r9] movzx ecx, word ptr [rcx+rsi*2] test ch, 1 jnz short loc_14F0 test ch, 2 jz short loc_1568 movsxd rcx, r10d add rdx, 1 add r10d, 1 mov [rbp+rcx+0], sil cmp r14, rdx jnz short loc_1503 loc_152D: movsxd rdi, edi movsxd r10, r10d movsxd r8, r8d movsxd r11, r11d add rbx, rdi add rbp, r10 add r12, r8 add r13, r11 loc_1545: mov byte ptr [rbx], 0 mov byte ptr [rbp+0], 0 mov byte ptr [r12], 0 mov byte ptr [r13+0], 0 add rsp, 8 pop rbx pop rbp pop r12 pop r13 pop r14 pop r15 retn loc_1568: and ch, 8 jz short loc_1580 movsxd rcx, r8d add r8d, 1 mov [r12+rcx], sil jmp short loc_14FA loc_1580: cmp sil, 3Fh ; '?' ja loc_14FA mov rcx, 8000500200000000h bt rcx, rsi jnb loc_14FA movsxd rcx, r11d add r11d, 1 mov [r13+rcx+0], sil jmp loc_14FA
size_t func0(const char *a1, _BYTE *a2, _BYTE *a3, _BYTE *a4, _BYTE *a5) { size_t result; // rax int v11; // r15d const unsigned __int16 **v12; // rax const char *v13; // rdx int v14; // r11d int v15; // r8d const unsigned __int16 **v16; // r9 int v17; // r10d int v18; // edi long long v19; // r14 long long v20; // rcx unsigned long long v21; // rsi unsigned __int16 v22; // cx long long v23; // rcx long long v24; // rcx unsigned long long v25; // rcx long long v26; // rcx result = strlen(a1); if ( (int)result > 0 ) { v11 = result; v12 = __ctype_b_loc(); v13 = a1; v14 = 0; v15 = 0; v16 = v12; result = (unsigned int)(v11 - 1); v17 = 0; v18 = 0; v19 = (long long)&a1[result + 1]; while ( 1 ) { while ( 1 ) { v21 = *v13; v22 = (*v16)[v21]; if ( (v22 & 0x100) == 0 ) break; v20 = v18++; a2[v20] = v21; LABEL_4: if ( (const char *)v19 == ++v13 ) goto LABEL_8; } if ( (v22 & 0x200) == 0 ) { if ( (v22 & 0x800) != 0 ) { v24 = v15++; a4[v24] = v21; } else if ( (unsigned __int8)v21 <= 0x3Fu ) { v25 = 0x8000500200000000LL; if ( _bittest64((const long long *)&v25, v21) ) { v26 = v14++; a5[v26] = v21; } } goto LABEL_4; } v23 = v17; ++v13; ++v17; a3[v23] = v21; if ( (const char *)v19 == v13 ) { LABEL_8: a2 += v18; a3 += v17; a4 += v15; a5 += v14; break; } } } *a2 = 0; *a3 = 0; *a4 = 0; *a5 = 0; return result; }
func0: ENDBR64 PUSH R15 PUSH R14 MOV R14,RDI PUSH R13 MOV R13,R8 PUSH R12 MOV R12,RCX PUSH RBP MOV RBP,RDX PUSH RBX MOV RBX,RSI SUB RSP,0x8 CALL 0x00101080 TEST EAX,EAX JLE 0x00101545 MOV R15,RAX CALL 0x001010b0 MOV RDX,R14 XOR R11D,R11D XOR R8D,R8D MOV R9,RAX LEA EAX,[R15 + -0x1] XOR R10D,R10D XOR EDI,EDI LEA R14,[R14 + RAX*0x1 + 0x1] JMP 0x00101503 LAB_001014f0: MOVSXD RCX,EDI ADD EDI,0x1 MOV byte ptr [RBX + RCX*0x1],SIL LAB_001014fa: ADD RDX,0x1 CMP R14,RDX JZ 0x0010152d LAB_00101503: MOVSX RSI,byte ptr [RDX] MOV RCX,qword ptr [R9] MOVZX ECX,word ptr [RCX + RSI*0x2] TEST CH,0x1 JNZ 0x001014f0 TEST CH,0x2 JZ 0x00101568 MOVSXD RCX,R10D ADD RDX,0x1 ADD R10D,0x1 MOV byte ptr [RBP + RCX*0x1],SIL CMP R14,RDX JNZ 0x00101503 LAB_0010152d: MOVSXD RDI,EDI MOVSXD R10,R10D MOVSXD R8,R8D MOVSXD R11,R11D ADD RBX,RDI ADD RBP,R10 ADD R12,R8 ADD R13,R11 LAB_00101545: MOV byte ptr [RBX],0x0 MOV byte ptr [RBP],0x0 MOV byte ptr [R12],0x0 MOV byte ptr [R13],0x0 ADD RSP,0x8 POP RBX POP RBP POP R12 POP R13 POP R14 POP R15 RET LAB_00101568: AND CH,0x8 JZ 0x00101580 MOVSXD RCX,R8D ADD R8D,0x1 MOV byte ptr [R12 + RCX*0x1],SIL JMP 0x001014fa LAB_00101580: CMP SIL,0x3f JA 0x001014fa MOV RCX,-0x7fffaffe00000000 BT RCX,RSI JNC 0x001014fa MOVSXD RCX,R11D ADD R11D,0x1 MOV byte ptr [R13 + RCX*0x1],SIL JMP 0x001014fa
void func0(byte *param_1,int *param_2,int *param_3,int *param_4,int *param_5 ) { byte *pbVar1; byte bVar2; ushort uVar3; size_t sVar4; ushort **ppuVar5; long lVar6; int iVar7; int iVar8; int iVar9; int iVar10; sVar4 = strlen((char *)param_1); if (0 < (int)sVar4) { ppuVar5 = __ctype_b_loc(); iVar10 = 0; iVar8 = 0; iVar9 = 0; iVar7 = 0; pbVar1 = param_1 + (ulong)((int)sVar4 - 1) + 1; LAB_00101503: do { bVar2 = *param_1; uVar3 = (*ppuVar5)[(char)bVar2]; if ((uVar3 & 0x100) == 0) { if ((uVar3 & 0x200) != 0) { lVar6 = (long)iVar9; param_1 = param_1 + 1; iVar9 = iVar9 + 1; param_3[lVar6] = bVar2; if (pbVar1 == param_1) break; goto LAB_00101503; } if ((uVar3 & 0x800) == 0) { if ((bVar2 < 0x40) && ((0x8000500200000000U >> ((long)(char)bVar2 & 0x3fU) & 1) != 0)) { lVar6 = (long)iVar10; iVar10 = iVar10 + 1; param_5[lVar6] = bVar2; } } else { lVar6 = (long)iVar8; iVar8 = iVar8 + 1; param_4[lVar6] = bVar2; } } else { lVar6 = (long)iVar7; iVar7 = iVar7 + 1; param_2[lVar6] = bVar2; } param_1 = param_1 + 1; } while (pbVar1 != param_1); param_2 = param_2 + iVar7; param_3 = param_3 + iVar9; param_4 = param_4 + iVar8; param_5 = param_5 + iVar10; } *param_2 = 0; *param_3 = 0; *param_4 = 0; *param_5 = 0; return; }
4,624
func0
#include <assert.h>
int func0(int arr[], int n, int k) { int count = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) { count++; } } } return count; }
int main() { int arr1[] = {1, 5, 3, 4, 2}; int arr2[] = {8, 12, 16, 4, 0, 20}; int arr3[] = {2, 4, 1, 3, 4}; assert(func0(arr1, 5, 3) == 2); assert(func0(arr2, 6, 4) == 5); assert(func0(arr3, 5, 2) == 3); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %rdi,-0x18(%rbp) mov %esi,-0x1c(%rbp) mov %edx,-0x20(%rbp) movl $0x0,-0xc(%rbp) movl $0x0,-0x8(%rbp) jmpq 1217 <func0+0xae> mov -0x8(%rbp),%eax add $0x1,%eax mov %eax,-0x4(%rbp) jmp 120b <func0+0xa2> mov -0x8(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x18(%rbp),%rax add %rdx,%rax mov (%rax),%edx mov -0x4(%rbp),%eax cltq lea 0x0(,%rax,4),%rcx mov -0x18(%rbp),%rax add %rcx,%rax mov (%rax),%eax sub %eax,%edx mov %edx,%eax cmp %eax,-0x20(%rbp) je 1203 <func0+0x9a> mov -0x4(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x18(%rbp),%rax add %rdx,%rax mov (%rax),%edx mov -0x8(%rbp),%eax cltq lea 0x0(,%rax,4),%rcx mov -0x18(%rbp),%rax add %rcx,%rax mov (%rax),%eax sub %eax,%edx mov %edx,%eax cmp %eax,-0x20(%rbp) jne 1207 <func0+0x9e> addl $0x1,-0xc(%rbp) addl $0x1,-0x4(%rbp) mov -0x4(%rbp),%eax cmp -0x1c(%rbp),%eax jl 1199 <func0+0x30> addl $0x1,-0x8(%rbp) mov -0x8(%rbp),%eax cmp -0x1c(%rbp),%eax jl 118e <func0+0x25> mov -0xc(%rbp),%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_18], rdi mov [rbp+var_1C], esi mov [rbp+var_20], edx mov [rbp+var_C], 0 mov [rbp+var_8], 0 jmp loc_1213 loc_118E: mov eax, [rbp+var_8] add eax, 1 mov [rbp+var_4], eax jmp short loc_1207 loc_1199: mov eax, [rbp+var_8] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rdx mov edx, [rax] mov eax, [rbp+var_4] cdqe lea rcx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rcx mov eax, [rax] sub edx, eax cmp [rbp+var_20], edx jz short loc_11FF mov eax, [rbp+var_4] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rdx mov edx, [rax] mov eax, [rbp+var_8] cdqe lea rcx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rcx mov eax, [rax] sub edx, eax cmp [rbp+var_20], edx jnz short loc_1203 loc_11FF: add [rbp+var_C], 1 loc_1203: add [rbp+var_4], 1 loc_1207: mov eax, [rbp+var_4] cmp eax, [rbp+var_1C] jl short loc_1199 add [rbp+var_8], 1 loc_1213: mov eax, [rbp+var_8] cmp eax, [rbp+var_1C] jl loc_118E mov eax, [rbp+var_C] pop rbp retn
long long func0(long long a1, int a2, int a3) { unsigned int v4; // [rsp+14h] [rbp-Ch] int i; // [rsp+18h] [rbp-8h] int j; // [rsp+1Ch] [rbp-4h] v4 = 0; for ( i = 0; i < a2; ++i ) { for ( j = i + 1; j < a2; ++j ) { if ( a3 == *(_DWORD *)(4LL * i + a1) - *(_DWORD *)(4LL * j + a1) || a3 == *(_DWORD *)(4LL * j + a1) - *(_DWORD *)(4LL * i + a1) ) { ++v4; } } } return v4; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV qword ptr [RBP + -0x18],RDI MOV dword ptr [RBP + -0x1c],ESI MOV dword ptr [RBP + -0x20],EDX MOV dword ptr [RBP + -0xc],0x0 MOV dword ptr [RBP + -0x8],0x0 JMP 0x00101213 LAB_0010118e: MOV EAX,dword ptr [RBP + -0x8] ADD EAX,0x1 MOV dword ptr [RBP + -0x4],EAX JMP 0x00101207 LAB_00101199: MOV EAX,dword ptr [RBP + -0x8] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOV EDX,dword ptr [RAX] MOV EAX,dword ptr [RBP + -0x4] CDQE LEA RCX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RCX MOV EAX,dword ptr [RAX] SUB EDX,EAX CMP dword ptr [RBP + -0x20],EDX JZ 0x001011ff MOV EAX,dword ptr [RBP + -0x4] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOV EDX,dword ptr [RAX] MOV EAX,dword ptr [RBP + -0x8] CDQE LEA RCX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RCX MOV EAX,dword ptr [RAX] SUB EDX,EAX CMP dword ptr [RBP + -0x20],EDX JNZ 0x00101203 LAB_001011ff: ADD dword ptr [RBP + -0xc],0x1 LAB_00101203: ADD dword ptr [RBP + -0x4],0x1 LAB_00101207: MOV EAX,dword ptr [RBP + -0x4] CMP EAX,dword ptr [RBP + -0x1c] JL 0x00101199 ADD dword ptr [RBP + -0x8],0x1 LAB_00101213: MOV EAX,dword ptr [RBP + -0x8] CMP EAX,dword ptr [RBP + -0x1c] JL 0x0010118e MOV EAX,dword ptr [RBP + -0xc] POP RBP RET
int func0(long param_1,int param_2,int param_3) { int4 local_14; int4 local_10; int4 local_c; local_14 = 0; for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) { while (local_c = local_c + 1, local_c < param_2) { if ((param_3 == *(int *)(param_1 + (long)local_10 * 4) - *(int *)(param_1 + (long)local_c * 4) ) || (param_3 == *(int *)(param_1 + (long)local_c * 4) - *(int *)(param_1 + (long)local_10 * 4))) { local_14 = local_14 + 1; } } } return local_14; }
4,625
func0
#include <assert.h>
int func0(int arr[], int n, int k) { int count = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) { count++; } } } return count; }
int main() { int arr1[] = {1, 5, 3, 4, 2}; int arr2[] = {8, 12, 16, 4, 0, 20}; int arr3[] = {2, 4, 1, 3, 4}; assert(func0(arr1, 5, 3) == 2); assert(func0(arr2, 6, 4) == 5); assert(func0(arr3, 5, 2) == 3); return 0; }
O1
c
func0: endbr64 test %esi,%esi jle 11bd <func0+0x54> push %rbx lea -0x1(%rsi),%ebx add $0x1,%rbx mov $0x1,%r11d mov $0x0,%r10d jmp 11ae <func0+0x45> add $0x1,%r10d add $0x1,%rax cmp %eax,%esi jle 11aa <func0+0x41> mov (%rdi,%rax,4),%ecx mov %r9d,%r8d sub %ecx,%r8d cmp %edx,%r8d je 1187 <func0+0x1e> sub %r9d,%ecx cmp %edx,%ecx jne 118b <func0+0x22> jmp 1187 <func0+0x1e> add $0x1,%r11 cmp %rbx,%r11 je 11c7 <func0+0x5e> mov -0x4(%rdi,%r11,4),%r9d mov %r11,%rax jmp 1193 <func0+0x2a> mov $0x0,%r10d mov %r10d,%eax retq mov %r10d,%eax pop %rbx retq
func0: endbr64 test esi, esi jle short loc_11B8 push rbx mov ebx, esi mov r11d, 1 mov r10d, 0 jmp short loc_11A9 loc_1182: add r10d, 1 loc_1186: add rax, 1 cmp esi, eax jle short loc_11A5 loc_118E: mov ecx, [rdi+rax*4] mov r8d, r9d sub r8d, ecx cmp r8d, edx jz short loc_1182 sub ecx, r9d cmp ecx, edx jnz short loc_1186 jmp short loc_1182 loc_11A5: add r11, 1 loc_11A9: cmp r11, rbx jz short loc_11C2 mov r9d, [rdi+r11*4-4] mov rax, r11 jmp short loc_118E loc_11B8: mov r10d, 0 mov eax, r10d retn loc_11C2: mov eax, r10d pop rbx retn
long long func0(long long a1, int a2, int a3) { long long v3; // r11 unsigned int v4; // r10d long long v5; // rax int v6; // ecx int v7; // r9d if ( a2 <= 0 ) return 0LL; v3 = 1LL; v4 = 0; while ( v3 != a2 ) { v7 = *(_DWORD *)(a1 + 4 * v3 - 4); v5 = v3; do { v6 = *(_DWORD *)(a1 + 4 * v5); if ( v7 - v6 == a3 || v6 - v7 == a3 ) ++v4; ++v5; } while ( a2 > (int)v5 ); ++v3; } return v4; }
func0: ENDBR64 TEST ESI,ESI JLE 0x001011b8 PUSH RBX MOV EBX,ESI MOV R11D,0x1 MOV R10D,0x0 JMP 0x001011a9 LAB_00101182: ADD R10D,0x1 LAB_00101186: ADD RAX,0x1 CMP ESI,EAX JLE 0x001011a5 LAB_0010118e: MOV ECX,dword ptr [RDI + RAX*0x4] MOV R8D,R9D SUB R8D,ECX CMP R8D,EDX JZ 0x00101182 SUB ECX,R9D CMP ECX,EDX JNZ 0x00101186 JMP 0x00101182 LAB_001011a5: ADD R11,0x1 LAB_001011a9: CMP R11,RBX JZ 0x001011c2 MOV R9D,dword ptr [RDI + R11*0x4 + -0x4] MOV RAX,R11 JMP 0x0010118e LAB_001011b8: MOV R10D,0x0 MOV EAX,R10D RET LAB_001011c2: MOV EAX,R10D POP RBX RET
int func0(long param_1,uint param_2,int param_3) { int iVar1; int iVar2; ulong uVar3; int iVar4; ulong uVar5; if (0 < (int)param_2) { iVar4 = 0; for (uVar5 = 1; uVar5 != param_2; uVar5 = uVar5 + 1) { iVar2 = *(int *)(param_1 + -4 + uVar5 * 4); uVar3 = uVar5; do { iVar1 = *(int *)(param_1 + uVar3 * 4); if ((iVar2 - iVar1 == param_3) || (iVar1 - iVar2 == param_3)) { iVar4 = iVar4 + 1; } uVar3 = uVar3 + 1; } while ((int)uVar3 < (int)param_2); } return iVar4; } return 0; }
4,626
func0
#include <assert.h>
int func0(int arr[], int n, int k) { int count = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) { count++; } } } return count; }
int main() { int arr1[] = {1, 5, 3, 4, 2}; int arr2[] = {8, 12, 16, 4, 0, 20}; int arr3[] = {2, 4, 1, 3, 4}; assert(func0(arr1, 5, 3) == 2); assert(func0(arr2, 6, 4) == 5); assert(func0(arr3, 5, 2) == 3); return 0; }
O2
c
func0: endbr64 test %esi,%esi jle 1407 <func0+0x67> push %rbx lea -0x1(%rsi),%ebx mov $0x1,%r11d xor %r10d,%r10d add $0x1,%rbx cmp %rbx,%r11 je 1402 <func0+0x62> xchg %ax,%ax mov -0x4(%rdi,%r11,4),%r9d mov %r11,%rax jmp 13df <func0+0x3f> nopw 0x0(%rax,%rax,1) sub %r9d,%ecx cmp %edx,%ecx je 13ed <func0+0x4d> add $0x1,%rax cmp %eax,%esi jle 13f9 <func0+0x59> mov (%rdi,%rax,4),%ecx mov %r9d,%r8d sub %ecx,%r8d cmp %edx,%r8d jne 13d0 <func0+0x30> add $0x1,%rax add $0x1,%r10d cmp %eax,%esi jg 13df <func0+0x3f> add $0x1,%r11 cmp %rbx,%r11 jne 13c0 <func0+0x20> mov %r10d,%eax pop %rbx retq xor %r10d,%r10d mov %r10d,%eax retq xchg %ax,%ax
func0: endbr64 test esi, esi jle short loc_1327 push rbx mov r11d, 1 movsxd rbx, esi xor r10d, r10d cmp r11, rbx jz short loc_1322 nop word ptr [rax+rax+00h] loc_12E0: mov r9d, [rdi+r11*4-4] mov rax, r11 jmp short loc_12FF loc_12F0: sub ecx, r9d cmp ecx, edx jz short loc_130D add rax, 1 cmp esi, eax jle short loc_1319 loc_12FF: mov ecx, [rdi+rax*4] mov r8d, r9d sub r8d, ecx cmp r8d, edx jnz short loc_12F0 loc_130D: add rax, 1 add r10d, 1 cmp esi, eax jg short loc_12FF loc_1319: add r11, 1 cmp r11, rbx jnz short loc_12E0 loc_1322: mov eax, r10d pop rbx retn loc_1327: xor eax, eax retn
long long func0(long long a1, int a2, int a3) { long long v3; // r11 unsigned int i; // r10d int v5; // r9d long long v6; // rax int v7; // ecx if ( a2 <= 0 ) return 0LL; v3 = 1LL; for ( i = 0; v3 != a2; ++v3 ) { v5 = *(_DWORD *)(a1 + 4 * v3 - 4); v6 = v3; do { while ( 1 ) { v7 = *(_DWORD *)(a1 + 4 * v6); if ( v5 - v7 == a3 || v7 - v5 == a3 ) break; if ( a2 <= (int)++v6 ) goto LABEL_8; } ++v6; ++i; } while ( a2 > (int)v6 ); LABEL_8: ; } return i; }
func0: ENDBR64 TEST ESI,ESI JLE 0x00101327 PUSH RBX MOV R11D,0x1 MOVSXD RBX,ESI XOR R10D,R10D CMP R11,RBX JZ 0x00101322 NOP word ptr [RAX + RAX*0x1] LAB_001012e0: MOV R9D,dword ptr [RDI + R11*0x4 + -0x4] MOV RAX,R11 JMP 0x001012ff LAB_001012f0: SUB ECX,R9D CMP ECX,EDX JZ 0x0010130d ADD RAX,0x1 CMP ESI,EAX JLE 0x00101319 LAB_001012ff: MOV ECX,dword ptr [RDI + RAX*0x4] MOV R8D,R9D SUB R8D,ECX CMP R8D,EDX JNZ 0x001012f0 LAB_0010130d: ADD RAX,0x1 ADD R10D,0x1 CMP ESI,EAX JG 0x001012ff LAB_00101319: ADD R11,0x1 CMP R11,RBX JNZ 0x001012e0 LAB_00101322: MOV EAX,R10D POP RBX RET LAB_00101327: XOR EAX,EAX RET
int func0(long param_1,int param_2,int param_3) { int iVar1; int iVar2; long lVar3; int iVar4; long lVar5; if (param_2 < 1) { return 0; } lVar5 = 1; iVar4 = 0; if ((long)param_2 != 1) { do { iVar1 = *(int *)(param_1 + -4 + lVar5 * 4); lVar3 = lVar5; do { while ((iVar2 = *(int *)(param_1 + lVar3 * 4), iVar1 - iVar2 != param_3 && (iVar2 - iVar1 != param_3))) { lVar3 = lVar3 + 1; if (param_2 <= (int)lVar3) goto LAB_00101319; } lVar3 = lVar3 + 1; iVar4 = iVar4 + 1; } while ((int)lVar3 < param_2); LAB_00101319: lVar5 = lVar5 + 1; } while (lVar5 != param_2); } return iVar4; }
4,627
func0
#include <assert.h>
int func0(int arr[], int n, int k) { int count = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) { count++; } } } return count; }
int main() { int arr1[] = {1, 5, 3, 4, 2}; int arr2[] = {8, 12, 16, 4, 0, 20}; int arr3[] = {2, 4, 1, 3, 4}; assert(func0(arr1, 5, 3) == 2); assert(func0(arr2, 6, 4) == 5); assert(func0(arr3, 5, 2) == 3); return 0; }
O3
c
func0: endbr64 push %r13 push %r12 push %rbp push %rbx test %esi,%esi jle 150e <func0+0x19e> cmp $0x1,%esi je 150e <func0+0x19e> movd %edx,%xmm6 lea 0x4(%rdi),%r11 xor %r12d,%r12d mov $0x1,%ebx pshufd $0x0,%xmm6,%xmm4 mov $0x1,%r8d lea -0x1(%rsi),%ebp pxor %xmm6,%xmm6 nopl (%rax) mov %esi,%r9d mov %ebp,%eax mov -0x4(%r11),%r10d sub %r8d,%r9d cmp %esi,%r8d cmovge %ebx,%r9d sub %r8d,%eax cmp $0x2,%eax jbe 1506 <func0+0x196> cmp %esi,%r8d jge 1506 <func0+0x196> mov %r9d,%ecx movd %r10d,%xmm7 pxor %xmm2,%xmm2 mov %r11,%rax shr $0x2,%ecx pshufd $0x0,%xmm7,%xmm3 shl $0x4,%rcx add %r11,%rcx nopw %cs:0x0(%rax,%rax,1) movdqu (%rax),%xmm7 movdqa %xmm3,%xmm1 add $0x10,%rax psubd %xmm7,%xmm1 movdqa %xmm7,%xmm0 pcmpeqd %xmm4,%xmm1 psubd %xmm3,%xmm0 pcmpeqd %xmm4,%xmm0 movdqa %xmm1,%xmm5 pcmpeqd %xmm6,%xmm5 pand %xmm5,%xmm0 por %xmm1,%xmm0 psubd %xmm0,%xmm2 cmp %rcx,%rax jne 1400 <func0+0x90> movdqa %xmm2,%xmm0 mov %r9d,%ecx psrldq $0x8,%xmm0 and $0xfffffffc,%ecx paddd %xmm0,%xmm2 movdqa %xmm2,%xmm0 psrldq $0x4,%xmm0 paddd %xmm0,%xmm2 movd %xmm2,%eax add %eax,%r12d lea (%rcx,%r8,1),%eax cmp %ecx,%r9d je 14c3 <func0+0x153> movslq %eax,%rcx mov %r10d,%r13d lea 0x0(,%rcx,4),%r9 mov (%rdi,%rcx,4),%ecx sub %ecx,%r13d cmp %r13d,%edx je 14e0 <func0+0x170> sub %r10d,%ecx cmp %ecx,%edx je 14e0 <func0+0x170> lea 0x1(%rax),%ecx cmp %ecx,%esi jle 14c3 <func0+0x153> mov 0x4(%rdi,%r9,1),%ecx mov %r10d,%r13d sub %ecx,%r13d cmp %r13d,%edx je 14f0 <func0+0x180> sub %r10d,%ecx cmp %ecx,%edx je 14f0 <func0+0x180> add $0x2,%eax cmp %eax,%esi jle 14c3 <func0+0x153> mov 0x8(%rdi,%r9,1),%eax mov %r10d,%ecx sub %eax,%ecx cmp %ecx,%edx je 1500 <func0+0x190> sub %r10d,%eax cmp %eax,%edx je 1500 <func0+0x190> add $0x1,%r8d add $0x4,%r11 cmp %r8d,%esi jne 13b0 <func0+0x40> pop %rbx mov %r12d,%eax pop %rbp pop %r12 pop %r13 retq xchg %ax,%ax add $0x1,%r12d jmp 1489 <func0+0x119> nopw %cs:0x0(%rax,%rax,1) add $0x1,%r12d jmp 14a7 <func0+0x137> nopw %cs:0x0(%rax,%rax,1) add $0x1,%r12d jmp 14c3 <func0+0x153> mov %r8d,%eax jmpq 1469 <func0+0xf9> xor %r12d,%r12d pop %rbx pop %rbp mov %r12d,%eax pop %r12 pop %r13 retq nopl 0x0(%rax,%rax,1)
func0: endbr64 test esi, esi jle loc_14AD cmp esi, 1 jz loc_14AD movd xmm7, edx push r13 mov r11d, edx lea r9, [rdi+4] push r12 xor r10d, r10d mov ecx, 1 lea r12d, [rsi-1] push rbp pshufd xmm4, xmm7, 0 mov ebp, 1 push rbx mov rbx, rdi nop loc_1370: mov edi, esi mov eax, r12d mov r8d, [r9-4] sub edi, ecx cmp ecx, esi cmovge edi, ebp sub eax, ecx cmp eax, 2 jbe loc_14A6 cmp ecx, esi jge loc_14A6 mov edx, edi movd xmm6, r8d pxor xmm2, xmm2 mov rax, r9 shr edx, 2 pshufd xmm3, xmm6, 0 shl rdx, 4 add rdx, r9 loc_13B0: movdqu xmm5, xmmword ptr [rax] movdqa xmm0, xmm3 add rax, 10h psubd xmm0, xmm5 movdqa xmm1, xmm0 movdqa xmm0, xmm5 psubd xmm0, xmm3 pcmpeqd xmm1, xmm4 pcmpeqd xmm0, xmm4 por xmm0, xmm1 psubd xmm2, xmm0 cmp rax, rdx jnz short loc_13B0 movdqa xmm0, xmm2 psrldq xmm0, 8 paddd xmm2, xmm0 movdqa xmm0, xmm2 psrldq xmm0, 4 paddd xmm2, xmm0 movd eax, xmm2 add r10d, eax mov eax, edi and eax, 0FFFFFFFCh add eax, ecx and edi, 3 jz short loc_146A loc_140E: movsxd rdx, eax mov r13d, r8d lea rdi, ds:0[rdx*4] mov edx, [rbx+rdx*4] sub r13d, edx cmp r11d, r13d jz short loc_1488 sub edx, r8d cmp r11d, edx jz short loc_1488 loc_142F: lea edx, [rax+1] cmp esi, edx jle short loc_146A mov edx, [rbx+rdi+4] mov r13d, r8d sub r13d, edx cmp r11d, r13d jz short loc_1490 sub edx, r8d cmp r11d, edx jz short loc_1490 loc_144D: add eax, 2 cmp esi, eax jle short loc_146A mov eax, [rbx+rdi+8] mov edx, r8d sub edx, eax cmp r11d, edx jz short loc_14A0 sub eax, r8d cmp r11d, eax jz short loc_14A0 loc_146A: add ecx, 1 add r9, 4 cmp esi, ecx jnz loc_1370 pop rbx mov eax, r10d pop rbp pop r12 pop r13 retn loc_1488: add r10d, 1 jmp short loc_142F loc_1490: add r10d, 1 jmp short loc_144D loc_14A0: add r10d, 1 jmp short loc_146A loc_14A6: mov eax, ecx jmp loc_140E loc_14AD: xor r10d, r10d mov eax, r10d retn
long long func0(long long a1, int a2, unsigned int a3) { const __m128i *v4; // r9 unsigned int v5; // r10d int v6; // ecx __m128i v7; // xmm4 unsigned int v9; // r8d unsigned int v10; // edi __m128i v11; // xmm2 const __m128i *v12; // rax __m128i v13; // xmm3 __m128i v14; // xmm5 __m128i v15; // xmm2 int v16; // eax long long v17; // rdi int v18; // edx int v19; // edx int v20; // eax if ( a2 >= 2 ) { v4 = (const __m128i *)(a1 + 4); v5 = 0; v6 = 1; v7 = _mm_shuffle_epi32(_mm_cvtsi32_si128(a3), 0); while ( 1 ) { v9 = v4[-1].m128i_u32[3]; v10 = a2 - v6; if ( v6 >= a2 ) v10 = 1; if ( (unsigned int)(a2 - 1 - v6) <= 2 || v6 >= a2 ) break; v11 = 0LL; v12 = v4; v13 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v9), 0); do { v14 = _mm_loadu_si128(v12++); v11 = _mm_sub_epi32( v11, _mm_or_si128(_mm_cmpeq_epi32(_mm_sub_epi32(v14, v13), v7), _mm_cmpeq_epi32(_mm_sub_epi32(v13, v14), v7))); } while ( v12 != &v4[v10 >> 2] ); v15 = _mm_add_epi32(v11, _mm_srli_si128(v11, 8)); v5 += _mm_cvtsi128_si32(_mm_add_epi32(v15, _mm_srli_si128(v15, 4))); v16 = v6 + (v10 & 0xFFFFFFFC); if ( (v10 & 3) != 0 ) goto LABEL_10; LABEL_18: ++v6; v4 = (const __m128i *)((char *)v4 + 4); if ( a2 == v6 ) return v5; } v16 = v6; LABEL_10: v17 = 4LL * v16; v18 = *(_DWORD *)(a1 + v17); if ( a3 == v9 - v18 || a3 == v18 - v9 ) ++v5; if ( a2 > v16 + 1 ) { v19 = *(_DWORD *)(a1 + v17 + 4); if ( a3 == v9 - v19 || a3 == v19 - v9 ) ++v5; if ( a2 > v16 + 2 ) { v20 = *(_DWORD *)(a1 + v17 + 8); if ( a3 == v9 - v20 || a3 == v20 - v9 ) ++v5; } } goto LABEL_18; } return 0LL; }
func0: ENDBR64 TEST ESI,ESI JLE 0x001014ad CMP ESI,0x1 JZ 0x001014ad MOVD XMM7,EDX PUSH R13 MOV R11D,EDX LEA R9,[RDI + 0x4] PUSH R12 XOR R10D,R10D MOV ECX,0x1 LEA R12D,[RSI + -0x1] PUSH RBP PSHUFD XMM4,XMM7,0x0 MOV EBP,0x1 PUSH RBX MOV RBX,RDI NOP LAB_00101370: MOV EDI,ESI MOV EAX,R12D MOV R8D,dword ptr [R9 + -0x4] SUB EDI,ECX CMP ECX,ESI CMOVGE EDI,EBP SUB EAX,ECX CMP EAX,0x2 JBE 0x001014a6 CMP ECX,ESI JGE 0x001014a6 MOV EDX,EDI MOVD XMM6,R8D PXOR XMM2,XMM2 MOV RAX,R9 SHR EDX,0x2 PSHUFD XMM3,XMM6,0x0 SHL RDX,0x4 ADD RDX,R9 LAB_001013b0: MOVDQU XMM5,xmmword ptr [RAX] MOVDQA XMM0,XMM3 ADD RAX,0x10 PSUBD XMM0,XMM5 MOVDQA XMM1,XMM0 MOVDQA XMM0,XMM5 PSUBD XMM0,XMM3 PCMPEQD XMM1,XMM4 PCMPEQD XMM0,XMM4 POR XMM0,XMM1 PSUBD XMM2,XMM0 CMP RAX,RDX JNZ 0x001013b0 MOVDQA XMM0,XMM2 PSRLDQ XMM0,0x8 PADDD XMM2,XMM0 MOVDQA XMM0,XMM2 PSRLDQ XMM0,0x4 PADDD XMM2,XMM0 MOVD EAX,XMM2 ADD R10D,EAX MOV EAX,EDI AND EAX,0xfffffffc ADD EAX,ECX AND EDI,0x3 JZ 0x0010146a LAB_0010140e: MOVSXD RDX,EAX MOV R13D,R8D LEA RDI,[RDX*0x4] MOV EDX,dword ptr [RBX + RDX*0x4] SUB R13D,EDX CMP R11D,R13D JZ 0x00101488 SUB EDX,R8D CMP R11D,EDX JZ 0x00101488 LAB_0010142f: LEA EDX,[RAX + 0x1] CMP ESI,EDX JLE 0x0010146a MOV EDX,dword ptr [RBX + RDI*0x1 + 0x4] MOV R13D,R8D SUB R13D,EDX CMP R11D,R13D JZ 0x00101490 SUB EDX,R8D CMP R11D,EDX JZ 0x00101490 LAB_0010144d: ADD EAX,0x2 CMP ESI,EAX JLE 0x0010146a MOV EAX,dword ptr [RBX + RDI*0x1 + 0x8] MOV EDX,R8D SUB EDX,EAX CMP R11D,EDX JZ 0x001014a0 SUB EAX,R8D CMP R11D,EAX JZ 0x001014a0 LAB_0010146a: ADD ECX,0x1 ADD R9,0x4 CMP ESI,ECX JNZ 0x00101370 POP RBX MOV EAX,R10D POP RBP POP R12 POP R13 RET LAB_00101488: ADD R10D,0x1 JMP 0x0010142f LAB_00101490: ADD R10D,0x1 JMP 0x0010144d LAB_001014a0: ADD R10D,0x1 JMP 0x0010146a LAB_001014a6: MOV EAX,ECX JMP 0x0010140e LAB_001014ad: XOR R10D,R10D MOV EAX,R10D RET
int func0(long param_1,int param_2,int param_3) { long lVar1; int iVar2; uint uVar3; int iVar4; int *piVar5; int *piVar6; int *piVar7; int *piVar8; int iVar9; int *piVar10; int iVar11; int iVar12; int iVar13; int iVar14; int iVar15; if ((param_2 < 1) || (param_2 == 1)) { return 0; } piVar10 = (int *)(param_1 + 4); iVar11 = 0; iVar9 = 1; do { iVar2 = piVar10[-1]; uVar3 = param_2 - iVar9; if (param_2 <= iVar9) { uVar3 = 1; } iVar12 = iVar9; if (((uint)((param_2 + -1) - iVar9) < 3) || (param_2 <= iVar9)) { LAB_0010140e: lVar1 = (long)iVar12 * 4; iVar13 = *(int *)(param_1 + (long)iVar12 * 4); if ((param_3 == iVar2 - iVar13) || (param_3 == iVar13 - iVar2)) { iVar11 = iVar11 + 1; } if (iVar12 + 1 < param_2) { iVar13 = *(int *)(param_1 + 4 + lVar1); if ((param_3 == iVar2 - iVar13) || (param_3 == iVar13 - iVar2)) { iVar11 = iVar11 + 1; } if ((iVar12 + 2 < param_2) && ((iVar12 = *(int *)(param_1 + 8 + lVar1), param_3 == iVar2 - iVar12 || (param_3 == iVar12 - iVar2)))) { iVar11 = iVar11 + 1; } } } else { iVar12 = 0; iVar13 = 0; iVar14 = 0; iVar15 = 0; piVar8 = piVar10; do { iVar4 = *piVar8; piVar5 = piVar8 + 1; piVar6 = piVar8 + 2; piVar7 = piVar8 + 3; piVar8 = piVar8 + 4; iVar12 = iVar12 + (uint)(iVar4 - iVar2 == param_3 || iVar2 - iVar4 == param_3); iVar13 = iVar13 + (uint)(*piVar5 - iVar2 == param_3 || iVar2 - *piVar5 == param_3); iVar14 = iVar14 + (uint)(*piVar6 - iVar2 == param_3 || iVar2 - *piVar6 == param_3); iVar15 = iVar15 + (uint)(*piVar7 - iVar2 == param_3 || iVar2 - *piVar7 == param_3); } while (piVar8 != piVar10 + (ulong)(uVar3 >> 2) * 4); iVar11 = iVar11 + iVar12 + iVar14 + iVar13 + iVar15; iVar12 = (uVar3 & 0xfffffffc) + iVar9; if ((uVar3 & 3) != 0) goto LAB_0010140e; } iVar9 = iVar9 + 1; piVar10 = piVar10 + 1; if (param_2 == iVar9) { return iVar11; } } while( true ); }
4,628
func0
#include <stdbool.h> #include <assert.h>
bool func0(int list[], int count, int num) { for (int i = 0; i < count; i++) { if (list[i] < num) { return false; } } return true; }
int main() { int arr1[] = {220, 330, 500}; int arr2[] = {12, 17, 21}; int arr3[] = {1, 2, 3, 4}; assert(func0(arr1, 3, 200) == true); assert(func0(arr2, 3, 20) == false); assert(func0(arr3, 4, 10) == false); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %rdi,-0x18(%rbp) mov %esi,-0x1c(%rbp) mov %edx,-0x20(%rbp) movl $0x0,-0x4(%rbp) jmp 11aa <func0+0x41> mov -0x4(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x18(%rbp),%rax add %rdx,%rax mov (%rax),%eax cmp %eax,-0x20(%rbp) jle 11a6 <func0+0x3d> mov $0x0,%eax jmp 11b7 <func0+0x4e> addl $0x1,-0x4(%rbp) mov -0x4(%rbp),%eax cmp -0x1c(%rbp),%eax jl 1184 <func0+0x1b> mov $0x1,%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_18], rdi mov [rbp+var_1C], esi mov [rbp+var_20], edx mov [rbp+var_4], 0 jmp short loc_11AA loc_1184: mov eax, [rbp+var_4] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rdx mov eax, [rax] cmp [rbp+var_20], eax jle short loc_11A6 mov eax, 0 jmp short loc_11B7 loc_11A6: add [rbp+var_4], 1 loc_11AA: mov eax, [rbp+var_4] cmp eax, [rbp+var_1C] jl short loc_1184 mov eax, 1 loc_11B7: pop rbp retn
long long func0(long long a1, int a2, int a3) { int i; // [rsp+1Ch] [rbp-4h] for ( i = 0; i < a2; ++i ) { if ( a3 > *(_DWORD *)(4LL * i + a1) ) return 0LL; } return 1LL; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV qword ptr [RBP + -0x18],RDI MOV dword ptr [RBP + -0x1c],ESI MOV dword ptr [RBP + -0x20],EDX MOV dword ptr [RBP + -0x4],0x0 JMP 0x001011aa LAB_00101184: MOV EAX,dword ptr [RBP + -0x4] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOV EAX,dword ptr [RAX] CMP dword ptr [RBP + -0x20],EAX JLE 0x001011a6 MOV EAX,0x0 JMP 0x001011b7 LAB_001011a6: ADD dword ptr [RBP + -0x4],0x1 LAB_001011aa: MOV EAX,dword ptr [RBP + -0x4] CMP EAX,dword ptr [RBP + -0x1c] JL 0x00101184 MOV EAX,0x1 LAB_001011b7: POP RBP RET
int8 func0(long param_1,int param_2,int param_3) { int local_c; local_c = 0; while( true ) { if (param_2 <= local_c) { return 1; } if (*(int *)(param_1 + (long)local_c * 4) < param_3) break; local_c = local_c + 1; } return 0; }
4,629
func0
#include <stdbool.h> #include <assert.h>
bool func0(int list[], int count, int num) { for (int i = 0; i < count; i++) { if (list[i] < num) { return false; } } return true; }
int main() { int arr1[] = {220, 330, 500}; int arr2[] = {12, 17, 21}; int arr3[] = {1, 2, 3, 4}; assert(func0(arr1, 3, 200) == true); assert(func0(arr2, 3, 20) == false); assert(func0(arr3, 4, 10) == false); return 0; }
O1
c
func0: endbr64 test %esi,%esi jle 118f <func0+0x26> mov %rdi,%rax lea -0x1(%rsi),%ecx lea 0x4(%rdi,%rcx,4),%rcx cmp %edx,(%rax) jl 1195 <func0+0x2c> add $0x4,%rax cmp %rcx,%rax jne 117c <func0+0x13> mov $0x1,%eax retq mov $0x1,%eax retq mov $0x0,%eax retq
func0: endbr64 test esi, esi jle short loc_118F mov rax, rdi lea ecx, [rsi-1] lea rcx, [rdi+rcx*4+4] loc_117C: cmp [rax], edx jl short loc_1195 add rax, 4 cmp rax, rcx jnz short loc_117C mov eax, 1 retn loc_118F: mov eax, 1 retn loc_1195: mov eax, 0 retn
long long func0(_DWORD *a1, int a2, int a3) { _DWORD *v3; // rax if ( a2 <= 0 ) return 1LL; v3 = a1; while ( *v3 >= a3 ) { if ( ++v3 == &a1[a2 - 1 + 1] ) return 1LL; } return 0LL; }
func0: ENDBR64 TEST ESI,ESI JLE 0x0010118f MOV RAX,RDI LEA ECX,[RSI + -0x1] LEA RCX,[RDI + RCX*0x4 + 0x4] LAB_0010117c: CMP dword ptr [RAX],EDX JL 0x00101195 ADD RAX,0x4 CMP RAX,RCX JNZ 0x0010117c MOV EAX,0x1 RET LAB_0010118f: MOV EAX,0x1 RET LAB_00101195: MOV EAX,0x0 RET
int8 func0(int *param_1,int param_2,int param_3) { int *piVar1; if (param_2 < 1) { return 1; } piVar1 = param_1 + (ulong)(param_2 - 1) + 1; do { if (*param_1 < param_3) { return 0; } param_1 = param_1 + 1; } while (param_1 != piVar1); return 1; }
4,630
func0
#include <stdbool.h> #include <assert.h>
bool func0(int list[], int count, int num) { for (int i = 0; i < count; i++) { if (list[i] < num) { return false; } } return true; }
int main() { int arr1[] = {220, 330, 500}; int arr2[] = {12, 17, 21}; int arr3[] = {1, 2, 3, 4}; assert(func0(arr1, 3, 200) == true); assert(func0(arr2, 3, 20) == false); assert(func0(arr3, 4, 10) == false); return 0; }
O2
c
func0: endbr64 test %esi,%esi jle 1170 <func0+0x30> lea -0x1(%rsi),%eax lea 0x4(%rdi,%rax,4),%rax jmp 1161 <func0+0x21> nopw 0x0(%rax,%rax,1) add $0x4,%rdi cmp %rax,%rdi je 1170 <func0+0x30> cmp %edx,(%rdi) jge 1158 <func0+0x18> xor %eax,%eax retq nopl 0x0(%rax,%rax,1) mov $0x1,%eax retq nopw %cs:0x0(%rax,%rax,1)
func0: endbr64 test esi, esi jle short loc_1170 lea eax, [rsi-1] lea rax, [rdi+rax*4+4] jmp short loc_1161 loc_1158: add rdi, 4 cmp rdi, rax jz short loc_1170 loc_1161: cmp [rdi], edx jge short loc_1158 xor eax, eax retn loc_1170: mov eax, 1 retn
long long func0(_DWORD *a1, int a2, int a3) { long long v3; // rax if ( a2 <= 0 ) return 1LL; v3 = (long long)&a1[a2 - 1 + 1]; while ( *a1 >= a3 ) { if ( ++a1 == (_DWORD *)v3 ) return 1LL; } return 0LL; }
func0: ENDBR64 TEST ESI,ESI JLE 0x00101170 LEA EAX,[RSI + -0x1] LEA RAX,[RDI + RAX*0x4 + 0x4] JMP 0x00101161 LAB_00101158: ADD RDI,0x4 CMP RDI,RAX JZ 0x00101170 LAB_00101161: CMP dword ptr [RDI],EDX JGE 0x00101158 XOR EAX,EAX RET LAB_00101170: MOV EAX,0x1 RET
int8 func0(int *param_1,int param_2,int param_3) { int *piVar1; if (0 < param_2) { piVar1 = param_1 + (ulong)(param_2 - 1) + 1; do { if (*param_1 < param_3) { return 0; } param_1 = param_1 + 1; } while (param_1 != piVar1); } return 1; }
4,631
func0
#include <stdbool.h> #include <assert.h>
bool func0(int list[], int count, int num) { for (int i = 0; i < count; i++) { if (list[i] < num) { return false; } } return true; }
int main() { int arr1[] = {220, 330, 500}; int arr2[] = {12, 17, 21}; int arr3[] = {1, 2, 3, 4}; assert(func0(arr1, 3, 200) == true); assert(func0(arr2, 3, 20) == false); assert(func0(arr3, 4, 10) == false); return 0; }
O3
c
func0: endbr64 test %esi,%esi jle 1170 <func0+0x30> lea -0x1(%rsi),%eax lea 0x4(%rdi,%rax,4),%rax jmp 1161 <func0+0x21> nopw 0x0(%rax,%rax,1) add $0x4,%rdi cmp %rax,%rdi je 1170 <func0+0x30> cmp %edx,(%rdi) jge 1158 <func0+0x18> xor %eax,%eax retq nopl 0x0(%rax,%rax,1) mov $0x1,%eax retq nopw %cs:0x0(%rax,%rax,1)
func0: endbr64 test esi, esi jle short loc_1170 movsxd rsi, esi lea rax, [rdi+rsi*4] jmp short loc_1161 loc_1158: add rdi, 4 cmp rdi, rax jz short loc_1170 loc_1161: cmp [rdi], edx jge short loc_1158 xor eax, eax retn loc_1170: mov eax, 1 retn
long long func0(_DWORD *a1, int a2, int a3) { _DWORD *v3; // rax if ( a2 <= 0 ) return 1LL; v3 = &a1[a2]; while ( *a1 >= a3 ) { if ( ++a1 == v3 ) return 1LL; } return 0LL; }
func0: ENDBR64 TEST ESI,ESI JLE 0x00101170 MOVSXD RSI,ESI LEA RAX,[RDI + RSI*0x4] JMP 0x00101161 LAB_00101158: ADD RDI,0x4 CMP RDI,RAX JZ 0x00101170 LAB_00101161: CMP dword ptr [RDI],EDX JGE 0x00101158 XOR EAX,EAX RET LAB_00101170: MOV EAX,0x1 RET
int8 func0(int *param_1,int param_2,int param_3) { int *piVar1; if (0 < param_2) { piVar1 = param_1 + param_2; do { if (*param_1 < param_3) { return 0; } param_1 = param_1 + 1; } while (param_1 != piVar1); } return 1; }
4,632
func0
#include <assert.h> #include <stdio.h>
double* func0(double a, double b, double c) { static double focus[2]; focus[0] = -b / (2 * a); focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a); return focus; }
int main() { double *result; result = func0(5, 3, 2); assert(result[0] == -0.3); assert(result[1] == 1.6); result = func0(9, 8, 4); assert(result[0] == -0.4444444444444444); assert(result[1] == 2.25); result = func0(2, 4, 6); assert(result[0] == -1.0); assert(result[1] == 4.125); printf("All tests passed successfully.\n"); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp movsd %xmm0,-0x8(%rbp) movsd %xmm1,-0x10(%rbp) movsd %xmm2,-0x18(%rbp) movsd -0x10(%rbp),%xmm0 movq 0xf63(%rip),%xmm1 xorpd %xmm0,%xmm1 movsd -0x8(%rbp),%xmm0 addsd %xmm0,%xmm0 divsd %xmm0,%xmm1 movapd %xmm1,%xmm0 movsd %xmm0,0x2e76(%rip) movsd -0x8(%rbp),%xmm1 movsd 0xf49(%rip),%xmm0 mulsd %xmm1,%xmm0 movapd %xmm0,%xmm1 mulsd -0x18(%rbp),%xmm1 movsd -0x10(%rbp),%xmm0 mulsd %xmm0,%xmm0 subsd %xmm0,%xmm1 movsd 0xf2f(%rip),%xmm0 addsd %xmm1,%xmm0 movsd -0x8(%rbp),%xmm2 movsd 0xf16(%rip),%xmm1 mulsd %xmm2,%xmm1 divsd %xmm1,%xmm0 movsd %xmm0,0x2e2e(%rip) lea 0x2e1f(%rip),%rax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp movsd [rbp+var_8], xmm0 movsd [rbp+var_10], xmm1 movsd [rbp+var_18], xmm2 movsd xmm0, [rbp+var_10] movq xmm1, cs:qword_20E0 xorpd xmm1, xmm0 movsd xmm0, [rbp+var_8] movapd xmm2, xmm0 addsd xmm2, xmm0 divsd xmm1, xmm2 movapd xmm0, xmm1 movsd cs:focus_1, xmm0 movsd xmm1, [rbp+var_8] movsd xmm0, cs:qword_20F0 mulsd xmm0, xmm1 movapd xmm1, xmm0 mulsd xmm1, [rbp+var_18] movsd xmm0, [rbp+var_10] mulsd xmm0, xmm0 subsd xmm1, xmm0 movsd xmm0, cs:qword_20F8 addsd xmm0, xmm1 movsd xmm2, [rbp+var_8] movsd xmm1, cs:qword_20F0 mulsd xmm1, xmm2 divsd xmm0, xmm1 movsd cs:qword_4028, xmm0 lea rax, focus_1 pop rbp retn
long long * func0(double a1, double a2, double a3) { *(double *)&focus_1 = -a2 / (a1 + a1); *(double *)&qword_4028 = (4.0 * a1 * a3 - a2 * a2 + 1.0) / (4.0 * a1); return &focus_1; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOVSD qword ptr [RBP + -0x8],XMM0 MOVSD qword ptr [RBP + -0x10],XMM1 MOVSD qword ptr [RBP + -0x18],XMM2 MOVSD XMM0,qword ptr [RBP + -0x10] MOVQ XMM1,qword ptr [0x001020e0] XORPD XMM1,XMM0 MOVSD XMM0,qword ptr [RBP + -0x8] MOVAPD XMM2,XMM0 ADDSD XMM2,XMM0 DIVSD XMM1,XMM2 MOVAPD XMM0,XMM1 MOVSD qword ptr [0x00104020],XMM0 MOVSD XMM1,qword ptr [RBP + -0x8] MOVSD XMM0,qword ptr [0x001020f0] MULSD XMM0,XMM1 MOVAPD XMM1,XMM0 MULSD XMM1,qword ptr [RBP + -0x18] MOVSD XMM0,qword ptr [RBP + -0x10] MULSD XMM0,XMM0 SUBSD XMM1,XMM0 MOVSD XMM0,qword ptr [0x001020f8] ADDSD XMM0,XMM1 MOVSD XMM2,qword ptr [RBP + -0x8] MOVSD XMM1,qword ptr [0x001020f0] MULSD XMM1,XMM2 DIVSD XMM0,XMM1 MOVSD qword ptr [0x00104028],XMM0 LEA RAX,[0x104020] POP RBP RET
int1 * func0(double param_1,double param_2,double param_3) { focus_1._0_8_ = (double)(DAT_001020e0 ^ (ulong)param_2) / (param_1 + param_1); focus_1._8_8_ = (DAT_001020f8 + (DAT_001020f0 * param_1 * param_3 - param_2 * param_2)) / (DAT_001020f0 * param_1); return focus_1; }
4,633
func0
#include <assert.h> #include <stdio.h>
double* func0(double a, double b, double c) { static double focus[2]; focus[0] = -b / (2 * a); focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a); return focus; }
int main() { double *result; result = func0(5, 3, 2); assert(result[0] == -0.3); assert(result[1] == 1.6); result = func0(9, 8, 4); assert(result[0] == -0.4444444444444444); assert(result[1] == 2.25); result = func0(2, 4, 6); assert(result[0] == -1.0); assert(result[1] == 4.125); printf("All tests passed successfully.\n"); return 0; }
O1
c
func0: endbr64 movapd %xmm1,%xmm3 xorpd 0xed7(%rip),%xmm3 movapd %xmm0,%xmm4 addsd %xmm0,%xmm4 divsd %xmm4,%xmm3 movsd %xmm3,0x2eb3(%rip) mulsd 0xecb(%rip),%xmm0 mulsd %xmm0,%xmm2 mulsd %xmm1,%xmm1 subsd %xmm1,%xmm2 addsd 0xebf(%rip),%xmm2 divsd %xmm0,%xmm2 movsd %xmm2,0x2e93(%rip) lea 0x2e84(%rip),%rax retq
func0: endbr64 movapd xmm3, xmm1 xorpd xmm3, cs:xmmword_2030 movapd xmm4, xmm0 addsd xmm4, xmm0 divsd xmm3, xmm4 movsd cs:focus_1, xmm3 mulsd xmm0, cs:qword_2040 mulsd xmm2, xmm0 mulsd xmm1, xmm1 subsd xmm2, xmm1 addsd xmm2, cs:qword_2048 divsd xmm2, xmm0 movsd cs:qword_4028, xmm2 lea rax, focus_1 retn
long long * func0(double a1, double a2, double a3) { *(double *)&focus_1 = -a2 / (a1 + a1); *(double *)&qword_4028 = (a3 * (a1 * 4.0) - a2 * a2 + 1.0) / (a1 * 4.0); return &focus_1; }
func0: ENDBR64 MOVAPD XMM3,XMM1 XORPD XMM3,xmmword ptr [0x00102030] MOVAPD XMM4,XMM0 ADDSD XMM4,XMM0 DIVSD XMM3,XMM4 MOVSD qword ptr [0x00104020],XMM3 MULSD XMM0,qword ptr [0x00102040] MULSD XMM2,XMM0 MULSD XMM1,XMM1 SUBSD XMM2,XMM1 ADDSD XMM2,qword ptr [0x00102048] DIVSD XMM2,XMM0 MOVSD qword ptr [0x00104028],XMM2 LEA RAX,[0x104020] RET
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ int1 * func0(double param_1,double param_2,double param_3) { focus_1._0_8_ = (double)((ulong)param_2 ^ _DAT_00102030) / (param_1 + param_1); focus_1._8_8_ = ((param_3 * param_1 * _DAT_00102040 - param_2 * param_2) + _DAT_00102048) / (param_1 * _DAT_00102040); return focus_1; }
4,634
func0
#include <assert.h> #include <stdio.h>
double* func0(double a, double b, double c) { static double focus[2]; focus[0] = -b / (2 * a); focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a); return focus; }
int main() { double *result; result = func0(5, 3, 2); assert(result[0] == -0.3); assert(result[1] == 1.6); result = func0(9, 8, 4); assert(result[0] == -0.4444444444444444); assert(result[1] == 2.25); result = func0(2, 4, 6); assert(result[0] == -1.0); assert(result[1] == 4.125); printf("All tests passed successfully.\n"); return 0; }
O2
c
func0: endbr64 movapd %xmm0,%xmm4 movapd %xmm1,%xmm3 xorpd 0xe8c(%rip),%xmm3 addsd %xmm0,%xmm4 mulsd %xmm1,%xmm1 lea 0x2e6d(%rip),%rax mulsd 0xe85(%rip),%xmm0 divsd %xmm4,%xmm3 mulsd %xmm0,%xmm2 subsd %xmm1,%xmm2 addsd 0xe79(%rip),%xmm2 divsd %xmm0,%xmm2 movsd %xmm3,0x2e45(%rip) movsd %xmm2,0x2e45(%rip) retq nopw %cs:0x0(%rax,%rax,1) xchg %ax,%ax
func0: endbr64 movapd xmm4, xmm0 movapd xmm3, xmm1 xorpd xmm3, cs:xmmword_2030 addsd xmm4, xmm0 mulsd xmm1, xmm1 lea rax, focus_1 mulsd xmm0, cs:qword_2040 divsd xmm3, xmm4 mulsd xmm2, xmm0 subsd xmm2, xmm1 addsd xmm2, cs:qword_2048 divsd xmm2, xmm0 movsd cs:focus_1, xmm3 movsd cs:qword_4028, xmm2 retn
long long * func0(double a1, double a2, double a3) { long long *result; // rax result = &focus_1; *(double *)&focus_1 = -a2 / (a1 + a1); *(double *)&qword_4028 = (a3 * (a1 * 4.0) - a2 * a2 + 1.0) / (a1 * 4.0); return result; }
func0: ENDBR64 MOVAPD XMM4,XMM0 MOVAPD XMM3,XMM1 XORPD XMM3,xmmword ptr [0x00102030] ADDSD XMM4,XMM0 MULSD XMM1,XMM1 LEA RAX,[0x104020] MULSD XMM0,qword ptr [0x00102040] DIVSD XMM3,XMM4 MULSD XMM2,XMM0 SUBSD XMM2,XMM1 ADDSD XMM2,qword ptr [0x00102048] DIVSD XMM2,XMM0 MOVSD qword ptr [0x00104020],XMM3 MOVSD qword ptr [0x00104028],XMM2 RET
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ int1 * func0(double param_1,double param_2,double param_3) { focus_1._0_8_ = (double)((ulong)param_2 ^ _DAT_00102030) / (param_1 + param_1); focus_1._8_8_ = ((param_3 * param_1 * _DAT_00102040 - param_2 * param_2) + _DAT_00102048) / (param_1 * _DAT_00102040); return focus_1; }
4,635
func0
#include <assert.h> #include <stdio.h>
double* func0(double a, double b, double c) { static double focus[2]; focus[0] = -b / (2 * a); focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a); return focus; }
int main() { double *result; result = func0(5, 3, 2); assert(result[0] == -0.3); assert(result[1] == 1.6); result = func0(9, 8, 4); assert(result[0] == -0.4444444444444444); assert(result[1] == 2.25); result = func0(2, 4, 6); assert(result[0] == -1.0); assert(result[1] == 4.125); printf("All tests passed successfully.\n"); return 0; }
O3
c
func0: endbr64 movapd %xmm0,%xmm4 movapd %xmm1,%xmm3 xorpd 0xe9c(%rip),%xmm3 addsd %xmm0,%xmm4 mulsd %xmm1,%xmm1 lea 0x2e7d(%rip),%rax mulsd 0xea5(%rip),%xmm0 divsd %xmm4,%xmm3 mulsd %xmm0,%xmm2 subsd %xmm1,%xmm2 addsd 0xe99(%rip),%xmm2 divsd %xmm0,%xmm2 movsd %xmm3,0x2e55(%rip) movsd %xmm2,0x2e55(%rip) retq nopw %cs:0x0(%rax,%rax,1) xchg %ax,%ax
func0: endbr64 unpcklpd xmm0, xmm0 movapd xmm4, xmm1 xorpd xmm4, cs:xmmword_2040 mulpd xmm0, cs:xmmword_2030 lea rax, focus_1 mulsd xmm1, xmm1 movapd xmm5, xmm0 unpckhpd xmm5, xmm5 movapd xmm3, xmm5 mulsd xmm3, xmm2 subsd xmm3, xmm1 addsd xmm3, cs:qword_2060 movapd xmm1, xmm4 unpcklpd xmm1, xmm3 divpd xmm1, xmm0 movaps cs:focus_1, xmm1 retn
__int128 * func0(__m128d a1, __m128d a2, double a3) { __m128d v3; // xmm0 __int128 *result; // rax __m128d v5; // xmm5 __m128d v6; // xmm3 v3 = _mm_mul_pd(_mm_unpacklo_pd(a1, a1), (__m128d)xmmword_2030); result = &focus_1; v5 = _mm_unpackhi_pd(v3, v3); v6.m128d_f64[1] = v5.m128d_f64[1]; v6.m128d_f64[0] = v5.m128d_f64[0] * a3 - a2.m128d_f64[0] * a2.m128d_f64[0] + 1.0; focus_1 = (__int128)_mm_div_pd(_mm_unpacklo_pd(_mm_xor_pd(a2, (__m128d)xmmword_2040), v6), v3); return result; }
func0: ENDBR64 UNPCKLPD XMM0,XMM0 MOVAPD XMM4,XMM1 XORPD XMM4,xmmword ptr [0x00102040] MULPD XMM0,xmmword ptr [0x00102030] LEA RAX,[0x104020] MULSD XMM1,XMM1 MOVAPD XMM5,XMM0 UNPCKHPD XMM5,XMM5 MOVAPD XMM3,XMM5 MULSD XMM3,XMM2 SUBSD XMM3,XMM1 ADDSD XMM3,qword ptr [0x00102060] MOVAPD XMM1,XMM4 UNPCKLPD XMM1,XMM3 DIVPD XMM1,XMM0 MOVAPS xmmword ptr [0x00104020],XMM1 RET
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ int1 * func0(double param_1,double param_2,double param_3) { int auVar1 [16]; int auVar2 [16]; auVar2._8_8_ = (param_1 * _UNK_00102038 * param_3 - param_2 * param_2) + _DAT_00102060; auVar2._0_8_ = (ulong)param_2 ^ _DAT_00102040; auVar1._8_8_ = param_1 * _UNK_00102038; auVar1._0_8_ = param_1 * _DAT_00102030; focus_1 = (int1 [16])divpd(auVar2,auVar1); return focus_1; }
4,636
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <regex.h>
char * func0(const char *text, const char *pattern) { regex_t regex; int reti; reti = regcomp(&regex, pattern, 0); if (reti) { return ("Regex compilation failed!"); } reti = regexec(&regex, text, 0, NULL, 0); regfree(&regex); if (!reti) { return ("Matched!"); } else { return ("Not Matched!"); } }
int main() { // Test the function implementation assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "lazy"), "Matched!") == 0); printf("All tests passed successfully.\n"); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x70,%rsp mov %rdi,-0x68(%rbp) mov %rsi,-0x70(%rbp) mov %fs:0x28,%rax mov %rax,-0x8(%rbp) xor %eax,%eax mov -0x70(%rbp),%rcx lea -0x50(%rbp),%rax mov $0x0,%edx mov %rcx,%rsi mov %rax,%rdi callq 10f0 <regcomp@plt> mov %eax,-0x54(%rbp) cmpl $0x0,-0x54(%rbp) je 1256 <func0+0x4d> lea 0xdb4(%rip),%rax jmp 129b <func0+0x92> mov -0x68(%rbp),%rsi lea -0x50(%rbp),%rax mov $0x0,%r8d mov $0x0,%ecx mov $0x0,%edx mov %rax,%rdi callq 1110 <regexec@plt> mov %eax,-0x54(%rbp) lea -0x50(%rbp),%rax mov %rax,%rdi callq 10c0 <regfree@plt> cmpl $0x0,-0x54(%rbp) jne 1294 <func0+0x8b> lea 0xd90(%rip),%rax jmp 129b <func0+0x92> lea 0xd90(%rip),%rax mov -0x8(%rbp),%rdx xor %fs:0x28,%rdx je 12af <func0+0xa6> callq 10d0 <__stack_chk_fail@plt> leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 70h mov [rbp+string], rdi mov [rbp+pattern], rsi mov rax, fs:28h mov [rbp+var_8], rax xor eax, eax mov rcx, [rbp+pattern] lea rax, [rbp+preg] mov edx, 0; cflags mov rsi, rcx; pattern mov rdi, rax; preg call _regcomp mov [rbp+var_54], eax cmp [rbp+var_54], 0 jz short loc_1256 lea rax, aRegexCompilati; "Regex compilation failed!" jmp short loc_129B loc_1256: mov rsi, [rbp+string]; string lea rax, [rbp+preg] mov r8d, 0; eflags mov ecx, 0; pmatch mov edx, 0; nmatch mov rdi, rax; preg call _regexec mov [rbp+var_54], eax lea rax, [rbp+preg] mov rdi, rax; preg call _regfree cmp [rbp+var_54], 0 jnz short loc_1294 lea rax, s2; "Matched!" jmp short loc_129B loc_1294: lea rax, aNotMatched; "Not Matched!" loc_129B: mov rdx, [rbp+var_8] sub rdx, fs:28h jz short locret_12AF call ___stack_chk_fail locret_12AF: leave retn
const char * func0(const char *a1, const char *a2) { int v3; // [rsp+1Ch] [rbp-54h] regex_t preg; // [rsp+20h] [rbp-50h] BYREF unsigned long long v5; // [rsp+68h] [rbp-8h] v5 = __readfsqword(0x28u); if ( regcomp(&preg, a2, 0) ) return "Regex compilation failed!"; v3 = regexec(&preg, a1, 0LL, 0LL, 0); regfree(&preg); if ( v3 ) return "Not Matched!"; else return "Matched!"; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x70 MOV qword ptr [RBP + -0x68],RDI MOV qword ptr [RBP + -0x70],RSI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RBP + -0x8],RAX XOR EAX,EAX MOV RCX,qword ptr [RBP + -0x70] LEA RAX,[RBP + -0x50] MOV EDX,0x0 MOV RSI,RCX MOV RDI,RAX CALL 0x001010f0 MOV dword ptr [RBP + -0x54],EAX CMP dword ptr [RBP + -0x54],0x0 JZ 0x00101256 LEA RAX,[0x102008] JMP 0x0010129b LAB_00101256: MOV RSI,qword ptr [RBP + -0x68] LEA RAX,[RBP + -0x50] MOV R8D,0x0 MOV ECX,0x0 MOV EDX,0x0 MOV RDI,RAX CALL 0x00101110 MOV dword ptr [RBP + -0x54],EAX LEA RAX,[RBP + -0x50] MOV RDI,RAX CALL 0x001010c0 CMP dword ptr [RBP + -0x54],0x0 JNZ 0x00101294 LEA RAX,[0x102022] JMP 0x0010129b LAB_00101294: LEA RAX,[0x10202b] LAB_0010129b: MOV RDX,qword ptr [RBP + -0x8] SUB RDX,qword ptr FS:[0x28] JZ 0x001012af CALL 0x001010d0 LAB_001012af: LEAVE RET
char * func0(char *param_1,char *param_2) { int iVar1; char *pcVar2; long in_FS_OFFSET; regex_t local_58; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); iVar1 = regcomp(&local_58,param_2,0); if (iVar1 == 0) { iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0); regfree(&local_58); if (iVar1 == 0) { pcVar2 = "Matched!"; } else { pcVar2 = "Not Matched!"; } } else { pcVar2 = "Regex compilation failed!"; } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return pcVar2; }
4,637
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <regex.h>
char * func0(const char *text, const char *pattern) { regex_t regex; int reti; reti = regcomp(&regex, pattern, 0); if (reti) { return ("Regex compilation failed!"); } reti = regexec(&regex, text, 0, NULL, 0); regfree(&regex); if (!reti) { return ("Matched!"); } else { return ("Not Matched!"); } }
int main() { // Test the function implementation assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "lazy"), "Matched!") == 0); printf("All tests passed successfully.\n"); return 0; }
O1
c
func0: endbr64 push %rbp push %rbx sub $0x58,%rsp mov %rdi,%rbx mov %fs:0x28,%rax mov %rax,0x48(%rsp) xor %eax,%eax mov %rsp,%rdi mov $0x0,%edx callq 10e0 <regcomp@plt> mov %eax,%edx lea 0xde8(%rip),%rax test %edx,%edx je 1237 <func0+0x4e> mov 0x48(%rsp),%rcx xor %fs:0x28,%rcx jne 1275 <func0+0x8c> add $0x58,%rsp pop %rbx pop %rbp retq mov %rsp,%rbp mov $0x0,%r8d mov $0x0,%ecx mov $0x0,%edx mov %rbx,%rsi mov %rbp,%rdi callq 10f0 <regexec@plt> mov %eax,%ebx mov %rbp,%rdi callq 10b0 <regfree@plt> test %ebx,%ebx lea 0xdba(%rip),%rax lea 0xdaf(%rip),%rdx cmovne %rdx,%rax jmp 1220 <func0+0x37> callq 10c0 <__stack_chk_fail@plt>
func0: endbr64 push rbp push rbx sub rsp, 58h mov rbx, rdi mov rax, fs:28h mov [rsp+68h+var_20], rax xor eax, eax mov rdi, rsp mov edx, 0 call _regcomp mov edx, eax lea rax, aRegexCompilati; "Regex compilation failed!" test edx, edx jz short loc_1257 loc_1240: mov rdx, [rsp+68h+var_20] sub rdx, fs:28h jnz short loc_1295 add rsp, 58h pop rbx pop rbp retn loc_1257: mov rbp, rsp mov r8d, 0 mov ecx, 0 mov edx, 0 mov rsi, rbx mov rdi, rbp call _regexec mov ebx, eax mov rdi, rbp call _regfree test ebx, ebx lea rax, aNotMatched+4; "Matched!" lea rdx, aNotMatched; "Not Matched!" cmovnz rax, rdx jmp short loc_1240 loc_1295: call ___stack_chk_fail
char * func0(long long a1, long long a2) { int v2; // edx char *result; // rax int v4; // ebx _QWORD v5[13]; // [rsp+0h] [rbp-68h] BYREF v5[9] = __readfsqword(0x28u); v2 = regcomp(v5, a2, 0LL); result = "Regex compilation failed!"; if ( !v2 ) { v4 = regexec(v5, a1, 0LL, 0LL, 0LL); regfree(v5); result = "Matched!"; if ( v4 ) return "Not Matched!"; } return result; }
func0: ENDBR64 PUSH RBP PUSH RBX SUB RSP,0x58 MOV RBX,RDI MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x48],RAX XOR EAX,EAX MOV RDI,RSP MOV EDX,0x0 CALL 0x001010f0 MOV EDX,EAX LEA RAX,[0x102004] TEST EDX,EDX JZ 0x00101257 LAB_00101240: MOV RDX,qword ptr [RSP + 0x48] SUB RDX,qword ptr FS:[0x28] JNZ 0x00101295 ADD RSP,0x58 POP RBX POP RBP RET LAB_00101257: MOV RBP,RSP MOV R8D,0x0 MOV ECX,0x0 MOV EDX,0x0 MOV RSI,RBX MOV RDI,RBP CALL 0x00101110 MOV EBX,EAX MOV RDI,RBP CALL 0x001010c0 TEST EBX,EBX LEA RAX,[0x102022] LEA RDX,[0x10201e] CMOVNZ RAX,RDX JMP 0x00101240 LAB_00101295: CALL 0x001010d0
char * func0(char *param_1,char *param_2) { int iVar1; char *pcVar2; long in_FS_OFFSET; regex_t rStack_68; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); iVar1 = regcomp(&rStack_68,param_2,0); pcVar2 = "Regex compilation failed!"; if (iVar1 == 0) { iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0); regfree(&rStack_68); pcVar2 = "Matched!"; if (iVar1 != 0) { pcVar2 = "Not Matched!"; } } if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return pcVar2; }
4,638
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <regex.h>
char * func0(const char *text, const char *pattern) { regex_t regex; int reti; reti = regcomp(&regex, pattern, 0); if (reti) { return ("Regex compilation failed!"); } reti = regexec(&regex, text, 0, NULL, 0); regfree(&regex); if (!reti) { return ("Matched!"); } else { return ("Not Matched!"); } }
int main() { // Test the function implementation assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "lazy"), "Matched!") == 0); printf("All tests passed successfully.\n"); return 0; }
O2
c
func0: endbr64 push %r12 xor %edx,%edx push %rbp mov %rdi,%rbp sub $0x58,%rsp mov %fs:0x28,%rax mov %rax,0x48(%rsp) xor %eax,%eax mov %rsp,%r12 mov %r12,%rdi callq 10e0 <regcomp@plt> mov %eax,%r8d lea 0xcdf(%rip),%rax test %r8d,%r8d jne 1357 <func0+0x67> xor %edx,%edx xor %ecx,%ecx mov %rbp,%rsi mov %r12,%rdi callq 10f0 <regexec@plt> mov %r12,%rdi mov %eax,%ebp callq 10b0 <regfree@plt> test %ebp,%ebp lea 0xcd6(%rip),%rax lea 0xccb(%rip),%rdx cmovne %rdx,%rax mov 0x48(%rsp),%rcx xor %fs:0x28,%rcx jne 136f <func0+0x7f> add $0x58,%rsp pop %rbp pop %r12 retq callq 10c0 <__stack_chk_fail@plt> nopw %cs:0x0(%rax,%rax,1) xchg %ax,%ax
func0: endbr64 push r12 xor edx, edx mov r12, rdi push rbp sub rsp, 58h mov rax, fs:28h mov [rsp+var_s48], rax xor eax, eax mov rbp, rsp mov rdi, rbp call _regcomp mov r8d, eax lea rax, aRegexCompilati; "Regex compilation failed!" test r8d, r8d jnz short loc_1369 xor edx, edx xor ecx, ecx mov rsi, r12 mov rdi, rbp call _regexec mov rdi, rbp mov r12d, eax call _regfree test r12d, r12d lea rax, aNotMatched+4; "Matched!" lea rdx, aNotMatched; "Not Matched!" cmovnz rax, rdx loc_1369: mov rdx, [rsp+var_s48] sub rdx, fs:28h jnz short loc_1381 add rsp, 58h pop rbp pop r12 retn loc_1381: call ___stack_chk_fail
char * func0(long long a1, long long a2) { int v2; // r8d char *result; // rax int v4; // r12d _QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF _0[9] = __readfsqword(0x28u); v2 = regcomp(_0, a2, 0LL); result = "Regex compilation failed!"; if ( !v2 ) { v4 = regexec(_0, a1, 0LL, 0LL); regfree(_0); result = "Matched!"; if ( v4 ) return "Not Matched!"; } return result; }
func0: ENDBR64 PUSH R12 XOR EDX,EDX MOV R12,RDI PUSH RBP SUB RSP,0x58 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x48],RAX XOR EAX,EAX MOV RBP,RSP MOV RDI,RBP CALL 0x001010f0 MOV R8D,EAX LEA RAX,[0x102004] TEST R8D,R8D JNZ 0x00101369 XOR EDX,EDX XOR ECX,ECX MOV RSI,R12 MOV RDI,RBP CALL 0x00101110 MOV RDI,RBP MOV R12D,EAX CALL 0x001010c0 TEST R12D,R12D LEA RAX,[0x102022] LEA RDX,[0x10201e] CMOVNZ RAX,RDX LAB_00101369: MOV RDX,qword ptr [RSP + 0x48] SUB RDX,qword ptr FS:[0x28] JNZ 0x00101381 ADD RSP,0x58 POP RBP POP R12 RET LAB_00101381: CALL 0x001010d0
char * func0(char *param_1,char *param_2) { int iVar1; char *pcVar2; long in_FS_OFFSET; regex_t rStack_68; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); iVar1 = regcomp(&rStack_68,param_2,0); pcVar2 = "Regex compilation failed!"; if (iVar1 == 0) { iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0); regfree(&rStack_68); pcVar2 = "Matched!"; if (iVar1 != 0) { pcVar2 = "Not Matched!"; } } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return pcVar2; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,639
func0
#include <stdio.h> #include <string.h> #include <assert.h> #include <regex.h>
char * func0(const char *text, const char *pattern) { regex_t regex; int reti; reti = regcomp(&regex, pattern, 0); if (reti) { return ("Regex compilation failed!"); } reti = regexec(&regex, text, 0, NULL, 0); regfree(&regex); if (!reti) { return ("Matched!"); } else { return ("Not Matched!"); } }
int main() { // Test the function implementation assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0); assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "lazy"), "Matched!") == 0); printf("All tests passed successfully.\n"); return 0; }
O3
c
func0: endbr64 push %r12 xor %edx,%edx push %rbp mov %rdi,%rbp sub $0x58,%rsp mov %fs:0x28,%rax mov %rax,0x48(%rsp) xor %eax,%eax mov %rsp,%r12 mov %r12,%rdi callq 10e0 <regcomp@plt> mov %eax,%r8d lea 0xcdf(%rip),%rax test %r8d,%r8d jne 1357 <func0+0x67> xor %edx,%edx xor %ecx,%ecx mov %rbp,%rsi mov %r12,%rdi callq 10f0 <regexec@plt> mov %r12,%rdi mov %eax,%ebp callq 10b0 <regfree@plt> test %ebp,%ebp lea 0xcd6(%rip),%rax lea 0xccb(%rip),%rdx cmovne %rdx,%rax mov 0x48(%rsp),%rcx xor %fs:0x28,%rcx jne 136f <func0+0x7f> add $0x58,%rsp pop %rbp pop %r12 retq callq 10c0 <__stack_chk_fail@plt> nopw %cs:0x0(%rax,%rax,1) xchg %ax,%ax
func0: endbr64 push rbp xor edx, edx; cflags push rbx mov rbx, rdi sub rsp, 58h mov rax, fs:28h mov [rsp+var_s48], rax xor eax, eax mov rbp, rsp mov rdi, rbp; preg call _regcomp mov edx, eax lea rax, aRegexCompilati; "Regex compilation failed!" test edx, edx jnz short loc_1367 xor edx, edx; nmatch xor r8d, r8d; eflags xor ecx, ecx; pmatch mov rsi, rbx; string mov rdi, rbp; preg call _regexec mov rdi, rbp; preg mov ebx, eax call _regfree test ebx, ebx lea rax, s2; "Not Matched!" lea rdx, s2+4; "Matched!" cmovz rax, rdx loc_1367: mov rdx, [rsp+var_s48] sub rdx, fs:28h jnz short loc_137E add rsp, 58h pop rbx pop rbp retn loc_137E: call ___stack_chk_fail
const char * func0(char *string, const char *a2) { int v2; // edx const char *result; // rax int v4; // ebx regex_t _0; // [rsp+0h] [rbp+0h] BYREF unsigned long long vars48; // [rsp+48h] [rbp+48h] vars48 = __readfsqword(0x28u); v2 = regcomp(&_0, a2, 0); result = "Regex compilation failed!"; if ( !v2 ) { v4 = regexec(&_0, string, 0LL, 0LL, 0); regfree(&_0); result = "Not Matched!"; if ( !v4 ) return "Matched!"; } return result; }
func0: ENDBR64 PUSH RBP XOR EDX,EDX PUSH RBX MOV RBX,RDI SUB RSP,0x58 MOV RAX,qword ptr FS:[0x28] MOV qword ptr [RSP + 0x48],RAX XOR EAX,EAX MOV RBP,RSP MOV RDI,RBP CALL 0x001010f0 MOV EDX,EAX LEA RAX,[0x102004] TEST EDX,EDX JNZ 0x00101367 XOR EDX,EDX XOR R8D,R8D XOR ECX,ECX MOV RSI,RBX MOV RDI,RBP CALL 0x00101110 MOV RDI,RBP MOV EBX,EAX CALL 0x001010c0 TEST EBX,EBX LEA RAX,[0x10201e] LEA RDX,[0x102022] CMOVZ RAX,RDX LAB_00101367: MOV RDX,qword ptr [RSP + 0x48] SUB RDX,qword ptr FS:[0x28] JNZ 0x0010137e ADD RSP,0x58 POP RBX POP RBP RET LAB_0010137e: CALL 0x001010d0
char * func0(char *param_1,char *param_2) { int iVar1; char *pcVar2; long in_FS_OFFSET; regex_t rStack_68; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); iVar1 = regcomp(&rStack_68,param_2,0); pcVar2 = "Regex compilation failed!"; if (iVar1 == 0) { iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0); regfree(&rStack_68); pcVar2 = "Not Matched!"; if (iVar1 == 0) { pcVar2 = "Matched!"; } } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return pcVar2; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
4,640
func0
#include <stdio.h> #include <assert.h>
int func0(const char *X, const char *Y, int m, int n) { if (m == 0 || n == 0) { return 0; } else if (X[m-1] == Y[n-1]) { return 1 + func0(X, Y, m-1, n-1); } else { int left = func0(X, Y, m, n-1); int right = func0(X, Y, m-1, n); return (left > right) ? left : right; } }
int main() { assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4); assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3); assert(func0("AXYT", "AYZX", 4, 4) == 2); printf("All test cases passed.\n"); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x30,%rsp mov %rdi,-0x18(%rbp) mov %rsi,-0x20(%rbp) mov %edx,-0x24(%rbp) mov %ecx,-0x28(%rbp) cmpl $0x0,-0x24(%rbp) je 118f <func0+0x26> cmpl $0x0,-0x28(%rbp) jne 1199 <func0+0x30> mov $0x0,%eax jmpq 122a <func0+0xc1> mov -0x24(%rbp),%eax cltq lea -0x1(%rax),%rdx mov -0x18(%rbp),%rax add %rdx,%rax movzbl (%rax),%edx mov -0x28(%rbp),%eax cltq lea -0x1(%rax),%rcx mov -0x20(%rbp),%rax add %rcx,%rax movzbl (%rax),%eax cmp %al,%dl jne 11e4 <func0+0x7b> mov -0x28(%rbp),%eax lea -0x1(%rax),%ecx mov -0x24(%rbp),%eax lea -0x1(%rax),%edx mov -0x20(%rbp),%rsi mov -0x18(%rbp),%rax mov %rax,%rdi callq 1169 <func0> add $0x1,%eax jmp 122a <func0+0xc1> mov -0x28(%rbp),%eax lea -0x1(%rax),%ecx mov -0x24(%rbp),%edx mov -0x20(%rbp),%rsi mov -0x18(%rbp),%rax mov %rax,%rdi callq 1169 <func0> mov %eax,-0x8(%rbp) mov -0x24(%rbp),%eax lea -0x1(%rax),%edi mov -0x28(%rbp),%edx mov -0x20(%rbp),%rsi mov -0x18(%rbp),%rax mov %edx,%ecx mov %edi,%edx mov %rax,%rdi callq 1169 <func0> mov %eax,-0x4(%rbp) mov -0x8(%rbp),%eax cmp %eax,-0x4(%rbp) cmovge -0x4(%rbp),%eax leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 30h mov [rbp+var_18], rdi mov [rbp+var_20], rsi mov [rbp+var_24], edx mov [rbp+var_28], ecx cmp [rbp+var_24], 0 jz short loc_118F cmp [rbp+var_28], 0 jnz short loc_1199 loc_118F: mov eax, 0 jmp locret_122B loc_1199: mov eax, [rbp+var_24] cdqe lea rdx, [rax-1] mov rax, [rbp+var_18] add rax, rdx movzx edx, byte ptr [rax] mov eax, [rbp+var_28] cdqe lea rcx, [rax-1] mov rax, [rbp+var_20] add rax, rcx movzx eax, byte ptr [rax] cmp dl, al jnz short loc_11E4 mov eax, [rbp+var_28] lea ecx, [rax-1] mov eax, [rbp+var_24] lea edx, [rax-1] mov rsi, [rbp+var_20] mov rax, [rbp+var_18] mov rdi, rax call func0 add eax, 1 jmp short locret_122B loc_11E4: mov eax, [rbp+var_28] lea ecx, [rax-1] mov edx, [rbp+var_24] mov rsi, [rbp+var_20] mov rax, [rbp+var_18] mov rdi, rax call func0 mov [rbp+var_8], eax mov eax, [rbp+var_24] lea edi, [rax-1] mov edx, [rbp+var_28] mov rsi, [rbp+var_20] mov rax, [rbp+var_18] mov ecx, edx mov edx, edi mov rdi, rax call func0 mov [rbp+var_4], eax mov edx, [rbp+var_4] mov eax, [rbp+var_8] cmp edx, eax cmovge eax, edx locret_122B: leave retn
long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4) { long long result; // rax unsigned int v5; // edx unsigned int v8; // [rsp+28h] [rbp-8h] if ( !a3 || !a4 ) return 0LL; if ( *(_BYTE *)((int)a3 - 1LL + a1) == *(_BYTE *)((int)a4 - 1LL + a2) ) return (unsigned int)func0(a1, a2, a3 - 1, a4 - 1) + 1; v8 = func0(a1, a2, a3, a4 - 1); v5 = func0(a1, a2, a3 - 1, a4); result = v8; if ( (int)v5 >= (int)v8 ) return v5; return result; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x30 MOV qword ptr [RBP + -0x18],RDI MOV qword ptr [RBP + -0x20],RSI MOV dword ptr [RBP + -0x24],EDX MOV dword ptr [RBP + -0x28],ECX CMP dword ptr [RBP + -0x24],0x0 JZ 0x0010118f CMP dword ptr [RBP + -0x28],0x0 JNZ 0x00101199 LAB_0010118f: MOV EAX,0x0 JMP 0x0010122b LAB_00101199: MOV EAX,dword ptr [RBP + -0x24] CDQE LEA RDX,[RAX + -0x1] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOVZX EDX,byte ptr [RAX] MOV EAX,dword ptr [RBP + -0x28] CDQE LEA RCX,[RAX + -0x1] MOV RAX,qword ptr [RBP + -0x20] ADD RAX,RCX MOVZX EAX,byte ptr [RAX] CMP DL,AL JNZ 0x001011e4 MOV EAX,dword ptr [RBP + -0x28] LEA ECX,[RAX + -0x1] MOV EAX,dword ptr [RBP + -0x24] LEA EDX,[RAX + -0x1] MOV RSI,qword ptr [RBP + -0x20] MOV RAX,qword ptr [RBP + -0x18] MOV RDI,RAX CALL 0x00101169 ADD EAX,0x1 JMP 0x0010122b LAB_001011e4: MOV EAX,dword ptr [RBP + -0x28] LEA ECX,[RAX + -0x1] MOV EDX,dword ptr [RBP + -0x24] MOV RSI,qword ptr [RBP + -0x20] MOV RAX,qword ptr [RBP + -0x18] MOV RDI,RAX CALL 0x00101169 MOV dword ptr [RBP + -0x8],EAX MOV EAX,dword ptr [RBP + -0x24] LEA EDI,[RAX + -0x1] MOV EDX,dword ptr [RBP + -0x28] MOV RSI,qword ptr [RBP + -0x20] MOV RAX,qword ptr [RBP + -0x18] MOV ECX,EDX MOV EDX,EDI MOV RDI,RAX CALL 0x00101169 MOV dword ptr [RBP + -0x4],EAX MOV EDX,dword ptr [RBP + -0x4] MOV EAX,dword ptr [RBP + -0x8] CMP EDX,EAX CMOVGE EAX,EDX LAB_0010122b: LEAVE RET
int func0(long param_1,long param_2,int param_3,int param_4) { int iVar1; int iVar2; if ((param_3 == 0) || (param_4 == 0)) { iVar1 = 0; } else if (*(char *)(param_1 + (long)param_3 + -1) == *(char *)(param_2 + (long)param_4 + -1)) { iVar1 = func0(param_1,param_2,param_3 + -1,param_4 + -1); iVar1 = iVar1 + 1; } else { iVar1 = func0(param_1,param_2,param_3,param_4 + -1); iVar2 = func0(param_1,param_2,param_3 + -1,param_4); if (iVar1 <= iVar2) { iVar1 = iVar2; } } return iVar1; }
4,641
func0
#include <stdio.h> #include <assert.h>
int func0(const char *X, const char *Y, int m, int n) { if (m == 0 || n == 0) { return 0; } else if (X[m-1] == Y[n-1]) { return 1 + func0(X, Y, m-1, n-1); } else { int left = func0(X, Y, m, n-1); int right = func0(X, Y, m-1, n); return (left > right) ? left : right; } }
int main() { assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4); assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3); assert(func0("AXYT", "AYZX", 4, 4) == 2); printf("All test cases passed.\n"); return 0; }
O1
c
func0: endbr64 test %edx,%edx je 11e3 <func0+0x7a> push %r14 push %r13 push %r12 push %rbp push %rbx mov %rdi,%r12 mov %rsi,%r13 mov %edx,%ebx mov %ecx,%ebp test %ecx,%ecx je 11dc <func0+0x73> movslq %edx,%rax movslq %ecx,%rdx movzbl -0x1(%rsi,%rdx,1),%esi cmp %sil,-0x1(%rdi,%rax,1) je 11c9 <func0+0x60> lea -0x1(%rcx),%ecx mov %ebx,%edx mov %r13,%rsi callq 1169 <func0> mov %eax,%r14d lea -0x1(%rbx),%edx mov %ebp,%ecx mov %r13,%rsi mov %r12,%rdi callq 1169 <func0> cmp %eax,%r14d cmovge %r14d,%eax pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 retq lea -0x1(%rcx),%ecx lea -0x1(%rbx),%edx mov %r13,%rsi callq 1169 <func0> add $0x1,%eax jmp 11c0 <func0+0x57> mov $0x0,%eax jmp 11c0 <func0+0x57> mov $0x0,%eax retq
func0: endbr64 test edx, edx jz short loc_11E3 push r14 push r13 push r12 push rbp push rbx mov r12, rdi mov r13, rsi mov ebx, edx mov ebp, ecx test ecx, ecx jz short loc_11DC movsxd rax, edx movsxd rdx, ecx movzx esi, byte ptr [rsi+rdx-1] cmp [rdi+rax-1], sil jz short loc_11C9 lea ecx, [rcx-1] mov edx, ebx mov rsi, r13 call func0 mov r14d, eax lea edx, [rbx-1] mov ecx, ebp mov rsi, r13 mov rdi, r12 call func0 cmp r14d, eax cmovge eax, r14d loc_11C0: pop rbx pop rbp pop r12 pop r13 pop r14 retn loc_11C9: lea ecx, [rcx-1] lea edx, [rbx-1] mov rsi, r13 call func0 add eax, 1 jmp short loc_11C0 loc_11DC: mov eax, 0 jmp short loc_11C0 loc_11E3: mov eax, 0 retn
long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4) { int v6; // r14d long long result; // rax if ( !a3 ) return 0LL; if ( !a4 ) return 0LL; if ( *(_BYTE *)(a1 + (int)a3 - 1) == *(_BYTE *)(a2 + (int)a4 - 1) ) return (unsigned int)func0(a1, a2, a3 - 1, a4 - 1) + 1; v6 = func0(a1, a2, a3, a4 - 1); result = func0(a1, a2, a3 - 1, a4); if ( v6 >= (int)result ) return (unsigned int)v6; return result; }
func0: ENDBR64 TEST EDX,EDX JZ 0x001011e3 PUSH R14 PUSH R13 PUSH R12 PUSH RBP PUSH RBX MOV R12,RDI MOV R13,RSI MOV EBX,EDX MOV EBP,ECX TEST ECX,ECX JZ 0x001011dc MOVSXD RAX,EDX MOVSXD RDX,ECX MOVZX ESI,byte ptr [RSI + RDX*0x1 + -0x1] CMP byte ptr [RDI + RAX*0x1 + -0x1],SIL JZ 0x001011c9 LEA ECX,[RCX + -0x1] MOV EDX,EBX MOV RSI,R13 CALL 0x00101169 MOV R14D,EAX LEA EDX,[RBX + -0x1] MOV ECX,EBP MOV RSI,R13 MOV RDI,R12 CALL 0x00101169 CMP R14D,EAX CMOVGE EAX,R14D LAB_001011c0: POP RBX POP RBP POP R12 POP R13 POP R14 RET LAB_001011c9: LEA ECX,[RCX + -0x1] LEA EDX,[RBX + -0x1] MOV RSI,R13 CALL 0x00101169 ADD EAX,0x1 JMP 0x001011c0 LAB_001011dc: MOV EAX,0x0 JMP 0x001011c0 LAB_001011e3: MOV EAX,0x0 RET
int func0(long param_1,long param_2,int param_3,int param_4) { int iVar1; int iVar2; if (param_3 != 0) { if (param_4 == 0) { iVar2 = 0; } else if (*(char *)(param_1 + -1 + (long)param_3) == *(char *)(param_2 + -1 + (long)param_4)) { iVar2 = func0(param_1,param_2,param_3 + -1,param_4 + -1); iVar2 = iVar2 + 1; } else { iVar1 = func0(param_1,param_2,param_3,param_4 + -1); iVar2 = func0(param_1,param_2,param_3 + -1,param_4); if (iVar2 <= iVar1) { iVar2 = iVar1; } } return iVar2; } return 0; }
4,642
func0
#include <stdio.h> #include <assert.h>
int func0(const char *X, const char *Y, int m, int n) { if (m == 0 || n == 0) { return 0; } else if (X[m-1] == Y[n-1]) { return 1 + func0(X, Y, m-1, n-1); } else { int left = func0(X, Y, m, n-1); int right = func0(X, Y, m-1, n); return (left > right) ? left : right; } }
int main() { assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4); assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3); assert(func0("AXYT", "AYZX", 4, 4) == 2); printf("All test cases passed.\n"); return 0; }
O2
c
func0: endbr64 push %r15 movslq %ecx,%rax push %r14 push %r13 push %r12 push %rbp push %rbx sub $0x8,%rsp test %eax,%eax je 12fd <func0+0xad> mov %edx,%r12d test %edx,%edx je 12fd <func0+0xad> movslq %edx,%r8 lea -0x1(%rax),%ecx mov %rdi,%r14 mov %rsi,%rbp sub %rax,%r8 movslq %ecx,%rcx xor %r13d,%r13d add %rdi,%r8 jmp 12af <func0+0x5f> nopw 0x0(%rax,%rax,1) add $0x1,%r13d test %r12d,%r12d sete %dl test %ecx,%ecx sete %al sub $0x1,%rcx or %al,%dl jne 12eb <func0+0x9b> mov %r12d,%edx movzbl 0x0(%rbp,%rcx,1),%eax lea 0x1(%rcx),%r15d sub $0x1,%r12d cmp %al,(%r8,%rcx,1) je 1298 <func0+0x48> mov %rbp,%rsi mov %r14,%rdi callq 1250 <func0> mov %r15d,%ecx mov %r12d,%edx mov %rbp,%rsi mov %r14,%rdi mov %eax,%ebx callq 1250 <func0> cmp %eax,%ebx cmovl %eax,%ebx add %ebx,%r13d add $0x8,%rsp mov %r13d,%eax pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 pop %r15 retq xor %r13d,%r13d jmp 12eb <func0+0x9b> nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax)
func0: endbr64 push r15 push r14 push r13 push r12 push rbp push rbx sub rsp, 8 test ecx, ecx jz loc_12FE mov r12d, edx test edx, edx jz loc_12FE lea eax, [rcx-1] mov rbp, rsi movsxd rcx, ecx movsxd rsi, edx sub rsi, rcx mov r14, rdi cdqe xor r13d, r13d add rsi, rdi jmp short loc_12AF loc_1298: add r13d, 1 test r12d, r12d setz dl test eax, eax setz cl sub rax, 1 or dl, cl jnz short loc_12EC loc_12AF: mov edx, r12d movzx ebx, byte ptr [rbp+rax+0] lea r15d, [rax+1] mov ecx, eax sub r12d, 1 cmp [rsi+rax], bl jz short loc_1298 mov rsi, rbp mov rdi, r14 call func0 mov ecx, r15d mov edx, r12d mov rsi, rbp mov rdi, r14 mov ebx, eax call func0 cmp ebx, eax cmovl ebx, eax add r13d, ebx loc_12EC: add rsp, 8 mov eax, r13d pop rbx pop rbp pop r12 pop r13 pop r14 pop r15 retn loc_12FE: xor r13d, r13d jmp short loc_12EC
long long func0(long long a1, long long a2, unsigned int a3, int a4) { unsigned int v4; // r12d long long v6; // rax unsigned int v7; // r13d long long v8; // rsi bool v9; // cl long long v10; // rdx unsigned int v11; // r15d int v12; // ebx int v13; // eax if ( a4 && (v4 = a3) != 0 ) { v6 = a4 - 1; v7 = 0; v8 = a1 + (int)a3 - (long long)a4; while ( 1 ) { v10 = v4; v11 = v6 + 1; --v4; if ( *(_BYTE *)(v8 + v6) != *(_BYTE *)(a2 + v6) ) break; ++v7; v9 = (_DWORD)v6-- == 0; if ( v9 || v4 == 0 ) return v7; } v12 = func0(a1, a2, v10, (unsigned int)v6); v13 = func0(a1, a2, v4, v11); if ( v12 < v13 ) v12 = v13; v7 += v12; } else { return 0; } return v7; }
func0: ENDBR64 PUSH R15 PUSH R14 PUSH R13 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x8 TEST ECX,ECX JZ 0x001012fe MOV R12D,EDX TEST EDX,EDX JZ 0x001012fe LEA EAX,[RCX + -0x1] MOV RBP,RSI MOVSXD RCX,ECX MOVSXD RSI,EDX SUB RSI,RCX MOV R14,RDI CDQE XOR R13D,R13D ADD RSI,RDI JMP 0x001012af LAB_00101298: ADD R13D,0x1 TEST R12D,R12D SETZ DL TEST EAX,EAX SETZ CL SUB RAX,0x1 OR DL,CL JNZ 0x001012ec LAB_001012af: MOV EDX,R12D MOVZX EBX,byte ptr [RBP + RAX*0x1] LEA R15D,[RAX + 0x1] MOV ECX,EAX SUB R12D,0x1 CMP byte ptr [RSI + RAX*0x1],BL JZ 0x00101298 MOV RSI,RBP MOV RDI,R14 CALL 0x00101250 MOV ECX,R15D MOV EDX,R12D MOV RSI,RBP MOV RDI,R14 MOV EBX,EAX CALL 0x00101250 CMP EBX,EAX CMOVL EBX,EAX ADD R13D,EBX LAB_001012ec: ADD RSP,0x8 MOV EAX,R13D POP RBX POP RBP POP R12 POP R13 POP R14 POP R15 RET LAB_001012fe: XOR R13D,R13D JMP 0x001012ec
int func0(long param_1,long param_2,int param_3,int param_4) { int iVar1; int iVar2; ulong uVar3; int iVar4; int iVar5; if ((param_4 == 0) || (param_3 == 0)) { iVar5 = 0; } else { uVar3 = (ulong)(param_4 + -1); iVar5 = 0; iVar1 = param_3; do { iVar2 = (int)uVar3; iVar4 = iVar1 + -1; if (*(char *)(((long)param_3 - (long)param_4) + param_1 + uVar3) != *(char *)(param_2 + uVar3) ) { iVar1 = func0(param_1,param_2,iVar1,uVar3 & 0xffffffff); iVar2 = func0(param_1,param_2,iVar4,iVar2 + 1); if (iVar1 < iVar2) { iVar1 = iVar2; } return iVar5 + iVar1; } iVar5 = iVar5 + 1; uVar3 = uVar3 - 1; iVar1 = iVar4; } while (iVar4 != 0 && iVar2 != 0); } return iVar5; }
4,643
func0
#include <stdio.h> #include <assert.h>
int func0(const char *X, const char *Y, int m, int n) { if (m == 0 || n == 0) { return 0; } else if (X[m-1] == Y[n-1]) { return 1 + func0(X, Y, m-1, n-1); } else { int left = func0(X, Y, m, n-1); int right = func0(X, Y, m-1, n); return (left > right) ? left : right; } }
int main() { assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4); assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3); assert(func0("AXYT", "AYZX", 4, 4) == 2); printf("All test cases passed.\n"); return 0; }
O3
c
func0: endbr64 push %r15 movslq %ecx,%rax push %r14 push %r13 push %r12 push %rbp push %rbx sub $0x8,%rsp test %eax,%eax je 12fd <func0+0xad> mov %edx,%r12d test %edx,%edx je 12fd <func0+0xad> movslq %edx,%r8 lea -0x1(%rax),%ecx mov %rdi,%r14 mov %rsi,%rbp sub %rax,%r8 movslq %ecx,%rcx xor %r13d,%r13d add %rdi,%r8 jmp 12af <func0+0x5f> nopw 0x0(%rax,%rax,1) add $0x1,%r13d test %r12d,%r12d sete %dl test %ecx,%ecx sete %al sub $0x1,%rcx or %al,%dl jne 12eb <func0+0x9b> mov %r12d,%edx movzbl 0x0(%rbp,%rcx,1),%eax lea 0x1(%rcx),%r15d sub $0x1,%r12d cmp %al,(%r8,%rcx,1) je 1298 <func0+0x48> mov %rbp,%rsi mov %r14,%rdi callq 1250 <func0> mov %r15d,%ecx mov %r12d,%edx mov %rbp,%rsi mov %r14,%rdi mov %eax,%ebx callq 1250 <func0> cmp %eax,%ebx cmovl %eax,%ebx add %ebx,%r13d add $0x8,%rsp mov %r13d,%eax pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 pop %r15 retq xor %r13d,%r13d jmp 12eb <func0+0x9b> nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax)
func0: endbr64 push r15 push r14 push r13 push r12 push rbp push rbx sub rsp, 68h mov [rsp+98h+var_98], rdi test edx, edx jz loc_1B87 test ecx, ecx jz loc_1B87 mov rax, rdi lea ebp, [rcx-1] movsxd rdi, edx movsxd rcx, ecx sub rdi, rcx mov ebx, edx movsxd rbp, ebp xor r13d, r13d add rdi, rax jmp short loc_12B0 loc_1298: add r13d, 1 sub rbp, 1 test dl, dl jnz loc_1B45 test cl, cl jnz loc_1B45 loc_12B0: mov r14d, ebx movzx eax, byte ptr [rdi+rbp] sub ebx, 1 movzx r12d, byte ptr [rsi+rbp] setz dl test ebp, ebp setz cl cmp al, r12b jz short loc_1298 mov [rsp+98h+var_8C], ebp test ebp, ebp jz loc_1BB6 movsxd rdx, ebp movsxd rdi, r14d xor r9d, r9d lea r15d, [rdx-1] sub rdi, rdx mov rdx, [rsp+98h+var_98] movsxd r15, r15d add rdi, rdx jmp short loc_1318 loc_12F8: add r9d, 1 sub r15, 1 test dl, dl jnz loc_1738 test cl, cl jnz loc_1738 movzx eax, byte ptr [rdi+r15] mov r14d, r8d loc_1318: mov r8d, r14d movzx r10d, byte ptr [rsi+r15] sub r8d, 1 setz dl test r15d, r15d setz cl cmp r10b, al jz short loc_12F8 mov [rsp+98h+var_90], r9d mov dword ptr [rsp+98h+var_80], r15d test r15d, r15d jz loc_1BD3 movsxd rdx, r15d movsxd rdi, r14d xor ecx, ecx mov dword ptr [rsp+98h+var_78], ebx lea r9d, [rdx-1] sub rdi, rdx mov rdx, [rsp+98h+var_98] mov [rsp+98h+var_70], rbp movsxd r9, r9d mov ebx, ecx add rdi, rdx jmp short loc_138F loc_1370: add ebx, 1 sub r9, 1 test dl, dl jnz loc_1B60 test cl, cl jnz loc_1B60 movzx eax, byte ptr [rdi+r9] mov r14d, r11d loc_138F: mov r11d, r14d sub r11d, 1 setz dl test r9d, r9d setz cl cmp [rsi+r9], al jz short loc_1370 movsxd rdx, r9d mov dword ptr [rsp+98h+var_88], ebx mov rbp, [rsp+98h+var_70] mov dword ptr [rsp+98h+var_68], r11d mov ebx, dword ptr [rsp+98h+var_78] mov [rsp+98h+var_50], edx test r9d, r9d jz loc_1C17 movsxd rax, r14d lea r11d, [rdx-1] mov dword ptr [rsp+98h+var_70], r8d xor edi, edi sub rax, rdx mov rdx, [rsp+98h+var_98] movsxd r11, r11d add rax, rdx jmp short loc_1400 loc_13E8: add edi, 1 sub r11, 1 test r14d, r14d jz loc_1B8C test ecx, ecx jz loc_1B8C loc_1400: mov edx, r14d movzx r8d, byte ptr [rsi+r11] mov ecx, r11d sub r14d, 1 cmp [rax+r11], r8b jz short loc_13E8 mov r8d, dword ptr [rsp+98h+var_70] mov dword ptr [rsp+98h+var_78], edi mov rdi, [rsp+98h+var_98] mov [rsp+98h+var_40], r9 mov byte ptr [rsp+98h+var_4C], r10b mov dword ptr [rsp+98h+var_58], r8d mov [rsp+98h+var_48], r11 mov [rsp+98h+var_60], rsi call func0 mov r11, [rsp+98h+var_48] mov rsi, [rsp+98h+var_60] mov edx, r14d mov rdi, [rsp+98h+var_98] mov dword ptr [rsp+98h+var_70], eax lea ecx, [r11+1] call func0 mov esi, dword ptr [rsp+98h+var_70] mov r8d, dword ptr [rsp+98h+var_58] movzx r10d, byte ptr [rsp+98h+var_4C] mov r9, [rsp+98h+var_40] cmp esi, eax cmovge eax, esi add dword ptr [rsp+98h+var_78], eax mov rsi, [rsp+98h+var_60] loc_1480: mov r14d, dword ptr [rsp+98h+var_68] test r14d, r14d jz loc_1C0F lea eax, [r9+1] movsxd rdx, r14d movsxd r11, [rsp+98h+var_50] xor r9d, r9d cdqe sub rdx, rax mov rax, [rsp+98h+var_98] add rax, rdx jmp short loc_14C1 loc_14B0: add r9d, 1 sub r11, 1 test r14d, r14d jz short loc_1537 test ecx, ecx jz short loc_1537 loc_14C1: mov edx, r14d movzx edi, byte ptr [rsi+r11] mov ecx, r11d sub r14d, 1 cmp [rax+r11], dil jz short loc_14B0 mov rdi, [rsp+98h+var_98] mov [rsp+98h+var_4C], r9d mov byte ptr [rsp+98h+var_60], r10b mov [rsp+98h+var_50], r8d mov [rsp+98h+var_58], r11 mov [rsp+98h+var_68], rsi call func0 mov r11, [rsp+98h+var_58] mov rsi, [rsp+98h+var_68] mov edx, r14d mov rdi, [rsp+98h+var_98] mov dword ptr [rsp+98h+var_70], eax lea ecx, [r11+1] call func0 mov esi, dword ptr [rsp+98h+var_70] mov r9d, [rsp+98h+var_4C] mov r8d, [rsp+98h+var_50] movzx r10d, byte ptr [rsp+98h+var_60] cmp esi, eax cmovge eax, esi mov rsi, [rsp+98h+var_68] add r9d, eax loc_1537: mov eax, dword ptr [rsp+98h+var_78] cmp eax, r9d cmovl eax, r9d add dword ptr [rsp+98h+var_88], eax loc_1546: test r8d, r8d jz loc_1BED lea eax, [r15+1] movsxd rcx, r8d movsxd r15, dword ptr [rsp+98h+var_80] xor r8d, r8d cdqe mov r14, rcx sub rcx, rax mov rax, [rsp+98h+var_98] add rcx, rax jmp short loc_1590 loc_1570: add r8d, 1 sub r15, 1 test al, al jnz loc_1723 test dl, dl jnz loc_1723 movzx r10d, byte ptr [rsi+r15] mov r14d, r9d loc_1590: mov r9d, r14d mov r11d, r15d sub r9d, 1 setz al test r15d, r15d setz dl cmp [rcx+r15], r10b jz short loc_1570 test r15d, r15d jz loc_1C02 movsxd rdx, r15d movsxd rax, r14d lea r10d, [r15-1] mov dword ptr [rsp+98h+var_80], r8d sub rax, rdx mov rdx, [rsp+98h+var_98] movsxd r10, r10d xor edi, edi add rax, rdx jmp short loc_15F0 loc_15D8: add edi, 1 sub r10, 1 test r14d, r14d jz loc_1B9A test ecx, ecx jz loc_1B9A loc_15F0: mov edx, r14d movzx r8d, byte ptr [rsi+r10] mov ecx, r10d sub r14d, 1 cmp [rax+r10], r8b jz short loc_15D8 mov r8d, dword ptr [rsp+98h+var_80] mov dword ptr [rsp+98h+var_80], edi mov rdi, [rsp+98h+var_98] mov [rsp+98h+var_50], r9d mov dword ptr [rsp+98h+var_58], r8d mov dword ptr [rsp+98h+var_68], r11d mov [rsp+98h+var_60], r10 mov [rsp+98h+var_70], rsi call func0 mov r10, [rsp+98h+var_60] mov rsi, [rsp+98h+var_70] mov edx, r14d mov rdi, [rsp+98h+var_98] mov dword ptr [rsp+98h+var_78], eax lea ecx, [r10+1] call func0 mov esi, dword ptr [rsp+98h+var_78] mov r11d, dword ptr [rsp+98h+var_68] mov r9d, [rsp+98h+var_50] mov r8d, dword ptr [rsp+98h+var_58] cmp esi, eax cmovge eax, esi add dword ptr [rsp+98h+var_80], eax mov rsi, [rsp+98h+var_70] loc_166F: test r9d, r9d jz loc_1C2C lea eax, [r15+1] movsxd rdx, r9d movsxd r15, r11d xor r9d, r9d cdqe mov r14, rdx sub rdx, rax mov rax, [rsp+98h+var_98] add rax, rdx jmp short loc_16B1 loc_16A0: add r9d, 1 sub r15, 1 test r14d, r14d jz short loc_1715 test ecx, ecx jz short loc_1715 loc_16B1: mov edx, r14d movzx edi, byte ptr [rsi+r15] mov ecx, r15d sub r14d, 1 cmp [rax+r15], dil jz short loc_16A0 mov rdi, [rsp+98h+var_98] mov [rsp+98h+var_50], r8d mov dword ptr [rsp+98h+var_68], r9d mov [rsp+98h+var_78], rsi call func0 mov rdi, [rsp+98h+var_98] lea ecx, [r15+1] mov edx, r14d mov rsi, [rsp+98h+var_78] mov dword ptr [rsp+98h+var_70], eax call func0 mov r10d, dword ptr [rsp+98h+var_70] mov r9d, dword ptr [rsp+98h+var_68] mov rsi, [rsp+98h+var_78] mov r8d, [rsp+98h+var_50] cmp r10d, eax cmovl r10d, eax add r9d, r10d loc_1715: mov eax, dword ptr [rsp+98h+var_80] cmp eax, r9d cmovl eax, r9d add r8d, eax loc_1723: mov eax, dword ptr [rsp+98h+var_88] cmp eax, r8d cmovl eax, r8d add [rsp+98h+var_90], eax jmp short loc_173D loc_1738: mov [rsp+98h+var_90], r9d loc_173D: test ebx, ebx jz loc_1BC3 lea eax, [rbp+1] movsxd rdi, ebx movsxd rbp, [rsp+98h+var_8C] xor r8d, r8d cdqe sub rdi, rax mov rax, [rsp+98h+var_98] add rdi, rax jmp short loc_1788 loc_1768: add r8d, 1 sub rbp, 1 test dl, dl jnz loc_1B37 test cl, cl jnz loc_1B37 movzx r12d, byte ptr [rsi+rbp] mov ebx, r14d loc_1788: mov r14d, ebx movzx eax, byte ptr [rdi+rbp] mov r11d, ebp sub r14d, 1 setz dl test ebp, ebp setz cl cmp al, r12b jz short loc_1768 test ebp, ebp jz loc_1BE0 movsxd rdx, ebp movsxd rdi, ebx lea r15d, [rbp-1] xor ecx, ecx sub rdi, rdx mov rdx, [rsp+98h+var_98] mov dword ptr [rsp+98h+var_88], r8d movsxd r15, r15d mov r8d, ecx add rdi, rdx jmp short loc_17F0 loc_17D0: add r8d, 1 sub r15, 1 test dl, dl jnz loc_1B78 test cl, cl jnz loc_1B78 movzx eax, byte ptr [rdi+r15] mov ebx, r9d loc_17F0: mov r9d, ebx sub r9d, 1 setz dl test r15d, r15d setz cl cmp [rsi+r15], al jz short loc_17D0 movsxd rdx, r15d mov [rsp+98h+var_8C], r8d mov r8d, dword ptr [rsp+98h+var_88] mov dword ptr [rsp+98h+var_80], edx test r15d, r15d jz loc_1BF5 movsxd rax, ebx lea r10d, [rdx-1] xor edi, edi sub rax, rdx mov rdx, [rsp+98h+var_98] movsxd r10, r10d add rax, rdx jmp short loc_1857 loc_1840: add edi, 1 sub r10, 1 test ebx, ebx jz loc_1BA8 test ecx, ecx jz loc_1BA8 loc_1857: mov edx, ebx movzx r8d, byte ptr [rsi+r10] mov ecx, r10d sub ebx, 1 cmp [rax+r10], r8b jz short loc_1840 mov r8d, dword ptr [rsp+98h+var_88] mov dword ptr [rsp+98h+var_88], edi mov rdi, [rsp+98h+var_98] mov [rsp+98h+var_50], r9d mov dword ptr [rsp+98h+var_58], r8d mov dword ptr [rsp+98h+var_68], r11d mov [rsp+98h+var_60], r10 mov [rsp+98h+var_70], rsi call func0 mov r10, [rsp+98h+var_60] mov rdi, [rsp+98h+var_98] mov edx, ebx mov rsi, [rsp+98h+var_70] mov dword ptr [rsp+98h+var_78], eax lea ecx, [r10+1] call func0 mov esi, dword ptr [rsp+98h+var_78] mov r11d, dword ptr [rsp+98h+var_68] mov r9d, [rsp+98h+var_50] mov r8d, dword ptr [rsp+98h+var_58] cmp esi, eax cmovge eax, esi add dword ptr [rsp+98h+var_88], eax mov rsi, [rsp+98h+var_70] loc_18D3: test r9d, r9d jz loc_1C24 lea eax, [r15+1] movsxd rdx, r9d movsxd rbx, dword ptr [rsp+98h+var_80] xor r9d, r9d cdqe mov r15, rdx sub rdx, rax mov rax, [rsp+98h+var_98] add rax, rdx jmp short loc_1911 loc_1900: add r9d, 1 sub rbx, 1 test r15d, r15d jz short loc_197C test ecx, ecx jz short loc_197C loc_1911: mov edx, r15d movzx edi, byte ptr [rsi+rbx] mov ecx, ebx sub r15d, 1 cmp [rax+rbx], dil jz short loc_1900 mov rdi, [rsp+98h+var_98] mov [rsp+98h+var_50], r8d mov dword ptr [rsp+98h+var_68], r9d mov dword ptr [rsp+98h+var_70], r11d mov [rsp+98h+var_80], rsi call func0 mov rsi, [rsp+98h+var_80] lea ecx, [rbx+1] mov edx, r15d mov rdi, [rsp+98h+var_98] mov dword ptr [rsp+98h+var_78], eax call func0 mov r10d, dword ptr [rsp+98h+var_78] mov r9d, dword ptr [rsp+98h+var_68] mov rsi, [rsp+98h+var_80] mov r11d, dword ptr [rsp+98h+var_70] cmp r10d, eax mov r8d, [rsp+98h+var_50] cmovl r10d, eax add r9d, r10d loc_197C: mov eax, dword ptr [rsp+98h+var_88] cmp eax, r9d cmovl eax, r9d add [rsp+98h+var_8C], eax loc_198B: test r14d, r14d jz loc_1BCB add ebp, 1 mov rax, [rsp+98h+var_98] movsxd rcx, r14d movsxd rbx, r11d movsxd rbp, ebp xor r9d, r9d sub rcx, rbp add rcx, rax jmp short loc_19D0 loc_19B0: add r9d, 1 sub rbx, 1 test al, al jnz loc_1B29 test dl, dl jnz loc_1B29 movzx r12d, byte ptr [rsi+rbx] mov r14d, ebp loc_19D0: mov ebp, r14d movsxd r15, ebx sub ebp, 1 setz al test ebx, ebx setz dl cmp [rcx+rbx], r12b jz short loc_19B0 test ebx, ebx jz loc_1C34 mov rdi, [rsp+98h+var_98] movsxd rax, r14d movsxd rdx, r15d lea r12d, [r15-1] sub rax, rdx movsxd r12, r12d xor r10d, r10d add rax, rdi jmp short loc_1A21 loc_1A10: add r10d, 1 sub r12, 1 test r14d, r14d jz short loc_1A90 test ecx, ecx jz short loc_1A90 loc_1A21: mov edx, r14d movzx edi, byte ptr [rsi+r12] mov ecx, r12d sub r14d, 1 cmp [rax+r12], dil jz short loc_1A10 mov rdi, [rsp+98h+var_98] mov dword ptr [rsp+98h+var_68], r8d mov dword ptr [rsp+98h+var_70], r9d mov dword ptr [rsp+98h+var_78], r10d mov [rsp+98h+var_88], rsi call func0 mov rsi, [rsp+98h+var_88] mov rdi, [rsp+98h+var_98] mov edx, r14d lea ecx, [r12+1] mov dword ptr [rsp+98h+var_80], eax call func0 mov r11d, dword ptr [rsp+98h+var_80] mov r10d, dword ptr [rsp+98h+var_78] mov rsi, [rsp+98h+var_88] mov r9d, dword ptr [rsp+98h+var_70] cmp r11d, eax mov r8d, dword ptr [rsp+98h+var_68] cmovl r11d, eax add r10d, r11d loc_1A90: test ebp, ebp jz loc_1C3C lea eax, [rbx+1] movsxd rdx, ebp xor r12d, r12d cdqe sub rdx, rax mov rax, [rsp+98h+var_98] add rax, rdx jmp short loc_1AC0 loc_1AB0: add r12d, 1 sub r15, 1 test ebp, ebp jz short loc_1B1F test ecx, ecx jz short loc_1B1F loc_1AC0: mov edx, ebp movzx edi, byte ptr [rsi+r15] mov ecx, r15d sub ebp, 1 cmp [rax+r15], dil jz short loc_1AB0 mov r14, [rsp+98h+var_98] mov dword ptr [rsp+98h+var_70], r8d mov dword ptr [rsp+98h+var_78], r9d mov rdi, r14 mov dword ptr [rsp+98h+var_80], r10d mov [rsp+98h+var_88], rsi call func0 mov rsi, [rsp+98h+var_88] lea ecx, [r15+1] mov edx, ebp mov rdi, r14 mov ebx, eax call func0 mov r10d, dword ptr [rsp+98h+var_80] mov r9d, dword ptr [rsp+98h+var_78] cmp ebx, eax mov r8d, dword ptr [rsp+98h+var_70] cmovl ebx, eax add r12d, ebx loc_1B1F: cmp r10d, r12d cmovl r10d, r12d add r9d, r10d loc_1B29: mov eax, [rsp+98h+var_8C] cmp eax, r9d cmovl eax, r9d add r8d, eax loc_1B37: mov eax, [rsp+98h+var_90] cmp eax, r8d cmovl eax, r8d add r13d, eax loc_1B45: add rsp, 68h mov eax, r13d pop rbx pop rbp pop r12 pop r13 pop r14 pop r15 retn loc_1B60: mov dword ptr [rsp+98h+var_88], ebx mov rbp, [rsp+98h+var_70] mov ebx, dword ptr [rsp+98h+var_78] jmp loc_1546 loc_1B78: mov [rsp+98h+var_8C], r8d mov r8d, dword ptr [rsp+98h+var_88] jmp loc_198B loc_1B87: xor r13d, r13d jmp short loc_1B45 loc_1B8C: mov dword ptr [rsp+98h+var_78], edi mov r8d, dword ptr [rsp+98h+var_70] jmp loc_1480 loc_1B9A: mov r8d, dword ptr [rsp+98h+var_80] mov dword ptr [rsp+98h+var_80], edi jmp loc_166F loc_1BA8: mov r8d, dword ptr [rsp+98h+var_88] mov dword ptr [rsp+98h+var_88], edi jmp loc_18D3 loc_1BB6: mov [rsp+98h+var_90], 0 jmp loc_173D loc_1BC3: xor r8d, r8d jmp loc_1B37 loc_1BCB: xor r9d, r9d jmp loc_1B29 loc_1BD3: mov dword ptr [rsp+98h+var_88], 0 jmp loc_1546 loc_1BE0: mov [rsp+98h+var_8C], 0 jmp loc_198B loc_1BED: xor r8d, r8d jmp loc_1723 loc_1BF5: mov dword ptr [rsp+98h+var_88], 0 jmp loc_18D3 loc_1C02: mov dword ptr [rsp+98h+var_80], 0 jmp loc_166F loc_1C0F: xor r9d, r9d jmp loc_1537 loc_1C17: mov dword ptr [rsp+98h+var_78], 0 jmp loc_1480 loc_1C24: xor r9d, r9d jmp loc_197C loc_1C2C: xor r9d, r9d jmp loc_1715 loc_1C34: xor r10d, r10d jmp loc_1A90 loc_1C3C: xor r12d, r12d jmp loc_1B1F
long long func0(long long a1, long long a2, unsigned int a3, int a4) { unsigned int v4; // ebx long long v5; // rbp unsigned int v6; // r13d long long v7; // rdi unsigned int v8; // r14d char v9; // al char v10; // r12 bool v11; // cl int v12; // r9d long long v13; // r15 long long v14; // rdi char v15; // r10 unsigned int v16; // r8d bool v17; // cl long long v18; // r9 int v19; // ebx long long v20; // rdi bool v21; // cl int v22; // edi long long v23; // r11 long long v24; // rax long long v25; // rdx int v26; // ecx int v27; // eax unsigned int v28; // r14d int v29; // eax long long v30; // r11 int v31; // r9d long long v32; // rax long long v33; // rdx int v34; // ecx int v35; // eax int v36; // eax long long v37; // rcx int v38; // r8d unsigned int v39; // r14d long long v40; // rcx int v41; // r11d unsigned int v42; // r9d bool v43; // dl long long v44; // r10 int v45; // edi long long v46; // rax long long v47; // rdx int v48; // ecx int v49; // eax int v50; // eax long long v51; // rdx long long v52; // r15 int v53; // r9d unsigned int v54; // r14d long long v55; // rax long long v56; // rdx int v57; // ecx int v58; // eax int v59; // r10d int v60; // eax int v61; // eax int v62; // r8d long long v63; // rdi char v64; // al int v65; // r11d unsigned int v66; // r14d bool v67; // cl long long v68; // r15 int v69; // r8d long long v70; // rdi unsigned int v71; // r9d bool v72; // cl int v73; // edi long long v74; // r10 long long v75; // rax long long v76; // rdx int v77; // ecx int v78; // eax long long v79; // rdx long long v80; // rbx int v81; // r9d long long v82; // rax unsigned int v83; // r15d long long v84; // rax long long v85; // rdx int v86; // ecx int v87; // eax int v88; // r10d int v89; // eax long long v90; // rbx int v91; // r9d long long v92; // rcx long long v93; // r15 unsigned int v94; // ebp bool v95; // dl long long v96; // r12 int v97; // r10d long long v98; // rax long long v99; // rdx int v100; // ecx int v101; // eax int v102; // r11d int v103; // r12d long long v104; // rax long long v105; // rdx int v106; // ecx int v107; // ebx int v108; // eax int v109; // eax int v110; // eax int v113; // [rsp+8h] [rbp-90h] int v114; // [rsp+8h] [rbp-90h] int v115; // [rsp+Ch] [rbp-8Ch] int v116; // [rsp+Ch] [rbp-8Ch] int v117; // [rsp+10h] [rbp-88h] int v118; // [rsp+10h] [rbp-88h] int v119; // [rsp+10h] [rbp-88h] int v120; // [rsp+10h] [rbp-88h] int v121; // [rsp+18h] [rbp-80h] int v122; // [rsp+18h] [rbp-80h] int v123; // [rsp+18h] [rbp-80h] unsigned int v124; // [rsp+20h] [rbp-78h] int v125; // [rsp+20h] [rbp-78h] int v126; // [rsp+20h] [rbp-78h] int v127; // [rsp+20h] [rbp-78h] int v128; // [rsp+20h] [rbp-78h] int v129; // [rsp+20h] [rbp-78h] int v130; // [rsp+20h] [rbp-78h] int v131; // [rsp+28h] [rbp-70h] int v132; // [rsp+28h] [rbp-70h] int v133; // [rsp+28h] [rbp-70h] int v134; // [rsp+28h] [rbp-70h] int v135; // [rsp+28h] [rbp-70h] int v136; // [rsp+28h] [rbp-70h] unsigned int v137; // [rsp+30h] [rbp-68h] int v138; // [rsp+30h] [rbp-68h] int v139; // [rsp+30h] [rbp-68h] int v140; // [rsp+30h] [rbp-68h] char v141; // [rsp+38h] [rbp-60h] int v142; // [rsp+38h] [rbp-60h] int v143; // [rsp+38h] [rbp-60h] unsigned int v144; // [rsp+40h] [rbp-58h] int v145; // [rsp+40h] [rbp-58h] int v146; // [rsp+40h] [rbp-58h] int v147; // [rsp+48h] [rbp-50h] unsigned int v148; // [rsp+48h] [rbp-50h] unsigned int v149; // [rsp+48h] [rbp-50h] int v150; // [rsp+48h] [rbp-50h] unsigned int v151; // [rsp+48h] [rbp-50h] int v152; // [rsp+48h] [rbp-50h] char v153; // [rsp+4Ch] [rbp-4Ch] int v154; // [rsp+4Ch] [rbp-4Ch] int v155; // [rsp+50h] [rbp-48h] int v156; // [rsp+58h] [rbp-40h] if ( a3 && a4 ) { v4 = a3; v5 = a4 - 1; v6 = 0; v7 = a1 + (int)a3 - (long long)a4; while ( 1 ) { v8 = v4; v9 = *(_BYTE *)(v7 + v5); --v4; v10 = *(_BYTE *)(a2 + v5); v11 = (_DWORD)v5 == 0; if ( v9 != v10 ) break; ++v6; --v5; if ( !v4 || v11 ) return v6; } if ( (_DWORD)v5 ) { v12 = 0; v13 = (int)v5 - 1; v14 = a1 + (int)v8 - (long long)(int)v5; while ( 1 ) { v15 = *(_BYTE *)(a2 + v13); v16 = v8 - 1; v17 = (_DWORD)v13 == 0; if ( v15 != v9 ) break; ++v12; --v13; if ( v8 == 1 || v17 ) { v114 = v12; goto LABEL_67; } v9 = *(_BYTE *)(v14 + v13); --v8; } v113 = v12; if ( (_DWORD)v13 ) { v124 = v4; v18 = (int)v13 - 1; v19 = 0; v20 = a1 + (int)v8 - (long long)(int)v13; while ( 1 ) { v21 = (_DWORD)v18 == 0; if ( *(_BYTE *)(a2 + v18) != v9 ) break; ++v19; --v18; if ( v8 == 1 || v21 ) { v118 = v19; v4 = v124; goto LABEL_38; } v9 = *(_BYTE *)(v20 + v18); --v8; } v117 = v19; v137 = v8 - 1; v4 = v124; v147 = v18; if ( (_DWORD)v18 ) { v22 = 0; v23 = (int)v18 - 1; v24 = a1 + (int)v8 - (long long)(int)v18; while ( 1 ) { v25 = v8; v26 = v23; --v8; if ( *(_BYTE *)(v24 + v23) != *(_BYTE *)(a2 + v23) ) break; ++v22; --v23; if ( !v8 || !v26 ) { v125 = v22; goto LABEL_27; } } v156 = v18; v153 = *(_BYTE *)(a2 + v13); v144 = v16; v155 = v23; v131 = func0(a1, a2, v25, (unsigned int)v23); v27 = func0(a1, a2, v8, (unsigned int)(v155 + 1)); v16 = v144; v15 = v153; LODWORD(v18) = v156; if ( v131 >= v27 ) v27 = v131; v125 = v27 + v22; } else { v125 = 0; } LABEL_27: v28 = v137; if ( v137 ) { v29 = v18 + 1; v30 = v147; v31 = 0; v32 = (int)v137 - (long long)v29 + a1; while ( 1 ) { v33 = v28; v34 = v30; --v28; if ( *(_BYTE *)(v32 + v30) != *(_BYTE *)(a2 + v30) ) break; ++v31; --v30; if ( !v28 || !v34 ) goto LABEL_35; } v154 = v31; v141 = v15; v148 = v16; v145 = v30; v132 = func0(a1, a2, v33, (unsigned int)v30); v35 = func0(a1, a2, v28, (unsigned int)(v145 + 1)); v16 = v148; v15 = v141; if ( v132 >= v35 ) v35 = v132; v31 = v35 + v154; } else { v31 = 0; } LABEL_35: v36 = v125; if ( v125 < v31 ) v36 = v31; v118 = v36 + v117; } else { v118 = 0; } LABEL_38: if ( v16 ) { v37 = (int)v16; v13 = (int)v13; v38 = 0; v39 = v37; v40 = a1 + v37 - ((int)v13 + 1); while ( 1 ) { v41 = v13; v42 = v39 - 1; v43 = (_DWORD)v13 == 0; if ( *(_BYTE *)(v40 + v13) != v15 ) break; ++v38; --v13; if ( v39 == 1 || v43 ) goto LABEL_63; v15 = *(_BYTE *)(a2 + v13); --v39; } if ( (_DWORD)v13 ) { v44 = (int)v13 - 1; v45 = 0; v46 = a1 + (int)v39 - (long long)(int)v13; while ( 1 ) { v47 = v39; v48 = v44; --v39; if ( *(_BYTE *)(v46 + v44) != *(_BYTE *)(a2 + v44) ) break; ++v45; --v44; if ( !v39 || !v48 ) { v121 = v45; goto LABEL_52; } } v149 = v42; v146 = v38; v142 = v44; v126 = func0(a1, a2, v47, (unsigned int)v44); v49 = func0(a1, a2, v39, (unsigned int)(v142 + 1)); v41 = v13; v42 = v149; v38 = v146; if ( v126 >= v49 ) v49 = v126; v121 = v49 + v45; } else { v121 = 0; } LABEL_52: if ( v42 ) { v50 = v13 + 1; v51 = (int)v42; v52 = v41; v53 = 0; v54 = v51; v55 = v51 - v50 + a1; while ( 1 ) { v56 = v54; v57 = v52; --v54; if ( *(_BYTE *)(v55 + v52) != *(_BYTE *)(a2 + v52) ) break; ++v53; --v52; if ( !v54 || !v57 ) goto LABEL_60; } v150 = v38; v138 = v53; v133 = func0(a1, a2, v56, (unsigned int)v52); v58 = func0(a1, a2, v54, (unsigned int)(v52 + 1)); v59 = v133; v38 = v150; if ( v133 < v58 ) v59 = v58; v53 = v59 + v138; } else { v53 = 0; } LABEL_60: v60 = v121; if ( v121 < v53 ) v60 = v53; v38 += v60; } else { v38 = 0; } LABEL_63: v61 = v118; if ( v118 < v38 ) v61 = v38; v114 = v61 + v113; } else { v114 = 0; } LABEL_67: if ( v4 ) { v5 = (int)v5; v62 = 0; v63 = a1 + (int)v4 - (long long)((int)v5 + 1); while ( 1 ) { v64 = *(_BYTE *)(v63 + v5); v65 = v5; v66 = v4 - 1; v67 = (_DWORD)v5 == 0; if ( v64 != v10 ) break; ++v62; --v5; if ( v4 == 1 || v67 ) goto LABEL_126; v10 = *(_BYTE *)(a2 + v5); --v4; } if ( (_DWORD)v5 ) { v119 = v62; v68 = (int)v5 - 1; v69 = 0; v70 = a1 + (int)v4 - (long long)(int)v5; while ( 1 ) { v71 = v4 - 1; v72 = (_DWORD)v68 == 0; if ( *(_BYTE *)(a2 + v68) != v64 ) break; ++v69; --v68; if ( v4 == 1 || v72 ) { v116 = v69; v62 = v119; goto LABEL_98; } v64 = *(_BYTE *)(v70 + v68); --v4; } v115 = v69; v62 = v119; if ( (_DWORD)v68 ) { v73 = 0; v74 = (int)v68 - 1; v75 = a1 + (int)v4 - (long long)(int)v68; while ( 1 ) { v76 = v4; v77 = v74; --v4; if ( *(_BYTE *)(v75 + v74) != *(_BYTE *)(a2 + v74) ) break; ++v73; --v74; if ( !v4 || !v77 ) { v62 = v119; v120 = v73; goto LABEL_87; } } v151 = v71; v143 = v74; v127 = func0(a1, a2, v76, (unsigned int)v74); v78 = func0(a1, a2, v4, (unsigned int)(v143 + 1)); v65 = v5; v71 = v151; v62 = v119; if ( v127 >= v78 ) v78 = v127; v120 = v78 + v73; } else { v120 = 0; } LABEL_87: if ( v71 ) { v79 = (int)v71; v80 = (int)v68; v81 = 0; v82 = (int)v68 + 1; v83 = v79; v84 = v79 - v82 + a1; while ( 1 ) { v85 = v83; v86 = v80; --v83; if ( *(_BYTE *)(v84 + v80) != *(_BYTE *)(a2 + v80) ) break; ++v81; --v80; if ( !v83 || !v86 ) goto LABEL_95; } v152 = v62; v139 = v81; v134 = v65; v128 = func0(a1, a2, v85, (unsigned int)v80); v87 = func0(a1, a2, v83, (unsigned int)(v80 + 1)); v88 = v128; v65 = v134; v62 = v152; if ( v128 < v87 ) v88 = v87; v81 = v88 + v139; } else { v81 = 0; } LABEL_95: v89 = v120; if ( v120 < v81 ) v89 = v81; v116 = v89 + v115; } else { v116 = 0; } LABEL_98: if ( v66 ) { v90 = v65; v91 = 0; v92 = a1 + (int)v66 - (long long)((int)v5 + 1); while ( 1 ) { v93 = (int)v90; v94 = v66 - 1; v95 = (_DWORD)v90 == 0; if ( *(_BYTE *)(v92 + v90) != v10 ) break; ++v91; --v90; if ( v66 == 1 || v95 ) goto LABEL_123; v10 = *(_BYTE *)(a2 + v90); --v66; } if ( (_DWORD)v90 ) { v96 = (int)v90 - 1; v97 = 0; v98 = a1 + (int)v66 - (long long)(int)v90; while ( 1 ) { v99 = v66; v100 = v96; --v66; if ( *(_BYTE *)(v98 + v96) != *(_BYTE *)(a2 + v96) ) break; ++v97; --v96; if ( !v66 || !v100 ) goto LABEL_112; } v140 = v62; v135 = v91; v129 = v97; v122 = func0(a1, a2, v99, (unsigned int)v96); v101 = func0(a1, a2, v66, (unsigned int)(v96 + 1)); v102 = v122; v91 = v135; v62 = v140; if ( v122 < v101 ) v102 = v101; v97 = v102 + v129; } else { v97 = 0; } LABEL_112: if ( v94 ) { v103 = 0; v104 = (int)v94 - (long long)((int)v90 + 1) + a1; while ( 1 ) { v105 = v94; v106 = v93; --v94; if ( *(_BYTE *)(v104 + v93) != *(_BYTE *)(a2 + v93) ) break; ++v103; --v93; if ( !v94 || !v106 ) goto LABEL_120; } v136 = v62; v130 = v91; v123 = v97; v107 = func0(a1, a2, v105, (unsigned int)v93); v108 = func0(a1, a2, v94, (unsigned int)(v93 + 1)); v97 = v123; v91 = v130; v62 = v136; if ( v107 < v108 ) v107 = v108; v103 += v107; } else { v103 = 0; } LABEL_120: if ( v97 < v103 ) v97 = v103; v91 += v97; } else { v91 = 0; } LABEL_123: v109 = v116; if ( v116 < v91 ) v109 = v91; v62 += v109; } else { v62 = 0; } LABEL_126: v110 = v114; if ( v114 < v62 ) v110 = v62; v6 += v110; } else { return 0; } return v6; }
func0: ENDBR64 PUSH R15 PUSH R14 PUSH R13 PUSH R12 PUSH RBP PUSH RBX SUB RSP,0x68 MOV qword ptr [RSP],RDI TEST EDX,EDX JZ 0x00101b87 TEST ECX,ECX JZ 0x00101b87 MOV RAX,RDI LEA EBP,[RCX + -0x1] MOVSXD RDI,EDX MOVSXD RCX,ECX SUB RDI,RCX MOV EBX,EDX MOVSXD RBP,EBP XOR R13D,R13D ADD RDI,RAX JMP 0x001012b0 LAB_00101298: ADD R13D,0x1 SUB RBP,0x1 TEST DL,DL JNZ 0x00101b45 TEST CL,CL JNZ 0x00101b45 LAB_001012b0: MOV R14D,EBX MOVZX EAX,byte ptr [RDI + RBP*0x1] SUB EBX,0x1 MOVZX R12D,byte ptr [RSI + RBP*0x1] SETZ DL TEST EBP,EBP SETZ CL CMP AL,R12B JZ 0x00101298 MOV dword ptr [RSP + 0xc],EBP TEST EBP,EBP JZ 0x00101bb6 MOVSXD RDX,EBP MOVSXD RDI,R14D XOR R9D,R9D LEA R15D,[RDX + -0x1] SUB RDI,RDX MOV RDX,qword ptr [RSP] MOVSXD R15,R15D ADD RDI,RDX JMP 0x00101318 LAB_001012f8: ADD R9D,0x1 SUB R15,0x1 TEST DL,DL JNZ 0x00101738 TEST CL,CL JNZ 0x00101738 MOVZX EAX,byte ptr [RDI + R15*0x1] MOV R14D,R8D LAB_00101318: MOV R8D,R14D MOVZX R10D,byte ptr [RSI + R15*0x1] SUB R8D,0x1 SETZ DL TEST R15D,R15D SETZ CL CMP R10B,AL JZ 0x001012f8 MOV dword ptr [RSP + 0x8],R9D MOV dword ptr [RSP + 0x18],R15D TEST R15D,R15D JZ 0x00101bd3 MOVSXD RDX,R15D MOVSXD RDI,R14D XOR ECX,ECX MOV dword ptr [RSP + 0x20],EBX LEA R9D,[RDX + -0x1] SUB RDI,RDX MOV RDX,qword ptr [RSP] MOV qword ptr [RSP + 0x28],RBP MOVSXD R9,R9D MOV EBX,ECX ADD RDI,RDX JMP 0x0010138f LAB_00101370: ADD EBX,0x1 SUB R9,0x1 TEST DL,DL JNZ 0x00101b60 TEST CL,CL JNZ 0x00101b60 MOVZX EAX,byte ptr [RDI + R9*0x1] MOV R14D,R11D LAB_0010138f: MOV R11D,R14D SUB R11D,0x1 SETZ DL TEST R9D,R9D SETZ CL CMP byte ptr [RSI + R9*0x1],AL JZ 0x00101370 MOVSXD RDX,R9D MOV dword ptr [RSP + 0x10],EBX MOV RBP,qword ptr [RSP + 0x28] MOV dword ptr [RSP + 0x30],R11D MOV EBX,dword ptr [RSP + 0x20] MOV dword ptr [RSP + 0x48],EDX TEST R9D,R9D JZ 0x00101c17 MOVSXD RAX,R14D LEA R11D,[RDX + -0x1] MOV dword ptr [RSP + 0x28],R8D XOR EDI,EDI SUB RAX,RDX MOV RDX,qword ptr [RSP] MOVSXD R11,R11D ADD RAX,RDX JMP 0x00101400 LAB_001013e8: ADD EDI,0x1 SUB R11,0x1 TEST R14D,R14D JZ 0x00101b8c TEST ECX,ECX JZ 0x00101b8c LAB_00101400: MOV EDX,R14D MOVZX R8D,byte ptr [RSI + R11*0x1] MOV ECX,R11D SUB R14D,0x1 CMP byte ptr [RAX + R11*0x1],R8B JZ 0x001013e8 MOV R8D,dword ptr [RSP + 0x28] MOV dword ptr [RSP + 0x20],EDI MOV RDI,qword ptr [RSP] MOV qword ptr [RSP + 0x58],R9 MOV byte ptr [RSP + 0x4c],R10B MOV dword ptr [RSP + 0x40],R8D MOV qword ptr [RSP + 0x50],R11 MOV qword ptr [RSP + 0x38],RSI CALL 0x00101250 MOV R11,qword ptr [RSP + 0x50] MOV RSI,qword ptr [RSP + 0x38] MOV EDX,R14D MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x28],EAX LEA ECX,[R11 + 0x1] CALL 0x00101250 MOV ESI,dword ptr [RSP + 0x28] MOV R8D,dword ptr [RSP + 0x40] MOVZX R10D,byte ptr [RSP + 0x4c] MOV R9,qword ptr [RSP + 0x58] CMP ESI,EAX CMOVGE EAX,ESI ADD dword ptr [RSP + 0x20],EAX MOV RSI,qword ptr [RSP + 0x38] LAB_00101480: MOV R14D,dword ptr [RSP + 0x30] TEST R14D,R14D JZ 0x00101c0f LEA EAX,[R9 + 0x1] MOVSXD RDX,R14D MOVSXD R11,dword ptr [RSP + 0x48] XOR R9D,R9D CDQE SUB RDX,RAX MOV RAX,qword ptr [RSP] ADD RAX,RDX JMP 0x001014c1 LAB_001014b0: ADD R9D,0x1 SUB R11,0x1 TEST R14D,R14D JZ 0x00101537 TEST ECX,ECX JZ 0x00101537 LAB_001014c1: MOV EDX,R14D MOVZX EDI,byte ptr [RSI + R11*0x1] MOV ECX,R11D SUB R14D,0x1 CMP byte ptr [RAX + R11*0x1],DIL JZ 0x001014b0 MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x4c],R9D MOV byte ptr [RSP + 0x38],R10B MOV dword ptr [RSP + 0x48],R8D MOV qword ptr [RSP + 0x40],R11 MOV qword ptr [RSP + 0x30],RSI CALL 0x00101250 MOV R11,qword ptr [RSP + 0x40] MOV RSI,qword ptr [RSP + 0x30] MOV EDX,R14D MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x28],EAX LEA ECX,[R11 + 0x1] CALL 0x00101250 MOV ESI,dword ptr [RSP + 0x28] MOV R9D,dword ptr [RSP + 0x4c] MOV R8D,dword ptr [RSP + 0x48] MOVZX R10D,byte ptr [RSP + 0x38] CMP ESI,EAX CMOVGE EAX,ESI MOV RSI,qword ptr [RSP + 0x30] ADD R9D,EAX LAB_00101537: MOV EAX,dword ptr [RSP + 0x20] CMP EAX,R9D CMOVL EAX,R9D ADD dword ptr [RSP + 0x10],EAX LAB_00101546: TEST R8D,R8D JZ 0x00101bed LEA EAX,[R15 + 0x1] MOVSXD RCX,R8D MOVSXD R15,dword ptr [RSP + 0x18] XOR R8D,R8D CDQE MOV R14,RCX SUB RCX,RAX MOV RAX,qword ptr [RSP] ADD RCX,RAX JMP 0x00101590 LAB_00101570: ADD R8D,0x1 SUB R15,0x1 TEST AL,AL JNZ 0x00101723 TEST DL,DL JNZ 0x00101723 MOVZX R10D,byte ptr [RSI + R15*0x1] MOV R14D,R9D LAB_00101590: MOV R9D,R14D MOV R11D,R15D SUB R9D,0x1 SETZ AL TEST R15D,R15D SETZ DL CMP byte ptr [RCX + R15*0x1],R10B JZ 0x00101570 TEST R15D,R15D JZ 0x00101c02 MOVSXD RDX,R15D MOVSXD RAX,R14D LEA R10D,[R15 + -0x1] MOV dword ptr [RSP + 0x18],R8D SUB RAX,RDX MOV RDX,qword ptr [RSP] MOVSXD R10,R10D XOR EDI,EDI ADD RAX,RDX JMP 0x001015f0 LAB_001015d8: ADD EDI,0x1 SUB R10,0x1 TEST R14D,R14D JZ 0x00101b9a TEST ECX,ECX JZ 0x00101b9a LAB_001015f0: MOV EDX,R14D MOVZX R8D,byte ptr [RSI + R10*0x1] MOV ECX,R10D SUB R14D,0x1 CMP byte ptr [RAX + R10*0x1],R8B JZ 0x001015d8 MOV R8D,dword ptr [RSP + 0x18] MOV dword ptr [RSP + 0x18],EDI MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x48],R9D MOV dword ptr [RSP + 0x40],R8D MOV dword ptr [RSP + 0x30],R11D MOV qword ptr [RSP + 0x38],R10 MOV qword ptr [RSP + 0x28],RSI CALL 0x00101250 MOV R10,qword ptr [RSP + 0x38] MOV RSI,qword ptr [RSP + 0x28] MOV EDX,R14D MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x20],EAX LEA ECX,[R10 + 0x1] CALL 0x00101250 MOV ESI,dword ptr [RSP + 0x20] MOV R11D,dword ptr [RSP + 0x30] MOV R9D,dword ptr [RSP + 0x48] MOV R8D,dword ptr [RSP + 0x40] CMP ESI,EAX CMOVGE EAX,ESI ADD dword ptr [RSP + 0x18],EAX MOV RSI,qword ptr [RSP + 0x28] LAB_0010166f: TEST R9D,R9D JZ 0x00101c2c LEA EAX,[R15 + 0x1] MOVSXD RDX,R9D MOVSXD R15,R11D XOR R9D,R9D CDQE MOV R14,RDX SUB RDX,RAX MOV RAX,qword ptr [RSP] ADD RAX,RDX JMP 0x001016b1 LAB_001016a0: ADD R9D,0x1 SUB R15,0x1 TEST R14D,R14D JZ 0x00101715 TEST ECX,ECX JZ 0x00101715 LAB_001016b1: MOV EDX,R14D MOVZX EDI,byte ptr [RSI + R15*0x1] MOV ECX,R15D SUB R14D,0x1 CMP byte ptr [RAX + R15*0x1],DIL JZ 0x001016a0 MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x48],R8D MOV dword ptr [RSP + 0x30],R9D MOV qword ptr [RSP + 0x20],RSI CALL 0x00101250 MOV RDI,qword ptr [RSP] LEA ECX,[R15 + 0x1] MOV EDX,R14D MOV RSI,qword ptr [RSP + 0x20] MOV dword ptr [RSP + 0x28],EAX CALL 0x00101250 MOV R10D,dword ptr [RSP + 0x28] MOV R9D,dword ptr [RSP + 0x30] MOV RSI,qword ptr [RSP + 0x20] MOV R8D,dword ptr [RSP + 0x48] CMP R10D,EAX CMOVL R10D,EAX ADD R9D,R10D LAB_00101715: MOV EAX,dword ptr [RSP + 0x18] CMP EAX,R9D CMOVL EAX,R9D ADD R8D,EAX LAB_00101723: MOV EAX,dword ptr [RSP + 0x10] CMP EAX,R8D CMOVL EAX,R8D ADD dword ptr [RSP + 0x8],EAX JMP 0x0010173d LAB_00101738: MOV dword ptr [RSP + 0x8],R9D LAB_0010173d: TEST EBX,EBX JZ 0x00101bc3 LEA EAX,[RBP + 0x1] MOVSXD RDI,EBX MOVSXD RBP,dword ptr [RSP + 0xc] XOR R8D,R8D CDQE SUB RDI,RAX MOV RAX,qword ptr [RSP] ADD RDI,RAX JMP 0x00101788 LAB_00101768: ADD R8D,0x1 SUB RBP,0x1 TEST DL,DL JNZ 0x00101b37 TEST CL,CL JNZ 0x00101b37 MOVZX R12D,byte ptr [RSI + RBP*0x1] MOV EBX,R14D LAB_00101788: MOV R14D,EBX MOVZX EAX,byte ptr [RDI + RBP*0x1] MOV R11D,EBP SUB R14D,0x1 SETZ DL TEST EBP,EBP SETZ CL CMP AL,R12B JZ 0x00101768 TEST EBP,EBP JZ 0x00101be0 MOVSXD RDX,EBP MOVSXD RDI,EBX LEA R15D,[RBP + -0x1] XOR ECX,ECX SUB RDI,RDX MOV RDX,qword ptr [RSP] MOV dword ptr [RSP + 0x10],R8D MOVSXD R15,R15D MOV R8D,ECX ADD RDI,RDX JMP 0x001017f0 LAB_001017d0: ADD R8D,0x1 SUB R15,0x1 TEST DL,DL JNZ 0x00101b78 TEST CL,CL JNZ 0x00101b78 MOVZX EAX,byte ptr [RDI + R15*0x1] MOV EBX,R9D LAB_001017f0: MOV R9D,EBX SUB R9D,0x1 SETZ DL TEST R15D,R15D SETZ CL CMP byte ptr [RSI + R15*0x1],AL JZ 0x001017d0 MOVSXD RDX,R15D MOV dword ptr [RSP + 0xc],R8D MOV R8D,dword ptr [RSP + 0x10] MOV dword ptr [RSP + 0x18],EDX TEST R15D,R15D JZ 0x00101bf5 MOVSXD RAX,EBX LEA R10D,[RDX + -0x1] XOR EDI,EDI SUB RAX,RDX MOV RDX,qword ptr [RSP] MOVSXD R10,R10D ADD RAX,RDX JMP 0x00101857 LAB_00101840: ADD EDI,0x1 SUB R10,0x1 TEST EBX,EBX JZ 0x00101ba8 TEST ECX,ECX JZ 0x00101ba8 LAB_00101857: MOV EDX,EBX MOVZX R8D,byte ptr [RSI + R10*0x1] MOV ECX,R10D SUB EBX,0x1 CMP byte ptr [RAX + R10*0x1],R8B JZ 0x00101840 MOV R8D,dword ptr [RSP + 0x10] MOV dword ptr [RSP + 0x10],EDI MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x48],R9D MOV dword ptr [RSP + 0x40],R8D MOV dword ptr [RSP + 0x30],R11D MOV qword ptr [RSP + 0x38],R10 MOV qword ptr [RSP + 0x28],RSI CALL 0x00101250 MOV R10,qword ptr [RSP + 0x38] MOV RDI,qword ptr [RSP] MOV EDX,EBX MOV RSI,qword ptr [RSP + 0x28] MOV dword ptr [RSP + 0x20],EAX LEA ECX,[R10 + 0x1] CALL 0x00101250 MOV ESI,dword ptr [RSP + 0x20] MOV R11D,dword ptr [RSP + 0x30] MOV R9D,dword ptr [RSP + 0x48] MOV R8D,dword ptr [RSP + 0x40] CMP ESI,EAX CMOVGE EAX,ESI ADD dword ptr [RSP + 0x10],EAX MOV RSI,qword ptr [RSP + 0x28] LAB_001018d3: TEST R9D,R9D JZ 0x00101c24 LEA EAX,[R15 + 0x1] MOVSXD RDX,R9D MOVSXD RBX,dword ptr [RSP + 0x18] XOR R9D,R9D CDQE MOV R15,RDX SUB RDX,RAX MOV RAX,qword ptr [RSP] ADD RAX,RDX JMP 0x00101911 LAB_00101900: ADD R9D,0x1 SUB RBX,0x1 TEST R15D,R15D JZ 0x0010197c TEST ECX,ECX JZ 0x0010197c LAB_00101911: MOV EDX,R15D MOVZX EDI,byte ptr [RSI + RBX*0x1] MOV ECX,EBX SUB R15D,0x1 CMP byte ptr [RAX + RBX*0x1],DIL JZ 0x00101900 MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x48],R8D MOV dword ptr [RSP + 0x30],R9D MOV dword ptr [RSP + 0x28],R11D MOV qword ptr [RSP + 0x18],RSI CALL 0x00101250 MOV RSI,qword ptr [RSP + 0x18] LEA ECX,[RBX + 0x1] MOV EDX,R15D MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x20],EAX CALL 0x00101250 MOV R10D,dword ptr [RSP + 0x20] MOV R9D,dword ptr [RSP + 0x30] MOV RSI,qword ptr [RSP + 0x18] MOV R11D,dword ptr [RSP + 0x28] CMP R10D,EAX MOV R8D,dword ptr [RSP + 0x48] CMOVL R10D,EAX ADD R9D,R10D LAB_0010197c: MOV EAX,dword ptr [RSP + 0x10] CMP EAX,R9D CMOVL EAX,R9D ADD dword ptr [RSP + 0xc],EAX LAB_0010198b: TEST R14D,R14D JZ 0x00101bcb ADD EBP,0x1 MOV RAX,qword ptr [RSP] MOVSXD RCX,R14D MOVSXD RBX,R11D MOVSXD RBP,EBP XOR R9D,R9D SUB RCX,RBP ADD RCX,RAX JMP 0x001019d0 LAB_001019b0: ADD R9D,0x1 SUB RBX,0x1 TEST AL,AL JNZ 0x00101b29 TEST DL,DL JNZ 0x00101b29 MOVZX R12D,byte ptr [RSI + RBX*0x1] MOV R14D,EBP LAB_001019d0: MOV EBP,R14D MOVSXD R15,EBX SUB EBP,0x1 SETZ AL TEST EBX,EBX SETZ DL CMP byte ptr [RCX + RBX*0x1],R12B JZ 0x001019b0 TEST EBX,EBX JZ 0x00101c34 MOV RDI,qword ptr [RSP] MOVSXD RAX,R14D MOVSXD RDX,R15D LEA R12D,[R15 + -0x1] SUB RAX,RDX MOVSXD R12,R12D XOR R10D,R10D ADD RAX,RDI JMP 0x00101a21 LAB_00101a10: ADD R10D,0x1 SUB R12,0x1 TEST R14D,R14D JZ 0x00101a90 TEST ECX,ECX JZ 0x00101a90 LAB_00101a21: MOV EDX,R14D MOVZX EDI,byte ptr [RSI + R12*0x1] MOV ECX,R12D SUB R14D,0x1 CMP byte ptr [RAX + R12*0x1],DIL JZ 0x00101a10 MOV RDI,qword ptr [RSP] MOV dword ptr [RSP + 0x30],R8D MOV dword ptr [RSP + 0x28],R9D MOV dword ptr [RSP + 0x20],R10D MOV qword ptr [RSP + 0x10],RSI CALL 0x00101250 MOV RSI,qword ptr [RSP + 0x10] MOV RDI,qword ptr [RSP] MOV EDX,R14D LEA ECX,[R12 + 0x1] MOV dword ptr [RSP + 0x18],EAX CALL 0x00101250 MOV R11D,dword ptr [RSP + 0x18] MOV R10D,dword ptr [RSP + 0x20] MOV RSI,qword ptr [RSP + 0x10] MOV R9D,dword ptr [RSP + 0x28] CMP R11D,EAX MOV R8D,dword ptr [RSP + 0x30] CMOVL R11D,EAX ADD R10D,R11D LAB_00101a90: TEST EBP,EBP JZ 0x00101c3c LEA EAX,[RBX + 0x1] MOVSXD RDX,EBP XOR R12D,R12D CDQE SUB RDX,RAX MOV RAX,qword ptr [RSP] ADD RAX,RDX JMP 0x00101ac0 LAB_00101ab0: ADD R12D,0x1 SUB R15,0x1 TEST EBP,EBP JZ 0x00101b1f TEST ECX,ECX JZ 0x00101b1f LAB_00101ac0: MOV EDX,EBP MOVZX EDI,byte ptr [RSI + R15*0x1] MOV ECX,R15D SUB EBP,0x1 CMP byte ptr [RAX + R15*0x1],DIL JZ 0x00101ab0 MOV R14,qword ptr [RSP] MOV dword ptr [RSP + 0x28],R8D MOV dword ptr [RSP + 0x20],R9D MOV RDI,R14 MOV dword ptr [RSP + 0x18],R10D MOV qword ptr [RSP + 0x10],RSI CALL 0x00101250 MOV RSI,qword ptr [RSP + 0x10] LEA ECX,[R15 + 0x1] MOV EDX,EBP MOV RDI,R14 MOV EBX,EAX CALL 0x00101250 MOV R10D,dword ptr [RSP + 0x18] MOV R9D,dword ptr [RSP + 0x20] CMP EBX,EAX MOV R8D,dword ptr [RSP + 0x28] CMOVL EBX,EAX ADD R12D,EBX LAB_00101b1f: CMP R10D,R12D CMOVL R10D,R12D ADD R9D,R10D LAB_00101b29: MOV EAX,dword ptr [RSP + 0xc] CMP EAX,R9D CMOVL EAX,R9D ADD R8D,EAX LAB_00101b37: MOV EAX,dword ptr [RSP + 0x8] CMP EAX,R8D CMOVL EAX,R8D ADD R13D,EAX LAB_00101b45: ADD RSP,0x68 MOV EAX,R13D POP RBX POP RBP POP R12 POP R13 POP R14 POP R15 RET LAB_00101b60: MOV dword ptr [RSP + 0x10],EBX MOV RBP,qword ptr [RSP + 0x28] MOV EBX,dword ptr [RSP + 0x20] JMP 0x00101546 LAB_00101b78: MOV dword ptr [RSP + 0xc],R8D MOV R8D,dword ptr [RSP + 0x10] JMP 0x0010198b LAB_00101b87: XOR R13D,R13D JMP 0x00101b45 LAB_00101b8c: MOV dword ptr [RSP + 0x20],EDI MOV R8D,dword ptr [RSP + 0x28] JMP 0x00101480 LAB_00101b9a: MOV R8D,dword ptr [RSP + 0x18] MOV dword ptr [RSP + 0x18],EDI JMP 0x0010166f LAB_00101ba8: MOV R8D,dword ptr [RSP + 0x10] MOV dword ptr [RSP + 0x10],EDI JMP 0x001018d3 LAB_00101bb6: MOV dword ptr [RSP + 0x8],0x0 JMP 0x0010173d LAB_00101bc3: XOR R8D,R8D JMP 0x00101b37 LAB_00101bcb: XOR R9D,R9D JMP 0x00101b29 LAB_00101bd3: MOV dword ptr [RSP + 0x10],0x0 JMP 0x00101546 LAB_00101be0: MOV dword ptr [RSP + 0xc],0x0 JMP 0x0010198b LAB_00101bed: XOR R8D,R8D JMP 0x00101723 LAB_00101bf5: MOV dword ptr [RSP + 0x10],0x0 JMP 0x001018d3 LAB_00101c02: MOV dword ptr [RSP + 0x18],0x0 JMP 0x0010166f LAB_00101c0f: XOR R9D,R9D JMP 0x00101537 LAB_00101c17: MOV dword ptr [RSP + 0x20],0x0 JMP 0x00101480 LAB_00101c24: XOR R9D,R9D JMP 0x0010197c LAB_00101c2c: XOR R9D,R9D JMP 0x00101715 LAB_00101c34: XOR R10D,R10D JMP 0x00101a90 LAB_00101c3c: XOR R12D,R12D JMP 0x00101b1f
int func0(long param_1,long param_2,int param_3,int param_4) { char cVar1; char cVar2; int iVar3; int iVar4; int iVar5; int iVar6; ulong uVar7; ulong uVar8; int iVar9; long lVar10; int iVar11; int iVar12; int iVar13; uint uVar14; int iVar15; char cVar16; int iVar17; int iVar18; int iVar19; int iVar20; uint uVar21; long lVar22; int local_90; int local_8c; if ((param_3 == 0) || (param_4 == 0)) { return 0; } lVar10 = (long)(param_4 + -1); iVar19 = 0; iVar13 = param_3; while( true ) { cVar2 = *(char *)(((long)param_3 - (long)param_4) + param_1 + lVar10); iVar9 = iVar13 + -1; cVar1 = *(char *)(param_2 + lVar10); iVar15 = (int)lVar10; if (cVar2 != cVar1) break; iVar19 = iVar19 + 1; lVar10 = lVar10 + -1; if (iVar9 == 0) { return iVar19; } iVar13 = iVar9; if (iVar15 == 0) { return iVar19; } } if (iVar15 == 0) { local_90 = 0; } else { local_90 = 0; lVar10 = (long)(iVar15 + -1); iVar12 = iVar13; while( true ) { cVar16 = *(char *)(param_2 + lVar10); iVar11 = iVar12 + -1; iVar6 = (int)lVar10; if (cVar16 != cVar2) break; local_90 = local_90 + 1; lVar10 = lVar10 + -1; if ((iVar11 == 0) || (iVar6 == 0)) goto LAB_0010173d; cVar2 = *(char *)(((long)iVar13 - (long)iVar15) + param_1 + lVar10); iVar12 = iVar11; } if (iVar6 == 0) { iVar13 = 0; } else { iVar13 = 0; lVar10 = (long)(iVar6 + -1); iVar4 = iVar12; while( true ) { iVar17 = iVar4 + -1; iVar5 = (int)lVar10; if (*(char *)(param_2 + lVar10) != cVar2) break; iVar13 = iVar13 + 1; lVar10 = lVar10 + -1; if ((iVar17 == 0) || (iVar5 == 0)) goto LAB_00101546; cVar2 = *(char *)(((long)iVar12 - (long)iVar6) + param_1 + lVar10); iVar4 = iVar17; } if (iVar5 == 0) { iVar12 = 0; } else { iVar12 = 0; lVar10 = (long)(iVar5 + -1); iVar3 = iVar4; while( true ) { iVar18 = (int)lVar10; iVar20 = iVar3 + -1; if (*(char *)(((long)iVar4 - (long)iVar5) + param_1 + lVar10) != *(char *)(param_2 + lVar10)) break; iVar12 = iVar12 + 1; lVar10 = lVar10 + -1; if ((iVar20 == 0) || (iVar3 = iVar20, iVar18 == 0)) goto LAB_00101480; } iVar3 = func0(param_1,param_2,iVar3); iVar4 = func0(param_1,param_2,iVar20,iVar18 + 1); if (iVar4 <= iVar3) { iVar4 = iVar3; } iVar12 = iVar12 + iVar4; } LAB_00101480: if (iVar17 == 0) { iVar4 = 0; } else { lVar10 = (long)iVar5; iVar4 = 0; iVar3 = iVar17; while( true ) { iVar18 = (int)lVar10; iVar20 = iVar3 + -1; if (*(char *)(param_1 + ((long)iVar17 - (long)(iVar5 + 1)) + lVar10) != *(char *)(param_2 + lVar10)) break; iVar4 = iVar4 + 1; lVar10 = lVar10 + -1; if ((iVar20 == 0) || (iVar3 = iVar20, iVar18 == 0)) goto LAB_00101537; } iVar17 = func0(param_1,param_2,iVar3); iVar5 = func0(param_1,param_2,iVar20,iVar18 + 1); if (iVar5 <= iVar17) { iVar5 = iVar17; } iVar4 = iVar4 + iVar5; } LAB_00101537: if (iVar12 < iVar4) { iVar12 = iVar4; } iVar13 = iVar13 + iVar12; } LAB_00101546: if (iVar11 == 0) { iVar12 = 0; } else { lVar10 = (long)iVar6; iVar12 = 0; uVar8 = (long)iVar11; while( true ) { iVar4 = (int)uVar8; iVar5 = (int)lVar10; uVar14 = iVar4 - 1; if (*(char *)(((long)iVar11 - (long)(iVar6 + 1)) + param_1 + lVar10) != cVar16) break; iVar12 = iVar12 + 1; lVar10 = lVar10 + -1; if ((uVar14 == 0) || (iVar5 == 0)) goto LAB_00101723; cVar16 = *(char *)(param_2 + lVar10); uVar8 = (ulong)uVar14; } if (iVar5 == 0) { iVar11 = 0; } else { lVar10 = (long)(iVar5 + -1); iVar11 = 0; while( true ) { uVar7 = uVar8 & 0xffffffff; iVar6 = (int)lVar10; uVar21 = (int)uVar8 - 1; uVar8 = (ulong)uVar21; if (*(char *)(((long)iVar4 - (long)iVar5) + param_1 + lVar10) != *(char *)(param_2 + lVar10)) break; iVar11 = iVar11 + 1; lVar10 = lVar10 + -1; if ((uVar21 == 0) || (iVar6 == 0)) goto LAB_0010166f; } iVar4 = func0(param_1,param_2,uVar7); iVar6 = func0(param_1,param_2,uVar8,iVar6 + 1); if (iVar6 <= iVar4) { iVar6 = iVar4; } iVar11 = iVar11 + iVar6; } LAB_0010166f: if (uVar14 == 0) { iVar6 = 0; } else { uVar8 = (ulong)(int)uVar14; lVar22 = (long)iVar5; iVar6 = 0; lVar10 = uVar8 - (long)(iVar5 + 1); while( true ) { uVar7 = uVar8 & 0xffffffff; iVar4 = (int)lVar22; uVar14 = (int)uVar8 - 1; uVar8 = (ulong)uVar14; if (*(char *)(param_1 + lVar10 + lVar22) != *(char *)(param_2 + lVar22)) break; iVar6 = iVar6 + 1; lVar22 = lVar22 + -1; if ((uVar14 == 0) || (iVar4 == 0)) goto LAB_00101715; } iVar5 = func0(param_1,param_2,uVar7); iVar4 = func0(param_1,param_2,uVar8,iVar4 + 1); if (iVar5 < iVar4) { iVar5 = iVar4; } iVar6 = iVar6 + iVar5; } LAB_00101715: if (iVar11 < iVar6) { iVar11 = iVar6; } iVar12 = iVar12 + iVar11; } LAB_00101723: if (iVar13 < iVar12) { iVar13 = iVar12; } local_90 = local_90 + iVar13; } LAB_0010173d: if (iVar9 == 0) { iVar13 = 0; } else { lVar10 = (long)iVar15; iVar13 = 0; iVar12 = iVar9; while( true ) { cVar2 = *(char *)(((long)iVar9 - (long)(iVar15 + 1)) + param_1 + lVar10); iVar11 = (int)lVar10; iVar6 = iVar12 + -1; if (cVar2 != cVar1) break; iVar13 = iVar13 + 1; lVar10 = lVar10 + -1; if ((iVar6 == 0) || (iVar11 == 0)) goto LAB_00101b37; cVar1 = *(char *)(param_2 + lVar10); iVar12 = iVar6; } if (iVar11 == 0) { local_8c = 0; } else { lVar10 = (long)(iVar11 + -1); local_8c = 0; iVar9 = iVar12; while( true ) { iVar15 = iVar9 + -1; iVar4 = (int)lVar10; if (*(char *)(param_2 + lVar10) != cVar2) break; local_8c = local_8c + 1; lVar10 = lVar10 + -1; if ((iVar15 == 0) || (iVar4 == 0)) goto LAB_0010198b; cVar2 = *(char *)(((long)iVar12 - (long)iVar11) + param_1 + lVar10); iVar9 = iVar15; } if (iVar4 == 0) { iVar12 = 0; } else { iVar12 = 0; lVar10 = (long)(iVar4 + -1); iVar5 = iVar9; while( true ) { iVar3 = (int)lVar10; iVar17 = iVar5 + -1; if (*(char *)(((long)iVar9 - (long)iVar4) + param_1 + lVar10) != *(char *)(param_2 + lVar10)) break; iVar12 = iVar12 + 1; lVar10 = lVar10 + -1; if ((iVar17 == 0) || (iVar5 = iVar17, iVar3 == 0)) goto LAB_001018d3; } iVar5 = func0(param_1,param_2,iVar5); iVar9 = func0(param_1,param_2,iVar17,iVar3 + 1); if (iVar9 <= iVar5) { iVar9 = iVar5; } iVar12 = iVar12 + iVar9; } LAB_001018d3: if (iVar15 == 0) { iVar9 = 0; } else { uVar8 = (ulong)iVar15; lVar22 = (long)iVar4; iVar9 = 0; lVar10 = uVar8 - (long)(iVar4 + 1); while( true ) { uVar7 = uVar8 & 0xffffffff; iVar15 = (int)lVar22; uVar14 = (int)uVar8 - 1; uVar8 = (ulong)uVar14; if (*(char *)(param_1 + lVar10 + lVar22) != *(char *)(param_2 + lVar22)) break; iVar9 = iVar9 + 1; lVar22 = lVar22 + -1; if ((uVar14 == 0) || (iVar15 == 0)) goto LAB_0010197c; } iVar4 = func0(param_1,param_2,uVar7); iVar15 = func0(param_1,param_2,uVar8,iVar15 + 1); if (iVar4 < iVar15) { iVar4 = iVar15; } iVar9 = iVar9 + iVar4; } LAB_0010197c: if (iVar12 < iVar9) { iVar12 = iVar9; } local_8c = local_8c + iVar12; } LAB_0010198b: if (iVar6 == 0) { iVar9 = 0; } else { lVar10 = (long)iVar11; iVar9 = 0; iVar15 = iVar6; while( true ) { iVar12 = (int)lVar10; lVar22 = (long)iVar12; iVar4 = iVar15 + -1; if (*(char *)(((long)iVar6 - (long)(iVar11 + 1)) + param_1 + lVar10) != cVar1) break; iVar9 = iVar9 + 1; lVar10 = lVar10 + -1; if ((iVar4 == 0) || (iVar12 == 0)) goto LAB_00101b29; cVar1 = *(char *)(param_2 + lVar10); iVar15 = iVar4; } if (iVar12 == 0) { iVar11 = 0; } else { lVar10 = (long)(iVar12 + -1); iVar11 = 0; iVar6 = iVar15; while( true ) { iVar5 = (int)lVar10; iVar17 = iVar6 + -1; if (*(char *)(((long)iVar15 - (long)iVar12) + param_1 + lVar10) != *(char *)(param_2 + lVar10)) break; iVar11 = iVar11 + 1; lVar10 = lVar10 + -1; if ((iVar17 == 0) || (iVar6 = iVar17, iVar5 == 0)) goto LAB_00101a90; } iVar15 = func0(param_1,param_2,iVar6); iVar6 = func0(param_1,param_2,iVar17,iVar5 + 1); if (iVar15 < iVar6) { iVar15 = iVar6; } iVar11 = iVar11 + iVar15; } LAB_00101a90: if (iVar4 == 0) { iVar15 = 0; } else { iVar15 = 0; iVar6 = iVar4; while( true ) { iVar17 = (int)lVar22; iVar5 = iVar6 + -1; if (*(char *)(param_1 + ((long)iVar4 - (long)(iVar12 + 1)) + lVar22) != *(char *)(param_2 + lVar22)) break; iVar15 = iVar15 + 1; lVar22 = lVar22 + -1; if ((iVar5 == 0) || (iVar6 = iVar5, iVar17 == 0)) goto LAB_00101b1f; } iVar12 = func0(param_1,param_2,iVar6); iVar6 = func0(param_1,param_2,iVar5,iVar17 + 1); if (iVar12 < iVar6) { iVar12 = iVar6; } iVar15 = iVar15 + iVar12; } LAB_00101b1f: if (iVar11 < iVar15) { iVar11 = iVar15; } iVar9 = iVar9 + iVar11; } LAB_00101b29: if (local_8c < iVar9) { local_8c = iVar9; } iVar13 = iVar13 + local_8c; } LAB_00101b37: if (local_90 < iVar13) { local_90 = iVar13; } return iVar19 + local_90; }
4,644
func0
#include <assert.h> #include <stdbool.h>
bool func0(int n) { for (int i = 2; i <= n; i++) { if (i * i < (n + 1)) { for (int j = 2; j <= n; j++) { if ((i * i * j * j) == n) { return true; } } } } return false; }
int main() { assert(func0(25) == false); assert(func0(30) == false); assert(func0(16) == true); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %edi,-0x14(%rbp) movl $0x2,-0x8(%rbp) jmp 119b <func0+0x52> mov -0x8(%rbp),%eax imul %eax,%eax cmp %eax,-0x14(%rbp) jl 1197 <func0+0x4e> movl $0x2,-0x4(%rbp) jmp 118f <func0+0x46> mov -0x8(%rbp),%eax imul %eax,%eax imul -0x4(%rbp),%eax imul -0x4(%rbp),%eax cmp %eax,-0x14(%rbp) jne 118b <func0+0x42> mov $0x1,%eax jmp 11a8 <func0+0x5f> addl $0x1,-0x4(%rbp) mov -0x4(%rbp),%eax cmp -0x14(%rbp),%eax jle 1171 <func0+0x28> addl $0x1,-0x8(%rbp) mov -0x8(%rbp),%eax cmp -0x14(%rbp),%eax jle 115d <func0+0x14> mov $0x0,%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_14], edi mov [rbp+var_8], 2 jmp short loc_119B loc_115D: mov eax, [rbp+var_8] imul eax, eax cmp [rbp+var_14], eax jl short loc_1197 mov [rbp+var_4], 2 jmp short loc_118F loc_1171: mov eax, [rbp+var_8] imul eax, eax imul eax, [rbp+var_4] imul eax, [rbp+var_4] cmp [rbp+var_14], eax jnz short loc_118B mov eax, 1 jmp short loc_11A8 loc_118B: add [rbp+var_4], 1 loc_118F: mov eax, [rbp+var_4] cmp eax, [rbp+var_14] jle short loc_1171 loc_1197: add [rbp+var_8], 1 loc_119B: mov eax, [rbp+var_8] cmp eax, [rbp+var_14] jle short loc_115D mov eax, 0 loc_11A8: pop rbp retn
long long func0(int a1) { int i; // [rsp+Ch] [rbp-8h] int j; // [rsp+10h] [rbp-4h] for ( i = 2; i <= a1; ++i ) { if ( a1 >= i * i ) { for ( j = 2; j <= a1; ++j ) { if ( a1 == j * j * i * i ) return 1LL; } } } return 0LL; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV dword ptr [RBP + -0x14],EDI MOV dword ptr [RBP + -0x8],0x2 JMP 0x0010119b LAB_0010115d: MOV EAX,dword ptr [RBP + -0x8] IMUL EAX,EAX CMP dword ptr [RBP + -0x14],EAX JL 0x00101197 MOV dword ptr [RBP + -0x4],0x2 JMP 0x0010118f LAB_00101171: MOV EAX,dword ptr [RBP + -0x8] IMUL EAX,EAX IMUL EAX,dword ptr [RBP + -0x4] IMUL EAX,dword ptr [RBP + -0x4] CMP dword ptr [RBP + -0x14],EAX JNZ 0x0010118b MOV EAX,0x1 JMP 0x001011a8 LAB_0010118b: ADD dword ptr [RBP + -0x4],0x1 LAB_0010118f: MOV EAX,dword ptr [RBP + -0x4] CMP EAX,dword ptr [RBP + -0x14] JLE 0x00101171 LAB_00101197: ADD dword ptr [RBP + -0x8],0x1 LAB_0010119b: MOV EAX,dword ptr [RBP + -0x8] CMP EAX,dword ptr [RBP + -0x14] JLE 0x0010115d MOV EAX,0x0 LAB_001011a8: POP RBP RET
int8 func0(int param_1) { int local_10; int local_c; local_10 = 2; do { if (param_1 < local_10) { return 0; } if (local_10 * local_10 <= param_1) { for (local_c = 2; local_c <= param_1; local_c = local_c + 1) { if (param_1 == local_10 * local_10 * local_c * local_c) { return 1; } } } local_10 = local_10 + 1; } while( true ); }
4,645
func0
#include <assert.h> #include <stdbool.h>
bool func0(int n) { for (int i = 2; i <= n; i++) { if (i * i < (n + 1)) { for (int j = 2; j <= n; j++) { if ((i * i * j * j) == n) { return true; } } } } return false; }
int main() { assert(func0(25) == false); assert(func0(30) == false); assert(func0(16) == true); return 0; }
O1
c
func0: endbr64 cmp $0x1,%edi jle 119e <func0+0x55> mov $0x2,%ecx jmp 1160 <func0+0x17> add $0x1,%ecx cmp %ecx,%edi jl 1198 <func0+0x4f> mov %ecx,%eax imul %ecx,%eax cmp %edi,%eax jg 1159 <func0+0x10> lea 0x0(,%rax,4),%edx cmp %edx,%edi je 11a4 <func0+0x5b> mov %eax,%r8d lea (%rax,%rax,2),%edx mov $0x2,%eax add $0x1,%eax cmp %eax,%edi jl 1159 <func0+0x10> mov %edx,%esi imul %eax,%esi add %r8d,%edx cmp %edi,%esi jne 117f <func0+0x36> mov $0x1,%eax retq mov $0x0,%eax retq mov $0x0,%eax retq mov $0x1,%eax retq
func0: endbr64 cmp edi, 1 jle short loc_119D mov esi, 2 jmp short loc_1160 loc_1159: add esi, 1 cmp edi, esi jl short loc_1197 loc_1160: mov ecx, esi imul ecx, esi cmp ecx, edi jg short loc_1159 lea eax, ds:0[rcx*4] cmp edi, eax jz short loc_11A3 lea edx, [rcx+rcx*2] mov eax, 2 loc_117C: add eax, 1 cmp edi, eax jl short loc_1159 mov r8d, edx imul r8d, eax add edx, ecx cmp r8d, edi jnz short loc_117C mov eax, 1 retn loc_1197: mov eax, 0 retn loc_119D: mov eax, 0 retn loc_11A3: mov eax, 1 retn
long long func0(int a1) { int v1; // esi int v2; // ecx int v3; // edx int v4; // eax int v5; // r8d if ( a1 <= 1 ) return 0LL; v1 = 2; while ( 1 ) { v2 = v1 * v1; if ( v1 * v1 <= a1 ) break; LABEL_3: if ( a1 < ++v1 ) return 0LL; } if ( a1 != 4 * v2 ) { v3 = 3 * v2; v4 = 2; while ( a1 >= ++v4 ) { v5 = v4 * v3; v3 += v2; if ( v5 == a1 ) return 1LL; } goto LABEL_3; } return 1LL; }
func0: ENDBR64 CMP EDI,0x1 JLE 0x0010119d MOV ESI,0x2 JMP 0x00101160 LAB_00101159: ADD ESI,0x1 CMP EDI,ESI JL 0x00101197 LAB_00101160: MOV ECX,ESI IMUL ECX,ESI CMP ECX,EDI JG 0x00101159 LEA EAX,[RCX*0x4] CMP EDI,EAX JZ 0x001011a3 LEA EDX,[RCX + RCX*0x2] MOV EAX,0x2 LAB_0010117c: ADD EAX,0x1 CMP EDI,EAX JL 0x00101159 MOV R8D,EDX IMUL R8D,EAX ADD EDX,ECX CMP R8D,EDI JNZ 0x0010117c MOV EAX,0x1 RET LAB_00101197: MOV EAX,0x0 RET LAB_0010119d: MOV EAX,0x0 RET LAB_001011a3: MOV EAX,0x1 RET
int8 func0(int param_1) { int iVar1; int iVar2; int iVar3; int iVar4; int iVar5; if (param_1 < 2) { return 0; } iVar4 = 2; do { iVar2 = iVar4 * iVar4; if (iVar2 <= param_1) { if (param_1 == iVar2 * 4) { return 1; } iVar3 = iVar2 * 3; iVar1 = 2; while (iVar1 = iVar1 + 1, iVar1 <= param_1) { iVar5 = iVar3 * iVar1; iVar3 = iVar3 + iVar2; if (iVar5 == param_1) { return 1; } } } iVar4 = iVar4 + 1; if (param_1 < iVar4) { return 0; } } while( true ); }
4,646
func0
#include <assert.h> #include <stdbool.h>
bool func0(int n) { for (int i = 2; i <= n; i++) { if (i * i < (n + 1)) { for (int j = 2; j <= n; j++) { if ((i * i * j * j) == n) { return true; } } } } return false; }
int main() { assert(func0(25) == false); assert(func0(30) == false); assert(func0(16) == true); return 0; }
O2
c
func0: endbr64 cmp $0x1,%edi jle 1278 <func0+0x58> mov $0x2,%ecx jmp 1237 <func0+0x17> add $0x1,%ecx cmp %ecx,%edi jl 1278 <func0+0x58> mov %ecx,%esi imul %ecx,%esi cmp %edi,%esi jg 1230 <func0+0x10> lea 0x0(,%rsi,4),%eax cmp %eax,%edi je 126d <func0+0x4d> lea (%rsi,%rsi,2),%edx mov $0x3,%eax jmp 1261 <func0+0x41> nopl (%rax) add $0x1,%eax add %esi,%edx cmp %eax,%edi jl 1230 <func0+0x10> mov %edx,%r8d imul %eax,%r8d cmp %edi,%r8d jne 1258 <func0+0x38> mov $0x1,%eax retq nopl 0x0(%rax,%rax,1) xor %eax,%eax retq nopl 0x0(%rax,%rax,1)
func0: endbr64 cmp edi, 1 jle short loc_1248 mov ecx, 2 jmp short loc_1207 loc_1200: add ecx, 1 cmp edi, ecx jl short loc_1248 loc_1207: mov esi, ecx imul esi, ecx cmp esi, edi jg short loc_1200 lea eax, ds:0[rsi*4] cmp edi, eax jz short loc_123D lea edx, [rsi+rsi*2] mov eax, 3 jmp short loc_1231 loc_1228: add eax, 1 add edx, esi cmp edi, eax jl short loc_1200 loc_1231: mov r8d, edx imul r8d, eax cmp r8d, edi jnz short loc_1228 loc_123D: mov eax, 1 retn loc_1248: xor eax, eax retn
long long func0(int a1) { int v1; // ecx int v2; // esi int v3; // edx int v4; // eax if ( a1 <= 1 ) return 0LL; v1 = 2; while ( 1 ) { v2 = v1 * v1; if ( v1 * v1 <= a1 ) break; LABEL_3: if ( a1 < ++v1 ) return 0LL; } if ( a1 != 4 * v2 ) { v3 = 3 * v2; v4 = 3; while ( v4 * v3 != a1 ) { ++v4; v3 += v2; if ( a1 < v4 ) goto LABEL_3; } } return 1LL; }
func0: ENDBR64 CMP EDI,0x1 JLE 0x00101248 MOV ECX,0x2 JMP 0x00101207 LAB_00101200: ADD ECX,0x1 CMP EDI,ECX JL 0x00101248 LAB_00101207: MOV ESI,ECX IMUL ESI,ECX CMP ESI,EDI JG 0x00101200 LEA EAX,[RSI*0x4] CMP EDI,EAX JZ 0x0010123d LEA EDX,[RSI + RSI*0x2] MOV EAX,0x3 JMP 0x00101231 LAB_00101228: ADD EAX,0x1 ADD EDX,ESI CMP EDI,EAX JL 0x00101200 LAB_00101231: MOV R8D,EDX IMUL R8D,EAX CMP R8D,EDI JNZ 0x00101228 LAB_0010123d: MOV EAX,0x1 RET LAB_00101248: XOR EAX,EAX RET
int8 func0(int param_1) { int iVar1; int iVar2; int iVar3; int iVar4; if (1 < param_1) { iVar2 = 2; do { iVar4 = iVar2 * iVar2; if (iVar4 <= param_1) { if (param_1 == iVar4 * 4) { return 1; } iVar3 = iVar4 * 3; iVar1 = 3; do { if (iVar3 * iVar1 == param_1) { return 1; } iVar1 = iVar1 + 1; iVar3 = iVar3 + iVar4; } while (iVar1 <= param_1); } iVar2 = iVar2 + 1; } while (iVar2 <= param_1); } return 0; }
4,647
func0
#include <assert.h> #include <stdbool.h>
bool func0(int n) { for (int i = 2; i <= n; i++) { if (i * i < (n + 1)) { for (int j = 2; j <= n; j++) { if ((i * i * j * j) == n) { return true; } } } } return false; }
int main() { assert(func0(25) == false); assert(func0(30) == false); assert(func0(16) == true); return 0; }
O3
c
func0: endbr64 cmp $0x1,%edi jle 1278 <func0+0x58> mov $0x2,%ecx jmp 1237 <func0+0x17> add $0x1,%ecx cmp %ecx,%edi jl 1278 <func0+0x58> mov %ecx,%esi imul %ecx,%esi cmp %edi,%esi jg 1230 <func0+0x10> lea 0x0(,%rsi,4),%eax cmp %eax,%edi je 126d <func0+0x4d> lea (%rsi,%rsi,2),%edx mov $0x3,%eax jmp 1261 <func0+0x41> nopl (%rax) add $0x1,%eax add %esi,%edx cmp %eax,%edi jl 1230 <func0+0x10> mov %edx,%r8d imul %eax,%r8d cmp %edi,%r8d jne 1258 <func0+0x38> mov $0x1,%eax retq nopl 0x0(%rax,%rax,1) xor %eax,%eax retq nopl 0x0(%rax,%rax,1)
func0: endbr64 cmp edi, 1 jle short loc_1198 mov esi, 2 jmp short loc_1157 loc_1150: add esi, 1 cmp edi, esi jl short loc_1198 loc_1157: mov ecx, esi imul ecx, esi cmp ecx, edi jg short loc_1150 lea eax, ds:0[rcx*4] cmp edi, eax jz short loc_118D lea edx, [rcx+rcx*2] mov eax, 2 nop dword ptr [rax+rax+00h] loc_1178: add eax, 1 cmp edi, eax jl short loc_1150 mov r8d, edx add edx, ecx imul r8d, eax cmp r8d, edi jnz short loc_1178 loc_118D: mov eax, 1 retn loc_1198: xor eax, eax retn
long long func0(int a1) { int i; // esi int v2; // ecx int v3; // edx int v4; // eax int v5; // r8d if ( a1 > 1 ) { for ( i = 2; a1 >= i; ++i ) { v2 = i * i; if ( i * i <= a1 ) { if ( a1 == 4 * v2 ) return 1LL; v3 = 3 * v2; v4 = 2; while ( a1 >= ++v4 ) { v5 = v3; v3 += v2; if ( v4 * v5 == a1 ) return 1LL; } } } } return 0LL; }
func0: ENDBR64 CMP EDI,0x1 JLE 0x00101198 MOV ESI,0x2 JMP 0x00101157 LAB_00101150: ADD ESI,0x1 CMP EDI,ESI JL 0x00101198 LAB_00101157: MOV ECX,ESI IMUL ECX,ESI CMP ECX,EDI JG 0x00101150 LEA EAX,[RCX*0x4] CMP EDI,EAX JZ 0x0010118d LEA EDX,[RCX + RCX*0x2] MOV EAX,0x2 NOP dword ptr [RAX + RAX*0x1] LAB_00101178: ADD EAX,0x1 CMP EDI,EAX JL 0x00101150 MOV R8D,EDX ADD EDX,ECX IMUL R8D,EAX CMP R8D,EDI JNZ 0x00101178 LAB_0010118d: MOV EAX,0x1 RET LAB_00101198: XOR EAX,EAX RET
int8 func0(int param_1) { int iVar1; int iVar2; int iVar3; int iVar4; int iVar5; if (1 < param_1) { iVar4 = 2; do { iVar3 = iVar4 * iVar4; if (iVar3 <= param_1) { if (param_1 == iVar3 * 4) { return 1; } iVar2 = 2; iVar1 = iVar3 * 3; while (iVar2 = iVar2 + 1, iVar2 <= param_1) { iVar5 = iVar1 * iVar2; iVar1 = iVar1 + iVar3; if (iVar5 == param_1) { return 1; } } } iVar4 = iVar4 + 1; } while (iVar4 <= param_1); } return 0; }
4,648
func0
#include <stdio.h> #include <assert.h>
int func0(int arr[], int n) { int ptr = 0; for (int i = 0; i < n; i++) { if (arr[i] == 1) { ptr = 1; break; } } if (ptr == 0) { return 1; } for (int i = 0; i < n; i++) { if (arr[i] <= 0 || arr[i] > n) { arr[i] = 1; } } for (int i = 0; i < n; i++) { arr[(arr[i] - 1) % n] += n; } for (int i = 0; i < n; i++) { if (arr[i] <= n) { return i + 1; } } return n + 1; }
int main() { int arr1[] = {1, 2, 3, -1, 5}; int arr2[] = {0, -1, -2, 1, 5, 8}; int arr3[] = {0, 1, 2, 5, -8}; assert(func0(arr1, 5) == 4); assert(func0(arr2, 6) == 2); assert(func0(arr3, 5) == 3); printf("All test cases passed\n"); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %rdi,-0x28(%rbp) mov %esi,-0x2c(%rbp) movl $0x0,-0x14(%rbp) movl $0x0,-0x10(%rbp) jmp 11d0 <func0+0x47> mov -0x10(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax mov (%rax),%eax cmp $0x1,%eax jne 11cc <func0+0x43> movl $0x1,-0x14(%rbp) jmp 11d8 <func0+0x4f> addl $0x1,-0x10(%rbp) mov -0x10(%rbp),%eax cmp -0x2c(%rbp),%eax jl 11a8 <func0+0x1f> cmpl $0x0,-0x14(%rbp) jne 11e8 <func0+0x5f> mov $0x1,%eax jmpq 12ea <func0+0x161> movl $0x0,-0xc(%rbp) jmp 1244 <func0+0xbb> mov -0xc(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax mov (%rax),%eax test %eax,%eax jle 1226 <func0+0x9d> mov -0xc(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax mov (%rax),%eax cmp %eax,-0x2c(%rbp) jge 1240 <func0+0xb7> mov -0xc(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax movl $0x1,(%rax) addl $0x1,-0xc(%rbp) mov -0xc(%rbp),%eax cmp -0x2c(%rbp),%eax jl 11f1 <func0+0x68> movl $0x0,-0x8(%rbp) jmp 12a4 <func0+0x11b> mov -0x8(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax mov (%rax),%eax sub $0x1,%eax cltd idivl -0x2c(%rbp) mov %edx,%eax movslq %eax,%rdx lea 0x0(,%rdx,4),%rcx mov -0x28(%rbp),%rdx add %rcx,%rdx mov (%rdx),%ecx cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax mov -0x2c(%rbp),%edx add %ecx,%edx mov %edx,(%rax) addl $0x1,-0x8(%rbp) mov -0x8(%rbp),%eax cmp -0x2c(%rbp),%eax jl 1255 <func0+0xcc> movl $0x0,-0x4(%rbp) jmp 12dc <func0+0x153> mov -0x4(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax mov (%rax),%eax cmp %eax,-0x2c(%rbp) jl 12d8 <func0+0x14f> mov -0x4(%rbp),%eax add $0x1,%eax jmp 12ea <func0+0x161> addl $0x1,-0x4(%rbp) mov -0x4(%rbp),%eax cmp -0x2c(%rbp),%eax jl 12b5 <func0+0x12c> mov -0x2c(%rbp),%eax add $0x1,%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_28], rdi mov [rbp+var_2C], esi mov [rbp+var_14], 0 mov [rbp+var_10], 0 jmp short loc_11D0 loc_11A8: mov eax, [rbp+var_10] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov eax, [rax] cmp eax, 1 jnz short loc_11CC mov [rbp+var_14], 1 jmp short loc_11D8 loc_11CC: add [rbp+var_10], 1 loc_11D0: mov eax, [rbp+var_10] cmp eax, [rbp+var_2C] jl short loc_11A8 loc_11D8: cmp [rbp+var_14], 0 jnz short loc_11E8 mov eax, 1 jmp loc_12EA loc_11E8: mov [rbp+var_C], 0 jmp short loc_1244 loc_11F1: mov eax, [rbp+var_C] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov eax, [rax] test eax, eax jle short loc_1226 mov eax, [rbp+var_C] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov eax, [rax] cmp [rbp+var_2C], eax jge short loc_1240 loc_1226: mov eax, [rbp+var_C] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov dword ptr [rax], 1 loc_1240: add [rbp+var_C], 1 loc_1244: mov eax, [rbp+var_C] cmp eax, [rbp+var_2C] jl short loc_11F1 mov [rbp+var_8], 0 jmp short loc_12A4 loc_1255: mov eax, [rbp+var_8] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov eax, [rax] sub eax, 1 cdq idiv [rbp+var_2C] mov eax, edx movsxd rdx, eax lea rcx, ds:0[rdx*4] mov rdx, [rbp+var_28] add rdx, rcx mov ecx, [rdx] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov edx, [rbp+var_2C] add edx, ecx mov [rax], edx add [rbp+var_8], 1 loc_12A4: mov eax, [rbp+var_8] cmp eax, [rbp+var_2C] jl short loc_1255 mov [rbp+var_4], 0 jmp short loc_12DC loc_12B5: mov eax, [rbp+var_4] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov eax, [rax] cmp [rbp+var_2C], eax jl short loc_12D8 mov eax, [rbp+var_4] add eax, 1 jmp short loc_12EA loc_12D8: add [rbp+var_4], 1 loc_12DC: mov eax, [rbp+var_4] cmp eax, [rbp+var_2C] jl short loc_12B5 mov eax, [rbp+var_2C] add eax, 1 loc_12EA: pop rbp retn
long long func0(long long a1, int a2) { int v3; // eax int v4; // [rsp+18h] [rbp-14h] int i; // [rsp+1Ch] [rbp-10h] int j; // [rsp+20h] [rbp-Ch] int k; // [rsp+24h] [rbp-8h] int m; // [rsp+28h] [rbp-4h] v4 = 0; for ( i = 0; i < a2; ++i ) { if ( *(_DWORD *)(4LL * i + a1) == 1 ) { v4 = 1; break; } } if ( !v4 ) return 1LL; for ( j = 0; j < a2; ++j ) { if ( *(int *)(4LL * j + a1) <= 0 || a2 < *(_DWORD *)(4LL * j + a1) ) *(_DWORD *)(4LL * j + a1) = 1; } for ( k = 0; k < a2; ++k ) { v3 = (*(_DWORD *)(4LL * k + a1) - 1) % a2; *(_DWORD *)(4LL * v3 + a1) += a2; } for ( m = 0; m < a2; ++m ) { if ( a2 >= *(_DWORD *)(4LL * m + a1) ) return (unsigned int)(m + 1); } return (unsigned int)(a2 + 1); }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV qword ptr [RBP + -0x28],RDI MOV dword ptr [RBP + -0x2c],ESI MOV dword ptr [RBP + -0x14],0x0 MOV dword ptr [RBP + -0x10],0x0 JMP 0x001011d0 LAB_001011a8: MOV EAX,dword ptr [RBP + -0x10] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV EAX,dword ptr [RAX] CMP EAX,0x1 JNZ 0x001011cc MOV dword ptr [RBP + -0x14],0x1 JMP 0x001011d8 LAB_001011cc: ADD dword ptr [RBP + -0x10],0x1 LAB_001011d0: MOV EAX,dword ptr [RBP + -0x10] CMP EAX,dword ptr [RBP + -0x2c] JL 0x001011a8 LAB_001011d8: CMP dword ptr [RBP + -0x14],0x0 JNZ 0x001011e8 MOV EAX,0x1 JMP 0x001012ea LAB_001011e8: MOV dword ptr [RBP + -0xc],0x0 JMP 0x00101244 LAB_001011f1: MOV EAX,dword ptr [RBP + -0xc] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV EAX,dword ptr [RAX] TEST EAX,EAX JLE 0x00101226 MOV EAX,dword ptr [RBP + -0xc] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV EAX,dword ptr [RAX] CMP dword ptr [RBP + -0x2c],EAX JGE 0x00101240 LAB_00101226: MOV EAX,dword ptr [RBP + -0xc] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV dword ptr [RAX],0x1 LAB_00101240: ADD dword ptr [RBP + -0xc],0x1 LAB_00101244: MOV EAX,dword ptr [RBP + -0xc] CMP EAX,dword ptr [RBP + -0x2c] JL 0x001011f1 MOV dword ptr [RBP + -0x8],0x0 JMP 0x001012a4 LAB_00101255: MOV EAX,dword ptr [RBP + -0x8] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV EAX,dword ptr [RAX] SUB EAX,0x1 CDQ IDIV dword ptr [RBP + -0x2c] MOV EAX,EDX MOVSXD RDX,EAX LEA RCX,[RDX*0x4] MOV RDX,qword ptr [RBP + -0x28] ADD RDX,RCX MOV ECX,dword ptr [RDX] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV EDX,dword ptr [RBP + -0x2c] ADD EDX,ECX MOV dword ptr [RAX],EDX ADD dword ptr [RBP + -0x8],0x1 LAB_001012a4: MOV EAX,dword ptr [RBP + -0x8] CMP EAX,dword ptr [RBP + -0x2c] JL 0x00101255 MOV dword ptr [RBP + -0x4],0x0 JMP 0x001012dc LAB_001012b5: MOV EAX,dword ptr [RBP + -0x4] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV EAX,dword ptr [RAX] CMP dword ptr [RBP + -0x2c],EAX JL 0x001012d8 MOV EAX,dword ptr [RBP + -0x4] ADD EAX,0x1 JMP 0x001012ea LAB_001012d8: ADD dword ptr [RBP + -0x4],0x1 LAB_001012dc: MOV EAX,dword ptr [RBP + -0x4] CMP EAX,dword ptr [RBP + -0x2c] JL 0x001012b5 MOV EAX,dword ptr [RBP + -0x2c] ADD EAX,0x1 LAB_001012ea: POP RBP RET
int func0(long param_1,int param_2) { bool bVar1; int iVar2; int local_18; int local_14; int local_10; int local_c; bVar1 = false; local_18 = 0; do { if (param_2 <= local_18) { LAB_001011d8: if (bVar1) { for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) { if ((*(int *)(param_1 + (long)local_14 * 4) < 1) || (param_2 < *(int *)(param_1 + (long)local_14 * 4))) { *(int4 *)(param_1 + (long)local_14 * 4) = 1; } } for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) { iVar2 = (*(int *)(param_1 + (long)local_10 * 4) + -1) % param_2; *(int *)(param_1 + (long)iVar2 * 4) = param_2 + *(int *)(param_1 + (long)iVar2 * 4); } for (local_c = 0; local_c < param_2; local_c = local_c + 1) { if (*(int *)(param_1 + (long)local_c * 4) <= param_2) { return local_c + 1; } } param_2 = param_2 + 1; } else { param_2 = 1; } return param_2; } if (*(int *)(param_1 + (long)local_18 * 4) == 1) { bVar1 = true; goto LAB_001011d8; } local_18 = local_18 + 1; } while( true ); }
4,649
func0
#include <stdio.h> #include <assert.h>
int func0(int arr[], int n) { int ptr = 0; for (int i = 0; i < n; i++) { if (arr[i] == 1) { ptr = 1; break; } } if (ptr == 0) { return 1; } for (int i = 0; i < n; i++) { if (arr[i] <= 0 || arr[i] > n) { arr[i] = 1; } } for (int i = 0; i < n; i++) { arr[(arr[i] - 1) % n] += n; } for (int i = 0; i < n; i++) { if (arr[i] <= n) { return i + 1; } } return n + 1; }
int main() { int arr1[] = {1, 2, 3, -1, 5}; int arr2[] = {0, -1, -2, 1, 5, 8}; int arr3[] = {0, 1, 2, 5, -8}; assert(func0(arr1, 5) == 4); assert(func0(arr2, 6) == 2); assert(func0(arr3, 5) == 3); printf("All test cases passed\n"); return 0; }
O1
c
func0: endbr64 test %esi,%esi jle 1215 <func0+0x8c> mov %rdi,%rcx lea -0x1(%rsi),%r9d lea 0x4(%rdi,%r9,4),%r8 mov %rdi,%rax cmpl $0x1,(%rax) je 11b8 <func0+0x2f> add $0x4,%rax cmp %r8,%rax jne 11a4 <func0+0x1b> mov $0x1,%eax retq mov %rdi,%rax jmp 11cd <func0+0x44> movl $0x1,(%r10) add $0x4,%rax cmp %r8,%rax je 11dc <func0+0x53> mov %rax,%r10 mov (%rax),%edx cmp %esi,%edx jg 11bd <func0+0x34> test %edx,%edx jle 11bd <func0+0x34> jmp 11c4 <func0+0x3b> mov (%rcx),%eax sub $0x1,%eax cltd idiv %esi movslq %edx,%rdx add %esi,(%rdi,%rdx,4) add $0x4,%rcx cmp %r8,%rcx jne 11dc <func0+0x53> mov $0x0,%edx jmp 11fd <func0+0x74> mov %rax,%rdx mov %edx,%eax cmp %esi,(%rdi,%rdx,4) jle 1211 <func0+0x88> lea 0x1(%rdx),%rax cmp %r9,%rdx jne 11fa <func0+0x71> lea 0x1(%rsi),%eax retq add $0x1,%eax retq mov $0x1,%eax retq
func0: endbr64 mov ecx, esi test esi, esi jle short loc_120D mov rsi, rdi lea eax, [rcx-1] lea r8, [rdi+rax*4+4] mov rax, rdi loc_11A1: cmp dword ptr [rax], 1 jz short loc_11B5 add rax, 4 cmp rax, r8 jnz short loc_11A1 mov eax, 1 retn loc_11B5: mov rax, rdi jmp short loc_11CA loc_11BA: mov dword ptr [r9], 1 loc_11C1: add rax, 4 cmp rax, r8 jz short loc_11D9 loc_11CA: mov r9, rax mov edx, [rax] cmp edx, ecx jg short loc_11BA test edx, edx jle short loc_11BA jmp short loc_11C1 loc_11D9: mov eax, [rsi] sub eax, 1 cdq idiv ecx movsxd rdx, edx add [rdi+rdx*4], ecx add rsi, 4 cmp rsi, r8 jnz short loc_11D9 mov esi, ecx mov eax, 0 loc_11F7: cmp [rdi+rax*4], ecx jle short loc_1209 add rax, 1 cmp rsi, rax jnz short loc_11F7 lea eax, [rcx+1] retn loc_1209: lea eax, [rax+1] retn loc_120D: mov eax, 1 retn
long long func0(_DWORD *a1, int a2) { _DWORD *v3; // rsi long long v4; // r8 _DWORD *v5; // rax int *v7; // rax long long v8; // rax if ( a2 <= 0 ) return 1LL; v3 = a1; v4 = (long long)&a1[a2 - 1 + 1]; v5 = a1; while ( *v5 != 1 ) { if ( ++v5 == (_DWORD *)v4 ) return 1LL; } v7 = a1; do { if ( *v7 > a2 || *v7 <= 0 ) *v7 = 1; ++v7; } while ( v7 != (int *)v4 ); do a1[(*v3++ - 1) % a2] += a2; while ( v3 != (_DWORD *)v4 ); v8 = 0LL; while ( a1[v8] > a2 ) { if ( a2 == ++v8 ) return (unsigned int)(a2 + 1); } return (unsigned int)(v8 + 1); }
func0: ENDBR64 MOV ECX,ESI TEST ESI,ESI JLE 0x0010120d MOV RSI,RDI LEA EAX,[RCX + -0x1] LEA R8,[RDI + RAX*0x4 + 0x4] MOV RAX,RDI LAB_001011a1: CMP dword ptr [RAX],0x1 JZ 0x001011b5 ADD RAX,0x4 CMP RAX,R8 JNZ 0x001011a1 MOV EAX,0x1 RET LAB_001011b5: MOV RAX,RDI JMP 0x001011ca LAB_001011ba: MOV dword ptr [R9],0x1 LAB_001011c1: ADD RAX,0x4 CMP RAX,R8 JZ 0x001011d9 LAB_001011ca: MOV R9,RAX MOV EDX,dword ptr [RAX] CMP EDX,ECX JG 0x001011ba TEST EDX,EDX JLE 0x001011ba JMP 0x001011c1 LAB_001011d9: MOV EAX,dword ptr [RSI] SUB EAX,0x1 CDQ IDIV ECX MOVSXD RDX,EDX ADD dword ptr [RDI + RDX*0x4],ECX ADD RSI,0x4 CMP RSI,R8 JNZ 0x001011d9 MOV ESI,ECX MOV EAX,0x0 LAB_001011f7: CMP dword ptr [RDI + RAX*0x4],ECX JLE 0x00101209 ADD RAX,0x1 CMP RSI,RAX JNZ 0x001011f7 LEA EAX,[RCX + 0x1] RET LAB_00101209: LEA EAX,[RAX + 0x1] RET LAB_0010120d: MOV EAX,0x1 RET
int func0(int *param_1,uint param_2) { int *piVar1; int *piVar2; int *piVar3; ulong uVar4; if ((int)param_2 < 1) { return 1; } piVar1 = param_1 + (ulong)(param_2 - 1) + 1; piVar2 = param_1; do { piVar3 = param_1; if (*piVar2 == 1) { do { if (((int)param_2 < *piVar3) || (*piVar3 < 1)) { *piVar3 = 1; } piVar3 = piVar3 + 1; piVar2 = param_1; } while (piVar3 != piVar1); do { param_1[(*piVar2 + -1) % (int)param_2] = param_1[(*piVar2 + -1) % (int)param_2] + param_2; piVar2 = piVar2 + 1; } while (piVar2 != piVar1); uVar4 = 0; do { if (param_1[uVar4] <= (int)param_2) { return (int)uVar4 + 1; } uVar4 = uVar4 + 1; } while (param_2 != uVar4); return param_2 + 1; } piVar2 = piVar2 + 1; } while (piVar2 != piVar1); return 1; }
4,650
func0
#include <stdio.h> #include <assert.h>
int func0(int arr[], int n) { int ptr = 0; for (int i = 0; i < n; i++) { if (arr[i] == 1) { ptr = 1; break; } } if (ptr == 0) { return 1; } for (int i = 0; i < n; i++) { if (arr[i] <= 0 || arr[i] > n) { arr[i] = 1; } } for (int i = 0; i < n; i++) { arr[(arr[i] - 1) % n] += n; } for (int i = 0; i < n; i++) { if (arr[i] <= n) { return i + 1; } } return n + 1; }
int main() { int arr1[] = {1, 2, 3, -1, 5}; int arr2[] = {0, -1, -2, 1, 5, 8}; int arr3[] = {0, 1, 2, 5, -8}; assert(func0(arr1, 5) == 4); assert(func0(arr2, 6) == 2); assert(func0(arr3, 5) == 3); printf("All test cases passed\n"); return 0; }
O2
c
func0: endbr64 test %esi,%esi jle 1380 <func0+0xa0> lea -0x1(%rsi),%r9d mov %rdi,%rcx mov %rdi,%rax lea 0x4(%rdi,%r9,4),%r8 jmp 1309 <func0+0x29> nopl (%rax) add $0x4,%rax cmp %rax,%r8 je 1380 <func0+0xa0> cmpl $0x1,(%rax) jne 1300 <func0+0x20> mov %rdi,%rax nopl 0x0(%rax) mov (%rax),%edx cmp %edx,%esi jl 1322 <func0+0x42> test %edx,%edx jg 1328 <func0+0x48> movl $0x1,(%rax) add $0x4,%rax cmp %rax,%r8 jne 1318 <func0+0x38> nopl 0x0(%rax) mov (%rcx),%eax add $0x4,%rcx sub $0x1,%eax cltd idiv %esi movslq %edx,%rdx add %esi,(%rdi,%rdx,4) cmp %rcx,%r8 jne 1338 <func0+0x58> lea 0x2(%r9),%rdx mov $0x1,%eax nopl 0x0(%rax,%rax,1) mov %eax,%r8d cmp -0x4(%rdi,%rax,4),%esi jge 1386 <func0+0xa6> add $0x1,%rax cmp %rax,%rdx jne 1360 <func0+0x80> lea 0x1(%rsi),%r8d mov %r8d,%eax retq nopw 0x0(%rax,%rax,1) mov $0x1,%r8d mov %r8d,%eax retq nopw 0x0(%rax,%rax,1)
func0: endbr64 mov ecx, esi test esi, esi jle loc_1380 lea r9d, [rcx-1] mov rsi, rdi mov rax, rdi lea r8, [rdi+r9*4+4] jmp short loc_1309 loc_1300: add rax, 4 cmp r8, rax jz short loc_1380 loc_1309: cmp dword ptr [rax], 1 jnz short loc_1300 mov rax, rdi nop dword ptr [rax+00000000h] loc_1318: mov edx, [rax] cmp ecx, edx jl short loc_1322 test edx, edx jg short loc_1328 loc_1322: mov dword ptr [rax], 1 loc_1328: add rax, 4 cmp r8, rax jnz short loc_1318 nop dword ptr [rax+00000000h] loc_1338: mov eax, [rsi] add rsi, 4 sub eax, 1 cdq idiv ecx movsxd rdx, edx add [rdi+rdx*4], ecx cmp r8, rsi jnz short loc_1338 lea rdx, [r9+2] mov eax, 1 nop dword ptr [rax+rax+00000000h] loc_1360: mov r8d, eax cmp ecx, [rdi+rax*4-4] jge short loc_1386 add rax, 1 cmp rdx, rax jnz short loc_1360 lea r8d, [rcx+1] mov eax, r8d retn loc_1380: mov r8d, 1 loc_1386: mov eax, r8d retn
long long func0(int *a1, int a2) { long long v3; // r9 int *v4; // rsi int *v5; // rax long long v6; // r8 int *v7; // rax int v8; // eax long long v9; // rax unsigned int v10; // r8d if ( a2 <= 0 ) { return 1; } else { v3 = (unsigned int)(a2 - 1); v4 = a1; v5 = a1; v6 = (long long)&a1[v3 + 1]; while ( *v5 != 1 ) { if ( (int *)v6 == ++v5 ) return 1; } v7 = a1; do { if ( a2 < *v7 || *v7 <= 0 ) *v7 = 1; ++v7; } while ( (int *)v6 != v7 ); do { v8 = *v4++; a1[(v8 - 1) % a2] += a2; } while ( (int *)v6 != v4 ); v9 = 1LL; while ( 1 ) { v10 = v9; if ( a2 >= a1[v9 - 1] ) break; if ( v3 + 2 == ++v9 ) return (unsigned int)(a2 + 1); } } return v10; }
func0: ENDBR64 MOV ECX,ESI TEST ESI,ESI JLE 0x00101380 LEA R9D,[RCX + -0x1] MOV RSI,RDI MOV RAX,RDI LEA R8,[RDI + R9*0x4 + 0x4] JMP 0x00101309 LAB_00101300: ADD RAX,0x4 CMP R8,RAX JZ 0x00101380 LAB_00101309: CMP dword ptr [RAX],0x1 JNZ 0x00101300 MOV RAX,RDI NOP dword ptr [RAX] LAB_00101318: MOV EDX,dword ptr [RAX] CMP ECX,EDX JL 0x00101322 TEST EDX,EDX JG 0x00101328 LAB_00101322: MOV dword ptr [RAX],0x1 LAB_00101328: ADD RAX,0x4 CMP R8,RAX JNZ 0x00101318 NOP dword ptr [RAX] LAB_00101338: MOV EAX,dword ptr [RSI] ADD RSI,0x4 SUB EAX,0x1 CDQ IDIV ECX MOVSXD RDX,EDX ADD dword ptr [RDI + RDX*0x4],ECX CMP R8,RSI JNZ 0x00101338 LEA RDX,[R9 + 0x2] MOV EAX,0x1 NOP dword ptr [RAX + RAX*0x1] LAB_00101360: MOV R8D,EAX CMP ECX,dword ptr [RDI + RAX*0x4 + -0x4] JGE 0x00101386 ADD RAX,0x1 CMP RDX,RAX JNZ 0x00101360 LEA R8D,[RCX + 0x1] MOV EAX,R8D RET LAB_00101380: MOV R8D,0x1 LAB_00101386: MOV EAX,R8D RET
ulong func0(int *param_1,int param_2) { int *piVar1; int iVar2; int *piVar3; int *piVar4; ulong uVar5; if (0 < param_2) { piVar1 = param_1 + (ulong)(param_2 - 1) + 1; piVar3 = param_1; do { piVar4 = param_1; if (*piVar3 == 1) { do { if ((param_2 < *piVar4) || (*piVar4 < 1)) { *piVar4 = 1; } piVar4 = piVar4 + 1; piVar3 = param_1; } while (piVar1 != piVar4); do { iVar2 = *piVar3; piVar3 = piVar3 + 1; param_1[(iVar2 + -1) % param_2] = param_1[(iVar2 + -1) % param_2] + param_2; } while (piVar1 != piVar3); uVar5 = 1; do { if (param_1[uVar5 - 1] <= param_2) { return uVar5 & 0xffffffff; } uVar5 = uVar5 + 1; } while ((ulong)(param_2 - 1) + 2 != uVar5); return (ulong)(param_2 + 1); } piVar3 = piVar3 + 1; } while (piVar1 != piVar3); } return 1; }
4,651
func0
#include <stdio.h> #include <assert.h>
int func0(int arr[], int n) { int ptr = 0; for (int i = 0; i < n; i++) { if (arr[i] == 1) { ptr = 1; break; } } if (ptr == 0) { return 1; } for (int i = 0; i < n; i++) { if (arr[i] <= 0 || arr[i] > n) { arr[i] = 1; } } for (int i = 0; i < n; i++) { arr[(arr[i] - 1) % n] += n; } for (int i = 0; i < n; i++) { if (arr[i] <= n) { return i + 1; } } return n + 1; }
int main() { int arr1[] = {1, 2, 3, -1, 5}; int arr2[] = {0, -1, -2, 1, 5, 8}; int arr3[] = {0, 1, 2, 5, -8}; assert(func0(arr1, 5) == 4); assert(func0(arr2, 6) == 2); assert(func0(arr3, 5) == 3); printf("All test cases passed\n"); return 0; }
O3
c
func0: endbr64 test %esi,%esi jle 1350 <func0+0xa0> lea -0x1(%rsi),%r9d mov %rdi,%rcx mov %rdi,%rax lea 0x4(%rdi,%r9,4),%r8 jmp 12d9 <func0+0x29> nopl (%rax) add $0x4,%rax cmp %rax,%r8 je 1350 <func0+0xa0> cmpl $0x1,(%rax) jne 12d0 <func0+0x20> mov %rdi,%rax nopl 0x0(%rax) mov (%rax),%edx cmp %edx,%esi jl 12f2 <func0+0x42> test %edx,%edx jg 12f8 <func0+0x48> movl $0x1,(%rax) add $0x4,%rax cmp %rax,%r8 jne 12e8 <func0+0x38> nopl 0x0(%rax) mov (%rcx),%eax add $0x4,%rcx sub $0x1,%eax cltd idiv %esi movslq %edx,%rdx add %esi,(%rdi,%rdx,4) cmp %rcx,%r8 jne 1308 <func0+0x58> lea 0x2(%r9),%rdx mov $0x1,%eax nopl 0x0(%rax,%rax,1) mov %eax,%r8d cmp -0x4(%rdi,%rax,4),%esi jge 1356 <func0+0xa6> add $0x1,%rax cmp %rax,%rdx jne 1330 <func0+0x80> lea 0x1(%rsi),%r8d mov %r8d,%eax retq nopw 0x0(%rax,%rax,1) mov $0x1,%r8d mov %r8d,%eax retq nopw 0x0(%rax,%rax,1)
func0: endbr64 mov ecx, esi test esi, esi jle loc_1348 movsxd r9, ecx mov rsi, rdi mov rax, rdi lea r8, [rdi+r9*4] jmp short loc_12D9 loc_12D0: add rax, 4 cmp r8, rax jz short loc_1348 loc_12D9: cmp dword ptr [rax], 1 jnz short loc_12D0 mov rax, rdi nop dword ptr [rax+00000000h] loc_12E8: mov edx, [rax] cmp ecx, edx jl short loc_12F2 test edx, edx jg short loc_12F8 loc_12F2: mov dword ptr [rax], 1 loc_12F8: add rax, 4 cmp r8, rax jnz short loc_12E8 nop dword ptr [rax+00000000h] loc_1308: mov eax, [rsi] add rsi, 4 sub eax, 1 cdq idiv ecx movsxd rdx, edx add [rdi+rdx*4], ecx cmp r8, rsi jnz short loc_1308 mov eax, 1 jmp short loc_133C loc_1330: lea rdx, [rax+1] cmp r9, rax jz short loc_1350 mov rax, rdx loc_133C: cmp ecx, [rdi+rax*4-4] jl short loc_1330 retn loc_1348: mov eax, 1 retn loc_1350: lea eax, [rcx+1] retn
long long func0(int *a1, int a2) { int *v3; // rsi int *v4; // rax int *v5; // r8 int *v6; // rax int v7; // eax long long result; // rax if ( a2 <= 0 ) return 1LL; v3 = a1; v4 = a1; v5 = &a1[a2]; while ( *v4 != 1 ) { if ( v5 == ++v4 ) return 1LL; } v6 = a1; do { if ( a2 < *v6 || *v6 <= 0 ) *v6 = 1; ++v6; } while ( v5 != v6 ); do { v7 = *v3++; a1[(v7 - 1) % a2] += a2; } while ( v5 != v3 ); for ( result = 1LL; a2 < a1[result - 1]; ++result ) { if ( a2 == result ) return (unsigned int)(a2 + 1); } return result; }
func0: ENDBR64 MOV ECX,ESI TEST ESI,ESI JLE 0x00101348 MOVSXD R9,ECX MOV RSI,RDI MOV RAX,RDI LEA R8,[RDI + R9*0x4] JMP 0x001012d9 LAB_001012d0: ADD RAX,0x4 CMP R8,RAX JZ 0x00101348 LAB_001012d9: CMP dword ptr [RAX],0x1 JNZ 0x001012d0 MOV RAX,RDI NOP dword ptr [RAX] LAB_001012e8: MOV EDX,dword ptr [RAX] CMP ECX,EDX JL 0x001012f2 TEST EDX,EDX JG 0x001012f8 LAB_001012f2: MOV dword ptr [RAX],0x1 LAB_001012f8: ADD RAX,0x4 CMP R8,RAX JNZ 0x001012e8 NOP dword ptr [RAX] LAB_00101308: MOV EAX,dword ptr [RSI] ADD RSI,0x4 SUB EAX,0x1 CDQ IDIV ECX MOVSXD RDX,EDX ADD dword ptr [RDI + RDX*0x4],ECX CMP R8,RSI JNZ 0x00101308 MOV EAX,0x1 JMP 0x0010133c LAB_00101330: LEA RDX,[RAX + 0x1] CMP R9,RAX JZ 0x00101350 MOV RAX,RDX LAB_0010133c: CMP ECX,dword ptr [RDI + RAX*0x4 + -0x4] JL 0x00101330 RET LAB_00101348: MOV EAX,0x1 RET LAB_00101350: LEA EAX,[RCX + 0x1] RET
ulong func0(int *param_1,int param_2) { int *piVar1; int iVar2; int *piVar3; int *piVar4; ulong uVar5; bool bVar6; if (0 < param_2) { piVar1 = param_1 + param_2; piVar3 = param_1; do { piVar4 = param_1; if (*piVar3 == 1) { do { if ((param_2 < *piVar4) || (*piVar4 < 1)) { *piVar4 = 1; } piVar4 = piVar4 + 1; piVar3 = param_1; } while (piVar1 != piVar4); do { iVar2 = *piVar3; piVar3 = piVar3 + 1; param_1[(iVar2 + -1) % param_2] = param_1[(iVar2 + -1) % param_2] + param_2; } while (piVar1 != piVar3); uVar5 = 1; do { if (param_1[uVar5 - 1] <= param_2) { return uVar5; } bVar6 = (long)param_2 != uVar5; uVar5 = uVar5 + 1; } while (bVar6); return (ulong)(param_2 + 1); } piVar3 = piVar3 + 1; } while (piVar1 != piVar3); } return 1; }
4,652
func0
#include <assert.h>
int func0(int x1, int y1, int x2, int y2) { return (y2 - y1 - 1) * (x2 - x1 - 1); }
int main() { assert(func0(1, 1, 4, 4) == 4); assert(func0(1, 2, 1, 2) == 1); assert(func0(4, 2, 6, 4) == 1); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %edi,-0x4(%rbp) mov %esi,-0x8(%rbp) mov %edx,-0xc(%rbp) mov %ecx,-0x10(%rbp) mov -0x10(%rbp),%eax sub -0x8(%rbp),%eax lea -0x1(%rax),%edx mov -0xc(%rbp),%eax sub -0x4(%rbp),%eax sub $0x1,%eax imul %edx,%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_4], edi mov [rbp+var_8], esi mov [rbp+var_C], edx mov [rbp+var_10], ecx mov eax, [rbp+var_10] sub eax, [rbp+var_8] lea edx, [rax-1] mov eax, [rbp+var_C] sub eax, [rbp+var_4] sub eax, 1 imul eax, edx pop rbp retn
long long func0(int a1, int a2, int a3, int a4) { return (unsigned int)((a4 - a2 - 1) * (a3 - a1 - 1)); }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV dword ptr [RBP + -0x4],EDI MOV dword ptr [RBP + -0x8],ESI MOV dword ptr [RBP + -0xc],EDX MOV dword ptr [RBP + -0x10],ECX MOV EAX,dword ptr [RBP + -0x10] SUB EAX,dword ptr [RBP + -0x8] LEA EDX,[RAX + -0x1] MOV EAX,dword ptr [RBP + -0xc] SUB EAX,dword ptr [RBP + -0x4] SUB EAX,0x1 IMUL EAX,EDX POP RBP RET
int func0(int param_1,int param_2,int param_3,int param_4) { return ((param_3 - param_1) + -1) * ((param_4 - param_2) + -1); }
4,653
func0
#include <assert.h>
int func0(int x1, int y1, int x2, int y2) { return (y2 - y1 - 1) * (x2 - x1 - 1); }
int main() { assert(func0(1, 1, 4, 4) == 4); assert(func0(1, 2, 1, 2) == 1); assert(func0(4, 2, 6, 4) == 1); return 0; }
O1
c
func0: endbr64 sub %esi,%ecx lea -0x1(%rcx),%eax sub %edi,%edx lea -0x1(%rdx),%ecx imul %ecx,%eax retq
func0: endbr64 sub ecx, esi lea eax, [rcx-1] sub edx, edi sub edx, 1 imul eax, edx retn
long long func0(int a1, int a2, int a3, int a4) { return (unsigned int)((a3 - a1 - 1) * (a4 - a2 - 1)); }
func0: ENDBR64 SUB ECX,ESI LEA EAX,[RCX + -0x1] SUB EDX,EDI SUB EDX,0x1 IMUL EAX,EDX RET
int func0(int param_1,int param_2,int param_3,int param_4) { return ((param_4 - param_2) + -1) * ((param_3 - param_1) + -1); }
4,654
func0
#include <assert.h>
int func0(int x1, int y1, int x2, int y2) { return (y2 - y1 - 1) * (x2 - x1 - 1); }
int main() { assert(func0(1, 1, 4, 4) == 4); assert(func0(1, 2, 1, 2) == 1); assert(func0(4, 2, 6, 4) == 1); return 0; }
O2
c
func0: endbr64 sub %esi,%ecx sub %edi,%edx lea -0x1(%rcx),%eax lea -0x1(%rdx),%ecx imul %ecx,%eax retq nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax)
func0: endbr64 sub ecx, esi sub edx, edi lea eax, [rcx-1] sub edx, 1 imul eax, edx retn
long long func0(int a1, int a2, int a3, int a4) { return (unsigned int)((a3 - a1 - 1) * (a4 - a2 - 1)); }
func0: ENDBR64 SUB ECX,ESI SUB EDX,EDI LEA EAX,[RCX + -0x1] SUB EDX,0x1 IMUL EAX,EDX RET
int func0(int param_1,int param_2,int param_3,int param_4) { return ((param_4 - param_2) + -1) * ((param_3 - param_1) + -1); }
4,655
func0
#include <assert.h>
int func0(int x1, int y1, int x2, int y2) { return (y2 - y1 - 1) * (x2 - x1 - 1); }
int main() { assert(func0(1, 1, 4, 4) == 4); assert(func0(1, 2, 1, 2) == 1); assert(func0(4, 2, 6, 4) == 1); return 0; }
O3
c
func0: endbr64 sub %esi,%ecx sub %edi,%edx lea -0x1(%rcx),%eax lea -0x1(%rdx),%ecx imul %ecx,%eax retq nopw %cs:0x0(%rax,%rax,1) nopl 0x0(%rax)
func0: endbr64 sub ecx, esi sub edx, edi lea eax, [rcx-1] sub edx, 1 imul eax, edx retn
long long func0(int a1, int a2, int a3, int a4) { return (unsigned int)((a3 - a1 - 1) * (a4 - a2 - 1)); }
func0: ENDBR64 SUB ECX,ESI SUB EDX,EDI LEA EAX,[RCX + -0x1] SUB EDX,0x1 IMUL EAX,EDX RET
int func0(int param_1,int param_2,int param_3,int param_4) { return ((param_4 - param_2) + -1) * ((param_3 - param_1) + -1); }
4,656
func0
#include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(const char *monthname3) { if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 || strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) { return true; } else { return false; } }
int main() { assert(func0("February") == false); assert(func0("June") == true); assert(func0("April") == true); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x10,%rsp mov %rdi,-0x8(%rbp) mov -0x8(%rbp),%rax lea 0xe84(%rip),%rsi mov %rax,%rdi callq 1070 <strcmp@plt> test %eax,%eax je 11d5 <func0+0x6c> mov -0x8(%rbp),%rax lea 0xe73(%rip),%rsi mov %rax,%rdi callq 1070 <strcmp@plt> test %eax,%eax je 11d5 <func0+0x6c> mov -0x8(%rbp),%rax lea 0xe61(%rip),%rsi mov %rax,%rdi callq 1070 <strcmp@plt> test %eax,%eax je 11d5 <func0+0x6c> mov -0x8(%rbp),%rax lea 0xe54(%rip),%rsi mov %rax,%rdi callq 1070 <strcmp@plt> test %eax,%eax jne 11dc <func0+0x73> mov $0x1,%eax jmp 11e1 <func0+0x78> mov $0x0,%eax leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 10h mov [rbp+s1], rdi mov rax, [rbp+s1] lea rdx, s2; "April" mov rsi, rdx; s2 mov rdi, rax; s1 call _strcmp test eax, eax jz short loc_11E1 mov rax, [rbp+s1] lea rdx, aJune; "June" mov rsi, rdx; s2 mov rdi, rax; s1 call _strcmp test eax, eax jz short loc_11E1 mov rax, [rbp+s1] lea rdx, aSeptember; "September" mov rsi, rdx; s2 mov rdi, rax; s1 call _strcmp test eax, eax jz short loc_11E1 mov rax, [rbp+s1] lea rdx, aNovember; "November" mov rsi, rdx; s2 mov rdi, rax; s1 call _strcmp test eax, eax jnz short loc_11E8 loc_11E1: mov eax, 1 jmp short locret_11ED loc_11E8: mov eax, 0 locret_11ED: leave retn
_BOOL8 func0(const char *a1) { return !strcmp(a1, "April") || !strcmp(a1, "June") || !strcmp(a1, "September") || !strcmp(a1, "November"); }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x10 MOV qword ptr [RBP + -0x8],RDI MOV RAX,qword ptr [RBP + -0x8] LEA RDX,[0x102004] MOV RSI,RDX MOV RDI,RAX CALL 0x00101070 TEST EAX,EAX JZ 0x001011e1 MOV RAX,qword ptr [RBP + -0x8] LEA RDX,[0x10200a] MOV RSI,RDX MOV RDI,RAX CALL 0x00101070 TEST EAX,EAX JZ 0x001011e1 MOV RAX,qword ptr [RBP + -0x8] LEA RDX,[0x10200f] MOV RSI,RDX MOV RDI,RAX CALL 0x00101070 TEST EAX,EAX JZ 0x001011e1 MOV RAX,qword ptr [RBP + -0x8] LEA RDX,[0x102019] MOV RSI,RDX MOV RDI,RAX CALL 0x00101070 TEST EAX,EAX JNZ 0x001011e8 LAB_001011e1: MOV EAX,0x1 JMP 0x001011ed LAB_001011e8: MOV EAX,0x0 LAB_001011ed: LEAVE RET
int8 func0(char *param_1) { int iVar1; iVar1 = strcmp(param_1,"April"); if ((((iVar1 != 0) && (iVar1 = strcmp(param_1,"June"), iVar1 != 0)) && (iVar1 = strcmp(param_1,"September"), iVar1 != 0)) && (iVar1 = strcmp(param_1,"November"), iVar1 != 0)) { return 0; } return 1; }
4,657
func0
#include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(const char *monthname3) { if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 || strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) { return true; } else { return false; } }
int main() { assert(func0("February") == false); assert(func0("June") == true); assert(func0("April") == true); return 0; }
O1
c
func0: endbr64 mov %rdi,%rax mov $0x6,%ecx lea 0xea8(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl mov $0x1,%ecx test %dl,%dl je 11cb <func0+0x82> mov $0x5,%ecx lea 0xe8e(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl mov $0x1,%ecx test %dl,%dl je 11cb <func0+0x82> mov $0xa,%ecx lea 0xe73(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl mov $0x1,%ecx test %dl,%dl je 11cb <func0+0x82> mov $0x9,%ecx lea 0xe5d(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %al sbb $0x0,%al test %al,%al sete %cl mov %ecx,%eax retq
func0: endbr64 push rbx mov rbx, rdi lea rsi, aApril; "April" call _strcmp mov edx, eax mov eax, 1 test edx, edx jz short loc_11D0 lea rsi, aJune; "June" mov rdi, rbx call _strcmp mov edx, eax mov eax, 1 test edx, edx jz short loc_11D0 lea rsi, aSeptember; "September" mov rdi, rbx call _strcmp mov edx, eax mov eax, 1 test edx, edx jz short loc_11D0 lea rsi, aNovember; "November" mov rdi, rbx call _strcmp test eax, eax setz al loc_11D0: pop rbx retn
bool func0(long long a1) { int v1; // edx bool result; // al int v3; // edx int v4; // edx v1 = strcmp(a1, "April"); result = 1; if ( v1 ) { v3 = strcmp(a1, "June"); result = 1; if ( v3 ) { v4 = strcmp(a1, "September"); result = 1; if ( v4 ) return (unsigned int)strcmp(a1, "November") == 0; } } return result; }
func0: ENDBR64 PUSH RBX MOV RBX,RDI LEA RSI,[0x102004] CALL 0x00101070 MOV EDX,EAX MOV EAX,0x1 TEST EDX,EDX JZ 0x001011d0 LEA RSI,[0x10200a] MOV RDI,RBX CALL 0x00101070 MOV EDX,EAX MOV EAX,0x1 TEST EDX,EDX JZ 0x001011d0 LEA RSI,[0x10200f] MOV RDI,RBX CALL 0x00101070 MOV EDX,EAX MOV EAX,0x1 TEST EDX,EDX JZ 0x001011d0 LEA RSI,[0x102019] MOV RDI,RBX CALL 0x00101070 TEST EAX,EAX SETZ AL LAB_001011d0: POP RBX RET
int8 func0(char *param_1) { int iVar1; int8 uVar2; int4 extraout_var; iVar1 = strcmp(param_1,"April"); uVar2 = 1; if (iVar1 != 0) { iVar1 = strcmp(param_1,"June"); uVar2 = 1; if (iVar1 != 0) { iVar1 = strcmp(param_1,"September"); uVar2 = 1; if (iVar1 != 0) { iVar1 = strcmp(param_1,"November"); uVar2 = CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),iVar1 == 0); } } } return uVar2; }
4,658
func0
#include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(const char *monthname3) { if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 || strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) { return true; } else { return false; } }
int main() { assert(func0("February") == false); assert(func0("June") == true); assert(func0("April") == true); return 0; }
O2
c
func0: endbr64 mov %rdi,%rax mov $0x6,%ecx lea 0xe01(%rip),%rdi mov $0x1,%r8d mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl test %dl,%dl je 126a <func0+0x7a> mov $0x5,%ecx lea 0xde6(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl test %dl,%dl je 126a <func0+0x7a> mov $0xa,%ecx lea 0xdd0(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl test %dl,%dl je 126a <func0+0x7a> mov %rax,%rsi mov $0x9,%ecx lea 0xdbc(%rip),%rdi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %al sbb $0x0,%al test %al,%al sete %r8b mov %r8d,%eax retq xchg %ax,%ax
func0: endbr64 push r12 lea rsi, aApril; "April" mov r12d, 1 push rbp mov rbp, rdi sub rsp, 8 call _strcmp test eax, eax jz short loc_126F lea rsi, aJune; "June" mov rdi, rbp call _strcmp test eax, eax jz short loc_126F lea rsi, aSeptember; "September" mov rdi, rbp call _strcmp test eax, eax jz short loc_126F lea rsi, aNovember; "November" mov rdi, rbp call _strcmp test eax, eax setz r12b loc_126F: add rsp, 8 mov eax, r12d pop rbp pop r12 retn
long long func0(long long a1) { unsigned int v1; // r12d v1 = 1; if ( (unsigned int)strcmp(a1, "April") && (unsigned int)strcmp(a1, "June") && (unsigned int)strcmp(a1, "September") ) LOBYTE(v1) = (unsigned int)strcmp(a1, "November") == 0; return v1; }
func0: ENDBR64 PUSH R12 LEA RSI,[0x102004] MOV R12D,0x1 PUSH RBP MOV RBP,RDI SUB RSP,0x8 CALL 0x00101070 TEST EAX,EAX JZ 0x0010126f LEA RSI,[0x10200a] MOV RDI,RBP CALL 0x00101070 TEST EAX,EAX JZ 0x0010126f LEA RSI,[0x10200f] MOV RDI,RBP CALL 0x00101070 TEST EAX,EAX JZ 0x0010126f LEA RSI,[0x102019] MOV RDI,RBP CALL 0x00101070 TEST EAX,EAX SETZ R12B LAB_0010126f: ADD RSP,0x8 MOV EAX,R12D POP RBP POP R12 RET
bool func0(char *param_1) { int iVar1; bool bVar2; bVar2 = true; iVar1 = strcmp(param_1,"April"); if (iVar1 != 0) { iVar1 = strcmp(param_1,"June"); if (iVar1 != 0) { iVar1 = strcmp(param_1,"September"); if (iVar1 != 0) { iVar1 = strcmp(param_1,"November"); bVar2 = iVar1 == 0; } } } return bVar2; }
4,659
func0
#include <stdbool.h> #include <string.h> #include <assert.h>
bool func0(const char *monthname3) { if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 || strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) { return true; } else { return false; } }
int main() { assert(func0("February") == false); assert(func0("June") == true); assert(func0("April") == true); return 0; }
O3
c
func0: endbr64 mov %rdi,%rax mov $0x6,%ecx lea 0xe01(%rip),%rdi mov $0x1,%r8d mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl test %dl,%dl je 126a <func0+0x7a> mov $0x5,%ecx lea 0xde6(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl test %dl,%dl je 126a <func0+0x7a> mov $0xa,%ecx lea 0xdd0(%rip),%rdi mov %rax,%rsi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %dl sbb $0x0,%dl test %dl,%dl je 126a <func0+0x7a> mov %rax,%rsi mov $0x9,%ecx lea 0xdbc(%rip),%rdi repz cmpsb %es:(%rdi),%ds:(%rsi) seta %al sbb $0x0,%al test %al,%al sete %r8b mov %r8d,%eax retq xchg %ax,%ax
func0: endbr64 push rbp lea rsi, s2; "April" mov ebp, 1 push rbx mov rbx, rdi sub rsp, 8 call _strcmp test eax, eax jz short loc_126D lea rsi, aJune; "June" mov rdi, rbx; s1 call _strcmp test eax, eax jz short loc_126D lea rsi, aSeptember; "September" mov rdi, rbx; s1 call _strcmp test eax, eax jz short loc_126D lea rsi, aNovember; "November" mov rdi, rbx; s1 call _strcmp test eax, eax setz bpl loc_126D: add rsp, 8 mov eax, ebp pop rbx pop rbp retn
long long func0(char *s1) { unsigned int v1; // ebp v1 = 1; if ( strcmp(s1, "April") && strcmp(s1, "June") && strcmp(s1, "September") ) LOBYTE(v1) = strcmp(s1, "November") == 0; return v1; }
func0: ENDBR64 PUSH RBP LEA RSI,[0x102004] MOV EBP,0x1 PUSH RBX MOV RBX,RDI SUB RSP,0x8 CALL 0x00101070 TEST EAX,EAX JZ 0x0010126d LEA RSI,[0x10200a] MOV RDI,RBX CALL 0x00101070 TEST EAX,EAX JZ 0x0010126d LEA RSI,[0x10200f] MOV RDI,RBX CALL 0x00101070 TEST EAX,EAX JZ 0x0010126d LEA RSI,[0x102019] MOV RDI,RBX CALL 0x00101070 TEST EAX,EAX SETZ BPL LAB_0010126d: ADD RSP,0x8 MOV EAX,EBP POP RBX POP RBP RET
bool func0(char *param_1) { int iVar1; bool bVar2; bVar2 = true; iVar1 = strcmp(param_1,"April"); if (iVar1 != 0) { iVar1 = strcmp(param_1,"June"); if (iVar1 != 0) { iVar1 = strcmp(param_1,"September"); if (iVar1 != 0) { iVar1 = strcmp(param_1,"November"); bVar2 = iVar1 == 0; } } } return bVar2; }
4,660
func0
#include <stdio.h> #include <stdlib.h> #include <ctype.h> #include <assert.h>
int func0(const char *str) { int flag_l = 0; int flag_n = 0; while (*str) { if (isalpha((unsigned char)*str)) { flag_l = 1; } if (isdigit((unsigned char)*str)) { flag_n = 1; } str++; } return flag_l && flag_n; }
int main() { assert(func0("thishasboth29") == 1); assert(func0("python") == 0); assert(func0("string") == 0); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x20,%rsp mov %rdi,-0x18(%rbp) movl $0x0,-0x8(%rbp) movl $0x0,-0x4(%rbp) jmp 11ea <func0+0x81> callq 1070 <__ctype_b_loc@plt> mov (%rax),%rdx mov -0x18(%rbp),%rax movzbl (%rax),%eax movzbl %al,%eax add %rax,%rax add %rdx,%rax movzwl (%rax),%eax movzwl %ax,%eax and $0x400,%eax test %eax,%eax je 11b7 <func0+0x4e> movl $0x1,-0x8(%rbp) callq 1070 <__ctype_b_loc@plt> mov (%rax),%rdx mov -0x18(%rbp),%rax movzbl (%rax),%eax movzbl %al,%eax add %rax,%rax add %rdx,%rax movzwl (%rax),%eax movzwl %ax,%eax and $0x800,%eax test %eax,%eax je 11e5 <func0+0x7c> movl $0x1,-0x4(%rbp) addq $0x1,-0x18(%rbp) mov -0x18(%rbp),%rax movzbl (%rax),%eax test %al,%al jne 1189 <func0+0x20> cmpl $0x0,-0x8(%rbp) je 1208 <func0+0x9f> cmpl $0x0,-0x4(%rbp) je 1208 <func0+0x9f> mov $0x1,%eax jmp 120d <func0+0xa4> mov $0x0,%eax leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 20h mov [rbp+var_18], rdi mov [rbp+var_8], 0 mov [rbp+var_4], 0 jmp short loc_11EA loc_1189: call ___ctype_b_loc mov rdx, [rax] mov rax, [rbp+var_18] movzx eax, byte ptr [rax] movzx eax, al add rax, rax add rax, rdx movzx eax, word ptr [rax] movzx eax, ax and eax, 400h test eax, eax jz short loc_11B7 mov [rbp+var_8], 1 loc_11B7: call ___ctype_b_loc mov rdx, [rax] mov rax, [rbp+var_18] movzx eax, byte ptr [rax] movzx eax, al add rax, rax add rax, rdx movzx eax, word ptr [rax] movzx eax, ax and eax, 800h test eax, eax jz short loc_11E5 mov [rbp+var_4], 1 loc_11E5: add [rbp+var_18], 1 loc_11EA: mov rax, [rbp+var_18] movzx eax, byte ptr [rax] test al, al jnz short loc_1189 cmp [rbp+var_8], 0 jz short loc_1208 cmp [rbp+var_4], 0 jz short loc_1208 mov eax, 1 jmp short locret_120D loc_1208: mov eax, 0 locret_120D: leave retn
_BOOL8 func0(_BYTE *a1) { int v3; // [rsp+18h] [rbp-8h] int v4; // [rsp+1Ch] [rbp-4h] v3 = 0; v4 = 0; while ( *a1 ) { if ( ((*__ctype_b_loc())[(unsigned __int8)*a1] & 0x400) != 0 ) v3 = 1; if ( ((*__ctype_b_loc())[(unsigned __int8)*a1] & 0x800) != 0 ) v4 = 1; ++a1; } return v3 && v4; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x20 MOV qword ptr [RBP + -0x18],RDI MOV dword ptr [RBP + -0x8],0x0 MOV dword ptr [RBP + -0x4],0x0 JMP 0x001011ea LAB_00101189: CALL 0x00101070 MOV RDX,qword ptr [RAX] MOV RAX,qword ptr [RBP + -0x18] MOVZX EAX,byte ptr [RAX] MOVZX EAX,AL ADD RAX,RAX ADD RAX,RDX MOVZX EAX,word ptr [RAX] MOVZX EAX,AX AND EAX,0x400 TEST EAX,EAX JZ 0x001011b7 MOV dword ptr [RBP + -0x8],0x1 LAB_001011b7: CALL 0x00101070 MOV RDX,qword ptr [RAX] MOV RAX,qword ptr [RBP + -0x18] MOVZX EAX,byte ptr [RAX] MOVZX EAX,AL ADD RAX,RAX ADD RAX,RDX MOVZX EAX,word ptr [RAX] MOVZX EAX,AX AND EAX,0x800 TEST EAX,EAX JZ 0x001011e5 MOV dword ptr [RBP + -0x4],0x1 LAB_001011e5: ADD qword ptr [RBP + -0x18],0x1 LAB_001011ea: MOV RAX,qword ptr [RBP + -0x18] MOVZX EAX,byte ptr [RAX] TEST AL,AL JNZ 0x00101189 CMP dword ptr [RBP + -0x8],0x0 JZ 0x00101208 CMP dword ptr [RBP + -0x4],0x0 JZ 0x00101208 MOV EAX,0x1 JMP 0x0010120d LAB_00101208: MOV EAX,0x0 LAB_0010120d: LEAVE RET
int8 func0(byte *param_1) { bool bVar1; bool bVar2; ushort **ppuVar3; int8 uVar4; byte *local_20; bVar1 = false; bVar2 = false; for (local_20 = param_1; *local_20 != 0; local_20 = local_20 + 1) { ppuVar3 = __ctype_b_loc(); if (((*ppuVar3)[*local_20] & 0x400) != 0) { bVar1 = true; } ppuVar3 = __ctype_b_loc(); if (((*ppuVar3)[*local_20] & 0x800) != 0) { bVar2 = true; } } if ((bVar1) && (bVar2)) { uVar4 = 1; } else { uVar4 = 0; } return uVar4; }
4,661
func0
#include <stdio.h> #include <stdlib.h> #include <ctype.h> #include <assert.h>
int func0(const char *str) { int flag_l = 0; int flag_n = 0; while (*str) { if (isalpha((unsigned char)*str)) { flag_l = 1; } if (isdigit((unsigned char)*str)) { flag_n = 1; } str++; } return flag_l && flag_n; }
int main() { assert(func0("thishasboth29") == 1); assert(func0("python") == 0); assert(func0("string") == 0); return 0; }
O1
c
func0: endbr64 push %rbp push %rbx sub $0x8,%rsp movzbl (%rdi),%ebx test %bl,%bl je 11c9 <func0+0x60> mov %rdi,%rbp callq 1070 <__ctype_b_loc@plt> mov (%rax),%rdi mov $0x0,%edx mov $0x0,%ecx mov $0x1,%esi movzbl %bl,%ebx movzwl (%rdi,%rbx,2),%eax test $0x4,%ah cmovne %esi,%ecx test $0x8,%ah cmovne %esi,%edx add $0x1,%rbp movzbl 0x0(%rbp),%ebx test %bl,%bl jne 1194 <func0+0x2b> test %ecx,%ecx setne %cl test %edx,%edx setne %al movzbl %al,%eax and %ecx,%eax add $0x8,%rsp pop %rbx pop %rbp retq mov $0x0,%edx mov $0x0,%ecx jmp 11b3 <func0+0x4a>
func0: endbr64 push rbp push rbx sub rsp, 8 movzx ebx, byte ptr [rdi] test bl, bl jz short loc_11C9 mov rbp, rdi call ___ctype_b_loc mov rdi, [rax] mov edx, 0 mov ecx, 0 mov esi, 1 loc_1194: movzx ebx, bl movzx eax, word ptr [rdi+rbx*2] test ah, 4 cmovnz ecx, esi test ah, 8 cmovnz edx, esi add rbp, 1 movzx ebx, byte ptr [rbp+0] test bl, bl jnz short loc_1194 loc_11B3: test ecx, ecx setnz cl test edx, edx setnz al movzx eax, al and eax, ecx add rsp, 8 pop rbx pop rbp retn loc_11C9: mov edx, 0 mov ecx, 0 jmp short loc_11B3
long long func0(unsigned __int8 *a1) { unsigned __int8 v1; // bl unsigned __int8 *v2; // rbp long long v3; // rdi int v4; // edx int v5; // ecx __int16 v6; // ax v1 = *a1; if ( *a1 ) { v2 = a1; v3 = *(_QWORD *)__ctype_b_loc(); v4 = 0; v5 = 0; do { v6 = *(_WORD *)(v3 + 2LL * v1); if ( (v6 & 0x400) != 0 ) v5 = 1; if ( (v6 & 0x800) != 0 ) v4 = 1; v1 = *++v2; } while ( *v2 ); } else { v4 = 0; v5 = 0; } return (v5 != 0) & (unsigned __int8)(v4 != 0); }
func0: ENDBR64 PUSH RBP PUSH RBX SUB RSP,0x8 MOVZX EBX,byte ptr [RDI] TEST BL,BL JZ 0x001011c9 MOV RBP,RDI CALL 0x00101070 MOV RDI,qword ptr [RAX] MOV EDX,0x0 MOV ECX,0x0 MOV ESI,0x1 LAB_00101194: MOVZX EBX,BL MOVZX EAX,word ptr [RDI + RBX*0x2] TEST AH,0x4 CMOVNZ ECX,ESI TEST AH,0x8 CMOVNZ EDX,ESI ADD RBP,0x1 MOVZX EBX,byte ptr [RBP] TEST BL,BL JNZ 0x00101194 LAB_001011b3: TEST ECX,ECX SETNZ CL TEST EDX,EDX SETNZ AL MOVZX EAX,AL AND EAX,ECX ADD RSP,0x8 POP RBX POP RBP RET LAB_001011c9: MOV EDX,0x0 MOV ECX,0x0 JMP 0x001011b3
byte func0(byte *param_1) { byte bVar1; byte bVar2; ushort **ppuVar3; byte bVar4; bVar4 = *param_1; if (bVar4 == 0) { bVar2 = 0; bVar1 = 0; } else { ppuVar3 = __ctype_b_loc(); bVar2 = 0; bVar1 = 0; do { if (((*ppuVar3)[bVar4] & 0x400) != 0) { bVar1 = 1; } if (((*ppuVar3)[bVar4] & 0x800) != 0) { bVar2 = 1; } param_1 = param_1 + 1; bVar4 = *param_1; } while (bVar4 != 0); } return bVar2 & bVar1; }
4,662
func0
#include <stdio.h> #include <stdlib.h> #include <ctype.h> #include <assert.h>
int func0(const char *str) { int flag_l = 0; int flag_n = 0; while (*str) { if (isalpha((unsigned char)*str)) { flag_l = 1; } if (isdigit((unsigned char)*str)) { flag_n = 1; } str++; } return flag_l && flag_n; }
int main() { assert(func0("thishasboth29") == 1); assert(func0("python") == 0); assert(func0("string") == 0); return 0; }
O2
c
func0: endbr64 push %rbp push %rbx sub $0x8,%rsp movzbl (%rdi),%ebx test %bl,%bl je 1260 <func0+0x50> mov %rdi,%rbp callq 1070 <__ctype_b_loc@plt> xor %ecx,%ecx mov $0x1,%esi mov (%rax),%rdi xor %eax,%eax nopl (%rax) movzbl %bl,%ebx movzwl (%rdi,%rbx,2),%edx test $0x4,%dh cmovne %esi,%eax and $0x8,%dh cmovne %esi,%ecx movzbl 0x1(%rbp),%ebx add $0x1,%rbp test %bl,%bl jne 1238 <func0+0x28> add $0x8,%rsp and %ecx,%eax pop %rbx pop %rbp retq add $0x8,%rsp xor %eax,%eax pop %rbx pop %rbp retq nopl 0x0(%rax)
func0: endbr64 push rbp push rbx sub rsp, 8 movzx ebx, byte ptr [rdi] test bl, bl jz short loc_1260 mov rbp, rdi call ___ctype_b_loc xor ecx, ecx mov esi, 1 mov rdi, [rax] xor eax, eax nop dword ptr [rax] loc_1238: movzx edx, word ptr [rdi+rbx*2] test dh, 4 cmovnz eax, esi and dh, 8 cmovnz ecx, esi movzx ebx, byte ptr [rbp+1] add rbp, 1 test bl, bl jnz short loc_1238 add rsp, 8 and eax, ecx pop rbx pop rbp retn loc_1260: add rsp, 8 xor eax, eax pop rbx pop rbp retn
long long func0(unsigned __int8 *a1) { long long v1; // rbx unsigned __int8 *v2; // rbp long long *v3; // rax int v4; // ecx long long v5; // rdi int v6; // eax __int16 v7; // dx v1 = *a1; if ( !(_BYTE)v1 ) return 0LL; v2 = a1; v3 = (long long *)__ctype_b_loc(); v4 = 0; v5 = *v3; v6 = 0; do { v7 = *(_WORD *)(v5 + 2 * v1); if ( (v7 & 0x400) != 0 ) v6 = 1; if ( (v7 & 0x800) != 0 ) v4 = 1; v1 = *++v2; } while ( (_BYTE)v1 ); return v4 & (unsigned int)v6; }
func0: ENDBR64 PUSH RBP PUSH RBX SUB RSP,0x8 MOVZX EBX,byte ptr [RDI] TEST BL,BL JZ 0x00101260 MOV RBP,RDI CALL 0x00101070 XOR ECX,ECX MOV ESI,0x1 MOV RDI,qword ptr [RAX] XOR EAX,EAX NOP dword ptr [RAX] LAB_00101238: MOVZX EDX,word ptr [RDI + RBX*0x2] TEST DH,0x4 CMOVNZ EAX,ESI AND DH,0x8 CMOVNZ ECX,ESI MOVZX EBX,byte ptr [RBP + 0x1] ADD RBP,0x1 TEST BL,BL JNZ 0x00101238 ADD RSP,0x8 AND EAX,ECX POP RBX POP RBP RET LAB_00101260: ADD RSP,0x8 XOR EAX,EAX POP RBX POP RBP RET
uint func0(byte *param_1) { byte bVar1; uint uVar2; ushort **ppuVar3; uint uVar4; bVar1 = *param_1; if (bVar1 != 0) { ppuVar3 = __ctype_b_loc(); uVar4 = 0; uVar2 = 0; do { if (((*ppuVar3)[bVar1] & 0x400) != 0) { uVar2 = 1; } if (((*ppuVar3)[bVar1] & 0x800) != 0) { uVar4 = 1; } bVar1 = param_1[1]; param_1 = param_1 + 1; } while (bVar1 != 0); return uVar2 & uVar4; } return 0; }
4,663
func0
#include <stdio.h> #include <stdlib.h> #include <ctype.h> #include <assert.h>
int func0(const char *str) { int flag_l = 0; int flag_n = 0; while (*str) { if (isalpha((unsigned char)*str)) { flag_l = 1; } if (isdigit((unsigned char)*str)) { flag_n = 1; } str++; } return flag_l && flag_n; }
int main() { assert(func0("thishasboth29") == 1); assert(func0("python") == 0); assert(func0("string") == 0); return 0; }
O3
c
func0: endbr64 push %rbp push %rbx sub $0x8,%rsp movzbl (%rdi),%ebx test %bl,%bl je 1260 <func0+0x50> mov %rdi,%rbp callq 1070 <__ctype_b_loc@plt> xor %ecx,%ecx mov $0x1,%esi mov (%rax),%rdi xor %eax,%eax nopl (%rax) movzbl %bl,%ebx movzwl (%rdi,%rbx,2),%edx test $0x4,%dh cmovne %esi,%eax and $0x8,%dh cmovne %esi,%ecx movzbl 0x1(%rbp),%ebx add $0x1,%rbp test %bl,%bl jne 1238 <func0+0x28> add $0x8,%rsp and %ecx,%eax pop %rbx pop %rbp retq add $0x8,%rsp xor %eax,%eax pop %rbx pop %rbp retq nopl 0x0(%rax)
func0: endbr64 push rbp push rbx sub rsp, 8 movzx ebx, byte ptr [rdi] test bl, bl jz short loc_1260 mov rbp, rdi call ___ctype_b_loc xor ecx, ecx mov esi, 1 mov rdi, [rax] xor eax, eax nop dword ptr [rax] loc_1238: movzx ebx, bl movzx edx, word ptr [rdi+rbx*2] test dh, 4 cmovnz eax, esi and dh, 8 cmovnz ecx, esi movzx ebx, byte ptr [rbp+1] add rbp, 1 test bl, bl jnz short loc_1238 add rsp, 8 and eax, ecx pop rbx pop rbp retn loc_1260: add rsp, 8 xor eax, eax pop rbx pop rbp retn
long long func0(unsigned __int8 *a1) { unsigned __int8 v1; // bl unsigned __int8 *v2; // rbp const unsigned __int16 **v3; // rax int v4; // ecx const unsigned __int16 *v5; // rdi int v6; // eax unsigned __int16 v7; // dx v1 = *a1; if ( !*a1 ) return 0LL; v2 = a1; v3 = __ctype_b_loc(); v4 = 0; v5 = *v3; v6 = 0; do { v7 = v5[v1]; if ( (v7 & 0x400) != 0 ) v6 = 1; if ( (v7 & 0x800) != 0 ) v4 = 1; v1 = *++v2; } while ( v1 ); return v4 & (unsigned int)v6; }
func0: ENDBR64 PUSH RBP PUSH RBX SUB RSP,0x8 MOVZX EBX,byte ptr [RDI] TEST BL,BL JZ 0x00101260 MOV RBP,RDI CALL 0x00101070 XOR ECX,ECX MOV ESI,0x1 MOV RDI,qword ptr [RAX] XOR EAX,EAX NOP dword ptr [RAX] LAB_00101238: MOVZX EBX,BL MOVZX EDX,word ptr [RDI + RBX*0x2] TEST DH,0x4 CMOVNZ EAX,ESI AND DH,0x8 CMOVNZ ECX,ESI MOVZX EBX,byte ptr [RBP + 0x1] ADD RBP,0x1 TEST BL,BL JNZ 0x00101238 ADD RSP,0x8 AND EAX,ECX POP RBX POP RBP RET LAB_00101260: ADD RSP,0x8 XOR EAX,EAX POP RBX POP RBP RET
uint func0(byte *param_1) { uint uVar1; ushort **ppuVar2; uint uVar3; byte bVar4; bVar4 = *param_1; if (bVar4 != 0) { ppuVar2 = __ctype_b_loc(); uVar3 = 0; uVar1 = 0; do { if (((*ppuVar2)[bVar4] & 0x400) != 0) { uVar1 = 1; } if (((*ppuVar2)[bVar4] & 0x800) != 0) { uVar3 = 1; } bVar4 = param_1[1]; param_1 = param_1 + 1; } while (bVar4 != 0); return uVar1 & uVar3; } return 0; }
4,664
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h>
void func0(int *test_tup, int size, int **result, int *result_size) { int *temp_res = malloc(size * sizeof(int)); int count = 0; for (int i = 0; i < size; i++) { int j; for (j = 0; j < count; j++) { if (test_tup[i] == temp_res[j]) { break; } } if (j == count) { temp_res[count++] = test_tup[i]; } } *result = malloc(count * sizeof(int)); for (int i = 0; i < count; i++) { (*result)[i] = temp_res[i]; } *result_size = count; free(temp_res); }
int main() { int i; int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3}; int *res1; int res1_size; func0(tup1, 9, &res1, &res1_size); assert(res1_size == 4); for (i = 0; i < res1_size; i++) { assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5)); } free(res1); int tup2[] = {2, 3, 4, 4, 5, 6, 6, 7, 8, 8}; int *res2; int res2_size; func0(tup2, 10, &res2, &res2_size); assert(res2_size == 7); for (i = 0; i < res2_size; i++) { assert((res2[i] == 2) || (res2[i] == 3) || (res2[i] == 4) || (res2[i] == 5) || (res2[i] == 6) || (res2[i] == 7) || (res2[i] == 8)); } free(res2); int tup3[] = {11, 12, 13, 11, 11, 12, 14, 13}; int *res3; int res3_size; func0(tup3, 8, &res3, &res3_size); assert(res3_size == 4); for (i = 0; i < res3_size; i++) { assert((res3[i] == 11) || (res3[i] == 12) || (res3[i] == 13) || (res3[i] == 14)); } free(res3); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x40,%rsp mov %rdi,-0x28(%rbp) mov %esi,-0x2c(%rbp) mov %rdx,-0x38(%rbp) mov %rcx,-0x40(%rbp) mov -0x2c(%rbp),%eax cltq shl $0x2,%rax mov %rax,%rdi callq 10b0 <malloc@plt> mov %rax,-0x8(%rbp) movl $0x0,-0x18(%rbp) movl $0x0,-0x14(%rbp) jmpq 1273 <func0+0xca> movl $0x0,-0x10(%rbp) jmp 1229 <func0+0x80> mov -0x14(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax add %rdx,%rax mov (%rax),%edx mov -0x10(%rbp),%eax cltq lea 0x0(,%rax,4),%rcx mov -0x8(%rbp),%rax add %rcx,%rax mov (%rax),%eax cmp %eax,%edx je 1233 <func0+0x8a> addl $0x1,-0x10(%rbp) mov -0x10(%rbp),%eax cmp -0x18(%rbp),%eax jl 11f5 <func0+0x4c> jmp 1234 <func0+0x8b> mov -0x10(%rbp),%eax cmp -0x18(%rbp),%eax jne 126f <func0+0xc6> mov -0x14(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x28(%rbp),%rax lea (%rdx,%rax,1),%rcx mov -0x18(%rbp),%eax lea 0x1(%rax),%edx mov %edx,-0x18(%rbp) cltq lea 0x0(,%rax,4),%rdx mov -0x8(%rbp),%rax add %rax,%rdx mov (%rcx),%eax mov %eax,(%rdx) addl $0x1,-0x14(%rbp) mov -0x14(%rbp),%eax cmp -0x2c(%rbp),%eax jl 11ec <func0+0x43> mov -0x18(%rbp),%eax cltq shl $0x2,%rax mov %rax,%rdi callq 10b0 <malloc@plt> mov %rax,%rdx mov -0x38(%rbp),%rax mov %rdx,(%rax) movl $0x0,-0xc(%rbp) jmp 12d4 <func0+0x12b> mov -0xc(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x8(%rbp),%rax lea (%rdx,%rax,1),%rcx mov -0x38(%rbp),%rax mov (%rax),%rax mov -0xc(%rbp),%edx movslq %edx,%rdx shl $0x2,%rdx add %rax,%rdx mov (%rcx),%eax mov %eax,(%rdx) addl $0x1,-0xc(%rbp) mov -0xc(%rbp),%eax cmp -0x18(%rbp),%eax jl 12a3 <func0+0xfa> mov -0x40(%rbp),%rax mov -0x18(%rbp),%edx mov %edx,(%rax) mov -0x8(%rbp),%rax mov %rax,%rdi callq 1080 <free@plt> leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 40h mov [rbp+var_28], rdi mov [rbp+var_2C], esi mov [rbp+var_38], rdx mov [rbp+var_40], rcx mov eax, [rbp+var_2C] cdqe shl rax, 2 mov rdi, rax; size call _malloc mov [rbp+ptr], rax mov [rbp+var_18], 0 mov [rbp+var_14], 0 jmp loc_1273 loc_11EC: mov [rbp+var_10], 0 jmp short loc_1229 loc_11F5: mov eax, [rbp+var_14] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] add rax, rdx mov edx, [rax] mov eax, [rbp+var_10] cdqe lea rcx, ds:0[rax*4] mov rax, [rbp+ptr] add rax, rcx mov eax, [rax] cmp edx, eax jz short loc_1233 add [rbp+var_10], 1 loc_1229: mov eax, [rbp+var_10] cmp eax, [rbp+var_18] jl short loc_11F5 jmp short loc_1234 loc_1233: nop loc_1234: mov eax, [rbp+var_10] cmp eax, [rbp+var_18] jnz short loc_126F mov eax, [rbp+var_14] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_28] lea rcx, [rdx+rax] mov eax, [rbp+var_18] lea edx, [rax+1] mov [rbp+var_18], edx cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+ptr] add rdx, rax mov eax, [rcx] mov [rdx], eax loc_126F: add [rbp+var_14], 1 loc_1273: mov eax, [rbp+var_14] cmp eax, [rbp+var_2C] jl loc_11EC mov eax, [rbp+var_18] cdqe shl rax, 2 mov rdi, rax; size call _malloc mov rdx, rax mov rax, [rbp+var_38] mov [rax], rdx mov [rbp+var_C], 0 jmp short loc_12D4 loc_12A3: mov eax, [rbp+var_C] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+ptr] lea rcx, [rdx+rax] mov rax, [rbp+var_38] mov rax, [rax] mov edx, [rbp+var_C] movsxd rdx, edx shl rdx, 2 add rdx, rax mov eax, [rcx] mov [rdx], eax add [rbp+var_C], 1 loc_12D4: mov eax, [rbp+var_C] cmp eax, [rbp+var_18] jl short loc_12A3 mov rax, [rbp+var_40] mov edx, [rbp+var_18] mov [rax], edx mov rax, [rbp+ptr] mov rdi, rax; ptr call _free nop leave retn
void func0(long long a1, int a2, void **a3, _DWORD *a4) { int v4; // eax int v7; // [rsp+28h] [rbp-18h] int i; // [rsp+2Ch] [rbp-14h] int j; // [rsp+30h] [rbp-10h] int k; // [rsp+34h] [rbp-Ch] _DWORD *ptr; // [rsp+38h] [rbp-8h] ptr = malloc(4LL * a2); v7 = 0; for ( i = 0; i < a2; ++i ) { for ( j = 0; j < v7 && *(_DWORD *)(4LL * i + a1) != ptr[j]; ++j ) ; if ( j == v7 ) { v4 = v7++; ptr[v4] = *(_DWORD *)(4LL * i + a1); } } *a3 = malloc(4LL * v7); for ( k = 0; k < v7; ++k ) *((_DWORD *)*a3 + k) = ptr[k]; *a4 = v7; free(ptr); }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x40 MOV qword ptr [RBP + -0x28],RDI MOV dword ptr [RBP + -0x2c],ESI MOV qword ptr [RBP + -0x38],RDX MOV qword ptr [RBP + -0x40],RCX MOV EAX,dword ptr [RBP + -0x2c] CDQE SHL RAX,0x2 MOV RDI,RAX CALL 0x001010b0 MOV qword ptr [RBP + -0x8],RAX MOV dword ptr [RBP + -0x18],0x0 MOV dword ptr [RBP + -0x14],0x0 JMP 0x00101273 LAB_001011ec: MOV dword ptr [RBP + -0x10],0x0 JMP 0x00101229 LAB_001011f5: MOV EAX,dword ptr [RBP + -0x14] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] ADD RAX,RDX MOV EDX,dword ptr [RAX] MOV EAX,dword ptr [RBP + -0x10] CDQE LEA RCX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x8] ADD RAX,RCX MOV EAX,dword ptr [RAX] CMP EDX,EAX JZ 0x00101233 ADD dword ptr [RBP + -0x10],0x1 LAB_00101229: MOV EAX,dword ptr [RBP + -0x10] CMP EAX,dword ptr [RBP + -0x18] JL 0x001011f5 JMP 0x00101234 LAB_00101233: NOP LAB_00101234: MOV EAX,dword ptr [RBP + -0x10] CMP EAX,dword ptr [RBP + -0x18] JNZ 0x0010126f MOV EAX,dword ptr [RBP + -0x14] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x28] LEA RCX,[RDX + RAX*0x1] MOV EAX,dword ptr [RBP + -0x18] LEA EDX,[RAX + 0x1] MOV dword ptr [RBP + -0x18],EDX CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x8] ADD RDX,RAX MOV EAX,dword ptr [RCX] MOV dword ptr [RDX],EAX LAB_0010126f: ADD dword ptr [RBP + -0x14],0x1 LAB_00101273: MOV EAX,dword ptr [RBP + -0x14] CMP EAX,dword ptr [RBP + -0x2c] JL 0x001011ec MOV EAX,dword ptr [RBP + -0x18] CDQE SHL RAX,0x2 MOV RDI,RAX CALL 0x001010b0 MOV RDX,RAX MOV RAX,qword ptr [RBP + -0x38] MOV qword ptr [RAX],RDX MOV dword ptr [RBP + -0xc],0x0 JMP 0x001012d4 LAB_001012a3: MOV EAX,dword ptr [RBP + -0xc] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x8] LEA RCX,[RDX + RAX*0x1] MOV RAX,qword ptr [RBP + -0x38] MOV RAX,qword ptr [RAX] MOV EDX,dword ptr [RBP + -0xc] MOVSXD RDX,EDX SHL RDX,0x2 ADD RDX,RAX MOV EAX,dword ptr [RCX] MOV dword ptr [RDX],EAX ADD dword ptr [RBP + -0xc],0x1 LAB_001012d4: MOV EAX,dword ptr [RBP + -0xc] CMP EAX,dword ptr [RBP + -0x18] JL 0x001012a3 MOV RAX,qword ptr [RBP + -0x40] MOV EDX,dword ptr [RBP + -0x18] MOV dword ptr [RAX],EDX MOV RAX,qword ptr [RBP + -0x8] MOV RDI,RAX CALL 0x00101080 NOP LEAVE RET
void func0(long param_1,int param_2,long *param_3,int *param_4) { void *__ptr; void *pvVar1; int local_20; int local_1c; int local_18; int local_14; __ptr = malloc((long)param_2 << 2); local_20 = 0; for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) { local_18 = 0; while ((local_18 < local_20 && (*(int *)(param_1 + (long)local_1c * 4) != *(int *)((long)__ptr + (long)local_18 * 4)))) { local_18 = local_18 + 1; } if (local_18 == local_20) { *(int4 *)((long)local_20 * 4 + (long)__ptr) = *(int4 *)((long)local_1c * 4 + param_1); local_20 = local_20 + 1; } } pvVar1 = malloc((long)local_20 << 2); *param_3 = (long)pvVar1; for (local_14 = 0; local_14 < local_20; local_14 = local_14 + 1) { *(int4 *)((long)local_14 * 4 + *param_3) = *(int4 *)((long)local_14 * 4 + (long)__ptr); } *param_4 = local_20; free(__ptr); return; }
4,665
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h>
void func0(int *test_tup, int size, int **result, int *result_size) { int *temp_res = malloc(size * sizeof(int)); int count = 0; for (int i = 0; i < size; i++) { int j; for (j = 0; j < count; j++) { if (test_tup[i] == temp_res[j]) { break; } } if (j == count) { temp_res[count++] = test_tup[i]; } } *result = malloc(count * sizeof(int)); for (int i = 0; i < count; i++) { (*result)[i] = temp_res[i]; } *result_size = count; free(temp_res); }
int main() { int i; int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3}; int *res1; int res1_size; func0(tup1, 9, &res1, &res1_size); assert(res1_size == 4); for (i = 0; i < res1_size; i++) { assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5)); } free(res1); int tup2[] = {2, 3, 4, 4, 5, 6, 6, 7, 8, 8}; int *res2; int res2_size; func0(tup2, 10, &res2, &res2_size); assert(res2_size == 7); for (i = 0; i < res2_size; i++) { assert((res2[i] == 2) || (res2[i] == 3) || (res2[i] == 4) || (res2[i] == 5) || (res2[i] == 6) || (res2[i] == 7) || (res2[i] == 8)); } free(res2); int tup3[] = {11, 12, 13, 11, 11, 12, 14, 13}; int *res3; int res3_size; func0(tup3, 8, &res3, &res3_size); assert(res3_size == 4); for (i = 0; i < res3_size; i++) { assert((res3[i] == 11) || (res3[i] == 12) || (res3[i] == 13) || (res3[i] == 14)); } free(res3); return 0; }
O1
c
func0: endbr64 push %r14 push %r13 push %r12 push %rbp push %rbx mov %rdi,%r14 mov %esi,%ebp mov %rdx,%r12 mov %rcx,%r13 movslq %esi,%rdi shl $0x2,%rdi callq 10b0 <malloc@plt> mov %rax,%rbx test %ebp,%ebp jle 128b <func0+0xe2> mov %r14,%r8 lea -0x1(%rbp),%eax lea (%r14,%rax,4),%r9 mov $0x0,%ebp mov $0x0,%edx mov $0x0,%r11d mov $0x0,%r10d jmp 1213 <func0+0x6a> mov %rcx,%rax mov %eax,%edx cmp (%rbx,%rax,4),%esi je 120f <func0+0x66> lea 0x1(%rax),%edx lea 0x1(%rax),%rcx cmp %rdi,%rax jne 11f9 <func0+0x50> add $0x4,%r8 cmp %ebp,%edx je 122c <func0+0x83> cmp %r9,%r8 je 123f <func0+0x96> test %ebp,%ebp jle 123a <func0+0x91> mov 0x4(%r8),%esi lea -0x1(%rbp),%edi mov %r10,%rax jmp 11fc <func0+0x53> movslq %ebp,%rax mov (%r8),%edx mov %edx,(%rbx,%rax,4) lea 0x1(%rbp),%ebp jmp 1217 <func0+0x6e> mov %r11d,%edx jmp 120f <func0+0x66> movslq %ebp,%rdi shl $0x2,%rdi callq 10b0 <malloc@plt> mov %rax,(%r12) test %ebp,%ebp jle 1276 <func0+0xcd> lea -0x1(%rbp),%eax lea 0x4(,%rax,4),%rsi mov $0x0,%eax mov (%r12),%rdx mov (%rbx,%rax,1),%ecx mov %ecx,(%rdx,%rax,1) add $0x4,%rax cmp %rax,%rsi jne 1263 <func0+0xba> mov %ebp,0x0(%r13) mov %rbx,%rdi callq 1080 <free@plt> pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 retq mov $0x0,%edi callq 10b0 <malloc@plt> mov %rax,(%r12) mov $0x0,%ebp jmp 1276 <func0+0xcd>
func0: endbr64 push r14 push r13 push r12 push rbp push rbx mov r14, rdi mov ebx, esi mov r12, rdx mov r13, rcx movsxd rdi, esi shl rdi, 2 call _malloc mov rbp, rax test ebx, ebx jle loc_1277 mov rsi, r14 lea eax, [rbx-1] lea rdi, [r14+rax*4] mov ebx, 0 mov eax, 0 jmp short loc_1204 loc_11ED: movsxd rax, ebx mov edx, [rsi] mov [rbp+rax*4+0], edx lea ebx, [rbx+1] jmp short loc_1208 loc_11FB: mov eax, 0 loc_1200: add rsi, 4 loc_1204: cmp eax, ebx jz short loc_11ED loc_1208: cmp rsi, rdi jz short loc_122F test ebx, ebx jle short loc_11FB mov ecx, [rsi+4] mov rdx, rbp mov eax, 0 loc_121C: cmp ecx, [rdx] jz short loc_1200 add eax, 1 add rdx, 4 cmp ebx, eax jnz short loc_121C mov eax, ebx jmp short loc_1200 loc_122F: movsxd rdi, ebx shl rdi, 2 call _malloc mov [r12], rax test ebx, ebx jle short loc_1262 mov esi, ebx shl rsi, 2 mov eax, 0 loc_124E: mov rdx, [r12] mov ecx, [rbp+rax+0] mov [rdx+rax], ecx add rax, 4 cmp rsi, rax jnz short loc_124E loc_1262: mov [r13+0], ebx mov rdi, rbp call _free pop rbx pop rbp pop r12 pop r13 pop r14 retn loc_1277: mov edi, 0 call _malloc mov [r12], rax mov ebx, 0 jmp short loc_1262
long long func0(_DWORD *a1, int a2, _QWORD *a3, int *a4) { long long v7; // rbp _DWORD *v8; // rsi _DWORD *v9; // rdi int v10; // ebx int v11; // eax _DWORD *v12; // rdx long long v13; // rax v7 = malloc(4LL * a2); if ( a2 <= 0 ) { *a3 = malloc(0LL); v10 = 0; } else { v8 = a1; v9 = &a1[a2 - 1]; v10 = 0; v11 = 0; while ( 1 ) { if ( v11 == v10 ) *(_DWORD *)(v7 + 4LL * v10++) = *v8; if ( v8 == v9 ) break; if ( v10 <= 0 ) { v11 = 0; } else { v12 = (_DWORD *)v7; v11 = 0; while ( v8[1] != *v12 ) { ++v11; ++v12; if ( v10 == v11 ) { v11 = v10; break; } } } ++v8; } *a3 = malloc(4LL * v10); if ( v10 > 0 ) { v13 = 0LL; do { *(_DWORD *)(*a3 + v13) = *(_DWORD *)(v7 + v13); v13 += 4LL; } while ( 4LL * (unsigned int)v10 != v13 ); } } *a4 = v10; return free(v7); }
func0: ENDBR64 PUSH R14 PUSH R13 PUSH R12 PUSH RBP PUSH RBX MOV R14,RDI MOV EBX,ESI MOV R12,RDX MOV R13,RCX MOVSXD RDI,ESI SHL RDI,0x2 CALL 0x001010b0 MOV RBP,RAX TEST EBX,EBX JLE 0x00101277 MOV RSI,R14 LEA EAX,[RBX + -0x1] LEA RDI,[R14 + RAX*0x4] MOV EBX,0x0 MOV EAX,0x0 JMP 0x00101204 LAB_001011ed: MOVSXD RAX,EBX MOV EDX,dword ptr [RSI] MOV dword ptr [RBP + RAX*0x4],EDX LEA EBX,[RBX + 0x1] JMP 0x00101208 LAB_001011fb: MOV EAX,0x0 LAB_00101200: ADD RSI,0x4 LAB_00101204: CMP EAX,EBX JZ 0x001011ed LAB_00101208: CMP RSI,RDI JZ 0x0010122f TEST EBX,EBX JLE 0x001011fb MOV ECX,dword ptr [RSI + 0x4] MOV RDX,RBP MOV EAX,0x0 LAB_0010121c: CMP ECX,dword ptr [RDX] JZ 0x00101200 ADD EAX,0x1 ADD RDX,0x4 CMP EBX,EAX JNZ 0x0010121c MOV EAX,EBX JMP 0x00101200 LAB_0010122f: MOVSXD RDI,EBX SHL RDI,0x2 CALL 0x001010b0 MOV qword ptr [R12],RAX TEST EBX,EBX JLE 0x00101262 MOV ESI,EBX SHL RSI,0x2 MOV EAX,0x0 LAB_0010124e: MOV RDX,qword ptr [R12] MOV ECX,dword ptr [RBP + RAX*0x1] MOV dword ptr [RDX + RAX*0x1],ECX ADD RAX,0x4 CMP RSI,RAX JNZ 0x0010124e LAB_00101262: MOV dword ptr [R13],EBX MOV RDI,RBP CALL 0x00101080 POP RBX POP RBP POP R12 POP R13 POP R14 RET LAB_00101277: MOV EDI,0x0 CALL 0x001010b0 MOV qword ptr [R12],RAX MOV EBX,0x0 JMP 0x00101262
void func0(int *param_1,int param_2,long *param_3,uint *param_4) { int *piVar1; uint uVar2; uint uVar3; int *__ptr; void *pvVar4; long lVar5; int *piVar6; uint uVar7; __ptr = (int *)malloc((long)param_2 << 2); if (param_2 < 1) { pvVar4 = malloc(0); *param_3 = (long)pvVar4; uVar7 = 0; } else { piVar1 = param_1 + (param_2 - 1); uVar7 = 0; uVar2 = 0; while( true ) { if (uVar2 == uVar7) { __ptr[(int)uVar7] = *param_1; uVar7 = uVar7 + 1; } if (param_1 == piVar1) break; if ((int)uVar7 < 1) { uVar2 = 0; } else { uVar3 = 0; piVar6 = __ptr; do { uVar2 = uVar3; if (param_1[1] == *piVar6) break; uVar3 = uVar3 + 1; piVar6 = piVar6 + 1; uVar2 = uVar7; } while (uVar7 != uVar3); } param_1 = param_1 + 1; } pvVar4 = malloc((long)(int)uVar7 << 2); *param_3 = (long)pvVar4; if (0 < (int)uVar7) { lVar5 = 0; do { *(int4 *)(*param_3 + lVar5) = *(int4 *)((long)__ptr + lVar5); lVar5 = lVar5 + 4; } while ((ulong)uVar7 << 2 != lVar5); } } *param_4 = uVar7; free(__ptr); return; }
4,666
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h>
void func0(int *test_tup, int size, int **result, int *result_size) { int *temp_res = malloc(size * sizeof(int)); int count = 0; for (int i = 0; i < size; i++) { int j; for (j = 0; j < count; j++) { if (test_tup[i] == temp_res[j]) { break; } } if (j == count) { temp_res[count++] = test_tup[i]; } } *result = malloc(count * sizeof(int)); for (int i = 0; i < count; i++) { (*result)[i] = temp_res[i]; } *result_size = count; free(temp_res); }
int main() { int i; int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3}; int *res1; int res1_size; func0(tup1, 9, &res1, &res1_size); assert(res1_size == 4); for (i = 0; i < res1_size; i++) { assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5)); } free(res1); int tup2[] = {2, 3, 4, 4, 5, 6, 6, 7, 8, 8}; int *res2; int res2_size; func0(tup2, 10, &res2, &res2_size); assert(res2_size == 7); for (i = 0; i < res2_size; i++) { assert((res2[i] == 2) || (res2[i] == 3) || (res2[i] == 4) || (res2[i] == 5) || (res2[i] == 6) || (res2[i] == 7) || (res2[i] == 8)); } free(res2); int tup3[] = {11, 12, 13, 11, 11, 12, 14, 13}; int *res3; int res3_size; func0(tup3, 8, &res3, &res3_size); assert(res3_size == 4); for (i = 0; i < res3_size; i++) { assert((res3[i] == 11) || (res3[i] == 12) || (res3[i] == 13) || (res3[i] == 14)); } free(res3); return 0; }
O2
c
func0: endbr64 push %r14 mov %rdi,%r14 movslq %esi,%rdi push %r13 mov %rdi,%r13 shl $0x2,%rdi push %r12 mov %rdx,%r12 push %rbp push %rbx mov %rcx,%rbx callq 10b0 <malloc@plt> mov %rax,%rbp test %r13d,%r13d jle 1560 <func0+0xf0> lea -0x1(%r13),%eax mov %r14,%rdi xor %r13d,%r13d lea 0x4(%r14,%rax,4),%r9 xor %esi,%esi test %r13d,%r13d jle 1540 <func0+0xd0> lea -0x1(%r13),%edx mov (%rdi),%ecx mov $0x1,%eax add $0x2,%rdx jmp 14db <func0+0x6b> nopl 0x0(%rax) mov %eax,%esi add $0x1,%rax cmp %rax,%rdx je 1540 <func0+0xd0> cmp -0x4(%rbp,%rax,4),%ecx jne 14d0 <func0+0x60> movslq %r13d,%r8 shl $0x2,%r8 add $0x4,%rdi cmp %rdi,%r9 jne 14b0 <func0+0x40> mov %r8,%rdi callq 10b0 <malloc@plt> mov %rax,(%r12) test %r13d,%r13d jle 1523 <func0+0xb3> lea -0x1(%r13),%esi xor %edx,%edx nopl 0x0(%rax,%rax,1) mov 0x0(%rbp,%rdx,4),%ecx mov %ecx,(%rax,%rdx,4) mov %rdx,%rcx add $0x1,%rdx cmp %rcx,%rsi jne 1510 <func0+0xa0> mov %r13d,(%rbx) mov %rbp,%rdi pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 jmpq 1080 <free@plt> nopw %cs:0x0(%rax,%rax,1) movslq %r13d,%rax lea 0x0(,%rax,4),%r8 cmp %esi,%r13d jne 14e8 <func0+0x78> mov (%rdi),%edx add $0x1,%r13d add $0x4,%r8 mov %edx,0x0(%rbp,%rax,4) jmp 14e8 <func0+0x78> xor %edi,%edi xor %r13d,%r13d callq 10b0 <malloc@plt> mov %rax,(%r12) jmp 1523 <func0+0xb3>
func0: endbr64 push r14 push r13 mov r13, rdi movsxd rdi, esi push r12 mov r14, rdi shl rdi, 2 mov r12, rdx push rbp push rbx mov rbx, rcx call _malloc mov rbp, rax test r14d, r14d jle loc_1561 lea eax, [r14-1] mov rdi, r13 lea r8, [r13+rax*4+4] xor r13d, r13d nop loc_14D0: xor esi, esi test r13d, r13d jle short loc_1540 mov edx, [rdi] lea ecx, [r13+1] mov eax, 1 jmp short loc_14F3 loc_14E8: mov esi, eax add rax, 1 cmp rcx, rax jz short loc_1540 loc_14F3: cmp edx, [rbp+rax*4-4] jnz short loc_14E8 loc_14F9: add rdi, 4 cmp rdi, r8 jnz short loc_14D0 loc_1502: movsxd r14, r13d shl r14, 2 mov rdi, r14 call _malloc mov [r12], rax mov rdi, rax test r13d, r13d jle short loc_1528 mov rdx, r14 mov rsi, rbp call _memcpy loc_1528: mov [rbx], r13d mov rdi, rbp pop rbx pop rbp pop r12 pop r13 pop r14 jmp _free loc_1540: cmp r13d, esi jnz short loc_14F9 mov edx, [rdi] movsxd rax, r13d add rdi, 4 add r13d, 1 mov [rbp+rax*4+0], edx cmp rdi, r8 jnz loc_14D0 jmp short loc_1502 loc_1561: xor edi, edi xor r13d, r13d call _malloc mov [r12], rax jmp short loc_1528
long long func0(int *a1, long long a2, long long *a3, int *a4) { long long v6; // rbp long long v7; // r8 int v8; // r13d long long v9; // rax long long v10; // rax int v12; // edx long long v13; // rax v6 = malloc(4LL * (int)a2); if ( (int)a2 <= 0 ) { v8 = 0; *a3 = malloc(0LL); goto LABEL_10; } v7 = (long long)&a1[(unsigned int)(a2 - 1) + 1]; v8 = 0; do { while ( 1 ) { a2 = 0LL; if ( v8 > 0 ) { v9 = 1LL; while ( *a1 != *(_DWORD *)(v6 + 4 * v9 - 4) ) { a2 = (unsigned int)v9++; if ( v8 + 1 == v9 ) goto LABEL_11; } goto LABEL_7; } LABEL_11: if ( v8 == (_DWORD)a2 ) break; LABEL_7: if ( ++a1 == (int *)v7 ) goto LABEL_8; } v12 = *a1; v13 = v8; ++a1; ++v8; *(_DWORD *)(v6 + 4 * v13) = v12; } while ( a1 != (int *)v7 ); LABEL_8: v10 = malloc(4LL * v8); *a3 = v10; if ( v8 > 0 ) { a2 = v6; memcpy(v10, v6, 4LL * v8); } LABEL_10: *a4 = v8; return free(v6, a2); }
func0: ENDBR64 PUSH R14 PUSH R13 MOV R13,RDI MOVSXD RDI,ESI PUSH R12 MOV R14,RDI SHL RDI,0x2 MOV R12,RDX PUSH RBP PUSH RBX MOV RBX,RCX CALL 0x001010d0 MOV RBP,RAX TEST R14D,R14D JLE 0x00101561 LEA EAX,[R14 + -0x1] MOV RDI,R13 LEA R8,[R13 + RAX*0x4 + 0x4] XOR R13D,R13D NOP LAB_001014d0: XOR ESI,ESI TEST R13D,R13D JLE 0x00101540 MOV EDX,dword ptr [RDI] LEA ECX,[R13 + 0x1] MOV EAX,0x1 JMP 0x001014f3 LAB_001014e8: MOV ESI,EAX ADD RAX,0x1 CMP RCX,RAX JZ 0x00101540 LAB_001014f3: CMP EDX,dword ptr [RBP + RAX*0x4 + -0x4] JNZ 0x001014e8 LAB_001014f9: ADD RDI,0x4 CMP RDI,R8 JNZ 0x001014d0 LAB_00101502: MOVSXD R14,R13D SHL R14,0x2 MOV RDI,R14 CALL 0x001010d0 MOV qword ptr [R12],RAX MOV RDI,RAX TEST R13D,R13D JLE 0x00101528 MOV RDX,R14 MOV RSI,RBP CALL 0x001010c0 LAB_00101528: MOV dword ptr [RBX],R13D MOV RDI,RBP POP RBX POP RBP POP R12 POP R13 POP R14 JMP 0x00101090 LAB_00101540: CMP R13D,ESI JNZ 0x001014f9 MOV EDX,dword ptr [RDI] MOVSXD RAX,R13D ADD RDI,0x4 ADD R13D,0x1 MOV dword ptr [RBP + RAX*0x4],EDX CMP RDI,R8 JNZ 0x001014d0 JMP 0x00101502 LAB_00101561: XOR EDI,EDI XOR R13D,R13D CALL 0x001010d0 MOV qword ptr [R12],RAX JMP 0x00101528
void func0(int *param_1,int param_2,int8 *param_3,int *param_4) { int *piVar1; void *__src; ulong uVar2; void *pvVar3; long lVar4; int iVar5; int iVar6; __src = malloc((long)param_2 << 2); if (param_2 < 1) { iVar6 = 0; pvVar3 = malloc(0); *param_3 = pvVar3; } else { piVar1 = param_1 + (ulong)(param_2 - 1) + 1; iVar6 = 0; do { while( true ) { iVar5 = 0; if (0 < iVar6) { uVar2 = 1; do { if (*param_1 == *(int *)((long)__src + uVar2 * 4 + -4)) goto LAB_001014f9; iVar5 = (int)uVar2; uVar2 = uVar2 + 1; } while (iVar6 + 1 != uVar2); } if (iVar6 == iVar5) break; LAB_001014f9: param_1 = param_1 + 1; if (param_1 == piVar1) goto LAB_00101502; } iVar5 = *param_1; lVar4 = (long)iVar6; param_1 = param_1 + 1; iVar6 = iVar6 + 1; *(int *)((long)__src + lVar4 * 4) = iVar5; } while (param_1 != piVar1); LAB_00101502: pvVar3 = malloc((long)iVar6 << 2); *param_3 = pvVar3; if (0 < iVar6) { memcpy(pvVar3,__src,(long)iVar6 << 2); } } *param_4 = iVar6; free(__src); return; }
4,667
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h>
void func0(int *test_tup, int size, int **result, int *result_size) { int *temp_res = malloc(size * sizeof(int)); int count = 0; for (int i = 0; i < size; i++) { int j; for (j = 0; j < count; j++) { if (test_tup[i] == temp_res[j]) { break; } } if (j == count) { temp_res[count++] = test_tup[i]; } } *result = malloc(count * sizeof(int)); for (int i = 0; i < count; i++) { (*result)[i] = temp_res[i]; } *result_size = count; free(temp_res); }
int main() { int i; int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3}; int *res1; int res1_size; func0(tup1, 9, &res1, &res1_size); assert(res1_size == 4); for (i = 0; i < res1_size; i++) { assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5)); } free(res1); int tup2[] = {2, 3, 4, 4, 5, 6, 6, 7, 8, 8}; int *res2; int res2_size; func0(tup2, 10, &res2, &res2_size); assert(res2_size == 7); for (i = 0; i < res2_size; i++) { assert((res2[i] == 2) || (res2[i] == 3) || (res2[i] == 4) || (res2[i] == 5) || (res2[i] == 6) || (res2[i] == 7) || (res2[i] == 8)); } free(res2); int tup3[] = {11, 12, 13, 11, 11, 12, 14, 13}; int *res3; int res3_size; func0(tup3, 8, &res3, &res3_size); assert(res3_size == 4); for (i = 0; i < res3_size; i++) { assert((res3[i] == 11) || (res3[i] == 12) || (res3[i] == 13) || (res3[i] == 14)); } free(res3); return 0; }
O3
c
func0: endbr64 push %r14 mov %rdi,%r14 movslq %esi,%rdi push %r13 mov %rdi,%r13 shl $0x2,%rdi push %r12 push %rbp mov %rdx,%rbp push %rbx mov %rcx,%rbx callq 10d0 <malloc@plt> mov %rax,%r12 test %r13d,%r13d jle 1590 <func0+0xe0> lea -0x1(%r13),%eax mov %r14,%rdi xor %r13d,%r13d lea 0x4(%r14,%rax,4),%r9 xor %esi,%esi test %r13d,%r13d jle 1570 <func0+0xc0> lea -0x1(%r13),%edx mov (%rdi),%ecx mov $0x1,%eax add $0x2,%rdx jmp 151b <func0+0x6b> nopl 0x0(%rax,%rax,1) mov %eax,%esi add $0x1,%rax cmp %rax,%rdx je 1570 <func0+0xc0> cmp -0x4(%r12,%rax,4),%ecx jne 1510 <func0+0x60> movslq %r13d,%r8 shl $0x2,%r8 add $0x4,%rdi cmp %r9,%rdi jne 14f0 <func0+0x40> mov %r8,%rdi callq 10d0 <malloc@plt> mov %rax,0x0(%rbp) mov %rax,%rdi test %r13d,%r13d jle 155a <func0+0xaa> lea -0x1(%r13),%eax mov %r12,%rsi lea 0x4(,%rax,4),%rdx callq 10c0 <memcpy@plt> mov %r13d,(%rbx) mov %r12,%rdi pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 jmpq 1090 <free@plt> nopl (%rax) movslq %r13d,%rax lea 0x0(,%rax,4),%r8 cmp %esi,%r13d jne 1529 <func0+0x79> mov (%rdi),%edx add $0x1,%r13d add $0x4,%r8 mov %edx,(%r12,%rax,4) jmp 1529 <func0+0x79> xor %edi,%edi xor %r13d,%r13d callq 10d0 <malloc@plt> mov %rax,0x0(%rbp) jmp 155a <func0+0xaa>
func0: endbr64 push r15 push r14 push r13 mov r13, rdi movsxd rdi, esi push r12 mov r15, rdi mov r12, rdx push rbp mov rbp, rcx push rbx lea rbx, ds:0[rdi*4] mov rdi, rbx; size sub rsp, 8 call _malloc mov r14, rax test r15d, r15d jle loc_15A3 lea rdi, [r13+rbx+0] mov rsi, r13 xor ebx, ebx loc_14F7: xor eax, eax test ebx, ebx jle short loc_151F loc_14FD: mov ecx, [rsi] mov rdx, r14 xor eax, eax jmp short loc_151B loc_1510: add eax, 1 add rdx, 4 cmp eax, ebx jz short loc_1570 loc_151B: cmp ecx, [rdx] jnz short loc_1510 loc_151F: cmp ebx, eax jz short loc_1570 add rsi, 4 cmp rsi, rdi jnz short loc_14F7 movsxd rdi, ebx shl rdi, 2; size call _malloc mov [r12], rax mov rdi, rax; dest test ebx, ebx jle short loc_1551 loc_1543: mov edx, ebx mov rsi, r14; src shl rdx, 2; n call _memcpy loc_1551: mov [rbp+0], ebx add rsp, 8 mov rdi, r14; ptr pop rbx pop rbp pop r12 pop r13 pop r14 pop r15 jmp _free loc_1570: mov eax, [rsi] add rsi, 4 lea r13d, [rbx+1] mov [r14+rbx*4], eax cmp rdi, rsi jz short loc_158B movsxd rbx, r13d jmp loc_14FD loc_158B: movsxd rdi, r13d mov ebx, r13d shl rdi, 2; size call _malloc mov [r12], rax mov rdi, rax jmp short loc_1543 loc_15A3: xor edi, edi; size xor ebx, ebx call _malloc mov [r12], rax jmp short loc_1551
void func0(int *a1, int a2, void **a3, _DWORD *a4) { _DWORD *v7; // r14 int *v8; // rdi int *v9; // rsi long long v10; // rbx int v11; // eax _DWORD *v12; // rdx void *v13; // rax void *v14; // rdi int v15; // eax int v16; // r13d void *v17; // rax v7 = malloc(4LL * a2); if ( a2 <= 0 ) { LODWORD(v10) = 0; *a3 = malloc(0LL); goto LABEL_11; } v8 = &a1[a2]; v9 = a1; v10 = 0LL; LABEL_3: v11 = 0; if ( (int)v10 <= 0 ) goto LABEL_7; while ( 1 ) { v12 = v7; v11 = 0; while ( *v9 != *v12 ) { ++v11; ++v12; if ( v11 == (_DWORD)v10 ) goto LABEL_12; } LABEL_7: if ( (_DWORD)v10 != v11 ) { if ( ++v9 == v8 ) { v13 = malloc(4LL * (int)v10); *a3 = v13; v14 = v13; if ( (int)v10 > 0 ) goto LABEL_10; goto LABEL_11; } goto LABEL_3; } LABEL_12: v15 = *v9++; v16 = v10 + 1; v7[v10] = v15; if ( v8 == v9 ) break; v10 = v16; } LODWORD(v10) = v10 + 1; v17 = malloc(4LL * v16); *a3 = v17; v14 = v17; LABEL_10: memcpy(v14, v7, 4LL * (unsigned int)v10); LABEL_11: *a4 = v10; free(v7); }
func0: ENDBR64 PUSH R15 PUSH R14 PUSH R13 MOV R13,RDI MOVSXD RDI,ESI PUSH R12 MOV R15,RDI MOV R12,RDX PUSH RBP MOV RBP,RCX PUSH RBX LEA RBX,[RDI*0x4] MOV RDI,RBX SUB RSP,0x8 CALL 0x001010d0 MOV R14,RAX TEST R15D,R15D JLE 0x001015a3 LEA RDI,[R13 + RBX*0x1] MOV RSI,R13 XOR EBX,EBX LAB_001014f7: XOR EAX,EAX TEST EBX,EBX JLE 0x0010151f LAB_001014fd: MOV ECX,dword ptr [RSI] MOV RDX,R14 XOR EAX,EAX JMP 0x0010151b LAB_00101510: ADD EAX,0x1 ADD RDX,0x4 CMP EAX,EBX JZ 0x00101570 LAB_0010151b: CMP ECX,dword ptr [RDX] JNZ 0x00101510 LAB_0010151f: CMP EBX,EAX JZ 0x00101570 ADD RSI,0x4 CMP RSI,RDI JNZ 0x001014f7 MOVSXD RDI,EBX SHL RDI,0x2 CALL 0x001010d0 MOV qword ptr [R12],RAX MOV RDI,RAX TEST EBX,EBX JLE 0x00101551 LAB_00101543: MOV EDX,EBX MOV RSI,R14 SHL RDX,0x2 CALL 0x001010c0 LAB_00101551: MOV dword ptr [RBP],EBX ADD RSP,0x8 MOV RDI,R14 POP RBX POP RBP POP R12 POP R13 POP R14 POP R15 JMP 0x00101090 LAB_00101570: MOV EAX,dword ptr [RSI] ADD RSI,0x4 LEA R13D,[RBX + 0x1] MOV dword ptr [R14 + RBX*0x4],EAX CMP RDI,RSI JZ 0x0010158b MOVSXD RBX,R13D JMP 0x001014fd LAB_0010158b: MOVSXD RDI,R13D MOV EBX,R13D SHL RDI,0x2 CALL 0x001010d0 MOV qword ptr [R12],RAX MOV RDI,RAX JMP 0x00101543 LAB_001015a3: XOR EDI,EDI XOR EBX,EBX CALL 0x001010d0 MOV qword ptr [R12],RAX JMP 0x00101551
void func0(int *param_1,int param_2,int8 *param_3,int4 *param_4) { int *piVar1; int iVar2; int *__src; void *pvVar3; int *piVar4; int iVar5; ulong uVar6; uint uVar7; __src = (int *)malloc((long)param_2 * 4); if (0 < param_2) { piVar1 = param_1 + param_2; uVar6 = 0; LAB_001014f7: iVar2 = 0; if ((int)uVar6 < 1) goto LAB_0010151f; LAB_001014fd: iVar2 = 0; piVar4 = __src; do { if (*param_1 == *piVar4) goto LAB_0010151f; iVar2 = iVar2 + 1; piVar4 = piVar4 + 1; } while (iVar2 != (int)uVar6); goto LAB_00101570; } uVar6 = 0; pvVar3 = malloc(0); *param_3 = pvVar3; LAB_00101551: *param_4 = (int)uVar6; free(__src); return; LAB_0010151f: iVar5 = (int)uVar6; if (iVar5 != iVar2) goto code_r0x00101523; LAB_00101570: iVar2 = *param_1; param_1 = param_1 + 1; uVar7 = (int)uVar6 + 1; __src[uVar6] = iVar2; if (piVar1 == param_1) { uVar6 = (ulong)uVar7; pvVar3 = malloc((long)(int)uVar7 << 2); *param_3 = pvVar3; goto LAB_00101543; } uVar6 = (ulong)(int)uVar7; goto LAB_001014fd; code_r0x00101523: param_1 = param_1 + 1; if (param_1 == piVar1) goto code_r0x0010152c; goto LAB_001014f7; code_r0x0010152c: pvVar3 = malloc((long)iVar5 << 2); *param_3 = pvVar3; if (0 < iVar5) { LAB_00101543: memcpy(pvVar3,__src,(uVar6 & 0xffffffff) << 2); } goto LAB_00101551; }
4,668
func0
#include <assert.h>
int func0(int n) { int num = n; int dec_value = 0; int base = 1; int temp = num; while (temp) { int last_digit = temp % 10; temp = temp / 10; dec_value += last_digit * base; base = base * 8; } return dec_value; }
int main() { assert(func0(25) == 21); assert(func0(30) == 24); assert(func0(40) == 32); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %edi,-0x24(%rbp) mov -0x24(%rbp),%eax mov %eax,-0x8(%rbp) movl $0x0,-0x14(%rbp) movl $0x1,-0x10(%rbp) mov -0x8(%rbp),%eax mov %eax,-0xc(%rbp) jmp 11c9 <func0+0x80> mov -0xc(%rbp),%edx movslq %edx,%rax imul $0x66666667,%rax,%rax shr $0x20,%rax mov %eax,%ecx sar $0x2,%ecx mov %edx,%eax sar $0x1f,%eax sub %eax,%ecx mov %ecx,%eax shl $0x2,%eax add %ecx,%eax add %eax,%eax sub %eax,%edx mov %edx,%eax mov %eax,-0x4(%rbp) mov -0xc(%rbp),%eax movslq %eax,%rdx imul $0x66666667,%rdx,%rdx shr $0x20,%rdx sar $0x2,%edx sar $0x1f,%eax sub %eax,%edx mov %edx,%eax mov %eax,-0xc(%rbp) mov -0x4(%rbp),%eax imul -0x10(%rbp),%eax add %eax,-0x14(%rbp) shll $0x3,-0x10(%rbp) cmpl $0x0,-0xc(%rbp) jne 1170 <func0+0x27> mov -0x14(%rbp),%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_24], edi mov eax, [rbp+var_24] mov [rbp+var_8], eax mov [rbp+var_14], 0 mov [rbp+var_10], 1 mov eax, [rbp+var_8] mov [rbp+var_C], eax jmp short loc_11C7 loc_1170: mov edx, [rbp+var_C] movsxd rax, edx imul rax, 66666667h shr rax, 20h mov ecx, eax sar ecx, 2 mov eax, edx sar eax, 1Fh sub ecx, eax mov eax, ecx shl eax, 2 add eax, ecx add eax, eax sub edx, eax mov [rbp+var_4], edx mov eax, [rbp+var_C] movsxd rdx, eax imul rdx, 66666667h shr rdx, 20h mov ecx, edx sar ecx, 2 cdq mov eax, ecx sub eax, edx mov [rbp+var_C], eax mov eax, [rbp+var_4] imul eax, [rbp+var_10] add [rbp+var_14], eax shl [rbp+var_10], 3 loc_11C7: cmp [rbp+var_C], 0 jnz short loc_1170 mov eax, [rbp+var_14] pop rbp retn
long long func0(int a1) { unsigned int v2; // [rsp+10h] [rbp-14h] int v3; // [rsp+14h] [rbp-10h] int v5; // [rsp+20h] [rbp-4h] v2 = 0; v3 = 1; while ( a1 ) { v5 = a1 % 10; a1 /= 10; v2 += v3 * v5; v3 *= 8; } return v2; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV dword ptr [RBP + -0x24],EDI MOV EAX,dword ptr [RBP + -0x24] MOV dword ptr [RBP + -0x8],EAX MOV dword ptr [RBP + -0x14],0x0 MOV dword ptr [RBP + -0x10],0x1 MOV EAX,dword ptr [RBP + -0x8] MOV dword ptr [RBP + -0xc],EAX JMP 0x001011c7 LAB_00101170: MOV EDX,dword ptr [RBP + -0xc] MOVSXD RAX,EDX IMUL RAX,RAX,0x66666667 SHR RAX,0x20 MOV ECX,EAX SAR ECX,0x2 MOV EAX,EDX SAR EAX,0x1f SUB ECX,EAX MOV EAX,ECX SHL EAX,0x2 ADD EAX,ECX ADD EAX,EAX SUB EDX,EAX MOV dword ptr [RBP + -0x4],EDX MOV EAX,dword ptr [RBP + -0xc] MOVSXD RDX,EAX IMUL RDX,RDX,0x66666667 SHR RDX,0x20 MOV ECX,EDX SAR ECX,0x2 CDQ MOV EAX,ECX SUB EAX,EDX MOV dword ptr [RBP + -0xc],EAX MOV EAX,dword ptr [RBP + -0x4] IMUL EAX,dword ptr [RBP + -0x10] ADD dword ptr [RBP + -0x14],EAX SHL dword ptr [RBP + -0x10],0x3 LAB_001011c7: CMP dword ptr [RBP + -0xc],0x0 JNZ 0x00101170 MOV EAX,dword ptr [RBP + -0x14] POP RBP RET
int func0(int param_1) { int4 local_1c; int4 local_18; int4 local_14; local_1c = 0; local_18 = 1; for (local_14 = param_1; local_14 != 0; local_14 = local_14 / 10) { local_1c = local_1c + (local_14 % 10) * local_18; local_18 = local_18 << 3; } return local_1c; }
4,669
func0
#include <assert.h>
int func0(int n) { int num = n; int dec_value = 0; int base = 1; int temp = num; while (temp) { int last_digit = temp % 10; temp = temp / 10; dec_value += last_digit * base; base = base * 8; } return dec_value; }
int main() { assert(func0(25) == 21); assert(func0(30) == 24); assert(func0(40) == 32); return 0; }
O1
c
func0: endbr64 test %edi,%edi je 118c <func0+0x43> mov $0x1,%edx mov $0x0,%esi movslq %edi,%rax imul $0x66666667,%rax,%rax sar $0x22,%rax mov %edi,%ecx sar $0x1f,%ecx sub %ecx,%eax mov %eax,%ecx lea (%rax,%rax,4),%eax add %eax,%eax sub %eax,%edi mov %edi,%eax mov %ecx,%edi imul %edx,%eax add %eax,%esi shl $0x3,%edx test %ecx,%ecx jne 115b <func0+0x12> mov %esi,%eax retq mov %edi,%esi jmp 1189 <func0+0x40>
func0: endbr64 test edi, edi jz short loc_118F mov ecx, 1 mov r8d, 0 loc_115C: movsxd rax, edi imul rax, 66666667h sar rax, 22h mov edx, edi sar edx, 1Fh sub eax, edx mov esi, eax lea edx, [rax+rax*4] add edx, edx mov eax, edi sub eax, edx mov edi, esi imul eax, ecx add r8d, eax shl ecx, 3 test esi, esi jnz short loc_115C loc_118B: mov eax, r8d retn loc_118F: mov r8d, edi jmp short loc_118B
long long func0(int a1) { int v1; // ecx unsigned int v2; // r8d int v3; // eax if ( a1 ) { v1 = 1; v2 = 0; do { v3 = a1 % 10; a1 /= 10; v2 += v1 * v3; v1 *= 8; } while ( a1 ); } else { return 0; } return v2; }
func0: ENDBR64 TEST EDI,EDI JZ 0x0010118f MOV ECX,0x1 MOV R8D,0x0 LAB_0010115c: MOVSXD RAX,EDI IMUL RAX,RAX,0x66666667 SAR RAX,0x22 MOV EDX,EDI SAR EDX,0x1f SUB EAX,EDX MOV ESI,EAX LEA EDX,[RAX + RAX*0x4] ADD EDX,EDX MOV EAX,EDI SUB EAX,EDX MOV EDI,ESI IMUL EAX,ECX ADD R8D,EAX SHL ECX,0x3 TEST ESI,ESI JNZ 0x0010115c LAB_0010118b: MOV EAX,R8D RET LAB_0010118f: MOV R8D,EDI JMP 0x0010118b
int func0(int param_1) { int iVar1; int iVar2; int iVar3; if (param_1 == 0) { iVar3 = 0; } else { iVar2 = 1; iVar3 = 0; do { iVar1 = param_1 / 10; iVar3 = iVar3 + (param_1 % 10) * iVar2; iVar2 = iVar2 << 3; param_1 = iVar1; } while (iVar1 != 0); } return iVar3; }
4,670
func0
#include <assert.h>
int func0(int n) { int num = n; int dec_value = 0; int base = 1; int temp = num; while (temp) { int last_digit = temp % 10; temp = temp / 10; dec_value += last_digit * base; base = base * 8; } return dec_value; }
int main() { assert(func0(25) == 21); assert(func0(30) == 24); assert(func0(40) == 32); return 0; }
O2
c
func0: endbr64 test %edi,%edi je 1188 <func0+0x48> mov $0x1,%ecx xor %r8d,%r8d movslq %edi,%rax mov %edi,%edx imul $0x66666667,%rax,%rax sar $0x1f,%edx sar $0x22,%rax sub %edx,%eax mov %eax,%edx lea (%rax,%rax,4),%eax add %eax,%eax sub %eax,%edi mov %edi,%eax mov %edx,%edi imul %ecx,%eax shl $0x3,%ecx add %eax,%r8d test %edx,%edx jne 1150 <func0+0x10> mov %r8d,%eax retq nopl 0x0(%rax,%rax,1) xor %r8d,%r8d mov %r8d,%eax retq
func0: endbr64 test edi, edi jz short loc_1188 mov esi, 1 xor r8d, r8d loc_1150: movsxd rax, edi mov edx, edi imul rax, 66666667h sar edx, 1Fh sar rax, 22h sub eax, edx lea ecx, [rax+rax*4] mov edx, eax mov eax, edi add ecx, ecx mov edi, edx sub eax, ecx imul eax, esi shl esi, 3 add r8d, eax test edx, edx jnz short loc_1150 mov eax, r8d retn loc_1188: xor r8d, r8d mov eax, r8d retn
long long func0(int a1) { int v1; // esi unsigned int v2; // r8d int v3; // eax int v4; // ecx int v5; // eax if ( !a1 ) return 0LL; v1 = 1; v2 = 0; do { v3 = a1; v4 = 10 * (a1 / 10); a1 /= 10; v5 = v1 * (v3 - v4); v1 *= 8; v2 += v5; } while ( a1 ); return v2; }
func0: ENDBR64 TEST EDI,EDI JZ 0x00101188 MOV ESI,0x1 XOR R8D,R8D LAB_00101150: MOVSXD RAX,EDI MOV EDX,EDI IMUL RAX,RAX,0x66666667 SAR EDX,0x1f SAR RAX,0x22 SUB EAX,EDX LEA ECX,[RAX + RAX*0x4] MOV EDX,EAX MOV EAX,EDI ADD ECX,ECX MOV EDI,EDX SUB EAX,ECX IMUL EAX,ESI SHL ESI,0x3 ADD R8D,EAX TEST EDX,EDX JNZ 0x00101150 MOV EAX,R8D RET LAB_00101188: XOR R8D,R8D MOV EAX,R8D RET
int func0(int param_1) { int iVar1; int iVar2; int iVar3; int iVar4; if (param_1 != 0) { iVar3 = 1; iVar4 = 0; do { iVar1 = param_1 / 10; iVar2 = (param_1 % 10) * iVar3; iVar3 = iVar3 << 3; iVar4 = iVar4 + iVar2; param_1 = iVar1; } while (iVar1 != 0); return iVar4; } return 0; }
4,671
func0
#include <assert.h>
int func0(int n) { int num = n; int dec_value = 0; int base = 1; int temp = num; while (temp) { int last_digit = temp % 10; temp = temp / 10; dec_value += last_digit * base; base = base * 8; } return dec_value; }
int main() { assert(func0(25) == 21); assert(func0(30) == 24); assert(func0(40) == 32); return 0; }
O3
c
func0: endbr64 test %edi,%edi je 1188 <func0+0x48> mov $0x1,%ecx xor %r8d,%r8d movslq %edi,%rax mov %edi,%edx imul $0x66666667,%rax,%rax sar $0x1f,%edx sar $0x22,%rax sub %edx,%eax mov %eax,%edx lea (%rax,%rax,4),%eax add %eax,%eax sub %eax,%edi mov %edi,%eax mov %edx,%edi imul %ecx,%eax shl $0x3,%ecx add %eax,%r8d test %edx,%edx jne 1150 <func0+0x10> mov %r8d,%eax retq nopl 0x0(%rax,%rax,1) xor %r8d,%r8d mov %r8d,%eax retq
func0: endbr64 test edi, edi jz short loc_1188 mov esi, 1 xor r8d, r8d loc_1150: movsxd rax, edi mov edx, edi imul rax, 66666667h sar edx, 1Fh sar rax, 22h sub eax, edx lea ecx, [rax+rax*4] mov edx, eax mov eax, edi add ecx, ecx mov edi, edx sub eax, ecx imul eax, esi shl esi, 3 add r8d, eax test edx, edx jnz short loc_1150 mov eax, r8d retn loc_1188: xor r8d, r8d mov eax, r8d retn
long long func0(int a1) { int v1; // esi unsigned int v2; // r8d int v3; // eax int v4; // ecx int v5; // eax if ( !a1 ) return 0LL; v1 = 1; v2 = 0; do { v3 = a1; v4 = 10 * (a1 / 10); a1 /= 10; v5 = v1 * (v3 - v4); v1 *= 8; v2 += v5; } while ( a1 ); return v2; }
func0: ENDBR64 TEST EDI,EDI JZ 0x00101188 MOV ESI,0x1 XOR R8D,R8D LAB_00101150: MOVSXD RAX,EDI MOV EDX,EDI IMUL RAX,RAX,0x66666667 SAR EDX,0x1f SAR RAX,0x22 SUB EAX,EDX LEA ECX,[RAX + RAX*0x4] MOV EDX,EAX MOV EAX,EDI ADD ECX,ECX MOV EDI,EDX SUB EAX,ECX IMUL EAX,ESI SHL ESI,0x3 ADD R8D,EAX TEST EDX,EDX JNZ 0x00101150 MOV EAX,R8D RET LAB_00101188: XOR R8D,R8D MOV EAX,R8D RET
int func0(int param_1) { int iVar1; int iVar2; int iVar3; int iVar4; if (param_1 != 0) { iVar3 = 1; iVar4 = 0; do { iVar1 = param_1 / 10; iVar2 = (param_1 % 10) * iVar3; iVar3 = iVar3 << 3; iVar4 = iVar4 + iVar2; param_1 = iVar1; } while (iVar1 != 0); return iVar4; } return 0; }
4,672
func0
#include <assert.h>
int func0(int arr[], int x, int n) { int low = 0; int high = n - 1; int res = -1; while (low <= high) { int mid = (low + high) / 2; if (arr[mid] > x) { high = mid - 1; } else if (arr[mid] < x) { low = mid + 1; } else { res = mid; high = mid - 1; } } return res; }
int main() { int arr1[] = {1,2,3,4,5,6,6}; int arr2[] = {1,2,2,2,3,2,2,4,2}; int arr3[] = {1,2,3}; assert(func0(arr1, 6, 7) == 5); assert(func0(arr2, 2, 9) == 1); assert(func0(arr3, 1, 3) == 0); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp mov %rdi,-0x18(%rbp) mov %esi,-0x1c(%rbp) mov %edx,-0x20(%rbp) movl $0x0,-0x10(%rbp) mov -0x20(%rbp),%eax sub $0x1,%eax mov %eax,-0xc(%rbp) movl $0xffffffff,-0x8(%rbp) jmp 1203 <func0+0x9a> mov -0x10(%rbp),%edx mov -0xc(%rbp),%eax add %edx,%eax mov %eax,%edx shr $0x1f,%edx add %edx,%eax sar %eax mov %eax,-0x4(%rbp) mov -0x4(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x18(%rbp),%rax add %rdx,%rax mov (%rax),%eax cmp %eax,-0x1c(%rbp) jge 11ce <func0+0x65> mov -0x4(%rbp),%eax sub $0x1,%eax mov %eax,-0xc(%rbp) jmp 1203 <func0+0x9a> mov -0x4(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x18(%rbp),%rax add %rdx,%rax mov (%rax),%eax cmp %eax,-0x1c(%rbp) jle 11f4 <func0+0x8b> mov -0x4(%rbp),%eax add $0x1,%eax mov %eax,-0x10(%rbp) jmp 1203 <func0+0x9a> mov -0x4(%rbp),%eax mov %eax,-0x8(%rbp) mov -0x4(%rbp),%eax sub $0x1,%eax mov %eax,-0xc(%rbp) mov -0x10(%rbp),%eax cmp -0xc(%rbp),%eax jle 1194 <func0+0x2b> mov -0x8(%rbp),%eax pop %rbp retq
func0: endbr64 push rbp mov rbp, rsp mov [rbp+var_18], rdi mov [rbp+var_1C], esi mov [rbp+var_20], edx mov [rbp+var_10], 0 mov eax, [rbp+var_20] sub eax, 1 mov [rbp+var_C], eax mov [rbp+var_8], 0FFFFFFFFh jmp short loc_1203 loc_1194: mov edx, [rbp+var_10] mov eax, [rbp+var_C] add eax, edx mov edx, eax shr edx, 1Fh add eax, edx sar eax, 1 mov [rbp+var_4], eax mov eax, [rbp+var_4] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rdx mov eax, [rax] cmp [rbp+var_1C], eax jge short loc_11CE mov eax, [rbp+var_4] sub eax, 1 mov [rbp+var_C], eax jmp short loc_1203 loc_11CE: mov eax, [rbp+var_4] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rdx mov eax, [rax] cmp [rbp+var_1C], eax jle short loc_11F4 mov eax, [rbp+var_4] add eax, 1 mov [rbp+var_10], eax jmp short loc_1203 loc_11F4: mov eax, [rbp+var_4] mov [rbp+var_8], eax mov eax, [rbp+var_4] sub eax, 1 mov [rbp+var_C], eax loc_1203: mov eax, [rbp+var_10] cmp eax, [rbp+var_C] jle short loc_1194 mov eax, [rbp+var_8] pop rbp retn
long long func0(long long a1, int a2, int a3) { int v4; // [rsp+10h] [rbp-10h] int v5; // [rsp+14h] [rbp-Ch] unsigned int v6; // [rsp+18h] [rbp-8h] int v7; // [rsp+1Ch] [rbp-4h] v4 = 0; v5 = a3 - 1; v6 = -1; while ( v4 <= v5 ) { v7 = (v4 + v5) / 2; if ( a2 >= *(_DWORD *)(4LL * v7 + a1) ) { if ( a2 <= *(_DWORD *)(4LL * v7 + a1) ) { v6 = (v4 + v5) / 2; v5 = v7 - 1; } else { v4 = v7 + 1; } } else { v5 = v7 - 1; } } return v6; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP MOV qword ptr [RBP + -0x18],RDI MOV dword ptr [RBP + -0x1c],ESI MOV dword ptr [RBP + -0x20],EDX MOV dword ptr [RBP + -0x10],0x0 MOV EAX,dword ptr [RBP + -0x20] SUB EAX,0x1 MOV dword ptr [RBP + -0xc],EAX MOV dword ptr [RBP + -0x8],0xffffffff JMP 0x00101203 LAB_00101194: MOV EDX,dword ptr [RBP + -0x10] MOV EAX,dword ptr [RBP + -0xc] ADD EAX,EDX MOV EDX,EAX SHR EDX,0x1f ADD EAX,EDX SAR EAX,0x1 MOV dword ptr [RBP + -0x4],EAX MOV EAX,dword ptr [RBP + -0x4] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOV EAX,dword ptr [RAX] CMP dword ptr [RBP + -0x1c],EAX JGE 0x001011ce MOV EAX,dword ptr [RBP + -0x4] SUB EAX,0x1 MOV dword ptr [RBP + -0xc],EAX JMP 0x00101203 LAB_001011ce: MOV EAX,dword ptr [RBP + -0x4] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOV EAX,dword ptr [RAX] CMP dword ptr [RBP + -0x1c],EAX JLE 0x001011f4 MOV EAX,dword ptr [RBP + -0x4] ADD EAX,0x1 MOV dword ptr [RBP + -0x10],EAX JMP 0x00101203 LAB_001011f4: MOV EAX,dword ptr [RBP + -0x4] MOV dword ptr [RBP + -0x8],EAX MOV EAX,dword ptr [RBP + -0x4] SUB EAX,0x1 MOV dword ptr [RBP + -0xc],EAX LAB_00101203: MOV EAX,dword ptr [RBP + -0x10] CMP EAX,dword ptr [RBP + -0xc] JLE 0x00101194 MOV EAX,dword ptr [RBP + -0x8] POP RBP RET
int func0(long param_1,int param_2,int param_3) { int iVar1; int4 local_18; int4 local_14; int4 local_10; local_18 = 0; local_14 = param_3 + -1; local_10 = -1; while (local_18 <= local_14) { iVar1 = (local_14 + local_18) / 2; if (param_2 < *(int *)(param_1 + (long)iVar1 * 4)) { local_14 = iVar1 + -1; } else if (*(int *)(param_1 + (long)iVar1 * 4) < param_2) { local_18 = iVar1 + 1; } else { local_14 = iVar1 + -1; local_10 = iVar1; } } return local_10; }
4,673
func0
#include <assert.h>
int func0(int arr[], int x, int n) { int low = 0; int high = n - 1; int res = -1; while (low <= high) { int mid = (low + high) / 2; if (arr[mid] > x) { high = mid - 1; } else if (arr[mid] < x) { low = mid + 1; } else { res = mid; high = mid - 1; } } return res; }
int main() { int arr1[] = {1,2,3,4,5,6,6}; int arr2[] = {1,2,2,2,3,2,2,4,2}; int arr3[] = {1,2,3}; assert(func0(arr1, 6, 7) == 5); assert(func0(arr2, 2, 9) == 1); assert(func0(arr3, 1, 3) == 0); return 0; }
O1
c
func0: endbr64 sub $0x1,%edx js 11af <func0+0x46> mov $0xffffffff,%r9d mov $0x0,%r8d jmp 118b <func0+0x22> jge 11a7 <func0+0x3e> lea 0x1(%rax),%r8d cmp %edx,%r8d jg 11b5 <func0+0x4c> lea (%r8,%rdx,1),%ecx mov %ecx,%eax shr $0x1f,%eax add %ecx,%eax sar %eax movslq %eax,%rcx mov (%rdi,%rcx,4),%ecx cmp %esi,%ecx jle 1180 <func0+0x17> lea -0x1(%rax),%edx jmp 1186 <func0+0x1d> lea -0x1(%rax),%edx mov %eax,%r9d jmp 1186 <func0+0x1d> mov $0xffffffff,%r9d mov %r9d,%eax retq
func0: endbr64 sub edx, 1 js short loc_11AF mov r9d, 0FFFFFFFFh mov r8d, 0 jmp short loc_118B loc_1180: jge short loc_11A7 lea r8d, [rax+1] loc_1186: cmp r8d, edx jg short loc_11B5 loc_118B: lea ecx, [r8+rdx] mov eax, ecx shr eax, 1Fh add eax, ecx sar eax, 1 movsxd rcx, eax mov ecx, [rdi+rcx*4] cmp ecx, esi jle short loc_1180 lea edx, [rax-1] jmp short loc_1186 loc_11A7: lea edx, [rax-1] mov r9d, eax jmp short loc_1186 loc_11AF: mov r9d, 0FFFFFFFFh loc_11B5: mov eax, r9d retn
long long func0(long long a1, int a2, int a3) { int v3; // edx unsigned int v4; // r9d int v5; // r8d int v6; // eax int v7; // ecx v3 = a3 - 1; if ( v3 < 0 ) { return (unsigned int)-1; } else { v4 = -1; v5 = 0; do { v6 = (v5 + v3) / 2; v7 = *(_DWORD *)(a1 + 4LL * v6); if ( v7 <= a2 ) { if ( v7 >= a2 ) { v3 = v6 - 1; v4 = v6; } else { v5 = v6 + 1; } } else { v3 = v6 - 1; } } while ( v5 <= v3 ); } return v4; }
func0: ENDBR64 SUB EDX,0x1 JS 0x001011af MOV R9D,0xffffffff MOV R8D,0x0 JMP 0x0010118b LAB_00101180: JGE 0x001011a7 LEA R8D,[RAX + 0x1] LAB_00101186: CMP R8D,EDX JG 0x001011b5 LAB_0010118b: LEA ECX,[R8 + RDX*0x1] MOV EAX,ECX SHR EAX,0x1f ADD EAX,ECX SAR EAX,0x1 MOVSXD RCX,EAX MOV ECX,dword ptr [RDI + RCX*0x4] CMP ECX,ESI JLE 0x00101180 LEA EDX,[RAX + -0x1] JMP 0x00101186 LAB_001011a7: LEA EDX,[RAX + -0x1] MOV R9D,EAX JMP 0x00101186 LAB_001011af: MOV R9D,0xffffffff LAB_001011b5: MOV EAX,R9D RET
int func0(long param_1,int param_2,int param_3) { int iVar1; int iVar2; int iVar3; int iVar4; param_3 = param_3 + -1; if (param_3 < 0) { iVar2 = -1; } else { iVar3 = 0; iVar4 = -1; do { iVar2 = (iVar3 + param_3) / 2; iVar1 = *(int *)(param_1 + (long)iVar2 * 4); if (param_2 < iVar1) { param_3 = iVar2 + -1; iVar2 = iVar4; } else if (iVar1 < param_2) { iVar3 = iVar2 + 1; iVar2 = iVar4; } else { param_3 = iVar2 + -1; } iVar4 = iVar2; } while (iVar3 <= param_3); } return iVar2; }
4,674
func0
#include <assert.h>
int func0(int arr[], int x, int n) { int low = 0; int high = n - 1; int res = -1; while (low <= high) { int mid = (low + high) / 2; if (arr[mid] > x) { high = mid - 1; } else if (arr[mid] < x) { low = mid + 1; } else { res = mid; high = mid - 1; } } return res; }
int main() { int arr1[] = {1,2,3,4,5,6,6}; int arr2[] = {1,2,2,2,3,2,2,4,2}; int arr3[] = {1,2,3}; assert(func0(arr1, 6, 7) == 5); assert(func0(arr2, 2, 9) == 1); assert(func0(arr3, 1, 3) == 0); return 0; }
O2
c
func0: endbr64 mov $0xffffffff,%r9d sub $0x1,%edx js 1396 <func0+0x36> xor %ecx,%ecx jmp 137f <func0+0x1f> nopl 0x0(%rax,%rax,1) lea -0x1(%rax),%edx cmp %ecx,%edx jl 1396 <func0+0x36> lea (%rdx,%rcx,1),%eax sar %eax movslq %eax,%r8 cmp %esi,(%rdi,%r8,4) jg 1378 <func0+0x18> jge 13a0 <func0+0x40> lea 0x1(%rax),%ecx cmp %ecx,%edx jge 137f <func0+0x1f> mov %r9d,%eax retq nopw 0x0(%rax,%rax,1) lea -0x1(%rax),%edx mov %eax,%r9d jmp 137b <func0+0x1b> nopl 0x0(%rax,%rax,1)
func0: endbr64 mov r9d, 0FFFFFFFFh sub edx, 1 js short loc_1306 xor ecx, ecx jmp short loc_12EF loc_12E8: lea edx, [rax-1] loc_12EB: cmp edx, ecx jl short loc_1306 loc_12EF: lea eax, [rdx+rcx] sar eax, 1 movsxd r8, eax cmp [rdi+r8*4], esi jg short loc_12E8 jge short loc_1310 lea ecx, [rax+1] cmp edx, ecx jge short loc_12EF loc_1306: mov eax, r9d retn loc_1310: lea edx, [rax-1] mov r9d, eax jmp short loc_12EB
long long func0(long long a1, int a2, int a3) { unsigned int v3; // r9d int v4; // edx int v5; // ecx int v6; // eax v3 = -1; v4 = a3 - 1; if ( v4 >= 0 ) { v5 = 0; do { while ( 1 ) { v6 = (v4 + v5) >> 1; if ( *(_DWORD *)(a1 + 4LL * v6) <= a2 ) break; v4 = v6 - 1; LABEL_4: if ( v4 < v5 ) return v3; } if ( *(_DWORD *)(a1 + 4LL * v6) >= a2 ) { v4 = v6 - 1; v3 = v6; goto LABEL_4; } v5 = v6 + 1; } while ( v4 >= v6 + 1 ); } return v3; }
func0: ENDBR64 MOV R9D,0xffffffff SUB EDX,0x1 JS 0x00101306 XOR ECX,ECX JMP 0x001012ef LAB_001012e8: LEA EDX,[RAX + -0x1] LAB_001012eb: CMP EDX,ECX JL 0x00101306 LAB_001012ef: LEA EAX,[RDX + RCX*0x1] SAR EAX,0x1 MOVSXD R8,EAX CMP dword ptr [RDI + R8*0x4],ESI JG 0x001012e8 JGE 0x00101310 LEA ECX,[RAX + 0x1] CMP EDX,ECX JGE 0x001012ef LAB_00101306: MOV EAX,R9D RET LAB_00101310: LEA EDX,[RAX + -0x1] MOV R9D,EAX JMP 0x001012eb
int func0(long param_1,int param_2,int param_3) { int iVar1; int iVar2; int iVar3; int iVar4; int iVar5; iVar5 = -1; param_3 = param_3 + -1; if (-1 < param_3) { iVar3 = 0; do { while( true ) { iVar2 = param_3 + iVar3 >> 1; iVar1 = *(int *)(param_1 + (long)iVar2 * 4); iVar4 = iVar5; if ((iVar1 <= param_2) && (iVar4 = iVar2, iVar1 < param_2)) break; param_3 = iVar2 + -1; iVar5 = iVar4; if (param_3 < iVar3) { return iVar4; } } iVar3 = iVar2 + 1; } while (iVar3 <= param_3); } return iVar5; }
4,675
func0
#include <assert.h>
int func0(int arr[], int x, int n) { int low = 0; int high = n - 1; int res = -1; while (low <= high) { int mid = (low + high) / 2; if (arr[mid] > x) { high = mid - 1; } else if (arr[mid] < x) { low = mid + 1; } else { res = mid; high = mid - 1; } } return res; }
int main() { int arr1[] = {1,2,3,4,5,6,6}; int arr2[] = {1,2,2,2,3,2,2,4,2}; int arr3[] = {1,2,3}; assert(func0(arr1, 6, 7) == 5); assert(func0(arr2, 2, 9) == 1); assert(func0(arr3, 1, 3) == 0); return 0; }
O3
c
func0: endbr64 mov $0xffffffff,%r9d sub $0x1,%edx js 1376 <func0+0x36> xor %ecx,%ecx jmp 135f <func0+0x1f> nopl 0x0(%rax,%rax,1) lea -0x1(%rax),%edx cmp %edx,%ecx jg 1376 <func0+0x36> lea (%rdx,%rcx,1),%eax sar %eax movslq %eax,%r8 cmp (%rdi,%r8,4),%esi jl 1358 <func0+0x18> jle 1380 <func0+0x40> lea 0x1(%rax),%ecx cmp %edx,%ecx jle 135f <func0+0x1f> mov %r9d,%eax retq nopw 0x0(%rax,%rax,1) lea -0x1(%rax),%edx mov %eax,%r9d jmp 135b <func0+0x1b> nopl 0x0(%rax,%rax,1)
func0: endbr64 mov r9d, 0FFFFFFFFh sub edx, 1 js short loc_1390 xor r8d, r8d jmp short loc_1370 loc_1368: lea edx, [rax-1] loc_136B: cmp r8d, edx jg short loc_1390 loc_1370: lea ecx, [rdx+r8] mov eax, ecx shr eax, 1Fh add eax, ecx sar eax, 1 movsxd rcx, eax cmp esi, [rdi+rcx*4] jl short loc_1368 jle short loc_1398 lea r8d, [rax+1] cmp r8d, edx jle short loc_1370 loc_1390: mov eax, r9d retn loc_1398: lea edx, [rax-1] mov r9d, eax jmp short loc_136B
long long func0(long long a1, int a2, int a3) { unsigned int v3; // r9d int v4; // edx int v5; // r8d int v6; // eax v3 = -1; v4 = a3 - 1; if ( v4 >= 0 ) { v5 = 0; do { while ( 1 ) { v6 = (v4 + v5) / 2; if ( a2 >= *(_DWORD *)(a1 + 4LL * v6) ) break; v4 = v6 - 1; LABEL_4: if ( v5 > v4 ) return v3; } if ( a2 <= *(_DWORD *)(a1 + 4LL * v6) ) { v4 = v6 - 1; v3 = v6; goto LABEL_4; } v5 = v6 + 1; } while ( v6 + 1 <= v4 ); } return v3; }
func0: ENDBR64 MOV R9D,0xffffffff SUB EDX,0x1 JS 0x00101390 XOR R8D,R8D JMP 0x00101370 LAB_00101368: LEA EDX,[RAX + -0x1] LAB_0010136b: CMP R8D,EDX JG 0x00101390 LAB_00101370: LEA ECX,[RDX + R8*0x1] MOV EAX,ECX SHR EAX,0x1f ADD EAX,ECX SAR EAX,0x1 MOVSXD RCX,EAX CMP ESI,dword ptr [RDI + RCX*0x4] JL 0x00101368 JLE 0x00101398 LEA R8D,[RAX + 0x1] CMP R8D,EDX JLE 0x00101370 LAB_00101390: MOV EAX,R9D RET LAB_00101398: LEA EDX,[RAX + -0x1] MOV R9D,EAX JMP 0x0010136b
int func0(long param_1,int param_2,int param_3) { int iVar1; int iVar2; int iVar3; int iVar4; int iVar5; iVar5 = -1; param_3 = param_3 + -1; if (-1 < param_3) { iVar3 = 0; do { while( true ) { iVar2 = (param_3 + iVar3) / 2; iVar1 = *(int *)(param_1 + (long)iVar2 * 4); iVar4 = iVar5; if ((iVar1 <= param_2) && (iVar4 = iVar2, iVar1 < param_2)) break; param_3 = iVar2 + -1; iVar5 = iVar4; if (param_3 < iVar3) { return iVar4; } } iVar3 = iVar2 + 1; } while (iVar3 <= param_3); } return iVar5; }
4,676
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h> struct Tuple { int *elements; int size; }; struct TupleList { struct Tuple *tuples; int size; }; struct TupleList remove_tuples(struct TupleList test_list, int K) { struct TupleList res; res.tuples = malloc(test_list.size * sizeof(struct Tuple)); res.size = 0; for (int i = 0; i < test_list.size; i++) { if (test_list.tuples[i].size != K) { res.tuples[res.size++] = test_list.tuples[i]; } } return res; } int compare_tuples(struct Tuple t1, struct Tuple t2) { if (t1.size != t2.size) return 0; for (int i = 0; i < t1.size; i++) { if (t1.elements[i] != t2.elements[i]) { return 0; } } return 1; }
int func0(struct TupleList l1, struct TupleList l2) { if (l1.size != l2.size) return 0; for (int i = 0; i < l1.size; i++) { if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0; } return 1; }
int main() { int tuple1[] = {4, 5}; int tuple2[] = {4}; int tuple3[] = {8, 6, 7}; int tuple4[] = {1}; int tuple5[] = {3, 4, 6, 7}; struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}}; struct TupleList test_list1 = {tuples1, 5}; struct Tuple expected1[] = {{tuple1, 2}, {tuple3, 3}, {tuple5, 4}}; struct TupleList expected_list1 = {expected1, 3}; struct TupleList result1 = remove_tuples(test_list1, 1); int tuple6[] = {4, 5}; int tuple7[] = {4, 5}; int tuple8[] = {6, 7}; int tuple9[] = {1, 2, 3}; int tuple10[] = {3, 4, 6, 7}; struct Tuple tuples2[] = {{tuple6, 2}, {tuple7, 2}, {tuple8, 2}, {tuple9, 3}, {tuple10, 4}}; struct TupleList test_list2 = {tuples2, 5}; struct Tuple expected2[] = {{tuple9, 3}, {tuple10, 4}}; struct TupleList expected_list2 = {expected2, 2}; struct TupleList result2 = remove_tuples(test_list2, 2); int tuple11[] = {1, 4, 4}; int tuple12[] = {4, 3}; int tuple13[] = {8, 6, 7}; int tuple14[] = {1}; int tuple15[] = {3, 6, 7}; struct Tuple tuples3[] = {{tuple11, 3}, {tuple12, 2}, {tuple13, 3}, {tuple14, 1}, {tuple15, 3}}; struct TupleList test_list3 = {tuples3, 5}; struct Tuple expected3[] = {{tuple12, 2}, {tuple14, 1}}; struct TupleList expected_list3 = {expected3, 2}; struct TupleList result3 = remove_tuples(test_list3, 3); assert(func0(result1, expected_list1)); assert(func0(result2, expected_list2)); assert(func0(result3, expected_list3)); printf("All tests passed!\n"); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x30,%rsp mov %rsi,%rax mov %rdi,%r8 mov %r8,%rsi mov %r9,%rdi mov %rax,%rdi mov %rsi,-0x20(%rbp) mov %rdi,-0x18(%rbp) mov %rdx,-0x30(%rbp) mov %rcx,-0x28(%rbp) mov -0x18(%rbp),%edx mov -0x28(%rbp),%eax cmp %eax,%edx je 131a <func0+0x3c> mov $0x0,%eax jmp 137a <func0+0x9c> movl $0x0,-0x4(%rbp) jmp 136d <func0+0x8f> mov -0x30(%rbp),%rax mov -0x4(%rbp),%edx movslq %edx,%rdx shl $0x4,%rdx add %rdx,%rax mov -0x20(%rbp),%rdx mov -0x4(%rbp),%ecx movslq %ecx,%rcx shl $0x4,%rcx add %rdx,%rcx mov 0x8(%rax),%rdx mov (%rax),%rax mov (%rcx),%rdi mov 0x8(%rcx),%rsi mov %rdx,%rcx mov %rax,%rdx callq 1259 <compare_tuples> test %eax,%eax jne 1369 <func0+0x8b> mov $0x0,%eax jmp 137a <func0+0x9c> addl $0x1,-0x4(%rbp) mov -0x18(%rbp),%eax cmp %eax,-0x4(%rbp) jl 1323 <func0+0x45> mov $0x1,%eax leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 30h mov rax, rdi mov r8, rsi mov rsi, rax mov rdi, rdx mov rdi, r8 mov [rbp+var_20], rsi mov [rbp+var_18], rdi mov [rbp+var_30], rdx mov [rbp+var_28], rcx mov edx, dword ptr [rbp+var_18] mov eax, dword ptr [rbp+var_28] cmp edx, eax jz short loc_131C mov eax, 0 jmp short locret_137C loc_131C: mov [rbp+var_4], 0 jmp short loc_136F loc_1325: mov rax, [rbp+var_30] mov edx, [rbp+var_4] movsxd rdx, edx shl rdx, 4 add rax, rdx mov rdx, [rbp+var_20] mov ecx, [rbp+var_4] movsxd rcx, ecx shl rcx, 4 add rcx, rdx mov rdx, [rax+8] mov rax, [rax] mov rdi, [rcx] mov rsi, [rcx+8] mov rcx, rdx mov rdx, rax call compare_tuples test eax, eax jnz short loc_136B mov eax, 0 jmp short locret_137C loc_136B: add [rbp+var_4], 1 loc_136F: mov eax, dword ptr [rbp+var_18] cmp [rbp+var_4], eax jl short loc_1325 mov eax, 1 locret_137C: leave retn
long long func0(long long a1, int a2, long long a3, int a4) { int i; // [rsp+2Ch] [rbp-4h] if ( a2 != a4 ) return 0LL; for ( i = 0; i < a2; ++i ) { if ( !(unsigned int)compare_tuples( *(_QWORD *)(a1 + 16LL * i), *(_QWORD *)(a1 + 16LL * i + 8), *(_QWORD *)(16LL * i + a3), *(_QWORD *)(16LL * i + a3 + 8)) ) return 0LL; } return 1LL; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x30 MOV RAX,RDI MOV R8,RSI MOV RSI,RAX MOV RDI,RDX MOV RDI,R8 MOV qword ptr [RBP + -0x20],RSI MOV qword ptr [RBP + -0x18],RDI MOV qword ptr [RBP + -0x30],RDX MOV qword ptr [RBP + -0x28],RCX MOV EDX,dword ptr [RBP + -0x18] MOV EAX,dword ptr [RBP + -0x28] CMP EDX,EAX JZ 0x0010131c MOV EAX,0x0 JMP 0x0010137c LAB_0010131c: MOV dword ptr [RBP + -0x4],0x0 JMP 0x0010136f LAB_00101325: MOV RAX,qword ptr [RBP + -0x30] MOV EDX,dword ptr [RBP + -0x4] MOVSXD RDX,EDX SHL RDX,0x4 ADD RAX,RDX MOV RDX,qword ptr [RBP + -0x20] MOV ECX,dword ptr [RBP + -0x4] MOVSXD RCX,ECX SHL RCX,0x4 ADD RCX,RDX MOV RDX,qword ptr [RAX + 0x8] MOV RAX,qword ptr [RAX] MOV RDI,qword ptr [RCX] MOV RSI,qword ptr [RCX + 0x8] MOV RCX,RDX MOV RDX,RAX CALL 0x0010125b TEST EAX,EAX JNZ 0x0010136b MOV EAX,0x0 JMP 0x0010137c LAB_0010136b: ADD dword ptr [RBP + -0x4],0x1 LAB_0010136f: MOV EAX,dword ptr [RBP + -0x18] CMP dword ptr [RBP + -0x4],EAX JL 0x00101325 MOV EAX,0x1 LAB_0010137c: LEAVE RET
int8 func0(long param_1,int param_2,long param_3,int param_4) { int iVar1; int8 uVar2; int8 *puVar3; int8 *puVar4; int local_c; if (param_2 == param_4) { for (local_c = 0; local_c < param_2; local_c = local_c + 1) { puVar3 = (int8 *)(param_3 + (long)local_c * 0x10); puVar4 = (int8 *)((long)local_c * 0x10 + param_1); iVar1 = compare_tuples(*puVar4,puVar4[1],*puVar3,puVar3[1]); if (iVar1 == 0) { return 0; } } uVar2 = 1; } else { uVar2 = 0; } return uVar2; }
4,677
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h> struct Tuple { int *elements; int size; }; struct TupleList { struct Tuple *tuples; int size; }; struct TupleList remove_tuples(struct TupleList test_list, int K) { struct TupleList res; res.tuples = malloc(test_list.size * sizeof(struct Tuple)); res.size = 0; for (int i = 0; i < test_list.size; i++) { if (test_list.tuples[i].size != K) { res.tuples[res.size++] = test_list.tuples[i]; } } return res; } int compare_tuples(struct Tuple t1, struct Tuple t2) { if (t1.size != t2.size) return 0; for (int i = 0; i < t1.size; i++) { if (t1.elements[i] != t2.elements[i]) { return 0; } } return 1; }
int func0(struct TupleList l1, struct TupleList l2) { if (l1.size != l2.size) return 0; for (int i = 0; i < l1.size; i++) { if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0; } return 1; }
int main() { int tuple1[] = {4, 5}; int tuple2[] = {4}; int tuple3[] = {8, 6, 7}; int tuple4[] = {1}; int tuple5[] = {3, 4, 6, 7}; struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}}; struct TupleList test_list1 = {tuples1, 5}; struct Tuple expected1[] = {{tuple1, 2}, {tuple3, 3}, {tuple5, 4}}; struct TupleList expected_list1 = {expected1, 3}; struct TupleList result1 = remove_tuples(test_list1, 1); int tuple6[] = {4, 5}; int tuple7[] = {4, 5}; int tuple8[] = {6, 7}; int tuple9[] = {1, 2, 3}; int tuple10[] = {3, 4, 6, 7}; struct Tuple tuples2[] = {{tuple6, 2}, {tuple7, 2}, {tuple8, 2}, {tuple9, 3}, {tuple10, 4}}; struct TupleList test_list2 = {tuples2, 5}; struct Tuple expected2[] = {{tuple9, 3}, {tuple10, 4}}; struct TupleList expected_list2 = {expected2, 2}; struct TupleList result2 = remove_tuples(test_list2, 2); int tuple11[] = {1, 4, 4}; int tuple12[] = {4, 3}; int tuple13[] = {8, 6, 7}; int tuple14[] = {1}; int tuple15[] = {3, 6, 7}; struct Tuple tuples3[] = {{tuple11, 3}, {tuple12, 2}, {tuple13, 3}, {tuple14, 1}, {tuple15, 3}}; struct TupleList test_list3 = {tuples3, 5}; struct Tuple expected3[] = {{tuple12, 2}, {tuple14, 1}}; struct TupleList expected_list3 = {expected3, 2}; struct TupleList result3 = remove_tuples(test_list3, 3); assert(func0(result1, expected_list1)); assert(func0(result2, expected_list2)); assert(func0(result3, expected_list3)); printf("All tests passed!\n"); return 0; }
O1
c
func0: endbr64 mov $0x0,%eax cmp %ecx,%esi jne 12aa <func0+0x5c> test %esi,%esi jle 12a4 <func0+0x56> push %r12 push %rbp push %rbx mov %rdi,%rbx mov %rdx,%rbp lea -0x1(%rsi),%eax shl $0x4,%rax lea 0x10(%rdi,%rax,1),%r12 mov (%rbx),%rdi mov 0x8(%rbx),%rsi mov 0x0(%rbp),%rdx mov 0x8(%rbp),%rcx callq 120d <compare_tuples> test %eax,%eax je 129f <func0+0x51> add $0x10,%rbx add $0x10,%rbp cmp %r12,%rbx jne 1275 <func0+0x27> mov $0x1,%eax pop %rbx pop %rbp pop %r12 retq mov $0x1,%eax retq retq
func0: endbr64 mov eax, 0 cmp esi, ecx jnz short locret_12AA test esi, esi jle short loc_12A4 push r12 push rbp push rbx mov rbx, rdi mov rbp, rdx lea eax, [rsi-1] shl rax, 4 lea r12, [rdi+rax+10h] loc_1275: mov rdi, [rbx] mov rsi, [rbx+8] mov rdx, [rbp+0] mov rcx, [rbp+8] call compare_tuples test eax, eax jz short loc_129F add rbx, 10h add rbp, 10h cmp rbx, r12 jnz short loc_1275 mov eax, 1 loc_129F: pop rbx pop rbp pop r12 retn loc_12A4: mov eax, 1 retn locret_12AA: retn
long long func0(_QWORD *a1, int a2, _QWORD *a3, int a4) { long long result; // rax _QWORD *v5; // rbx result = 0LL; if ( a2 == a4 ) { if ( a2 <= 0 ) { return 1LL; } else { v5 = a1; while ( 1 ) { result = compare_tuples(*v5, v5[1], *a3, a3[1]); if ( !(_DWORD)result ) break; v5 += 2; a3 += 2; if ( v5 == &a1[2 * (unsigned int)(a2 - 1) + 2] ) return 1LL; } } } return result; }
func0: ENDBR64 MOV EAX,0x0 CMP ESI,ECX JNZ 0x001012aa TEST ESI,ESI JLE 0x001012a4 PUSH R12 PUSH RBP PUSH RBX MOV RBX,RDI MOV RBP,RDX LEA EAX,[RSI + -0x1] SHL RAX,0x4 LEA R12,[RDI + RAX*0x1 + 0x10] LAB_00101275: MOV RDI,qword ptr [RBX] MOV RSI,qword ptr [RBX + 0x8] MOV RDX,qword ptr [RBP] MOV RCX,qword ptr [RBP + 0x8] CALL 0x0010120d TEST EAX,EAX JZ 0x0010129f ADD RBX,0x10 ADD RBP,0x10 CMP RBX,R12 JNZ 0x00101275 MOV EAX,0x1 LAB_0010129f: POP RBX POP RBP POP R12 RET LAB_001012a4: MOV EAX,0x1 RET LAB_001012aa: RET
int8 func0(int8 *param_1,int param_2,int8 *param_3,int param_4) { int8 *puVar1; int8 uVar2; if (param_2 != param_4) { return 0; } if (0 < param_2) { puVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2; do { uVar2 = compare_tuples(*param_1,param_1[1],*param_3,param_3[1]); if ((int)uVar2 == 0) { return uVar2; } param_1 = param_1 + 2; param_3 = param_3 + 2; } while (param_1 != puVar1); return 1; } return 1; }
4,678
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h> struct Tuple { int *elements; int size; }; struct TupleList { struct Tuple *tuples; int size; }; struct TupleList remove_tuples(struct TupleList test_list, int K) { struct TupleList res; res.tuples = malloc(test_list.size * sizeof(struct Tuple)); res.size = 0; for (int i = 0; i < test_list.size; i++) { if (test_list.tuples[i].size != K) { res.tuples[res.size++] = test_list.tuples[i]; } } return res; } int compare_tuples(struct Tuple t1, struct Tuple t2) { if (t1.size != t2.size) return 0; for (int i = 0; i < t1.size; i++) { if (t1.elements[i] != t2.elements[i]) { return 0; } } return 1; }
int func0(struct TupleList l1, struct TupleList l2) { if (l1.size != l2.size) return 0; for (int i = 0; i < l1.size; i++) { if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0; } return 1; }
int main() { int tuple1[] = {4, 5}; int tuple2[] = {4}; int tuple3[] = {8, 6, 7}; int tuple4[] = {1}; int tuple5[] = {3, 4, 6, 7}; struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}}; struct TupleList test_list1 = {tuples1, 5}; struct Tuple expected1[] = {{tuple1, 2}, {tuple3, 3}, {tuple5, 4}}; struct TupleList expected_list1 = {expected1, 3}; struct TupleList result1 = remove_tuples(test_list1, 1); int tuple6[] = {4, 5}; int tuple7[] = {4, 5}; int tuple8[] = {6, 7}; int tuple9[] = {1, 2, 3}; int tuple10[] = {3, 4, 6, 7}; struct Tuple tuples2[] = {{tuple6, 2}, {tuple7, 2}, {tuple8, 2}, {tuple9, 3}, {tuple10, 4}}; struct TupleList test_list2 = {tuples2, 5}; struct Tuple expected2[] = {{tuple9, 3}, {tuple10, 4}}; struct TupleList expected_list2 = {expected2, 2}; struct TupleList result2 = remove_tuples(test_list2, 2); int tuple11[] = {1, 4, 4}; int tuple12[] = {4, 3}; int tuple13[] = {8, 6, 7}; int tuple14[] = {1}; int tuple15[] = {3, 6, 7}; struct Tuple tuples3[] = {{tuple11, 3}, {tuple12, 2}, {tuple13, 3}, {tuple14, 1}, {tuple15, 3}}; struct TupleList test_list3 = {tuples3, 5}; struct Tuple expected3[] = {{tuple12, 2}, {tuple14, 1}}; struct TupleList expected_list3 = {expected3, 2}; struct TupleList result3 = remove_tuples(test_list3, 3); assert(func0(result1, expected_list1)); assert(func0(result2, expected_list2)); assert(func0(result3, expected_list3)); printf("All tests passed!\n"); return 0; }
O2
c
func0: endbr64 xor %eax,%eax cmp %ecx,%esi jne 173e <func0+0x6e> test %esi,%esi jle 1739 <func0+0x69> lea -0x1(%rsi),%eax xor %esi,%esi add $0x1,%rax shl $0x4,%rax mov %rax,%r11 mov 0x8(%rdi,%rsi,1),%eax cmp 0x8(%rdx,%rsi,1),%eax jne 1726 <func0+0x56> test %eax,%eax jle 1730 <func0+0x60> lea -0x1(%rax),%r10d mov (%rdi,%rsi,1),%r9 mov (%rdx,%rsi,1),%r8 xor %eax,%eax jmp 171c <func0+0x4c> nopl 0x0(%rax) lea 0x1(%rax),%rcx cmp %rax,%r10 je 1730 <func0+0x60> mov %rcx,%rax mov (%r8,%rax,4),%ecx cmp %ecx,(%r9,%rax,4) je 1710 <func0+0x40> xor %eax,%eax retq nopl 0x0(%rax) add $0x10,%rsi cmp %r11,%rsi jne 16ee <func0+0x1e> mov $0x1,%eax retq
func0: endbr64 mov r10, rdi xor eax, eax cmp esi, ecx jnz short locret_1740 movsxd r11, esi xor ecx, ecx shl r11, 4 test esi, esi jle short loc_1739 nop word ptr [rax+rax+00h] loc_16F0: mov rsi, [r10+rcx] mov r9d, [r10+rcx+8] mov rdi, [rdx+rcx] cmp r9d, [rdx+rcx+8] jnz short loc_1723 movsxd r8, r9d xor eax, eax test r9d, r9d jg short loc_1719 jmp short loc_1730 loc_1710: add rax, 1 cmp r8, rax jz short loc_1730 loc_1719: mov r9d, [rdi+rax*4] cmp [rsi+rax*4], r9d jz short loc_1710 loc_1723: xor eax, eax retn loc_1730: add rcx, 10h cmp r11, rcx jnz short loc_16F0 loc_1739: mov eax, 1 retn locret_1740: retn
long long func0(long long a1, int a2, long long a3, int a4) { long long result; // rax long long v5; // rcx int v6; // r9d long long v7; // rax result = 0LL; if ( a2 == a4 ) { v5 = 0LL; if ( a2 <= 0 ) { return 1LL; } else { while ( 1 ) { v6 = *(_DWORD *)(a1 + v5 + 8); if ( v6 != *(_DWORD *)(a3 + v5 + 8) ) return 0LL; v7 = 0LL; if ( v6 > 0 ) { while ( *(_DWORD *)(*(_QWORD *)(a1 + v5) + 4 * v7) == *(_DWORD *)(*(_QWORD *)(a3 + v5) + 4 * v7) ) { if ( v6 == ++v7 ) goto LABEL_9; } return 0LL; } LABEL_9: v5 += 16LL; if ( 16LL * a2 == v5 ) return 1LL; } } } return result; }
func0: ENDBR64 MOV R10,RDI XOR EAX,EAX CMP ESI,ECX JNZ 0x00101740 MOVSXD R11,ESI XOR ECX,ECX SHL R11,0x4 TEST ESI,ESI JLE 0x00101739 NOP word ptr [RAX + RAX*0x1] LAB_001016f0: MOV RSI,qword ptr [R10 + RCX*0x1] MOV R9D,dword ptr [R10 + RCX*0x1 + 0x8] MOV RDI,qword ptr [RDX + RCX*0x1] CMP R9D,dword ptr [RDX + RCX*0x1 + 0x8] JNZ 0x00101723 MOVSXD R8,R9D XOR EAX,EAX TEST R9D,R9D JG 0x00101719 JMP 0x00101730 LAB_00101710: ADD RAX,0x1 CMP R8,RAX JZ 0x00101730 LAB_00101719: MOV R9D,dword ptr [RDI + RAX*0x4] CMP dword ptr [RSI + RAX*0x4],R9D JZ 0x00101710 LAB_00101723: XOR EAX,EAX RET LAB_00101730: ADD RCX,0x10 CMP R11,RCX JNZ 0x001016f0 LAB_00101739: MOV EAX,0x1 RET LAB_00101740: RET
int8 func0(long param_1,int param_2,long param_3,int param_4) { int iVar1; long lVar2; long lVar3; if (param_2 != param_4) { return 0; } lVar3 = 0; if (0 < param_2) { do { iVar1 = *(int *)(param_1 + 8 + lVar3); if (iVar1 != *(int *)(param_3 + 8 + lVar3)) { return 0; } lVar2 = 0; if (0 < iVar1) { do { if (*(int *)(*(long *)(param_1 + lVar3) + lVar2 * 4) != *(int *)(*(long *)(param_3 + lVar3) + lVar2 * 4)) { return 0; } lVar2 = lVar2 + 1; } while (iVar1 != lVar2); } lVar3 = lVar3 + 0x10; } while ((long)param_2 * 0x10 != lVar3); } return 1; }
4,679
func0
#include <stdio.h> #include <stdlib.h> #include <assert.h> struct Tuple { int *elements; int size; }; struct TupleList { struct Tuple *tuples; int size; }; struct TupleList remove_tuples(struct TupleList test_list, int K) { struct TupleList res; res.tuples = malloc(test_list.size * sizeof(struct Tuple)); res.size = 0; for (int i = 0; i < test_list.size; i++) { if (test_list.tuples[i].size != K) { res.tuples[res.size++] = test_list.tuples[i]; } } return res; } int compare_tuples(struct Tuple t1, struct Tuple t2) { if (t1.size != t2.size) return 0; for (int i = 0; i < t1.size; i++) { if (t1.elements[i] != t2.elements[i]) { return 0; } } return 1; }
int func0(struct TupleList l1, struct TupleList l2) { if (l1.size != l2.size) return 0; for (int i = 0; i < l1.size; i++) { if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0; } return 1; }
int main() { int tuple1[] = {4, 5}; int tuple2[] = {4}; int tuple3[] = {8, 6, 7}; int tuple4[] = {1}; int tuple5[] = {3, 4, 6, 7}; struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}}; struct TupleList test_list1 = {tuples1, 5}; struct Tuple expected1[] = {{tuple1, 2}, {tuple3, 3}, {tuple5, 4}}; struct TupleList expected_list1 = {expected1, 3}; struct TupleList result1 = remove_tuples(test_list1, 1); int tuple6[] = {4, 5}; int tuple7[] = {4, 5}; int tuple8[] = {6, 7}; int tuple9[] = {1, 2, 3}; int tuple10[] = {3, 4, 6, 7}; struct Tuple tuples2[] = {{tuple6, 2}, {tuple7, 2}, {tuple8, 2}, {tuple9, 3}, {tuple10, 4}}; struct TupleList test_list2 = {tuples2, 5}; struct Tuple expected2[] = {{tuple9, 3}, {tuple10, 4}}; struct TupleList expected_list2 = {expected2, 2}; struct TupleList result2 = remove_tuples(test_list2, 2); int tuple11[] = {1, 4, 4}; int tuple12[] = {4, 3}; int tuple13[] = {8, 6, 7}; int tuple14[] = {1}; int tuple15[] = {3, 6, 7}; struct Tuple tuples3[] = {{tuple11, 3}, {tuple12, 2}, {tuple13, 3}, {tuple14, 1}, {tuple15, 3}}; struct TupleList test_list3 = {tuples3, 5}; struct Tuple expected3[] = {{tuple12, 2}, {tuple14, 1}}; struct TupleList expected_list3 = {expected3, 2}; struct TupleList result3 = remove_tuples(test_list3, 3); assert(func0(result1, expected_list1)); assert(func0(result2, expected_list2)); assert(func0(result3, expected_list3)); printf("All tests passed!\n"); return 0; }
O3
c
func0: endbr64 xor %eax,%eax cmp %ecx,%esi jne 172e <func0+0x6e> test %esi,%esi jle 1729 <func0+0x69> lea -0x1(%rsi),%eax xor %esi,%esi add $0x1,%rax shl $0x4,%rax mov %rax,%r11 mov 0x8(%rdi,%rsi,1),%eax cmp 0x8(%rdx,%rsi,1),%eax jne 1716 <func0+0x56> test %eax,%eax jle 1720 <func0+0x60> lea -0x1(%rax),%r10d mov (%rdi,%rsi,1),%r9 mov (%rdx,%rsi,1),%r8 xor %eax,%eax jmp 170c <func0+0x4c> nopl 0x0(%rax) lea 0x1(%rax),%rcx cmp %rax,%r10 je 1720 <func0+0x60> mov %rcx,%rax mov (%r8,%rax,4),%ecx cmp %ecx,(%r9,%rax,4) je 1700 <func0+0x40> xor %eax,%eax retq nopl 0x0(%rax) add $0x10,%rsi cmp %r11,%rsi jne 16de <func0+0x1e> mov $0x1,%eax retq
func0: endbr64 mov r10, rdi xor eax, eax cmp esi, ecx jnz short locret_1725 test esi, esi jle short loc_1739 movsxd rsi, esi xor edi, edi shl rsi, 4 loc_16EA: movsxd rcx, dword ptr [r10+rdi+8] cmp ecx, [rdx+rdi+8] jnz short loc_1723 test ecx, ecx jle short loc_1730 mov r9, [r10+rdi] mov r8, [rdx+rdi] shl rcx, 2 xor eax, eax jmp short loc_1719 loc_1710: add rax, 4 cmp rcx, rax jz short loc_1730 loc_1719: mov r11d, [r8+rax] cmp [r9+rax], r11d jz short loc_1710 loc_1723: xor eax, eax locret_1725: retn loc_1730: add rdi, 10h cmp rsi, rdi jnz short loc_16EA loc_1739: mov eax, 1 retn
long long func0(long long a1, int a2, long long a3, int a4) { long long result; // rax long long v6; // rdi long long v7; // rsi long long v8; // rcx long long v9; // rcx long long v10; // rax result = 0LL; if ( a2 == a4 ) { if ( a2 <= 0 ) { return 1LL; } else { v6 = 0LL; v7 = 16LL * a2; while ( 1 ) { v8 = *(int *)(a1 + v6 + 8); if ( (_DWORD)v8 != *(_DWORD *)(a3 + v6 + 8) ) return 0LL; if ( (int)v8 > 0 ) { v9 = 4 * v8; v10 = 0LL; while ( *(_DWORD *)(*(_QWORD *)(a1 + v6) + v10) == *(_DWORD *)(*(_QWORD *)(a3 + v6) + v10) ) { v10 += 4LL; if ( v9 == v10 ) goto LABEL_11; } return 0LL; } LABEL_11: v6 += 16LL; if ( v7 == v6 ) return 1LL; } } } return result; }
func0: ENDBR64 MOV R10,RDI XOR EAX,EAX CMP ESI,ECX JNZ 0x00101725 TEST ESI,ESI JLE 0x00101739 MOVSXD RSI,ESI XOR EDI,EDI SHL RSI,0x4 LAB_001016ea: MOVSXD RCX,dword ptr [R10 + RDI*0x1 + 0x8] CMP ECX,dword ptr [RDX + RDI*0x1 + 0x8] JNZ 0x00101723 TEST ECX,ECX JLE 0x00101730 MOV R9,qword ptr [R10 + RDI*0x1] MOV R8,qword ptr [RDX + RDI*0x1] SHL RCX,0x2 XOR EAX,EAX JMP 0x00101719 LAB_00101710: ADD RAX,0x4 CMP RCX,RAX JZ 0x00101730 LAB_00101719: MOV R11D,dword ptr [R8 + RAX*0x1] CMP dword ptr [R9 + RAX*0x1],R11D JZ 0x00101710 LAB_00101723: XOR EAX,EAX LAB_00101725: RET LAB_00101730: ADD RDI,0x10 CMP RSI,RDI JNZ 0x001016ea LAB_00101739: MOV EAX,0x1 RET
int8 func0(long param_1,int param_2,long param_3,int param_4) { int iVar1; long lVar2; long lVar3; if (param_2 != param_4) { return 0; } if (0 < param_2) { lVar3 = 0; do { iVar1 = *(int *)(param_1 + 8 + lVar3); if (iVar1 != *(int *)(param_3 + 8 + lVar3)) { return 0; } if (0 < iVar1) { lVar2 = 0; do { if (*(int *)(*(long *)(param_1 + lVar3) + lVar2) != *(int *)(*(long *)(param_3 + lVar3) + lVar2)) { return 0; } lVar2 = lVar2 + 4; } while ((long)iVar1 * 4 != lVar2); } lVar3 = lVar3 + 0x10; } while ((long)param_2 * 0x10 != lVar3); } return 1; }
4,680
func0
#include <assert.h> #include <math.h> #include <stdlib.h> #include <string.h>
int* func0(int test_tup1[], int test_tup2[], int n) { int* res = malloc(sizeof(int) * n); for(int i = 0; i < n; i++) { res[i] = (int)pow(test_tup1[i], test_tup2[i]); } return res; }
int main() { int test1_tup1[] = {10, 4, 5, 6}; int test1_tup2[] = {5, 6, 7, 5}; int expected1[] = {100000, 4096, 78125, 7776}; int* res1 = func0(test1_tup1, test1_tup2, 4); assert(memcmp(res1, expected1, sizeof(expected1)) == 0); free(res1); int test2_tup1[] = {11, 5, 6, 7}; int test2_tup2[] = {6, 7, 8, 6}; int expected2[] = {1771561, 78125, 1679616, 117649}; int* res2 = func0(test2_tup1, test2_tup2, 4); assert(memcmp(res2, expected2, sizeof(expected2)) == 0); free(res2); int test3_tup1[] = {12, 6, 7, 8}; int test3_tup2[] = {7, 8, 9, 7}; int expected3[] = {35831808, 1679616, 40353607, 2097152}; int* res3 = func0(test3_tup1, test3_tup2, 4); assert(memcmp(res3, expected3, sizeof(expected3)) == 0); free(res3); return 0; }
O0
c
func0: endbr64 push %rbp mov %rsp,%rbp sub $0x30,%rsp mov %rdi,-0x18(%rbp) mov %rsi,-0x20(%rbp) mov %edx,-0x24(%rbp) mov -0x24(%rbp),%eax cltq shl $0x2,%rax mov %rax,%rdi callq 10f0 <malloc@plt> mov %rax,-0x8(%rbp) movl $0x0,-0xc(%rbp) jmp 1275 <func0+0x8c> mov -0xc(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x20(%rbp),%rax add %rdx,%rax mov (%rax),%eax cvtsi2sd %eax,%xmm1 mov -0xc(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x18(%rbp),%rax add %rdx,%rax mov (%rax),%eax cvtsi2sd %eax,%xmm0 callq 10b0 <pow@plt> mov -0xc(%rbp),%eax cltq lea 0x0(,%rax,4),%rdx mov -0x8(%rbp),%rax add %rax,%rdx cvttsd2si %xmm0,%eax mov %eax,(%rdx) addl $0x1,-0xc(%rbp) mov -0xc(%rbp),%eax cmp -0x24(%rbp),%eax jl 121e <func0+0x35> mov -0x8(%rbp),%rax leaveq retq
func0: endbr64 push rbp mov rbp, rsp sub rsp, 30h mov [rbp+var_18], rdi mov [rbp+var_20], rsi mov [rbp+var_24], edx mov eax, [rbp+var_24] cdqe shl rax, 2 mov rdi, rax; size call _malloc mov [rbp+var_8], rax mov [rbp+var_C], 0 jmp short loc_128B loc_121E: mov eax, [rbp+var_C] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_20] add rax, rdx mov eax, [rax] pxor xmm0, xmm0 cvtsi2sd xmm0, eax mov eax, [rbp+var_C] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_18] add rax, rdx mov eax, [rax] pxor xmm2, xmm2 cvtsi2sd xmm2, eax movq rax, xmm2 movapd xmm1, xmm0; y movq xmm0, rax; x call _pow mov eax, [rbp+var_C] cdqe lea rdx, ds:0[rax*4] mov rax, [rbp+var_8] add rdx, rax cvttsd2si eax, xmm0 mov [rdx], eax add [rbp+var_C], 1 loc_128B: mov eax, [rbp+var_C] cmp eax, [rbp+var_24] jl short loc_121E mov rax, [rbp+var_8] leave retn
_DWORD * func0(long long a1, long long a2, int a3) { int i; // [rsp+24h] [rbp-Ch] _DWORD *v6; // [rsp+28h] [rbp-8h] v6 = malloc(4LL * a3); for ( i = 0; i < a3; ++i ) v6[i] = (int)pow((double)*(int *)(4LL * i + a1), (double)*(int *)(4LL * i + a2)); return v6; }
func0: ENDBR64 PUSH RBP MOV RBP,RSP SUB RSP,0x30 MOV qword ptr [RBP + -0x18],RDI MOV qword ptr [RBP + -0x20],RSI MOV dword ptr [RBP + -0x24],EDX MOV EAX,dword ptr [RBP + -0x24] CDQE SHL RAX,0x2 MOV RDI,RAX CALL 0x001010f0 MOV qword ptr [RBP + -0x8],RAX MOV dword ptr [RBP + -0xc],0x0 JMP 0x0010128b LAB_0010121e: MOV EAX,dword ptr [RBP + -0xc] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x20] ADD RAX,RDX MOV EAX,dword ptr [RAX] PXOR XMM0,XMM0 CVTSI2SD XMM0,EAX MOV EAX,dword ptr [RBP + -0xc] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x18] ADD RAX,RDX MOV EAX,dword ptr [RAX] PXOR XMM2,XMM2 CVTSI2SD XMM2,EAX MOVQ RAX,XMM2 MOVAPD XMM1,XMM0 MOVQ XMM0,RAX CALL 0x001010b0 MOV EAX,dword ptr [RBP + -0xc] CDQE LEA RDX,[RAX*0x4] MOV RAX,qword ptr [RBP + -0x8] ADD RDX,RAX CVTTSD2SI EAX,XMM0 MOV dword ptr [RDX],EAX ADD dword ptr [RBP + -0xc],0x1 LAB_0010128b: MOV EAX,dword ptr [RBP + -0xc] CMP EAX,dword ptr [RBP + -0x24] JL 0x0010121e MOV RAX,qword ptr [RBP + -0x8] LEAVE RET
void * func0(long param_1,long param_2,int param_3) { void *pvVar1; double dVar2; int4 local_14; pvVar1 = malloc((long)param_3 << 2); for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) { dVar2 = pow((double)*(int *)(param_1 + (long)local_14 * 4), (double)*(int *)(param_2 + (long)local_14 * 4)); *(int *)((long)local_14 * 4 + (long)pvVar1) = (int)dVar2; } return pvVar1; }
4,681
func0
#include <assert.h> #include <math.h> #include <stdlib.h> #include <string.h>
int* func0(int test_tup1[], int test_tup2[], int n) { int* res = malloc(sizeof(int) * n); for(int i = 0; i < n; i++) { res[i] = (int)pow(test_tup1[i], test_tup2[i]); } return res; }
int main() { int test1_tup1[] = {10, 4, 5, 6}; int test1_tup2[] = {5, 6, 7, 5}; int expected1[] = {100000, 4096, 78125, 7776}; int* res1 = func0(test1_tup1, test1_tup2, 4); assert(memcmp(res1, expected1, sizeof(expected1)) == 0); free(res1); int test2_tup1[] = {11, 5, 6, 7}; int test2_tup2[] = {6, 7, 8, 6}; int expected2[] = {1771561, 78125, 1679616, 117649}; int* res2 = func0(test2_tup1, test2_tup2, 4); assert(memcmp(res2, expected2, sizeof(expected2)) == 0); free(res2); int test3_tup1[] = {12, 6, 7, 8}; int test3_tup2[] = {7, 8, 9, 7}; int expected3[] = {35831808, 1679616, 40353607, 2097152}; int* res3 = func0(test3_tup1, test3_tup2, 4); assert(memcmp(res3, expected3, sizeof(expected3)) == 0); free(res3); return 0; }
O1
c
func0: endbr64 push %r14 push %r13 push %r12 push %rbp push %rbx mov %rdi,%r12 mov %rsi,%r13 mov %edx,%ebx movslq %edx,%rdi shl $0x2,%rdi callq 10f0 <malloc@plt> mov %rax,%rbp test %ebx,%ebx jle 1247 <func0+0x5e> lea -0x1(%rbx),%r14d mov $0x0,%ebx pxor %xmm0,%xmm0 cvtsi2sdl (%r12,%rbx,4),%xmm0 pxor %xmm1,%xmm1 cvtsi2sdl 0x0(%r13,%rbx,4),%xmm1 callq 10b0 <pow@plt> cvttsd2si %xmm0,%eax mov %eax,0x0(%rbp,%rbx,4) mov %rbx,%rax add $0x1,%rbx cmp %r14,%rax jne 1219 <func0+0x30> mov %rbp,%rax pop %rbx pop %rbp pop %r12 pop %r13 pop %r14 retq
func0: endbr64 push r14 push r13 push r12 push rbp push rbx mov r13, rdi mov r14, rsi mov ebp, edx movsxd rdi, edx shl rdi, 2 call _malloc mov r12, rax test ebp, ebp jle short loc_1242 mov ebp, ebp mov ebx, 0 loc_1217: pxor xmm0, xmm0 cvtsi2sd xmm0, dword ptr [r13+rbx*4+0] pxor xmm1, xmm1 cvtsi2sd xmm1, dword ptr [r14+rbx*4] call _pow cvttsd2si eax, xmm0 mov [r12+rbx*4], eax add rbx, 1 cmp rbx, rbp jnz short loc_1217 loc_1242: mov rax, r12 pop rbx pop rbp pop r12 pop r13 pop r14 retn
long long func0(long long a1, long long a2, int a3) { long long v4; // r12 long long v5; // rbx v4 = malloc(4LL * a3); if ( a3 > 0 ) { v5 = 0LL; do { *(_DWORD *)(v4 + 4 * v5) = (int)pow((double)*(int *)(a1 + 4 * v5), (double)*(int *)(a2 + 4 * v5)); ++v5; } while ( v5 != a3 ); } return v4; }
func0: ENDBR64 PUSH R14 PUSH R13 PUSH R12 PUSH RBP PUSH RBX MOV R13,RDI MOV R14,RSI MOV EBP,EDX MOVSXD RDI,EDX SHL RDI,0x2 CALL 0x001010f0 MOV R12,RAX TEST EBP,EBP JLE 0x00101242 MOV EBP,EBP MOV EBX,0x0 LAB_00101217: PXOR XMM0,XMM0 CVTSI2SD XMM0,dword ptr [R13 + RBX*0x4] PXOR XMM1,XMM1 CVTSI2SD XMM1,dword ptr [R14 + RBX*0x4] CALL 0x001010b0 CVTTSD2SI EAX,XMM0 MOV dword ptr [R12 + RBX*0x4],EAX ADD RBX,0x1 CMP RBX,RBP JNZ 0x00101217 LAB_00101242: MOV RAX,R12 POP RBX POP RBP POP R12 POP R13 POP R14 RET
void * func0(long param_1,long param_2,uint param_3) { void *pvVar1; ulong uVar2; double dVar3; pvVar1 = malloc((long)(int)param_3 << 2); if (0 < (int)param_3) { uVar2 = 0; do { dVar3 = pow((double)*(int *)(param_1 + uVar2 * 4),(double)*(int *)(param_2 + uVar2 * 4)); *(int *)((long)pvVar1 + uVar2 * 4) = (int)dVar3; uVar2 = uVar2 + 1; } while (uVar2 != param_3); } return pvVar1; }