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(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
regfree(®ex);
return "Matched!";
}
regfree(®ex);
}
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(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
regfree(®ex);
return "Matched!";
}
regfree(®ex);
}
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(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
regfree(®ex);
return "Matched!";
}
regfree(®ex);
}
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(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
regfree(®ex);
return "Matched!";
}
regfree(®ex);
}
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(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
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(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
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(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
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(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
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;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.