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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
7,282 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare_arrays(int* arr1, int* arr2, int len) {
for (int i = 0; i < len; i++) {
if (arr1[i] != arr2[i]) {
return 0;
}
}
return 1;
}
| int* func0(int* xs, int length) {
int* copy = malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
copy[i] = xs[i];
}
return copy;
}
| int main() {
int xs1[] = {1, 2, 3};
int* result1 = func0(xs1, 3);
assert(compare_arrays(result1, xs1, 3));
int xs2[] = {4, 8, 2, 10, 15, 18};
int* result2 = func0(xs2, 6);
assert(compare_arrays(result2, xs2, 6));
int xs3[] = {4, 5, 6};
int* result3 = func0(xs3, 3);
assert(compare_arrays(result3, xs3, 3));
free(result1);
free(result2);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 12fa <func0+0x3a>
lea -0x1(%rbp),%esi
xor %edx,%edx
nopl (%rax)
mov (%rbx,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 12e8 <func0+0x28>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
movsxd r12, esi
push rbp
mov rbp, rdi
push rbx
mov rbx, r12
shl r12, 2
mov rdi, r12
call _malloc
mov r8, rax
test ebx, ebx
jle short loc_13E5
mov rdx, r12
mov rsi, rbp
mov rdi, rax
call _memcpy
mov r8, rax
loc_13E5:
pop rbx
mov rax, r8
pop rbp
pop r12
retn | long long func0(long long a1, int a2)
{
long long v2; // rax
long long v3; // rcx
long long v4; // r8
v2 = malloc(4LL * a2);
v4 = v2;
if ( a2 > 0 )
return memcpy(v2, a1, 4LL * a2, v3, v2);
return v4;
} | func0:
ENDBR64
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,R12
SHL R12,0x2
MOV RDI,R12
CALL 0x001010d0
MOV R8,RAX
TEST EBX,EBX
JLE 0x001013e5
MOV RDX,R12
MOV RSI,RBP
MOV RDI,RAX
CALL 0x001010c0
MOV R8,RAX
LAB_001013e5:
POP RBX
MOV RAX,R8
POP RBP
POP R12
RET | void * func0(void *param_1,int param_2)
{
void *__dest;
__dest = malloc((long)param_2 << 2);
if (0 < param_2) {
__dest = memcpy(__dest,param_1,(long)param_2 << 2);
}
return __dest;
} |
7,283 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare_arrays(int* arr1, int* arr2, int len) {
for (int i = 0; i < len; i++) {
if (arr1[i] != arr2[i]) {
return 0;
}
}
return 1;
}
| int* func0(int* xs, int length) {
int* copy = malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
copy[i] = xs[i];
}
return copy;
}
| int main() {
int xs1[] = {1, 2, 3};
int* result1 = func0(xs1, 3);
assert(compare_arrays(result1, xs1, 3));
int xs2[] = {4, 8, 2, 10, 15, 18};
int* result2 = func0(xs2, 6);
assert(compare_arrays(result2, xs2, 6));
int xs3[] = {4, 5, 6};
int* result3 = func0(xs3, 3);
assert(compare_arrays(result3, xs3, 3));
free(result1);
free(result2);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %rax,%r8
test %ebx,%ebx
jle 130c <func0+0x3c>
lea -0x1(%rbx),%eax
mov %r8,%rdi
mov %rbp,%rsi
lea 0x4(,%rax,4),%rdx
callq 10c0 <memcpy@plt>
mov %rax,%r8
add $0x8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov rbx, rdi
shl rdi, 2; size
sub rsp, 8
call _malloc
mov rcx, rax
test ebx, ebx
jle short loc_12F7
mov edx, ebx
mov rsi, rbp; src
mov rdi, rax; dest
shl rdx, 2; n
call _memcpy
mov rcx, rax
loc_12F7:
add rsp, 8
mov rax, rcx
pop rbx
pop rbp
retn | void * func0(void *src, int a2)
{
void *v2; // rax
void *v3; // rcx
v2 = malloc(4LL * a2);
v3 = v2;
if ( a2 > 0 )
return memcpy(v2, src, 4LL * (unsigned int)a2);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010d0
MOV RCX,RAX
TEST EBX,EBX
JLE 0x001012f7
MOV EDX,EBX
MOV RSI,RBP
MOV RDI,RAX
SHL RDX,0x2
CALL 0x001010c0
MOV RCX,RAX
LAB_001012f7:
ADD RSP,0x8
MOV RAX,RCX
POP RBX
POP RBP
RET | void * func0(void *param_1,uint param_2)
{
void *__dest;
__dest = malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
__dest = memcpy(__dest,param_1,(ulong)param_2 << 2);
}
return __dest;
} |
7,284 | func0 | #include <assert.h>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd %xmm2,-0x28(%rbp)
movsd -0x18(%rbp),%xmm0
movapd %xmm0,%xmm1
addsd -0x20(%rbp),%xmm1
movsd 0xf1a(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd -0x28(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd [rbp+var_28], xmm2
movsd xmm0, [rbp+var_18]
movapd xmm1, xmm0
addsd xmm1, [rbp+var_20]
movsd xmm0, cs:qword_2078
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_28]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1, double a2, double a3)
{
return 0.5 * (a1 + a2) * a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD qword ptr [RBP + -0x28],XMM2
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
ADDSD XMM1,qword ptr [RBP + -0x20]
MOVSD XMM0,qword ptr [0x00102078]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x28]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1,double param_2,double param_3)
{
return DAT_00102078 * (param_1 + param_2) * param_3;
} |
7,285 | func0 | #include <assert.h>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O1 | c | func0:
endbr64
addsd %xmm1,%xmm0
mulsd 0xecf(%rip),%xmm0
mulsd %xmm2,%xmm0
retq
| func0:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5 * a3;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2,double param_3)
{
return (param_1 + param_2) * _DAT_00102008 * param_3;
} |
7,286 | func0 | #include <assert.h>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O2 | c | func0:
endbr64
addsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5 * a3;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2,double param_3)
{
return (param_1 + param_2) * _DAT_00102008 * param_3;
} |
7,287 | func0 | #include <assert.h>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O3 | c | func0:
endbr64
addsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5 * a3;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2,double param_3)
{
return (param_1 + param_2) * _DAT_00102008 * param_3;
} |
7,288 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int SumOfPrimeDivisors[N + 1];
for (int i = 0; i <= N; i++) {
SumOfPrimeDivisors[i] = 0;
}
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x44(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1207 <func0+0x9e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f0 <func0+0x87>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1231 <func0+0xc8>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 1262 <func0+0xf9>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
movl $0x0,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 124d <func0+0xe4>
movl $0x2,-0x30(%rbp)
jmp 12be <func0+0x155>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
test %eax,%eax
jne 12ba <func0+0x151>
mov -0x30(%rbp),%eax
mov %eax,-0x34(%rbp)
jmp 12b2 <func0+0x149>
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x30(%rbp),%eax
lea (%rdx,%rax,1),%ecx
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
mov -0x30(%rbp),%eax
add %eax,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 128c <func0+0x123>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 1273 <func0+0x10a>
mov -0x20(%rbp),%rax
mov -0x44(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 12ea <func0+0x181>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11D5:
cmp rsp, rdx
jz short loc_11EC
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11D5
loc_11EC:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1216
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1216:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_24], 0
jmp short loc_1247
loc_1232:
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 0
add [rbp+var_24], 1
loc_1247:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_34]
jle short loc_1232
mov [rbp+var_20], 2
jmp short loc_12A3
loc_1258:
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
test eax, eax
jnz short loc_129F
mov eax, [rbp+var_20]
mov [rbp+var_1C], eax
jmp short loc_1297
loc_1271:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov eax, [rbp+var_20]
lea ecx, [rdx+rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
mov eax, [rbp+var_20]
add [rbp+var_1C], eax
loc_1297:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_34]
jle short loc_1271
loc_129F:
add [rbp+var_20], 1
loc_12A3:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_34]
jle short loc_1258
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12CF
call ___stack_chk_fail
locret_12CF:
leave
retn | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
_BYTE v4[12]; // [rsp+8h] [rbp-40h] BYREF
int v5; // [rsp+14h] [rbp-34h]
int i; // [rsp+24h] [rbp-24h]
int j; // [rsp+28h] [rbp-20h]
int k; // [rsp+2Ch] [rbp-1Ch]
long long v9; // [rsp+30h] [rbp-18h]
_BYTE *v10; // [rsp+38h] [rbp-10h]
unsigned long long v11; // [rsp+40h] [rbp-8h]
v5 = a1;
v11 = __readfsqword(0x28u);
v9 = a1 + 1 - 1LL;
v1 = 16 * ((4LL * (a1 + 1) + 15) / 0x10uLL);
while ( v4 != &v4[-(v1 & 0xFFFFFFFFFFFFF000LL)] )
;
v2 = alloca(v1 & 0xFFF);
if ( (v1 & 0xFFF) != 0 )
*(_QWORD *)&v4[(v1 & 0xFFF) - 8] = *(_QWORD *)&v4[(v1 & 0xFFF) - 8];
v10 = v4;
for ( i = 0; i <= v5; ++i )
*(_DWORD *)&v10[4 * i] = 0;
for ( j = 2; j <= v5; ++j )
{
if ( !*(_DWORD *)&v10[4 * j] )
{
for ( k = j; k <= v5; k += j )
*(_DWORD *)&v10[4 * k] += j;
}
}
return *(unsigned int *)&v10[4 * v5];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011d5:
CMP RSP,RDX
JZ 0x001011ec
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d5
LAB_001011ec:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101216
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101216:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101247
LAB_00101232:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x0
ADD dword ptr [RBP + -0x24],0x1
LAB_00101247:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101232
MOV dword ptr [RBP + -0x20],0x2
JMP 0x001012a3
LAB_00101258:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
TEST EAX,EAX
JNZ 0x0010129f
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00101297
LAB_00101271:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x20]
LEA ECX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
MOV EAX,dword ptr [RBP + -0x20]
ADD dword ptr [RBP + -0x1c],EAX
LAB_00101297:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101271
LAB_0010129f:
ADD dword ptr [RBP + -0x20],0x1
LAB_001012a3:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101258
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012cf
CALL 0x00101060
LAB_001012cf:
LEAVE
RET | int4 func0(int param_1)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [12];
int local_3c;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_3c = param_1;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_1 + 1) + -1;
uVar2 = (((long)(param_1 + 1) * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_2c = 0; local_2c <= local_3c; local_2c = local_2c + 1) {
*(int4 *)(puVar3 + (long)local_2c * 4 + lVar1) = 0;
}
for (local_28 = 2; local_28 <= local_3c; local_28 = local_28 + 1) {
if (*(int *)(puVar3 + (long)local_28 * 4 + lVar1) == 0) {
for (local_24 = local_28; local_24 <= local_3c; local_24 = local_24 + local_28) {
*(int *)(puVar3 + (long)local_24 * 4 + lVar1) =
*(int *)(puVar3 + (long)local_24 * 4 + lVar1) + local_28;
}
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)(puVar3 + (long)local_3c * 4 + lVar1);
} |
7,289 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int SumOfPrimeDivisors[N + 1];
for (int i = 0; i <= N; i++) {
SumOfPrimeDivisors[i] = 0;
}
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je 11be <func0+0x55>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11a7 <func0+0x3e>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d4 <func0+0x6b>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r9
mov %r9,%rcx
test %edi,%edi
js 11f7 <func0+0x8e>
mov %r9,%rax
mov %edi,%edx
lea 0x4(%r9,%rdx,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 11e8 <func0+0x7f>
cmp $0x1,%edi
jle 122f <func0+0xc6>
lea -0x2(%rdi),%r8d
add $0x3,%r8
mov $0x2,%edx
jmp 1214 <func0+0xab>
add $0x1,%rdx
cmp %r8,%rdx
je 122f <func0+0xc6>
mov %edx,%esi
cmpl $0x0,(%rcx,%rdx,4)
jne 120b <func0+0xa2>
cmp %edx,%edi
jl 120b <func0+0xa2>
mov %rdx,%rax
add %esi,(%rcx,%rax,4)
add %rdx,%rax
cmp %eax,%edi
jge 1223 <func0+0xba>
jmp 120b <func0+0xa2>
movslq %edi,%rdi
mov (%r9,%rdi,4),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
jne 1247 <func0+0xde>
leaveq
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov esi, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A6:
cmp rsp, rdx
jz short loc_11BD
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11A6
loc_11BD:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11D3
or [rsp+rax+10h+var_18], 0
loc_11D3:
mov rcx, rsp
test esi, esi
js short loc_11F3
mov rax, rcx
lea edx, [rsi+1]
lea rdx, [rcx+rdx*4]
loc_11E4:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_11E4
loc_11F3:
cmp esi, 1
jle short loc_1227
lea r8d, [rsi+1]
mov edx, 2
jmp short loc_120C
loc_1203:
add rdx, 1
cmp rdx, r8
jz short loc_1227
loc_120C:
mov edi, edx
cmp dword ptr [rcx+rdx*4], 0
jnz short loc_1203
cmp esi, edx
jl short loc_1203
mov rax, rdx
loc_121B:
add [rcx+rax*4], edi
add rax, rdx
cmp esi, eax
jge short loc_121B
jmp short loc_1203
loc_1227:
movsxd rsi, esi
mov eax, [rcx+rsi*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_123E
leave
retn
loc_123E:
call ___stack_chk_fail | long long func0(int a1)
{
signed long long v1; // rax
void *v2; // rsp
_DWORD *v3; // rax
long long v4; // rdx
long long v5; // rax
_DWORD v8[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v9; // [rsp+10h] [rbp-8h]
v9 = __readfsqword(0x28u);
while ( v8 != (_DWORD *)((char *)v8 - ((4LL * (a1 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v1 = (4 * ((_WORD)a1 + 1) + 15) & 0xFF0;
v2 = alloca(v1);
if ( ((4 * ((_WORD)a1 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v8[-2] + v1) = *(_QWORD *)((char *)&v8[-2] + v1);
if ( a1 >= 0 )
{
v3 = v8;
do
*v3++ = 0;
while ( v3 != &v8[a1 + 1] );
}
if ( a1 > 1 )
{
v4 = 2LL;
do
{
if ( !v8[v4] && a1 >= (int)v4 )
{
v5 = v4;
do
{
v8[v5] += v4;
v5 += v4;
}
while ( a1 >= (int)v5 );
}
++v4;
}
while ( v4 != a1 + 1 );
}
return (unsigned int)v8[a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a6:
CMP RSP,RDX
JZ 0x001011bd
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011a6
LAB_001011bd:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011d3
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011d3:
MOV RCX,RSP
TEST ESI,ESI
JS 0x001011f3
MOV RAX,RCX
LEA EDX,[RSI + 0x1]
LEA RDX,[RCX + RDX*0x4]
LAB_001011e4:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011e4
LAB_001011f3:
CMP ESI,0x1
JLE 0x00101227
LEA R8D,[RSI + 0x1]
MOV EDX,0x2
JMP 0x0010120c
LAB_00101203:
ADD RDX,0x1
CMP RDX,R8
JZ 0x00101227
LAB_0010120c:
MOV EDI,EDX
CMP dword ptr [RCX + RDX*0x4],0x0
JNZ 0x00101203
CMP ESI,EDX
JL 0x00101203
MOV RAX,RDX
LAB_0010121b:
ADD dword ptr [RCX + RAX*0x4],EDI
ADD RAX,RDX
CMP ESI,EAX
JGE 0x0010121b
JMP 0x00101203
LAB_00101227:
MOVSXD RSI,ESI
MOV EAX,dword ptr [RCX + RSI*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010123e
LEAVE
RET
LAB_0010123e:
CALL 0x00101060 | int4 func0(int param_1)
{
long lVar1;
int iVar2;
int4 *puVar3;
ulong uVar4;
ulong uVar5;
int1 *puVar6;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(param_1 + 1) * 4 + 0xf;
for (puVar6 = auStack_18; puVar6 != auStack_18 + -(uVar5 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar1 = -uVar5;
puVar3 = (int4 *)(puVar6 + lVar1);
if (uVar5 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (-1 < param_1) {
do {
*puVar3 = 0;
puVar3 = puVar3 + 1;
} while (puVar3 != (int4 *)(puVar6 + (ulong)(param_1 + 1) * 4 + lVar1));
}
if (1 < param_1) {
uVar5 = 2;
do {
uVar4 = uVar5;
iVar2 = (int)uVar5;
if (*(int *)(puVar6 + uVar5 * 4 + lVar1) == 0) {
while (iVar2 <= param_1) {
*(int *)(puVar6 + uVar4 * 4 + lVar1) = *(int *)(puVar6 + uVar4 * 4 + lVar1) + (int)uVar5;
uVar4 = uVar4 + uVar5;
iVar2 = (int)uVar4;
}
}
uVar5 = uVar5 + 1;
} while (uVar5 != param_1 + 1);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + lVar1 + -8) = main;
__stack_chk_fail();
}
return *(int4 *)(puVar6 + (long)param_1 * 4 + lVar1);
} |
7,290 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int SumOfPrimeDivisors[N + 1];
for (int i = 0; i <= N; i++) {
SumOfPrimeDivisors[i] = 0;
}
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rsi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je 1268 <func0+0x58>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1253 <func0+0x43>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1306 <func0+0xf6>
mov %rsp,%rsi
movslq %edi,%r10
test %edi,%edi
js 12f1 <func0+0xe1>
movslq %edi,%r10
mov %rsi,%rax
lea 0x4(%rsi,%r10,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1290 <func0+0x80>
cmp $0x1,%edi
jle 12f1 <func0+0xe1>
lea -0x2(%rdi),%r9d
mov $0x2,%ecx
add $0x3,%r9
jmp 12c1 <func0+0xb1>
nopl 0x0(%rax,%rax,1)
add $0x1,%rcx
cmp %r9,%rcx
je 12f1 <func0+0xe1>
mov (%rsi,%rcx,4),%edx
mov %ecx,%r8d
test %edx,%edx
jne 12b8 <func0+0xa8>
cmp %ecx,%edi
jl 12b8 <func0+0xa8>
mov %rcx,%rax
jmp 12db <func0+0xcb>
nopl 0x0(%rax)
mov (%rsi,%rax,4),%edx
add %r8d,%edx
mov %edx,(%rsi,%rax,4)
add %rcx,%rax
cmp %eax,%edi
jge 12d8 <func0+0xc8>
add $0x1,%rcx
cmp %r9,%rcx
jne 12c1 <func0+0xb1>
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
mov (%rsi,%r10,4),%eax
jne 1311 <func0+0x101>
leaveq
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 127a <func0+0x6a>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
lea r12d, [rdi+1]
push rbx
mov ebx, edi
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, r12d
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_128E
loc_1279:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_1279
loc_128E:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1326
loc_12A0:
mov rdi, rsp
movsxd r13, ebx
test ebx, ebx
js short loc_1308
lea rdx, ds:4[r13*4]
xor esi, esi
call _memset
mov rdi, rax
cmp ebx, 1
jle short loc_1308
mov r8d, r12d
mov ecx, 2
jmp short loc_12D9
loc_12D0:
add rcx, 1
cmp rcx, r8
jz short loc_1308
loc_12D9:
mov edx, [rdi+rcx*4]
mov esi, ecx
test edx, edx
jnz short loc_12D0
cmp ebx, ecx
jl short loc_12D0
mov rax, rcx
jmp short loc_12F3
loc_12F0:
mov edx, [rdi+rax*4]
loc_12F3:
add edx, esi
mov [rdi+rax*4], edx
add rax, rcx
cmp ebx, eax
jge short loc_12F0
add rcx, 1
cmp rcx, r8
jnz short loc_12D9
loc_1308:
mov eax, [rdi+r13*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_1331
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_1326:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_12A0
loc_1331:
call ___stack_chk_fail | long long func0(int a1)
{
int v1; // r12d
long long v3; // rdx
_BYTE *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
_BYTE *v8; // rdi
long long v9; // rcx
int v10; // edx
long long i; // rax
_BYTE v14[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v15[6]; // [rsp+1008h] [rbp-30h] BYREF
v1 = a1 + 1;
v15[1] = __readfsqword(0x28u);
v3 = 4LL * (a1 + 1) + 15;
v4 = (char *)v15 - (v3 & 0xFFFFFFFFFFFFF000LL);
v5 = v3 & 0xFFF0;
if ( v15 != (_QWORD *)v4 )
{
while ( v14 != v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(_QWORD *)&v14[v6 - 8] = *(_QWORD *)&v14[v6 - 8];
v8 = v14;
if ( a1 >= 0 )
{
v8 = (_BYTE *)memset(v14, 0LL, 4LL * a1 + 4);
if ( a1 > 1 )
{
v9 = 2LL;
do
{
while ( 1 )
{
v10 = *(_DWORD *)&v8[4 * v9];
if ( !v10 && a1 >= (int)v9 )
break;
if ( ++v9 == v1 )
return *(unsigned int *)&v8[4 * a1];
}
for ( i = v9; ; v10 = *(_DWORD *)&v8[4 * i] )
{
*(_DWORD *)&v8[4 * i] = v9 + v10;
i += v9;
if ( a1 < (int)i )
break;
}
++v9;
}
while ( v9 != v1 );
}
}
return *(unsigned int *)&v8[4 * a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBX
MOV EBX,EDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,R12D
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010128e
LAB_00101279:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101279
LAB_0010128e:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101326
LAB_001012a0:
MOV RDI,RSP
MOVSXD R13,EBX
TEST EBX,EBX
JS 0x00101308
LEA RDX,[0x4 + R13*0x4]
XOR ESI,ESI
CALL 0x00101090
MOV RDI,RAX
CMP EBX,0x1
JLE 0x00101308
MOV R8D,R12D
MOV ECX,0x2
JMP 0x001012d9
LAB_001012d0:
ADD RCX,0x1
CMP RCX,R8
JZ 0x00101308
LAB_001012d9:
MOV EDX,dword ptr [RDI + RCX*0x4]
MOV ESI,ECX
TEST EDX,EDX
JNZ 0x001012d0
CMP EBX,ECX
JL 0x001012d0
MOV RAX,RCX
JMP 0x001012f3
LAB_001012f0:
MOV EDX,dword ptr [RDI + RAX*0x4]
LAB_001012f3:
ADD EDX,ESI
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,RCX
CMP EBX,EAX
JGE 0x001012f0
ADD RCX,0x1
CMP RCX,R8
JNZ 0x001012d9
LAB_00101308:
MOV EAX,dword ptr [RDI + R13*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101331
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_00101326:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012a0
LAB_00101331:
CALL 0x00101070 | int4 func0(int param_1)
{
long lVar1;
int1 *puVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int1 *puVar6;
uint uVar8;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar7;
uVar8 = param_1 + 1;
puVar6 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)uVar8 * 4 + 0xf;
puVar7 = auStack_38;
puVar2 = auStack_38;
while (puVar7 != auStack_38 + -(uVar4 & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
puVar2 = puVar6 + lVar1;
if (uVar4 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (-1 < param_1) {
*(int8 *)(puVar6 + lVar1 + -8) = 0x1012b9;
puVar2 = (int1 *)memset(puVar6 + lVar1,0,(long)param_1 * 4 + 4);
if (1 < param_1) {
uVar4 = 2;
do {
while ((*(int *)(puVar2 + uVar4 * 4) == 0 && ((int)uVar4 <= param_1))) {
iVar5 = 0;
uVar3 = uVar4;
while( true ) {
*(int *)(puVar2 + uVar3 * 4) = iVar5 + (int)uVar4;
uVar3 = uVar3 + uVar4;
if (param_1 < (int)uVar3) break;
iVar5 = *(int *)(puVar2 + uVar3 * 4);
}
uVar4 = uVar4 + 1;
if (uVar4 == uVar8) goto LAB_00101308;
}
uVar4 = uVar4 + 1;
} while (uVar4 != uVar8);
}
}
LAB_00101308:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x101336;
__stack_chk_fail();
}
return *(int4 *)(puVar2 + (long)param_1 * 4);
} |
7,291 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int N) {
int SumOfPrimeDivisors[N + 1];
for (int i = 0; i <= N; i++) {
SumOfPrimeDivisors[i] = 0;
}
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
mov %edi,%ebx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rdi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 128d <func0+0x5d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1278 <func0+0x48>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1317 <func0+0xe7>
mov %rsp,%rcx
movslq %ebx,%r12
test %ebx,%ebx
js 12fb <func0+0xcb>
mov %rcx,%rdi
lea 0x4(,%r12,4),%rdx
xor %esi,%esi
callq 1090 <memset@plt>
mov %rax,%rcx
cmp $0x1,%ebx
jle 12fb <func0+0xcb>
lea -0x2(%rbx),%edi
mov $0x2,%edx
add $0x3,%rdi
jmp 12d9 <func0+0xa9>
nopl (%rax)
add $0x1,%rdx
cmp %rdi,%rdx
je 12fb <func0+0xcb>
mov (%rcx,%rdx,4),%eax
mov %edx,%esi
test %eax,%eax
jne 12d0 <func0+0xa0>
mov %rdx,%rax
nopl (%rax)
add %esi,(%rcx,%rax,4)
add %rdx,%rax
cmp %eax,%ebx
jge 12e8 <func0+0xb8>
add $0x1,%rdx
cmp %rdi,%rdx
jne 12d9 <func0+0xa9>
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
mov (%rcx,%r12,4),%eax
jne 1322 <func0+0xf2>
lea -0x10(%rbp),%rsp
pop %rbx
pop %r12
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 129b <func0+0x6b>
callq 1070 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
lea r12d, [rdi+1]
push rbx
mov ebx, edi
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, r12d
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_128E
loc_1279:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_1279
loc_128E:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz short loc_1314
loc_129C:
mov rcx, rsp
movsxd r13, ebx
test ebx, ebx
js short loc_12E0
mov rdi, rcx; s
lea rdx, ds:4[r13*4]; n
xor esi, esi; c
call _memset
mov rcx, rax
cmp ebx, 1
jle short loc_12E0
mov edi, r12d
mov edx, 2
nop dword ptr [rax+rax+00000000h]
loc_12D0:
mov eax, [rcx+rdx*4]
test eax, eax
jz short loc_1300
loc_12D7:
add rdx, 1
cmp rdi, rdx
jnz short loc_12D0
loc_12E0:
mov eax, [rcx+r13*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_131C
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_1300:
mov esi, edx
mov rax, rdx
nop dword ptr [rax]
loc_1308:
add [rcx+rax*4], esi
add rax, rdx
cmp ebx, eax
jge short loc_1308
jmp short loc_12D7
loc_1314:
or [rsp+rdx+1030h+var_1038], 0
jmp short loc_129C
loc_131C:
call ___stack_chk_fail | long long func0(int a1)
{
long long v1; // rdx
_BYTE *v2; // rcx
__int16 v3; // dx
signed long long v4; // rdx
void *v5; // rsp
_BYTE *v6; // rcx
long long v7; // rdx
long long v9; // rax
_BYTE v11[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v12[6]; // [rsp+1008h] [rbp-30h] BYREF
v12[1] = __readfsqword(0x28u);
v1 = 4LL * (a1 + 1) + 15;
v2 = (char *)v12 - (v1 & 0xFFFFFFFFFFFFF000LL);
v3 = v1 & 0xFFF0;
if ( v12 != (_QWORD *)v2 )
{
while ( v11 != v2 )
;
}
v4 = v3 & 0xFFF;
v5 = alloca(v4);
if ( v4 )
*(_QWORD *)&v11[v4 - 8] = *(_QWORD *)&v11[v4 - 8];
v6 = v11;
if ( a1 >= 0 )
{
v6 = memset(v11, 0, 4LL * a1 + 4);
if ( a1 > 1 )
{
v7 = 2LL;
do
{
if ( !*(_DWORD *)&v6[4 * v7] )
{
v9 = v7;
do
{
*(_DWORD *)&v6[4 * v9] += v7;
v9 += v7;
}
while ( a1 >= (int)v9 );
}
++v7;
}
while ( a1 + 1 != v7 );
}
}
return *(unsigned int *)&v6[4 * a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBX
MOV EBX,EDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,R12D
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010128e
LAB_00101279:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101279
LAB_0010128e:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101314
LAB_0010129c:
MOV RCX,RSP
MOVSXD R13,EBX
TEST EBX,EBX
JS 0x001012e0
MOV RDI,RCX
LEA RDX,[0x4 + R13*0x4]
XOR ESI,ESI
CALL 0x00101090
MOV RCX,RAX
CMP EBX,0x1
JLE 0x001012e0
MOV EDI,R12D
MOV EDX,0x2
NOP dword ptr [RAX + RAX*0x1]
LAB_001012d0:
MOV EAX,dword ptr [RCX + RDX*0x4]
TEST EAX,EAX
JZ 0x00101300
LAB_001012d7:
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x001012d0
LAB_001012e0:
MOV EAX,dword ptr [RCX + R13*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010131c
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_00101300:
MOV ESI,EDX
MOV RAX,RDX
NOP dword ptr [RAX]
LAB_00101308:
ADD dword ptr [RCX + RAX*0x4],ESI
ADD RAX,RDX
CMP EBX,EAX
JGE 0x00101308
JMP 0x001012d7
LAB_00101314:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010129c
LAB_0010131c:
CALL 0x00101070 | int4 func0(int param_1)
{
long lVar1;
int *puVar2;
ulong uVar3;
ulong uVar4;
int *puVar5;
long in_FS_OFFSET;
int auStack_38 [8];
long local_30;
int *puVar6;
puVar5 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)(param_1 + 1U) * 4 + 0xf;
puVar6 = auStack_38;
puVar2 = auStack_38;
while (puVar6 != auStack_38 + -(uVar4 & 0xfffffffffffff000)) {
puVar5 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar6 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
puVar2 = puVar5 + lVar1;
if (uVar4 != 0) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
if (-1 < param_1) {
*(int8 *)(puVar5 + lVar1 + -8) = 0x1012b8;
puVar2 = (int *)memset(puVar5 + lVar1,0,(long)param_1 * 4 + 4);
if (1 < param_1) {
uVar4 = 2;
do {
uVar3 = uVar4;
if (*(int *)(puVar2 + uVar4 * 4) == 0) {
do {
*(int *)(puVar2 + uVar3 * 4) = *(int *)(puVar2 + uVar3 * 4) + (int)uVar4;
uVar3 = uVar3 + uVar4;
} while ((int)uVar3 <= param_1);
}
uVar4 = uVar4 + 1;
} while (param_1 + 1U != uVar4);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar2 + (long)param_1 * 4);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar5 + lVar1 + -8) = 0x101321;
__stack_chk_fail();
} |
7,292 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
if (a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if ((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return 1;
} else {
return 0;
}
} else {
return 0;
}
}
| int main() {
assert(func0(50, 60, 70) == 1);
assert(func0(90, 45, 45) == 1);
assert(func0(150, 30, 70) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
cmpl $0x0,-0x4(%rbp)
je 11b5 <func0+0x6c>
cmpl $0x0,-0x8(%rbp)
je 11b5 <func0+0x6c>
cmpl $0x0,-0xc(%rbp)
je 11b5 <func0+0x6c>
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %eax,%edx
mov -0xc(%rbp),%eax
add %edx,%eax
cmp $0xb4,%eax
jne 11b5 <func0+0x6c>
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
cmp %eax,-0xc(%rbp)
jle 11a7 <func0+0x5e>
mov -0x8(%rbp),%edx
mov -0xc(%rbp),%eax
add %edx,%eax
cmp %eax,-0x4(%rbp)
jle 11a7 <func0+0x5e>
mov -0x4(%rbp),%edx
mov -0xc(%rbp),%eax
add %edx,%eax
cmp %eax,-0x8(%rbp)
jg 11ae <func0+0x65>
mov $0x1,%eax
jmp 11ba <func0+0x71>
mov $0x0,%eax
jmp 11ba <func0+0x71>
mov $0x0,%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
cmp [rbp+var_4], 0
jz short loc_11B5
cmp [rbp+var_8], 0
jz short loc_11B5
cmp [rbp+var_C], 0
jz short loc_11B5
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add edx, eax
mov eax, [rbp+var_C]
add eax, edx
cmp eax, 0B4h
jnz short loc_11B5
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
cmp [rbp+var_C], eax
jle short loc_11A7
mov edx, [rbp+var_8]
mov eax, [rbp+var_C]
add eax, edx
cmp [rbp+var_4], eax
jle short loc_11A7
mov edx, [rbp+var_4]
mov eax, [rbp+var_C]
add eax, edx
cmp [rbp+var_8], eax
jg short loc_11AE
loc_11A7:
mov eax, 1
jmp short loc_11BA
loc_11AE:
mov eax, 0
jmp short loc_11BA
loc_11B5:
mov eax, 0
loc_11BA:
pop rbp
retn | _BOOL8 func0(int a1, int a2, int a3)
{
if ( !a1 || !a2 || !a3 || a2 + a1 + a3 != 180 )
return 0LL;
return a3 <= a1 + a2 || a1 <= a2 + a3 || a2 <= a1 + a3;
} | 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
CMP dword ptr [RBP + -0x4],0x0
JZ 0x001011b5
CMP dword ptr [RBP + -0x8],0x0
JZ 0x001011b5
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001011b5
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EDX
CMP EAX,0xb4
JNZ 0x001011b5
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
CMP dword ptr [RBP + -0xc],EAX
JLE 0x001011a7
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EDX
CMP dword ptr [RBP + -0x4],EAX
JLE 0x001011a7
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EDX
CMP dword ptr [RBP + -0x8],EAX
JG 0x001011ae
LAB_001011a7:
MOV EAX,0x1
JMP 0x001011ba
LAB_001011ae:
MOV EAX,0x0
JMP 0x001011ba
LAB_001011b5:
MOV EAX,0x0
LAB_001011ba:
POP RBP
RET | int8 func0(int param_1,int param_2,int param_3)
{
int8 uVar1;
if ((((param_1 == 0) || (param_2 == 0)) || (param_3 == 0)) ||
(param_3 + param_1 + param_2 != 0xb4)) {
uVar1 = 0;
}
else if (((param_2 + param_1 < param_3) && (param_3 + param_2 < param_1)) &&
(param_3 + param_1 < param_2)) {
uVar1 = 0;
}
else {
uVar1 = 1;
}
return uVar1;
} |
7,293 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
if (a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if ((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return 1;
} else {
return 0;
}
} else {
return 0;
}
}
| int main() {
assert(func0(50, 60, 70) == 1);
assert(func0(90, 45, 45) == 1);
assert(func0(150, 30, 70) == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
setne %cl
test %edx,%edx
setne %al
test %al,%cl
je 116f <func0+0x46>
test %edi,%edi
je 116f <func0+0x46>
lea (%rdi,%rsi,1),%ecx
lea (%rcx,%rdx,1),%r8d
mov $0x0,%eax
cmp $0xb4,%r8d
jne 1174 <func0+0x4b>
mov $0x1,%eax
cmp %edx,%ecx
jge 1174 <func0+0x4b>
lea (%rsi,%rdx,1),%ecx
cmp %edi,%ecx
jge 1174 <func0+0x4b>
add %edi,%edx
cmp %esi,%edx
setge %al
movzbl %al,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test esi, esi
setnz cl
test edx, edx
setnz al
test cl, al
jz short loc_116F
test edi, edi
jz short loc_116F
lea ecx, [rdi+rsi]
lea r8d, [rcx+rdx]
mov eax, 0
cmp r8d, 0B4h
jnz short locret_1174
mov eax, 1
cmp ecx, edx
jge short locret_1174
lea ecx, [rsi+rdx]
cmp ecx, edi
jge short locret_1174
add edi, edx
cmp edi, esi
setnl al
movzx eax, al
retn
loc_116F:
mov eax, 0
locret_1174:
retn | _BOOL8 func0(int a1, int a2, int a3)
{
_BOOL8 result; // rax
if ( a3 == 0 || a2 == 0 || !a1 )
return 0LL;
result = 0LL;
if ( a1 + a2 + a3 == 180 )
{
result = 1LL;
if ( a1 + a2 < a3 && a2 + a3 < a1 )
return a3 + a1 >= a2;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
SETNZ CL
TEST EDX,EDX
SETNZ AL
TEST CL,AL
JZ 0x0010116f
TEST EDI,EDI
JZ 0x0010116f
LEA ECX,[RDI + RSI*0x1]
LEA R8D,[RCX + RDX*0x1]
MOV EAX,0x0
CMP R8D,0xb4
JNZ 0x00101174
MOV EAX,0x1
CMP ECX,EDX
JGE 0x00101174
LEA ECX,[RSI + RDX*0x1]
CMP ECX,EDI
JGE 0x00101174
ADD EDI,EDX
CMP EDI,ESI
SETGE AL
MOVZX EAX,AL
RET
LAB_0010116f:
MOV EAX,0x0
LAB_00101174:
RET | bool func0(int param_1,int param_2,int param_3)
{
bool bVar1;
if ((param_2 == 0 || param_3 == 0) || (param_1 == 0)) {
bVar1 = false;
}
else {
bVar1 = false;
if (((param_1 + param_2 + param_3 == 0xb4) && (bVar1 = true, param_1 + param_2 < param_3)) &&
(param_2 + param_3 < param_1)) {
return param_2 <= param_1 + param_3;
}
}
return bVar1;
} |
7,294 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
if (a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if ((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return 1;
} else {
return 0;
}
} else {
return 0;
}
}
| int main() {
assert(func0(50, 60, 70) == 1);
assert(func0(90, 45, 45) == 1);
assert(func0(150, 30, 70) == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
setne %cl
test %edx,%edx
setne %al
test %al,%cl
je 1188 <func0+0x48>
test %edi,%edi
je 1188 <func0+0x48>
lea (%rdi,%rsi,1),%ecx
xor %eax,%eax
lea (%rcx,%rdx,1),%r8d
cmp $0xb4,%r8d
jne 118a <func0+0x4a>
mov $0x1,%eax
cmp %edx,%ecx
jge 118a <func0+0x4a>
lea (%rsi,%rdx,1),%ecx
cmp %edi,%ecx
jge 118a <func0+0x4a>
add %edi,%edx
xor %eax,%eax
cmp %esi,%edx
setge %al
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
setnz cl
test edx, edx
setnz al
test cl, al
jz short loc_1188
test edi, edi
jz short loc_1188
lea ecx, [rdi+rsi]
xor eax, eax
lea r8d, [rcx+rdx]
cmp r8d, 0B4h
jnz short locret_118A
mov eax, 1
cmp ecx, edx
jge short locret_118A
lea ecx, [rsi+rdx]
cmp ecx, edi
jge short locret_118A
add edi, edx
xor eax, eax
cmp edi, esi
setnl al
retn
loc_1188:
xor eax, eax
locret_118A:
retn | _BOOL8 func0(int a1, int a2, int a3)
{
_BOOL8 result; // rax
if ( a3 == 0 || a2 == 0 || !a1 )
return 0LL;
result = 0LL;
if ( a1 + a2 + a3 == 180 )
{
result = 1LL;
if ( a1 + a2 < a3 && a2 + a3 < a1 )
return a3 + a1 >= a2;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
SETNZ CL
TEST EDX,EDX
SETNZ AL
TEST CL,AL
JZ 0x00101188
TEST EDI,EDI
JZ 0x00101188
LEA ECX,[RDI + RSI*0x1]
XOR EAX,EAX
LEA R8D,[RCX + RDX*0x1]
CMP R8D,0xb4
JNZ 0x0010118a
MOV EAX,0x1
CMP ECX,EDX
JGE 0x0010118a
LEA ECX,[RSI + RDX*0x1]
CMP ECX,EDI
JGE 0x0010118a
ADD EDI,EDX
XOR EAX,EAX
CMP EDI,ESI
SETGE AL
RET
LAB_00101188:
XOR EAX,EAX
LAB_0010118a:
RET | bool func0(int param_1,int param_2,int param_3)
{
bool bVar1;
if ((param_2 == 0 || param_3 == 0) || (param_1 == 0)) {
bVar1 = false;
}
else {
bVar1 = false;
if (((param_1 + param_2 + param_3 == 0xb4) && (bVar1 = true, param_1 + param_2 < param_3)) &&
(param_2 + param_3 < param_1)) {
return param_2 <= param_1 + param_3;
}
}
return bVar1;
} |
7,295 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
if (a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if ((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return 1;
} else {
return 0;
}
} else {
return 0;
}
}
| int main() {
assert(func0(50, 60, 70) == 1);
assert(func0(90, 45, 45) == 1);
assert(func0(150, 30, 70) == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
setne %cl
test %edx,%edx
setne %al
test %al,%cl
je 1188 <func0+0x48>
test %edi,%edi
je 1188 <func0+0x48>
lea (%rdi,%rsi,1),%ecx
xor %eax,%eax
lea (%rcx,%rdx,1),%r8d
cmp $0xb4,%r8d
jne 118a <func0+0x4a>
mov $0x1,%eax
cmp %edx,%ecx
jge 118a <func0+0x4a>
lea (%rsi,%rdx,1),%ecx
cmp %edi,%ecx
jge 118a <func0+0x4a>
add %edi,%edx
xor %eax,%eax
cmp %esi,%edx
setge %al
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
setnz cl
test edx, edx
setnz al
test cl, al
jz short loc_1188
test edi, edi
jz short loc_1188
lea ecx, [rdi+rsi]
xor eax, eax
lea r8d, [rcx+rdx]
cmp r8d, 0B4h
jnz short locret_118A
mov eax, 1
cmp ecx, edx
jge short locret_118A
lea ecx, [rsi+rdx]
cmp ecx, edi
jge short locret_118A
add edi, edx
xor eax, eax
cmp edi, esi
setnl al
retn
loc_1188:
xor eax, eax
locret_118A:
retn | _BOOL8 func0(int a1, int a2, int a3)
{
_BOOL8 result; // rax
if ( a3 == 0 || a2 == 0 || !a1 )
return 0LL;
result = 0LL;
if ( a1 + a2 + a3 == 180 )
{
result = 1LL;
if ( a1 + a2 < a3 && a2 + a3 < a1 )
return a3 + a1 >= a2;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
SETNZ CL
TEST EDX,EDX
SETNZ AL
TEST CL,AL
JZ 0x00101188
TEST EDI,EDI
JZ 0x00101188
LEA ECX,[RDI + RSI*0x1]
XOR EAX,EAX
LEA R8D,[RCX + RDX*0x1]
CMP R8D,0xb4
JNZ 0x0010118a
MOV EAX,0x1
CMP ECX,EDX
JGE 0x0010118a
LEA ECX,[RSI + RDX*0x1]
CMP ECX,EDI
JGE 0x0010118a
ADD EDI,EDX
XOR EAX,EAX
CMP EDI,ESI
SETGE AL
RET
LAB_00101188:
XOR EAX,EAX
LAB_0010118a:
RET | bool func0(int param_1,int param_2,int param_3)
{
bool bVar1;
if ((param_2 == 0 || param_3 == 0) || (param_1 == 0)) {
bVar1 = false;
}
else {
bVar1 = false;
if (((param_1 + param_2 + param_3 == 0xb4) && (bVar1 = true, param_1 + param_2 < param_3)) &&
(param_2 + param_3 < param_1)) {
return param_2 <= param_1 + param_3;
}
}
return bVar1;
} |
7,296 | func0 | #include <assert.h>
#include <math.h>
| double func0(int N, int Sum) {
double ans = (double)Sum / (double)N;
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(fabs(func0(9, 13) - 1.44) < 0.01);
assert(func0(1, 4) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm1
movsd 0xefd(%rip),%xmm0
mulsd %xmm1,%xmm0
callq 1060 <round@plt>
movsd 0xeec(%rip),%xmm1
divsd %xmm1,%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_18]
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_14]
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm1, [rbp+var_8]
movsd xmm0, cs:qword_2078
mulsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _round
movq rax, xmm0
movsd xmm0, cs:qword_2078
movq xmm1, rax
divsd xmm1, xmm0
movapd xmm0, xmm1
leave
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>, int a2@<esi>)
{
double v2; // rax
__int128 v3; // xmm1
v2 = round((double)a2 / (double)a1 * 100.0);
v3 = *(unsigned long long *)&v2;
*(double *)&v3 = v2 / 100.0;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x18]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x14]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM1,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x00102078]
MULSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101060
MOVQ RAX,XMM0
MOVSD XMM0,qword ptr [0x00102078]
MOVQ XMM1,RAX
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM1
LEAVE
RET | double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * DAT_00102078);
return dVar1 / DAT_00102078;
} |
7,297 | func0 | #include <assert.h>
#include <math.h>
| double func0(int N, int Sum) {
double ans = (double)Sum / (double)N;
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(fabs(func0(9, 13) - 1.44) < 0.01);
assert(func0(1, 4) == 4);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xe9b(%rip),%xmm0
callq 1050 <round@plt>
divsd 0xe8e(%rip),%xmm0
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
pxor xmm0, xmm0
cvtsi2sd xmm0, esi
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
call _round
divsd xmm0, cs:qword_2008
add rsp, 8
retn | double func0(int a1, int a2)
{
return round((double)a2 / (double)a1 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
PXOR XMM0,XMM0
CVTSI2SD XMM0,ESI
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
CALL 0x00101050
DIVSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * _DAT_00102008);
return dVar1 / _DAT_00102008;
} |
7,298 | func0 | #include <assert.h>
#include <math.h>
| double func0(int N, int Sum) {
double ans = (double)Sum / (double)N;
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(fabs(func0(9, 13) - 1.44) < 0.01);
assert(func0(1, 4) == 4);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub $0x8,%rsp
cvtsi2sd %esi,%xmm0
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xe84(%rip),%xmm0
callq 1050 <round@plt>
divsd 0xe77(%rip),%xmm0
add $0x8,%rsp
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
sub rsp, 8
cvtsi2sd xmm0, esi
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
call _round
divsd xmm0, cs:qword_2008
add rsp, 8
retn | double func0(int a1, int a2)
{
return round((double)a2 / (double)a1 * 100.0) / 100.0;
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB RSP,0x8
CVTSI2SD XMM0,ESI
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
CALL 0x00101050
DIVSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * _DAT_00102008);
return dVar1 / _DAT_00102008;
} |
7,299 | func0 | #include <assert.h>
#include <math.h>
| double func0(int N, int Sum) {
double ans = (double)Sum / (double)N;
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(fabs(func0(9, 13) - 1.44) < 0.01);
assert(func0(1, 4) == 4);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub $0x8,%rsp
cvtsi2sd %esi,%xmm0
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xe84(%rip),%xmm0
callq 1050 <round@plt>
divsd 0xe77(%rip),%xmm0
add $0x8,%rsp
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
sub rsp, 8
cvtsi2sd xmm0, esi
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2008; x
call _round
divsd xmm0, cs:qword_2008
add rsp, 8
retn | double func0(int a1, int a2)
{
return round((double)a2 / (double)a1 * 100.0) / 100.0;
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB RSP,0x8
CVTSI2SD XMM0,ESI
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
CALL 0x00101050
DIVSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * _DAT_00102008);
return dVar1 / _DAT_00102008;
} |
7,300 | func0 | #include <assert.h>
#include <stdlib.h>
| int* func0(int num_list[], int num_elems, int* result_size) {
int* new_list = (int*)malloc(num_elems * sizeof(int));
int j = 0;
for (int i = 0; i < num_elems; i++) {
if (num_list[i] >= 0) {
new_list[j++] = num_list[i];
}
}
*result_size = j;
return new_list;
}
| int main() {
int size;
int list1[] = {1, -2, 3, -4};
int* result1 = func0(list1, 4, &size);
assert(size == 2 && result1[0] == 1 && result1[1] == 3);
free(result1);
int list2[] = {1, 2, 3, -4};
int* result2 = func0(list2, 4, &size);
assert(size == 3 && result2[0] == 1 && result2[1] == 2 && result2[2] == 3);
free(result2);
int list3[] = {4, 5, -6, 7, -8};
int* result3 = func0(list3, 5, &size);
assert(size == 3 && result3[0] == 4 && result3[1] == 5 && result3[2] == 7);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1236 <func0+0x8d>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
js 1232 <func0+0x89>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11e5 <func0+0x3c>
mov -0x28(%rbp),%rax
mov -0x10(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_1236
loc_11E5:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
js short loc_1232
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1232:
add [rbp+var_C], 1
loc_1236:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11E5
mov rax, [rbp+var_28]
mov edx, [rbp+var_10]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v8; // [rsp+28h] [rbp-8h]
v8 = malloc(4LL * a2);
v6 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) >= 0 )
{
v3 = v6++;
v8[v3] = *(_DWORD *)(4LL * i + a1);
}
}
*a3 = v6;
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101236
LAB_001011e5:
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]
TEST EAX,EAX
JS 0x00101232
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],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_00101232:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101236:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011e5
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (-1 < *(int *)(param_1 + (long)local_14 * 4)) {
*(int4 *)((long)local_18 * 4 + (long)pvVar1) =
*(int4 *)((long)local_14 * 4 + param_1);
local_18 = local_18 + 1;
}
}
*param_3 = local_18;
return pvVar1;
} |
7,301 | func0 | #include <assert.h>
#include <stdlib.h>
| int* func0(int num_list[], int num_elems, int* result_size) {
int* new_list = (int*)malloc(num_elems * sizeof(int));
int j = 0;
for (int i = 0; i < num_elems; i++) {
if (num_list[i] >= 0) {
new_list[j++] = num_list[i];
}
}
*result_size = j;
return new_list;
}
| int main() {
int size;
int list1[] = {1, -2, 3, -4};
int* result1 = func0(list1, 4, &size);
assert(size == 2 && result1[0] == 1 && result1[1] == 3);
free(result1);
int list2[] = {1, 2, 3, -4};
int* result2 = func0(list2, 4, &size);
assert(size == 3 && result2[0] == 1 && result2[1] == 2 && result2[2] == 3);
free(result2);
int list3[] = {4, 5, -6, 7, -8};
int* result3 = func0(list3, 5, &size);
assert(size == 3 && result3[0] == 4 && result3[1] == 5 && result3[2] == 7);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 11f5 <func0+0x4c>
mov %r12,%rdx
lea -0x1(%rbp),%ecx
lea 0x4(%r12,%rcx,4),%r8
mov $0x0,%esi
jmp 11e4 <func0+0x3b>
add $0x4,%rdx
cmp %r8,%rdx
je 11fa <func0+0x51>
mov (%rdx),%ecx
test %ecx,%ecx
js 11db <func0+0x32>
movslq %esi,%rdi
mov %ecx,(%rax,%rdi,4)
lea 0x1(%rsi),%esi
jmp 11db <func0+0x32>
mov $0x0,%esi
mov %esi,(%rbx)
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov ebp, esi
mov rbx, rdx
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebp, ebp
jle short loc_11F5
mov rdx, r12
lea ecx, [rbp-1]
lea r8, [r12+rcx*4+4]
mov esi, 0
jmp short loc_11ED
loc_11DB:
movsxd rdi, esi
mov [rax+rdi*4], ecx
lea esi, [rsi+1]
loc_11E4:
add rdx, 4
cmp rdx, r8
jz short loc_11FA
loc_11ED:
mov ecx, [rdx]
test ecx, ecx
jns short loc_11DB
jmp short loc_11E4
loc_11F5:
mov esi, 0
loc_11FA:
mov [rbx], esi
pop rbx
pop rbp
pop r12
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3)
{
long long result; // rax
_DWORD *v6; // rdx
int v7; // esi
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( (int)*v6 >= 0 )
*(_DWORD *)(result + 4LL * v7++) = *v6;
++v6;
}
while ( v6 != &a1[a2 - 1 + 1] );
}
*a3 = v7;
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV EBP,ESI
MOV RBX,RDX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001011f5
MOV RDX,R12
LEA ECX,[RBP + -0x1]
LEA R8,[R12 + RCX*0x4 + 0x4]
MOV ESI,0x0
JMP 0x001011ed
LAB_001011db:
MOVSXD RDI,ESI
MOV dword ptr [RAX + RDI*0x4],ECX
LEA ESI,[RSI + 0x1]
LAB_001011e4:
ADD RDX,0x4
CMP RDX,R8
JZ 0x001011fa
LAB_001011ed:
MOV ECX,dword ptr [RDX]
TEST ECX,ECX
JNS 0x001011db
JMP 0x001011e4
LAB_001011f5:
MOV ESI,0x0
LAB_001011fa:
MOV dword ptr [RBX],ESI
POP RBX
POP RBP
POP R12
RET | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
void *pvVar2;
int iVar3;
pvVar2 = malloc((long)param_2 << 2);
if (param_2 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
if (-1 < *param_1) {
*(int *)((long)pvVar2 + (long)iVar3 * 4) = *param_1;
iVar3 = iVar3 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
*param_3 = iVar3;
return;
} |
7,302 | func0 | #include <assert.h>
#include <stdlib.h>
| int* func0(int num_list[], int num_elems, int* result_size) {
int* new_list = (int*)malloc(num_elems * sizeof(int));
int j = 0;
for (int i = 0; i < num_elems; i++) {
if (num_list[i] >= 0) {
new_list[j++] = num_list[i];
}
}
*result_size = j;
return new_list;
}
| int main() {
int size;
int list1[] = {1, -2, 3, -4};
int* result1 = func0(list1, 4, &size);
assert(size == 2 && result1[0] == 1 && result1[1] == 3);
free(result1);
int list2[] = {1, 2, 3, -4};
int* result2 = func0(list2, 4, &size);
assert(size == 3 && result2[0] == 1 && result2[1] == 2 && result2[2] == 3);
free(result2);
int list3[] = {4, 5, -6, 7, -8};
int* result3 = func0(list3, 5, &size);
assert(size == 3 && result3[0] == 4 && result3[1] == 5 && result3[2] == 7);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 13a8 <func0+0x58>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x4(%rbx,%rdx,4),%r9
xchg %ax,%ax
mov (%rdi),%ecx
test %ecx,%ecx
js 1390 <func0+0x40>
movslq %esi,%r8
add $0x1,%esi
mov %ecx,(%rax,%r8,4)
add $0x4,%rdi
cmp %r9,%rdi
jne 1380 <func0+0x30>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw 0x0(%rax,%rax,1)
xor %esi,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 2
call _malloc
test ebp, ebp
jle short loc_13A8
lea edx, [rbp-1]
mov rcx, rbx
xor edi, edi
lea r9, [rbx+rdx*4+4]
xchg ax, ax
loc_1380:
mov esi, [rcx]
test esi, esi
js short loc_1390
movsxd r8, edi
add edi, 1
mov [rax+r8*4], esi
loc_1390:
add rcx, 4
cmp rcx, r9
jnz short loc_1380
pop rbx
pop rbp
mov [r12], edi
pop r12
retn
loc_13A8:
xor edi, edi
pop rbx
pop rbp
mov [r12], edi
pop r12
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3)
{
long long result; // rax
_DWORD *v6; // rcx
int v7; // edi
long long v8; // r8
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( (int)*v6 >= 0 )
{
v8 = v7++;
*(_DWORD *)(result + 4 * v8) = *v6;
}
++v6;
}
while ( v6 != &a1[a2 - 1 + 1] );
*a3 = v7;
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001013a8
LEA EDX,[RBP + -0x1]
MOV RCX,RBX
XOR EDI,EDI
LEA R9,[RBX + RDX*0x4 + 0x4]
NOP
LAB_00101380:
MOV ESI,dword ptr [RCX]
TEST ESI,ESI
JS 0x00101390
MOVSXD R8,EDI
ADD EDI,0x1
MOV dword ptr [RAX + R8*0x4],ESI
LAB_00101390:
ADD RCX,0x4
CMP RCX,R9
JNZ 0x00101380
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET
LAB_001013a8:
XOR EDI,EDI
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 << 2);
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (-1 < *param_1) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(int *)((long)pvVar2 + lVar4 * 4) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
*param_3 = iVar3;
return;
}
*param_3 = 0;
return;
} |
7,303 | func0 | #include <assert.h>
#include <stdlib.h>
| int* func0(int num_list[], int num_elems, int* result_size) {
int* new_list = (int*)malloc(num_elems * sizeof(int));
int j = 0;
for (int i = 0; i < num_elems; i++) {
if (num_list[i] >= 0) {
new_list[j++] = num_list[i];
}
}
*result_size = j;
return new_list;
}
| int main() {
int size;
int list1[] = {1, -2, 3, -4};
int* result1 = func0(list1, 4, &size);
assert(size == 2 && result1[0] == 1 && result1[1] == 3);
free(result1);
int list2[] = {1, 2, 3, -4};
int* result2 = func0(list2, 4, &size);
assert(size == 3 && result2[0] == 1 && result2[1] == 2 && result2[2] == 3);
free(result2);
int list3[] = {4, 5, -6, 7, -8};
int* result3 = func0(list3, 5, &size);
assert(size == 3 && result3[0] == 4 && result3[1] == 5 && result3[2] == 7);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 1378 <func0+0x58>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x4(%rbx,%rdx,4),%r9
xchg %ax,%ax
mov (%rdi),%ecx
test %ecx,%ecx
js 1360 <func0+0x40>
movslq %esi,%r8
add $0x1,%esi
mov %ecx,(%rax,%r8,4)
add $0x4,%rdi
cmp %r9,%rdi
jne 1350 <func0+0x30>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw 0x0(%rax,%rax,1)
xor %esi,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r13
movsxd r8, esi
mov r13, rdx
push r12
mov r12, r8
push rbp
lea rbp, ds:0[r8*4]
push rbx
mov rbx, rdi
mov rdi, rbp; size
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_1390
mov rcx, rbx
lea r8, [rbx+rbp]
xor edi, edi
nop dword ptr [rax+rax+00000000h]
loc_1360:
mov esi, [rcx]
test esi, esi
js short loc_1370
movsxd r9, edi
add edi, 1
mov [rax+r9*4], esi
loc_1370:
add rcx, 4
cmp rcx, r8
jnz short loc_1360
mov [r13+0], edi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1390:
xor edi, edi
mov [r13+0], edi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *result; // rax
_DWORD *v6; // rcx
int v7; // edi
long long v8; // r9
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( (int)*v6 >= 0 )
{
v8 = v7++;
result[v8] = *v6;
}
++v6;
}
while ( v6 != &a1[a2] );
*a3 = v7;
}
return result;
} | func0:
ENDBR64
PUSH R13
MOVSXD R8,ESI
MOV R13,RDX
PUSH R12
MOV R12,R8
PUSH RBP
LEA RBP,[R8*0x4]
PUSH RBX
MOV RBX,RDI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
TEST R12D,R12D
JLE 0x00101390
MOV RCX,RBX
LEA R8,[RBX + RBP*0x1]
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101360:
MOV ESI,dword ptr [RCX]
TEST ESI,ESI
JS 0x00101370
MOVSXD R9,EDI
ADD EDI,0x1
MOV dword ptr [RAX + R9*0x4],ESI
LAB_00101370:
ADD RCX,0x4
CMP RCX,R8
JNZ 0x00101360
MOV dword ptr [R13],EDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101390:
XOR EDI,EDI
MOV dword ptr [R13],EDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 * 4);
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar3 = 0;
do {
if (-1 < *param_1) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(int *)((long)pvVar2 + lVar4 * 4) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
*param_3 = iVar3;
return;
}
*param_3 = 0;
return;
} |
7,304 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n /= 2;
}
for (int i = 3; i <= sqrt(n) + 1; i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n /= i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if (n >= 2) {
res *= (1 + n);
}
return res;
}
| int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
movl $0x1,-0x14(%rbp)
jmp 11b0 <func0+0x27>
mov -0x24(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 11a1 <func0+0x18>
movl $0x3,-0x10(%rbp)
jmp 1213 <func0+0x8a>
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11f8 <func0+0x6f>
addl $0x1,-0xc(%rbp)
mov -0x24(%rbp),%eax
cltd
idivl -0x10(%rbp)
mov %eax,-0x24(%rbp)
mov -0x4(%rbp),%eax
imul -0x10(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
mov -0x24(%rbp),%eax
cltd
idivl -0x10(%rbp)
mov %edx,%eax
test %eax,%eax
je 11da <func0+0x51>
mov -0x14(%rbp),%eax
imul -0x8(%rbp),%eax
mov %eax,-0x14(%rbp)
addl $0x2,-0x10(%rbp)
cvtsi2sdl -0x10(%rbp),%xmm2
movsd %xmm2,-0x30(%rbp)
cvtsi2sdl -0x24(%rbp),%xmm0
callq 1090 <sqrt@plt>
movsd 0xe61(%rip),%xmm1
addsd %xmm1,%xmm0
comisd -0x30(%rbp),%xmm0
jae 11c3 <func0+0x3a>
cmpl $0x1,-0x24(%rbp)
jle 124f <func0+0xc6>
mov -0x24(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x14(%rbp),%eax
imul %edx,%eax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_14], 1
jmp short loc_11B0
loc_11A1:
mov eax, [rbp+var_24]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_24], eax
loc_11B0:
mov eax, [rbp+var_24]
and eax, 1
test eax, eax
jz short loc_11A1
mov [rbp+var_10], 3
jmp short loc_1213
loc_11C3:
mov [rbp+var_C], 0
mov [rbp+var_8], 1
mov [rbp+var_4], 1
jmp short loc_11F8
loc_11DA:
add [rbp+var_C], 1
mov eax, [rbp+var_24]
cdq
idiv [rbp+var_10]
mov [rbp+var_24], eax
mov eax, [rbp+var_4]
imul eax, [rbp+var_10]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
add [rbp+var_8], eax
loc_11F8:
mov eax, [rbp+var_24]
cdq
idiv [rbp+var_10]
mov eax, edx
test eax, eax
jz short loc_11DA
mov eax, [rbp+var_14]
imul eax, [rbp+var_8]
mov [rbp+var_14], eax
add [rbp+var_10], 2
loc_1213:
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_10]
movsd [rbp+var_30], xmm2
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_24]
movq rax, xmm3
movq xmm0, rax; x
call _sqrt
movsd xmm1, cs:qword_2070
addsd xmm0, xmm1
comisd xmm0, [rbp+var_30]
jnb loc_11C3
cmp [rbp+var_24], 1
jle short loc_1265
mov eax, [rbp+var_24]
lea edx, [rax+1]
mov eax, [rbp+var_14]
imul eax, edx
mov [rbp+var_14], eax
loc_1265:
mov eax, [rbp+var_14]
leave
retn | long long func0(int a1)
{
unsigned int v3; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v5; // [rsp+24h] [rbp-Ch]
int v6; // [rsp+28h] [rbp-8h]
int v7; // [rsp+2Ch] [rbp-4h]
v3 = 1;
while ( (a1 & 1) == 0 )
a1 /= 2;
for ( i = 3; sqrt((double)a1) + 1.0 >= (double)i; i += 2 )
{
v5 = 0;
v6 = 1;
v7 = 1;
while ( !(a1 % i) )
{
++v5;
a1 /= i;
v7 *= i;
v6 += v7;
}
v3 *= v6;
}
if ( a1 > 1 )
v3 *= a1 + 1;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001011b0
LAB_001011a1:
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
LAB_001011b0:
MOV EAX,dword ptr [RBP + -0x24]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011a1
MOV dword ptr [RBP + -0x10],0x3
JMP 0x00101213
LAB_001011c3:
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011f8
LAB_001011da:
ADD dword ptr [RBP + -0xc],0x1
MOV EAX,dword ptr [RBP + -0x24]
CDQ
IDIV dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8],EAX
LAB_001011f8:
MOV EAX,dword ptr [RBP + -0x24]
CDQ
IDIV dword ptr [RBP + -0x10]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x001011da
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x10],0x2
LAB_00101213:
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x10]
MOVSD qword ptr [RBP + -0x30],XMM2
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x24]
MOVQ RAX,XMM3
MOVQ XMM0,RAX
CALL 0x00101090
MOVSD XMM1,qword ptr [0x00102070]
ADDSD XMM0,XMM1
COMISD XMM0,qword ptr [RBP + -0x30]
JNC 0x001011c3
CMP dword ptr [RBP + -0x24],0x1
JLE 0x00101265
MOV EAX,dword ptr [RBP + -0x24]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
LAB_00101265:
MOV EAX,dword ptr [RBP + -0x14]
LEAVE
RET | int func0(uint param_1)
{
double dVar1;
int4 local_2c;
int4 local_1c;
int4 local_18;
int4 local_10;
int4 local_c;
local_1c = 1;
for (local_2c = param_1; (local_2c & 1) == 0; local_2c = (int)local_2c / 2) {
}
local_18 = 3;
while( true ) {
dVar1 = sqrt((double)(int)local_2c);
if (dVar1 + DAT_00102070 < (double)local_18) break;
local_10 = 1;
local_c = 1;
for (; (int)local_2c % local_18 == 0; local_2c = (int)local_2c / local_18) {
local_c = local_c * local_18;
local_10 = local_10 + local_c;
}
local_1c = local_1c * local_10;
local_18 = local_18 + 2;
}
if (1 < (int)local_2c) {
local_1c = local_1c * (local_2c + 1);
}
return local_1c;
} |
7,305 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n /= 2;
}
for (int i = 3; i <= sqrt(n) + 1; i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n /= i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if (n >= 2) {
res *= (1 + n);
}
return res;
}
| int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %edi,%ebx
test $0x1,%dil
jne 11ae <func0+0x25>
mov %ebx,%edi
shr $0x1f,%edi
add %ebx,%edi
sar %edi
mov %edi,%ebx
test $0x1,%dil
je 119d <func0+0x14>
mov $0x3,%ebp
mov $0x1,%r12d
jmp 11d5 <func0+0x4c>
mov %ebx,%eax
cltd
idiv %ebp
mov %eax,%ebx
imul %ebp,%ecx
add %ecx,%esi
cltd
idiv %ebp
test %edx,%edx
je 11bb <func0+0x32>
imul %esi,%r12d
add $0x2,%ebp
pxor %xmm2,%xmm2
cvtsi2sd %ebp,%xmm2
movsd %xmm2,(%rsp)
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
movsd %xmm1,0x8(%rsp)
pxor %xmm3,%xmm3
ucomisd %xmm0,%xmm3
ja 122c <func0+0xa3>
movsd 0xe86(%rip),%xmm0
addsd 0x8(%rsp),%xmm0
comisd (%rsp),%xmm0
jb 1233 <func0+0xaa>
mov %ebx,%eax
cltd
idiv %ebp
mov $0x1,%ecx
mov $0x1,%esi
test %edx,%edx
je 11bb <func0+0x32>
jmp 11ce <func0+0x45>
callq 1090 <sqrt@plt>
jmp 1202 <func0+0x79>
cmp $0x1,%ebx
jle 123f <func0+0xb6>
add $0x1,%ebx
imul %ebx,%r12d
mov %r12d,%eax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov ebx, edi
test dil, 1
jnz short loc_11AC
loc_119D:
mov eax, ebx
shr eax, 1Fh
add eax, ebx
sar eax, 1
mov ebx, eax
test al, 1
jz short loc_119D
loc_11AC:
mov ebp, 3
mov r12d, 1
jmp short loc_11D3
loc_11B9:
mov eax, ebx
cdq
idiv ebp
mov ebx, eax
imul ecx, ebp
add esi, ecx
cdq
idiv ebp
test edx, edx
jz short loc_11B9
loc_11CC:
imul r12d, esi
add ebp, 2
loc_11D3:
pxor xmm1, xmm1
cvtsi2sd xmm1, ebp
movsd [rsp+28h+var_20], xmm1
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
pxor xmm2, xmm2
ucomisd xmm2, xmm0
ja short loc_121C
sqrtsd xmm0, xmm0
loc_11F7:
addsd xmm0, cs:qword_2070
comisd xmm0, [rsp+28h+var_20]
jb short loc_1223
mov eax, ebx
cdq
idiv ebp
mov ecx, 1
mov esi, 1
test edx, edx
jz short loc_11B9
jmp short loc_11CC
loc_121C:
call _sqrt
jmp short loc_11F7
loc_1223:
cmp ebx, 1
jle short loc_122F
add ebx, 1
imul r12d, ebx
loc_122F:
mov eax, r12d
add rsp, 10h
pop rbx
pop rbp
pop r12
retn | long long func0(int a1)
{
int i; // ebx
int v2; // ebp
unsigned int v3; // r12d
int v4; // ecx
int j; // esi
double v6; // xmm0_8
double v7; // xmm0_8
for ( i = a1; (i & 1) == 0; i /= 2 )
;
v2 = 3;
v3 = 1;
while ( 1 )
{
v6 = (double)i;
v7 = (double)i < 0.0 ? sqrt(v6) : sqrt(v6);
if ( v7 + 1.0 < (double)v2 )
break;
v4 = 1;
for ( j = 1; !(i % v2); j += v4 )
{
i /= v2;
v4 *= v2;
}
v3 *= j;
v2 += 2;
}
if ( i > 1 )
v3 *= i + 1;
return v3;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV EBX,EDI
TEST DIL,0x1
JNZ 0x001011ac
LAB_0010119d:
MOV EAX,EBX
SHR EAX,0x1f
ADD EAX,EBX
SAR EAX,0x1
MOV EBX,EAX
TEST AL,0x1
JZ 0x0010119d
LAB_001011ac:
MOV EBP,0x3
MOV R12D,0x1
JMP 0x001011d3
LAB_001011b9:
MOV EAX,EBX
CDQ
IDIV EBP
MOV EBX,EAX
IMUL ECX,EBP
ADD ESI,ECX
CDQ
IDIV EBP
TEST EDX,EDX
JZ 0x001011b9
LAB_001011cc:
IMUL R12D,ESI
ADD EBP,0x2
LAB_001011d3:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBP
MOVSD qword ptr [RSP + 0x8],XMM1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
PXOR XMM2,XMM2
UCOMISD XMM2,XMM0
JA 0x0010121c
SQRTSD XMM0,XMM0
LAB_001011f7:
ADDSD XMM0,qword ptr [0x00102070]
COMISD XMM0,qword ptr [RSP + 0x8]
JC 0x00101223
MOV EAX,EBX
CDQ
IDIV EBP
MOV ECX,0x1
MOV ESI,0x1
TEST EDX,EDX
JZ 0x001011b9
JMP 0x001011cc
LAB_0010121c:
CALL 0x00101090
JMP 0x001011f7
LAB_00101223:
CMP EBX,0x1
JLE 0x0010122f
ADD EBX,0x1
IMUL R12D,EBX
LAB_0010122f:
MOV EAX,R12D
ADD RSP,0x10
POP RBX
POP RBP
POP R12
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint param_1)
{
long lVar1;
uint uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
double dVar8;
uVar2 = param_1 & 1;
while (uVar2 == 0) {
param_1 = (int)param_1 / 2;
uVar2 = param_1 & 1;
}
iVar5 = 3;
iVar7 = 1;
while( true ) {
dVar8 = (double)(int)param_1;
if (dVar8 < 0.0) {
dVar8 = sqrt(dVar8);
}
else {
dVar8 = SQRT(dVar8);
}
if (dVar8 + _DAT_00102070 < (double)iVar5) break;
iVar3 = 1;
iVar6 = 1;
iVar4 = (int)param_1 % iVar5;
while (iVar4 == 0) {
lVar1 = (long)(int)param_1;
param_1 = (uint)(lVar1 / (long)iVar5);
iVar3 = iVar3 * iVar5;
iVar6 = iVar6 + iVar3;
iVar4 = (int)((long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar5 & 0xffffffffU) % (long)iVar5);
}
iVar7 = iVar7 * iVar6;
iVar5 = iVar5 + 2;
}
if (1 < (int)param_1) {
iVar7 = iVar7 * (param_1 + 1);
}
return iVar7;
} |
7,306 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n /= 2;
}
for (int i = 3; i <= sqrt(n) + 1; i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n /= i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if (n >= 2) {
res *= (1 + n);
}
return res;
}
| int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbx
sub $0x28,%rsp
test $0x1,%dil
jne 1267 <func0+0x27>
nopl 0x0(%rax)
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
mov %eax,%edi
sar %edi
test $0x2,%al
je 1258 <func0+0x18>
pxor %xmm2,%xmm2
mov $0x3,%ebx
mov $0x1,%r12d
movsd 0xe12(%rip),%xmm4
cvtsi2sd %edi,%xmm2
pxor %xmm5,%xmm5
nopw %cs:0x0(%rax,%rax,1)
ucomisd %xmm2,%xmm5
pxor %xmm3,%xmm3
movapd %xmm2,%xmm1
cvtsi2sd %ebx,%xmm3
sqrtsd %xmm1,%xmm1
ja 1307 <func0+0xc7>
addsd %xmm4,%xmm1
comisd %xmm3,%xmm1
jb 12f0 <func0+0xb0>
mov %edi,%eax
mov $0x1,%ecx
mov $0x1,%esi
cltd
idiv %ebx
test %edx,%edx
jne 12e7 <func0+0xa7>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
imul %ebx,%ecx
cltd
idiv %ebx
add %ecx,%esi
cltd
mov %eax,%edi
idiv %ebx
test %edx,%edx
je 12c8 <func0+0x88>
pxor %xmm2,%xmm2
imul %esi,%r12d
cvtsi2sd %edi,%xmm2
add $0x2,%ebx
jmp 1290 <func0+0x50>
nopl 0x0(%rax)
cmp $0x1,%edi
jle 12fc <func0+0xbc>
add $0x1,%edi
imul %edi,%r12d
add $0x28,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
movapd %xmm2,%xmm0
mov %edi,0x1c(%rsp)
movsd %xmm1,0x10(%rsp)
movsd %xmm3,0x8(%rsp)
movsd %xmm2,(%rsp)
callq 1090 <sqrt@plt>
mov 0xd64(%rip),%rax
mov 0x1c(%rsp),%edi
pxor %xmm5,%xmm5
movsd 0x10(%rsp),%xmm1
movsd 0x8(%rsp),%xmm3
movsd (%rsp),%xmm2
movq %rax,%xmm4
jmpq 12a6 <func0+0x66>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
test dil, 1
jnz short loc_1267
nop word ptr [rax+rax+00h]
loc_1258:
mov eax, edi
shr eax, 1Fh
add eax, edi
mov edi, eax
sar edi, 1
test al, 2
jz short loc_1258
loc_1267:
pxor xmm1, xmm1
mov ebp, 3
mov r12d, 1
movsd xmm3, cs:qword_2070
cvtsi2sd xmm1, edi
pxor xmm4, xmm4
nop word ptr [rax+rax+00000000h]
loc_1290:
ucomisd xmm4, xmm1
pxor xmm2, xmm2
cvtsi2sd xmm2, ebp
ja short loc_1308
movapd xmm0, xmm1
sqrtsd xmm0, xmm0
loc_12A6:
addsd xmm0, xmm3
comisd xmm0, xmm2
jb short loc_12F0
mov eax, edi
mov ecx, 1
mov esi, 1
cdq
idiv ebp
test edx, edx
jnz short loc_12E7
nop dword ptr [rax+rax+00h]
loc_12C8:
mov eax, edi
imul ecx, ebp
cdq
idiv ebp
add esi, ecx
cdq
mov edi, eax
idiv ebp
test edx, edx
jz short loc_12C8
pxor xmm1, xmm1
imul r12d, esi
cvtsi2sd xmm1, edi
loc_12E7:
add ebp, 2
jmp short loc_1290
loc_12F0:
cmp edi, 1
jle short loc_12FC
lea ebx, [rdi+1]
imul r12d, ebx
loc_12FC:
add rsp, 20h
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1308:
movapd xmm0, xmm1
mov [rsp+38h+var_1C], edi
movsd [rsp+38h+var_28], xmm2
movsd [rsp+38h+var_30], xmm1
call _sqrt
mov rax, cs:qword_2070
mov edi, [rsp+38h+var_1C]
pxor xmm4, xmm4
movsd xmm2, [rsp+38h+var_28]
movsd xmm1, [rsp+38h+var_30]
movq xmm3, rax
jmp loc_12A6 | long long func0(int a1)
{
unsigned int v1; // eax
int v2; // ebp
unsigned int v3; // r12d
double v4; // xmm1_8
double v5; // xmm2_8
double v6; // xmm0_8
int v7; // ecx
int v8; // esi
int v9; // edx
if ( (a1 & 1) == 0 )
{
do
{
v1 = a1 + ((unsigned int)a1 >> 31);
a1 /= 2;
}
while ( (v1 & 2) == 0 );
}
v2 = 3;
v3 = 1;
v4 = (double)a1;
while ( 1 )
{
v5 = (double)v2;
if ( v4 < 0.0 )
{
v6 = sqrt(v4);
v5 = (double)v2;
}
else
{
v6 = sqrt(v4);
}
if ( v6 + 1.0 < v5 )
break;
v7 = 1;
v8 = 1;
if ( !(a1 % v2) )
{
do
{
v7 *= v2;
v8 += v7;
v9 = (a1 / v2) >> 31;
a1 /= v2;
}
while ( !(unsigned int)(__SPAIR64__(v9, a1) % v2) );
v3 *= v8;
v4 = (double)a1;
}
v2 += 2;
}
if ( a1 > 1 )
v3 *= a1 + 1;
return v3;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
TEST DIL,0x1
JNZ 0x00101267
NOP word ptr [RAX + RAX*0x1]
LAB_00101258:
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
MOV EDI,EAX
SAR EDI,0x1
TEST AL,0x2
JZ 0x00101258
LAB_00101267:
PXOR XMM1,XMM1
MOV EBP,0x3
MOV R12D,0x1
MOVSD XMM3,qword ptr [0x00102070]
CVTSI2SD XMM1,EDI
PXOR XMM4,XMM4
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101290:
UCOMISD XMM4,XMM1
PXOR XMM2,XMM2
CVTSI2SD XMM2,EBP
JA 0x00101308
MOVAPD XMM0,XMM1
SQRTSD XMM0,XMM0
LAB_001012a6:
ADDSD XMM0,XMM3
COMISD XMM0,XMM2
JC 0x001012f0
MOV EAX,EDI
MOV ECX,0x1
MOV ESI,0x1
CDQ
IDIV EBP
TEST EDX,EDX
JNZ 0x001012e7
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c8:
MOV EAX,EDI
IMUL ECX,EBP
CDQ
IDIV EBP
ADD ESI,ECX
CDQ
MOV EDI,EAX
IDIV EBP
TEST EDX,EDX
JZ 0x001012c8
PXOR XMM1,XMM1
IMUL R12D,ESI
CVTSI2SD XMM1,EDI
LAB_001012e7:
ADD EBP,0x2
JMP 0x00101290
LAB_001012f0:
CMP EDI,0x1
JLE 0x001012fc
LEA EBX,[RDI + 0x1]
IMUL R12D,EBX
LAB_001012fc:
ADD RSP,0x20
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101308:
MOVAPD XMM0,XMM1
MOV dword ptr [RSP + 0x1c],EDI
MOVSD qword ptr [RSP + 0x10],XMM2
MOVSD qword ptr [RSP + 0x8],XMM1
CALL 0x00101090
MOV RAX,qword ptr [0x00102070]
MOV EDI,dword ptr [RSP + 0x1c]
PXOR XMM4,XMM4
MOVSD XMM2,qword ptr [RSP + 0x10]
MOVSD XMM1,qword ptr [RSP + 0x8]
MOVQ XMM3,RAX
JMP 0x001012a6 | int func0(ulong param_1)
{
ulong uVar1;
uint uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
double dVar8;
double __x;
double dVar9;
if ((param_1 & 1) == 0) {
do {
uVar2 = ((uint)(param_1 >> 0x1f) & 1) + (int)param_1;
param_1 = (ulong)(uint)((int)uVar2 >> 1);
} while ((uVar2 & 2) == 0);
}
iVar4 = 3;
iVar7 = 1;
__x = (double)(int)param_1;
dVar9 = DAT_00102070;
while( true ) {
if (__x < 0.0) {
dVar8 = sqrt(__x);
param_1 = param_1 & 0xffffffff;
dVar9 = DAT_00102070;
}
else {
dVar8 = SQRT(__x);
}
iVar6 = (int)param_1;
if (dVar8 + dVar9 < (double)iVar4) break;
iVar3 = 1;
iVar5 = 1;
if ((int)((long)((ulong)(uint)(iVar6 >> 0x1f) << 0x20 | param_1 & 0xffffffff) % (long)iVar4) ==
0) {
do {
iVar3 = iVar3 * iVar4;
uVar1 = (long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 | param_1 & 0xffffffff) /
(long)iVar4;
iVar5 = iVar5 + iVar3;
param_1 = uVar1 & 0xffffffff;
} while ((int)((long)((ulong)(uint)((int)uVar1 >> 0x1f) << 0x20 | uVar1 & 0xffffffff) %
(long)iVar4) == 0);
iVar7 = iVar7 * iVar5;
__x = (double)(int)uVar1;
}
iVar4 = iVar4 + 2;
}
if (1 < iVar6) {
iVar7 = iVar7 * (iVar6 + 1);
}
return iVar7;
} |
7,307 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n /= 2;
}
for (int i = 3; i <= sqrt(n) + 1; i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n /= i;
curr_term *= i;
curr_sum += curr_term;
}
res *= curr_sum;
}
if (n >= 2) {
res *= (1 + n);
}
return res;
}
| int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbx
sub $0x28,%rsp
test $0x1,%dil
jne 1267 <func0+0x27>
nopl 0x0(%rax)
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
mov %eax,%edi
sar %edi
test $0x2,%al
je 1258 <func0+0x18>
pxor %xmm2,%xmm2
mov $0x3,%ebx
mov $0x1,%r12d
movsd 0xe12(%rip),%xmm4
cvtsi2sd %edi,%xmm2
pxor %xmm5,%xmm5
nopw %cs:0x0(%rax,%rax,1)
ucomisd %xmm2,%xmm5
pxor %xmm3,%xmm3
movapd %xmm2,%xmm1
cvtsi2sd %ebx,%xmm3
sqrtsd %xmm1,%xmm1
ja 1307 <func0+0xc7>
addsd %xmm4,%xmm1
comisd %xmm3,%xmm1
jb 12f0 <func0+0xb0>
mov %edi,%eax
mov $0x1,%ecx
mov $0x1,%esi
cltd
idiv %ebx
test %edx,%edx
jne 12e7 <func0+0xa7>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
imul %ebx,%ecx
cltd
idiv %ebx
add %ecx,%esi
cltd
mov %eax,%edi
idiv %ebx
test %edx,%edx
je 12c8 <func0+0x88>
pxor %xmm2,%xmm2
imul %esi,%r12d
cvtsi2sd %edi,%xmm2
add $0x2,%ebx
jmp 1290 <func0+0x50>
nopl 0x0(%rax)
cmp $0x1,%edi
jle 12fc <func0+0xbc>
add $0x1,%edi
imul %edi,%r12d
add $0x28,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
movapd %xmm2,%xmm0
mov %edi,0x1c(%rsp)
movsd %xmm1,0x10(%rsp)
movsd %xmm3,0x8(%rsp)
movsd %xmm2,(%rsp)
callq 1090 <sqrt@plt>
mov 0xd64(%rip),%rax
mov 0x1c(%rsp),%edi
pxor %xmm5,%xmm5
movsd 0x10(%rsp),%xmm1
movsd 0x8(%rsp),%xmm3
movsd (%rsp),%xmm2
movq %rax,%xmm4
jmpq 12a6 <func0+0x66>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
test dil, 1
jnz short loc_1267
nop word ptr [rax+rax+00h]
loc_1258:
mov eax, edi
shr eax, 1Fh
add eax, edi
mov edi, eax
sar edi, 1
test al, 2
jz short loc_1258
loc_1267:
pxor xmm1, xmm1
mov ebp, 3
mov r12d, 1
movsd xmm4, cs:qword_2070
cvtsi2sd xmm1, edi
pxor xmm3, xmm3
nop word ptr [rax+rax+00000000h]
loc_1290:
ucomisd xmm3, xmm1
pxor xmm2, xmm2
cvtsi2sd xmm2, ebp
ja short loc_1308
movapd xmm0, xmm1
sqrtsd xmm0, xmm0
loc_12A6:
addsd xmm0, xmm4
comisd xmm0, xmm2
jb short loc_12F0
mov eax, edi
mov ecx, 1
mov esi, 1
cdq
idiv ebp
test edx, edx
jnz short loc_12E7
nop dword ptr [rax+rax+00h]
loc_12C8:
mov eax, edi
imul ecx, ebp
cdq
idiv ebp
add esi, ecx
cdq
mov edi, eax
idiv ebp
test edx, edx
jz short loc_12C8
pxor xmm1, xmm1
imul r12d, esi
cvtsi2sd xmm1, edi
loc_12E7:
add ebp, 2
jmp short loc_1290
loc_12F0:
cmp edi, 1
jle short loc_12FC
lea ebx, [rdi+1]
imul r12d, ebx
loc_12FC:
add rsp, 20h
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1308:
movapd xmm0, xmm1; x
mov [rsp+38h+var_1C], edi
movsd [rsp+38h+var_28], xmm2
movsd [rsp+38h+var_30], xmm1
call _sqrt
mov edi, [rsp+38h+var_1C]
pxor xmm3, xmm3
movsd xmm4, cs:qword_2070
movsd xmm2, [rsp+38h+var_28]
movsd xmm1, [rsp+38h+var_30]
jmp loc_12A6 | long long func0(int a1)
{
unsigned int v1; // eax
int v2; // ebp
unsigned int v3; // r12d
double v4; // xmm1_8
double v5; // xmm2_8
double v6; // xmm0_8
int v7; // ecx
int v8; // esi
int v9; // edx
if ( (a1 & 1) == 0 )
{
do
{
v1 = a1 + ((unsigned int)a1 >> 31);
a1 /= 2;
}
while ( (v1 & 2) == 0 );
}
v2 = 3;
v3 = 1;
v4 = (double)a1;
while ( 1 )
{
v5 = (double)v2;
if ( v4 < 0.0 )
{
v6 = sqrt(v4);
v5 = (double)v2;
}
else
{
v6 = sqrt(v4);
}
if ( v6 + 1.0 < v5 )
break;
v7 = 1;
v8 = 1;
if ( !(a1 % v2) )
{
do
{
v7 *= v2;
v8 += v7;
v9 = (a1 / v2) >> 31;
a1 /= v2;
}
while ( !(unsigned int)(__SPAIR64__(v9, a1) % v2) );
v3 *= v8;
v4 = (double)a1;
}
v2 += 2;
}
if ( a1 > 1 )
v3 *= a1 + 1;
return v3;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
TEST DIL,0x1
JNZ 0x00101267
NOP word ptr [RAX + RAX*0x1]
LAB_00101258:
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
MOV EDI,EAX
SAR EDI,0x1
TEST AL,0x2
JZ 0x00101258
LAB_00101267:
PXOR XMM1,XMM1
MOV EBP,0x3
MOV R12D,0x1
MOVSD XMM4,qword ptr [0x00102070]
CVTSI2SD XMM1,EDI
PXOR XMM3,XMM3
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101290:
UCOMISD XMM3,XMM1
PXOR XMM2,XMM2
CVTSI2SD XMM2,EBP
JA 0x00101308
MOVAPD XMM0,XMM1
SQRTSD XMM0,XMM0
LAB_001012a6:
ADDSD XMM0,XMM4
COMISD XMM0,XMM2
JC 0x001012f0
MOV EAX,EDI
MOV ECX,0x1
MOV ESI,0x1
CDQ
IDIV EBP
TEST EDX,EDX
JNZ 0x001012e7
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c8:
MOV EAX,EDI
IMUL ECX,EBP
CDQ
IDIV EBP
ADD ESI,ECX
CDQ
MOV EDI,EAX
IDIV EBP
TEST EDX,EDX
JZ 0x001012c8
PXOR XMM1,XMM1
IMUL R12D,ESI
CVTSI2SD XMM1,EDI
LAB_001012e7:
ADD EBP,0x2
JMP 0x00101290
LAB_001012f0:
CMP EDI,0x1
JLE 0x001012fc
LEA EBX,[RDI + 0x1]
IMUL R12D,EBX
LAB_001012fc:
ADD RSP,0x20
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101308:
MOVAPD XMM0,XMM1
MOV dword ptr [RSP + 0x1c],EDI
MOVSD qword ptr [RSP + 0x10],XMM2
MOVSD qword ptr [RSP + 0x8],XMM1
CALL 0x00101090
MOV EDI,dword ptr [RSP + 0x1c]
PXOR XMM3,XMM3
MOVSD XMM4,qword ptr [0x00102070]
MOVSD XMM2,qword ptr [RSP + 0x10]
MOVSD XMM1,qword ptr [RSP + 0x8]
JMP 0x001012a6 | int func0(ulong param_1)
{
ulong uVar1;
uint uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
double dVar8;
double __x;
double dVar9;
if ((param_1 & 1) == 0) {
do {
uVar2 = ((uint)(param_1 >> 0x1f) & 1) + (int)param_1;
param_1 = (ulong)(uint)((int)uVar2 >> 1);
} while ((uVar2 & 2) == 0);
}
iVar4 = 3;
iVar7 = 1;
__x = (double)(int)param_1;
dVar9 = DAT_00102070;
while( true ) {
if (__x < 0.0) {
dVar8 = sqrt(__x);
param_1 = param_1 & 0xffffffff;
dVar9 = DAT_00102070;
}
else {
dVar8 = SQRT(__x);
}
iVar6 = (int)param_1;
if (dVar8 + dVar9 < (double)iVar4) break;
iVar3 = 1;
iVar5 = 1;
if ((int)((long)((ulong)(uint)(iVar6 >> 0x1f) << 0x20 | param_1 & 0xffffffff) % (long)iVar4) ==
0) {
do {
iVar3 = iVar3 * iVar4;
uVar1 = (long)((ulong)(uint)((int)param_1 >> 0x1f) << 0x20 | param_1 & 0xffffffff) /
(long)iVar4;
iVar5 = iVar5 + iVar3;
param_1 = uVar1 & 0xffffffff;
} while ((int)((long)((ulong)(uint)((int)uVar1 >> 0x1f) << 0x20 | uVar1 & 0xffffffff) %
(long)iVar4) == 0);
iVar7 = iVar7 * iVar5;
__x = (double)(int)uVar1;
}
iVar4 = iVar4 + 2;
}
if (1 < iVar6) {
iVar7 = iVar7 * (iVar6 + 1);
}
return iVar7;
} |
7,308 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int rawheap[], int size) {
int i, j, temp;
for (i = size / 2 - 1; i >= 0; i--) {
for (j = 2 * i + 1; j < size; j = 2 * j + 1) {
if (j + 1 < size && rawheap[j] > rawheap[j + 1]) {
j++;
}
if (rawheap[i] <= rawheap[j]) {
break;
}
temp = rawheap[i];
rawheap[i] = rawheap[j];
rawheap[j] = temp;
i = j-1;
}
}
}
| int main() {
int array1[] = {25, 44, 68, 21, 39, 23, 89};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
int expected1[] = {21, 25, 23, 44, 39, 68, 89};
for (int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
int array2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
int expected2[] = {14, 25, 22, 25, 35, 65, 75, 85, 58};
for (int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
int array3[] = {4, 5, 6, 2};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
int expected3[] = {2, 4, 6, 5};
for (int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmpq 129c <func0+0x133>
mov -0xc(%rbp),%eax
add %eax,%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 1289 <func0+0x120>
mov -0x8(%rbp),%eax
add $0x1,%eax
cmp %eax,-0x1c(%rbp)
jle 11e2 <func0+0x79>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 11e2 <func0+0x79>
addl $0x1,-0x8(%rbp)
mov -0xc(%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
cmp %eax,%edx
jle 1297 <func0+0x12e>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
mov -0x8(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
mov -0x8(%rbp),%eax
add %eax,%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 119f <func0+0x36>
jmp 1298 <func0+0x12f>
subl $0x1,-0xc(%rbp)
cmpl $0x0,-0xc(%rbp)
jns 118f <func0+0x26>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
sub eax, 1
mov [rbp+var_C], eax
jmp loc_129C
loc_118F:
mov eax, [rbp+var_C]
add eax, eax
add eax, 1
mov [rbp+var_8], eax
jmp loc_1289
loc_119F:
mov eax, [rbp+var_8]
add eax, 1
cmp [rbp+var_1C], eax
jle short loc_11E2
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_8]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_11E2
add [rbp+var_8], 1
loc_11E2:
mov eax, [rbp+var_C]
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]
cmp edx, eax
jle loc_1297
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
mov eax, [rbp+var_8]
sub eax, 1
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
add eax, eax
add eax, 1
mov [rbp+var_8], eax
loc_1289:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_119F
jmp short loc_1298
loc_1297:
nop
loc_1298:
sub [rbp+var_C], 1
loc_129C:
cmp [rbp+var_C], 0
jns loc_118F
nop
nop
pop rbp
retn | long long func0(long long a1, int a2)
{
long long result; // rax
int i; // [rsp+10h] [rbp-Ch]
int j; // [rsp+14h] [rbp-8h]
int v5; // [rsp+18h] [rbp-4h]
result = (unsigned int)(a2 / 2 - 1);
for ( i = a2 / 2 - 1; i >= 0; --i )
{
for ( j = 2 * i + 1; ; j = 2 * j + 1 )
{
result = (unsigned int)j;
if ( j >= a2 )
break;
if ( a2 > j + 1 && *(_DWORD *)(4LL * j + a1) > *(_DWORD *)(4 * (j + 1LL) + a1) )
++j;
result = *(unsigned int *)(4LL * j + a1);
if ( *(_DWORD *)(4LL * i + a1) <= (int)result )
break;
v5 = *(_DWORD *)(4LL * i + a1);
*(_DWORD *)(4LL * i + a1) = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(a1 + 4LL * j) = v5;
i = j - 1;
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0010129c
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EAX
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101289
LAB_0010119f:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JLE 0x001011e2
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 + -0x8]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001011e2
ADD dword ptr [RBP + -0x8],0x1
LAB_001011e2:
MOV EAX,dword ptr [RBP + -0xc]
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]
CMP EDX,EAX
JLE 0x00101297
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]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
LAB_00101289:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010119f
JMP 0x00101298
LAB_00101297:
NOP
LAB_00101298:
SUB dword ptr [RBP + -0xc],0x1
LAB_0010129c:
CMP dword ptr [RBP + -0xc],0x0
JNS 0x0010118f
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2)
{
int4 uVar1;
int iVar2;
int local_14;
int local_10;
local_14 = param_2 / 2;
do {
local_14 = local_14 + -1;
local_10 = local_14;
if (local_14 < 0) {
return;
}
while( true ) {
iVar2 = local_10 * 2;
local_10 = iVar2 + 1;
if (param_2 <= local_10) break;
if ((iVar2 + 2 < param_2) &&
(*(int *)(param_1 + ((long)local_10 + 1) * 4) < *(int *)(param_1 + (long)local_10 * 4))) {
local_10 = iVar2 + 2;
}
if (*(int *)(param_1 + (long)local_14 * 4) <= *(int *)(param_1 + (long)local_10 * 4)) break;
uVar1 = *(int4 *)(param_1 + (long)local_14 * 4);
*(int4 *)(param_1 + (long)local_14 * 4) = *(int4 *)(param_1 + (long)local_10 * 4);
*(int4 *)((long)local_10 * 4 + param_1) = uVar1;
local_14 = local_10 + -1;
}
} while( true );
} |
7,309 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int rawheap[], int size) {
int i, j, temp;
for (i = size / 2 - 1; i >= 0; i--) {
for (j = 2 * i + 1; j < size; j = 2 * j + 1) {
if (j + 1 < size && rawheap[j] > rawheap[j + 1]) {
j++;
}
if (rawheap[i] <= rawheap[j]) {
break;
}
temp = rawheap[i];
rawheap[i] = rawheap[j];
rawheap[j] = temp;
i = j-1;
}
}
}
| int main() {
int array1[] = {25, 44, 68, 21, 39, 23, 89};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
int expected1[] = {21, 25, 23, 44, 39, 68, 89};
for (int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
int array2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
int expected2[] = {14, 25, 22, 25, 35, 65, 75, 85, 58};
for (int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
int array3[] = {4, 5, 6, 2};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
int expected3[] = {2, 4, 6, 5};
for (int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
mov %esi,%r10d
shr $0x1f,%r10d
add %esi,%r10d
sar %r10d
sub $0x1,%r10d
jns 11c9 <func0+0x60>
retq
movslq %r10d,%rdx
lea (%rdi,%rdx,4),%r8
mov (%r8),%ecx
movslq %eax,%rdx
lea (%rdi,%rdx,4),%rdx
mov (%rdx),%r9d
cmp %r9d,%ecx
jle 11c3 <func0+0x5a>
mov %r9d,(%r8)
mov %ecx,(%rdx)
lea -0x1(%rax),%r10d
lea 0x1(%rax,%rax,1),%eax
cmp %eax,%esi
jle 11c3 <func0+0x5a>
lea 0x1(%rax),%edx
cmp %esi,%edx
jge 1181 <func0+0x18>
movslq %eax,%rcx
mov 0x4(%rdi,%rcx,4),%r11d
cmp %r11d,(%rdi,%rcx,4)
cmovg %edx,%eax
jmp 1181 <func0+0x18>
sub $0x1,%r10d
js 1180 <func0+0x17>
lea 0x1(%r10,%r10,1),%eax
cmp %eax,%esi
jg 11ab <func0+0x42>
jmp 11c3 <func0+0x5a>
| func0:
endbr64
mov rdx, rdi
mov r10d, esi
shr r10d, 1Fh
add r10d, esi
sar r10d, 1
sub r10d, 1
jns short loc_11CC
locret_1183:
retn
loc_1184:
movsxd rcx, r10d
lea r8, [rdx+rcx*4]
mov edi, [r8]
movsxd rcx, eax
lea rcx, [rdx+rcx*4]
mov r9d, [rcx]
cmp edi, r9d
jle short loc_11C6
mov [r8], r9d
mov [rcx], edi
lea r10d, [rax-1]
lea eax, [rax+rax+1]
cmp esi, eax
jle short loc_11C6
loc_11AE:
lea ecx, [rax+1]
cmp ecx, esi
jge short loc_1184
movsxd rdi, eax
mov r11d, [rdx+rdi*4+4]
cmp [rdx+rdi*4], r11d
cmovg eax, ecx
jmp short loc_1184
loc_11C6:
sub r10d, 1
js short locret_1183
loc_11CC:
lea eax, [r10+r10+1]
cmp esi, eax
jg short loc_11AE
jmp short loc_11C6 | void func0(long long a1, int a2)
{
int i; // r10d
int *v4; // r8
int v5; // edi
int *v6; // rcx
int j; // eax
for ( i = a2 / 2 - 1; i >= 0; --i )
{
for ( j = 2 * i + 1; a2 > j; j = 2 * j + 1 )
{
if ( j + 1 < a2 && *(_DWORD *)(a1 + 4LL * j) > *(_DWORD *)(a1 + 4LL * j + 4) )
++j;
v4 = (int *)(a1 + 4LL * i);
v5 = *v4;
v6 = (int *)(a1 + 4LL * j);
if ( *v4 <= *v6 )
break;
*v4 = *v6;
*v6 = v5;
i = j - 1;
}
}
} | func0:
ENDBR64
MOV RDX,RDI
MOV R10D,ESI
SHR R10D,0x1f
ADD R10D,ESI
SAR R10D,0x1
SUB R10D,0x1
JNS 0x001011cc
LAB_00101183:
RET
LAB_00101184:
MOVSXD RCX,R10D
LEA R8,[RDX + RCX*0x4]
MOV EDI,dword ptr [R8]
MOVSXD RCX,EAX
LEA RCX,[RDX + RCX*0x4]
MOV R9D,dword ptr [RCX]
CMP EDI,R9D
JLE 0x001011c6
MOV dword ptr [R8],R9D
MOV dword ptr [RCX],EDI
LEA R10D,[RAX + -0x1]
LEA EAX,[RAX + RAX*0x1 + 0x1]
CMP ESI,EAX
JLE 0x001011c6
LAB_001011ae:
LEA ECX,[RAX + 0x1]
CMP ECX,ESI
JGE 0x00101184
MOVSXD RDI,EAX
MOV R11D,dword ptr [RDX + RDI*0x4 + 0x4]
CMP dword ptr [RDX + RDI*0x4],R11D
CMOVG EAX,ECX
JMP 0x00101184
LAB_001011c6:
SUB R10D,0x1
JS 0x00101183
LAB_001011cc:
LEA EAX,[R10 + R10*0x1 + 0x1]
CMP ESI,EAX
JG 0x001011ae
JMP 0x001011c6 | void func0(long param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
iVar6 = param_2 / 2;
do {
do {
iVar6 = iVar6 + -1;
if (iVar6 < 0) {
return;
}
iVar5 = iVar6 * 2 + 1;
} while (param_2 <= iVar5);
do {
if ((iVar5 + 1 < param_2) &&
(*(int *)(param_1 + 4 + (long)iVar5 * 4) < *(int *)(param_1 + (long)iVar5 * 4))) {
iVar5 = iVar5 + 1;
}
piVar1 = (int *)(param_1 + (long)iVar6 * 4);
iVar3 = *piVar1;
piVar2 = (int *)(param_1 + (long)iVar5 * 4);
iVar4 = *piVar2;
if (iVar3 <= iVar4) break;
*piVar1 = iVar4;
*piVar2 = iVar3;
iVar6 = iVar5 + -1;
iVar5 = iVar5 * 2 + 1;
} while (iVar5 < param_2);
} while( true );
} |
7,310 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int rawheap[], int size) {
int i, j, temp;
for (i = size / 2 - 1; i >= 0; i--) {
for (j = 2 * i + 1; j < size; j = 2 * j + 1) {
if (j + 1 < size && rawheap[j] > rawheap[j + 1]) {
j++;
}
if (rawheap[i] <= rawheap[j]) {
break;
}
temp = rawheap[i];
rawheap[i] = rawheap[j];
rawheap[j] = temp;
i = j-1;
}
}
}
| int main() {
int array1[] = {25, 44, 68, 21, 39, 23, 89};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
int expected1[] = {21, 25, 23, 44, 39, 68, 89};
for (int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
int array2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
int expected2[] = {14, 25, 22, 25, 35, 65, 75, 85, 58};
for (int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
int array3[] = {4, 5, 6, 2};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
int expected3[] = {2, 4, 6, 5};
for (int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%r10d
shr $0x1f,%r10d
add %esi,%r10d
sar %r10d
sub $0x1,%r10d
js 1457 <func0+0x87>
nopw 0x0(%rax,%rax,1)
lea 0x1(%r10,%r10,1),%eax
cmp %eax,%esi
jg 1412 <func0+0x42>
jmp 144d <func0+0x7d>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rax),%r10d
lea 0x1(%rax,%rax,1),%eax
mov %ecx,(%r9)
mov %edx,(%r8)
cmp %eax,%esi
jle 144d <func0+0x7d>
movslq %eax,%rdx
lea 0x1(%rax),%r9d
shl $0x2,%rdx
lea (%rdi,%rdx,1),%r8
mov (%r8),%ecx
cmp %esi,%r9d
jge 143f <func0+0x6f>
lea 0x4(%rdi,%rdx,1),%rdx
mov (%rdx),%r11d
cmp %ecx,%r11d
jge 143f <func0+0x6f>
mov %r11d,%ecx
mov %rdx,%r8
mov %r9d,%eax
movslq %r10d,%rdx
lea (%rdi,%rdx,4),%r9
mov (%r9),%edx
cmp %ecx,%edx
jg 1400 <func0+0x30>
sub $0x1,%r10d
cmp $0xffffffff,%r10d
jne 13f0 <func0+0x20>
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r9d, esi
mov r8, rdi
mov r10d, esi
shr r9d, 1Fh
add r9d, esi
sar r9d, 1
sub r9d, 1
js short locret_145E
nop dword ptr [rax]
loc_1400:
lea eax, [r9+r9+1]
cmp r10d, eax
jg short loc_1421
jmp short loc_1458
loc_1410:
lea r9d, [rax-1]
lea eax, [rax+rax+1]
mov [rdi], ecx
mov [rsi], edx
cmp r10d, eax
jle short loc_1458
loc_1421:
movsxd rdx, eax
lea edi, [rax+1]
shl rdx, 2
lea rsi, [r8+rdx]
mov ecx, [rsi]
cmp edi, r10d
jge short loc_144B
lea rdx, [r8+rdx+4]
mov r11d, [rdx]
cmp r11d, ecx
jge short loc_144B
mov ecx, r11d
mov rsi, rdx
mov eax, edi
loc_144B:
movsxd rdx, r9d
lea rdi, [r8+rdx*4]
mov edx, [rdi]
cmp edx, ecx
jg short loc_1410
loc_1458:
sub r9d, 1
jnb short loc_1400
locret_145E:
retn | void func0(long long a1, int a2)
{
int v4; // r9d
int i; // eax
long long v6; // rdx
_DWORD *v7; // rsi
int v8; // ecx
_DWORD *v9; // rdx
int *v10; // rdi
int v11; // edx
v4 = a2 / 2 - 1;
if ( v4 >= 0 )
{
do
{
for ( i = 2 * v4 + 1; a2 > i; *v7 = v11 )
{
v6 = 4LL * i;
v7 = (_DWORD *)(a1 + v6);
v8 = *(_DWORD *)(a1 + v6);
if ( i + 1 < a2 )
{
v9 = (_DWORD *)(a1 + v6 + 4);
if ( *v9 < v8 )
{
v8 = *v9;
v7 = v9;
++i;
}
}
v10 = (int *)(a1 + 4LL * v4);
v11 = *v10;
if ( *v10 <= v8 )
break;
v4 = i - 1;
i = 2 * i + 1;
*v10 = v8;
}
}
while ( v4-- != 0 );
}
} | func0:
ENDBR64
MOV R9D,ESI
MOV R8,RDI
MOV R10D,ESI
SHR R9D,0x1f
ADD R9D,ESI
SAR R9D,0x1
SUB R9D,0x1
JS 0x0010145e
NOP dword ptr [RAX]
LAB_00101400:
LEA EAX,[R9 + R9*0x1 + 0x1]
CMP R10D,EAX
JG 0x00101421
JMP 0x00101458
LAB_00101410:
LEA R9D,[RAX + -0x1]
LEA EAX,[RAX + RAX*0x1 + 0x1]
MOV dword ptr [RDI],ECX
MOV dword ptr [RSI],EDX
CMP R10D,EAX
JLE 0x00101458
LAB_00101421:
MOVSXD RDX,EAX
LEA EDI,[RAX + 0x1]
SHL RDX,0x2
LEA RSI,[R8 + RDX*0x1]
MOV ECX,dword ptr [RSI]
CMP EDI,R10D
JGE 0x0010144b
LEA RDX,[R8 + RDX*0x1 + 0x4]
MOV R11D,dword ptr [RDX]
CMP R11D,ECX
JGE 0x0010144b
MOV ECX,R11D
MOV RSI,RDX
MOV EAX,EDI
LAB_0010144b:
MOVSXD RDX,R9D
LEA RDI,[R8 + RDX*0x4]
MOV EDX,dword ptr [RDI]
CMP EDX,ECX
JG 0x00101410
LAB_00101458:
SUB R9D,0x1
JNC 0x00101400
LAB_0010145e:
RET | void func0(long param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int *piVar5;
int iVar6;
int iVar7;
bool bVar8;
iVar7 = param_2 / 2 + -1;
iVar4 = iVar7;
if (-1 < iVar7) {
joined_r0x00101408:
do {
iVar3 = iVar4 * 2 + 1;
if (iVar3 < param_2) {
iVar6 = iVar4 * 2 + 2;
piVar5 = (int *)(param_1 + (long)iVar3 * 4);
iVar4 = *piVar5;
if (iVar6 < param_2) {
piVar1 = (int *)(param_1 + 4 + (long)iVar3 * 4);
iVar2 = *piVar1;
if (iVar2 < iVar4) {
piVar5 = piVar1;
iVar4 = iVar2;
iVar3 = iVar6;
}
}
piVar1 = (int *)(param_1 + (long)iVar7 * 4);
iVar6 = *piVar1;
if (iVar4 < iVar6) {
iVar7 = iVar3 + -1;
*piVar1 = iVar4;
*piVar5 = iVar6;
iVar4 = iVar3;
goto joined_r0x00101408;
}
}
bVar8 = iVar7 != 0;
iVar7 = iVar7 + -1;
iVar4 = iVar7;
} while (bVar8);
}
return;
} |
7,311 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int rawheap[], int size) {
int i, j, temp;
for (i = size / 2 - 1; i >= 0; i--) {
for (j = 2 * i + 1; j < size; j = 2 * j + 1) {
if (j + 1 < size && rawheap[j] > rawheap[j + 1]) {
j++;
}
if (rawheap[i] <= rawheap[j]) {
break;
}
temp = rawheap[i];
rawheap[i] = rawheap[j];
rawheap[j] = temp;
i = j-1;
}
}
}
| int main() {
int array1[] = {25, 44, 68, 21, 39, 23, 89};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
int expected1[] = {21, 25, 23, 44, 39, 68, 89};
for (int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
int array2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
int expected2[] = {14, 25, 22, 25, 35, 65, 75, 85, 58};
for (int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
int array3[] = {4, 5, 6, 2};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
int expected3[] = {2, 4, 6, 5};
for (int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%r10d
shr $0x1f,%r10d
add %esi,%r10d
sar %r10d
sub $0x1,%r10d
js 1437 <func0+0x87>
nopw 0x0(%rax,%rax,1)
lea 0x1(%r10,%r10,1),%eax
cmp %eax,%esi
jg 13f2 <func0+0x42>
jmp 142d <func0+0x7d>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rax),%r10d
lea 0x1(%rax,%rax,1),%eax
mov %ecx,(%r9)
mov %edx,(%r8)
cmp %eax,%esi
jle 142d <func0+0x7d>
movslq %eax,%rdx
lea 0x1(%rax),%r9d
shl $0x2,%rdx
lea (%rdi,%rdx,1),%r8
mov (%r8),%ecx
cmp %esi,%r9d
jge 141f <func0+0x6f>
lea 0x4(%rdi,%rdx,1),%rdx
mov (%rdx),%r11d
cmp %ecx,%r11d
jge 141f <func0+0x6f>
mov %r11d,%ecx
mov %rdx,%r8
mov %r9d,%eax
movslq %r10d,%rdx
lea (%rdi,%rdx,4),%r9
mov (%r9),%edx
cmp %ecx,%edx
jg 13e0 <func0+0x30>
sub $0x1,%r10d
cmp $0xffffffff,%r10d
jne 13d0 <func0+0x20>
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r9d, esi
mov r8, rdi
mov r10d, esi
shr r9d, 1Fh
add r9d, esi
sar r9d, 1
nop word ptr [rax+rax+00000000h]
loc_1350:
sub r9d, 1
js short locret_13AE
loc_1356:
lea eax, [r9+r9+1]
cmp r10d, eax
jle short loc_1350
loc_1360:
movsxd rdx, eax
lea edi, [rax+1]
shl rdx, 2
lea rsi, [r8+rdx]
mov ecx, [rsi]
cmp edi, r10d
jge short loc_138A
lea rdx, [r8+rdx+4]
mov r11d, [rdx]
cmp r11d, ecx
jge short loc_138A
mov ecx, r11d
mov rsi, rdx
mov eax, edi
loc_138A:
movsxd rdx, r9d
lea rdi, [r8+rdx*4]
mov edx, [rdi]
cmp edx, ecx
jle short loc_1350
lea r9d, [rax-1]
lea eax, [rax+rax+1]
mov [rdi], ecx
mov [rsi], edx
cmp r10d, eax
jg short loc_1360
sub r9d, 1
jns short loc_1356
locret_13AE:
retn | void func0(long long a1, int a2)
{
int v4; // r9d
int v5; // eax
long long v6; // rdx
_DWORD *v7; // rsi
int v8; // ecx
_DWORD *v9; // rdx
int *v10; // rdi
int v11; // edx
v4 = a2 / 2;
while ( --v4 >= 0 )
{
LABEL_3:
v5 = 2 * v4 + 1;
if ( a2 > v5 )
{
while ( 1 )
{
v6 = 4LL * v5;
v7 = (_DWORD *)(a1 + v6);
v8 = *(_DWORD *)(a1 + v6);
if ( v5 + 1 < a2 )
{
v9 = (_DWORD *)(a1 + v6 + 4);
if ( *v9 < v8 )
{
v8 = *v9;
v7 = v9;
++v5;
}
}
v10 = (int *)(a1 + 4LL * v4);
v11 = *v10;
if ( *v10 <= v8 )
break;
v4 = v5 - 1;
v5 = 2 * v5 + 1;
*v10 = v8;
*v7 = v11;
if ( a2 <= v5 )
{
if ( --v4 >= 0 )
goto LABEL_3;
return;
}
}
}
}
} | func0:
ENDBR64
MOV R9D,ESI
MOV R8,RDI
MOV R10D,ESI
SHR R9D,0x1f
ADD R9D,ESI
SAR R9D,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101350:
SUB R9D,0x1
JS 0x001013ae
LAB_00101356:
LEA EAX,[R9 + R9*0x1 + 0x1]
CMP R10D,EAX
JLE 0x00101350
LAB_00101360:
MOVSXD RDX,EAX
LEA EDI,[RAX + 0x1]
SHL RDX,0x2
LEA RSI,[R8 + RDX*0x1]
MOV ECX,dword ptr [RSI]
CMP EDI,R10D
JGE 0x0010138a
LEA RDX,[R8 + RDX*0x1 + 0x4]
MOV R11D,dword ptr [RDX]
CMP R11D,ECX
JGE 0x0010138a
MOV ECX,R11D
MOV RSI,RDX
MOV EAX,EDI
LAB_0010138a:
MOVSXD RDX,R9D
LEA RDI,[R8 + RDX*0x4]
MOV EDX,dword ptr [RDI]
CMP EDX,ECX
JLE 0x00101350
LEA R9D,[RAX + -0x1]
LEA EAX,[RAX + RAX*0x1 + 0x1]
MOV dword ptr [RDI],ECX
MOV dword ptr [RSI],EDX
CMP R10D,EAX
JG 0x00101360
SUB R9D,0x1
JNS 0x00101356
LAB_001013ae:
RET | void func0(long param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int *piVar6;
int iVar7;
iVar7 = param_2 / 2;
LAB_00101350:
do {
iVar7 = iVar7 + -1;
while( true ) {
if (iVar7 < 0) {
return;
}
iVar3 = iVar7 * 2 + 1;
if (param_2 <= iVar3) break;
do {
piVar6 = (int *)(param_1 + (long)iVar3 * 4);
iVar5 = *piVar6;
iVar4 = iVar3;
if (iVar3 + 1 < param_2) {
piVar1 = (int *)(param_1 + 4 + (long)iVar3 * 4);
iVar2 = *piVar1;
if (iVar2 < iVar5) {
piVar6 = piVar1;
iVar5 = iVar2;
iVar4 = iVar3 + 1;
}
}
piVar1 = (int *)(param_1 + (long)iVar7 * 4);
iVar2 = *piVar1;
if (iVar2 <= iVar5) goto LAB_00101350;
iVar7 = iVar4 + -1;
iVar3 = iVar4 * 2 + 1;
*piVar1 = iVar5;
*piVar6 = iVar2;
} while (iVar3 < param_2);
iVar7 = iVar4 + -2;
}
} while( true );
} |
7,312 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity++;
}
return (parity % 2 == 0);
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
jmp 116a <func0+0x21>
mov -0x14(%rbp),%eax
sub $0x1,%eax
and %eax,-0x14(%rbp)
addl $0x1,-0x4(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 115d <func0+0x14>
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
sete %al
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
jmp short loc_116A
loc_115D:
mov eax, [rbp+var_14]
sub eax, 1
and [rbp+var_14], eax
add [rbp+var_4], 1
loc_116A:
cmp [rbp+var_14], 0
jnz short loc_115D
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
setz al
pop rbp
retn | bool func0(int a1)
{
char v3; // [rsp+10h] [rbp-4h]
v3 = 0;
while ( a1 )
{
a1 &= a1 - 1;
++v3;
}
return (v3 & 1) == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010116a
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
AND dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010116a:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010115d
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
SETZ AL
POP RBP
RET | bool func0(uint param_1)
{
bool bVar1;
int4 local_1c;
bVar1 = false;
for (local_1c = param_1; local_1c != 0; local_1c = local_1c & local_1c - 1) {
bVar1 = (bool)(bVar1 ^ 1);
}
return !bVar1;
} |
7,313 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity++;
}
return (parity % 2 == 0);
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
je 1167 <func0+0x1e>
mov $0x0,%eax
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1156 <func0+0xd>
xor $0x1,%eax
and $0x1,%eax
retq
mov %edi,%eax
jmp 1160 <func0+0x17>
| func0:
endbr64
test edi, edi
jz short loc_1167
mov eax, 0
loc_1156:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1156
loc_1160:
xor eax, 1
and eax, 1
retn
loc_1167:
mov eax, edi
jmp short loc_1160 | long long func0(int a1)
{
unsigned __int8 v1; // al
if ( a1 )
{
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
}
else
{
v1 = 0;
}
return (v1 ^ 1) & 1;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101167
MOV EAX,0x0
LAB_00101156:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101156
LAB_00101160:
XOR EAX,0x1
AND EAX,0x1
RET
LAB_00101167:
MOV EAX,EDI
JMP 0x00101160 | uint func0(uint param_1)
{
uint uVar1;
if (param_1 == 0) {
uVar1 = 0;
}
else {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1;
} while (param_1 != 0);
}
return (uVar1 ^ 1) & 1;
} |
7,314 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity++;
}
return (parity % 2 == 0);
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
je 1160 <func0+0x20>
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1150 <func0+0x10>
not %eax
and $0x1,%eax
retq
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jz short loc_1160
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1150:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1150
not eax
and eax, 1
retn
loc_1160:
mov eax, 1
retn | _BOOL8 func0(int a1)
{
char v1; // al
if ( !a1 )
return 1LL;
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
return (v1 & 1) == 0;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101160
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101150
NOT EAX
AND EAX,0x1
RET
LAB_00101160:
MOV EAX,0x1
RET | uint func0(uint param_1)
{
uint uVar1;
if (param_1 != 0) {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1;
} while (param_1 != 0);
return ~uVar1 & 1;
}
return 1;
} |
7,315 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity++;
}
return (parity % 2 == 0);
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
je 1160 <func0+0x20>
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1150 <func0+0x10>
not %eax
and $0x1,%eax
retq
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jz short loc_1160
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1150:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1150
not eax
and eax, 1
retn
loc_1160:
mov eax, 1
retn | _BOOL8 func0(int a1)
{
char v1; // al
if ( !a1 )
return 1LL;
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
return (v1 & 1) == 0;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101160
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101150
NOT EAX
AND EAX,0x1
RET
LAB_00101160:
MOV EAX,0x1
RET | uint func0(uint param_1)
{
uint uVar1;
if (param_1 != 0) {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1;
} while (param_1 != 0);
return ~uVar1 & 1;
}
return 1;
} |
7,316 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int noOfZeroes[n];
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n - 2; i >= 0; i--) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i]++;
}
}
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
count += noOfZeroes[i];
}
}
return count;
}
| int main() {
int arr1[] = {1, 0, 1, 0};
int arr2[] = {0, 1, 0};
int arr3[] = {0, 0, 1, 1, 0};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 2);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x4c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1228 <func0+0x9f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1211 <func0+0x88>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1252 <func0+0xc9>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x0,-0x2c(%rbp)
mov -0x4c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4c(%rbp),%edx
sub $0x1,%edx
mov $0x1,%ecx
sub %eax,%ecx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
mov -0x4c(%rbp),%eax
sub $0x2,%eax
mov %eax,-0x30(%rbp)
jmp 12fc <func0+0x173>
mov -0x30(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jne 12f8 <func0+0x16f>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
subl $0x1,-0x30(%rbp)
cmpl $0x0,-0x30(%rbp)
jns 12a4 <func0+0x11b>
movl $0x0,-0x34(%rbp)
jmp 133a <func0+0x1b1>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0x1,%eax
jne 1336 <func0+0x1ad>
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %eax,-0x2c(%rbp)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 130b <func0+0x182>
mov -0x2c(%rbp),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 135c <func0+0x1d3>
callq 1080 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
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
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11F6:
cmp rsp, rdx
jz short loc_120D
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11F6
loc_120D:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1237
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1237:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_24], 0
mov eax, [rbp+var_3C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_3C]
sub edx, 1
mov ecx, 1
sub ecx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov [rax+rdx*4], ecx
mov eax, [rbp+var_3C]
sub eax, 2
mov [rbp+var_20], eax
jmp short loc_12E1
loc_1289:
mov eax, [rbp+var_20]
lea edx, [rax+1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov [rax+rdx*4], ecx
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
test eax, eax
jnz short loc_12DD
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
lea ecx, [rax+1]
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov [rax+rdx*4], ecx
loc_12DD:
sub [rbp+var_20], 1
loc_12E1:
cmp [rbp+var_20], 0
jns short loc_1289
mov [rbp+var_1C], 0
jmp short loc_131F
loc_12F0:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
cmp eax, 1
jnz short loc_131B
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add [rbp+var_24], eax
loc_131B:
add [rbp+var_1C], 1
loc_131F:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_3C]
jl short loc_12F0
mov eax, [rbp+var_24]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1341
call ___stack_chk_fail
locret_1341:
leave
retn | long long func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[4]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+Ch] [rbp-3Ch]
long long v7; // [rsp+10h] [rbp-38h]
unsigned int v8; // [rsp+24h] [rbp-24h]
int i; // [rsp+28h] [rbp-20h]
int j; // [rsp+2Ch] [rbp-1Ch]
long long v11; // [rsp+30h] [rbp-18h]
_BYTE *v12; // [rsp+38h] [rbp-10h]
unsigned long long v13; // [rsp+40h] [rbp-8h]
v7 = a1;
v6 = a2;
v13 = __readfsqword(0x28u);
v11 = a2 - 1LL;
v2 = 16 * ((4LL * a2 + 15) / 0x10uLL);
while ( v5 != &v5[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v5[(v2 & 0xFFF) - 8] = *(_QWORD *)&v5[(v2 & 0xFFF) - 8];
v12 = v5;
v8 = 0;
*(_DWORD *)&v5[4 * v6 - 4] = 1 - *(_DWORD *)(4LL * v6 - 4 + v7);
for ( i = v6 - 2; i >= 0; --i )
{
*(_DWORD *)&v12[4 * i] = *(_DWORD *)&v12[4 * i + 4];
if ( !*(_DWORD *)(4LL * i + v7) )
++*(_DWORD *)&v12[4 * i];
}
for ( j = 0; j < v6; ++j )
{
if ( *(_DWORD *)(4LL * j + v7) == 1 )
v8 += *(_DWORD *)&v12[4 * j];
}
return v8;
} | 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
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011f6:
CMP RSP,RDX
JZ 0x0010120d
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011f6
LAB_0010120d:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101237
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101237:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x3c]
SUB EDX,0x1
MOV ECX,0x1
SUB ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x2
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001012e1
LAB_00101289:
MOV EAX,dword ptr [RBP + -0x20]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x001012dd
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LEA ECX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_001012dd:
SUB dword ptr [RBP + -0x20],0x1
LAB_001012e1:
CMP dword ptr [RBP + -0x20],0x0
JNS 0x00101289
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010131f
LAB_001012f0:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,0x1
JNZ 0x0010131b
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD dword ptr [RBP + -0x24],EAX
LAB_0010131b:
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010131f:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001012f0
MOV EAX,dword ptr [RBP + -0x24]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101341
CALL 0x00101080
LAB_00101341:
LEAVE
RET | int func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
long local_40;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_40 = param_1;
local_44 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)param_2 + -1;
uVar2 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
local_2c = 0;
*(int *)(puVar3 + (long)(local_44 + -1) * 4 + lVar1) =
1 - *(int *)(local_40 + (long)local_44 * 4 + -4);
for (local_28 = local_44 + -2; -1 < local_28; local_28 = local_28 + -1) {
*(int4 *)(puVar3 + (long)local_28 * 4 + lVar1) =
*(int4 *)(puVar3 + (long)(local_28 + 1) * 4 + lVar1);
if (*(int *)(local_40 + (long)local_28 * 4) == 0) {
*(int *)(puVar3 + (long)local_28 * 4 + lVar1) =
*(int *)(puVar3 + (long)local_28 * 4 + lVar1) + 1;
}
}
for (local_24 = 0; local_24 < local_44; local_24 = local_24 + 1) {
if (*(int *)(local_40 + (long)local_24 * 4) == 1) {
local_2c = local_2c + *(int *)(puVar3 + (long)local_24 * 4 + lVar1);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_2c;
} |
7,317 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int noOfZeroes[n];
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n - 2; i >= 0; i--) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i]++;
}
}
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
count += noOfZeroes[i];
}
}
return count;
}
| int main() {
int arr1[] = {1, 0, 1, 0};
int arr2[] = {0, 1, 0};
int arr3[] = {0, 0, 1, 1, 0};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 2);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rdx
shl $0x2,%rdx
lea 0xf(%rdx),%rax
mov %rax,%rcx
and $0xfffffffffffffff0,%rcx
and $0xfffffffffffff000,%rax
mov %rsp,%r10
sub %rax,%r10
mov %r10,%rax
cmp %rax,%rsp
je 11dc <func0+0x53>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11c5 <func0+0x3c>
mov %rcx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11f2 <func0+0x69>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r9
mov %r9,%rcx
lea -0x1(%rsi),%eax
cltq
mov $0x1,%r8d
sub -0x4(%rdi,%rdx,1),%r8d
mov %r8d,(%r9,%rax,4)
mov %esi,%eax
sub $0x2,%eax
js 1234 <func0+0xab>
cltq
jmp 121f <func0+0x96>
sub $0x1,%rax
test %eax,%eax
js 1234 <func0+0xab>
mov 0x4(%rcx,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
cmpl $0x0,(%rdi,%rax,4)
jne 1217 <func0+0x8e>
add $0x1,%edx
mov %edx,(%rcx,%rax,4)
jmp 1217 <func0+0x8e>
test %esi,%esi
jle 1260 <func0+0xd7>
lea -0x1(%rsi),%esi
mov $0x0,%eax
mov $0x0,%r8d
jmp 1254 <func0+0xcb>
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 1266 <func0+0xdd>
mov %rdx,%rax
cmpl $0x1,(%rdi,%rax,4)
jne 1248 <func0+0xbf>
add (%rcx,%rax,4),%r8d
jmp 1248 <func0+0xbf>
mov $0x0,%r8d
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 127a <func0+0xf1>
mov %r8d,%eax
leaveq
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rdx, esi
shl rdx, 2
lea rax, [rdx+0Fh]
mov r8, rax
and r8, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rax
loc_11C2:
cmp rsp, rcx
jz short loc_11D9
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11C2
loc_11D9:
mov rax, r8
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11EF
or [rsp+rax+10h+var_18], 0
loc_11EF:
mov rcx, rsp
lea eax, [rsi-1]
cdqe
mov r8d, 1
sub r8d, [rdi+rdx-4]
mov [rcx+rax*4], r8d
mov eax, esi
sub eax, 2
js short loc_122E
cdqe
jmp short loc_1219
loc_1211:
sub rax, 1
test eax, eax
js short loc_122E
loc_1219:
mov edx, [rcx+rax*4+4]
mov [rcx+rax*4], edx
cmp dword ptr [rdi+rax*4], 0
jnz short loc_1211
add edx, 1
mov [rcx+rax*4], edx
jmp short loc_1211
loc_122E:
test esi, esi
jle short loc_1254
mov edx, esi
mov eax, 0
mov esi, 0
jmp short loc_1249
loc_1240:
add rax, 1
cmp rax, rdx
jz short loc_1259
loc_1249:
cmp dword ptr [rdi+rax*4], 1
jnz short loc_1240
add esi, [rcx+rax*4]
jmp short loc_1240
loc_1254:
mov esi, 0
loc_1259:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_126C
mov eax, esi
leave
retn
loc_126C:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v2; // rdx
signed long long v3; // rax
void *v4; // rsp
long long v5; // rax
int v6; // edx
long long v7; // rdx
long long v8; // rax
unsigned int v9; // esi
_DWORD v12[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v13; // [rsp+10h] [rbp-8h]
v13 = __readfsqword(0x28u);
v2 = 4LL * a2;
while ( v12 != (_DWORD *)((char *)v12 - ((v2 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v3 = ((_WORD)v2 + 15) & 0xFF0;
v4 = alloca(v3);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v12[-2] + v3) = *(_QWORD *)((char *)&v12[-2] + v3);
v12[a2 - 1] = 1 - *(_DWORD *)(a1 + v2 - 4);
LODWORD(v5) = a2 - 2;
if ( a2 - 2 >= 0 )
{
v5 = (int)v5;
do
{
v6 = v12[v5 + 1];
v12[v5] = v6;
if ( !*(_DWORD *)(a1 + 4 * v5) )
v12[v5] = v6 + 1;
--v5;
}
while ( (int)v5 >= 0 );
}
if ( a2 <= 0 )
{
return 0;
}
else
{
v7 = (unsigned int)a2;
v8 = 0LL;
v9 = 0;
do
{
if ( *(_DWORD *)(a1 + 4 * v8) == 1 )
v9 += v12[v8];
++v8;
}
while ( v8 != v7 );
}
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RDX,ESI
SHL RDX,0x2
LEA RAX,[RDX + 0xf]
MOV R8,RAX
AND R8,-0x10
AND RAX,-0x1000
MOV RCX,RSP
SUB RCX,RAX
LAB_001011c2:
CMP RSP,RCX
JZ 0x001011d9
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011c2
LAB_001011d9:
MOV RAX,R8
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011ef
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011ef:
MOV RCX,RSP
LEA EAX,[RSI + -0x1]
CDQE
MOV R8D,0x1
SUB R8D,dword ptr [RDI + RDX*0x1 + -0x4]
MOV dword ptr [RCX + RAX*0x4],R8D
MOV EAX,ESI
SUB EAX,0x2
JS 0x0010122e
CDQE
JMP 0x00101219
LAB_00101211:
SUB RAX,0x1
TEST EAX,EAX
JS 0x0010122e
LAB_00101219:
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
CMP dword ptr [RDI + RAX*0x4],0x0
JNZ 0x00101211
ADD EDX,0x1
MOV dword ptr [RCX + RAX*0x4],EDX
JMP 0x00101211
LAB_0010122e:
TEST ESI,ESI
JLE 0x00101254
MOV EDX,ESI
MOV EAX,0x0
MOV ESI,0x0
JMP 0x00101249
LAB_00101240:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x00101259
LAB_00101249:
CMP dword ptr [RDI + RAX*0x4],0x1
JNZ 0x00101240
ADD ESI,dword ptr [RCX + RAX*0x4]
JMP 0x00101240
LAB_00101254:
MOV ESI,0x0
LAB_00101259:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010126c
MOV EAX,ESI
LEAVE
RET
LAB_0010126c:
CALL 0x00101080 | int func0(long param_1,uint param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
int1 *puVar4;
int iVar5;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(int)param_2 * 4 + 0xf;
for (puVar4 = auStack_18; puVar4 != auStack_18 + -(uVar3 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
if (uVar3 != 0) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
*(int *)(puVar4 + (long)(int)(param_2 - 1) * 4 + lVar1) =
1 - *(int *)(param_1 + -4 + (long)(int)param_2 * 4);
if (-1 < (int)(param_2 - 2)) {
lVar2 = (long)(int)(param_2 - 2);
do {
*(int *)(puVar4 + lVar2 * 4 + lVar1) = *(int *)(puVar4 + lVar2 * 4 + lVar1 + 4);
if (*(int *)(param_1 + lVar2 * 4) == 0) {
*(int *)(puVar4 + lVar2 * 4 + lVar1) = *(int *)(puVar4 + lVar2 * 4 + lVar1 + 4) + 1;
}
lVar2 = lVar2 + -1;
} while (-1 < (int)lVar2);
}
if ((int)param_2 < 1) {
iVar5 = 0;
}
else {
uVar3 = 0;
iVar5 = 0;
do {
if (*(int *)(param_1 + uVar3 * 4) == 1) {
iVar5 = iVar5 + *(int *)(puVar4 + uVar3 * 4 + lVar1);
}
uVar3 = uVar3 + 1;
} while (uVar3 != param_2);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar5;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar4 + lVar1 + -8) = main;
__stack_chk_fail();
} |
7,318 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int noOfZeroes[n];
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n - 2; i >= 0; i--) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i]++;
}
}
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
count += noOfZeroes[i];
}
}
return count;
}
| int main() {
int arr1[] = {1, 0, 1, 0};
int arr2[] = {0, 1, 0};
int arr3[] = {0, 0, 1, 1, 0};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 2);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
mov %rsi,%r8
shl $0x2,%rsi
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xf(%rsi),%rax
mov %rsp,%rcx
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1309 <func0+0x59>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12f4 <func0+0x44>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13a0 <func0+0xf0>
mov $0x1,%edx
sub -0x4(%rdi,%rsi,1),%edx
lea -0x1(%r8),%esi
mov %rsp,%rcx
movslq %esi,%rax
mov %edx,(%rcx,%rax,4)
mov %r8d,%eax
sub $0x2,%eax
js 135e <func0+0xae>
cltq
jmp 1344 <func0+0x94>
nopl (%rax)
mov 0x4(%rcx,%rax,4),%edx
mov (%rdi,%rax,4),%r9d
mov %edx,(%rcx,%rax,4)
test %r9d,%r9d
jne 1356 <func0+0xa6>
add $0x1,%edx
mov %edx,(%rcx,%rax,4)
sub $0x1,%rax
test %eax,%eax
jns 1340 <func0+0x90>
test %r8d,%r8d
jle 13b0 <func0+0x100>
mov %esi,%esi
xor %eax,%eax
xor %r8d,%r8d
jmp 1373 <func0+0xc3>
nopl 0x0(%rax)
mov %rdx,%rax
cmpl $0x1,(%rdi,%rax,4)
jne 137d <func0+0xcd>
add (%rcx,%rax,4),%r8d
lea 0x1(%rax),%rdx
cmp %rax,%rsi
jne 1370 <func0+0xc0>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 13b5 <func0+0x105>
leaveq
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 131b <func0+0x6b>
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
jmp 1386 <func0+0xd6>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd rsi, esi
lea r9, ds:0[rsi*4]
mov r8, rsi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [r9+0Fh]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_130A
loc_12F5:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_12F5
loc_130A:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13A0
loc_131C:
lea eax, [r8-1]
mov rcx, rsp
mov edx, 1
sub edx, [rdi+r9-4]
cdqe
mov [rcx+rax*4], edx
mov eax, r8d
sub eax, 2
js short loc_135E
cdqe
jmp short loc_1344
loc_1340:
mov edx, [rcx+rax*4+4]
loc_1344:
mov r9d, [rdi+rax*4]
mov [rcx+rax*4], edx
test r9d, r9d
jnz short loc_1356
add edx, 1
mov [rcx+rax*4], edx
loc_1356:
sub rax, 1
test eax, eax
jns short loc_1340
loc_135E:
test r8d, r8d
jle short loc_13B0
xor eax, eax
xor r8d, r8d
nop dword ptr [rax+rax+00000000h]
loc_1370:
cmp dword ptr [rdi+rax*4], 1
jnz short loc_137A
add r8d, [rcx+rax*4]
loc_137A:
add rax, 1
cmp rsi, rax
jnz short loc_1370
loc_1383:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_13B5
leave
mov eax, r8d
retn
loc_13A0:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_131C
loc_13B0:
xor r8d, r8d
jmp short loc_1383
loc_13B5:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v2; // r9
_DWORD *v3; // rcx
signed long long v4; // rdx
void *v5; // rsp
int v6; // edx
long long i; // rax
int v8; // r9d
long long v9; // rax
unsigned int v10; // r8d
_DWORD v13[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v14[2]; // [rsp+1008h] [rbp-10h] BYREF
v2 = 4LL * a2;
v14[1] = __readfsqword(0x28u);
v3 = (_DWORD *)((char *)v14 - ((v2 + 15) & 0xFFFFFFFFFFFFF000LL));
if ( v14 != (_QWORD *)v3 )
{
while ( v13 != v3 )
;
}
v4 = ((_WORD)v2 + 15) & 0xFF0;
v5 = alloca(v4);
if ( (((_WORD)v2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v13[-2] + v4) = *(_QWORD *)((char *)&v13[-2] + v4);
v6 = 1 - *(_DWORD *)(a1 + v2 - 4);
v13[a2 - 1] = v6;
LODWORD(i) = a2 - 2;
if ( a2 - 2 >= 0 )
{
for ( i = (int)i; ; v6 = v13[i + 1] )
{
v8 = *(_DWORD *)(a1 + 4 * i);
v13[i] = v6;
if ( !v8 )
v13[i] = v6 + 1;
if ( (int)--i < 0 )
break;
}
}
if ( a2 <= 0 )
{
return 0;
}
else
{
v9 = 0LL;
v10 = 0;
do
{
if ( *(_DWORD *)(a1 + 4 * v9) == 1 )
v10 += v13[v9];
++v9;
}
while ( a2 != v9 );
}
return v10;
} | func0:
ENDBR64
PUSH RBP
MOVSXD RSI,ESI
LEA R9,[RSI*0x4]
MOV R8,RSI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[R9 + 0xf]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010130a
LAB_001012f5:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012f5
LAB_0010130a:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013a0
LAB_0010131c:
LEA EAX,[R8 + -0x1]
MOV RCX,RSP
MOV EDX,0x1
SUB EDX,dword ptr [RDI + R9*0x1 + -0x4]
CDQE
MOV dword ptr [RCX + RAX*0x4],EDX
MOV EAX,R8D
SUB EAX,0x2
JS 0x0010135e
CDQE
JMP 0x00101344
LAB_00101340:
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
LAB_00101344:
MOV R9D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
TEST R9D,R9D
JNZ 0x00101356
ADD EDX,0x1
MOV dword ptr [RCX + RAX*0x4],EDX
LAB_00101356:
SUB RAX,0x1
TEST EAX,EAX
JNS 0x00101340
LAB_0010135e:
TEST R8D,R8D
JLE 0x001013b0
XOR EAX,EAX
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101370:
CMP dword ptr [RDI + RAX*0x4],0x1
JNZ 0x0010137a
ADD R8D,dword ptr [RCX + RAX*0x4]
LAB_0010137a:
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101370
LAB_00101383:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013b5
LEAVE
MOV EAX,R8D
RET
LAB_001013a0:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010131c
LAB_001013b0:
XOR R8D,R8D
JMP 0x00101383
LAB_001013b5:
CALL 0x00101080 | int func0(long param_1,int param_2)
{
int iVar1;
long lVar2;
int1 *puVar3;
long lVar4;
int iVar5;
ulong uVar6;
int1 *puVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar8;
lVar4 = (long)param_2 * 4;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = lVar4 + 0xf;
puVar8 = auStack_18;
puVar3 = auStack_18;
while (puVar8 != auStack_18 + -(uVar6 & 0xfffffffffffff000)) {
puVar7 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar8 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar2 = -uVar6;
if (uVar6 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
iVar5 = 1 - *(int *)(param_1 + -4 + lVar4);
*(int *)(puVar7 + (long)(param_2 + -1) * 4 + lVar2) = iVar5;
if (-1 < param_2 + -2) {
lVar4 = (long)(param_2 + -2);
while( true ) {
iVar1 = *(int *)(param_1 + lVar4 * 4);
*(int *)(puVar7 + lVar4 * 4 + lVar2) = iVar5;
if (iVar1 == 0) {
*(int *)(puVar7 + lVar4 * 4 + lVar2) = iVar5 + 1;
}
lVar4 = lVar4 + -1;
if ((int)lVar4 < 0) break;
iVar5 = *(int *)(puVar7 + lVar4 * 4 + lVar2 + 4);
}
}
if (param_2 < 1) {
iVar5 = 0;
}
else {
lVar4 = 0;
iVar5 = 0;
do {
if (*(int *)(param_1 + lVar4 * 4) == 1) {
iVar5 = iVar5 + *(int *)(puVar7 + lVar4 * 4 + lVar2);
}
lVar4 = lVar4 + 1;
} while (param_2 != lVar4);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar2 + -8) = 0x1013ba;
__stack_chk_fail();
}
return iVar5;
} |
7,319 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int noOfZeroes[n];
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n - 2; i >= 0; i--) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i]++;
}
}
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
count += noOfZeroes[i];
}
}
return count;
}
| int main() {
int arr1[] = {1, 0, 1, 0};
int arr2[] = {0, 1, 0};
int arr3[] = {0, 0, 1, 1, 0};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 2);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
movslq %esi,%rdx
mov %rdx,%r8
shl $0x2,%rdx
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xf(%rdx),%rax
mov %rsp,%rsi
mov %rax,%rcx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rcx
mov %rsi,%rax
cmp %rax,%rsp
je 1309 <func0+0x59>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12f4 <func0+0x44>
and $0xfff,%ecx
sub %rcx,%rsp
test %rcx,%rcx
jne 13a0 <func0+0xf0>
lea -0x1(%r8),%esi
mov %rsp,%rcx
mov $0x1,%eax
sub -0x4(%rdi,%rdx,1),%eax
movslq %esi,%r9
mov %eax,(%rcx,%r9,4)
mov %r8d,%eax
sub $0x2,%eax
js 135e <func0+0xae>
cltq
nopl 0x0(%rax)
mov 0x4(%rcx,%rax,4),%edx
mov (%rdi,%rax,4),%r9d
mov %edx,(%rcx,%rax,4)
test %r9d,%r9d
jne 1356 <func0+0xa6>
add $0x1,%edx
mov %edx,(%rcx,%rax,4)
sub $0x1,%rax
test %eax,%eax
jns 1340 <func0+0x90>
test %r8d,%r8d
jle 13b0 <func0+0x100>
mov %esi,%esi
xor %eax,%eax
xor %r8d,%r8d
jmp 1373 <func0+0xc3>
nopl 0x0(%rax)
mov %rdx,%rax
cmpl $0x1,(%rdi,%rax,4)
jne 137d <func0+0xcd>
add (%rcx,%rax,4),%r8d
lea 0x1(%rax),%rdx
cmp %rax,%rsi
jne 1370 <func0+0xc0>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 13b5 <func0+0x105>
leaveq
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rcx,1)
jmpq 131b <func0+0x6b>
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
jmp 1386 <func0+0xd6>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd rsi, esi
mov rdx, rsi
shl rsi, 2
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rsi+0Fh]
mov r8, rsp
mov rcx, rax
and rax, 0FFFFFFFFFFFFF000h
sub r8, rax
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, r8
jz short loc_12F6
loc_12E1:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, r8
jnz short loc_12E1
loc_12F6:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz short loc_1378
loc_1304:
lea eax, [rdx-1]
mov rcx, rsp
mov r8d, 1
sub r8d, [rdi+rsi-4]
cdqe
mov [rcx+rax*4], r8d
mov eax, edx
sub eax, 2
js short loc_1380
cdqe
nop dword ptr [rax+00h]
loc_1328:
mov edx, [rcx+rax*4+4]
mov r8d, [rdi+rax*4]
mov [rcx+rax*4], edx
test r8d, r8d
jnz short loc_133E
add edx, 1
mov [rcx+rax*4], edx
loc_133E:
sub rax, 1
test eax, eax
jns short loc_1328
loc_1346:
xor eax, eax
xor edx, edx
nop word ptr [rax+rax+00h]
loc_1350:
cmp dword ptr [rdi+rax], 1
jnz short loc_1359
add edx, [rcx+rax]
loc_1359:
add rax, 4
cmp rsi, rax
jnz short loc_1350
loc_1362:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_1389
leave
mov eax, edx
retn
loc_1378:
or [rsp+rcx+1010h+var_1018], 0
jmp short loc_1304
loc_1380:
cmp edx, 1
jz short loc_1346
xor edx, edx
jmp short loc_1362
loc_1389:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v3; // rsi
_BYTE *v4; // r8
signed long long v5; // rcx
void *v6; // rsp
long long v7; // rax
int v8; // edx
int v9; // r8d
long long v10; // rax
unsigned int v11; // edx
_BYTE v14[4088]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v15[2]; // [rsp+1008h] [rbp-10h] BYREF
v3 = 4LL * a2;
v15[1] = __readfsqword(0x28u);
v4 = (char *)v15 - ((v3 + 15) & 0xFFFFFFFFFFFFF000LL);
if ( v15 != (_QWORD *)v4 )
{
while ( v14 != v4 )
;
}
v5 = ((_WORD)v3 + 15) & 0xFF0;
v6 = alloca(v5);
if ( (((_WORD)v3 + 15) & 0xFF0) != 0 )
*(_QWORD *)&v14[v5 - 8] = *(_QWORD *)&v14[v5 - 8];
*(_DWORD *)&v14[4 * a2 - 4] = 1 - *(_DWORD *)(a1 + v3 - 4);
LODWORD(v7) = a2 - 2;
if ( a2 - 2 < 0 )
{
if ( a2 != 1 )
return 0;
}
else
{
v7 = (int)v7;
do
{
v8 = *(_DWORD *)&v14[4 * v7 + 4];
v9 = *(_DWORD *)(a1 + 4 * v7);
*(_DWORD *)&v14[4 * v7] = v8;
if ( !v9 )
*(_DWORD *)&v14[4 * v7] = v8 + 1;
--v7;
}
while ( (int)v7 >= 0 );
}
v10 = 0LL;
v11 = 0;
do
{
if ( *(_DWORD *)(a1 + v10) == 1 )
v11 += *(_DWORD *)&v14[v10];
v10 += 4LL;
}
while ( v3 != v10 );
return v11;
} | func0:
ENDBR64
PUSH RBP
MOVSXD RSI,ESI
MOV RDX,RSI
SHL RSI,0x2
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RSI + 0xf]
MOV R8,RSP
MOV RCX,RAX
AND RAX,-0x1000
SUB R8,RAX
AND RCX,-0x10
CMP RSP,R8
JZ 0x001012f6
LAB_001012e1:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,R8
JNZ 0x001012e1
LAB_001012f6:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x00101378
LAB_00101304:
LEA EAX,[RDX + -0x1]
MOV RCX,RSP
MOV R8D,0x1
SUB R8D,dword ptr [RDI + RSI*0x1 + -0x4]
CDQE
MOV dword ptr [RCX + RAX*0x4],R8D
MOV EAX,EDX
SUB EAX,0x2
JS 0x00101380
CDQE
NOP dword ptr [RAX]
LAB_00101328:
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV R8D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
TEST R8D,R8D
JNZ 0x0010133e
ADD EDX,0x1
MOV dword ptr [RCX + RAX*0x4],EDX
LAB_0010133e:
SUB RAX,0x1
TEST EAX,EAX
JNS 0x00101328
LAB_00101346:
XOR EAX,EAX
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101350:
CMP dword ptr [RDI + RAX*0x1],0x1
JNZ 0x00101359
ADD EDX,dword ptr [RCX + RAX*0x1]
LAB_00101359:
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x00101350
LAB_00101362:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101389
LEAVE
MOV EAX,EDX
RET
LAB_00101378:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x00101304
LAB_00101380:
CMP EDX,0x1
JZ 0x00101346
XOR EDX,EDX
JMP 0x00101362
LAB_00101389:
CALL 0x00101080 | int func0(long param_1,int param_2)
{
long lVar1;
int *puVar2;
long lVar3;
ulong uVar4;
int iVar5;
int *puVar6;
long lVar8;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar7;
lVar8 = (long)param_2 * 4;
puVar6 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
puVar7 = auStack_18;
puVar2 = auStack_18;
while (puVar7 != auStack_18 + -(lVar8 + 0xfU & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)(lVar8 + 0xfU) & 0xff0);
lVar1 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
*(int *)(puVar6 + (long)(param_2 + -1) * 4 + lVar1) = 1 - *(int *)(param_1 + -4 + lVar8);
if (param_2 + -2 < 0) {
if (param_2 != 1) {
iVar5 = 0;
goto LAB_00101362;
}
}
else {
lVar3 = (long)(param_2 + -2);
do {
iVar5 = *(int *)(param_1 + lVar3 * 4);
*(int *)(puVar6 + lVar3 * 4 + lVar1) = *(int *)(puVar6 + lVar3 * 4 + lVar1 + 4);
if (iVar5 == 0) {
*(int *)(puVar6 + lVar3 * 4 + lVar1) = *(int *)(puVar6 + lVar3 * 4 + lVar1 + 4) + 1;
}
lVar3 = lVar3 + -1;
} while (-1 < (int)lVar3);
}
lVar3 = 0;
iVar5 = 0;
do {
if (*(int *)(param_1 + lVar3) == 1) {
iVar5 = iVar5 + *(int *)(puVar6 + lVar3 + lVar1);
}
lVar3 = lVar3 + 4;
} while (lVar8 != lVar3);
LAB_00101362:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x10138e;
__stack_chk_fail();
}
return iVar5;
} |
7,320 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| char** func0(char** list1, int num_elements, int* sizes) {
char** result = (char**)malloc(num_elements * sizeof(char*));
for (int i = 0; i < num_elements; i++) {
int len = strlen(list1[i]);
sizes[i] = len;
result[i] = (char*)malloc((len + 1) * sizeof(char));
for (int j = 0; j < len; j++) {
result[i][j] = list1[i][j];
}
result[i][len] = '\0';
}
return result;
}
| int main() {
int sizes1[5], sizes2[1], sizes3[6];
char* list1[] = {"Red", "Blue", "Black", "White", "Pink"};
char** result1 = func0(list1, 5, sizes1);
assert(sizes1[0] == 3 && sizes1[1] == 4);
assert(strcmp(result1[0], "Red") == 0 && strcmp(result1[1], "Blue") == 0);
char* list2[] = {"python"};
char** result2 = func0(list2, 1, sizes2);
assert(sizes2[0] == 6);
assert(strcmp(result2[0], "python") == 0);
char* list3[] = {" red ", "green", " black", "blue ", " orange", "brown"};
char** result3 = func0(list3, 6, sizes3);
assert(sizes3[0] == 5 && sizes3[1] == 5);
assert(strcmp(result3[0], " red ") == 0 && strcmp(result3[1], "green") == 0);
// Free allocated memory
for (int i = 0; i < 5; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 1; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 6; i++) free(result3[i]);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
jmpq 1306 <func0+0x11d>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x1c(%rbp)
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rax,%rdx
mov -0x1c(%rbp),%eax
mov %eax,(%rdx)
mov -0x1c(%rbp),%eax
add $0x1,%eax
cltq
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,-0x20(%rbp)
jmp 12d8 <func0+0xef>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x20(%rbp),%eax
cltq
add %rdx,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rcx
mov -0x20(%rbp),%edx
movslq %edx,%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 128f <func0+0xa6>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movb $0x0,(%rax)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1222 <func0+0x39>
mov -0x18(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_24], 0
jmp loc_1306
loc_1222:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov [rbp+var_1C], eax
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rdx, rax
mov eax, [rbp+var_1C]
mov [rdx], eax
mov eax, [rbp+var_1C]
add eax, 1
cdqe
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov [rbp+var_20], 0
jmp short loc_12D8
loc_128F:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_20]
cdqe
add rax, rdx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rcx, [rdx]
mov edx, [rbp+var_20]
movsxd rdx, edx
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
add [rbp+var_20], 1
loc_12D8:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jl short loc_128F
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
mov byte ptr [rax], 0
add [rbp+var_24], 1
loc_1306:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl loc_1222
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2, long long a3)
{
int i; // [rsp+2Ch] [rbp-24h]
int j; // [rsp+30h] [rbp-20h]
int v7; // [rsp+34h] [rbp-1Ch]
_QWORD *v8; // [rsp+38h] [rbp-18h]
v8 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
v7 = strlen(*(const char **)(8LL * i + a1));
*(_DWORD *)(a3 + 4LL * i) = v7;
v8[i] = malloc(v7 + 1);
for ( j = 0; j < v7; ++j )
*(_BYTE *)(v8[i] + j) = *(_BYTE *)(*(_QWORD *)(8LL * i + a1) + j);
*(_BYTE *)(v8[i] + v7) = 0;
}
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101306
LAB_00101222:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001012d8
LAB_0010128f:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RCX,qword ptr [RDX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x20],0x1
LAB_001012d8:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010128f
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOV byte ptr [RAX],0x0
ADD dword ptr [RBP + -0x24],0x1
LAB_00101306:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101222
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,long param_3)
{
int iVar1;
void *pvVar2;
size_t sVar3;
void *pvVar4;
int4 local_2c;
int4 local_28;
pvVar2 = malloc((long)param_2 << 3);
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
sVar3 = strlen(*(char **)(param_1 + (long)local_2c * 8));
iVar1 = (int)sVar3;
*(int *)((long)local_2c * 4 + param_3) = iVar1;
pvVar4 = malloc((long)(iVar1 + 1));
*(void **)((long)local_2c * 8 + (long)pvVar2) = pvVar4;
for (local_28 = 0; local_28 < iVar1; local_28 = local_28 + 1) {
*(int *)((long)local_28 + *(long *)((long)pvVar2 + (long)local_2c * 8)) =
*(int *)((long)local_28 + *(long *)(param_1 + (long)local_2c * 8));
}
*(int *)((long)iVar1 + *(long *)((long)pvVar2 + (long)local_2c * 8)) = 0;
}
return pvVar2;
} |
7,321 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| char** func0(char** list1, int num_elements, int* sizes) {
char** result = (char**)malloc(num_elements * sizeof(char*));
for (int i = 0; i < num_elements; i++) {
int len = strlen(list1[i]);
sizes[i] = len;
result[i] = (char*)malloc((len + 1) * sizeof(char));
for (int j = 0; j < len; j++) {
result[i][j] = list1[i][j];
}
result[i][len] = '\0';
}
return result;
}
| int main() {
int sizes1[5], sizes2[1], sizes3[6];
char* list1[] = {"Red", "Blue", "Black", "White", "Pink"};
char** result1 = func0(list1, 5, sizes1);
assert(sizes1[0] == 3 && sizes1[1] == 4);
assert(strcmp(result1[0], "Red") == 0 && strcmp(result1[1], "Blue") == 0);
char* list2[] = {"python"};
char** result2 = func0(list2, 1, sizes2);
assert(sizes2[0] == 6);
assert(strcmp(result2[0], "python") == 0);
char* list3[] = {" red ", "green", " black", "blue ", " orange", "brown"};
char** result3 = func0(list3, 6, sizes3);
assert(sizes3[0] == 5 && sizes3[1] == 5);
assert(strcmp(result3[0], " red ") == 0 && strcmp(result3[1], "green") == 0);
// Free allocated memory
for (int i = 0; i < 5; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 1; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 6; i++) free(result3[i]);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %esi,%ebx
mov %rdx,%r14
movslq %esi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 1263 <func0+0xba>
mov %rbp,%r12
mov %rax,%r13
lea -0x1(%rbx),%eax
lea 0x8(%rbp,%rax,8),%r15
jmp 1207 <func0+0x5e>
movslq %ebx,%rbx
mov (%rsi),%rax
movb $0x0,(%rax,%rbx,1)
add $0x8,%r12
add $0x4,%r14
add $0x8,%r13
cmp %r15,%r12
je 1263 <func0+0xba>
mov %r12,%rbp
mov (%r12),%rdi
mov $0x0,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rbx
mov %ebx,(%r14)
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %r13,%rsi
mov %rax,0x0(%r13)
test %ebx,%ebx
jle 11ec <func0+0x43>
lea -0x1(%rbx),%edi
mov $0x0,%eax
mov 0x0(%rbp),%rdx
movzbl (%rdx,%rax,1),%ecx
mov (%rsi),%rdx
mov %cl,(%rdx,%rax,1)
mov %rax,%rdx
add $0x1,%rax
cmp %rdi,%rdx
jne 1247 <func0+0x9e>
jmp 11ec <func0+0x43>
mov 0x8(%rsp),%rax
add $0x18,%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 r13d, esi
mov r15, rdx
movsxd rdi, esi
shl rdi, 3
call _malloc
mov r14, rax
test r13d, r13d
jle short loc_1272
mov r13d, r13d
mov ebp, 0
loc_1220:
mov rdi, [r12+rbp*8]
call _strlen
mov rbx, rax
mov [r15+rbp*4], eax
lea edi, [rax+1]
movsxd rdi, edi
call _malloc
mov [r14+rbp*8], rax
test ebx, ebx
jle short loc_1262
mov rdi, [r12+rbp*8]
lea esi, [rbx-1]
mov edx, 0
loc_124F:
movzx ecx, byte ptr [rdi+rdx]
mov [rax+rdx], cl
mov rcx, rdx
add rdx, 1
cmp rcx, rsi
jnz short loc_124F
loc_1262:
movsxd rbx, ebx
mov byte ptr [rax+rbx], 0
add rbp, 1
cmp rbp, r13
jnz short loc_1220
loc_1272:
mov rax, r14
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2, long long a3)
{
long long v5; // r14
long long i; // rbp
int v7; // ebx
long long v8; // rax
long long v9; // rdi
long long v10; // rdx
long long v11; // rcx
v5 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
v7 = strlen(*(_QWORD *)(a1 + 8 * i));
*(_DWORD *)(a3 + 4 * i) = v7;
v8 = malloc(v7 + 1);
*(_QWORD *)(v5 + 8 * i) = v8;
if ( v7 > 0 )
{
v9 = *(_QWORD *)(a1 + 8 * i);
v10 = 0LL;
do
{
*(_BYTE *)(v8 + v10) = *(_BYTE *)(v9 + v10);
v11 = v10++;
}
while ( v11 != v7 - 1 );
}
*(_BYTE *)(v8 + v7) = 0;
}
}
return v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV R13D,ESI
MOV R15,RDX
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x001010f0
MOV R14,RAX
TEST R13D,R13D
JLE 0x00101272
MOV R13D,R13D
MOV EBP,0x0
LAB_00101220:
MOV RDI,qword ptr [R12 + RBP*0x8]
CALL 0x001010b0
MOV RBX,RAX
MOV dword ptr [R15 + RBP*0x4],EAX
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x001010f0
MOV qword ptr [R14 + RBP*0x8],RAX
TEST EBX,EBX
JLE 0x00101262
MOV RDI,qword ptr [R12 + RBP*0x8]
LEA ESI,[RBX + -0x1]
MOV EDX,0x0
LAB_0010124f:
MOVZX ECX,byte ptr [RDI + RDX*0x1]
MOV byte ptr [RAX + RDX*0x1],CL
MOV RCX,RDX
ADD RDX,0x1
CMP RCX,RSI
JNZ 0x0010124f
LAB_00101262:
MOVSXD RBX,EBX
MOV byte ptr [RAX + RBX*0x1],0x0
ADD RBP,0x1
CMP RBP,R13
JNZ 0x00101220
LAB_00101272:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(long param_1,uint param_2,long param_3)
{
long lVar1;
int iVar2;
void *pvVar3;
size_t sVar4;
void *pvVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
pvVar3 = malloc((long)(int)param_2 << 3);
if (0 < (int)param_2) {
uVar7 = 0;
do {
sVar4 = strlen(*(char **)(param_1 + uVar7 * 8));
iVar2 = (int)sVar4;
*(int *)(param_3 + uVar7 * 4) = iVar2;
pvVar5 = malloc((long)(iVar2 + 1));
*(void **)((long)pvVar3 + uVar7 * 8) = pvVar5;
if (0 < iVar2) {
lVar1 = *(long *)(param_1 + uVar7 * 8);
uVar6 = 0;
do {
*(int1 *)((long)pvVar5 + uVar6) = *(int1 *)(lVar1 + uVar6);
bVar8 = uVar6 != iVar2 - 1;
uVar6 = uVar6 + 1;
} while (bVar8);
}
*(int1 *)((long)pvVar5 + (long)iVar2) = 0;
uVar7 = uVar7 + 1;
} while (uVar7 != param_2);
}
return pvVar3;
} |
7,322 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| char** func0(char** list1, int num_elements, int* sizes) {
char** result = (char**)malloc(num_elements * sizeof(char*));
for (int i = 0; i < num_elements; i++) {
int len = strlen(list1[i]);
sizes[i] = len;
result[i] = (char*)malloc((len + 1) * sizeof(char));
for (int j = 0; j < len; j++) {
result[i][j] = list1[i][j];
}
result[i][len] = '\0';
}
return result;
}
| int main() {
int sizes1[5], sizes2[1], sizes3[6];
char* list1[] = {"Red", "Blue", "Black", "White", "Pink"};
char** result1 = func0(list1, 5, sizes1);
assert(sizes1[0] == 3 && sizes1[1] == 4);
assert(strcmp(result1[0], "Red") == 0 && strcmp(result1[1], "Blue") == 0);
char* list2[] = {"python"};
char** result2 = func0(list2, 1, sizes2);
assert(sizes2[0] == 6);
assert(strcmp(result2[0], "python") == 0);
char* list3[] = {" red ", "green", " black", "blue ", " orange", "brown"};
char** result3 = func0(list3, 6, sizes3);
assert(sizes3[0] == 5 && sizes3[1] == 5);
assert(strcmp(result3[0], " red ") == 0 && strcmp(result3[1], "green") == 0);
// Free allocated memory
for (int i = 0; i < 5; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 1; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 6; i++) free(result3[i]);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
push %r12
push %rbp
mov %rdi,%rbp
shl $0x3,%rdi
push %rbx
mov %rdx,%rbx
sub $0x18,%rsp
callq 10d0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebp,%ebp
jle 1586 <func0+0xa6>
mov %rax,%r15
lea -0x1(%rbp),%eax
lea 0x8(%r14,%rax,8),%rbp
nopl 0x0(%rax,%rax,1)
mov (%r14),%r13
mov %r13,%rdi
callq 10a0 <strlen@plt>
mov %eax,(%rbx)
lea 0x1(%rax),%edi
mov %rax,%r12
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,(%r15)
test %r12d,%r12d
jle 156e <func0+0x8e>
lea -0x1(%r12),%edi
xor %edx,%edx
jmp 1559 <func0+0x79>
nopl 0x0(%rax)
mov (%r14),%r13
mov (%r15),%rax
mov %rcx,%rdx
movzbl 0x0(%r13,%rdx,1),%ecx
mov %cl,(%rax,%rdx,1)
lea 0x1(%rdx),%rcx
cmp %rdi,%rdx
jne 1550 <func0+0x70>
mov (%r15),%rax
movslq %r12d,%rsi
add $0x8,%r14
add $0x4,%rbx
add $0x8,%r15
movb $0x0,(%rax,%rsi,1)
cmp %rbp,%r14
jne 1520 <func0+0x40>
mov 0x8(%rsp),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
movsxd rax, esi
push r14
mov r14, rax
push r13
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
lea rdi, ds:0[rax*8]
sub rsp, 18h
mov [rsp+48h+var_40], rax
call _malloc
mov r12, rax
test r14d, r14d
jle short loc_1577
xor r13d, r13d
nop dword ptr [rax+rax+00h]
loc_1520:
mov r14, [rbx+r13*8]
mov rdi, r14
call _strlen
mov [rbp+r13*4+0], eax
lea edi, [rax+1]
mov r15, rax
movsxd rdi, edi
call _malloc
mov [r12+r13*8], rax
test r15d, r15d
jle short loc_1564
lea esi, [r15-1]
xor edx, edx
xchg ax, ax
loc_1550:
movzx ecx, byte ptr [r14+rdx]
mov [rax+rdx], cl
mov rcx, rdx
add rdx, 1
cmp rcx, rsi
jnz short loc_1550
loc_1564:
movsxd r15, r15d
add r13, 1
mov byte ptr [rax+r15], 0
cmp [rsp+48h+var_40], r13
jnz short loc_1520
loc_1577:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2, long long a3)
{
long long v4; // r12
long long i; // r13
long long v6; // r14
int v7; // eax
int v8; // r15d
long long v9; // rax
long long v10; // rdx
long long v11; // rcx
v4 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
v6 = *(_QWORD *)(a1 + 8 * i);
v7 = strlen(v6);
*(_DWORD *)(a3 + 4 * i) = v7;
v8 = v7;
v9 = malloc(v7 + 1);
*(_QWORD *)(v4 + 8 * i) = v9;
if ( v8 > 0 )
{
v10 = 0LL;
do
{
*(_BYTE *)(v9 + v10) = *(_BYTE *)(v6 + v10);
v11 = v10++;
}
while ( v11 != v8 - 1 );
}
*(_BYTE *)(v9 + v8) = 0;
}
}
return v4;
} | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
PUSH R14
MOV R14,RAX
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
LEA RDI,[RAX*0x8]
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001010f0
MOV R12,RAX
TEST R14D,R14D
JLE 0x00101577
XOR R13D,R13D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101520:
MOV R14,qword ptr [RBX + R13*0x8]
MOV RDI,R14
CALL 0x001010b0
MOV dword ptr [RBP + R13*0x4],EAX
LEA EDI,[RAX + 0x1]
MOV R15,RAX
MOVSXD RDI,EDI
CALL 0x001010f0
MOV qword ptr [R12 + R13*0x8],RAX
TEST R15D,R15D
JLE 0x00101564
LEA ESI,[R15 + -0x1]
XOR EDX,EDX
NOP
LAB_00101550:
MOVZX ECX,byte ptr [R14 + RDX*0x1]
MOV byte ptr [RAX + RDX*0x1],CL
MOV RCX,RDX
ADD RDX,0x1
CMP RCX,RSI
JNZ 0x00101550
LAB_00101564:
MOVSXD R15,R15D
ADD R13,0x1
MOV byte ptr [RAX + R15*0x1],0x0
CMP qword ptr [RSP + 0x8],R13
JNZ 0x00101520
LAB_00101577:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(long param_1,int param_2,long param_3)
{
char *__s;
int iVar1;
void *pvVar2;
size_t sVar3;
void *pvVar4;
ulong uVar5;
long lVar6;
bool bVar7;
pvVar2 = malloc((long)param_2 * 8);
if (0 < param_2) {
lVar6 = 0;
do {
__s = *(char **)(param_1 + lVar6 * 8);
sVar3 = strlen(__s);
iVar1 = (int)sVar3;
*(int *)(param_3 + lVar6 * 4) = iVar1;
pvVar4 = malloc((long)(iVar1 + 1));
*(void **)((long)pvVar2 + lVar6 * 8) = pvVar4;
if (0 < iVar1) {
uVar5 = 0;
do {
*(char *)((long)pvVar4 + uVar5) = __s[uVar5];
bVar7 = uVar5 != iVar1 - 1;
uVar5 = uVar5 + 1;
} while (bVar7);
}
lVar6 = lVar6 + 1;
*(int1 *)((long)pvVar4 + (long)iVar1) = 0;
} while (param_2 != lVar6);
}
return pvVar2;
} |
7,323 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| char** func0(char** list1, int num_elements, int* sizes) {
char** result = (char**)malloc(num_elements * sizeof(char*));
for (int i = 0; i < num_elements; i++) {
int len = strlen(list1[i]);
sizes[i] = len;
result[i] = (char*)malloc((len + 1) * sizeof(char));
for (int j = 0; j < len; j++) {
result[i][j] = list1[i][j];
}
result[i][len] = '\0';
}
return result;
}
| int main() {
int sizes1[5], sizes2[1], sizes3[6];
char* list1[] = {"Red", "Blue", "Black", "White", "Pink"};
char** result1 = func0(list1, 5, sizes1);
assert(sizes1[0] == 3 && sizes1[1] == 4);
assert(strcmp(result1[0], "Red") == 0 && strcmp(result1[1], "Blue") == 0);
char* list2[] = {"python"};
char** result2 = func0(list2, 1, sizes2);
assert(sizes2[0] == 6);
assert(strcmp(result2[0], "python") == 0);
char* list3[] = {" red ", "green", " black", "blue ", " orange", "brown"};
char** result3 = func0(list3, 6, sizes3);
assert(sizes3[0] == 5 && sizes3[1] == 5);
assert(strcmp(result3[0], " red ") == 0 && strcmp(result3[1], "green") == 0);
// Free allocated memory
for (int i = 0; i < 5; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 1; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 6; i++) free(result3[i]);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
movslq %esi,%rdi
push %r12
push %rbp
mov %rdi,%rbp
shl $0x3,%rdi
push %rbx
mov %rdx,%rbx
sub $0x18,%rsp
callq 10d0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebp,%ebp
jle 15bb <func0+0xbb>
mov %rax,%r14
lea -0x1(%rbp),%eax
lea 0x8(%r13,%rax,8),%rbp
mov 0x0(%r13),%r12
mov %r12,%rdi
callq 10a0 <strlen@plt>
mov %eax,(%rbx)
lea 0x1(%rax),%edi
mov %rax,%r15
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,(%r14)
mov %rax,%rdx
test %r15d,%r15d
jle 15a2 <func0+0xa2>
movzbl (%r12),%edx
mov %dl,(%rax)
cmp $0x1,%r15d
je 159f <func0+0x9f>
lea -0x2(%r15),%esi
mov $0x1,%eax
add $0x2,%rsi
nopl 0x0(%rax)
mov 0x0(%r13),%rdx
movzbl (%rdx,%rax,1),%ecx
mov (%r14),%rdx
mov %cl,(%rdx,%rax,1)
add $0x1,%rax
cmp %rax,%rsi
jne 1588 <func0+0x88>
mov (%r14),%rdx
movslq %r15d,%r15
add $0x8,%r13
add $0x4,%rbx
add $0x8,%r14
movb $0x0,(%rdx,%r15,1)
cmp %r13,%rbp
jne 1540 <func0+0x40>
mov 0x8(%rsp),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
movsxd rax, esi
push r14
mov r14, rax
push r13
push r12
mov r12, rdx
push rbp
mov rbp, rdi
lea rdi, ds:0[rax*8]; size
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rax
call _malloc
mov rbx, rax
test r14d, r14d
jle short loc_15C7
xor r13d, r13d
nop dword ptr [rax+rax+00h]
loc_1550:
mov r15, [rbp+r13*8+0]
mov rdi, r15; s
call _strlen
mov [r12+r13*4], eax
lea edi, [rax+1]
mov r14, rax
movsxd rdi, edi; size
call _malloc
mov [rbx+r13*8], rax
mov rdx, rax
test r14d, r14d
jle short loc_15B4
lea edi, [r14-1]
mov r8d, r14d
cmp edi, 6
jbe short loc_1594
lea rcx, [r15+1]
sub rax, rcx
cmp rax, 0Eh
ja short loc_15E0
loc_1594:
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_15A0:
movzx ecx, byte ptr [r15+rax]
mov [rdx+rax], cl
mov rcx, rax
add rax, 1
cmp rcx, rdi
jnz short loc_15A0
loc_15B4:
movsxd r14, r14d
add r13, 1
mov byte ptr [rdx+r14], 0
cmp [rsp+48h+var_40], r13
jnz short loc_1550
loc_15C7:
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15E0:
cmp edi, 0Eh
jbe loc_16E1
mov ecx, r14d
xor eax, eax
shr ecx, 4
shl rcx, 4
nop dword ptr [rax]
loc_15F8:
movdqu xmm0, xmmword ptr [r15+rax]
movups xmmword ptr [rdx+rax], xmm0
add rax, 10h
cmp rax, rcx
jnz short loc_15F8
mov ecx, r14d
and ecx, 0FFFFFFF0h
mov eax, ecx
test r14b, 0Fh
jz short loc_15B4
mov r8d, r14d
sub r8d, ecx
lea edi, [r8-1]
cmp edi, 6
jbe short loc_1642
loc_1628:
mov rdi, [r15+rcx]
mov [rdx+rcx], rdi
mov ecx, r8d
and ecx, 0FFFFFFF8h
add eax, ecx
and r8d, 7
jz loc_15B4
loc_1642:
movsxd rcx, eax
movzx edi, byte ptr [r15+rcx]
mov [rdx+rcx], dil
lea ecx, [rax+1]
cmp r14d, ecx
jle loc_15B4
movsxd rcx, ecx
movzx edi, byte ptr [r15+rcx]
mov [rdx+rcx], dil
lea ecx, [rax+2]
cmp r14d, ecx
jle loc_15B4
movsxd rcx, ecx
movzx edi, byte ptr [r15+rcx]
mov [rdx+rcx], dil
lea ecx, [rax+3]
cmp r14d, ecx
jle loc_15B4
movsxd rcx, ecx
movzx edi, byte ptr [r15+rcx]
mov [rdx+rcx], dil
lea ecx, [rax+4]
cmp r14d, ecx
jle loc_15B4
movsxd rcx, ecx
movzx edi, byte ptr [r15+rcx]
mov [rdx+rcx], dil
lea ecx, [rax+5]
cmp r14d, ecx
jle loc_15B4
movsxd rcx, ecx
add eax, 6
movzx edi, byte ptr [r15+rcx]
mov [rdx+rcx], dil
cmp r14d, eax
jle loc_15B4
cdqe
movzx ecx, byte ptr [r15+rax]
mov [rdx+rax], cl
jmp loc_15B4
loc_16E1:
xor ecx, ecx
xor eax, eax
jmp loc_1628 | _QWORD * func0(long long a1, int a2, long long a3)
{
_QWORD *v5; // rbx
long long i; // r13
const char *v7; // r15
int v8; // eax
int v9; // r14d
_BYTE *v10; // rax
_BYTE *v11; // rdx
long long v12; // rdi
int v13; // r8d
long long v14; // rax
long long v15; // rcx
long long v17; // rax
long long v18; // rcx
signed int v19; // eax
int v20; // ecx
int v21; // eax
v5 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; a2 != i; ++i )
{
v7 = *(const char **)(a1 + 8 * i);
v8 = strlen(v7);
*(_DWORD *)(a3 + 4 * i) = v8;
v9 = v8;
v10 = malloc(v8 + 1);
v5[i] = v10;
v11 = v10;
if ( v9 > 0 )
{
v12 = (unsigned int)(v9 - 1);
v13 = v9;
if ( (unsigned int)v12 > 6 && (unsigned long long)(v10 - (v7 + 1)) > 0xE )
{
if ( (unsigned int)v12 <= 0xE )
{
v18 = 0LL;
v19 = 0;
}
else
{
v17 = 0LL;
do
{
*(__m128i *)&v11[v17] = _mm_loadu_si128((const __m128i *)&v7[v17]);
v17 += 16LL;
}
while ( v17 != 16LL * ((unsigned int)v9 >> 4) );
v18 = v9 & 0xFFFFFFF0;
v19 = v9 & 0xFFFFFFF0;
if ( (v9 & 0xF) == 0 )
goto LABEL_8;
v13 = v9 - v18;
if ( (unsigned int)(v9 - v18 - 1) <= 6 )
goto LABEL_16;
}
*(_QWORD *)&v11[v18] = *(_QWORD *)&v7[v18];
v19 += v13 & 0xFFFFFFF8;
if ( (v13 & 7) != 0 )
{
LABEL_16:
v11[v19] = v7[v19];
if ( v9 > v19 + 1 )
{
v11[v19 + 1] = v7[v19 + 1];
if ( v9 > v19 + 2 )
{
v11[v19 + 2] = v7[v19 + 2];
if ( v9 > v19 + 3 )
{
v11[v19 + 3] = v7[v19 + 3];
if ( v9 > v19 + 4 )
{
v11[v19 + 4] = v7[v19 + 4];
v20 = v19 + 5;
if ( v9 > v19 + 5 )
{
v21 = v19 + 6;
v11[v20] = v7[v20];
if ( v9 > v21 )
v11[v21] = v7[v21];
}
}
}
}
}
}
}
else
{
v14 = 0LL;
do
{
v11[v14] = v7[v14];
v15 = v14++;
}
while ( v15 != v12 );
}
}
LABEL_8:
v11[v9] = 0;
}
}
return v5;
} | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
PUSH R14
MOV R14,RAX
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
LEA RDI,[RAX*0x8]
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001010f0
MOV RBX,RAX
TEST R14D,R14D
JLE 0x001015c7
XOR R13D,R13D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101550:
MOV R15,qword ptr [RBP + R13*0x8]
MOV RDI,R15
CALL 0x001010b0
MOV dword ptr [R12 + R13*0x4],EAX
LEA EDI,[RAX + 0x1]
MOV R14,RAX
MOVSXD RDI,EDI
CALL 0x001010f0
MOV qword ptr [RBX + R13*0x8],RAX
MOV RDX,RAX
TEST R14D,R14D
JLE 0x001015b4
LEA EDI,[R14 + -0x1]
MOV R8D,R14D
CMP EDI,0x6
JBE 0x00101594
LEA RCX,[R15 + 0x1]
SUB RAX,RCX
CMP RAX,0xe
JA 0x001015e0
LAB_00101594:
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001015a0:
MOVZX ECX,byte ptr [R15 + RAX*0x1]
MOV byte ptr [RDX + RAX*0x1],CL
MOV RCX,RAX
ADD RAX,0x1
CMP RCX,RDI
JNZ 0x001015a0
LAB_001015b4:
MOVSXD R14,R14D
ADD R13,0x1
MOV byte ptr [RDX + R14*0x1],0x0
CMP qword ptr [RSP + 0x8],R13
JNZ 0x00101550
LAB_001015c7:
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015e0:
CMP EDI,0xe
JBE 0x001016e1
MOV ECX,R14D
XOR EAX,EAX
SHR ECX,0x4
SHL RCX,0x4
NOP dword ptr [RAX]
LAB_001015f8:
MOVDQU XMM0,xmmword ptr [R15 + RAX*0x1]
MOVUPS xmmword ptr [RDX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x001015f8
MOV ECX,R14D
AND ECX,0xfffffff0
MOV EAX,ECX
TEST R14B,0xf
JZ 0x001015b4
MOV R8D,R14D
SUB R8D,ECX
LEA EDI,[R8 + -0x1]
CMP EDI,0x6
JBE 0x00101642
LAB_00101628:
MOV RDI,qword ptr [R15 + RCX*0x1]
MOV qword ptr [RDX + RCX*0x1],RDI
MOV ECX,R8D
AND ECX,0xfffffff8
ADD EAX,ECX
AND R8D,0x7
JZ 0x001015b4
LAB_00101642:
MOVSXD RCX,EAX
MOVZX EDI,byte ptr [R15 + RCX*0x1]
MOV byte ptr [RDX + RCX*0x1],DIL
LEA ECX,[RAX + 0x1]
CMP R14D,ECX
JLE 0x001015b4
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [R15 + RCX*0x1]
MOV byte ptr [RDX + RCX*0x1],DIL
LEA ECX,[RAX + 0x2]
CMP R14D,ECX
JLE 0x001015b4
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [R15 + RCX*0x1]
MOV byte ptr [RDX + RCX*0x1],DIL
LEA ECX,[RAX + 0x3]
CMP R14D,ECX
JLE 0x001015b4
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [R15 + RCX*0x1]
MOV byte ptr [RDX + RCX*0x1],DIL
LEA ECX,[RAX + 0x4]
CMP R14D,ECX
JLE 0x001015b4
MOVSXD RCX,ECX
MOVZX EDI,byte ptr [R15 + RCX*0x1]
MOV byte ptr [RDX + RCX*0x1],DIL
LEA ECX,[RAX + 0x5]
CMP R14D,ECX
JLE 0x001015b4
MOVSXD RCX,ECX
ADD EAX,0x6
MOVZX EDI,byte ptr [R15 + RCX*0x1]
MOV byte ptr [RDX + RCX*0x1],DIL
CMP R14D,EAX
JLE 0x001015b4
CDQE
MOVZX ECX,byte ptr [R15 + RAX*0x1]
MOV byte ptr [RDX + RAX*0x1],CL
JMP 0x001015b4
LAB_001016e1:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x00101628 | void * func0(long param_1,int param_2,long param_3)
{
char *__s;
int8 uVar1;
uint uVar2;
int iVar3;
void *pvVar4;
size_t sVar5;
void *pvVar6;
ulong uVar7;
long lVar8;
uint uVar9;
int iVar10;
uint uVar11;
long lVar12;
bool bVar13;
pvVar4 = malloc((long)param_2 * 8);
if (0 < param_2) {
lVar12 = 0;
do {
__s = *(char **)(param_1 + lVar12 * 8);
sVar5 = strlen(__s);
uVar2 = (uint)sVar5;
*(uint *)(param_3 + lVar12 * 4) = uVar2;
pvVar6 = malloc((long)(int)(uVar2 + 1));
*(void **)((long)pvVar4 + lVar12 * 8) = pvVar6;
if (0 < (int)uVar2) {
uVar11 = uVar2 - 1;
if ((uVar11 < 7) || ((ulong)((long)pvVar6 - (long)(__s + 1)) < 0xf)) {
uVar7 = 0;
do {
*(char *)((long)pvVar6 + uVar7) = __s[uVar7];
bVar13 = uVar7 != uVar11;
uVar7 = uVar7 + 1;
} while (bVar13);
}
else if (uVar11 < 0xf) {
uVar7 = 0;
uVar9 = 0;
uVar11 = uVar2;
LAB_00101628:
*(int8 *)((long)pvVar6 + uVar7) = *(int8 *)(__s + uVar7);
uVar9 = uVar9 + (uVar11 & 0xfffffff8);
if ((uVar11 & 7) != 0) {
LAB_00101642:
*(char *)((long)pvVar6 + (long)(int)uVar9) = __s[(int)uVar9];
iVar10 = uVar9 + 1;
if (iVar10 < (int)uVar2) {
*(char *)((long)pvVar6 + (long)iVar10) = __s[iVar10];
iVar10 = uVar9 + 2;
if (iVar10 < (int)uVar2) {
*(char *)((long)pvVar6 + (long)iVar10) = __s[iVar10];
iVar10 = uVar9 + 3;
if (iVar10 < (int)uVar2) {
*(char *)((long)pvVar6 + (long)iVar10) = __s[iVar10];
iVar10 = uVar9 + 4;
if (iVar10 < (int)uVar2) {
*(char *)((long)pvVar6 + (long)iVar10) = __s[iVar10];
iVar10 = uVar9 + 5;
if (iVar10 < (int)uVar2) {
iVar3 = uVar9 + 6;
*(char *)((long)pvVar6 + (long)iVar10) = __s[iVar10];
if (iVar3 < (int)uVar2) {
*(char *)((long)pvVar6 + (long)iVar3) = __s[iVar3];
}
}
}
}
}
}
}
}
else {
lVar8 = 0;
do {
uVar1 = *(int8 *)(__s + lVar8 + 8);
*(int8 *)((long)pvVar6 + lVar8) = *(int8 *)(__s + lVar8);
((int8 *)((long)pvVar6 + lVar8))[1] = uVar1;
lVar8 = lVar8 + 0x10;
} while (lVar8 != (sVar5 >> 4 & 0xfffffff) << 4);
uVar9 = uVar2 & 0xfffffff0;
uVar7 = (ulong)uVar9;
if ((sVar5 & 0xf) != 0) {
uVar11 = uVar2 - uVar9;
if (6 < (uVar2 - uVar9) - 1) goto LAB_00101628;
goto LAB_00101642;
}
}
}
lVar12 = lVar12 + 1;
*(int *)((long)pvVar6 + (long)(int)uVar2) = 0;
} while (param_2 != lVar12);
}
return pvVar4;
} |
7,324 | func0 |
#include <assert.h>
| int func0(int input_list[], int size) {
return size * size;
}
| int main() {
int test1[] = {0, 1, 3, 5, 7, 9, 11, 13, 15, 17};
int test2[] = {1, 3, 5, 7, 9, 11, 13, 15, 17};
int test3[] = {2, 4, 6, 8, 4, 5, 8, 10, 12, 14};
assert(func0(test1, 5) == 25);
assert(func0(test2, 4) == 16);
assert(func0(test3, 3) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
imul %eax,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
imul eax, eax
pop rbp
retn | long long func0(long long a1, int a2)
{
return (unsigned int)(a2 * a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
POP RBP
RET | int func0(int8 param_1,int param_2)
{
return param_2 * param_2;
} |
7,325 | func0 |
#include <assert.h>
| int func0(int input_list[], int size) {
return size * size;
}
| int main() {
int test1[] = {0, 1, 3, 5, 7, 9, 11, 13, 15, 17};
int test2[] = {1, 3, 5, 7, 9, 11, 13, 15, 17};
int test3[] = {2, 4, 6, 8, 4, 5, 8, 10, 12, 14};
assert(func0(test1, 5) == 25);
assert(func0(test2, 4) == 16);
assert(func0(test3, 3) == 9);
return 0;
}
| O1 | c | func0:
endbr64
imul %esi,%esi
mov %esi,%eax
retq
| func0:
endbr64
imul esi, esi
mov eax, esi
retn | long long func0(long long a1, int a2)
{
return (unsigned int)(a2 * a2);
} | func0:
ENDBR64
IMUL ESI,ESI
MOV EAX,ESI
RET | int func0(int8 param_1,int param_2)
{
return param_2 * param_2;
} |
7,326 | func0 |
#include <assert.h>
| int func0(int input_list[], int size) {
return size * size;
}
| int main() {
int test1[] = {0, 1, 3, 5, 7, 9, 11, 13, 15, 17};
int test2[] = {1, 3, 5, 7, 9, 11, 13, 15, 17};
int test3[] = {2, 4, 6, 8, 4, 5, 8, 10, 12, 14};
assert(func0(test1, 5) == 25);
assert(func0(test2, 4) == 16);
assert(func0(test3, 3) == 9);
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%eax
imul %esi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
imul eax, esi
retn | long long func0(long long a1, int a2)
{
return (unsigned int)(a2 * a2);
} | func0:
ENDBR64
MOV EAX,ESI
IMUL EAX,ESI
RET | int func0(int8 param_1,int param_2)
{
return param_2 * param_2;
} |
7,327 | func0 |
#include <assert.h>
| int func0(int input_list[], int size) {
return size * size;
}
| int main() {
int test1[] = {0, 1, 3, 5, 7, 9, 11, 13, 15, 17};
int test2[] = {1, 3, 5, 7, 9, 11, 13, 15, 17};
int test3[] = {2, 4, 6, 8, 4, 5, 8, 10, 12, 14};
assert(func0(test1, 5) == 25);
assert(func0(test2, 4) == 16);
assert(func0(test3, 3) == 9);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%eax
imul %esi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
imul esi, esi
mov eax, esi
retn | long long func0(long long a1, int a2)
{
return (unsigned int)(a2 * a2);
} | func0:
ENDBR64
IMUL ESI,ESI
MOV EAX,ESI
RET | int func0(int8 param_1,int param_2)
{
return param_2 * param_2;
} |
7,328 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int my_list[], int list_size, int ***output, int *output_size, int **output_element_sizes) {
int total_sublists = 1 << list_size;
int **subs = malloc(total_sublists * sizeof(int *));
int *sizes = malloc(total_sublists * sizeof(int));
int count = 0;
for (int mask = 0; mask < total_sublists; mask++) {
sizes[count] = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
sizes[count]++;
}
}
subs[count] = malloc(sizes[count] * sizeof(int));
int pos = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
subs[count][pos] = my_list[i];
pos++;
}
}
count++;
}
*output = subs;
*output_size = total_sublists;
*output_element_sizes = sizes;
}
| int main() {
int list1[] = {10, 20, 30, 40};
int list_size1 = 4;
int **output1;
int output_size1;
int *output_element_sizes1;
func0(list1, list_size1, &output1, &output_size1, &output_element_sizes1);
assert(output_size1 == 16); // replace specific list comparison for simplicity
char *list2[] = {'X', 'Y', 'Z'};
int list_size2 = 3;
int **output2;
int output_size2;
int *output_element_sizes2;
func0((int*)list2, list_size2, &output2, &output_size2, &output_element_sizes2);
assert(output_size2 == 8);
int list3[] = {1, 2, 3};
int list_size3 = 3;
int **output3;
int output_size3;
int *output_element_sizes3;
func0(list3, list_size3, &output3, &output_size3, &output_element_sizes3);
assert(output_size3 == 8);
// Free memory
for (int i = 0; i < output_size1; i++) {
free(output1[i]);
}
free(output1);
free(output_element_sizes1);
for (int i = 0; i < output_size2; i++) {
free(output2[i]);
}
free(output2);
free(output_element_sizes2);
for (int i = 0; i < output_size3; i++) {
free(output3[i]);
}
free(output3);
free(output_element_sizes3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %rdx,-0x58(%rbp)
mov %rcx,-0x60(%rbp)
mov %r8,-0x68(%rbp)
mov -0x4c(%rbp),%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
jmpq 1329 <func0+0x180>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movl $0x0,(%rax)
movl $0x0,-0x30(%rbp)
jmp 126c <func0+0xc3>
mov -0x30(%rbp),%eax
mov -0x34(%rbp),%edx
mov %eax,%ecx
sar %cl,%edx
mov %edx,%eax
and $0x1,%eax
test %eax,%eax
je 1268 <func0+0xbf>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 123a <func0+0x91>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x20(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,-0x2c(%rbp)
movl $0x0,-0x28(%rbp)
jmp 1319 <func0+0x170>
mov -0x28(%rbp),%eax
mov -0x34(%rbp),%edx
mov %eax,%ecx
sar %cl,%edx
mov %edx,%eax
and $0x1,%eax
test %eax,%eax
je 1315 <func0+0x16c>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x2c(%rbp)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 12c1 <func0+0x118>
addl $0x1,-0x38(%rbp)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1217 <func0+0x6e>
mov -0x58(%rbp),%rax
mov -0x20(%rbp),%rdx
mov %rdx,(%rax)
mov -0x60(%rbp),%rax
mov -0x24(%rbp),%edx
mov %edx,(%rax)
mov -0x68(%rbp),%rax
mov -0x18(%rbp),%rdx
mov %rdx,(%rax)
add $0x68,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_58], rdx
mov [rbp+var_60], rcx
mov [rbp+var_68], r8
mov eax, [rbp+var_4C]
mov edx, 1
mov ecx, eax
shl edx, cl
mov eax, edx
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_38], 0
mov [rbp+var_34], 0
jmp loc_1329
loc_1217:
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov dword ptr [rax], 0
mov [rbp+var_30], 0
jmp short loc_126C
loc_123A:
mov eax, [rbp+var_30]
mov edx, [rbp+var_34]
mov ecx, eax
sar edx, cl
mov eax, edx
and eax, 1
test eax, eax
jz short loc_1268
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
add edx, 1
mov [rax], edx
loc_1268:
add [rbp+var_30], 1
loc_126C:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_4C]
jl short loc_123A
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cdqe
shl rax, 2
mov edx, [rbp+var_38]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_20]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov [rbp+var_2C], 0
mov [rbp+var_28], 0
jmp short loc_1319
loc_12C1:
mov eax, [rbp+var_28]
mov edx, [rbp+var_34]
mov ecx, eax
sar edx, cl
mov eax, edx
and eax, 1
test eax, eax
jz short loc_1315
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rbp+var_38]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_20]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_2C]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_2C], 1
loc_1315:
add [rbp+var_28], 1
loc_1319:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_4C]
jl short loc_12C1
add [rbp+var_38], 1
add [rbp+var_34], 1
loc_1329:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_24]
jl loc_1217
mov rax, [rbp+var_58]
mov rdx, [rbp+var_20]
mov [rax], rdx
mov rax, [rbp+var_60]
mov edx, [rbp+var_24]
mov [rax], edx
mov rax, [rbp+var_68]
mov rdx, [rbp+var_18]
mov [rax], rdx
nop
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2, _QWORD *a3, int *a4, _QWORD *a5)
{
_QWORD *result; // rax
int v9; // [rsp+38h] [rbp-38h]
int i; // [rsp+3Ch] [rbp-34h]
int j; // [rsp+40h] [rbp-30h]
int v12; // [rsp+44h] [rbp-2Ch]
int k; // [rsp+48h] [rbp-28h]
int v14; // [rsp+4Ch] [rbp-24h]
_QWORD *v15; // [rsp+50h] [rbp-20h]
int *v16; // [rsp+58h] [rbp-18h]
v14 = 1 << a2;
v15 = malloc(8LL * (1 << a2));
v16 = (int *)malloc(4LL * (1 << a2));
v9 = 0;
for ( i = 0; i < v14; ++i )
{
v16[v9] = 0;
for ( j = 0; j < a2; ++j )
{
if ( ((i >> j) & 1) != 0 )
++v16[v9];
}
v15[v9] = malloc(4LL * v16[v9]);
v12 = 0;
for ( k = 0; k < a2; ++k )
{
if ( ((i >> k) & 1) != 0 )
*(_DWORD *)(4LL * v12++ + v15[v9]) = *(_DWORD *)(4LL * k + a1);
}
++v9;
}
*a3 = v15;
*a4 = v14;
result = a5;
*a5 = v16;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV qword ptr [RBP + -0x58],RDX
MOV qword ptr [RBP + -0x60],RCX
MOV qword ptr [RBP + -0x68],R8
MOV EAX,dword ptr [RBP + -0x4c]
MOV EDX,0x1
MOV ECX,EAX
SHL EDX,CL
MOV EAX,EDX
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x34],0x0
JMP 0x00101329
LAB_00101217:
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x30],0x0
JMP 0x0010126c
LAB_0010123a:
MOV EAX,dword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x34]
MOV ECX,EAX
SAR EDX,CL
MOV EAX,EDX
AND EAX,0x1
TEST EAX,EAX
JZ 0x00101268
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
ADD EDX,0x1
MOV dword ptr [RAX],EDX
LAB_00101268:
ADD dword ptr [RBP + -0x30],0x1
LAB_0010126c:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x0010123a
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x2
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x20]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x2c],0x0
MOV dword ptr [RBP + -0x28],0x0
JMP 0x00101319
LAB_001012c1:
MOV EAX,dword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x34]
MOV ECX,EAX
SAR EDX,CL
MOV EAX,EDX
AND EAX,0x1
TEST EAX,EAX
JZ 0x00101315
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x2c]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101315:
ADD dword ptr [RBP + -0x28],0x1
LAB_00101319:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x001012c1
ADD dword ptr [RBP + -0x38],0x1
ADD dword ptr [RBP + -0x34],0x1
LAB_00101329:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101217
MOV RAX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV EDX,dword ptr [RBP + -0x24]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RDX
NOP
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void func0(long param_1,int param_2,int8 *param_3,int *param_4,int8 *param_5)
{
void *pvVar1;
void *pvVar2;
int *piVar3;
void *pvVar4;
int iVar5;
int4 local_40;
int4 local_3c;
int4 local_38;
int4 local_34;
int4 local_30;
iVar5 = 1 << ((byte)param_2 & 0x1f);
pvVar1 = malloc((long)iVar5 << 3);
pvVar2 = malloc((long)iVar5 << 2);
local_40 = 0;
for (local_3c = 0; local_3c < iVar5; local_3c = local_3c + 1) {
*(int4 *)((long)pvVar2 + (long)local_40 * 4) = 0;
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
if ((local_3c >> ((byte)local_38 & 0x1f) & 1U) != 0) {
piVar3 = (int *)((long)pvVar2 + (long)local_40 * 4);
*piVar3 = *piVar3 + 1;
}
}
pvVar4 = malloc((long)*(int *)((long)pvVar2 + (long)local_40 * 4) << 2);
*(void **)((long)local_40 * 8 + (long)pvVar1) = pvVar4;
local_34 = 0;
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
if ((local_3c >> ((byte)local_30 & 0x1f) & 1U) != 0) {
*(int4 *)(*(long *)((long)pvVar1 + (long)local_40 * 8) + (long)local_34 * 4) =
*(int4 *)(param_1 + (long)local_30 * 4);
local_34 = local_34 + 1;
}
}
local_40 = local_40 + 1;
}
*param_3 = pvVar1;
*param_4 = iVar5;
*param_5 = pvVar2;
return;
} |
7,329 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int my_list[], int list_size, int ***output, int *output_size, int **output_element_sizes) {
int total_sublists = 1 << list_size;
int **subs = malloc(total_sublists * sizeof(int *));
int *sizes = malloc(total_sublists * sizeof(int));
int count = 0;
for (int mask = 0; mask < total_sublists; mask++) {
sizes[count] = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
sizes[count]++;
}
}
subs[count] = malloc(sizes[count] * sizeof(int));
int pos = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
subs[count][pos] = my_list[i];
pos++;
}
}
count++;
}
*output = subs;
*output_size = total_sublists;
*output_element_sizes = sizes;
}
| int main() {
int list1[] = {10, 20, 30, 40};
int list_size1 = 4;
int **output1;
int output_size1;
int *output_element_sizes1;
func0(list1, list_size1, &output1, &output_size1, &output_element_sizes1);
assert(output_size1 == 16); // replace specific list comparison for simplicity
char *list2[] = {'X', 'Y', 'Z'};
int list_size2 = 3;
int **output2;
int output_size2;
int *output_element_sizes2;
func0((int*)list2, list_size2, &output2, &output_size2, &output_element_sizes2);
assert(output_size2 == 8);
int list3[] = {1, 2, 3};
int list_size3 = 3;
int **output3;
int output_size3;
int *output_element_sizes3;
func0(list3, list_size3, &output3, &output_size3, &output_element_sizes3);
assert(output_size3 == 8);
// Free memory
for (int i = 0; i < output_size1; i++) {
free(output1[i]);
}
free(output1);
free(output_element_sizes1);
for (int i = 0; i < output_size2; i++) {
free(output2[i]);
}
free(output2);
free(output_element_sizes2);
for (int i = 0; i < output_size3; i++) {
free(output3[i]);
}
free(output3);
free(output_element_sizes3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %rdx,0x18(%rsp)
mov %rcx,0x20(%rsp)
mov %r8,0x28(%rsp)
mov $0x1,%eax
mov %esi,%ecx
shl %cl,%eax
mov %eax,%ebp
mov %eax,0x4(%rsp)
movslq %eax,%rbx
lea 0x0(,%rbx,8),%rdi
callq 10b0 <malloc@plt>
mov %rax,%r15
mov %rax,0x8(%rsp)
lea 0x0(,%rbx,4),%rdi
callq 10b0 <malloc@plt>
mov %rax,0x10(%rsp)
test %ebp,%ebp
jle 1252 <func0+0xa9>
mov %rax,%r14
mov $0x0,%ebp
jmpq 12c4 <func0+0x11b>
lea 0x1(%rbx),%eax
cmp %eax,%r12d
je 1286 <func0+0xdd>
mov %eax,%ebx
bt %ebx,%ebp
jae 121a <func0+0x71>
addl $0x1,(%rdx)
jmp 121a <func0+0x71>
lea 0x1(%rax),%rdx
cmp %rbx,%rax
je 12b3 <func0+0x10a>
mov %rdx,%rax
bt %eax,%ebp
jae 122e <func0+0x85>
mov 0x0(%r13,%rax,4),%edi
movslq %ecx,%rsi
mov (%r8),%rdx
mov %edi,(%rdx,%rsi,4)
add $0x1,%ecx
jmp 122e <func0+0x85>
mov 0x18(%rsp),%rax
mov 0x8(%rsp),%rsi
mov %rsi,(%rax)
mov 0x20(%rsp),%rax
mov 0x4(%rsp),%esi
mov %esi,(%rax)
mov 0x28(%rsp),%rax
mov 0x10(%rsp),%rsi
mov %rsi,(%rax)
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movslq (%rdx),%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %r15,%r8
mov %rax,(%r15)
mov %ebx,%ebx
mov $0x0,%eax
mov $0x0,%ecx
jmp 123a <func0+0x91>
mov $0x0,%edi
callq 10b0 <malloc@plt>
mov %rax,(%r15)
add $0x1,%ebp
add $0x4,%r14
add $0x8,%r15
cmp %ebp,0x4(%rsp)
je 1252 <func0+0xa9>
mov %r14,%rdx
movl $0x0,(%r14)
test %r12d,%r12d
jle 12a6 <func0+0xfd>
mov $0x0,%ebx
jmpq 1224 <func0+0x7b>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r13, rdi
mov r12d, esi
mov [rsp+68h+var_50], rdx
mov [rsp+68h+var_48], rcx
mov [rsp+68h+var_40], r8
mov eax, 1
mov ecx, esi
shl eax, cl
mov ebp, eax
mov [rsp+68h+var_64], eax
movsxd rbx, eax
lea rdi, ds:0[rbx*8]
call _malloc
mov r15, rax
mov [rsp+68h+var_60], rax
lea rdi, ds:0[rbx*4]
call _malloc
mov [rsp+68h+var_58], rax
test ebp, ebp
jle short loc_1252
mov r14, rax
mov ebp, 0
jmp loc_12C4
loc_121A:
lea eax, [rbx+1]
cmp r12d, eax
jz short loc_1286
mov ebx, eax
loc_1224:
bt ebp, ebx
jnb short loc_121A
add dword ptr [rdx], 1
jmp short loc_121A
loc_122E:
lea rdx, [rax+1]
cmp rax, rbx
jz short loc_12B3
mov rax, rdx
loc_123A:
bt ebp, eax
jnb short loc_122E
mov edi, [r13+rax*4+0]
movsxd rsi, ecx
mov rdx, [r8]
mov [rdx+rsi*4], edi
add ecx, 1
jmp short loc_122E
loc_1252:
mov rax, [rsp+68h+var_50]
mov rsi, [rsp+68h+var_60]
mov [rax], rsi
mov rax, [rsp+68h+var_48]
mov esi, [rsp+68h+var_64]
mov [rax], esi
mov rax, [rsp+68h+var_40]
mov rsi, [rsp+68h+var_58]
mov [rax], rsi
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1286:
movsxd rdi, dword ptr [rdx]
shl rdi, 2
call _malloc
mov r8, r15
mov [r15], rax
mov ebx, ebx
mov eax, 0
mov ecx, 0
jmp short loc_123A
loc_12A6:
mov edi, 0
call _malloc
mov [r15], rax
loc_12B3:
add ebp, 1
add r14, 4
add r15, 8
cmp [rsp+68h+var_64], ebp
jz short loc_1252
loc_12C4:
mov rdx, r14
mov dword ptr [r14], 0
test r12d, r12d
jle short loc_12A6
mov ebx, 0
jmp loc_1224 | long long * func0(long long a1, int a2, _QWORD *a3, int *a4, long long *a5)
{
long long v5; // rbx
_QWORD *v6; // r15
long long v7; // rax
int *v8; // r14
int v9; // ebp
unsigned int i; // ebx
long long v11; // rax
int v12; // ecx
long long *result; // rax
int v14; // [rsp+4h] [rbp-64h]
_QWORD *v15; // [rsp+8h] [rbp-60h]
long long v16; // [rsp+10h] [rbp-58h]
v14 = 1 << a2;
v5 = 1 << a2;
v6 = (_QWORD *)malloc(8 * v5);
v15 = v6;
v7 = malloc(4 * v5);
v16 = v7;
if ( 1 << a2 > 0 )
{
v8 = (int *)v7;
v9 = 0;
do
{
*v8 = 0;
if ( a2 <= 0 )
{
*v6 = malloc(0LL);
}
else
{
for ( i = 0; ; ++i )
{
if ( _bittest(&v9, i) )
++*v8;
if ( a2 == i + 1 )
break;
}
*v6 = malloc(4LL * *v8);
v11 = 0LL;
v12 = 0;
while ( 1 )
{
if ( _bittest(&v9, v11) )
*(_DWORD *)(*v6 + 4LL * v12++) = *(_DWORD *)(a1 + 4 * v11);
if ( v11 == i )
break;
++v11;
}
}
++v9;
++v8;
++v6;
}
while ( v14 != v9 );
}
*a3 = v15;
*a4 = v14;
result = a5;
*a5 = v16;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R13,RDI
MOV R12D,ESI
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x28],R8
MOV EAX,0x1
MOV ECX,ESI
SHL EAX,CL
MOV EBP,EAX
MOV dword ptr [RSP + 0x4],EAX
MOVSXD RBX,EAX
LEA RDI,[RBX*0x8]
CALL 0x001010b0
MOV R15,RAX
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RBX*0x4]
CALL 0x001010b0
MOV qword ptr [RSP + 0x10],RAX
TEST EBP,EBP
JLE 0x00101252
MOV R14,RAX
MOV EBP,0x0
JMP 0x001012c4
LAB_0010121a:
LEA EAX,[RBX + 0x1]
CMP R12D,EAX
JZ 0x00101286
MOV EBX,EAX
LAB_00101224:
BT EBP,EBX
JNC 0x0010121a
ADD dword ptr [RDX],0x1
JMP 0x0010121a
LAB_0010122e:
LEA RDX,[RAX + 0x1]
CMP RAX,RBX
JZ 0x001012b3
MOV RAX,RDX
LAB_0010123a:
BT EBP,EAX
JNC 0x0010122e
MOV EDI,dword ptr [R13 + RAX*0x4]
MOVSXD RSI,ECX
MOV RDX,qword ptr [R8]
MOV dword ptr [RDX + RSI*0x4],EDI
ADD ECX,0x1
JMP 0x0010122e
LAB_00101252:
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x4]
MOV dword ptr [RAX],ESI
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RAX],RSI
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101286:
MOVSXD RDI,dword ptr [RDX]
SHL RDI,0x2
CALL 0x001010b0
MOV R8,R15
MOV qword ptr [R15],RAX
MOV EBX,EBX
MOV EAX,0x0
MOV ECX,0x0
JMP 0x0010123a
LAB_001012a6:
MOV EDI,0x0
CALL 0x001010b0
MOV qword ptr [R15],RAX
LAB_001012b3:
ADD EBP,0x1
ADD R14,0x4
ADD R15,0x8
CMP dword ptr [RSP + 0x4],EBP
JZ 0x00101252
LAB_001012c4:
MOV RDX,R14
MOV dword ptr [R14],0x0
TEST R12D,R12D
JLE 0x001012a6
MOV EBX,0x0
JMP 0x00101224 | void func0(long param_1,uint param_2,int8 *param_3,uint *param_4,int8 *param_5)
{
uint uVar1;
uint uVar2;
long *plVar3;
int *piVar4;
ulong uVar5;
void *pvVar6;
int iVar7;
uint uVar8;
uint uVar9;
int *piVar10;
long *plVar11;
bool bVar12;
uVar2 = 1 << ((byte)param_2 & 0x1f);
plVar3 = (long *)malloc((long)(int)uVar2 * 8);
piVar4 = (int *)malloc((long)(int)uVar2 * 4);
if (0 < (int)uVar2) {
uVar9 = 0;
piVar10 = piVar4;
plVar11 = plVar3;
do {
*piVar10 = 0;
if ((int)param_2 < 1) {
pvVar6 = malloc(0);
*plVar11 = (long)pvVar6;
}
else {
uVar1 = 0;
do {
uVar8 = uVar1;
if ((uVar9 >> (uVar8 & 0x1f) & 1) != 0) {
*piVar10 = *piVar10 + 1;
}
uVar1 = uVar8 + 1;
} while (param_2 != uVar8 + 1);
pvVar6 = malloc((long)*piVar10 << 2);
*plVar11 = (long)pvVar6;
iVar7 = 0;
uVar5 = 0;
do {
if ((uVar9 >> ((uint)uVar5 & 0x1f) & 1) != 0) {
*(int4 *)(*plVar11 + (long)iVar7 * 4) = *(int4 *)(param_1 + uVar5 * 4);
iVar7 = iVar7 + 1;
}
bVar12 = uVar5 != uVar8;
uVar5 = uVar5 + 1;
} while (bVar12);
}
uVar9 = uVar9 + 1;
piVar10 = piVar10 + 1;
plVar11 = plVar11 + 1;
} while (uVar2 != uVar9);
}
*param_3 = plVar3;
*param_4 = uVar2;
*param_5 = piVar4;
return;
} |
7,330 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int my_list[], int list_size, int ***output, int *output_size, int **output_element_sizes) {
int total_sublists = 1 << list_size;
int **subs = malloc(total_sublists * sizeof(int *));
int *sizes = malloc(total_sublists * sizeof(int));
int count = 0;
for (int mask = 0; mask < total_sublists; mask++) {
sizes[count] = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
sizes[count]++;
}
}
subs[count] = malloc(sizes[count] * sizeof(int));
int pos = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
subs[count][pos] = my_list[i];
pos++;
}
}
count++;
}
*output = subs;
*output_size = total_sublists;
*output_element_sizes = sizes;
}
| int main() {
int list1[] = {10, 20, 30, 40};
int list_size1 = 4;
int **output1;
int output_size1;
int *output_element_sizes1;
func0(list1, list_size1, &output1, &output_size1, &output_element_sizes1);
assert(output_size1 == 16); // replace specific list comparison for simplicity
char *list2[] = {'X', 'Y', 'Z'};
int list_size2 = 3;
int **output2;
int output_size2;
int *output_element_sizes2;
func0((int*)list2, list_size2, &output2, &output_size2, &output_element_sizes2);
assert(output_size2 == 8);
int list3[] = {1, 2, 3};
int list_size3 = 3;
int **output3;
int output_size3;
int *output_element_sizes3;
func0(list3, list_size3, &output3, &output_size3, &output_element_sizes3);
assert(output_size3 == 8);
// Free memory
for (int i = 0; i < output_size1; i++) {
free(output1[i]);
}
free(output1);
free(output_element_sizes1);
for (int i = 0; i < output_size2; i++) {
free(output2[i]);
}
free(output2);
free(output_element_sizes2);
for (int i = 0; i < output_size3; i++) {
free(output3[i]);
}
free(output3);
free(output_element_sizes3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
mov $0x1,%eax
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x38,%rsp
mov %rcx,0x20(%rsp)
mov %esi,%ecx
shl %cl,%eax
mov %rdx,0x18(%rsp)
movslq %eax,%rbp
mov %r8,0x28(%rsp)
lea 0x0(,%rbp,8),%rdi
mov %ebp,0x14(%rsp)
callq 10b0 <malloc@plt>
lea 0x0(,%rbp,4),%rdi
mov %rax,(%rsp)
callq 10b0 <malloc@plt>
mov %rax,%r13
lea -0x1(%rbp),%eax
mov %rax,0x8(%rsp)
test %ebp,%ebp
jle 14f3 <func0+0x123>
xor %r14d,%r14d
mov %r13,%r15
mov %r12d,%r13d
movl $0x0,(%r15,%r14,4)
mov %r14d,%r12d
test %r13d,%r13d
jle 14d5 <func0+0x105>
nopl (%rax)
xor %edi,%edi
xor %ebp,%ebp
jmp 1462 <func0+0x92>
xchg %ax,%ax
mov %eax,%ebp
bt %ebp,%r12d
jae 146f <func0+0x9f>
add $0x1,%edi
mov %edi,(%r15,%r14,4)
lea 0x1(%rbp),%eax
cmp %eax,%r13d
jne 1460 <func0+0x90>
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rsp),%rsi
xor %edx,%edx
xor %r8d,%r8d
mov %rax,(%rsi,%r14,8)
jmp 149b <func0+0xcb>
nopw 0x0(%rax,%rax,1)
mov %rcx,%rdx
bt %edx,%r12d
jae 14ae <func0+0xde>
mov (%rbx,%rdx,4),%esi
movslq %r8d,%rcx
add $0x1,%r8d
mov %esi,(%rax,%rcx,4)
lea 0x1(%rdx),%rcx
cmp %rdx,%rbp
jne 1498 <func0+0xc8>
lea 0x1(%r14),%rax
cmp 0x8(%rsp),%r14
je 14f0 <func0+0x120>
mov %rax,%r14
movl $0x0,(%r15,%r14,4)
mov %r14d,%r12d
test %r13d,%r13d
jg 1458 <func0+0x88>
xor %edi,%edi
callq 10b0 <malloc@plt>
mov (%rsp),%rsi
mov %rax,(%rsi,%r14,8)
lea 0x1(%r14),%rax
cmp 0x8(%rsp),%r14
jne 14c2 <func0+0xf2>
mov %r15,%r13
mov 0x18(%rsp),%rax
mov (%rsp),%rbx
mov %rbx,(%rax)
mov 0x20(%rsp),%rax
mov 0x14(%rsp),%ebx
mov %ebx,(%rax)
mov 0x28(%rsp),%rax
mov %r13,(%rax)
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov eax, 1
push r14
push r13
push r12
mov r12d, esi
push rbp
push rbx
mov rbx, rdi
sub rsp, 38h
mov [rsp+68h+var_48], rcx
mov ecx, esi
shl eax, cl
mov [rsp+68h+var_50], rdx
movsxd r14, eax
mov [rsp+68h+var_40], r8
lea rdi, ds:0[r14*8]
mov [rsp+68h+var_54], r14d
mov [rsp+68h+var_60], r14
call _malloc
lea rdi, ds:0[r14*4]
mov [rsp+68h+var_68], rax
call _malloc
mov r13, rax
test r14d, r14d
jle loc_1488
movsxd r14, r12d
xor ebp, ebp
mov r15, rax
mov r13, r14
mov r14d, r12d
mov r12, rbp
nop dword ptr [rax+rax+00000000h]
loc_1410:
mov dword ptr [r15+r12*4], 0
mov ebp, r12d
test r14d, r14d
jle loc_14C0
xor edi, edi
xor eax, eax
nop dword ptr [rax+rax+00000000h]
loc_1430:
bt ebp, eax
jnb short loc_143C
add edi, 1
mov [r15+r12*4], edi
loc_143C:
add eax, 1
cmp r14d, eax
jnz short loc_1430
movsxd rdi, edi
shl rdi, 2
call _malloc
mov rsi, [rsp+68h+var_68]
xor edx, edx
xor edi, edi
mov [rsi+r12*8], rax
nop dword ptr [rax+00h]
loc_1460:
bt ebp, edx
jnb short loc_1471
mov esi, [rbx+rdx*4]
movsxd rcx, edi
add edi, 1
mov [rax+rcx*4], esi
loc_1471:
add rdx, 1
cmp r13, rdx
jnz short loc_1460
add r12, 1
cmp r12, [rsp+68h+var_60]
jnz short loc_1410
loc_1485:
mov r13, r15
loc_1488:
mov rax, [rsp+68h+var_50]
mov rcx, [rsp+68h+var_68]
mov [rax], rcx
mov rax, [rsp+68h+var_48]
mov ecx, [rsp+68h+var_54]
mov [rax], ecx
mov rax, [rsp+68h+var_40]
mov [rax], r13
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14C0:
xor edi, edi
call _malloc
mov rcx, [rsp+68h+var_68]
mov [rcx+r12*8], rax
add r12, 1
cmp r12, [rsp+68h+var_60]
jnz loc_1410
jmp short loc_1485 | long long * func0(long long a1, int a2, long long *a3, _DWORD *a4, long long *a5)
{
long long v6; // r14
long long v7; // rax
long long v8; // r13
long long v9; // r15
long long i; // r12
int v11; // ebp
int v12; // edi
unsigned int j; // eax
long long v14; // rax
long long v15; // rdx
int v16; // edi
long long v17; // rcx
long long *result; // rax
long long v19; // [rsp+0h] [rbp-68h]
v6 = 1 << a2;
v19 = malloc(8 * v6);
v7 = malloc(4 * v6);
v8 = v7;
if ( (int)v6 > 0 )
{
v9 = v7;
for ( i = 0LL; i != v6; ++i )
{
while ( 1 )
{
*(_DWORD *)(v9 + 4 * i) = 0;
v11 = i;
if ( a2 > 0 )
break;
*(_QWORD *)(v19 + 8 * i++) = malloc(0LL);
if ( i == v6 )
goto LABEL_13;
}
v12 = 0;
for ( j = 0; j != a2; ++j )
{
if ( _bittest(&v11, j) )
*(_DWORD *)(v9 + 4 * i) = ++v12;
}
v14 = malloc(4LL * v12);
v15 = 0LL;
v16 = 0;
*(_QWORD *)(v19 + 8 * i) = v14;
do
{
if ( _bittest(&v11, v15) )
{
v17 = v16++;
*(_DWORD *)(v14 + 4 * v17) = *(_DWORD *)(a1 + 4 * v15);
}
++v15;
}
while ( a2 != v15 );
}
LABEL_13:
v8 = v9;
}
*a3 = v19;
*a4 = 1 << a2;
result = a5;
*a5 = v8;
return result;
} | func0:
ENDBR64
PUSH R15
MOV EAX,0x1
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RCX
MOV ECX,ESI
SHL EAX,CL
MOV qword ptr [RSP + 0x18],RDX
MOVSXD R14,EAX
MOV qword ptr [RSP + 0x28],R8
LEA RDI,[R14*0x8]
MOV dword ptr [RSP + 0x14],R14D
MOV qword ptr [RSP + 0x8],R14
CALL 0x001010b0
LEA RDI,[R14*0x4]
MOV qword ptr [RSP],RAX
CALL 0x001010b0
MOV R13,RAX
TEST R14D,R14D
JLE 0x00101488
MOVSXD R14,R12D
XOR EBP,EBP
MOV R15,RAX
MOV R13,R14
MOV R14D,R12D
MOV R12,RBP
NOP dword ptr [RAX + RAX*0x1]
LAB_00101410:
MOV dword ptr [R15 + R12*0x4],0x0
MOV EBP,R12D
TEST R14D,R14D
JLE 0x001014c0
XOR EDI,EDI
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101430:
BT EBP,EAX
JNC 0x0010143c
ADD EDI,0x1
MOV dword ptr [R15 + R12*0x4],EDI
LAB_0010143c:
ADD EAX,0x1
CMP R14D,EAX
JNZ 0x00101430
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RSI,qword ptr [RSP]
XOR EDX,EDX
XOR EDI,EDI
MOV qword ptr [RSI + R12*0x8],RAX
NOP dword ptr [RAX]
LAB_00101460:
BT EBP,EDX
JNC 0x00101471
MOV ESI,dword ptr [RBX + RDX*0x4]
MOVSXD RCX,EDI
ADD EDI,0x1
MOV dword ptr [RAX + RCX*0x4],ESI
LAB_00101471:
ADD RDX,0x1
CMP R13,RDX
JNZ 0x00101460
ADD R12,0x1
CMP R12,qword ptr [RSP + 0x8]
JNZ 0x00101410
LAB_00101485:
MOV R13,R15
LAB_00101488:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x14]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],R13
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014c0:
XOR EDI,EDI
CALL 0x001010b0
MOV RCX,qword ptr [RSP]
MOV qword ptr [RCX + R12*0x8],RAX
ADD R12,0x1
CMP R12,qword ptr [RSP + 0x8]
JNZ 0x00101410
JMP 0x00101485 | void func0(long param_1,uint param_2,int8 *param_3,int *param_4,int8 *param_5)
{
byte bVar1;
int iVar2;
uint uVar3;
void *pvVar4;
void *pvVar5;
void *pvVar6;
long lVar7;
long lVar8;
int iVar9;
long lVar10;
long lVar11;
bVar1 = (byte)param_2 & 0x1f;
iVar2 = 1 << bVar1;
lVar11 = (long)iVar2;
pvVar4 = malloc(lVar11 * 8);
pvVar5 = malloc(lVar11 * 4);
if (0 < 1 << bVar1) {
lVar10 = 0;
do {
while (*(int4 *)((long)pvVar5 + lVar10 * 4) = 0, (int)param_2 < 1) {
pvVar6 = malloc(0);
*(void **)((long)pvVar4 + lVar10 * 8) = pvVar6;
lVar10 = lVar10 + 1;
if (lVar10 == lVar11) goto LAB_00101488;
}
iVar9 = 0;
uVar3 = 0;
do {
if (((uint)lVar10 >> (uVar3 & 0x1f) & 1) != 0) {
iVar9 = iVar9 + 1;
*(int *)((long)pvVar5 + lVar10 * 4) = iVar9;
}
uVar3 = uVar3 + 1;
} while (param_2 != uVar3);
pvVar6 = malloc((long)iVar9 << 2);
lVar8 = 0;
iVar9 = 0;
*(void **)((long)pvVar4 + lVar10 * 8) = pvVar6;
do {
if (((uint)lVar10 >> ((uint)lVar8 & 0x1f) & 1) != 0) {
lVar7 = (long)iVar9;
iVar9 = iVar9 + 1;
*(int4 *)((long)pvVar6 + lVar7 * 4) = *(int4 *)(param_1 + lVar8 * 4);
}
lVar8 = lVar8 + 1;
} while ((int)param_2 != lVar8);
lVar10 = lVar10 + 1;
} while (lVar10 != lVar11);
}
LAB_00101488:
*param_3 = pvVar4;
*param_4 = iVar2;
*param_5 = pvVar5;
return;
} |
7,331 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int my_list[], int list_size, int ***output, int *output_size, int **output_element_sizes) {
int total_sublists = 1 << list_size;
int **subs = malloc(total_sublists * sizeof(int *));
int *sizes = malloc(total_sublists * sizeof(int));
int count = 0;
for (int mask = 0; mask < total_sublists; mask++) {
sizes[count] = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
sizes[count]++;
}
}
subs[count] = malloc(sizes[count] * sizeof(int));
int pos = 0;
for (int i = 0; i < list_size; i++) {
if (mask & (1 << i)) {
subs[count][pos] = my_list[i];
pos++;
}
}
count++;
}
*output = subs;
*output_size = total_sublists;
*output_element_sizes = sizes;
}
| int main() {
int list1[] = {10, 20, 30, 40};
int list_size1 = 4;
int **output1;
int output_size1;
int *output_element_sizes1;
func0(list1, list_size1, &output1, &output_size1, &output_element_sizes1);
assert(output_size1 == 16); // replace specific list comparison for simplicity
char *list2[] = {'X', 'Y', 'Z'};
int list_size2 = 3;
int **output2;
int output_size2;
int *output_element_sizes2;
func0((int*)list2, list_size2, &output2, &output_size2, &output_element_sizes2);
assert(output_size2 == 8);
int list3[] = {1, 2, 3};
int list_size3 = 3;
int **output3;
int output_size3;
int *output_element_sizes3;
func0(list3, list_size3, &output3, &output_size3, &output_element_sizes3);
assert(output_size3 == 8);
// Free memory
for (int i = 0; i < output_size1; i++) {
free(output1[i]);
}
free(output1);
free(output_element_sizes1);
for (int i = 0; i < output_size2; i++) {
free(output2[i]);
}
free(output2);
free(output_element_sizes2);
for (int i = 0; i < output_size3; i++) {
free(output3[i]);
}
free(output3);
free(output_element_sizes3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
mov $0x1,%eax
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x38,%rsp
mov %rcx,0x20(%rsp)
mov %esi,%ecx
shl %cl,%eax
mov %rdx,0x18(%rsp)
movslq %eax,%rbp
mov %r8,0x28(%rsp)
lea 0x0(,%rbp,8),%rdi
mov %ebp,0x14(%rsp)
callq 10b0 <malloc@plt>
lea 0x0(,%rbp,4),%rdi
mov %rax,(%rsp)
callq 10b0 <malloc@plt>
mov %rax,%r13
lea -0x1(%rbp),%eax
mov %rax,0x8(%rsp)
test %ebp,%ebp
jle 14e3 <func0+0x123>
xor %r14d,%r14d
mov %r13,%r15
mov %r12d,%r13d
movl $0x0,(%r15,%r14,4)
mov %r14d,%r12d
test %r13d,%r13d
jle 14c5 <func0+0x105>
nopl (%rax)
xor %edi,%edi
xor %ebp,%ebp
jmp 1452 <func0+0x92>
xchg %ax,%ax
mov %eax,%ebp
bt %ebp,%r12d
jae 145f <func0+0x9f>
add $0x1,%edi
mov %edi,(%r15,%r14,4)
lea 0x1(%rbp),%eax
cmp %eax,%r13d
jne 1450 <func0+0x90>
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rsp),%rsi
xor %edx,%edx
xor %r8d,%r8d
mov %rax,(%rsi,%r14,8)
jmp 148b <func0+0xcb>
nopw 0x0(%rax,%rax,1)
mov %rcx,%rdx
bt %edx,%r12d
jae 149e <func0+0xde>
mov (%rbx,%rdx,4),%esi
movslq %r8d,%rcx
add $0x1,%r8d
mov %esi,(%rax,%rcx,4)
lea 0x1(%rdx),%rcx
cmp %rdx,%rbp
jne 1488 <func0+0xc8>
lea 0x1(%r14),%rax
cmp %r14,0x8(%rsp)
je 14e0 <func0+0x120>
mov %rax,%r14
movl $0x0,(%r15,%r14,4)
mov %r14d,%r12d
test %r13d,%r13d
jg 1448 <func0+0x88>
xor %edi,%edi
callq 10b0 <malloc@plt>
mov (%rsp),%rsi
mov %rax,(%rsi,%r14,8)
lea 0x1(%r14),%rax
cmp %r14,0x8(%rsp)
jne 14b2 <func0+0xf2>
mov %r15,%r13
mov 0x18(%rsp),%rax
mov (%rsp),%rbx
mov %rbx,(%rax)
mov 0x20(%rsp),%rax
mov 0x14(%rsp),%ebx
mov %ebx,(%rax)
mov 0x28(%rsp),%rax
mov %r13,(%rax)
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov eax, 1
push r14
push r13
push r12
mov r12d, esi
push rbp
push rbx
mov rbx, rdi
sub rsp, 38h
mov [rsp+68h+var_48], rcx
mov ecx, esi
shl eax, cl
mov [rsp+68h+var_50], rdx
movsxd r15, eax
mov [rsp+68h+var_40], r8
lea rdi, ds:0[r15*8]; size
mov [rsp+68h+var_54], r15d
mov [rsp+68h+var_60], r15
call _malloc
lea rdi, ds:0[r15*4]; size
mov [rsp+68h+var_68], rax
call _malloc
mov r13, rax
test r15d, r15d
jle loc_148A
mov dword ptr [rax], 0
test r12d, r12d
jle loc_147C
movsxd r14, r12d
xor ebp, ebp
xor r15d, r15d
mov rax, r14
mov r14d, r12d
mov r12, rbp
mov rbp, rbx
mov rbx, r13
mov r13, rax
loc_1410:
xor edi, edi
xor eax, eax
nop dword ptr [rax+00h]
loc_1418:
bt r15d, eax
jnb short loc_1425
add edi, 1
mov [rbx+r12*4], edi
loc_1425:
add eax, 1
cmp r14d, eax
jnz short loc_1418
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rsi, [rsp+68h+var_68]
xor edx, edx
xor edi, edi
mov [rsi+r12*8], rax
nop dword ptr [rax]
loc_1448:
bt r15d, edx
jnb short loc_145B
mov esi, [rbp+rdx*4+0]
movsxd rcx, edi
add edi, 1
mov [rax+rcx*4], esi
loc_145B:
add rdx, 1
cmp rdx, r13
jnz short loc_1448
add r12, 1
cmp [rsp+68h+var_60], r12
jz short loc_14C0
mov dword ptr [rbx+r12*4], 0
mov r15d, r12d
jmp short loc_1410
loc_147C:
xor edi, edi; size
call _malloc
mov rcx, [rsp+68h+var_68]
mov [rcx], rax
loc_148A:
mov rax, [rsp+68h+var_50]
mov rcx, [rsp+68h+var_68]
mov [rax], rcx
mov rax, [rsp+68h+var_48]
mov ecx, [rsp+68h+var_54]
mov [rax], ecx
mov rax, [rsp+68h+var_40]
mov [rax], r13
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14C0:
mov r13, rbx
jmp short loc_148A | _QWORD * func0(long long a1, int a2, _QWORD *a3, _DWORD *a4, _QWORD *a5)
{
long long v5; // r15
_DWORD *v6; // rax
_DWORD *v7; // r13
int v8; // r15d
long long v9; // r12
_DWORD *v11; // rbx
int v12; // edi
unsigned int i; // eax
_DWORD *v14; // rax
long long v15; // rdx
int v16; // edi
long long v17; // rcx
_QWORD *result; // rax
_QWORD *v19; // [rsp+0h] [rbp-68h]
v5 = 1 << a2;
v19 = malloc(8 * v5);
v6 = malloc(4 * v5);
v7 = v6;
if ( (int)v5 > 0 )
{
*v6 = 0;
if ( a2 <= 0 )
{
*v19 = malloc(0LL);
}
else
{
v8 = 0;
v9 = 0LL;
v11 = v6;
while ( 1 )
{
v12 = 0;
for ( i = 0; i != a2; ++i )
{
if ( _bittest(&v8, i) )
v11[v9] = ++v12;
}
v14 = malloc(4LL * v12);
v15 = 0LL;
v16 = 0;
v19[v9] = v14;
do
{
if ( _bittest(&v8, v15) )
{
v17 = v16++;
v14[v17] = *(_DWORD *)(a1 + 4 * v15);
}
++v15;
}
while ( v15 != a2 );
if ( 1 << a2 == ++v9 )
break;
v11[v9] = 0;
v8 = v9;
}
v7 = v11;
}
}
*a3 = v19;
*a4 = 1 << a2;
result = a5;
*a5 = v7;
return result;
} | func0:
ENDBR64
PUSH R15
MOV EAX,0x1
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RCX
MOV ECX,ESI
SHL EAX,CL
MOV qword ptr [RSP + 0x18],RDX
MOVSXD R15,EAX
MOV qword ptr [RSP + 0x28],R8
LEA RDI,[R15*0x8]
MOV dword ptr [RSP + 0x14],R15D
MOV qword ptr [RSP + 0x8],R15
CALL 0x001010b0
LEA RDI,[R15*0x4]
MOV qword ptr [RSP],RAX
CALL 0x001010b0
MOV R13,RAX
TEST R15D,R15D
JLE 0x0010148a
MOV dword ptr [RAX],0x0
TEST R12D,R12D
JLE 0x0010147c
MOVSXD R14,R12D
XOR EBP,EBP
XOR R15D,R15D
MOV RAX,R14
MOV R14D,R12D
MOV R12,RBP
MOV RBP,RBX
MOV RBX,R13
MOV R13,RAX
LAB_00101410:
XOR EDI,EDI
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101418:
BT R15D,EAX
JNC 0x00101425
ADD EDI,0x1
MOV dword ptr [RBX + R12*0x4],EDI
LAB_00101425:
ADD EAX,0x1
CMP R14D,EAX
JNZ 0x00101418
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RSI,qword ptr [RSP]
XOR EDX,EDX
XOR EDI,EDI
MOV qword ptr [RSI + R12*0x8],RAX
NOP dword ptr [RAX]
LAB_00101448:
BT R15D,EDX
JNC 0x0010145b
MOV ESI,dword ptr [RBP + RDX*0x4]
MOVSXD RCX,EDI
ADD EDI,0x1
MOV dword ptr [RAX + RCX*0x4],ESI
LAB_0010145b:
ADD RDX,0x1
CMP RDX,R13
JNZ 0x00101448
ADD R12,0x1
CMP qword ptr [RSP + 0x8],R12
JZ 0x001014c0
MOV dword ptr [RBX + R12*0x4],0x0
MOV R15D,R12D
JMP 0x00101410
LAB_0010147c:
XOR EDI,EDI
CALL 0x001010b0
MOV RCX,qword ptr [RSP]
MOV qword ptr [RCX],RAX
LAB_0010148a:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x14]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],R13
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014c0:
MOV R13,RBX
JMP 0x0010148a | void func0(long param_1,uint param_2,int8 *param_3,int *param_4,int8 *param_5)
{
byte bVar1;
int iVar2;
uint uVar3;
int8 *puVar4;
int4 *puVar5;
void *pvVar6;
long lVar7;
long lVar8;
int iVar9;
uint uVar10;
long lVar11;
long lVar12;
bVar1 = (byte)param_2 & 0x1f;
iVar2 = 1 << bVar1;
lVar12 = (long)iVar2;
puVar4 = (int8 *)malloc(lVar12 * 8);
puVar5 = (int4 *)malloc(lVar12 * 4);
if (0 < 1 << bVar1) {
*puVar5 = 0;
if ((int)param_2 < 1) {
pvVar6 = malloc(0);
*puVar4 = pvVar6;
}
else {
lVar11 = 0;
uVar10 = 0;
while( true ) {
iVar9 = 0;
uVar3 = 0;
do {
if ((uVar10 >> (uVar3 & 0x1f) & 1) != 0) {
iVar9 = iVar9 + 1;
puVar5[lVar11] = iVar9;
}
uVar3 = uVar3 + 1;
} while (param_2 != uVar3);
pvVar6 = malloc((long)iVar9 << 2);
lVar8 = 0;
iVar9 = 0;
puVar4[lVar11] = pvVar6;
do {
if ((uVar10 >> ((uint)lVar8 & 0x1f) & 1) != 0) {
lVar7 = (long)iVar9;
iVar9 = iVar9 + 1;
*(int4 *)((long)pvVar6 + lVar7 * 4) = *(int4 *)(param_1 + lVar8 * 4);
}
lVar8 = lVar8 + 1;
} while (lVar8 != (int)param_2);
lVar11 = lVar11 + 1;
if (lVar12 == lVar11) break;
puVar5[lVar11] = 0;
uVar10 = (uint)lVar11;
}
}
}
*param_3 = puVar4;
*param_4 = iVar2;
*param_5 = puVar5;
return;
} |
7,332 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| const char* func0(const char *string) {
regex_t reg;
const char *regex = "[a-zA-Z0-9]$";
int ret;
ret = regcomp(®, regex, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
regmatch_t matches[1];
ret = regexec(®, string, 1, matches, 0);
regfree(®);
if (!ret) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(strcmp(func0("dawood@"), "Discard") == 0);
assert(strcmp(func0("skdmsam326"), "Accept") == 0);
assert(strcmp(func0("cooltricks@"), "Discard") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdf9(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10d0 <regcomp@plt>
mov %eax,-0x5c(%rbp)
cmpl $0x0,-0x5c(%rbp)
je 123d <func0+0x54>
lea 0xdda(%rip),%rax
jmp 1284 <func0+0x9b>
lea -0x10(%rbp),%rdx
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov $0x1,%edx
mov %rax,%rdi
callq 10f0 <regexec@plt>
mov %eax,-0x5c(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 10a0 <regfree@plt>
cmpl $0x0,-0x5c(%rbp)
jne 127d <func0+0x94>
lea 0xdb0(%rip),%rax
jmp 1284 <func0+0x9b>
lea 0xdae(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1298 <func0+0xaf>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAZaZ09; "[a-zA-Z0-9]$"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov [rbp+var_5C], eax
cmp [rbp+var_5C], 0
jz short loc_123D
lea rax, aErrorCompiling; "Error compiling regex"
jmp short loc_1284
loc_123D:
lea rdx, [rbp+pmatch]
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov rcx, rdx; pmatch
mov edx, 1; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_5C], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_5C], 0
jnz short loc_127D
lea rax, aAccept; "Accept"
jmp short loc_1284
loc_127D:
lea rax, s2; "Discard"
loc_1284:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1298
call ___stack_chk_fail
locret_1298:
leave
retn | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
regmatch_t pmatch; // [rsp+60h] [rbp-10h] BYREF
unsigned long long v5; // [rsp+68h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( regcomp(&preg, "[a-zA-Z0-9]$", 1) )
return "Error compiling regex";
v2 = regexec(&preg, a1, 1uLL, &pmatch, 0);
regfree(&preg);
if ( v2 )
return "Discard";
else
return "Accept";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x0010123d
LEA RAX,[0x102015]
JMP 0x00101284
LAB_0010123d:
LEA RDX,[RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x5c],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001010a0
CMP dword ptr [RBP + -0x5c],0x0
JNZ 0x0010127d
LEA RAX,[0x10202b]
JMP 0x00101284
LAB_0010127d:
LEA RAX,[0x102032]
LAB_00101284:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101298
CALL 0x001010b0
LAB_00101298:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
regmatch_t local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"[a-zA-Z0-9]$",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,1,&local_18,0);
regfree(&local_58);
if (iVar1 == 0) {
pcVar2 = "Accept";
}
else {
pcVar2 = "Discard";
}
}
else {
pcVar2 = "Error compiling regex";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,333 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| const char* func0(const char *string) {
regex_t reg;
const char *regex = "[a-zA-Z0-9]$";
int ret;
ret = regcomp(®, regex, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
regmatch_t matches[1];
ret = regexec(®, string, 1, matches, 0);
regfree(®);
if (!ret) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(strcmp(func0("dawood@"), "Discard") == 0);
assert(strcmp(func0("skdmsam326"), "Accept") == 0);
assert(strcmp(func0("cooltricks@"), "Discard") == 0);
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 $0x1,%edx
lea 0xe34(%rip),%rsi
callq 10c0 <regcomp@plt>
mov %eax,%edx
lea 0xe01(%rip),%rax
test %edx,%edx
je 121e <func0+0x55>
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 125c <func0+0x93>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
lea 0x40(%rsp),%rcx
mov %rsp,%rbp
mov $0x0,%r8d
mov $0x1,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 1090 <regfree@plt>
test %ebx,%ebx
lea 0xdcb(%rip),%rax
lea 0xdcb(%rip),%rdx
cmovne %rdx,%rax
jmp 1207 <func0+0x3e>
callq 10a0 <__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, 1
lea rsi, aAZaZ09; "[a-zA-Z0-9]$"
call _regcomp
mov edx, eax
lea rax, aErrorCompiling; "Error compiling regex"
test edx, edx
jz short loc_123E
loc_1227:
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_127C
add rsp, 58h
pop rbx
pop rbp
retn
loc_123E:
lea rcx, [rsp+68h+var_28]
mov rbp, rsp
mov r8d, 0
mov edx, 1
mov rsi, rbx
mov rdi, rbp
call _regexec
mov ebx, eax
mov rdi, rbp
call _regfree
test ebx, ebx
lea rax, aAccept; "Accept"
lea rdx, aDiscard; "Discard"
cmovnz rax, rdx
jmp short loc_1227
loc_127C:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
_BYTE v4[64]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v5[8]; // [rsp+40h] [rbp-28h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-20h]
v6 = __readfsqword(0x28u);
v1 = regcomp(v4, "[a-zA-Z0-9]$", 1LL);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(v4, a1, 1LL, v5, 0LL);
regfree(v4);
result = "Accept";
if ( v3 )
return "Discard";
}
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,0x1
LEA RSI,[0x102029]
CALL 0x001010d0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x0010123e
LAB_00101227:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010127c
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_0010123e:
LEA RCX,[RSP + 0x40]
MOV RBP,RSP
MOV R8D,0x0
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010f0
MOV EBX,EAX
MOV RDI,RBP
CALL 0x001010a0
TEST EBX,EBX
LEA RAX,[0x10201a]
LEA RDX,[0x102021]
CMOVNZ RAX,RDX
JMP 0x00101227
LAB_0010127c:
CALL 0x001010b0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
regmatch_t local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"[a-zA-Z0-9]$",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,1,&local_28,0);
regfree(&rStack_68);
pcVar2 = "Accept";
if (iVar1 != 0) {
pcVar2 = "Discard";
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,334 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| const char* func0(const char *string) {
regex_t reg;
const char *regex = "[a-zA-Z0-9]$";
int ret;
ret = regcomp(®, regex, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
regmatch_t matches[1];
ret = regexec(®, string, 1, matches, 0);
regfree(®);
if (!ret) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(strcmp(func0("dawood@"), "Discard") == 0);
assert(strcmp(func0("skdmsam326"), "Accept") == 0);
assert(strcmp(func0("cooltricks@"), "Discard") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd67(%rip),%rsi
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 10c0 <regcomp@plt>
mov %eax,%r8d
lea 0xd15(%rip),%rax
test %r8d,%r8d
jne 1327 <func0+0x77>
mov $0x1,%edx
mov %rbp,%rsi
lea 0x40(%rsp),%rcx
mov %r12,%rdi
callq 10d0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 1090 <regfree@plt>
test %ebp,%ebp
lea 0xcfe(%rip),%rax
lea 0xcfe(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 133f <func0+0x8f>
add $0x58,%rsp
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r12
mov edx, 1
mov r12, rdi
lea rsi, aAZaZ09; "[a-zA-Z0-9]$"
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, aErrorCompiling; "Error compiling regex"
test r8d, r8d
jnz short loc_1339
mov edx, 1
mov rsi, r12
lea rcx, [rsp+var_s40]
mov rdi, rbp
call _regexec
mov rdi, rbp
mov r12d, eax
call _regfree
test r12d, r12d
lea rax, aAccept; "Accept"
lea rdx, aDiscard; "Discard"
cmovnz rax, rdx
loc_1339:
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_1351
add rsp, 58h
pop rbp
pop r12
retn
loc_1351:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // r8d
const char *result; // rax
int v3; // r12d
_BYTE _0[64]; // [rsp+0h] [rbp+0h] BYREF
char vars40; // [rsp+40h] [rbp+40h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
v1 = regcomp(_0, "[a-zA-Z0-9]$", 1LL);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(_0, a1, 1LL, &vars40);
regfree(_0);
result = "Accept";
if ( v3 )
return "Discard";
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
MOV R12,RDI
LEA RSI,[0x102029]
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 0x001010d0
MOV R8D,EAX
LEA RAX,[0x102004]
TEST R8D,R8D
JNZ 0x00101339
MOV EDX,0x1
MOV RSI,R12
LEA RCX,[RSP + 0x40]
MOV RDI,RBP
CALL 0x001010f0
MOV RDI,RBP
MOV R12D,EAX
CALL 0x001010a0
TEST R12D,R12D
LEA RAX,[0x10201a]
LEA RDX,[0x102021]
CMOVNZ RAX,RDX
LAB_00101339:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101351
ADD RSP,0x58
POP RBP
POP R12
RET
LAB_00101351:
CALL 0x001010b0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
regmatch_t local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"[a-zA-Z0-9]$",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,1,&local_28,0);
regfree(&rStack_68);
pcVar2 = "Accept";
if (iVar1 != 0) {
pcVar2 = "Discard";
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,335 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| const char* func0(const char *string) {
regex_t reg;
const char *regex = "[a-zA-Z0-9]$";
int ret;
ret = regcomp(®, regex, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
regmatch_t matches[1];
ret = regexec(®, string, 1, matches, 0);
regfree(®);
if (!ret) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(strcmp(func0("dawood@"), "Discard") == 0);
assert(strcmp(func0("skdmsam326"), "Accept") == 0);
assert(strcmp(func0("cooltricks@"), "Discard") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd67(%rip),%rsi
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 10c0 <regcomp@plt>
mov %eax,%r8d
lea 0xd15(%rip),%rax
test %r8d,%r8d
jne 1327 <func0+0x77>
mov $0x1,%edx
mov %rbp,%rsi
lea 0x40(%rsp),%rcx
mov %r12,%rdi
callq 10d0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 1090 <regfree@plt>
test %ebp,%ebp
lea 0xcfe(%rip),%rax
lea 0xcfe(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 133f <func0+0x8f>
add $0x58,%rsp
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "[a-zA-Z0-9]$"
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, aErrorCompiling; "Error compiling regex"
test edx, edx
jnz short loc_1337
xor r8d, r8d; eflags
mov edx, 1; nmatch
mov rsi, rbx; string
mov rdi, rbp; preg
lea rcx, [rsp+pmatch]; pmatch
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
test ebx, ebx
lea rax, s2; "Discard"
lea rdx, aAccept; "Accept"
cmovz rax, rdx
loc_1337:
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_134E
add rsp, 58h
pop rbx
pop rbp
retn
loc_134E:
call ___stack_chk_fail | const char * func0(char *string)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
regex_t vars0; // [rsp+0h] [rbp+0h] BYREF
regmatch_t pmatch; // [rsp+40h] [rbp+40h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
v1 = regcomp(&vars0, "[a-zA-Z0-9]$", 1);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(&vars0, string, 1uLL, &pmatch, 0);
regfree(&vars0);
result = "Discard";
if ( !v3 )
return "Accept";
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102029]
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 0x001010d0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JNZ 0x00101337
XOR R8D,R8D
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,RBP
LEA RCX,[RSP + 0x40]
CALL 0x001010f0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x001010a0
TEST EBX,EBX
LEA RAX,[0x102021]
LEA RDX,[0x10201a]
CMOVZ RAX,RDX
LAB_00101337:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010134e
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_0010134e:
CALL 0x001010b0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
regmatch_t local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"[a-zA-Z0-9]$",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,1,&local_28,0);
regfree(&rStack_68);
pcVar2 = "Discard";
if (iVar1 == 0) {
pcVar2 = "Accept";
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,336 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int is_anagram(const char *str1, const char *str2) {
int count1[256] = {0};
int count2[256] = {0};
while (*str1) {
count1[(unsigned char)*str1++]++;
}
while (*str2) {
count2[(unsigned char)*str2++]++;
}
for(int i=0;i<256;i++) {
if(count1[i] != count2[i])
return 0;
}
return 1;
}
| int func0(char* texts[], int texts_size, char* str, char* result[]) {
int result_size = 0;
for(int i=0;i<texts_size;i++) {
if(is_anagram(texts[i], str)) {
result[result_size++] = texts[i];
}
}
return result_size;
}
| int main() {
// Test case 1
char* texts1[] = {"bcda", "abce", "cbda", "cbea", "adcb"};
char* str1 = "abcd";
char* expected1[] = {"bcda", "cbda", "adcb"};
char* result1[5];
int size1 = func0(texts1, 5, str1, result1);
assert(size1 == 3);
assert(strcmp(result1[0], expected1[0]) == 0);
assert(strcmp(result1[1], expected1[1]) == 0);
assert(strcmp(result1[2], expected1[2]) == 0);
// Test case 2
char* texts2[] = {"recitals", " python"};
char* str2 = "articles";
char* expected2[] = {"recitals"};
char* result2[2];
int size2 = func0(texts2, 2, str2, result2);
assert(size2 == 1);
assert(strcmp(result2[0], expected2[0]) == 0);
// Test case 3
char* texts3[] = {" keep", " abcdef", " xyz"};
char* str3 = " peek";
char* expected3[] = {" keep"};
char* result3[3];
int size3 = func0(texts3, 3, str3, result3);
assert(size3 == 1);
assert(strcmp(result3[0], expected3[0]) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1350 <func0+0x8e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 1189 <is_anagram>
test %eax,%eax
je 134c <func0+0x8a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x30(%rbp),%rax
add %rax,%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 12ed <func0+0x2b>
mov -0x8(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1350
loc_12ED:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call is_anagram
test eax, eax
jz short loc_134C
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_30]
add rdx, rax
mov rax, [rcx]
mov [rdx], rax
loc_134C:
add [rbp+var_4], 1
loc_1350:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_12ED
mov eax, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2, long long a3, long long a4)
{
int v4; // eax
unsigned int v8; // [rsp+28h] [rbp-8h]
int i; // [rsp+2Ch] [rbp-4h]
v8 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (unsigned int)is_anagram(*(_QWORD *)(8LL * i + a1), a3) )
{
v4 = v8++;
*(_QWORD *)(a4 + 8LL * v4) = *(_QWORD *)(8LL * i + a1);
}
}
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101350
LAB_001012ed:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101189
TEST EAX,EAX
JZ 0x0010134c
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x30]
ADD RDX,RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
LAB_0010134c:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101350:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001012ed
MOV EAX,dword ptr [RBP + -0x8]
LEAVE
RET | int func0(long param_1,int param_2,int8 param_3,long param_4)
{
int iVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
iVar1 = is_anagram(*(int8 *)(param_1 + (long)local_c * 8),param_3);
if (iVar1 != 0) {
*(int8 *)((long)local_10 * 8 + param_4) = *(int8 *)((long)local_c * 8 + param_1);
local_10 = local_10 + 1;
}
}
return local_10;
} |
7,337 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int is_anagram(const char *str1, const char *str2) {
int count1[256] = {0};
int count2[256] = {0};
while (*str1) {
count1[(unsigned char)*str1++]++;
}
while (*str2) {
count2[(unsigned char)*str2++]++;
}
for(int i=0;i<256;i++) {
if(count1[i] != count2[i])
return 0;
}
return 1;
}
| int func0(char* texts[], int texts_size, char* str, char* result[]) {
int result_size = 0;
for(int i=0;i<texts_size;i++) {
if(is_anagram(texts[i], str)) {
result[result_size++] = texts[i];
}
}
return result_size;
}
| int main() {
// Test case 1
char* texts1[] = {"bcda", "abce", "cbda", "cbea", "adcb"};
char* str1 = "abcd";
char* expected1[] = {"bcda", "cbda", "adcb"};
char* result1[5];
int size1 = func0(texts1, 5, str1, result1);
assert(size1 == 3);
assert(strcmp(result1[0], expected1[0]) == 0);
assert(strcmp(result1[1], expected1[1]) == 0);
assert(strcmp(result1[2], expected1[2]) == 0);
// Test case 2
char* texts2[] = {"recitals", " python"};
char* str2 = "articles";
char* expected2[] = {"recitals"};
char* result2[2];
int size2 = func0(texts2, 2, str2, result2);
assert(size2 == 1);
assert(strcmp(result2[0], expected2[0]) == 0);
// Test case 3
char* texts3[] = {" keep", " abcdef", " xyz"};
char* str3 = " peek";
char* expected3[] = {" keep"};
char* result3[3];
int size3 = func0(texts3, 3, str3, result3);
assert(size3 == 1);
assert(strcmp(result3[0], expected3[0]) == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1280 <func0+0x58>
mov %rdx,%r13
mov %rcx,%r15
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r14
mov $0x0,%r12d
jmp 1260 <func0+0x38>
add $0x8,%rbx
cmp %r14,%rbx
je 1286 <func0+0x5e>
mov (%rbx),%rbp
mov %r13,%rsi
mov %rbp,%rdi
callq 1169 <is_anagram>
test %eax,%eax
je 1257 <func0+0x2f>
movslq %r12d,%rax
mov %rbp,(%r15,%rax,8)
lea 0x1(%r12),%r12d
jmp 1257 <func0+0x2f>
mov $0x0,%r12d
mov %r12d,%eax
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
test esi, esi
jle short loc_12A0
mov r13, rdx
mov r15, rcx
mov rbx, rdi
lea eax, [rsi-1]
lea r14, [rdi+rax*8+8]
mov r12d, 0
jmp short loc_1280
loc_1277:
add rbx, 8
cmp rbx, r14
jz short loc_12A6
loc_1280:
mov rbp, [rbx]
mov rsi, r13
mov rdi, rbp
call is_anagram
test eax, eax
jz short loc_1277
movsxd rax, r12d
mov [r15+rax*8], rbp
lea r12d, [r12+1]
jmp short loc_1277
loc_12A0:
mov r12d, 0
loc_12A6:
mov eax, r12d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(_QWORD *a1, int a2, long long a3, long long a4)
{
_QWORD *v6; // rbx
unsigned int v7; // r12d
long long v8; // rbp
if ( a2 <= 0 )
{
return 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
v8 = *v6;
if ( (unsigned int)is_anagram(*v6, a3) )
*(_QWORD *)(a4 + 8LL * (int)v7++) = v8;
++v6;
}
while ( v6 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return v7;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001012a0
MOV R13,RDX
MOV R15,RCX
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R14,[RDI + RAX*0x8 + 0x8]
MOV R12D,0x0
JMP 0x00101280
LAB_00101277:
ADD RBX,0x8
CMP RBX,R14
JZ 0x001012a6
LAB_00101280:
MOV RBP,qword ptr [RBX]
MOV RSI,R13
MOV RDI,RBP
CALL 0x00101189
TEST EAX,EAX
JZ 0x00101277
MOVSXD RAX,R12D
MOV qword ptr [R15 + RAX*0x8],RBP
LEA R12D,[R12 + 0x1]
JMP 0x00101277
LAB_001012a0:
MOV R12D,0x0
LAB_001012a6:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int func0(int8 *param_1,int param_2,int8 param_3,long param_4)
{
int8 *puVar1;
int8 uVar2;
int iVar3;
int iVar4;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0;
do {
uVar2 = *param_1;
iVar3 = is_anagram(uVar2,param_3);
if (iVar3 != 0) {
*(int8 *)(param_4 + (long)iVar4 * 8) = uVar2;
iVar4 = iVar4 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar4;
} |
7,338 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int is_anagram(const char *str1, const char *str2) {
int count1[256] = {0};
int count2[256] = {0};
while (*str1) {
count1[(unsigned char)*str1++]++;
}
while (*str2) {
count2[(unsigned char)*str2++]++;
}
for(int i=0;i<256;i++) {
if(count1[i] != count2[i])
return 0;
}
return 1;
}
| int func0(char* texts[], int texts_size, char* str, char* result[]) {
int result_size = 0;
for(int i=0;i<texts_size;i++) {
if(is_anagram(texts[i], str)) {
result[result_size++] = texts[i];
}
}
return result_size;
}
| int main() {
// Test case 1
char* texts1[] = {"bcda", "abce", "cbda", "cbea", "adcb"};
char* str1 = "abcd";
char* expected1[] = {"bcda", "cbda", "adcb"};
char* result1[5];
int size1 = func0(texts1, 5, str1, result1);
assert(size1 == 3);
assert(strcmp(result1[0], expected1[0]) == 0);
assert(strcmp(result1[1], expected1[1]) == 0);
assert(strcmp(result1[2], expected1[2]) == 0);
// Test case 2
char* texts2[] = {"recitals", " python"};
char* str2 = "articles";
char* expected2[] = {"recitals"};
char* result2[2];
int size2 = func0(texts2, 2, str2, result2);
assert(size2 == 1);
assert(strcmp(result2[0], expected2[0]) == 0);
// Test case 3
char* texts3[] = {" keep", " abcdef", " xyz"};
char* str3 = " peek";
char* expected3[] = {" keep"};
char* result3[3];
int size3 = func0(texts3, 3, str3, result3);
assert(size3 == 1);
assert(strcmp(result3[0], expected3[0]) == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1580 <func0+0x70>
lea -0x1(%rsi),%eax
mov %rdx,%r13
mov %rcx,%r14
mov %rdi,%rbx
lea 0x8(%rdi,%rax,8),%r15
xor %r12d,%r12d
nopw 0x0(%rax,%rax,1)
mov (%rbx),%rbp
mov %r13,%rsi
mov %rbp,%rdi
callq 1430 <is_anagram>
test %eax,%eax
je 155d <func0+0x4d>
movslq %r12d,%rax
add $0x1,%r12d
mov %rbp,(%r14,%rax,8)
add $0x8,%rbx
cmp %r15,%rbx
jne 1540 <func0+0x30>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 1566 <func0+0x56>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1570
lea eax, [rsi-1]
mov r13, rdx
mov r14, rcx
mov rbx, rdi
lea r15, [rdi+rax*8+8]
xor r12d, r12d
nop word ptr [rax+rax+00h]
loc_1530:
mov rbp, [rbx]
mov rsi, r13
mov rdi, rbp
call is_anagram
test eax, eax
jz short loc_154D
movsxd rax, r12d
add r12d, 1
mov [r14+rax*8], rbp
loc_154D:
add rbx, 8
cmp rbx, r15
jnz short loc_1530
loc_1556:
add rsp, 8
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1570:
xor r12d, r12d
jmp short loc_1556 | long long func0(_QWORD *a1, int a2, long long a3, long long a4)
{
_QWORD *v6; // rbx
unsigned int v7; // r12d
long long v8; // rbp
long long v9; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
v8 = *v6;
if ( (unsigned int)is_anagram(*v6, a3) )
{
v9 = (int)v7++;
*(_QWORD *)(a4 + 8 * v9) = v8;
}
++v6;
}
while ( v6 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return v7;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101570
LEA EAX,[RSI + -0x1]
MOV R13,RDX
MOV R14,RCX
MOV RBX,RDI
LEA R15,[RDI + RAX*0x8 + 0x8]
XOR R12D,R12D
NOP word ptr [RAX + RAX*0x1]
LAB_00101530:
MOV RBP,qword ptr [RBX]
MOV RSI,R13
MOV RDI,RBP
CALL 0x00101430
TEST EAX,EAX
JZ 0x0010154d
MOVSXD RAX,R12D
ADD R12D,0x1
MOV qword ptr [R14 + RAX*0x8],RBP
LAB_0010154d:
ADD RBX,0x8
CMP RBX,R15
JNZ 0x00101530
LAB_00101556:
ADD RSP,0x8
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101570:
XOR R12D,R12D
JMP 0x00101556 | int func0(int8 *param_1,int param_2,int8 param_3,long param_4)
{
int8 *puVar1;
int8 uVar2;
int iVar3;
long lVar4;
int iVar5;
if (param_2 < 1) {
iVar5 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar5 = 0;
do {
uVar2 = *param_1;
iVar3 = is_anagram(uVar2,param_3);
if (iVar3 != 0) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
*(int8 *)(param_4 + lVar4 * 8) = uVar2;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar5;
} |
7,339 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int is_anagram(const char *str1, const char *str2) {
int count1[256] = {0};
int count2[256] = {0};
while (*str1) {
count1[(unsigned char)*str1++]++;
}
while (*str2) {
count2[(unsigned char)*str2++]++;
}
for(int i=0;i<256;i++) {
if(count1[i] != count2[i])
return 0;
}
return 1;
}
| int func0(char* texts[], int texts_size, char* str, char* result[]) {
int result_size = 0;
for(int i=0;i<texts_size;i++) {
if(is_anagram(texts[i], str)) {
result[result_size++] = texts[i];
}
}
return result_size;
}
| int main() {
// Test case 1
char* texts1[] = {"bcda", "abce", "cbda", "cbea", "adcb"};
char* str1 = "abcd";
char* expected1[] = {"bcda", "cbda", "adcb"};
char* result1[5];
int size1 = func0(texts1, 5, str1, result1);
assert(size1 == 3);
assert(strcmp(result1[0], expected1[0]) == 0);
assert(strcmp(result1[1], expected1[1]) == 0);
assert(strcmp(result1[2], expected1[2]) == 0);
// Test case 2
char* texts2[] = {"recitals", " python"};
char* str2 = "articles";
char* expected2[] = {"recitals"};
char* result2[2];
int size2 = func0(texts2, 2, str2, result2);
assert(size2 == 1);
assert(strcmp(result2[0], expected2[0]) == 0);
// Test case 3
char* texts3[] = {" keep", " abcdef", " xyz"};
char* str3 = " peek";
char* expected3[] = {" keep"};
char* result3[3];
int size3 = func0(texts3, 3, str3, result3);
assert(size3 == 1);
assert(strcmp(result3[0], expected3[0]) == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 15a0 <func0+0x70>
lea -0x1(%rsi),%eax
mov %rdx,%r13
mov %rcx,%r14
mov %rdi,%rbx
lea 0x8(%rdi,%rax,8),%r15
xor %r12d,%r12d
nopw 0x0(%rax,%rax,1)
mov (%rbx),%rbp
mov %r13,%rsi
mov %rbp,%rdi
callq 1450 <is_anagram>
test %eax,%eax
je 157d <func0+0x4d>
movslq %r12d,%rax
add $0x1,%r12d
mov %rbp,(%r14,%rax,8)
add $0x8,%rbx
cmp %r15,%rbx
jne 1560 <func0+0x30>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 1586 <func0+0x56>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_15B0
movsxd rsi, esi
mov r13, rdx
mov r14, rcx
mov rbx, rdi
lea r15, [rdi+rsi*8]
xor r12d, r12d
nop dword ptr [rax+00000000h]
loc_1570:
mov rbp, [rbx]
mov rsi, r13
mov rdi, rbp
call is_anagram
test eax, eax
jz short loc_158D
movsxd rax, r12d
add r12d, 1
mov [r14+rax*8], rbp
loc_158D:
add rbx, 8
cmp rbx, r15
jnz short loc_1570
loc_1596:
add rsp, 8
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15B0:
xor r12d, r12d
jmp short loc_1596 | long long func0(_QWORD *a1, int a2, long long a3, long long a4)
{
_QWORD *v6; // rbx
unsigned int v7; // r12d
long long v8; // rbp
long long v9; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
v8 = *v6;
if ( (unsigned int)is_anagram(*v6, a3) )
{
v9 = (int)v7++;
*(_QWORD *)(a4 + 8 * v9) = v8;
}
++v6;
}
while ( v6 != &a1[a2] );
}
return v7;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001015b0
MOVSXD RSI,ESI
MOV R13,RDX
MOV R14,RCX
MOV RBX,RDI
LEA R15,[RDI + RSI*0x8]
XOR R12D,R12D
NOP dword ptr [RAX]
LAB_00101570:
MOV RBP,qword ptr [RBX]
MOV RSI,R13
MOV RDI,RBP
CALL 0x00101470
TEST EAX,EAX
JZ 0x0010158d
MOVSXD RAX,R12D
ADD R12D,0x1
MOV qword ptr [R14 + RAX*0x8],RBP
LAB_0010158d:
ADD RBX,0x8
CMP RBX,R15
JNZ 0x00101570
LAB_00101596:
ADD RSP,0x8
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015b0:
XOR R12D,R12D
JMP 0x00101596 | int func0(int8 *param_1,int param_2,int8 param_3,long param_4)
{
int8 *puVar1;
int8 uVar2;
int iVar3;
long lVar4;
int iVar5;
if (param_2 < 1) {
iVar5 = 0;
}
else {
puVar1 = param_1 + param_2;
iVar5 = 0;
do {
uVar2 = *param_1;
iVar3 = is_anagram(uVar2,param_3);
if (iVar3 != 0) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
*(int8 *)(param_4 + lVar4 * 8) = uVar2;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar5;
} |
7,340 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
typedef struct {
char *word;
int frequency;
} WordFreq;
int compare(const void *a, const void *b) {
WordFreq *wordFreq1 = (WordFreq *)a;
WordFreq *wordFreq2 = (WordFreq *)b;
return wordFreq2->frequency - wordFreq1->frequency;
}
| WordFreq* func0(char *text, int n, int *returnSize) {
char *token;
int size = 0, capacity = 10;
WordFreq *freqs = (WordFreq*)malloc(capacity * sizeof(WordFreq));
char *text_copy = strdup(text);
for (token = strtok(text_copy, " ,.-"); token != NULL; token = strtok(NULL, " ,.-")) {
int found = 0;
for (int i = 0; i < size; ++i) {
if (strcmp(freqs[i].word, token) == 0) {
freqs[i].frequency++;
found = 1;
break;
}
}
if (!found) {
if (size >= capacity) {
capacity *= 2;
freqs = realloc(freqs, capacity * sizeof(WordFreq));
}
freqs[size].word = strdup(token);
freqs[size].frequency = 1;
size++;
}
}
free(text_copy);
qsort(freqs, size, sizeof(WordFreq), compare);
*returnSize = n > size ? size : n;
return freqs;
}
| int main() {
int size;
WordFreq *result;
result = func0("python is a programming language", 1, &size);
assert(size == 1 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 2, &size);
assert(size == 2 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 5, &size);
assert(size == 5 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
for(int i = 0; i < size; i++) {
free(result[i].word);
}
free(result);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %rdx,-0x58(%rbp)
movl $0x0,-0x38(%rbp)
movl $0xa,-0x34(%rbp)
mov -0x34(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1150 <strdup@plt>
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
lea 0xd35(%rip),%rsi
mov %rax,%rdi
callq 1140 <strtok@plt>
mov %rax,-0x28(%rbp)
jmpq 13d4 <func0+0x157>
movl $0x0,-0x30(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 1346 <func0+0xc9>
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 1110 <strcmp@plt>
test %eax,%eax
jne 1342 <func0+0xc5>
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%edx
add $0x1,%edx
mov %edx,0x8(%rax)
movl $0x1,-0x30(%rbp)
jmp 134e <func0+0xd1>
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 12f4 <func0+0x77>
cmpl $0x0,-0x30(%rbp)
jne 13bf <func0+0x142>
mov -0x38(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 137e <func0+0x101>
shll -0x34(%rbp)
mov -0x34(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <realloc@plt>
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1150 <strdup@plt>
mov %rax,(%rbx)
mov -0x38(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movl $0x1,0x8(%rax)
addl $0x1,-0x38(%rbp)
lea 0xc42(%rip),%rsi
mov $0x0,%edi
callq 1140 <strtok@plt>
mov %rax,-0x28(%rbp)
cmpq $0x0,-0x28(%rbp)
jne 12e4 <func0+0x67>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10d0 <free@plt>
mov -0x38(%rbp),%eax
movslq %eax,%rsi
mov -0x20(%rbp),%rax
lea -0x1b3(%rip),%rcx
mov $0x10,%edx
mov %rax,%rdi
callq 10e0 <qsort@plt>
mov -0x38(%rbp),%eax
cmp %eax,-0x4c(%rbp)
cmovle -0x4c(%rbp),%eax
mov %eax,%edx
mov -0x58(%rbp),%rax
mov %edx,(%rax)
mov -0x20(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+s], rdi
mov [rbp+var_4C], esi
mov [rbp+var_58], rdx
mov [rbp+var_38], 0
mov [rbp+var_34], 0Ah
mov eax, [rbp+var_34]
cdqe
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
lea rdx, delim; " ,.-"
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+s2], rax
jmp loc_13DA
loc_12E7:
mov [rbp+var_30], 0
mov [rbp+var_2C], 0
jmp short loc_1349
loc_12F7:
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+s2]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1345
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax+8]
add edx, 1
mov [rax+8], edx
mov [rbp+var_30], 1
jmp short loc_1351
loc_1345:
add [rbp+var_2C], 1
loc_1349:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_38]
jl short loc_12F7
loc_1351:
cmp [rbp+var_30], 0
jnz short loc_13C2
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jl short loc_1381
shl [rbp+var_34], 1
mov eax, [rbp+var_34]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
loc_1381:
mov eax, [rbp+var_38]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+ptr]
lea rbx, [rdx+rax]
mov rax, [rbp+s2]
mov rdi, rax; s
call _strdup
mov [rbx], rax
mov eax, [rbp+var_38]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+ptr]
add rax, rdx
mov dword ptr [rax+8], 1
add [rbp+var_38], 1
loc_13C2:
lea rax, delim; " ,.-"
mov rsi, rax; delim
mov edi, 0; s
call _strtok
mov [rbp+s2], rax
loc_13DA:
cmp [rbp+s2], 0
jnz loc_12E7
mov rax, [rbp+var_18]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_38]
movsxd rsi, eax; nmemb
mov rax, [rbp+ptr]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 10h; size
mov rdi, rax; base
call _qsort
mov edx, [rbp+var_4C]
mov eax, [rbp+var_38]
cmp edx, eax
cmovg edx, eax
mov rax, [rbp+var_58]
mov [rax], edx
mov rax, [rbp+ptr]
mov rbx, [rbp+var_8]
leave
retn | _DWORD * func0(const char *a1, int a2, int *a3)
{
int v3; // edx
int v6; // [rsp+28h] [rbp-38h]
int v7; // [rsp+2Ch] [rbp-34h]
int v8; // [rsp+30h] [rbp-30h]
int i; // [rsp+34h] [rbp-2Ch]
const char *s2; // [rsp+38h] [rbp-28h]
_DWORD *ptr; // [rsp+40h] [rbp-20h]
char *v12; // [rsp+48h] [rbp-18h]
v6 = 0;
v7 = 10;
ptr = malloc(0xA0uLL);
v12 = strdup(a1);
for ( s2 = strtok(v12, " ,.-"); s2; s2 = strtok(0LL, " ,.-") )
{
v8 = 0;
for ( i = 0; i < v6; ++i )
{
if ( !strcmp(*(const char **)&ptr[4 * i], s2) )
{
++ptr[4 * i + 2];
v8 = 1;
break;
}
}
if ( !v8 )
{
if ( v6 >= v7 )
{
v7 *= 2;
ptr = realloc(ptr, 16LL * v7);
}
*(_QWORD *)&ptr[4 * v6] = strdup(s2);
ptr[4 * v6++ + 2] = 1;
}
}
free(v12);
qsort(ptr, v6, 0x10uLL, compare);
v3 = a2;
if ( a2 > v6 )
v3 = v6;
*a3 = v3;
return ptr;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV qword ptr [RBP + -0x58],RDX
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x34],0xa
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x4
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101150
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101140
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001013da
LAB_001012e7:
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101349
LAB_001012f7:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
TEST EAX,EAX
JNZ 0x00101345
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x8]
ADD EDX,0x1
MOV dword ptr [RAX + 0x8],EDX
MOV dword ptr [RBP + -0x30],0x1
JMP 0x00101351
LAB_00101345:
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101349:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x001012f7
LAB_00101351:
CMP dword ptr [RBP + -0x30],0x0
JNZ 0x001013c2
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x00101381
SHL dword ptr [RBP + -0x34],0x1
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x20],RAX
LAB_00101381:
MOV EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RBX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101150
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],0x1
ADD dword ptr [RBP + -0x38],0x1
LAB_001013c2:
LEA RAX,[0x102008]
MOV RSI,RAX
MOV EDI,0x0
CALL 0x00101140
MOV qword ptr [RBP + -0x28],RAX
LAB_001013da:
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001012e7
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001010d0
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x101249]
MOV RCX,RDX
MOV EDX,0x10
MOV RDI,RAX
CALL 0x001010e0
MOV EDX,dword ptr [RBP + -0x4c]
MOV EAX,dword ptr [RBP + -0x38]
CMP EDX,EAX
CMOVG EDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x20]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(char *param_1,int param_2,int *param_3)
{
bool bVar1;
int iVar2;
char *__s;
char *pcVar3;
int local_40;
int local_3c;
int local_34;
char *local_30;
void *local_28;
local_40 = 0;
local_3c = 10;
local_28 = malloc(0xa0);
__s = strdup(param_1);
local_30 = strtok(__s," ,.-");
do {
if (local_30 == (char *)0x0) {
free(__s);
qsort(local_28,(long)local_40,0x10,compare);
if (local_40 < param_2) {
param_2 = local_40;
}
*param_3 = param_2;
return local_28;
}
bVar1 = false;
for (local_34 = 0; local_34 < local_40; local_34 = local_34 + 1) {
iVar2 = strcmp(*(char **)((long)local_28 + (long)local_34 * 0x10),local_30);
if (iVar2 == 0) {
*(int *)((long)local_28 + (long)local_34 * 0x10 + 8) =
*(int *)((long)local_28 + (long)local_34 * 0x10 + 8) + 1;
bVar1 = true;
break;
}
}
if (!bVar1) {
if (local_3c <= local_40) {
local_3c = local_3c << 1;
local_28 = realloc(local_28,(long)local_3c << 4);
}
pcVar3 = strdup(local_30);
*(char **)((long)local_40 * 0x10 + (long)local_28) = pcVar3;
*(int4 *)((long)local_28 + (long)local_40 * 0x10 + 8) = 1;
local_40 = local_40 + 1;
}
local_30 = strtok((char *)0x0," ,.-");
} while( true );
} |
7,341 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
typedef struct {
char *word;
int frequency;
} WordFreq;
int compare(const void *a, const void *b) {
WordFreq *wordFreq1 = (WordFreq *)a;
WordFreq *wordFreq2 = (WordFreq *)b;
return wordFreq2->frequency - wordFreq1->frequency;
}
| WordFreq* func0(char *text, int n, int *returnSize) {
char *token;
int size = 0, capacity = 10;
WordFreq *freqs = (WordFreq*)malloc(capacity * sizeof(WordFreq));
char *text_copy = strdup(text);
for (token = strtok(text_copy, " ,.-"); token != NULL; token = strtok(NULL, " ,.-")) {
int found = 0;
for (int i = 0; i < size; ++i) {
if (strcmp(freqs[i].word, token) == 0) {
freqs[i].frequency++;
found = 1;
break;
}
}
if (!found) {
if (size >= capacity) {
capacity *= 2;
freqs = realloc(freqs, capacity * sizeof(WordFreq));
}
freqs[size].word = strdup(token);
freqs[size].frequency = 1;
size++;
}
}
free(text_copy);
qsort(freqs, size, sizeof(WordFreq), compare);
*returnSize = n > size ? size : n;
return freqs;
}
| int main() {
int size;
WordFreq *result;
result = func0("python is a programming language", 1, &size);
assert(size == 1 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 2, &size);
assert(size == 2 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 5, &size);
assert(size == 5 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
for(int i = 0; i < size; i++) {
free(result[i].word);
}
free(result);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbx
mov %esi,0x14(%rsp)
mov %rdx,0x18(%rsp)
mov $0xa0,%edi
callq 1120 <malloc@plt>
mov %rax,%r15
mov %rbx,%rdi
callq 1150 <strdup@plt>
mov %rax,0x8(%rsp)
lea 0xd71(%rip),%rsi
mov %rax,%rdi
callq 1140 <strtok@plt>
mov %rax,%rbp
movl $0xa,0x10(%rsp)
mov $0x0,%r14d
test %rax,%rax
jne 133e <func0+0xea>
mov 0x8(%rsp),%rdi
callq 10d0 <free@plt>
movslq %r14d,%rsi
lea -0x80(%rip),%rcx
mov $0x10,%edx
mov %r15,%rdi
callq 10e0 <qsort@plt>
mov 0x14(%rsp),%eax
cmp %r14d,%eax
cmovle %eax,%r14d
mov 0x18(%rsp),%rax
mov %r14d,(%rax)
mov %r15,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
addl $0x1,0x8(%rbx)
jmp 1321 <func0+0xcd>
movslq %r14d,%rbx
shl $0x4,%rbx
add %r15,%rbx
mov %rbp,%rdi
callq 1150 <strdup@plt>
mov %rax,(%rbx)
movl $0x1,0x8(%rbx)
add $0x1,%r14d
lea 0xcdc(%rip),%rsi
mov $0x0,%edi
callq 1140 <strtok@plt>
mov %rax,%rbp
test %rax,%rax
je 12b5 <func0+0x61>
test %r14d,%r14d
jle 136b <func0+0x117>
mov %r15,%rbx
lea -0x1(%r14),%eax
shl $0x4,%rax
lea 0x10(%r15,%rax,1),%r13
mov %rbp,%rsi
mov (%rbx),%rdi
callq 1110 <strcmp@plt>
test %eax,%eax
je 12fb <func0+0xa7>
add $0x10,%rbx
cmp %r13,%rbx
jne 1353 <func0+0xff>
cmp 0x10(%rsp),%r14d
jl 1301 <func0+0xad>
shll 0x10(%rsp)
mov 0x10(%rsp),%eax
movslq %eax,%rsi
shl $0x4,%rsi
mov %r15,%rdi
callq 1130 <realloc@plt>
mov %rax,%r15
jmpq 1301 <func0+0xad>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rbx, rdi
mov [rsp+58h+var_44], esi
mov [rsp+58h+var_40], rdx
mov edi, 0A0h
call _malloc
mov r15, rax
mov rdi, rbx
call _strdup
mov [rsp+58h+var_50], rax
lea rsi, asc_2004; " ,.-"
mov rdi, rax
call _strtok
mov rbp, rax
mov [rsp+58h+var_48], 0Ah
mov r14d, 0
test rax, rax
jnz loc_133D
loc_12B5:
mov rdi, [rsp+58h+var_50]
call _free
movsxd rsi, r14d
lea rcx, compare
mov edx, 10h
mov rdi, r15
call _qsort
mov eax, [rsp+58h+var_44]
cmp eax, r14d
cmovg eax, r14d
mov rcx, [rsp+58h+var_40]
mov [rcx], eax
mov rax, r15
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12FA:
add dword ptr [rbx+8], 1
jmp short loc_1320
loc_1300:
movsxd rbx, r14d
shl rbx, 4
add rbx, r15
mov rdi, rbp
call _strdup
mov [rbx], rax
mov dword ptr [rbx+8], 1
add r14d, 1
loc_1320:
lea rsi, asc_2004; " ,.-"
mov edi, 0
call _strtok
mov rbp, rax
test rax, rax
jz loc_12B5
loc_133D:
test r14d, r14d
jle short loc_136A
mov rbx, r15
lea eax, [r14-1]
shl rax, 4
lea r13, [r15+rax+10h]
loc_1352:
mov rsi, rbp
mov rdi, [rbx]
call _strcmp
test eax, eax
jz short loc_12FA
add rbx, 10h
cmp rbx, r13
jnz short loc_1352
loc_136A:
cmp r14d, [rsp+58h+var_48]
jl short loc_1300
shl [rsp+58h+var_48], 1
mov eax, [rsp+58h+var_48]
movsxd rsi, eax
shl rsi, 4
mov rdi, r15
call _realloc
mov r15, rax
jmp loc_1300 | long long func0(long long a1, int a2, int *a3)
{
long long v3; // r15
long long v4; // rbp
int i; // r14d
int v6; // eax
long long v8; // rbx
long long v9; // rbx
long long v10; // [rsp+8h] [rbp-50h]
int v11; // [rsp+10h] [rbp-48h]
v3 = malloc(160LL);
v10 = strdup(a1);
v4 = strtok(v10, " ,.-");
v11 = 10;
for ( i = 0; v4; v4 = strtok(0LL, " ,.-") )
{
if ( i <= 0 )
{
LABEL_12:
if ( i >= v11 )
{
v11 *= 2;
v3 = realloc(v3, 16LL * v11);
}
v8 = v3 + 16LL * i;
*(_QWORD *)v8 = strdup(v4);
*(_DWORD *)(v8 + 8) = 1;
++i;
}
else
{
v9 = v3;
while ( (unsigned int)strcmp(*(_QWORD *)v9, v4) )
{
v9 += 16LL;
if ( v9 == v3 + 16LL * (unsigned int)(i - 1) + 16 )
goto LABEL_12;
}
++*(_DWORD *)(v9 + 8);
}
}
free(v10);
qsort(v3, i, 16LL, compare);
v6 = a2;
if ( a2 > i )
v6 = i;
*a3 = v6;
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV dword ptr [RSP + 0x14],ESI
MOV qword ptr [RSP + 0x18],RDX
MOV EDI,0xa0
CALL 0x00101120
MOV R15,RAX
MOV RDI,RBX
CALL 0x00101150
MOV qword ptr [RSP + 0x8],RAX
LEA RSI,[0x102004]
MOV RDI,RAX
CALL 0x00101140
MOV RBP,RAX
MOV dword ptr [RSP + 0x10],0xa
MOV R14D,0x0
TEST RAX,RAX
JNZ 0x0010133d
LAB_001012b5:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001010d0
MOVSXD RSI,R14D
LEA RCX,[0x101249]
MOV EDX,0x10
MOV RDI,R15
CALL 0x001010e0
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,R14D
CMOVG EAX,R14D
MOV RCX,qword ptr [RSP + 0x18]
MOV dword ptr [RCX],EAX
MOV RAX,R15
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012fa:
ADD dword ptr [RBX + 0x8],0x1
JMP 0x00101320
LAB_00101300:
MOVSXD RBX,R14D
SHL RBX,0x4
ADD RBX,R15
MOV RDI,RBP
CALL 0x00101150
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],0x1
ADD R14D,0x1
LAB_00101320:
LEA RSI,[0x102004]
MOV EDI,0x0
CALL 0x00101140
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001012b5
LAB_0010133d:
TEST R14D,R14D
JLE 0x0010136a
MOV RBX,R15
LEA EAX,[R14 + -0x1]
SHL RAX,0x4
LEA R13,[R15 + RAX*0x1 + 0x10]
LAB_00101352:
MOV RSI,RBP
MOV RDI,qword ptr [RBX]
CALL 0x00101110
TEST EAX,EAX
JZ 0x001012fa
ADD RBX,0x10
CMP RBX,R13
JNZ 0x00101352
LAB_0010136a:
CMP R14D,dword ptr [RSP + 0x10]
JL 0x00101300
SHL dword ptr [RSP + 0x10],0x1
MOV EAX,dword ptr [RSP + 0x10]
MOVSXD RSI,EAX
SHL RSI,0x4
MOV RDI,R15
CALL 0x00101130
MOV R15,RAX
JMP 0x00101300 | int8 * func0(char *param_1,int param_2,int *param_3)
{
int iVar1;
int8 *__ptr;
char *__s;
char *pcVar2;
int8 *puVar3;
int iVar4;
int local_48;
__ptr = (int8 *)malloc(0xa0);
__s = strdup(param_1);
pcVar2 = strtok(__s," ,.-");
local_48 = 10;
iVar4 = 0;
do {
if (pcVar2 == (char *)0x0) {
free(__s);
qsort(__ptr,(long)iVar4,0x10,compare);
if (iVar4 < param_2) {
param_2 = iVar4;
}
*param_3 = param_2;
return __ptr;
}
if (0 < iVar4) {
puVar3 = __ptr;
do {
iVar1 = strcmp((char *)*puVar3,pcVar2);
if (iVar1 == 0) {
*(int *)(puVar3 + 1) = *(int *)(puVar3 + 1) + 1;
goto LAB_00101320;
}
puVar3 = puVar3 + 2;
} while (puVar3 != __ptr + (ulong)(iVar4 - 1) * 2 + 2);
}
if (local_48 <= iVar4) {
local_48 = local_48 << 1;
__ptr = (int8 *)realloc(__ptr,(long)local_48 << 4);
}
pcVar2 = strdup(pcVar2);
__ptr[(long)iVar4 * 2] = pcVar2;
*(int4 *)(__ptr + (long)iVar4 * 2 + 1) = 1;
iVar4 = iVar4 + 1;
LAB_00101320:
pcVar2 = strtok((char *)0x0," ,.-");
} while( true );
} |
7,342 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
typedef struct {
char *word;
int frequency;
} WordFreq;
int compare(const void *a, const void *b) {
WordFreq *wordFreq1 = (WordFreq *)a;
WordFreq *wordFreq2 = (WordFreq *)b;
return wordFreq2->frequency - wordFreq1->frequency;
}
| WordFreq* func0(char *text, int n, int *returnSize) {
char *token;
int size = 0, capacity = 10;
WordFreq *freqs = (WordFreq*)malloc(capacity * sizeof(WordFreq));
char *text_copy = strdup(text);
for (token = strtok(text_copy, " ,.-"); token != NULL; token = strtok(NULL, " ,.-")) {
int found = 0;
for (int i = 0; i < size; ++i) {
if (strcmp(freqs[i].word, token) == 0) {
freqs[i].frequency++;
found = 1;
break;
}
}
if (!found) {
if (size >= capacity) {
capacity *= 2;
freqs = realloc(freqs, capacity * sizeof(WordFreq));
}
freqs[size].word = strdup(token);
freqs[size].frequency = 1;
size++;
}
}
free(text_copy);
qsort(freqs, size, sizeof(WordFreq), compare);
*returnSize = n > size ? size : n;
return freqs;
}
| int main() {
int size;
WordFreq *result;
result = func0("python is a programming language", 1, &size);
assert(size == 1 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 2, &size);
assert(size == 2 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 5, &size);
assert(size == 5 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
for(int i = 0; i < size; i++) {
free(result[i].word);
}
free(result);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
xor %r13d,%r13d
push %r12
push %rbp
mov %rdi,%rbp
mov $0xa0,%edi
push %rbx
sub $0x28,%rsp
mov %esi,0x14(%rsp)
mov %rdx,0x18(%rsp)
callq 1120 <malloc@plt>
mov %rbp,%rdi
xor %ebp,%ebp
mov %rax,%r12
callq 1150 <strdup@plt>
lea 0xba5(%rip),%rsi
mov %rax,%rdi
mov %rax,0x8(%rsp)
callq 1140 <strtok@plt>
movl $0xa,0x10(%rsp)
test %rax,%rax
je 14da <func0+0xba>
mov %rax,%r15
lea 0xb81(%rip),%r13
nopl 0x0(%rax,%rax,1)
test %ebp,%ebp
je 153e <func0+0x11e>
lea -0x1(%rbp),%eax
mov %r12,%r14
shl $0x4,%rax
lea 0x10(%r12,%rax,1),%rbx
jmp 14b1 <func0+0x91>
nopl 0x0(%rax)
add $0x10,%r14
cmp %rbx,%r14
je 1520 <func0+0x100>
mov (%r14),%rdi
mov %r15,%rsi
callq 1110 <strcmp@plt>
test %eax,%eax
jne 14a8 <func0+0x88>
addl $0x1,0x8(%r14)
mov %r13,%rsi
xor %edi,%edi
callq 1140 <strtok@plt>
mov %rax,%r15
test %rax,%rax
jne 1488 <func0+0x68>
movslq %ebp,%r13
mov 0x8(%rsp),%rdi
callq 10d0 <free@plt>
mov %r13,%rsi
mov %r12,%rdi
mov $0x10,%edx
lea -0xe6(%rip),%rcx
callq 10e0 <qsort@plt>
mov 0x14(%rsp),%eax
cmp %ebp,%eax
cmovle %eax,%ebp
mov 0x18(%rsp),%rax
mov %ebp,(%rax)
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
cmp %ebp,0x10(%rsp)
jg 153e <func0+0x11e>
shll 0x10(%rsp)
movslq 0x10(%rsp),%rsi
mov %r12,%rdi
shl $0x4,%rsi
callq 1130 <realloc@plt>
mov %rax,%r12
movslq %ebp,%rbx
mov %r15,%rdi
add $0x1,%ebp
callq 1150 <strdup@plt>
shl $0x4,%rbx
add %r12,%rbx
mov %rax,(%rbx)
movl $0x1,0x8(%rbx)
jmpq 14c5 <func0+0xa5>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
lea r13, asc_2004; " ,.-"
push r12
push rbp
mov rbp, rdi
mov edi, 0A0h
push rbx
sub rsp, 28h
mov [rsp+58h+var_44], esi
mov [rsp+58h+var_40], rdx
call _malloc
mov rdi, rbp
xor ebp, ebp
mov r12, rax
call _strdup
mov rsi, r13
mov rdi, rax
mov [rsp+58h+var_50], rax
call _strtok
mov [rsp+58h+var_48], 0Ah
mov r15, rax
test rax, rax
jz loc_1552
loc_1470:
test ebp, ebp
jz loc_150E
lea eax, [rbp-1]
mov r14, r12
shl rax, 4
lea rbx, [r12+rax+10h]
jmp short loc_1499
loc_1490:
add r14, 10h
cmp r14, rbx
jz short loc_1508
loc_1499:
mov rdi, [r14]
mov rsi, r15
call _strcmp
test eax, eax
jnz short loc_1490
add dword ptr [r14+8], 1
loc_14AD:
mov rsi, r13
xor edi, edi
call _strtok
mov r15, rax
test rax, rax
jnz short loc_1470
movsxd r13, ebp
loc_14C2:
mov rdi, [rsp+58h+var_50]
call _free
mov rsi, r13
mov rdi, r12
mov edx, 10h
lea rcx, compare
call _qsort
mov eax, [rsp+58h+var_44]
mov rcx, [rsp+58h+var_40]
cmp eax, ebp
cmovg eax, ebp
mov [rcx], eax
add rsp, 28h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1508:
cmp [rsp+58h+var_48], ebp
jle short loc_1538
loc_150E:
movsxd rbx, ebp
mov rdi, r15
add ebp, 1
call _strdup
shl rbx, 4
add rbx, r12
mov [rbx], rax
mov dword ptr [rbx+8], 1
jmp loc_14AD
loc_1538:
shl [rsp+58h+var_48], 1
movsxd rsi, [rsp+58h+var_48]
mov rdi, r12
shl rsi, 4
call _realloc
mov r12, rax
jmp short loc_150E
loc_1552:
xor r13d, r13d
jmp loc_14C2 | long long func0(long long a1, int a2, int *a3)
{
int v3; // ebp
long long v4; // r12
long long v5; // r15
long long v6; // r14
long long v7; // r13
int v8; // eax
long long v10; // rbx
long long v11; // rbx
long long v12; // [rsp+8h] [rbp-50h]
int v13; // [rsp+10h] [rbp-48h]
v3 = 0;
v4 = malloc(160LL);
v12 = strdup(a1);
v13 = 10;
v5 = strtok(v12, " ,.-");
if ( v5 )
{
do
{
if ( v3 )
{
v6 = v4;
do
{
if ( !(unsigned int)strcmp(*(_QWORD *)v6, v5) )
{
++*(_DWORD *)(v6 + 8);
goto LABEL_7;
}
v6 += 16LL;
}
while ( v6 != v4 + 16LL * (unsigned int)(v3 - 1) + 16 );
if ( v13 <= v3 )
{
v13 *= 2;
v4 = realloc(v4, 16LL * v13);
}
}
v10 = v3++;
v11 = v4 + 16 * v10;
*(_QWORD *)v11 = strdup(v5);
*(_DWORD *)(v11 + 8) = 1;
LABEL_7:
v5 = strtok(0LL, " ,.-");
}
while ( v5 );
v7 = v3;
}
else
{
v7 = 0LL;
}
free(v12);
qsort(v4, v7, 16LL, compare);
v8 = a2;
if ( a2 > v3 )
v8 = v3;
*a3 = v8;
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
LEA R13,[0x102004]
PUSH R12
PUSH RBP
MOV RBP,RDI
MOV EDI,0xa0
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RSP + 0x14],ESI
MOV qword ptr [RSP + 0x18],RDX
CALL 0x00101120
MOV RDI,RBP
XOR EBP,EBP
MOV R12,RAX
CALL 0x00101150
MOV RSI,R13
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00101140
MOV dword ptr [RSP + 0x10],0xa
MOV R15,RAX
TEST RAX,RAX
JZ 0x00101552
LAB_00101470:
TEST EBP,EBP
JZ 0x0010150e
LEA EAX,[RBP + -0x1]
MOV R14,R12
SHL RAX,0x4
LEA RBX,[R12 + RAX*0x1 + 0x10]
JMP 0x00101499
LAB_00101490:
ADD R14,0x10
CMP R14,RBX
JZ 0x00101508
LAB_00101499:
MOV RDI,qword ptr [R14]
MOV RSI,R15
CALL 0x00101110
TEST EAX,EAX
JNZ 0x00101490
ADD dword ptr [R14 + 0x8],0x1
LAB_001014ad:
MOV RSI,R13
XOR EDI,EDI
CALL 0x00101140
MOV R15,RAX
TEST RAX,RAX
JNZ 0x00101470
MOVSXD R13,EBP
LAB_001014c2:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001010d0
MOV RSI,R13
MOV RDI,R12
MOV EDX,0x10
LEA RCX,[0x101400]
CALL 0x001010e0
MOV EAX,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RSP + 0x18]
CMP EAX,EBP
CMOVG EAX,EBP
MOV dword ptr [RCX],EAX
ADD RSP,0x28
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101508:
CMP dword ptr [RSP + 0x10],EBP
JLE 0x00101538
LAB_0010150e:
MOVSXD RBX,EBP
MOV RDI,R15
ADD EBP,0x1
CALL 0x00101150
SHL RBX,0x4
ADD RBX,R12
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],0x1
JMP 0x001014ad
LAB_00101538:
SHL dword ptr [RSP + 0x10],0x1
MOVSXD RSI,dword ptr [RSP + 0x10]
MOV RDI,R12
SHL RSI,0x4
CALL 0x00101130
MOV R12,RAX
JMP 0x0010150e
LAB_00101552:
XOR R13D,R13D
JMP 0x001014c2 | int8 * func0(char *param_1,int param_2,int *param_3)
{
int iVar1;
int8 *__ptr;
char *__s;
char *pcVar2;
long lVar3;
int iVar4;
size_t __nmemb;
int8 *puVar5;
int local_48;
__ptr = (int8 *)malloc(0xa0);
iVar4 = 0;
__s = strdup(param_1);
pcVar2 = strtok(__s," ,.-");
local_48 = 10;
if (pcVar2 == (char *)0x0) {
__nmemb = 0;
}
else {
do {
if (iVar4 != 0) {
puVar5 = __ptr;
do {
iVar1 = strcmp((char *)*puVar5,pcVar2);
if (iVar1 == 0) {
*(int *)(puVar5 + 1) = *(int *)(puVar5 + 1) + 1;
goto LAB_001014ad;
}
puVar5 = puVar5 + 2;
} while (puVar5 != __ptr + (ulong)(iVar4 - 1) * 2 + 2);
if (local_48 <= iVar4) {
local_48 = local_48 << 1;
__ptr = (int8 *)realloc(__ptr,(long)local_48 << 4);
}
}
lVar3 = (long)iVar4;
iVar4 = iVar4 + 1;
pcVar2 = strdup(pcVar2);
__ptr[lVar3 * 2] = pcVar2;
*(int4 *)(__ptr + lVar3 * 2 + 1) = 1;
LAB_001014ad:
pcVar2 = strtok((char *)0x0," ,.-");
} while (pcVar2 != (char *)0x0);
__nmemb = (size_t)iVar4;
}
free(__s);
qsort(__ptr,__nmemb,0x10,compare);
if (iVar4 < param_2) {
param_2 = iVar4;
}
*param_3 = param_2;
return __ptr;
} |
7,343 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
typedef struct {
char *word;
int frequency;
} WordFreq;
int compare(const void *a, const void *b) {
WordFreq *wordFreq1 = (WordFreq *)a;
WordFreq *wordFreq2 = (WordFreq *)b;
return wordFreq2->frequency - wordFreq1->frequency;
}
| WordFreq* func0(char *text, int n, int *returnSize) {
char *token;
int size = 0, capacity = 10;
WordFreq *freqs = (WordFreq*)malloc(capacity * sizeof(WordFreq));
char *text_copy = strdup(text);
for (token = strtok(text_copy, " ,.-"); token != NULL; token = strtok(NULL, " ,.-")) {
int found = 0;
for (int i = 0; i < size; ++i) {
if (strcmp(freqs[i].word, token) == 0) {
freqs[i].frequency++;
found = 1;
break;
}
}
if (!found) {
if (size >= capacity) {
capacity *= 2;
freqs = realloc(freqs, capacity * sizeof(WordFreq));
}
freqs[size].word = strdup(token);
freqs[size].frequency = 1;
size++;
}
}
free(text_copy);
qsort(freqs, size, sizeof(WordFreq), compare);
*returnSize = n > size ? size : n;
return freqs;
}
| int main() {
int size;
WordFreq *result;
result = func0("python is a programming language", 1, &size);
assert(size == 1 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 2, &size);
assert(size == 2 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
free(result);
result = func0("python is a programming language", 5, &size);
assert(size == 5 && strcmp(result[0].word, "python") == 0 && result[0].frequency == 1);
for(int i = 0; i < size; i++) {
free(result[i].word);
}
free(result);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
xor %r13d,%r13d
push %r12
push %rbp
mov %rdi,%rbp
mov $0xa0,%edi
push %rbx
sub $0x28,%rsp
mov %esi,0x14(%rsp)
mov %rdx,0x18(%rsp)
callq 1120 <malloc@plt>
mov %rbp,%rdi
xor %ebp,%ebp
mov %rax,%r12
callq 1150 <strdup@plt>
lea 0xbb5(%rip),%rsi
mov %rax,%rdi
mov %rax,0x8(%rsp)
callq 1140 <strtok@plt>
movl $0xa,0x10(%rsp)
test %rax,%rax
je 14ca <func0+0xba>
mov %rax,%r15
lea 0xb91(%rip),%r13
nopl 0x0(%rax,%rax,1)
test %ebp,%ebp
je 152e <func0+0x11e>
lea -0x1(%rbp),%eax
mov %r12,%r14
shl $0x4,%rax
lea 0x10(%r12,%rax,1),%rbx
jmp 14a1 <func0+0x91>
nopl 0x0(%rax)
add $0x10,%r14
cmp %rbx,%r14
je 1510 <func0+0x100>
mov (%r14),%rdi
mov %r15,%rsi
callq 1110 <strcmp@plt>
test %eax,%eax
jne 1498 <func0+0x88>
addl $0x1,0x8(%r14)
mov %r13,%rsi
xor %edi,%edi
callq 1140 <strtok@plt>
mov %rax,%r15
test %rax,%rax
jne 1478 <func0+0x68>
movslq %ebp,%r13
mov 0x8(%rsp),%rdi
callq 10d0 <free@plt>
mov %r13,%rsi
mov %r12,%rdi
mov $0x10,%edx
lea -0xe6(%rip),%rcx
callq 10e0 <qsort@plt>
mov 0x14(%rsp),%eax
cmp %ebp,%eax
cmovle %eax,%ebp
mov 0x18(%rsp),%rax
mov %ebp,(%rax)
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
cmp %ebp,0x10(%rsp)
jg 152e <func0+0x11e>
shll 0x10(%rsp)
movslq 0x10(%rsp),%rsi
mov %r12,%rdi
shl $0x4,%rsi
callq 1130 <realloc@plt>
mov %rax,%r12
movslq %ebp,%rbx
mov %r15,%rdi
add $0x1,%ebp
callq 1150 <strdup@plt>
shl $0x4,%rbx
add %r12,%rbx
mov %rax,(%rbx)
movl $0x1,0x8(%rbx)
jmpq 14b5 <func0+0xa5>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
xor r14d, r14d
push r13
push r12
xor r12d, r12d
push rbp
push rbx
mov rbx, rdi
mov edi, 0A0h; size
sub rsp, 28h
mov [rsp+58h+var_44], esi
mov [rsp+58h+var_40], rdx
call _malloc
mov rdi, rbx; s
mov r13, rax
call _strdup
lea rsi, delim; " ,.-"
mov rdi, rax; s
mov [rsp+58h+ptr], rax
call _strtok
mov [rsp+58h+var_48], 0Ah
mov rbx, rax
test rax, rax
jz short loc_149B
nop dword ptr [rax]
loc_1450:
mov rbp, r12
mov r15, r13
shl rbp, 4
add rbp, r13
test r14d, r14d
jg short loc_1471
jmp short loc_14E0
loc_1468:
add r15, 10h
cmp rbp, r15
jz short loc_14E0
loc_1471:
mov rdi, [r15]; s1
mov rsi, rbx; s2
call _strcmp
test eax, eax
jnz short loc_1468
add dword ptr [r15+8], 1
loc_1485:
lea rsi, delim; " ,.-"
xor edi, edi; s
call _strtok
mov rbx, rax
test rax, rax
jnz short loc_1450
loc_149B:
mov rdi, [rsp+58h+ptr]; ptr
call _free
mov rsi, r12; nmemb
mov rdi, r13; base
mov edx, 10h; size
lea rcx, compare; compar
call _qsort
mov eax, [rsp+58h+var_44]
mov rcx, [rsp+58h+var_40]
cmp eax, r14d
cmovg eax, r14d
mov [rcx], eax
add rsp, 28h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14E0:
mov eax, [rsp+58h+var_48]
cmp r14d, eax
jge short loc_1518
loc_14E9:
shl r12, 4
mov rdi, rbx; s
add r14d, 1
call _strdup
add r12, r13
mov [r12], rax
mov dword ptr [r12+8], 1
movsxd r12, r14d
jmp loc_1485
loc_1518:
shl [rsp+58h+var_48], 1
movsxd rsi, [rsp+58h+var_48]
mov rdi, r13; ptr
shl rsi, 4; size
call _realloc
mov r13, rax
jmp short loc_14E9 | const char ** func0(char *s, int a2, int *a3)
{
int v3; // r14d
size_t v4; // r12
const char **v5; // r13
char *i; // rbx
const char **v7; // r15
int v8; // eax
char *v10; // r12
char *ptr; // [rsp+8h] [rbp-50h]
int v12; // [rsp+10h] [rbp-48h]
v3 = 0;
v4 = 0LL;
v5 = (const char **)malloc(0xA0uLL);
ptr = strdup(s);
v12 = 10;
for ( i = strtok(ptr, " ,.-"); i; i = strtok(0LL, " ,.-") )
{
v7 = v5;
if ( v3 > 0 )
{
while ( strcmp(*v7, i) )
{
v7 += 2;
if ( &v5[2 * v4] == v7 )
goto LABEL_11;
}
++*((_DWORD *)v7 + 2);
}
else
{
LABEL_11:
if ( v3 >= v12 )
{
v12 *= 2;
v5 = (const char **)realloc(v5, 16LL * v12);
}
++v3;
v10 = (char *)&v5[2 * v4];
*(_QWORD *)v10 = strdup(i);
*((_DWORD *)v10 + 2) = 1;
v4 = v3;
}
}
free(ptr);
qsort(v5, v4, 0x10uLL, compare);
v8 = a2;
if ( a2 > v3 )
v8 = v3;
*a3 = v8;
return v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
XOR R14D,R14D
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV EDI,0xa0
SUB RSP,0x28
MOV dword ptr [RSP + 0x14],ESI
MOV qword ptr [RSP + 0x18],RDX
CALL 0x00101120
MOV RDI,RBX
MOV R13,RAX
CALL 0x00101150
LEA RSI,[0x102004]
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00101140
MOV dword ptr [RSP + 0x10],0xa
MOV RBX,RAX
TEST RAX,RAX
JZ 0x0010149b
NOP dword ptr [RAX]
LAB_00101450:
MOV RBP,R12
MOV R15,R13
SHL RBP,0x4
ADD RBP,R13
TEST R14D,R14D
JG 0x00101471
JMP 0x001014e0
LAB_00101468:
ADD R15,0x10
CMP RBP,R15
JZ 0x001014e0
LAB_00101471:
MOV RDI,qword ptr [R15]
MOV RSI,RBX
CALL 0x00101110
TEST EAX,EAX
JNZ 0x00101468
ADD dword ptr [R15 + 0x8],0x1
LAB_00101485:
LEA RSI,[0x102004]
XOR EDI,EDI
CALL 0x00101140
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x00101450
LAB_0010149b:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001010d0
MOV RSI,R12
MOV RDI,R13
MOV EDX,0x10
LEA RCX,[0x1013e0]
CALL 0x001010e0
MOV EAX,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RSP + 0x18]
CMP EAX,R14D
CMOVG EAX,R14D
MOV dword ptr [RCX],EAX
ADD RSP,0x28
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014e0:
MOV EAX,dword ptr [RSP + 0x10]
CMP R14D,EAX
JGE 0x00101518
LAB_001014e9:
SHL R12,0x4
MOV RDI,RBX
ADD R14D,0x1
CALL 0x00101150
ADD R12,R13
MOV qword ptr [R12],RAX
MOV dword ptr [R12 + 0x8],0x1
MOVSXD R12,R14D
JMP 0x00101485
LAB_00101518:
SHL dword ptr [RSP + 0x10],0x1
MOVSXD RSI,dword ptr [RSP + 0x10]
MOV RDI,R13
SHL RSI,0x4
CALL 0x00101130
MOV R13,RAX
JMP 0x001014e9 | int8 * func0(char *param_1,int param_2,int *param_3)
{
int iVar1;
int8 *__ptr;
char *__s;
char *pcVar2;
size_t __nmemb;
int iVar3;
int8 *puVar4;
int local_48;
iVar3 = 0;
__nmemb = 0;
__ptr = (int8 *)malloc(0xa0);
__s = strdup(param_1);
pcVar2 = strtok(__s," ,.-");
local_48 = 10;
do {
if (pcVar2 == (char *)0x0) {
free(__s);
qsort(__ptr,__nmemb,0x10,compare);
if (iVar3 < param_2) {
param_2 = iVar3;
}
*param_3 = param_2;
return __ptr;
}
puVar4 = __ptr;
if (0 < iVar3) {
do {
iVar1 = strcmp((char *)*puVar4,pcVar2);
if (iVar1 == 0) {
*(int *)(puVar4 + 1) = *(int *)(puVar4 + 1) + 1;
goto LAB_00101485;
}
puVar4 = puVar4 + 2;
} while (__ptr + __nmemb * 2 != puVar4);
}
if (local_48 <= iVar3) {
local_48 = local_48 << 1;
__ptr = (int8 *)realloc(__ptr,(long)local_48 << 4);
}
iVar3 = iVar3 + 1;
pcVar2 = strdup(pcVar2);
__ptr[__nmemb * 2] = pcVar2;
*(int4 *)(__ptr + __nmemb * 2 + 1) = 1;
__nmemb = (size_t)iVar3;
LAB_00101485:
pcVar2 = strtok((char *)0x0," ,.-");
} while( true );
} |
7,344 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, count = 0;
int i, j;
// Sort the array
for (i = 0; i < n-1; i++) {
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
// Remove duplicates from the array and find the longest consecutive subsequence
int *v = (int*)malloc(n * sizeof(int));
int size_v = 0;
v[size_v++] = arr[0];
for (i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v[size_v++] = arr[i];
}
}
for (i = 0; i < size_v; i++) {
if (i > 0 && v[i] == v[i - 1] + 1) {
count++;
} else {
count = 1;
}
if (ans < count) {
ans = count;
}
}
free(v);
return ans;
}
| int main() {
assert(func0((int[]){1, 2, 2, 3}, 4) == 3);
assert(func0((int[]){1, 9, 3, 10, 4, 20, 2}, 7) == 4);
assert(func0((int[]){36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}, 11) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 1297 <func0+0xee>
movl $0x0,-0x14(%rbp)
jmpq 1281 <func0+0xd8>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 127d <func0+0xd4>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x2c(%rbp),%eax
sub -0x18(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x14(%rbp)
jl 11e2 <func0+0x39>
addl $0x1,-0x18(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x18(%rbp)
jl 11d6 <func0+0x2d>
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x28(%rbp),%rax
mov (%rax),%eax
mov %eax,(%rdx)
movl $0x1,-0x18(%rbp)
jmp 1354 <func0+0x1ab>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 1350 <func0+0x1a7>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 12ed <func0+0x144>
movl $0x0,-0x18(%rbp)
jmp 13be <func0+0x215>
cmpl $0x0,-0x18(%rbp)
jle 13a5 <func0+0x1fc>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea -0x4(%rdx),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%edx
add $0x1,%edx
cmp %edx,%eax
jne 13a5 <func0+0x1fc>
addl $0x1,-0x1c(%rbp)
jmp 13ac <func0+0x203>
movl $0x1,-0x1c(%rbp)
mov -0x20(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 13ba <func0+0x211>
mov -0x1c(%rbp),%eax
mov %eax,-0x20(%rbp)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 1365 <func0+0x1bc>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x20(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp loc_1297
loc_11D6:
mov [rbp+var_14], 0
jmp loc_1281
loc_11E2:
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_14]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_127D
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_14]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
loc_127D:
add [rbp+var_14], 1
loc_1281:
mov eax, [rbp+var_2C]
sub eax, [rbp+var_18]
sub eax, 1
cmp [rbp+var_14], eax
jl loc_11E2
add [rbp+var_18], 1
loc_1297:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_18], eax
jl loc_11D6
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_10], 0
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rdx], eax
mov [rbp+var_18], 1
jmp short loc_1354
loc_12ED:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_1350
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1350:
add [rbp+var_18], 1
loc_1354:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_12ED
mov [rbp+var_18], 0
jmp short loc_13BD
loc_1365:
cmp [rbp+var_18], 0
jle short loc_13A4
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+ptr]
add rax, rcx
mov eax, [rax]
add eax, 1
cmp edx, eax
jnz short loc_13A4
add [rbp+var_1C], 1
jmp short loc_13AB
loc_13A4:
mov [rbp+var_1C], 1
loc_13AB:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jge short loc_13B9
mov eax, [rbp+var_1C]
mov [rbp+var_20], eax
loc_13B9:
add [rbp+var_18], 1
loc_13BD:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_10]
jl short loc_1365
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_20]
leave
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-20h]
int v5; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int k; // [rsp+18h] [rbp-18h]
int m; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int v10; // [rsp+20h] [rbp-10h]
int v11; // [rsp+24h] [rbp-Ch]
_DWORD *ptr; // [rsp+28h] [rbp-8h]
v4 = 0;
v5 = 0;
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( a1[j] > a1[j + 1] )
{
v11 = a1[j];
a1[j] = a1[j + 1];
a1[j + 1] = v11;
}
}
}
ptr = malloc(4LL * a2);
v10 = 1;
*ptr = *a1;
for ( k = 1; k < a2; ++k )
{
if ( a1[k] != a1[k - 1] )
{
v2 = v10++;
ptr[v2] = a1[k];
}
}
for ( m = 0; m < v10; ++m )
{
if ( m > 0 && ptr[m] == ptr[m - 1] + 1 )
++v5;
else
v5 = 1;
if ( v4 < v5 )
v4 = v5;
}
free(ptr);
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101297
LAB_001011d6:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101281
LAB_001011e2:
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 + -0x14]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010127d
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RDX],EAX
LAB_0010127d:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101281:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JL 0x001011e2
ADD dword ptr [RBP + -0x18],0x1
LAB_00101297:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x18],EAX
JL 0x001011d6
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 + -0x10],0x0
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV dword ptr [RBP + -0x18],0x1
JMP 0x00101354
LAB_001012ed:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x00101350
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
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
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_00101350:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101354:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001012ed
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001013bd
LAB_00101365:
CMP dword ptr [RBP + -0x18],0x0
JLE 0x001013a4
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EAX,0x1
CMP EDX,EAX
JNZ 0x001013a4
ADD dword ptr [RBP + -0x1c],0x1
JMP 0x001013ab
LAB_001013a4:
MOV dword ptr [RBP + -0x1c],0x1
LAB_001013ab:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x001013b9
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x20],EAX
LAB_001013b9:
ADD dword ptr [RBP + -0x18],0x1
LAB_001013bd:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x10]
JL 0x00101365
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101080
MOV EAX,dword ptr [RBP + -0x20]
LEAVE
RET | int func0(int4 *param_1,int param_2)
{
int4 uVar1;
int4 *__ptr;
int local_28;
int local_24;
int local_20;
int local_1c;
int local_18;
local_28 = 0;
local_24 = 0;
for (local_20 = 0; local_20 < param_2 + -1; local_20 = local_20 + 1) {
for (local_1c = 0; local_1c < (param_2 - local_20) + -1; local_1c = local_1c + 1) {
if ((int)param_1[(long)local_1c + 1] < (int)param_1[local_1c]) {
uVar1 = param_1[local_1c];
param_1[local_1c] = param_1[(long)local_1c + 1];
param_1[(long)local_1c + 1] = uVar1;
}
}
}
__ptr = (int4 *)malloc((long)param_2 << 2);
local_18 = 1;
*__ptr = *param_1;
for (local_20 = 1; local_20 < param_2; local_20 = local_20 + 1) {
if (param_1[local_20] != param_1[(long)local_20 + -1]) {
__ptr[local_18] = param_1[local_20];
local_18 = local_18 + 1;
}
}
for (local_20 = 0; local_20 < local_18; local_20 = local_20 + 1) {
if ((local_20 < 1) || (__ptr[local_20] != __ptr[(long)local_20 + -1] + 1)) {
local_24 = 1;
}
else {
local_24 = local_24 + 1;
}
if (local_28 < local_24) {
local_28 = local_24;
}
}
free(__ptr);
return local_28;
} |
7,345 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, count = 0;
int i, j;
// Sort the array
for (i = 0; i < n-1; i++) {
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
// Remove duplicates from the array and find the longest consecutive subsequence
int *v = (int*)malloc(n * sizeof(int));
int size_v = 0;
v[size_v++] = arr[0];
for (i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v[size_v++] = arr[i];
}
}
for (i = 0; i < size_v; i++) {
if (i > 0 && v[i] == v[i - 1] + 1) {
count++;
} else {
count = 1;
}
if (ans < count) {
ans = count;
}
}
free(v);
return ans;
}
| int main() {
assert(func0((int[]){1, 2, 2, 3}, 4) == 3);
assert(func0((int[]){1, 9, 3, 10, 4, 20, 2}, 7) == 4);
assert(func0((int[]){36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}, 11) == 5);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
lea -0x1(%rsi),%edi
test %edi,%edi
jle 11f3 <func0+0x4a>
lea 0x4(%rbx),%r8
jmp 11e3 <func0+0x3a>
add $0x4,%rax
cmp %rsi,%rax
je 11de <func0+0x35>
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 11c5 <func0+0x1c>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
jmp 11c5 <func0+0x1c>
sub $0x1,%edi
je 11f3 <func0+0x4a>
test %edi,%edi
jle 11de <func0+0x35>
mov %rbx,%rax
lea -0x1(%rdi),%edx
lea (%r8,%rdx,4),%rsi
jmp 11ce <func0+0x25>
movslq %ebp,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rbx),%edx
mov %edx,(%rax)
cmp $0x1,%ebp
jle 124a <func0+0xa1>
mov %rbx,%rdx
lea -0x2(%rbp),%ecx
lea 0x4(%rbx,%rcx,4),%r8
mov $0x1,%esi
jmp 1223 <func0+0x7a>
add $0x4,%rdx
cmp %r8,%rdx
je 1235 <func0+0x8c>
mov 0x4(%rdx),%ecx
cmp (%rdx),%ecx
je 121a <func0+0x71>
movslq %esi,%rdi
mov %ecx,(%rax,%rdi,4)
lea 0x1(%rsi),%esi
jmp 121a <func0+0x71>
test %esi,%esi
jle 127d <func0+0xd4>
mov $0x0,%edx
mov $0x0,%ecx
mov $0x0,%ebx
jmp 1263 <func0+0xba>
mov $0x1,%esi
jmp 1239 <func0+0x90>
mov $0x1,%ecx
cmp %ecx,%ebx
cmovl %ecx,%ebx
add $0x1,%rdx
cmp %edx,%esi
jle 1282 <func0+0xd9>
test %edx,%edx
jle 1251 <func0+0xa8>
mov -0x4(%rax,%rdx,4),%edi
add $0x1,%edi
add $0x1,%ecx
cmp %edi,(%rax,%rdx,4)
je 1256 <func0+0xad>
mov $0x1,%ecx
jmp 1256 <func0+0xad>
mov $0x0,%ebx
mov %rax,%rdi
callq 1080 <free@plt>
mov %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
lea edi, [rsi-1]
test edi, edi
jle short loc_11F3
lea r8, [rbx+4]
jmp short loc_11E3
loc_11C5:
add rax, 4
cmp rax, rsi
jz short loc_11DE
loc_11CE:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_11C5
mov [rax], ecx
mov [rax+4], edx
jmp short loc_11C5
loc_11DE:
sub edi, 1
jz short loc_11F3
loc_11E3:
test edi, edi
jle short loc_11DE
mov rax, rbx
lea edx, [rdi-1]
lea rsi, [r8+rdx*4]
jmp short loc_11CE
loc_11F3:
movsxd rdi, ebp
shl rdi, 2
call _malloc
mov edx, [rbx]
mov [rax], edx
cmp ebp, 1
jle short loc_124A
mov rdx, rbx
lea ecx, [rbp-2]
lea r8, [rbx+rcx*4+4]
mov esi, 1
jmp short loc_1223
loc_121A:
add rdx, 4
cmp rdx, r8
jz short loc_1235
loc_1223:
mov ecx, [rdx+4]
cmp ecx, [rdx]
jz short loc_121A
movsxd rdi, esi
mov [rax+rdi*4], ecx
lea esi, [rsi+1]
jmp short loc_121A
loc_1235:
test esi, esi
jle short loc_127D
loc_1239:
mov edx, 0
mov ecx, 0
mov ebx, 0
jmp short loc_1263
loc_124A:
mov esi, 1
jmp short loc_1239
loc_1251:
mov ecx, 1
loc_1256:
cmp ebx, ecx
cmovl ebx, ecx
add rdx, 1
cmp esi, edx
jle short loc_1282
loc_1263:
test edx, edx
jle short loc_1251
mov edi, [rax+rdx*4-4]
add edi, 1
add ecx, 1
cmp [rax+rdx*4], edi
jz short loc_1256
mov ecx, 1
jmp short loc_1256
loc_127D:
mov ebx, 0
loc_1282:
mov rdi, rax
call _free
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn | long long func0(int *a1, int a2)
{
int v4; // edi
int *v5; // rax
int v6; // edx
int v7; // ecx
int *v8; // rax
int *v9; // rdx
int v10; // esi
int v11; // ecx
long long v12; // rdx
int v13; // ecx
int v14; // ebx
v4 = a2 - 1;
if ( a2 - 1 > 0 )
{
do
{
if ( v4 > 0 )
{
v5 = a1;
do
{
v6 = *v5;
v7 = v5[1];
if ( *v5 > v7 )
{
*v5 = v7;
v5[1] = v6;
}
++v5;
}
while ( v5 != &a1[v4 - 1 + 1] );
}
--v4;
}
while ( v4 );
}
v8 = (int *)malloc(4LL * a2);
*v8 = *a1;
if ( a2 <= 1 )
{
v10 = 1;
}
else
{
v9 = a1;
v10 = 1;
do
{
v11 = v9[1];
if ( v11 != *v9 )
v8[v10++] = v11;
++v9;
}
while ( v9 != &a1[a2 - 2 + 1] );
if ( v10 <= 0 )
{
v14 = 0;
goto LABEL_25;
}
}
v12 = 0LL;
v13 = 0;
v14 = 0;
do
{
if ( (int)v12 <= 0 )
{
v13 = 1;
}
else
{
++v13;
if ( v8[v12] != v8[v12 - 1] + 1 )
v13 = 1;
}
if ( v14 < v13 )
v14 = v13;
++v12;
}
while ( v10 > (int)v12 );
LABEL_25:
free(v8);
return (unsigned int)v14;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
LEA EDI,[RSI + -0x1]
TEST EDI,EDI
JLE 0x001011f3
LEA R8,[RBX + 0x4]
JMP 0x001011e3
LAB_001011c5:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x001011de
LAB_001011ce:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x001011c5
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
JMP 0x001011c5
LAB_001011de:
SUB EDI,0x1
JZ 0x001011f3
LAB_001011e3:
TEST EDI,EDI
JLE 0x001011de
MOV RAX,RBX
LEA EDX,[RDI + -0x1]
LEA RSI,[R8 + RDX*0x4]
JMP 0x001011ce
LAB_001011f3:
MOVSXD RDI,EBP
SHL RDI,0x2
CALL 0x001010b0
MOV EDX,dword ptr [RBX]
MOV dword ptr [RAX],EDX
CMP EBP,0x1
JLE 0x0010124a
MOV RDX,RBX
LEA ECX,[RBP + -0x2]
LEA R8,[RBX + RCX*0x4 + 0x4]
MOV ESI,0x1
JMP 0x00101223
LAB_0010121a:
ADD RDX,0x4
CMP RDX,R8
JZ 0x00101235
LAB_00101223:
MOV ECX,dword ptr [RDX + 0x4]
CMP ECX,dword ptr [RDX]
JZ 0x0010121a
MOVSXD RDI,ESI
MOV dword ptr [RAX + RDI*0x4],ECX
LEA ESI,[RSI + 0x1]
JMP 0x0010121a
LAB_00101235:
TEST ESI,ESI
JLE 0x0010127d
LAB_00101239:
MOV EDX,0x0
MOV ECX,0x0
MOV EBX,0x0
JMP 0x00101263
LAB_0010124a:
MOV ESI,0x1
JMP 0x00101239
LAB_00101251:
MOV ECX,0x1
LAB_00101256:
CMP EBX,ECX
CMOVL EBX,ECX
ADD RDX,0x1
CMP ESI,EDX
JLE 0x00101282
LAB_00101263:
TEST EDX,EDX
JLE 0x00101251
MOV EDI,dword ptr [RAX + RDX*0x4 + -0x4]
ADD EDI,0x1
ADD ECX,0x1
CMP dword ptr [RAX + RDX*0x4],EDI
JZ 0x00101256
MOV ECX,0x1
JMP 0x00101256
LAB_0010127d:
MOV EBX,0x0
LAB_00101282:
MOV RDI,RAX
CALL 0x00101080
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
long lVar4;
int iVar5;
int iVar6;
iVar6 = param_2 + -1;
if (0 < iVar6) {
do {
if (0 < iVar6) {
piVar2 = param_1;
do {
iVar5 = *piVar2;
if (piVar2[1] < iVar5) {
*piVar2 = piVar2[1];
piVar2[1] = iVar5;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(iVar6 - 1) + 1);
}
iVar6 = iVar6 + -1;
} while (iVar6 != 0);
}
piVar2 = (int *)malloc((long)param_2 << 2);
*piVar2 = *param_1;
if (param_2 < 2) {
iVar6 = 1;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
iVar6 = 1;
do {
if (param_1[1] != *param_1) {
piVar2[iVar6] = param_1[1];
iVar6 = iVar6 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
if (iVar6 < 1) {
iVar5 = 0;
goto LAB_00101282;
}
}
lVar4 = 0;
iVar3 = 0;
iVar5 = 0;
do {
if ((int)lVar4 < 1) {
iVar3 = 1;
}
else {
iVar3 = iVar3 + 1;
if (piVar2[lVar4] != piVar2[lVar4 + -1] + 1) {
iVar3 = 1;
}
}
if (iVar5 < iVar3) {
iVar5 = iVar3;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar6);
LAB_00101282:
free(piVar2);
return iVar5;
} |
7,346 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, count = 0;
int i, j;
// Sort the array
for (i = 0; i < n-1; i++) {
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
// Remove duplicates from the array and find the longest consecutive subsequence
int *v = (int*)malloc(n * sizeof(int));
int size_v = 0;
v[size_v++] = arr[0];
for (i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v[size_v++] = arr[i];
}
}
for (i = 0; i < size_v; i++) {
if (i > 0 && v[i] == v[i - 1] + 1) {
count++;
} else {
count = 1;
}
if (ans < count) {
ans = count;
}
}
free(v);
return ans;
}
| int main() {
assert(func0((int[]){1, 2, 2, 3}, 4) == 3);
assert(func0((int[]){1, 9, 3, 10, 4, 20, 2}, 7) == 4);
assert(func0((int[]){36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}, 11) == 5);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
lea -0x1(%rsi),%edx
mov %esi,%r12d
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
test %edx,%edx
jle 137f <func0+0x4f>
lea 0x4(%rdi),%rsi
nopl 0x0(%rax)
sub $0x1,%edx
mov %rbx,%rax
mov %rdx,%r8
lea (%rsi,%rdx,4),%rdi
nopl (%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 136e <func0+0x3e>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x4,%rax
cmp %rdi,%rax
jne 1360 <func0+0x30>
mov %r8d,%edx
test %r8d,%r8d
jne 1350 <func0+0x20>
movslq %r12d,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rbx),%edi
mov %rax,%r8
mov %edi,(%rax)
cmp $0x1,%r12d
jle 1415 <func0+0xe5>
lea 0x4(%rbx),%rdx
lea -0x2(%r12),%eax
mov $0x1,%esi
lea (%rdx,%rax,4),%r9
jmp 13b6 <func0+0x86>
nopl 0x0(%rax)
add $0x4,%rdx
mov %ecx,%edi
mov (%rdx),%ecx
cmp %edi,%ecx
je 13c6 <func0+0x96>
movslq %esi,%rax
add $0x1,%esi
mov %ecx,(%r8,%rax,4)
cmp %r9,%rdx
jne 13b0 <func0+0x80>
lea -0x1(%rsi),%eax
mov %r8,%rdx
xor %r12d,%r12d
mov $0x1,%ecx
lea (%r8,%rax,4),%rax
jmp 13f6 <func0+0xc6>
mov (%rdx),%ebx
add $0x1,%ecx
lea 0x1(%rbx),%esi
cmp %esi,0x4(%rdx)
je 13f2 <func0+0xc2>
mov $0x1,%ecx
add $0x4,%rdx
cmp %ecx,%r12d
cmovl %ecx,%r12d
cmp %rdx,%rax
jne 13e0 <func0+0xb0>
mov %r8,%rdi
callq 1080 <free@plt>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
mov $0x1,%esi
jmp 13cb <func0+0x9b>
nopl 0x0(%rax)
| func0:
endbr64
push r12
lea edx, [rsi-1]
mov r12d, esi
push rbx
mov rbx, rdi
sub rsp, 8
test edx, edx
jle short loc_137D
lea r8, [rdi+4]
nop dword ptr [rax+00h]
loc_1350:
sub edx, 1
mov rax, rbx
mov rdi, rdx
lea rsi, [r8+rdx*4]
nop dword ptr [rax]
loc_1360:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_136E
mov [rax], ecx
mov [rax+4], edx
loc_136E:
add rax, 4
cmp rax, rsi
jnz short loc_1360
mov edx, edi
test edi, edi
jnz short loc_1350
loc_137D:
movsxd rdi, r12d
shl rdi, 2
call _malloc
mov esi, [rbx]
mov rdi, rax
mov [rax], esi
cmp r12d, 1
jle short loc_1412
lea rax, [rbx+4]
lea edx, [r12-2]
mov ecx, 1
lea r8, [rax+rdx*4]
jmp short loc_13B6
loc_13B0:
add rax, 4
mov esi, edx
loc_13B6:
mov edx, [rax]
cmp edx, esi
jz short loc_13C5
movsxd rsi, ecx
add ecx, 1
mov [rdi+rsi*4], edx
loc_13C5:
cmp rax, r8
jnz short loc_13B0
loc_13CA:
lea edx, [rcx-1]
mov rax, rdi
xor r12d, r12d
lea rsi, [rdi+rdx*4]
mov edx, 1
jmp short loc_13F6
loc_13E0:
mov ebx, [rax]
add edx, 1
lea ecx, [rbx+1]
cmp [rax+4], ecx
jz short loc_13F2
mov edx, 1
loc_13F2:
add rax, 4
loc_13F6:
cmp r12d, edx
cmovl r12d, edx
cmp rsi, rax
jnz short loc_13E0
call _free
add rsp, 8
mov eax, r12d
pop rbx
pop r12
retn
loc_1412:
mov ecx, 1
jmp short loc_13CA | long long func0(int *a1, int a2)
{
int v2; // edx
_DWORD *v5; // r8
int *v6; // rax
int v7; // edi
int *v8; // rsi
int v9; // edx
int v10; // ecx
int *v11; // rax
int v12; // esi
int *v13; // rdi
int *v14; // rax
int v15; // ecx
int v16; // edx
long long v17; // rsi
int *v18; // rax
int v19; // r12d
int v20; // edx
v2 = a2 - 1;
if ( a2 - 1 > 0 )
{
v5 = a1 + 1;
do
{
v6 = a1;
v7 = v2 - 1;
v8 = &v5[v2 - 1];
do
{
v9 = *v6;
v10 = v6[1];
if ( *v6 > v10 )
{
*v6 = v10;
v6[1] = v9;
}
++v6;
}
while ( v6 != v8 );
v2 = v7;
}
while ( v7 );
}
v11 = (int *)malloc(4LL * a2);
v12 = *a1;
v13 = v11;
*v11 = *a1;
if ( a2 <= 1 )
{
v15 = 1;
}
else
{
v14 = a1 + 1;
v15 = 1;
while ( 1 )
{
v16 = *v14;
if ( *v14 != v12 )
{
v17 = v15++;
v13[v17] = v16;
}
if ( v14 == &a1[a2 - 2 + 1] )
break;
++v14;
v12 = v16;
}
}
v18 = v13;
v19 = 0;
v20 = 1;
while ( 1 )
{
if ( v19 < v20 )
v19 = v20;
if ( &v13[v15 - 1] == v18 )
break;
++v20;
if ( v18[1] != *v18 + 1 )
v20 = 1;
++v18;
}
free();
return (unsigned int)v19;
} | func0:
ENDBR64
PUSH R12
LEA EDX,[RSI + -0x1]
MOV R12D,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
TEST EDX,EDX
JLE 0x0010137d
LEA R8,[RDI + 0x4]
NOP dword ptr [RAX]
LAB_00101350:
SUB EDX,0x1
MOV RAX,RBX
MOV RDI,RDX
LEA RSI,[R8 + RDX*0x4]
NOP dword ptr [RAX]
LAB_00101360:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x0010136e
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
LAB_0010136e:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101360
MOV EDX,EDI
TEST EDI,EDI
JNZ 0x00101350
LAB_0010137d:
MOVSXD RDI,R12D
SHL RDI,0x2
CALL 0x001010b0
MOV ESI,dword ptr [RBX]
MOV RDI,RAX
MOV dword ptr [RAX],ESI
CMP R12D,0x1
JLE 0x00101412
LEA RAX,[RBX + 0x4]
LEA EDX,[R12 + -0x2]
MOV ECX,0x1
LEA R8,[RAX + RDX*0x4]
JMP 0x001013b6
LAB_001013b0:
ADD RAX,0x4
MOV ESI,EDX
LAB_001013b6:
MOV EDX,dword ptr [RAX]
CMP EDX,ESI
JZ 0x001013c5
MOVSXD RSI,ECX
ADD ECX,0x1
MOV dword ptr [RDI + RSI*0x4],EDX
LAB_001013c5:
CMP RAX,R8
JNZ 0x001013b0
LAB_001013ca:
LEA EDX,[RCX + -0x1]
MOV RAX,RDI
XOR R12D,R12D
LEA RSI,[RDI + RDX*0x4]
MOV EDX,0x1
JMP 0x001013f6
LAB_001013e0:
MOV EBX,dword ptr [RAX]
ADD EDX,0x1
LEA ECX,[RBX + 0x1]
CMP dword ptr [RAX + 0x4],ECX
JZ 0x001013f2
MOV EDX,0x1
LAB_001013f2:
ADD RAX,0x4
LAB_001013f6:
CMP R12D,EDX
CMOVL R12D,EDX
CMP RSI,RAX
JNZ 0x001013e0
CALL 0x00101080
ADD RSP,0x8
MOV EAX,R12D
POP RBX
POP R12
RET
LAB_00101412:
MOV ECX,0x1
JMP 0x001013ca | int func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
uint uVar4;
int iVar5;
int iVar6;
long lVar7;
uVar4 = param_2 - 1;
if (0 < (int)uVar4) {
do {
uVar4 = uVar4 - 1;
piVar1 = param_1;
do {
iVar6 = *piVar1;
if (piVar1[1] < iVar6) {
*piVar1 = piVar1[1];
piVar1[1] = iVar6;
}
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)uVar4 + 1);
} while (uVar4 != 0);
}
piVar1 = (int *)malloc((long)param_2 << 2);
iVar6 = *param_1;
*piVar1 = iVar6;
if (param_2 < 2) {
iVar3 = 1;
}
else {
param_1 = param_1 + 1;
iVar3 = 1;
piVar2 = param_1 + (param_2 - 2);
while( true ) {
iVar5 = *param_1;
if (iVar5 != iVar6) {
lVar7 = (long)iVar3;
iVar3 = iVar3 + 1;
piVar1[lVar7] = iVar5;
}
if (param_1 == piVar2) break;
param_1 = param_1 + 1;
iVar6 = iVar5;
}
}
iVar6 = 0;
iVar5 = 1;
piVar2 = piVar1;
while( true ) {
if (iVar6 < iVar5) {
iVar6 = iVar5;
}
if (piVar1 + (iVar3 - 1) == piVar2) break;
iVar5 = iVar5 + 1;
if (piVar2[1] != *piVar2 + 1) {
iVar5 = 1;
}
piVar2 = piVar2 + 1;
}
free(piVar1);
return iVar6;
} |
7,347 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, count = 0;
int i, j;
// Sort the array
for (i = 0; i < n-1; i++) {
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
// Remove duplicates from the array and find the longest consecutive subsequence
int *v = (int*)malloc(n * sizeof(int));
int size_v = 0;
v[size_v++] = arr[0];
for (i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v[size_v++] = arr[i];
}
}
for (i = 0; i < size_v; i++) {
if (i > 0 && v[i] == v[i - 1] + 1) {
count++;
} else {
count = 1;
}
if (ans < count) {
ans = count;
}
}
free(v);
return ans;
}
| int main() {
assert(func0((int[]){1, 2, 2, 3}, 4) == 3);
assert(func0((int[]){1, 9, 3, 10, 4, 20, 2}, 7) == 4);
assert(func0((int[]){36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}, 11) == 5);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%edx
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
test %edx,%edx
jle 133f <func0+0x4f>
lea 0x4(%rdi),%rsi
nopl 0x0(%rax,%rax,1)
sub $0x1,%edx
mov %rbx,%rax
mov %rdx,%r8
lea (%rsi,%rdx,4),%rdi
nopl (%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 132e <func0+0x3e>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x4,%rax
cmp %rdi,%rax
jne 1320 <func0+0x30>
mov %r8d,%edx
test %r8d,%r8d
jne 1310 <func0+0x20>
movslq %ebp,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rbx),%esi
mov %rax,%rdi
mov %esi,(%rax)
cmp $0x1,%ebp
jle 1488 <func0+0x198>
cmp $0x3,%ebp
jle 149b <func0+0x1ab>
lea -0x4(%rbp),%eax
mov $0x1,%ecx
shr %eax
lea 0x5(%rax,%rax,1),%r8
mov $0x3,%eax
mov -0x8(%rbx,%rax,4),%edx
cmp %esi,%edx
je 1389 <func0+0x99>
movslq %ecx,%rsi
add $0x1,%ecx
mov %edx,(%rdi,%rsi,4)
mov -0x4(%rbx,%rax,4),%esi
cmp %esi,%edx
je 139a <func0+0xaa>
movslq %ecx,%rdx
add $0x1,%ecx
mov %esi,(%rdi,%rdx,4)
movslq %eax,%rdx
add $0x2,%rax
cmp %r8,%rax
jne 1378 <func0+0x88>
nopw %cs:0x0(%rax,%rax,1)
mov (%rbx,%rdx,4),%eax
cmp -0x4(%rbx,%rdx,4),%eax
je 13c2 <func0+0xd2>
movslq %ecx,%rsi
add $0x1,%ecx
mov %eax,(%rdi,%rsi,4)
add $0x1,%rdx
cmp %edx,%ebp
jg 13b0 <func0+0xc0>
cmp $0x1,%ecx
je 1488 <func0+0x198>
cmp $0x3,%ecx
jle 14aa <func0+0x1ba>
lea -0x4(%rcx),%eax
mov (%rdi),%r8d
mov $0x1,%esi
mov $0x1,%r12d
shr %eax
mov $0x1,%r10d
lea 0x5(%rax,%rax,1),%r9
mov $0x3,%eax
jmp 1419 <func0+0x129>
cmp %esi,%r12d
movslq %eax,%rdx
cmovl %esi,%r12d
add $0x2,%rax
mov $0x1,%esi
cmp %r9,%rax
je 145d <func0+0x16d>
mov -0x8(%rdi,%rax,4),%edx
add $0x1,%r8d
add $0x1,%esi
cmp %edx,%r8d
mov -0x4(%rdi,%rax,4),%r8d
cmovne %r10d,%esi
add $0x1,%edx
cmp %edx,%r8d
jne 1401 <func0+0x111>
add $0x1,%esi
movslq %eax,%rdx
cmp %esi,%r12d
cmovl %esi,%r12d
add $0x2,%rax
cmp %r9,%rax
jne 1419 <func0+0x129>
jmp 145d <func0+0x16d>
add $0x1,%rdx
cmp %edx,%ecx
jle 147b <func0+0x18b>
mov $0x1,%esi
mov -0x4(%rdi,%rdx,4),%eax
add $0x1,%eax
cmp %eax,(%rdi,%rdx,4)
jne 1450 <func0+0x160>
add $0x1,%esi
cmp %esi,%r12d
cmovl %esi,%r12d
add $0x1,%rdx
cmp %edx,%ecx
jg 145d <func0+0x16d>
callq 1080 <free@plt>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
callq 1080 <free@plt>
mov $0x1,%r12d
pop %rbx
pop %rbp
mov %r12d,%eax
pop %r12
retq
mov $0x1,%ecx
mov $0x1,%edx
jmpq 13b0 <func0+0xc0>
mov $0x1,%edx
mov $0x1,%esi
mov $0x1,%r12d
jmp 145d <func0+0x16d>
nopl 0x0(%rax)
| func0:
endbr64
push rbp
movsxd r9, esi
push rbx
mov rbp, r9
mov rbx, rdi
shl r9, 2
sub rsp, 8
cmp ebp, 1
jle loc_1438
mov edi, ebp
lea r8, [rbx+4]
nop word ptr [rax+rax+00000000h]
loc_1310:
cmp edi, 1
jle loc_1420
lea edx, [rdi-2]
mov rax, rbx
lea rsi, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_1328:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ecx, edx
jle short loc_1346
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_1346:
add rax, 4
cmp rax, rsi
jnz short loc_1328
sub edi, 1
cmp edi, 1
jnz short loc_1310
mov rdi, r9; size
call _malloc
mov ecx, [rbx]
mov rdi, rax; ptr
mov [rax], ecx
cmp ebp, 3
jle loc_144E
lea eax, [rbp-4]
mov edx, 1
shr eax, 1
lea esi, [rax+rax]
mov eax, 3
add rsi, 5
jmp short loc_138A
loc_1387:
mov rax, r8
loc_138A:
mov r8d, [rbx+rax*4-8]
cmp r8d, ecx
jz short loc_139E
movsxd rcx, edx
add edx, 1
mov [rdi+rcx*4], r8d
loc_139E:
mov ecx, [rbx+rax*4-4]
cmp r8d, ecx
jz short loc_13B1
movsxd r8, edx
add edx, 1
mov [rdi+r8*4], ecx
loc_13B1:
lea r8, [rax+2]
cmp rsi, r8
jnz short loc_1387
loc_13BA:
cdqe
nop dword ptr [rax+00h]
loc_13C0:
mov ecx, [rbx+rax*4]
cmp [rbx+rax*4-4], ecx
jz short loc_13D2
movsxd rsi, edx
add edx, 1
mov [rdi+rsi*4], ecx
loc_13D2:
add rax, 1
cmp ebp, eax
jg short loc_13C0
test edx, edx
jle short loc_1428
loc_13DE:
xor eax, eax
xor ecx, ecx
xor ebx, ebx
nop dword ptr [rax+00h]
loc_13E8:
test rax, rax
jz short loc_13FC
mov esi, [rdi+rax*4-4]
add ecx, 1
add esi, 1
cmp [rdi+rax*4], esi
jz short loc_1401
loc_13FC:
mov ecx, 1
loc_1401:
cmp ebx, ecx
cmovl ebx, ecx
add rax, 1
cmp edx, eax
jg short loc_13E8
call _free
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
retn
loc_1420:
sub edi, 1; ptr
jmp loc_1310
loc_1428:
call _free
xor ebx, ebx
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
retn
loc_1438:
mov rdi, r9; size
call _malloc
mov edx, 1
mov rdi, rax
mov eax, [rbx]
mov [rdi], eax
jmp short loc_13DE
loc_144E:
mov edx, 1
mov eax, 1
jmp loc_13BA | long long func0(__m128i *a1, int a2)
{
int i; // edi
__m128i *v5; // rax
__m128i v6; // xmm0
_DWORD *v7; // rax
__int32 v8; // ecx
_DWORD *v9; // rdi
int v10; // edx
long long j; // rax
__int32 v12; // r8d
long long v13; // rcx
long long v14; // r8
__int32 v15; // ecx
long long v16; // rsi
long long v17; // rax
int v18; // ecx
int v19; // ebx
_DWORD *v21; // rax
if ( a2 <= 1 )
{
v21 = malloc(4LL * a2);
v10 = 1;
v9 = v21;
*v21 = a1->m128i_i32[0];
}
else
{
for ( i = a2; i != 1; --i )
{
while ( i <= 1 )
--i;
v5 = a1;
do
{
v6 = _mm_loadl_epi64(v5);
if ( _mm_cvtsi128_si32(v6) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v6, 229)) )
v5->m128i_i64[0] = _mm_shuffle_epi32(v6, 225).m128i_u64[0];
v5 = (__m128i *)((char *)v5 + 4);
}
while ( v5 != (__m128i *)((char *)a1->m128i_i64 + 4 * (unsigned int)(i - 2) + 4) );
}
v7 = malloc(4LL * a2);
v8 = a1->m128i_i32[0];
v9 = v7;
*v7 = a1->m128i_i32[0];
if ( a2 <= 3 )
{
v10 = 1;
LODWORD(j) = 1;
}
else
{
v10 = 1;
for ( j = 3LL; ; j += 2LL )
{
v12 = a1->m128i_i32[j - 2];
if ( v12 != v8 )
{
v13 = v10++;
v9[v13] = v12;
}
v8 = a1->m128i_i32[j - 1];
if ( v12 != v8 )
{
v14 = v10++;
v9[v14] = v8;
}
if ( 2 * ((unsigned int)(a2 - 4) >> 1) + 5LL == j + 2 )
break;
}
}
j = (int)j;
do
{
v15 = a1->m128i_i32[j];
if ( a1->m128i_i32[j - 1] != v15 )
{
v16 = v10++;
v9[v16] = v15;
}
++j;
}
while ( a2 > (int)j );
if ( v10 <= 0 )
{
free(v9);
return 0LL;
}
}
v17 = 0LL;
v18 = 0;
v19 = 0;
do
{
if ( !v17 || (++v18, v9[v17] != v9[v17 - 1] + 1) )
v18 = 1;
if ( v19 < v18 )
v19 = v18;
++v17;
}
while ( v10 > (int)v17 );
free(v9);
return (unsigned int)v19;
} | func0:
ENDBR64
PUSH RBP
MOVSXD R9,ESI
PUSH RBX
MOV RBP,R9
MOV RBX,RDI
SHL R9,0x2
SUB RSP,0x8
CMP EBP,0x1
JLE 0x00101438
MOV EDI,EBP
LEA R8,[RBX + 0x4]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101310:
CMP EDI,0x1
JLE 0x00101420
LEA EDX,[RDI + -0x2]
MOV RAX,RBX
LEA RSI,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101328:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x00101346
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_00101346:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101328
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x00101310
MOV RDI,R9
CALL 0x001010b0
MOV ECX,dword ptr [RBX]
MOV RDI,RAX
MOV dword ptr [RAX],ECX
CMP EBP,0x3
JLE 0x0010144e
LEA EAX,[RBP + -0x4]
MOV EDX,0x1
SHR EAX,0x1
LEA ESI,[RAX + RAX*0x1]
MOV EAX,0x3
ADD RSI,0x5
JMP 0x0010138a
LAB_00101387:
MOV RAX,R8
LAB_0010138a:
MOV R8D,dword ptr [RBX + RAX*0x4 + -0x8]
CMP R8D,ECX
JZ 0x0010139e
MOVSXD RCX,EDX
ADD EDX,0x1
MOV dword ptr [RDI + RCX*0x4],R8D
LAB_0010139e:
MOV ECX,dword ptr [RBX + RAX*0x4 + -0x4]
CMP R8D,ECX
JZ 0x001013b1
MOVSXD R8,EDX
ADD EDX,0x1
MOV dword ptr [RDI + R8*0x4],ECX
LAB_001013b1:
LEA R8,[RAX + 0x2]
CMP RSI,R8
JNZ 0x00101387
LAB_001013ba:
CDQE
NOP dword ptr [RAX]
LAB_001013c0:
MOV ECX,dword ptr [RBX + RAX*0x4]
CMP dword ptr [RBX + RAX*0x4 + -0x4],ECX
JZ 0x001013d2
MOVSXD RSI,EDX
ADD EDX,0x1
MOV dword ptr [RDI + RSI*0x4],ECX
LAB_001013d2:
ADD RAX,0x1
CMP EBP,EAX
JG 0x001013c0
TEST EDX,EDX
JLE 0x00101428
LAB_001013de:
XOR EAX,EAX
XOR ECX,ECX
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_001013e8:
TEST RAX,RAX
JZ 0x001013fc
MOV ESI,dword ptr [RDI + RAX*0x4 + -0x4]
ADD ECX,0x1
ADD ESI,0x1
CMP dword ptr [RDI + RAX*0x4],ESI
JZ 0x00101401
LAB_001013fc:
MOV ECX,0x1
LAB_00101401:
CMP EBX,ECX
CMOVL EBX,ECX
ADD RAX,0x1
CMP EDX,EAX
JG 0x001013e8
CALL 0x00101080
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
RET
LAB_00101420:
SUB EDI,0x1
JMP 0x00101310
LAB_00101428:
CALL 0x00101080
XOR EBX,EBX
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
RET
LAB_00101438:
MOV RDI,R9
CALL 0x001010b0
MOV EDX,0x1
MOV RDI,RAX
MOV EAX,dword ptr [RBX]
MOV dword ptr [RDI],EAX
JMP 0x001013de
LAB_0010144e:
MOV EDX,0x1
MOV EAX,0x1
JMP 0x001013ba | int func0(int *param_1,int param_2)
{
int *piVar1;
long lVar2;
int iVar3;
long lVar4;
int iVar5;
int iVar6;
iVar5 = param_2;
if (param_2 < 2) {
piVar1 = (int *)malloc((long)param_2 << 2);
iVar5 = 1;
*piVar1 = *param_1;
}
else {
do {
for (; iVar5 < 2; iVar5 = iVar5 + -1) {
}
piVar1 = param_1;
do {
iVar6 = (int)*(int8 *)piVar1;
iVar3 = (int)((ulong)*(int8 *)piVar1 >> 0x20);
if (iVar3 < iVar6) {
*(ulong *)piVar1 = CONCAT44(iVar6,iVar3);
}
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)(iVar5 - 2) + 1);
iVar5 = iVar5 + -1;
} while (iVar5 != 1);
piVar1 = (int *)malloc((long)param_2 << 2);
iVar6 = *param_1;
*piVar1 = iVar6;
if (param_2 < 4) {
iVar5 = 1;
lVar2 = 1;
}
else {
iVar5 = 1;
lVar4 = 3;
do {
lVar2 = lVar4;
iVar3 = param_1[lVar2 + -2];
if (iVar3 != iVar6) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar1[lVar4] = iVar3;
}
iVar6 = param_1[lVar2 + -1];
if (iVar3 != iVar6) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar1[lVar4] = iVar6;
}
lVar4 = lVar2 + 2;
} while ((ulong)(param_2 - 4U & 0xfffffffe) + 5 != lVar2 + 2);
}
lVar2 = (long)(int)lVar2;
do {
if (param_1[lVar2 + -1] != param_1[lVar2]) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar1[lVar4] = param_1[lVar2];
}
lVar2 = lVar2 + 1;
} while ((int)lVar2 < param_2);
if (iVar5 < 1) {
free(piVar1);
return 0;
}
}
lVar2 = 0;
iVar3 = 0;
iVar6 = 0;
do {
if ((lVar2 == 0) || (iVar3 = iVar3 + 1, piVar1[lVar2] != piVar1[lVar2 + -1] + 1)) {
iVar3 = 1;
}
if (iVar6 < iVar3) {
iVar6 = iVar3;
}
lVar2 = lVar2 + 1;
} while ((int)lVar2 < iVar5);
free(piVar1);
return iVar6;
} |
7,348 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
bool is_palindrome(const char* text) {
int length = strlen(text);
for (int i = 0; i < length / 2; i++) {
if (text[i] != text[length - 1 - i]) {
return false;
}
}
return true;
}
| int func0(const char *texts[], int size, const char* result[]) {
int count = 0;
for (int i = 0; i < size; i++) {
if (is_palindrome(texts[i])) {
result[count++] = texts[i];
}
}
return count;
}
| int main() {
const char* input1[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
const char* expected1[] = {"php", "aaa"};
const char* results1[6];
int count1 = func0(input1, 6, results1);
assert(count1 == 2);
for (int i = 0; i < count1; i++) {
assert(strcmp(results1[i], expected1[i]) == 0);
}
const char* input2[] = {"abcd", "Python", "abba", "aba"};
const char* expected2[] = {"abba", "aba"};
const char* results2[4];
int count2 = func0(input2, 4, results2);
assert(count2 == 2);
for (int i = 0; i < count2; i++) {
assert(strcmp(results2[i], expected2[i]) == 0);
}
const char* input3[] = {"abcd", "abbccbba", "abba", "aba"};
const char* expected3[] = {"abbccbba", "abba", "aba"};
const char* results3[4];
int count3 = func0(input3, 4, results3);
assert(count3 == 3);
for (int i = 0; i < count3; i++) {
assert(strcmp(results3[i], expected3[i]) == 0);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 12a1 <func0+0x83>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 11a9 <is_palindrome>
test %al,%al
je 129d <func0+0x7f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1245 <func0+0x27>
mov -0x8(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_12A1
loc_1245:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rdi, rax
call is_palindrome
test al, al
jz short loc_129D
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rdx, rax
mov rax, [rcx]
mov [rdx], rax
loc_129D:
add [rbp+var_4], 1
loc_12A1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1245
mov eax, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2, long long a3)
{
int v3; // eax
unsigned int v6; // [rsp+28h] [rbp-8h]
int i; // [rsp+2Ch] [rbp-4h]
v6 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (unsigned __int8)is_palindrome(*(_QWORD *)(8LL * i + a1)) )
{
v3 = v6++;
*(_QWORD *)(a3 + 8LL * v3) = *(_QWORD *)(8LL * i + a1);
}
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012a1
LAB_00101245:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001011a9
TEST AL,AL
JZ 0x0010129d
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
LAB_0010129d:
ADD dword ptr [RBP + -0x4],0x1
LAB_001012a1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101245
MOV EAX,dword ptr [RBP + -0x8]
LEAVE
RET | int func0(long param_1,int param_2,long param_3)
{
char cVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
cVar1 = is_palindrome(*(int8 *)(param_1 + (long)local_c * 8));
if (cVar1 != '\0') {
*(int8 *)((long)local_10 * 8 + param_3) = *(int8 *)((long)local_c * 8 + param_1);
local_10 = local_10 + 1;
}
}
return local_10;
} |
7,349 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
bool is_palindrome(const char* text) {
int length = strlen(text);
for (int i = 0; i < length / 2; i++) {
if (text[i] != text[length - 1 - i]) {
return false;
}
}
return true;
}
| int func0(const char *texts[], int size, const char* result[]) {
int count = 0;
for (int i = 0; i < size; i++) {
if (is_palindrome(texts[i])) {
result[count++] = texts[i];
}
}
return count;
}
| int main() {
const char* input1[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
const char* expected1[] = {"php", "aaa"};
const char* results1[6];
int count1 = func0(input1, 6, results1);
assert(count1 == 2);
for (int i = 0; i < count1; i++) {
assert(strcmp(results1[i], expected1[i]) == 0);
}
const char* input2[] = {"abcd", "Python", "abba", "aba"};
const char* expected2[] = {"abba", "aba"};
const char* results2[4];
int count2 = func0(input2, 4, results2);
assert(count2 == 2);
for (int i = 0; i < count2; i++) {
assert(strcmp(results2[i], expected2[i]) == 0);
}
const char* input3[] = {"abcd", "abbccbba", "abba", "aba"};
const char* expected3[] = {"abbccbba", "abba", "aba"};
const char* results3[4];
int count3 = func0(input3, 4, results3);
assert(count3 == 3);
for (int i = 0; i < count3; i++) {
assert(strcmp(results3[i], expected3[i]) == 0);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 1235 <func0+0x4c>
mov %rdx,%r14
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r13
mov $0x0,%r12d
jmp 1218 <func0+0x2f>
add $0x8,%rbx
cmp %r13,%rbx
je 123b <func0+0x52>
mov (%rbx),%rbp
mov %rbp,%rdi
callq 1189 <is_palindrome>
test %al,%al
je 120f <func0+0x26>
movslq %r12d,%rax
mov %rbp,(%r14,%rax,8)
lea 0x1(%r12),%r12d
jmp 120f <func0+0x26>
mov $0x0,%r12d
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
test esi, esi
jle short loc_1246
mov r14, rdx
mov rbx, rdi
lea eax, [rsi-1]
lea r13, [rdi+rax*8+8]
mov r12d, 0
jmp short loc_1229
loc_1220:
add rbx, 8
cmp rbx, r13
jz short loc_124C
loc_1229:
mov rbp, [rbx]
mov rdi, rbp
call is_palindrome
test al, al
jz short loc_1220
movsxd rax, r12d
mov [r14+rax*8], rbp
lea r12d, [r12+1]
jmp short loc_1220
loc_1246:
mov r12d, 0
loc_124C:
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(_QWORD *a1, int a2, long long a3)
{
_QWORD *v4; // rbx
unsigned int v5; // r12d
long long v6; // rbp
if ( a2 <= 0 )
{
return 0;
}
else
{
v4 = a1;
v5 = 0;
do
{
v6 = *v4;
if ( (unsigned __int8)is_palindrome(*v4) )
*(_QWORD *)(a3 + 8LL * (int)v5++) = v6;
++v4;
}
while ( v4 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x00101246
MOV R14,RDX
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R13,[RDI + RAX*0x8 + 0x8]
MOV R12D,0x0
JMP 0x00101229
LAB_00101220:
ADD RBX,0x8
CMP RBX,R13
JZ 0x0010124c
LAB_00101229:
MOV RBP,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001011a9
TEST AL,AL
JZ 0x00101220
MOVSXD RAX,R12D
MOV qword ptr [R14 + RAX*0x8],RBP
LEA R12D,[R12 + 0x1]
JMP 0x00101220
LAB_00101246:
MOV R12D,0x0
LAB_0010124c:
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int func0(int8 *param_1,int param_2,long param_3)
{
int8 *puVar1;
int8 uVar2;
char cVar3;
int iVar4;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0;
do {
uVar2 = *param_1;
cVar3 = is_palindrome(uVar2);
if (cVar3 != '\0') {
*(int8 *)(param_3 + (long)iVar4 * 8) = uVar2;
iVar4 = iVar4 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar4;
} |
7,350 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
bool is_palindrome(const char* text) {
int length = strlen(text);
for (int i = 0; i < length / 2; i++) {
if (text[i] != text[length - 1 - i]) {
return false;
}
}
return true;
}
| int func0(const char *texts[], int size, const char* result[]) {
int count = 0;
for (int i = 0; i < size; i++) {
if (is_palindrome(texts[i])) {
result[count++] = texts[i];
}
}
return count;
}
| int main() {
const char* input1[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
const char* expected1[] = {"php", "aaa"};
const char* results1[6];
int count1 = func0(input1, 6, results1);
assert(count1 == 2);
for (int i = 0; i < count1; i++) {
assert(strcmp(results1[i], expected1[i]) == 0);
}
const char* input2[] = {"abcd", "Python", "abba", "aba"};
const char* expected2[] = {"abba", "aba"};
const char* results2[4];
int count2 = func0(input2, 4, results2);
assert(count2 == 2);
for (int i = 0; i < count2; i++) {
assert(strcmp(results2[i], expected2[i]) == 0);
}
const char* input3[] = {"abcd", "abbccbba", "abba", "aba"};
const char* expected3[] = {"abbccbba", "abba", "aba"};
const char* results3[4];
int count3 = func0(input3, 4, results3);
assert(count3 == 3);
for (int i = 0; i < count3; i++) {
assert(strcmp(results3[i], expected3[i]) == 0);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 1530 <func0+0x60>
lea -0x1(%rsi),%eax
mov %rdx,%r13
mov %rdi,%rbx
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%r14
nopl 0x0(%rax)
mov (%rbx),%rbp
mov %rbp,%rdi
callq 1470 <is_palindrome>
test %al,%al
je 1513 <func0+0x43>
movslq %r12d,%rax
add $0x1,%r12d
mov %rbp,0x0(%r13,%rax,8)
add $0x8,%rbx
cmp %r14,%rbx
jne 14f8 <func0+0x28>
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
pop %rbx
pop %rbp
mov %r12d,%eax
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
test esi, esi
jle loc_1547
lea eax, [rsi-1]
mov rbp, rdx
mov r13, rdi
xor r12d, r12d
lea rbx, [rdi+rax*8+8]
nop dword ptr [rax]
loc_14D8:
mov r14, [r13+0]
mov rdi, r14
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_1530
sub eax, 1
xor edx, edx
cdqe
add rax, r14
jmp short loc_150C
loc_1500:
add rdx, 1
sub rax, 1
cmp ecx, edx
jle short loc_1530
loc_150C:
movzx esi, byte ptr [rax]
cmp [r14+rdx], sil
jz short loc_1500
add r13, 8
cmp r13, rbx
jnz short loc_14D8
loc_151E:
pop rbx
mov eax, r12d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1530:
movsxd rax, r12d
add r13, 8
add r12d, 1
mov [rbp+rax*8+0], r14
cmp r13, rbx
jnz short loc_14D8
jmp short loc_151E
loc_1547:
xor r12d, r12d
pop rbx
pop rbp
mov eax, r12d
pop r12
pop r13
pop r14
retn | long long func0(_QWORD *a1, int a2, long long a3)
{
_QWORD *v4; // r13
unsigned int v5; // r12d
long long v6; // rbx
long long v7; // r14
int v8; // eax
int v9; // ecx
long long v10; // rdx
_BYTE *v11; // rax
long long v13; // rax
if ( a2 <= 0 )
return 0LL;
v4 = a1;
v5 = 0;
v6 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
do
{
while ( 1 )
{
v7 = *v4;
v8 = strlen(*v4);
v9 = v8 / 2;
if ( v8 > 1 )
break;
LABEL_9:
v13 = (int)v5;
++v4;
++v5;
*(_QWORD *)(a3 + 8 * v13) = v7;
if ( v4 == (_QWORD *)v6 )
return v5;
}
v10 = 0LL;
v11 = (_BYTE *)(v7 + v8 - 1);
while ( *(_BYTE *)(v7 + v10) == *v11 )
{
++v10;
--v11;
if ( v9 <= (int)v10 )
goto LABEL_9;
}
++v4;
}
while ( v4 != (_QWORD *)v6 );
return v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x00101547
LEA EAX,[RSI + -0x1]
MOV RBP,RDX
MOV R13,RDI
XOR R12D,R12D
LEA RBX,[RDI + RAX*0x8 + 0x8]
NOP dword ptr [RAX]
LAB_001014d8:
MOV R14,qword ptr [R13]
MOV RDI,R14
CALL 0x00101080
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x00101530
SUB EAX,0x1
XOR EDX,EDX
CDQE
ADD RAX,R14
JMP 0x0010150c
LAB_00101500:
ADD RDX,0x1
SUB RAX,0x1
CMP ECX,EDX
JLE 0x00101530
LAB_0010150c:
MOVZX ESI,byte ptr [RAX]
CMP byte ptr [R14 + RDX*0x1],SIL
JZ 0x00101500
ADD R13,0x8
CMP R13,RBX
JNZ 0x001014d8
LAB_0010151e:
POP RBX
MOV EAX,R12D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101530:
MOVSXD RAX,R12D
ADD R13,0x8
ADD R12D,0x1
MOV qword ptr [RBP + RAX*0x8],R14
CMP R13,RBX
JNZ 0x001014d8
JMP 0x0010151e
LAB_00101547:
XOR R12D,R12D
POP RBX
POP RBP
MOV EAX,R12D
POP R12
POP R13
POP R14
RET | int func0(int8 *param_1,int param_2,long param_3)
{
int8 *puVar1;
char *__s;
int iVar2;
size_t sVar3;
char *pcVar4;
long lVar5;
int iVar6;
if (param_2 < 1) {
return 0;
}
iVar6 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
__s = (char *)*param_1;
sVar3 = strlen(__s);
iVar2 = (int)sVar3;
if (1 < iVar2) {
lVar5 = 0;
pcVar4 = __s + (iVar2 + -1);
do {
if (__s[lVar5] != *pcVar4) goto joined_r0x0010151c;
lVar5 = lVar5 + 1;
pcVar4 = pcVar4 + -1;
} while ((int)lVar5 < (int)(((uint)(sVar3 >> 0x1f) & 1) + iVar2) >> 1);
}
lVar5 = (long)iVar6;
iVar6 = iVar6 + 1;
*(char **)(param_3 + lVar5 * 8) = __s;
joined_r0x0010151c:
param_1 = param_1 + 1;
if (param_1 == puVar1) {
return iVar6;
}
} while( true );
} |
7,351 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
bool is_palindrome(const char* text) {
int length = strlen(text);
for (int i = 0; i < length / 2; i++) {
if (text[i] != text[length - 1 - i]) {
return false;
}
}
return true;
}
| int func0(const char *texts[], int size, const char* result[]) {
int count = 0;
for (int i = 0; i < size; i++) {
if (is_palindrome(texts[i])) {
result[count++] = texts[i];
}
}
return count;
}
| int main() {
const char* input1[] = {"php", "res", "Python", "abcd", "Java", "aaa"};
const char* expected1[] = {"php", "aaa"};
const char* results1[6];
int count1 = func0(input1, 6, results1);
assert(count1 == 2);
for (int i = 0; i < count1; i++) {
assert(strcmp(results1[i], expected1[i]) == 0);
}
const char* input2[] = {"abcd", "Python", "abba", "aba"};
const char* expected2[] = {"abba", "aba"};
const char* results2[4];
int count2 = func0(input2, 4, results2);
assert(count2 == 2);
for (int i = 0; i < count2; i++) {
assert(strcmp(results2[i], expected2[i]) == 0);
}
const char* input3[] = {"abcd", "abbccbba", "abba", "aba"};
const char* expected3[] = {"abbccbba", "abba", "aba"};
const char* results3[4];
int count3 = func0(input3, 4, results3);
assert(count3 == 3);
for (int i = 0; i < count3; i++) {
assert(strcmp(results3[i], expected3[i]) == 0);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 15a0 <func0+0xa0>
lea -0x1(%rsi),%eax
mov %rdx,%rbp
mov %rdi,%r13
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%rbx
nopl (%rax)
mov 0x0(%r13),%r14
mov %r14,%rdi
callq 1080 <strlen@plt>
mov %eax,%edx
shr $0x1f,%edx
add %eax,%edx
sar %edx
cmp $0x1,%eax
jle 1580 <func0+0x80>
sub $0x1,%eax
xor %ecx,%ecx
cltq
add %r14,%rax
jmp 155c <func0+0x5c>
xchg %ax,%ax
add $0x1,%rcx
sub $0x1,%rax
cmp %ecx,%edx
jle 1580 <func0+0x80>
movzbl (%rax),%esi
cmp %sil,(%r14,%rcx,1)
je 1550 <func0+0x50>
add $0x8,%r13
cmp %r13,%rbx
jne 1528 <func0+0x28>
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
movslq %r12d,%rax
add $0x8,%r13
add $0x1,%r12d
mov %r14,0x0(%rbp,%rax,8)
cmp %r13,%rbx
jne 1528 <func0+0x28>
jmp 156e <func0+0x6e>
nopw 0x0(%rax,%rax,1)
xor %r12d,%r12d
pop %rbx
pop %rbp
mov %r12d,%eax
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
test esi, esi
jle loc_1595
movsxd rsi, esi
mov r12, rdx
mov r13, rdi
xor ebx, ebx
lea rbp, [rdi+rsi*8]
nop dword ptr [rax+rax+00h]
loc_1528:
mov r14, [r13+0]
mov rdi, r14; s
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_1580
sub eax, 1
xor edx, edx
cdqe
add rax, r14
jmp short loc_155C
loc_1550:
add rdx, 1
sub rax, 1
cmp ecx, edx
jle short loc_1580
loc_155C:
movzx esi, byte ptr [rax]
cmp [r14+rdx], sil
jz short loc_1550
add r13, 8
cmp rbp, r13
jnz short loc_1528
loc_156E:
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1580:
movsxd rax, ebx
add r13, 8
add ebx, 1
mov [r12+rax*8], r14
cmp rbp, r13
jnz short loc_1528
jmp short loc_156E
loc_1595:
xor ebx, ebx
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(const char **a1, int a2, long long a3)
{
const char **v4; // r13
unsigned int v5; // ebx
const char **v6; // rbp
const char *v7; // r14
int v8; // eax
int v9; // ecx
long long v10; // rdx
const char *v11; // rax
long long v13; // rax
if ( a2 <= 0 )
return 0LL;
v4 = a1;
v5 = 0;
v6 = &a1[a2];
do
{
while ( 1 )
{
v7 = *v4;
v8 = strlen(*v4);
v9 = v8 / 2;
if ( v8 > 1 )
break;
LABEL_9:
v13 = (int)v5;
++v4;
++v5;
*(_QWORD *)(a3 + 8 * v13) = v7;
if ( v6 == v4 )
return v5;
}
v10 = 0LL;
v11 = &v7[v8 - 1];
while ( v7[v10] == *v11 )
{
++v10;
--v11;
if ( v9 <= (int)v10 )
goto LABEL_9;
}
++v4;
}
while ( v6 != v4 );
return v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x00101595
MOVSXD RSI,ESI
MOV R12,RDX
MOV R13,RDI
XOR EBX,EBX
LEA RBP,[RDI + RSI*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101528:
MOV R14,qword ptr [R13]
MOV RDI,R14
CALL 0x00101080
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x00101580
SUB EAX,0x1
XOR EDX,EDX
CDQE
ADD RAX,R14
JMP 0x0010155c
LAB_00101550:
ADD RDX,0x1
SUB RAX,0x1
CMP ECX,EDX
JLE 0x00101580
LAB_0010155c:
MOVZX ESI,byte ptr [RAX]
CMP byte ptr [R14 + RDX*0x1],SIL
JZ 0x00101550
ADD R13,0x8
CMP RBP,R13
JNZ 0x00101528
LAB_0010156e:
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101580:
MOVSXD RAX,EBX
ADD R13,0x8
ADD EBX,0x1
MOV qword ptr [R12 + RAX*0x8],R14
CMP RBP,R13
JNZ 0x00101528
JMP 0x0010156e
LAB_00101595:
XOR EBX,EBX
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int func0(int8 *param_1,int param_2,long param_3)
{
int8 *puVar1;
char *__s;
int iVar2;
size_t sVar3;
char *pcVar4;
long lVar5;
int iVar6;
if (param_2 < 1) {
return 0;
}
iVar6 = 0;
puVar1 = param_1 + param_2;
do {
__s = (char *)*param_1;
sVar3 = strlen(__s);
iVar2 = (int)sVar3;
if (1 < iVar2) {
lVar5 = 0;
pcVar4 = __s + (iVar2 + -1);
do {
if (__s[lVar5] != *pcVar4) goto joined_r0x0010156c;
lVar5 = lVar5 + 1;
pcVar4 = pcVar4 + -1;
} while ((int)lVar5 < (int)(((uint)(sVar3 >> 0x1f) & 1) + iVar2) >> 1);
}
lVar5 = (long)iVar6;
iVar6 = iVar6 + 1;
*(char **)(param_3 + lVar5 * 8) = __s;
joined_r0x0010156c:
param_1 = param_1 + 1;
if (puVar1 == param_1) {
return iVar6;
}
} while( true );
} |
7,352 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int n, int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = n * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[7];
func0(nums1, 3, size1, result1);
int expected1[] = {3, 6, 9, 12, 15, 18, 21};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int nums2[] = {1, 2, 3, 4, 5, 6, 7};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int result2[7];
func0(nums2, 4, size2, result2);
int expected2[] = {4, 8, 12, 16, 20, 24, 28};
for (int i = 0; i < size2; i++) {
assert(result2[i] == expected2[i]);
}
int nums3[] = {1, 2, 3, 4, 5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
int result3[7];
func0(nums3, 10, size3, result3);
int expected3[] = {10, 20, 30, 40, 50, 60, 70};
for (int i = 0; i < size3; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11bd <func0+0x54>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
imul -0x1c(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 1188 <func0+0x1f>
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_28], rcx
mov [rbp+var_4], 0
jmp short loc_11BD
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
imul eax, [rbp+var_1C]
mov [rdx], eax
add [rbp+var_4], 1
loc_11BD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jl short loc_1188
nop
nop
pop rbp
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
unsigned int i; // [rsp+24h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
*(_DWORD *)(4LL * (int)i + a4) = a2 * *(_DWORD *)(4LL * (int)i + a1);
}
return result;
} | 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 qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011bd
LAB_00101188:
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]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
IMUL EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011bd:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x00101188
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int *)(param_4 + (long)local_c * 4) = *(int *)(param_1 + (long)local_c * 4) * param_2;
}
return;
} |
7,353 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int n, int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = n * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[7];
func0(nums1, 3, size1, result1);
int expected1[] = {3, 6, 9, 12, 15, 18, 21};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int nums2[] = {1, 2, 3, 4, 5, 6, 7};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int result2[7];
func0(nums2, 4, size2, result2);
int expected2[] = {4, 8, 12, 16, 20, 24, 28};
for (int i = 0; i < size2; i++) {
assert(result2[i] == expected2[i]);
}
int nums3[] = {1, 2, 3, 4, 5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
int result3[7];
func0(nums3, 10, size3, result3);
int expected3[] = {10, 20, 30, 40, 50, 60, 70};
for (int i = 0; i < size3; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 118f <func0+0x26>
lea -0x1(%rdx),%r8d
mov $0x0,%eax
mov %esi,%edx
imul (%rdi,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %r8,%rdx
jne 117a <func0+0x11>
retq
| func0:
endbr64
test edx, edx
jle short locret_118D
mov edx, edx
mov eax, 0
loc_1178:
mov r8d, esi
imul r8d, [rdi+rax*4]
mov [rcx+rax*4], r8d
add rax, 1
cmp rax, rdx
jnz short loc_1178
locret_118D:
retn | void func0(long long a1, int a2, int a3, long long a4)
{
long long i; // rax
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a1 + 4 * i) * a2;
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x0010118d
MOV EDX,EDX
MOV EAX,0x0
LAB_00101178:
MOV R8D,ESI
IMUL R8D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],R8D
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101178
LAB_0010118d:
RET | void func0(long param_1,int param_2,uint param_3,long param_4)
{
ulong uVar1;
if (0 < (int)param_3) {
uVar1 = 0;
do {
*(int *)(param_4 + uVar1 * 4) = param_2 * *(int *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
return;
} |
7,354 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int n, int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = n * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[7];
func0(nums1, 3, size1, result1);
int expected1[] = {3, 6, 9, 12, 15, 18, 21};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int nums2[] = {1, 2, 3, 4, 5, 6, 7};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int result2[7];
func0(nums2, 4, size2, result2);
int expected2[] = {4, 8, 12, 16, 20, 24, 28};
for (int i = 0; i < size2; i++) {
assert(result2[i] == expected2[i]);
}
int nums3[] = {1, 2, 3, 4, 5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
int result3[7];
func0(nums3, 10, size3, result3);
int expected3[] = {10, 20, 30, 40, 50, 60, 70};
for (int i = 0; i < size3; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 1465 <func0+0x25>
lea -0x1(%rdx),%r8d
xor %eax,%eax
xchg %ax,%ax
mov (%rdi,%rax,4),%edx
imul %esi,%edx
mov %edx,(%rcx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%r8
jne 1450 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
jle short locret_1465
movsxd rdx, edx
xor eax, eax
nop dword ptr [rax]
loc_1450:
mov r8d, [rdi+rax*4]
imul r8d, esi
mov [rcx+rax*4], r8d
add rax, 1
cmp rdx, rax
jnz short loc_1450
locret_1465:
retn | void func0(long long a1, int a2, int a3, long long a4)
{
long long i; // rax
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = a2 * *(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101465
MOVSXD RDX,EDX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101450:
MOV R8D,dword ptr [RDI + RAX*0x4]
IMUL R8D,ESI
MOV dword ptr [RCX + RAX*0x4],R8D
ADD RAX,0x1
CMP RDX,RAX
JNZ 0x00101450
LAB_00101465:
RET | void func0(long param_1,int param_2,int param_3,long param_4)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
*(int *)(param_4 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) * param_2;
lVar1 = lVar1 + 1;
} while (param_3 != lVar1);
}
return;
} |
7,355 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int n, int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = n * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[7];
func0(nums1, 3, size1, result1);
int expected1[] = {3, 6, 9, 12, 15, 18, 21};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int nums2[] = {1, 2, 3, 4, 5, 6, 7};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int result2[7];
func0(nums2, 4, size2, result2);
int expected2[] = {4, 8, 12, 16, 20, 24, 28};
for (int i = 0; i < size2; i++) {
assert(result2[i] == expected2[i]);
}
int nums3[] = {1, 2, 3, 4, 5, 6, 7};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
int result3[7];
func0(nums3, 10, size3, result3);
int expected3[] = {10, 20, 30, 40, 50, 60, 70};
for (int i = 0; i < size3; i++) {
assert(result3[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 1478 <func0+0xe8>
lea 0xf(%rdi),%r8
lea -0x1(%rdx),%eax
sub %rcx,%r8
cmp $0x1e,%r8
jbe 1458 <func0+0xc8>
cmp $0x3,%eax
jbe 1458 <func0+0xc8>
movd %esi,%xmm4
mov %edx,%r8d
xor %eax,%eax
pshufd $0x0,%xmm4,%xmm2
shr $0x2,%r8d
movdqa %xmm2,%xmm3
shl $0x4,%r8
psrlq $0x20,%xmm3
nopl 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm0
movdqu (%rdi,%rax,1),%xmm1
psrlq $0x20,%xmm0
pmuludq %xmm2,%xmm1
pmuludq %xmm3,%xmm0
pshufd $0x8,%xmm1,%xmm1
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
movups %xmm1,(%rcx,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 13e0 <func0+0x50>
mov %edx,%eax
and $0xfffffffc,%eax
test $0x3,%dl
je 1478 <func0+0xe8>
mov %eax,%r8d
mov (%rdi,%r8,4),%r9d
imul %esi,%r9d
mov %r9d,(%rcx,%r8,4)
lea 0x1(%rax),%r8d
cmp %r8d,%edx
jle 1478 <func0+0xe8>
movslq %r8d,%r8
add $0x2,%eax
mov (%rdi,%r8,4),%r9d
imul %esi,%r9d
mov %r9d,(%rcx,%r8,4)
cmp %eax,%edx
jle 1478 <func0+0xe8>
cltq
imul (%rdi,%rax,4),%esi
mov %esi,(%rcx,%rax,4)
retq
nopl 0x0(%rax)
mov %eax,%edx
xor %eax,%eax
nopl 0x0(%rax)
mov (%rdi,%rax,4),%r8d
imul %esi,%r8d
mov %r8d,(%rcx,%rax,4)
mov %rax,%r8
add $0x1,%rax
cmp %rdx,%r8
jne 1460 <func0+0xd0>
retq
nopl 0x0(%rax)
| func0:
endbr64
movsxd rax, edx
mov r8, rcx
test eax, eax
jle short locret_1183
lea edx, [rax-1]
cmp edx, 2
jbe short loc_1166
lea rcx, [rdi+4]
mov rdx, r8
sub rdx, rcx
cmp rdx, 8
ja short loc_1188
loc_1166:
lea rdx, ds:0[rax*4]
xor eax, eax
loc_1170:
mov ecx, [rdi+rax]
imul ecx, esi
mov [r8+rax], ecx
add rax, 4
cmp rdx, rax
jnz short loc_1170
locret_1183:
retn
loc_1188:
movd xmm4, esi
mov ecx, eax
xor edx, edx
pshufd xmm2, xmm4, 0
shr ecx, 2
movdqa xmm3, xmm2
shl rcx, 4
psrlq xmm3, 20h ; ' '
nop dword ptr [rax]
loc_11A8:
movdqu xmm0, xmmword ptr [rdi+rdx]
movdqu xmm1, xmmword ptr [rdi+rdx]
psrlq xmm0, 20h ; ' '
pmuludq xmm1, xmm2
pmuludq xmm0, xmm3
pshufd xmm1, xmm1, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movups xmmword ptr [r8+rdx], xmm1
add rdx, 10h
cmp rdx, rcx
jnz short loc_11A8
mov edx, eax
and edx, 0FFFFFFFCh
test al, 3
jz short locret_1183
mov r9d, edx
mov r10d, [rdi+r9*4]
lea rcx, ds:0[r9*4]
imul r10d, esi
mov [r8+r9*4], r10d
lea r9d, [rdx+1]
cmp eax, r9d
jle locret_1183
mov r9d, [rdi+rcx+4]
add edx, 2
imul r9d, esi
mov [r8+rcx+4], r9d
cmp eax, edx
jle locret_1183
imul esi, [rdi+rcx+8]
mov [r8+rcx+8], esi
retn | long long func0(long long a1, unsigned int a2, int a3, long long a4)
{
long long result; // rax
long long v6; // rdx
long long v7; // rdx
__m128i v8; // xmm2
__m128i v9; // xmm3
unsigned int v10; // edx
long long v11; // rcx
result = a3;
if ( a3 > 0 )
{
if ( (unsigned int)(a3 - 1) > 2 && (unsigned long long)(a4 - (a1 + 4)) > 8 )
{
v7 = 0LL;
v8 = _mm_shuffle_epi32(_mm_cvtsi32_si128(a2), 0);
v9 = _mm_srli_epi64(v8, 0x20u);
do
{
*(__m128i *)(a4 + v7) = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(_mm_loadu_si128((const __m128i *)(a1 + v7)), v8), 8),
_mm_shuffle_epi32(
_mm_mul_epu32(
_mm_srli_epi64(_mm_loadu_si128((const __m128i *)(a1 + v7)), 0x20u),
v9),
8));
v7 += 16LL;
}
while ( v7 != 16LL * ((unsigned int)result >> 2) );
v10 = result & 0xFFFFFFFC;
if ( (result & 3) != 0 )
{
v11 = 4LL * v10;
*(_DWORD *)(a4 + v11) = a2 * *(_DWORD *)(a1 + v11);
if ( (int)result > (int)(v10 + 1) )
{
*(_DWORD *)(a4 + v11 + 4) = a2 * *(_DWORD *)(a1 + v11 + 4);
if ( (int)result > (int)(v10 + 2) )
*(_DWORD *)(a4 + v11 + 8) = *(_DWORD *)(a1 + v11 + 8) * a2;
}
}
}
else
{
v6 = 4LL * a3;
result = 0LL;
do
{
*(_DWORD *)(a4 + result) = a2 * *(_DWORD *)(a1 + result);
result += 4LL;
}
while ( v6 != result );
}
}
return result;
} | func0:
ENDBR64
MOVSXD RAX,EDX
MOV R8,RCX
TEST EAX,EAX
JLE 0x00101183
LEA EDX,[RAX + -0x1]
CMP EDX,0x2
JBE 0x00101166
LEA RCX,[RDI + 0x4]
MOV RDX,R8
SUB RDX,RCX
CMP RDX,0x8
JA 0x00101188
LAB_00101166:
LEA RDX,[RAX*0x4]
XOR EAX,EAX
LAB_00101170:
MOV ECX,dword ptr [RDI + RAX*0x1]
IMUL ECX,ESI
MOV dword ptr [R8 + RAX*0x1],ECX
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x00101170
LAB_00101183:
RET
LAB_00101188:
MOVD XMM4,ESI
MOV ECX,EAX
XOR EDX,EDX
PSHUFD XMM2,XMM4,0x0
SHR ECX,0x2
MOVDQA XMM3,XMM2
SHL RCX,0x4
PSRLQ XMM3,0x20
NOP dword ptr [RAX]
LAB_001011a8:
MOVDQU XMM0,xmmword ptr [RDI + RDX*0x1]
MOVDQU XMM1,xmmword ptr [RDI + RDX*0x1]
PSRLQ XMM0,0x20
PMULUDQ XMM1,XMM2
PMULUDQ XMM0,XMM3
PSHUFD XMM1,XMM1,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVUPS xmmword ptr [R8 + RDX*0x1],XMM1
ADD RDX,0x10
CMP RDX,RCX
JNZ 0x001011a8
MOV EDX,EAX
AND EDX,0xfffffffc
TEST AL,0x3
JZ 0x00101183
MOV R9D,EDX
MOV R10D,dword ptr [RDI + R9*0x4]
LEA RCX,[R9*0x4]
IMUL R10D,ESI
MOV dword ptr [R8 + R9*0x4],R10D
LEA R9D,[RDX + 0x1]
CMP EAX,R9D
JLE 0x00101183
MOV R9D,dword ptr [RDI + RCX*0x1 + 0x4]
ADD EDX,0x2
IMUL R9D,ESI
MOV dword ptr [R8 + RCX*0x1 + 0x4],R9D
CMP EAX,EDX
JLE 0x00101183
IMUL ESI,dword ptr [RDI + RCX*0x1 + 0x8]
MOV dword ptr [R8 + RCX*0x1 + 0x8],ESI
RET | void func0(long param_1,uint param_2,uint param_3,long param_4)
{
int8 *puVar1;
int auVar2 [16];
ulong uVar3;
long lVar4;
uint uVar5;
ulong uVar6;
if (0 < (int)param_3) {
if ((param_3 - 1 < 3) || ((ulong)(param_4 - (param_1 + 4)) < 9)) {
lVar4 = 0;
do {
*(uint *)(param_4 + lVar4) = *(int *)(param_1 + lVar4) * param_2;
lVar4 = lVar4 + 4;
} while ((long)(int)param_3 * 4 - lVar4 != 0);
}
else {
lVar4 = 0;
auVar2._4_4_ = param_2;
auVar2._0_4_ = param_2;
auVar2._8_4_ = param_2;
auVar2._12_4_ = param_2;
do {
uVar6 = ((ulong *)(param_1 + lVar4))[1];
uVar3 = ((ulong *)(param_1 + lVar4))[1];
puVar1 = (int8 *)(param_4 + lVar4);
*puVar1 = CONCAT44((int)((*(ulong *)(param_1 + lVar4) >> 0x20) * (ulong)param_2),
(int)((*(ulong *)(param_1 + lVar4) & 0xffffffff) * (ulong)param_2));
*(int *)(puVar1 + 2) = (int)((uVar3 & 0xffffffff) * (ulong)param_2);
*(int *)((long)puVar1 + 0x14) = (int)((uVar6 >> 0x20) * (auVar2._8_8_ >> 0x20));
lVar4 = lVar4 + 0x10;
} while (lVar4 != (ulong)(param_3 >> 2) << 4);
uVar5 = param_3 & 0xfffffffc;
if (((long)(int)param_3 & 3U) != 0) {
uVar6 = (ulong)uVar5;
lVar4 = uVar6 * 4;
*(uint *)(param_4 + uVar6 * 4) = *(int *)(param_1 + uVar6 * 4) * param_2;
if (((int)(uVar5 + 1) < (int)param_3) &&
(*(uint *)(param_4 + 4 + lVar4) = *(int *)(param_1 + 4 + lVar4) * param_2,
(int)(uVar5 + 2) < (int)param_3)) {
*(uint *)(param_4 + 8 + lVar4) = param_2 * *(int *)(param_1 + 8 + lVar4);
return;
}
}
}
}
return;
} |
7,356 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* monthname2) {
if (strcmp(monthname2, "January") == 0 || strcmp(monthname2, "March") == 0 || strcmp(monthname2, "May") == 0 ||
strcmp(monthname2, "July") == 0 || strcmp(monthname2, "Augest") == 0 || strcmp(monthname2, "October") == 0 ||
strcmp(monthname2, "December") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == 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 121e <func0+0xb5>
mov -0x8(%rbp),%rax
lea 0xe71(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%eax
je 121e <func0+0xb5>
mov -0x8(%rbp),%rax
lea 0xe60(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%eax
je 121e <func0+0xb5>
mov -0x8(%rbp),%rax
lea 0xe4d(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%eax
je 121e <func0+0xb5>
mov -0x8(%rbp),%rax
lea 0xe3b(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%eax
je 121e <func0+0xb5>
mov -0x8(%rbp),%rax
lea 0xe2b(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%eax
je 121e <func0+0xb5>
mov -0x8(%rbp),%rax
lea 0xe1c(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%eax
jne 1225 <func0+0xbc>
mov $0x1,%eax
jmp 122a <func0+0xc1>
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; "January"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz loc_1237
mov rax, [rbp+s1]
lea rdx, aMarch; "March"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz loc_1237
mov rax, [rbp+s1]
lea rdx, aMay; "May"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1237
mov rax, [rbp+s1]
lea rdx, aJuly; "July"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1237
mov rax, [rbp+s1]
lea rdx, aAugest; "Augest"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1237
mov rax, [rbp+s1]
lea rdx, aOctober; "October"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1237
mov rax, [rbp+s1]
lea rdx, aDecember; "December"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_123E
loc_1237:
mov eax, 1
jmp short locret_1243
loc_123E:
mov eax, 0
locret_1243:
leave
retn | _BOOL8 func0(const char *a1)
{
return !strcmp(a1, "January")
|| !strcmp(a1, "March")
|| !strcmp(a1, "May")
|| !strcmp(a1, "July")
|| !strcmp(a1, "Augest")
|| !strcmp(a1, "October")
|| !strcmp(a1, "December");
} | 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 0x00101237
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x10200c]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JZ 0x00101237
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102012]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JZ 0x00101237
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102016]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JZ 0x00101237
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x10201b]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JZ 0x00101237
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102022]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JZ 0x00101237
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x10202a]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JNZ 0x0010123e
LAB_00101237:
MOV EAX,0x1
JMP 0x00101243
LAB_0010123e:
MOV EAX,0x0
LAB_00101243:
LEAVE
RET | int8 func0(char *param_1)
{
int iVar1;
iVar1 = strcmp(param_1,"January");
if ((((iVar1 != 0) && (iVar1 = strcmp(param_1,"March"), iVar1 != 0)) &&
(iVar1 = strcmp(param_1,"May"), iVar1 != 0)) &&
(((iVar1 = strcmp(param_1,"July"), iVar1 != 0 && (iVar1 = strcmp(param_1,"Augest"), iVar1 != 0)
) && ((iVar1 = strcmp(param_1,"October"), iVar1 != 0 &&
(iVar1 = strcmp(param_1,"December"), iVar1 != 0)))))) {
return 0;
}
return 1;
} |
7,357 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* monthname2) {
if (strcmp(monthname2, "January") == 0 || strcmp(monthname2, "March") == 0 || strcmp(monthname2, "May") == 0 ||
strcmp(monthname2, "July") == 0 || strcmp(monthname2, "Augest") == 0 || strcmp(monthname2, "October") == 0 ||
strcmp(monthname2, "December") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
mov $0x8,%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 1233 <func0+0xea>
mov $0x6,%ecx
lea 0xe8c(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
mov $0x1,%ecx
test %dl,%dl
je 1233 <func0+0xea>
mov $0x4,%ecx
lea 0xe6e(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
mov $0x1,%ecx
test %dl,%dl
je 1233 <func0+0xea>
mov $0x5,%ecx
lea 0xe52(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
mov $0x1,%ecx
test %dl,%dl
je 1233 <func0+0xea>
mov $0x7,%ecx
lea 0xe37(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
mov $0x1,%ecx
test %dl,%dl
je 1233 <func0+0xea>
mov $0x8,%ecx
lea 0xe1e(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
mov $0x1,%ecx
test %dl,%dl
je 1233 <func0+0xea>
mov $0x9,%ecx
lea 0xe06(%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, aJanuary; "January"
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz loc_1222
lea rsi, aMarch; "March"
mov rdi, rbx
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz short loc_1222
lea rsi, aMay; "May"
mov rdi, rbx
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz short loc_1222
lea rsi, aJuly; "July"
mov rdi, rbx
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz short loc_1222
lea rsi, aAugest; "Augest"
mov rdi, rbx
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz short loc_1222
lea rsi, aOctober; "October"
mov rdi, rbx
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz short loc_1222
lea rsi, aDecember; "December"
mov rdi, rbx
call _strcmp
test eax, eax
setz al
loc_1222:
pop rbx
retn | bool func0(long long a1)
{
int v1; // edx
bool result; // al
int v3; // edx
int v4; // edx
int v5; // edx
int v6; // edx
int v7; // edx
v1 = strcmp(a1, "January");
result = 1;
if ( v1 )
{
v3 = strcmp(a1, "March");
result = 1;
if ( v3 )
{
v4 = strcmp(a1, "May");
result = 1;
if ( v4 )
{
v5 = strcmp(a1, "July");
result = 1;
if ( v5 )
{
v6 = strcmp(a1, "Augest");
result = 1;
if ( v6 )
{
v7 = strcmp(a1, "October");
result = 1;
if ( v7 )
return (unsigned int)strcmp(a1, "December") == 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 0x00101222
LEA RSI,[0x10200c]
MOV RDI,RBX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x00101222
LEA RSI,[0x102012]
MOV RDI,RBX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x00101222
LEA RSI,[0x102016]
MOV RDI,RBX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x00101222
LEA RSI,[0x10201b]
MOV RDI,RBX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x00101222
LEA RSI,[0x102022]
MOV RDI,RBX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x00101222
LEA RSI,[0x10202a]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
SETZ AL
LAB_00101222:
POP RBX
RET | int8 func0(char *param_1)
{
int iVar1;
int8 uVar2;
int4 extraout_var;
iVar1 = strcmp(param_1,"January");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"March");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"May");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"July");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"Augest");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"October");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"December");
uVar2 = CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),iVar1 == 0);
}
}
}
}
}
}
return uVar2;
} |
7,358 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* monthname2) {
if (strcmp(monthname2, "January") == 0 || strcmp(monthname2, "March") == 0 || strcmp(monthname2, "May") == 0 ||
strcmp(monthname2, "July") == 0 || strcmp(monthname2, "Augest") == 0 || strcmp(monthname2, "October") == 0 ||
strcmp(monthname2, "December") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == true);
return 0;
}
| O2 | c | func0:
endbr64
mov %rdi,%rax
mov $0x8,%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 12c3 <func0+0xd3>
mov $0x6,%ecx
lea 0xde4(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x4,%ecx
lea 0xdcb(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x5,%ecx
lea 0xdb4(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x7,%ecx
lea 0xd9e(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x8,%ecx
lea 0xd8a(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov %rax,%rsi
mov $0x9,%ecx
lea 0xd74(%rip),%rdi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %al
sbb $0x0,%al
test %al,%al
sete %r8b
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
lea rsi, aJanuary; "January"
mov r12d, 1
push rbp
mov rbp, rdi
sub rsp, 8
call _strcmp
test eax, eax
jz short loc_12A8
lea rsi, aMarch; "March"
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_12A8
lea rsi, aMay; "May"
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_12A8
lea rsi, aJuly; "July"
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_12A8
lea rsi, aAugest; "Augest"
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_12A8
lea rsi, aOctober; "October"
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_12A8
lea rsi, aDecember; "December"
mov rdi, rbp
call _strcmp
test eax, eax
setz r12b
loc_12A8:
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, "January")
&& (unsigned int)strcmp(a1, "March")
&& (unsigned int)strcmp(a1, "May")
&& (unsigned int)strcmp(a1, "July")
&& (unsigned int)strcmp(a1, "Augest")
&& (unsigned int)strcmp(a1, "October") )
{
LOBYTE(v1) = (unsigned int)strcmp(a1, "December") == 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 0x001012a8
LEA RSI,[0x10200c]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a8
LEA RSI,[0x102012]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a8
LEA RSI,[0x102016]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a8
LEA RSI,[0x10201b]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a8
LEA RSI,[0x102022]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a8
LEA RSI,[0x10202a]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
SETZ R12B
LAB_001012a8:
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,"January");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"March");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"May");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"July");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"Augest");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"October");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"December");
bVar2 = iVar1 == 0;
}
}
}
}
}
}
return bVar2;
} |
7,359 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* monthname2) {
if (strcmp(monthname2, "January") == 0 || strcmp(monthname2, "March") == 0 || strcmp(monthname2, "May") == 0 ||
strcmp(monthname2, "July") == 0 || strcmp(monthname2, "Augest") == 0 || strcmp(monthname2, "October") == 0 ||
strcmp(monthname2, "December") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == true);
return 0;
}
| O3 | c | func0:
endbr64
mov %rdi,%rax
mov $0x8,%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 12c3 <func0+0xd3>
mov $0x6,%ecx
lea 0xde4(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x4,%ecx
lea 0xdcb(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x5,%ecx
lea 0xdb4(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x7,%ecx
lea 0xd9e(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov $0x8,%ecx
lea 0xd8a(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 12c3 <func0+0xd3>
mov %rax,%rsi
mov $0x9,%ecx
lea 0xd74(%rip),%rdi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %al
sbb $0x0,%al
test %al,%al
sete %r8b
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
lea rsi, s2; "January"
mov ebp, 1
push rbx
mov rbx, rdi
sub rsp, 8
call _strcmp
test eax, eax
jz short loc_12A6
lea rsi, aMarch; "March"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz short loc_12A6
lea rsi, aMay; "May"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz short loc_12A6
lea rsi, aJuly; "July"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz short loc_12A6
lea rsi, aAugest; "Augest"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz short loc_12A6
lea rsi, aOctober; "October"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz short loc_12A6
lea rsi, aDecember; "December"
mov rdi, rbx; s1
call _strcmp
test eax, eax
setz bpl
loc_12A6:
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, "January")
&& strcmp(s1, "March")
&& strcmp(s1, "May")
&& strcmp(s1, "July")
&& strcmp(s1, "Augest")
&& strcmp(s1, "October") )
{
LOBYTE(v1) = strcmp(s1, "December") == 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 0x001012a6
LEA RSI,[0x10200c]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a6
LEA RSI,[0x102012]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a6
LEA RSI,[0x102016]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a6
LEA RSI,[0x10201b]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a6
LEA RSI,[0x102022]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JZ 0x001012a6
LEA RSI,[0x10202a]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
SETZ BPL
LAB_001012a6:
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,"January");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"March");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"May");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"July");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"Augest");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"October");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"December");
bVar2 = iVar1 == 0;
}
}
}
}
}
}
return bVar2;
} |
7,360 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; i++) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 9) == 1);
assert(func0(arr2, 8) == 2);
assert(func0(arr3, 3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ad <func0+0x44>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
je 11a9 <func0+0x40>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 11c6 <func0+0x5d>
mov $0x1,%eax
jmp 11cb <func0+0x62>
mov $0x2,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AD
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jz short loc_11A9
add [rbp+var_8], 1
loc_11A9:
add [rbp+var_4], 1
loc_11AD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
and eax, 1
test eax, eax
jz short loc_11C6
mov eax, 1
jmp short loc_11CB
loc_11C6:
mov eax, 2
loc_11CB:
pop rbp
retn | long long func0(long long a1, int a2)
{
char v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) != 0 )
++v3;
}
if ( (v3 & 1) != 0 )
return 1LL;
else
return 2LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ad
LAB_00101188:
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]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011a9
ADD dword ptr [RBP + -0x8],0x1
LAB_001011a9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011c6
MOV EAX,0x1
JMP 0x001011cb
LAB_001011c6:
MOV EAX,0x2
LAB_001011cb:
POP RBP
RET | int8 func0(long param_1,int param_2)
{
byte bVar1;
int8 uVar2;
int4 local_c;
bVar1 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) != 0) {
bVar1 = bVar1 + 1;
}
}
if ((bool)(bVar1 & 1)) {
uVar2 = 1;
}
else {
uVar2 = 2;
}
return uVar2;
} |
7,361 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; i++) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 9) == 1);
assert(func0(arr2, 8) == 2);
assert(func0(arr3, 3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a0 <func0+0x37>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%ecx
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%ecx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
and $0x1,%ecx
mov $0x2,%eax
sub %ecx,%eax
retq
mov $0x2,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11A0
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov ecx, 0
loc_1181:
mov edx, [rax]
and edx, 1
cmp edx, 1
sbb ecx, 0FFFFFFFFh
add rax, 4
cmp rax, rsi
jnz short loc_1181
and ecx, 1
mov eax, 2
sub eax, ecx
retn
loc_11A0:
mov eax, 2
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rsi
char v4; // cl
if ( a2 <= 0 )
return 2LL;
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 -= ((*v2++ & 1) == 0) - 1;
while ( v2 != (_DWORD *)v3 );
return 2 - (v4 & 1u);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a0
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV ECX,0x0
LAB_00101181:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
SBB ECX,-0x1
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
AND ECX,0x1
MOV EAX,0x2
SUB EAX,ECX
RET
LAB_001011a0:
MOV EAX,0x2
RET | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar2 = 0;
do {
uVar2 = (uVar2 + 1) - (uint)((*param_1 & 1) == 0);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return 2 - (uVar2 & 1);
}
return 2;
} |
7,362 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; i++) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 9) == 1);
assert(func0(arr2, 8) == 2);
assert(func0(arr3, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 12e0 <func0+0x40>
lea -0x1(%rsi),%eax
xor %edx,%edx
lea 0x4(%rdi,%rax,4),%rcx
nopw 0x0(%rax,%rax,1)
mov (%rdi),%eax
and $0x1,%eax
cmp $0x1,%eax
sbb $0xffffffff,%edx
add $0x4,%rdi
cmp %rdi,%rcx
jne 12b8 <func0+0x18>
and $0x1,%edx
mov $0x2,%eax
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12E0
lea eax, [rsi-1]
xor edx, edx
lea rcx, [rdi+rax*4+4]
nop word ptr [rax+rax+00h]
loc_12B8:
mov eax, [rdi]
and eax, 1
cmp eax, 1
sbb edx, 0FFFFFFFFh
add rdi, 4
cmp rcx, rdi
jnz short loc_12B8
and edx, 1
mov eax, 2
sub eax, edx
retn
loc_12E0:
mov eax, 2
retn | long long func0(_DWORD *a1, int a2)
{
char v2; // dl
long long v3; // rcx
if ( a2 <= 0 )
return 2LL;
v2 = 0;
v3 = (long long)&a1[a2 - 1 + 1];
do
v2 -= ((*a1++ & 1) == 0) - 1;
while ( (_DWORD *)v3 != a1 );
return 2 - (v2 & 1u);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012e0
LEA EAX,[RSI + -0x1]
XOR EDX,EDX
LEA RCX,[RDI + RAX*0x4 + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001012b8:
MOV EAX,dword ptr [RDI]
AND EAX,0x1
CMP EAX,0x1
SBB EDX,-0x1
ADD RDI,0x4
CMP RCX,RDI
JNZ 0x001012b8
AND EDX,0x1
MOV EAX,0x2
SUB EAX,EDX
RET
LAB_001012e0:
MOV EAX,0x2
RET | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (0 < param_2) {
uVar2 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
uVar2 = (uVar2 + 1) - (uint)((*param_1 & 1) == 0);
param_1 = param_1 + 1;
} while (puVar1 != param_1);
return 2 - (uVar2 & 1);
}
return 2;
} |
7,363 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; i++) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 9) == 1);
assert(func0(arr2, 8) == 2);
assert(func0(arr3, 3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1228 <func0+0xe8>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 122e <func0+0xee>
mov %esi,%edx
pxor %xmm1,%xmm1
pcmpeqd %xmm2,%xmm2
mov %rdi,%rax
shr $0x2,%edx
movdqa 0xea0(%rip),%xmm4
movdqa %xmm1,%xmm3
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
pand %xmm4,%xmm0
pcmpeqd %xmm3,%xmm0
pandn %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rdx,%rax
jne 1180 <func0+0x40>
movdqa %xmm1,%xmm0
mov %esi,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 1217 <func0+0xd7>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
and $0x1,%ecx
cmp $0x1,%ecx
lea 0x1(%rdx),%ecx
sbb $0xffffffff,%eax
cmp %esi,%ecx
jge 1217 <func0+0xd7>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
and $0x1,%ecx
cmp $0x1,%ecx
lea 0x2(%rdx),%ecx
sbb $0xffffffff,%eax
cmp %ecx,%esi
jle 1217 <func0+0xd7>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
and $0x1,%ecx
cmp $0x1,%ecx
sbb $0xffffffff,%eax
add $0x3,%edx
cmp %edx,%esi
jle 1217 <func0+0xd7>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%eax
and $0x1,%eax
mov $0x2,%edx
sub %eax,%edx
mov %edx,%eax
retq
nopl 0x0(%rax)
mov $0x2,%eax
retq
xor %edx,%edx
xor %eax,%eax
jmp 11c6 <func0+0x86>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1218
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1220
mov edx, esi
pxor xmm1, xmm1
movdqa xmm3, cs:xmmword_2010
mov rax, rdi
shr edx, 2
movdqa xmm2, xmm1
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1180:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pand xmm0, xmm3
pcmpeqd xmm0, xmm2
pcmpeqd xmm0, xmm2
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_1180
movdqa xmm0, xmm1
mov edx, ecx
psrldq xmm0, 8
and edx, 0FFFFFFFCh
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
test cl, 3
jz short loc_1206
loc_11C5:
movsxd rsi, edx
lea r8, ds:0[rsi*4]
mov esi, [rdi+rsi*4]
and esi, 1
cmp esi, 1
lea esi, [rdx+1]
sbb eax, 0FFFFFFFFh
cmp ecx, esi
jle short loc_1206
mov esi, [rdi+r8+4]
and esi, 1
cmp esi, 1
sbb eax, 0FFFFFFFFh
add edx, 2
cmp ecx, edx
jle short loc_1206
mov edx, [rdi+r8+8]
and edx, 1
cmp edx, 1
sbb eax, 0FFFFFFFFh
loc_1206:
and eax, 1
mov edx, 2
sub edx, eax
mov eax, edx
retn
loc_1218:
mov edx, 2
mov eax, edx
retn
loc_1220:
xor edx, edx
xor eax, eax
jmp short loc_11C5 | long long func0(const __m128i *a1, int a2)
{
__m128i v2; // xmm1
__m128i si128; // xmm3
const __m128i *v4; // rax
__m128i v5; // xmm0
signed int v6; // edx
__m128i v7; // xmm1
char v8; // al
long long v9; // r8
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v6 = 0;
v8 = 0;
}
else
{
v2 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v4 = a1;
do
{
v5 = _mm_loadu_si128(v4++);
v2 = _mm_sub_epi32(v2, _mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_and_si128(v5, si128), (__m128i)0LL), (__m128i)0LL));
}
while ( v4 != &a1[(unsigned int)a2 >> 2] );
v6 = a2 & 0xFFFFFFFC;
v7 = _mm_add_epi32(v2, _mm_srli_si128(v2, 8));
v8 = _mm_cvtsi128_si32(_mm_add_epi32(v7, _mm_srli_si128(v7, 4)));
if ( (a2 & 3) == 0 )
return 2 - (v8 & 1u);
}
v9 = v6;
v8 -= ((a1->m128i_i32[v9] & 1) == 0) - 1;
if ( a2 > v6 + 1 )
{
v8 -= ((a1->m128i_i32[v9 + 1] & 1) == 0) - 1;
if ( a2 > v6 + 2 )
v8 -= ((a1->m128i_i32[v9 + 2] & 1) == 0) - 1;
}
return 2 - (v8 & 1u);
}
return 2LL;
} | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101218
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101220
MOV EDX,ESI
PXOR XMM1,XMM1
MOVDQA XMM3,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM2,XMM1
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PAND XMM0,XMM3
PCMPEQD XMM0,XMM2
PCMPEQD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x00101180
MOVDQA XMM0,XMM1
MOV EDX,ECX
PSRLDQ XMM0,0x8
AND EDX,0xfffffffc
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
TEST CL,0x3
JZ 0x00101206
LAB_001011c5:
MOVSXD RSI,EDX
LEA R8,[RSI*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
AND ESI,0x1
CMP ESI,0x1
LEA ESI,[RDX + 0x1]
SBB EAX,-0x1
CMP ECX,ESI
JLE 0x00101206
MOV ESI,dword ptr [RDI + R8*0x1 + 0x4]
AND ESI,0x1
CMP ESI,0x1
SBB EAX,-0x1
ADD EDX,0x2
CMP ECX,EDX
JLE 0x00101206
MOV EDX,dword ptr [RDI + R8*0x1 + 0x8]
AND EDX,0x1
CMP EDX,0x1
SBB EAX,-0x1
LAB_00101206:
AND EAX,0x1
MOV EDX,0x2
SUB EDX,EAX
MOV EAX,EDX
RET
LAB_00101218:
MOV EDX,0x2
MOV EAX,EDX
RET
LAB_00101220:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011c5 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
int iVar6;
uint uVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
return 2;
}
if (param_2 - 1 < 3) {
uVar5 = 0;
uVar7 = 0;
}
else {
iVar6 = 0;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
puVar4 = param_1;
do {
uVar7 = *puVar4;
puVar1 = puVar4 + 1;
puVar2 = puVar4 + 2;
puVar3 = puVar4 + 3;
puVar4 = puVar4 + 4;
iVar6 = iVar6 + (uint)((uVar7 & _DAT_00102010) != 0);
iVar8 = iVar8 + (uint)((*puVar1 & _UNK_00102014) != 0);
iVar9 = iVar9 + (uint)((*puVar2 & _UNK_00102018) != 0);
iVar10 = iVar10 + (uint)((*puVar3 & _UNK_0010201c) != 0);
} while (puVar4 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar5 = param_2 & 0xfffffffc;
uVar7 = iVar6 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) == 0) goto LAB_00101206;
}
uVar7 = (uVar7 + 1) - (uint)((param_1[(int)uVar5] & 1) == 0);
if (((int)(uVar5 + 1) < (int)param_2) &&
(uVar7 = (uVar7 + 1) - (uint)((param_1[(long)(int)uVar5 + 1] & 1) == 0),
(int)(uVar5 + 2) < (int)param_2)) {
uVar7 = (uVar7 + 1) - (uint)((param_1[(long)(int)uVar5 + 2] & 1) == 0);
}
LAB_00101206:
return 2 - (uVar7 & 1);
} |
7,364 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *a) {
int l = 0;
char *x = a;
while (*x == ' ') x++; // Trim leading spaces
for (int i = 0; i < strlen(x); i++) {
if (x[i] == ' ') {
l = 0;
} else {
l++;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x20(%rbp)
mov -0x28(%rbp),%rax
mov %rax,-0x18(%rbp)
jmp 1190 <func0+0x27>
addq $0x1,-0x18(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 118b <func0+0x22>
movl $0x0,-0x1c(%rbp)
jmp 11c9 <func0+0x60>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 11c1 <func0+0x58>
movl $0x0,-0x20(%rbp)
jmp 11c5 <func0+0x5c>
addl $0x1,-0x20(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 11a4 <func0+0x3b>
mov -0x20(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_20], 0
mov rax, [rbp+var_28]
mov [rbp+s], rax
jmp short loc_1190
loc_118B:
add [rbp+s], 1
loc_1190:
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_118B
mov [rbp+var_1C], 0
jmp short loc_11C9
loc_11A4:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_11C1
mov [rbp+var_20], 0
jmp short loc_11C5
loc_11C1:
add [rbp+var_20], 1
loc_11C5:
add [rbp+var_1C], 1
loc_11C9:
mov eax, [rbp+var_1C]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_11A4
mov eax, [rbp+var_20]
mov rbx, [rbp+var_8]
leave
retn | long long func0(const char *a1)
{
unsigned int v2; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
v2 = 0;
while ( *a1 == 32 )
++a1;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] == 32 )
v2 = 0;
else
++v2;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00101190
LAB_0010118b:
ADD qword ptr [RBP + -0x18],0x1
LAB_00101190:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x0010118b
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001011c9
LAB_001011a4:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x001011c1
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001011c5
LAB_001011c1:
ADD dword ptr [RBP + -0x20],0x1
LAB_001011c5:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001011c9:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x001011a4
MOV EAX,dword ptr [RBP + -0x20]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int func0(char *param_1)
{
size_t sVar1;
int local_28;
int local_24;
char *local_20;
local_28 = 0;
for (local_20 = param_1; *local_20 == ' '; local_20 = local_20 + 1) {
}
local_24 = 0;
while( true ) {
sVar1 = strlen(local_20);
if (sVar1 <= (ulong)(long)local_24) break;
if (local_20[local_24] == ' ') {
local_28 = 0;
}
else {
local_28 = local_28 + 1;
}
local_24 = local_24 + 1;
}
return local_28;
} |
7,365 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *a) {
int l = 0;
char *x = a;
while (*x == ' ') x++; // Trim leading spaces
for (int i = 0; i < strlen(x); i++) {
if (x[i] == ' ') {
l = 0;
} else {
l++;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rsi
cmpb $0x20,(%rdi)
jne 115e <func0+0x15>
add $0x1,%rsi
cmpb $0x20,(%rsi)
je 1155 <func0+0xc>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
not %rcx
mov %rsi,%rdx
lea -0x1(%rsi,%rcx,1),%rcx
mov $0x0,%eax
mov $0x0,%esi
cmp %rcx,%rdx
je 1198 <func0+0x4f>
add $0x1,%eax
cmpb $0x20,(%rdx)
cmove %esi,%eax
add $0x1,%rdx
jmp 1184 <func0+0x3b>
retq
| func0:
endbr64
push rbx
mov rbx, rdi
cmp byte ptr [rdi], 20h ; ' '
jnz short loc_117F
loc_1176:
add rbx, 1
cmp byte ptr [rbx], 20h ; ' '
jz short loc_1176
loc_117F:
mov rdi, rbx
call _strlen
mov rdx, rbx
add rbx, rax
mov eax, 0
mov ecx, 0
jmp short loc_11A6
loc_1199:
add eax, 1
cmp byte ptr [rdx], 20h ; ' '
cmovz eax, ecx
add rdx, 1
loc_11A6:
cmp rdx, rbx
jnz short loc_1199
pop rbx
retn | long long func0(_BYTE *a1)
{
_BYTE *i; // rbx
long long v2; // rax
_BYTE *v3; // rdx
_BYTE *v4; // rbx
long long result; // rax
for ( i = a1; *i == 32; ++i )
;
v2 = strlen(i);
v3 = i;
v4 = &i[v2];
result = 0LL;
while ( v3 != v4 )
{
result = (unsigned int)(result + 1);
if ( *v3 == 32 )
result = 0LL;
++v3;
}
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CMP byte ptr [RDI],0x20
JNZ 0x0010117f
LAB_00101176:
ADD RBX,0x1
CMP byte ptr [RBX],0x20
JZ 0x00101176
LAB_0010117f:
MOV RDI,RBX
CALL 0x00101060
MOV RDX,RBX
ADD RBX,RAX
MOV EAX,0x0
MOV ECX,0x0
JMP 0x001011a6
LAB_00101199:
ADD EAX,0x1
CMP byte ptr [RDX],0x20
CMOVZ EAX,ECX
ADD RDX,0x1
LAB_001011a6:
CMP RDX,RBX
JNZ 0x00101199
POP RBX
RET | int func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
cVar1 = *param_1;
while (cVar1 == ' ') {
param_1 = param_1 + 1;
cVar1 = *param_1;
}
sVar3 = strlen(param_1);
pcVar4 = param_1 + sVar3;
iVar2 = 0;
for (; param_1 != pcVar4; param_1 = param_1 + 1) {
iVar2 = iVar2 + 1;
if (*param_1 == ' ') {
iVar2 = 0;
}
}
return iVar2;
} |
7,366 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *a) {
int l = 0;
char *x = a;
while (*x == ' ') x++; // Trim leading spaces
for (int i = 0; i < strlen(x); i++) {
if (x[i] == ' ') {
l = 0;
} else {
l++;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
cmpb $0x20,(%rdi)
mov %rdi,%rbx
jne 1229 <func0+0x19>
nopl (%rax)
add $0x1,%rbx
cmpb $0x20,(%rbx)
je 1220 <func0+0x10>
mov %rbx,%rdi
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
lea (%rbx,%rax,1),%rdx
xor %eax,%eax
jmp 124d <func0+0x3d>
xchg %ax,%ax
add $0x1,%eax
cmpb $0x20,(%rdi)
cmove %ecx,%eax
add $0x1,%rdi
cmp %rdx,%rdi
jne 1240 <func0+0x30>
pop %rbx
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbx
cmp byte ptr [rdi], 20h ; ' '
mov rbx, rdi
jnz short loc_1229
nop dword ptr [rax]
loc_1220:
add rbx, 1
cmp byte ptr [rbx], 20h ; ' '
jz short loc_1220
loc_1229:
mov rdi, rbx
call _strlen
mov rdi, rbx
xor ecx, ecx
lea rdx, [rbx+rax]
xor eax, eax
jmp short loc_124D
loc_1240:
add eax, 1
cmp byte ptr [rdi], 20h ; ' '
cmovz eax, ecx
add rdi, 1
loc_124D:
cmp rdi, rdx
jnz short loc_1240
pop rbx
retn | long long func0(_BYTE *a1)
{
_BYTE *i; // rbx
_BYTE *v2; // rdi
_BYTE *v3; // rdx
long long result; // rax
for ( i = a1; *i == 32; ++i )
;
v2 = i;
v3 = &i[strlen(i)];
result = 0LL;
while ( v2 != v3 )
{
result = (unsigned int)(result + 1);
if ( *v2 == 32 )
result = 0LL;
++v2;
}
return result;
} | func0:
ENDBR64
PUSH RBX
CMP byte ptr [RDI],0x20
MOV RBX,RDI
JNZ 0x00101229
NOP dword ptr [RAX]
LAB_00101220:
ADD RBX,0x1
CMP byte ptr [RBX],0x20
JZ 0x00101220
LAB_00101229:
MOV RDI,RBX
CALL 0x00101060
MOV RDI,RBX
XOR ECX,ECX
LEA RDX,[RBX + RAX*0x1]
XOR EAX,EAX
JMP 0x0010124d
LAB_00101240:
ADD EAX,0x1
CMP byte ptr [RDI],0x20
CMOVZ EAX,ECX
ADD RDI,0x1
LAB_0010124d:
CMP RDI,RDX
JNZ 0x00101240
POP RBX
RET | int func0(char *param_1)
{
char *pcVar1;
char cVar2;
int iVar3;
size_t sVar4;
cVar2 = *param_1;
while (cVar2 == ' ') {
param_1 = param_1 + 1;
cVar2 = *param_1;
}
sVar4 = strlen(param_1);
pcVar1 = param_1 + sVar4;
iVar3 = 0;
for (; param_1 != pcVar1; param_1 = param_1 + 1) {
iVar3 = iVar3 + 1;
if (*param_1 == ' ') {
iVar3 = 0;
}
}
return iVar3;
} |
7,367 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *a) {
int l = 0;
char *x = a;
while (*x == ' ') x++; // Trim leading spaces
for (int i = 0; i < strlen(x); i++) {
if (x[i] == ' ') {
l = 0;
} else {
l++;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
cmpb $0x20,(%rdi)
mov %rdi,%rbx
jne 1229 <func0+0x19>
nopl (%rax)
add $0x1,%rbx
cmpb $0x20,(%rbx)
je 1220 <func0+0x10>
mov %rbx,%rdi
callq 1060 <strlen@plt>
test %rax,%rax
je 1260 <func0+0x50>
lea (%rbx,%rax,1),%rdx
mov %rbx,%rdi
xor %eax,%eax
xor %ecx,%ecx
nopl 0x0(%rax)
add $0x1,%eax
cmpb $0x20,(%rdi)
cmove %ecx,%eax
add $0x1,%rdi
cmp %rdi,%rdx
jne 1248 <func0+0x38>
pop %rbx
retq
nopl 0x0(%rax)
xor %eax,%eax
pop %rbx
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbx
cmp byte ptr [rdi], 20h ; ' '
mov rbx, rdi
jnz short loc_1229
nop dword ptr [rax]
loc_1220:
add rbx, 1
cmp byte ptr [rbx], 20h ; ' '
jz short loc_1220
loc_1229:
mov rdi, rbx; s
call _strlen
test rax, rax
jz short loc_1258
lea rdx, [rbx+rax]
mov rdi, rbx
xor eax, eax
nop
loc_1240:
add eax, 1
cmp byte ptr [rdi], 20h ; ' '
jnz short loc_124A
xor eax, eax
loc_124A:
add rdi, 1
cmp rdx, rdi
jnz short loc_1240
pop rbx
retn
loc_1258:
xor eax, eax
pop rbx
retn | size_t func0(char *s)
{
char *i; // rbx
size_t result; // rax
char *v3; // rdx
char *v4; // rdi
for ( i = s; *i == 32; ++i )
;
result = strlen(i);
if ( !result )
return 0LL;
v3 = &i[result];
v4 = i;
LODWORD(result) = 0;
do
{
result = (unsigned int)(result + 1);
if ( *v4 == 32 )
result = 0LL;
++v4;
}
while ( v3 != v4 );
return result;
} | func0:
ENDBR64
PUSH RBX
CMP byte ptr [RDI],0x20
MOV RBX,RDI
JNZ 0x00101229
NOP dword ptr [RAX]
LAB_00101220:
ADD RBX,0x1
CMP byte ptr [RBX],0x20
JZ 0x00101220
LAB_00101229:
MOV RDI,RBX
CALL 0x00101060
TEST RAX,RAX
JZ 0x00101258
LEA RDX,[RBX + RAX*0x1]
MOV RDI,RBX
XOR EAX,EAX
NOP
LAB_00101240:
ADD EAX,0x1
CMP byte ptr [RDI],0x20
JNZ 0x0010124a
XOR EAX,EAX
LAB_0010124a:
ADD RDI,0x1
CMP RDX,RDI
JNZ 0x00101240
POP RBX
RET
LAB_00101258:
XOR EAX,EAX
POP RBX
RET | int func0(char *param_1)
{
char *pcVar1;
char cVar2;
int iVar3;
size_t sVar4;
cVar2 = *param_1;
while (cVar2 == ' ') {
param_1 = param_1 + 1;
cVar2 = *param_1;
}
sVar4 = strlen(param_1);
if (sVar4 == 0) {
return 0;
}
pcVar1 = param_1 + sVar4;
iVar3 = 0;
do {
iVar3 = iVar3 + 1;
if (*param_1 == ' ') {
iVar3 = 0;
}
param_1 = param_1 + 1;
} while (pcVar1 != param_1);
return iVar3;
} |
7,368 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct {
int elements[10];
int size;
} IntList;
typedef struct {
IntList lists[10];
int size;
} ListOfLists;
int compare_lists(ListOfLists a, ListOfLists b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.lists[i].size != b.lists[i].size) return 0;
for(int j = 0; j < a.lists[i].size; j++) {
if(a.lists[i].elements[j] != b.lists[i].elements[j]) return 0;
}
}
return 1;
}
| ListOfLists func0(ListOfLists list1, int leftrange, int rigthrange) {
ListOfLists result;
result.size = 0;
for(int i = 0; i < list1.size; i++) {
int min = list1.lists[i].elements[0];
int max = list1.lists[i].elements[0];
for(int j = 1; j < list1.lists[i].size; j++) {
if(list1.lists[i].elements[j] < min) min = list1.lists[i].elements[j];
if(list1.lists[i].elements[j] > max) max = list1.lists[i].elements[j];
}
if(min >= leftrange && max <= rigthrange) {
result.lists[result.size++] = list1.lists[i];
}
}
return result;
}
| int main() {
ListOfLists list1;
list1.size = 6;
list1.lists[0].size = 1; list1.lists[0].elements[0] = 2;
list1.lists[1].size = 1; list1.lists[1].elements[0] = 0;
list1.lists[2].size = 3; list1.lists[2].elements[0] = 1; list1.lists[2].elements[1] = 2; list1.lists[2].elements[2] = 3;
list1.lists[3].size = 6; list1.lists[3].elements[0] = 0; list1.lists[3].elements[1] = 1; list1.lists[3].elements[2] = 2;
list1.lists[3].elements[3] = 3; list1.lists[3].elements[4] = 6; list1.lists[3].elements[5] = 7;
list1.lists[4].size = 2; list1.lists[4].elements[0] = 9; list1.lists[4].elements[1] = 11;
list1.lists[5].size = 4; list1.lists[5].elements[0] = 13; list1.lists[5].elements[1] = 14;
list1.lists[5].elements[2] = 15; list1.lists[5].elements[3] = 17;
ListOfLists expected1;
expected1.size = 1;
expected1.lists[0].size = 4; expected1.lists[0].elements[0] = 13; expected1.lists[0].elements[1] = 14;
expected1.lists[0].elements[2] = 15; expected1.lists[0].elements[3] = 17;
ListOfLists result1 = func0(list1, 13, 17);
assert(compare_lists(result1, expected1));
ListOfLists expected2;
expected2.size = 2;
expected2.lists[0].size = 1; expected2.lists[0].elements[0] = 2;
expected2.lists[1].size = 3; expected2.lists[1].elements[0] = 1; expected2.lists[1].elements[1] = 2; expected2.lists[1].elements[2] = 3;
ListOfLists result2 = func0(list1, 1, 3);
assert(compare_lists(result2, expected2));
ListOfLists expected3;
expected3.size = 4;
expected3.lists[0].size = 1; expected3.lists[0].elements[0] = 2;
expected3.lists[1].size = 1; expected3.lists[1].elements[0] = 0;
expected3.lists[2].size = 3; expected3.lists[2].elements[0] = 1; expected3.lists[2].elements[1] = 2; expected3.lists[2].elements[2] = 3;
expected3.lists[3].size = 6; expected3.lists[3].elements[0] = 0; expected3.lists[3].elements[1] = 1;
expected3.lists[3].elements[2] = 2; expected3.lists[3].elements[3] = 3; expected3.lists[3].elements[4] = 6; expected3.lists[3].elements[5] = 7;
ListOfLists result3 = func0(list1, 0, 7);
assert(compare_lists(result3, expected3));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x1f8,%rsp
mov %rdi,-0x1f8(%rbp)
mov %esi,-0x1fc(%rbp)
mov %edx,-0x200(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
movl $0x0,-0x1f0(%rbp)
jmpq 14f1 <func0+0x251>
mov -0x1f0(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
lea 0x10(%rbp),%rbx
add %rbx,%rax
mov (%rax),%eax
mov %eax,-0x1ec(%rbp)
mov -0x1f0(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
lea 0x10(%rbp),%rbx
add %rbx,%rax
mov (%rax),%eax
mov %eax,-0x1e8(%rbp)
movl $0x1,-0x1e4(%rbp)
jmpq 1416 <func0+0x176>
mov -0x1e4(%rbp),%eax
movslq %eax,%rcx
mov -0x1f0(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
add %rcx,%rax
mov 0x10(%rbp,%rax,4),%eax
cmp %eax,-0x1ec(%rbp)
jle 13af <func0+0x10f>
mov -0x1e4(%rbp),%eax
movslq %eax,%rcx
mov -0x1f0(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
add %rcx,%rax
mov 0x10(%rbp,%rax,4),%eax
mov %eax,-0x1ec(%rbp)
mov -0x1e4(%rbp),%eax
movslq %eax,%rcx
mov -0x1f0(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
add %rcx,%rax
mov 0x10(%rbp,%rax,4),%eax
cmp %eax,-0x1e8(%rbp)
jge 140f <func0+0x16f>
mov -0x1e4(%rbp),%eax
movslq %eax,%rcx
mov -0x1f0(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
add %rcx,%rax
mov 0x10(%rbp,%rax,4),%eax
mov %eax,-0x1e8(%rbp)
addl $0x1,-0x1e4(%rbp)
mov -0x1f0(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
lea 0x10(%rbp),%rbx
add %rbx,%rax
add $0x28,%rax
mov (%rax),%eax
cmp %eax,-0x1e4(%rbp)
jl 134f <func0+0xaf>
mov -0x1ec(%rbp),%eax
cmp -0x1fc(%rbp),%eax
jl 14ea <func0+0x24a>
mov -0x1e8(%rbp),%eax
cmp -0x200(%rbp),%eax
jg 14ea <func0+0x24a>
mov -0x28(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
lea -0x10(%rbp),%rbx
add %rbx,%rax
lea -0x1d0(%rax),%rdx
mov -0x1f0(%rbp),%eax
movslq %eax,%rcx
mov %rcx,%rax
shl $0x2,%rax
add %rcx,%rax
add %rax,%rax
add %rcx,%rax
shl $0x2,%rax
lea 0x10(%rbp),%rdi
add %rdi,%rax
mov (%rax),%rcx
mov 0x8(%rax),%rbx
mov %rcx,(%rdx)
mov %rbx,0x8(%rdx)
mov 0x10(%rax),%rcx
mov 0x18(%rax),%rbx
mov %rcx,0x10(%rdx)
mov %rbx,0x18(%rdx)
mov 0x20(%rax),%rcx
mov %rcx,0x20(%rdx)
mov 0x28(%rax),%eax
mov %eax,0x28(%rdx)
addl $0x1,-0x1f0(%rbp)
mov 0x1c8(%rbp),%eax
cmp %eax,-0x1f0(%rbp)
jl 12e8 <func0+0x48>
mov -0x1f8(%rbp),%rax
mov %rax,%rdx
lea -0x1e0(%rbp),%rax
mov $0x1bc,%ecx
mov (%rax),%rsi
mov %rsi,(%rdx)
mov %ecx,%esi
add %rdx,%rsi
lea 0x8(%rsi),%rdi
mov %ecx,%esi
add %rax,%rsi
add $0x8,%rsi
mov -0x10(%rsi),%rsi
mov %rsi,-0x10(%rdi)
lea 0x8(%rdx),%rdi
and $0xfffffffffffffff8,%rdi
sub %rdi,%rdx
sub %rdx,%rax
add %edx,%ecx
and $0xfffffff8,%ecx
shr $0x3,%ecx
mov %ecx,%edx
mov %edx,%edx
mov %rax,%rsi
mov %rdx,%rcx
rep movsq %ds:(%rsi),%es:(%rdi)
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1570 <func0+0x2d0>
callq 1060 <__stack_chk_fail@plt>
mov -0x1f8(%rbp),%rax
add $0x1f8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 1F8h
mov [rbp+var_1F8], rdi
mov [rbp+var_1FC], esi
mov [rbp+var_200], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_28], 0
mov [rbp+var_1F0], 0
jmp loc_14F7
loc_12E8:
mov eax, [rbp+var_1F0]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
lea rax, [rax+10h]
add rax, rbp
mov eax, [rax]
mov [rbp+var_1EC], eax
mov eax, [rbp+var_1F0]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
lea rax, [rax+10h]
add rax, rbp
mov eax, [rax]
mov [rbp+var_1E8], eax
mov [rbp+var_1E4], 1
jmp loc_1416
loc_134F:
mov eax, [rbp+var_1E4]
movsxd rcx, eax
mov eax, [rbp+var_1F0]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rcx
mov eax, [rbp+rax*4+arg_0]
cmp [rbp+var_1EC], eax
jle short loc_13AF
mov eax, [rbp+var_1E4]
movsxd rcx, eax
mov eax, [rbp+var_1F0]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rcx
mov eax, [rbp+rax*4+arg_0]
mov [rbp+var_1EC], eax
loc_13AF:
mov eax, [rbp+var_1E4]
movsxd rcx, eax
mov eax, [rbp+var_1F0]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rcx
mov eax, [rbp+rax*4+arg_0]
cmp [rbp+var_1E8], eax
jge short loc_140F
mov eax, [rbp+var_1E4]
movsxd rcx, eax
mov eax, [rbp+var_1F0]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rcx
mov eax, [rbp+rax*4+arg_0]
mov [rbp+var_1E8], eax
loc_140F:
add [rbp+var_1E4], 1
loc_1416:
mov eax, [rbp+var_1F0]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
lea rax, [rax+10h]
add rax, rbp
add rax, 28h ; '('
mov eax, [rax]
cmp [rbp+var_1E4], eax
jl loc_134F
mov eax, [rbp+var_1EC]
cmp eax, [rbp+var_1FC]
jl loc_14F0
mov eax, [rbp+var_1E8]
cmp eax, [rbp+var_200]
jg loc_14F0
mov eax, [rbp+var_28]
lea edx, [rax+1]
mov [rbp+var_28], edx
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
lea rax, [rax-10h]
add rax, rbp
lea rdx, [rax-1D0h]
mov eax, [rbp+var_1F0]
movsxd rcx, eax
mov rax, rcx
shl rax, 2
add rax, rcx
add rax, rax
add rax, rcx
shl rax, 2
lea rax, [rax+10h]
add rax, rbp
mov rcx, [rax]
mov rbx, [rax+8]
mov [rdx], rcx
mov [rdx+8], rbx
mov rcx, [rax+10h]
mov rbx, [rax+18h]
mov [rdx+10h], rcx
mov [rdx+18h], rbx
mov rcx, [rax+1Ch]
mov rbx, [rax+24h]
mov [rdx+1Ch], rcx
mov [rdx+24h], rbx
loc_14F0:
add [rbp+var_1F0], 1
loc_14F7:
mov eax, [rbp+arg_1B8]
cmp [rbp+var_1F0], eax
jl loc_12E8
mov rax, [rbp+var_1F8]
mov rdx, rax
lea rax, [rbp+var_1E0]
mov ecx, 1BCh
mov rsi, [rax]
mov [rdx], rsi
mov esi, ecx
add rsi, rdx
lea rdi, [rsi+8]
mov esi, ecx
add rsi, rax
add rsi, 8
mov rsi, [rsi-10h]
mov [rdi-10h], rsi
lea rdi, [rdx+8]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
sub rax, rdx
add ecx, edx
and ecx, 0FFFFFFF8h
shr ecx, 3
mov edx, ecx
mov edx, edx
mov rsi, rax
mov rcx, rdx
rep movsq
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_1576
call ___stack_chk_fail
loc_1576:
mov rax, [rbp+var_1F8]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(
_QWORD *a1,
int a2,
int a3,
long long a4,
long long a5,
long long a6,
int a7,
int a8,
int a9,
int a10,
int a11,
int a12,
int a13,
int a14,
int a15,
int a16,
int a17,
int a18,
int a19,
int a20,
int a21,
int a22,
int a23,
int a24,
int a25,
int a26,
int a27,
int a28,
int a29,
int a30,
int a31,
int a32,
int a33,
int a34,
int a35,
int a36,
int a37,
int a38,
int a39,
int a40,
int a41,
int a42,
int a43,
int a44,
int a45,
int a46,
int a47,
int a48,
int a49,
int a50,
int a51,
int a52,
int a53,
int a54,
int a55,
int a56,
int a57,
int a58,
int a59,
int a60,
int a61,
int a62)
{
int v62; // eax
_QWORD *v63; // rdx
_QWORD *v64; // rax
long long v65; // rbx
long long v66; // rbx
long long v67; // rbx
int i; // [rsp+10h] [rbp-1F0h]
int v71; // [rsp+14h] [rbp-1ECh]
int v72; // [rsp+18h] [rbp-1E8h]
int j; // [rsp+1Ch] [rbp-1E4h]
_QWORD v74[54]; // [rsp+20h] [rbp-1E0h] BYREF
long long v75; // [rsp+1D4h] [rbp-2Ch]
unsigned long long v76; // [rsp+1E8h] [rbp-18h]
long long savedregs; // [rsp+200h] [rbp+0h] BYREF
v76 = __readfsqword(0x28u);
HIDWORD(v75) = 0;
for ( i = 0; i < a62; ++i )
{
v71 = *((_DWORD *)&savedregs + 11 * i + 4);
v72 = v71;
for ( j = 1; j < *(&a10 + 11 * i + 4); ++j )
{
if ( v71 > *(&a7 + 11 * i + j) )
v71 = *(&a7 + 11 * i + j);
if ( v72 < *(&a7 + 11 * i + j) )
v72 = *(&a7 + 11 * i + j);
}
if ( v71 >= a2 && v72 <= a3 )
{
v62 = HIDWORD(v75)++;
v63 = (_QWORD *)((char *)v74 + 44 * v62);
v64 = (long long *)((char *)&savedregs + 44 * i + 16);
v65 = v64[1];
*v63 = *v64;
v63[1] = v65;
v66 = v64[3];
v63[2] = v64[2];
v63[3] = v66;
v67 = *(_QWORD *)((char *)v64 + 36);
*(_QWORD *)((char *)v63 + 28) = *(_QWORD *)((char *)v64 + 28);
*(_QWORD *)((char *)v63 + 36) = v67;
}
}
*a1 = v74[0];
*(_QWORD *)((char *)a1 + 436) = v75;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v74 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * ((((_DWORD)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 444) & 0xFFFFFFF8) >> 3));
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x1f8
MOV qword ptr [RBP + -0x1f8],RDI
MOV dword ptr [RBP + -0x1fc],ESI
MOV dword ptr [RBP + -0x200],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x1f0],0x0
JMP 0x001014f7
LAB_001012e8:
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
LEA RAX,[RAX + 0x10]
ADD RAX,RBP
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1ec],EAX
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
LEA RAX,[RAX + 0x10]
ADD RAX,RBP
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1e8],EAX
MOV dword ptr [RBP + -0x1e4],0x1
JMP 0x00101416
LAB_0010134f:
MOV EAX,dword ptr [RBP + -0x1e4]
MOVSXD RCX,EAX
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RCX
MOV EAX,dword ptr [RBP + RAX*0x4 + 0x10]
CMP dword ptr [RBP + -0x1ec],EAX
JLE 0x001013af
MOV EAX,dword ptr [RBP + -0x1e4]
MOVSXD RCX,EAX
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RCX
MOV EAX,dword ptr [RBP + RAX*0x4 + 0x10]
MOV dword ptr [RBP + -0x1ec],EAX
LAB_001013af:
MOV EAX,dword ptr [RBP + -0x1e4]
MOVSXD RCX,EAX
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RCX
MOV EAX,dword ptr [RBP + RAX*0x4 + 0x10]
CMP dword ptr [RBP + -0x1e8],EAX
JGE 0x0010140f
MOV EAX,dword ptr [RBP + -0x1e4]
MOVSXD RCX,EAX
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RCX
MOV EAX,dword ptr [RBP + RAX*0x4 + 0x10]
MOV dword ptr [RBP + -0x1e8],EAX
LAB_0010140f:
ADD dword ptr [RBP + -0x1e4],0x1
LAB_00101416:
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
LEA RAX,[RAX + 0x10]
ADD RAX,RBP
ADD RAX,0x28
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1e4],EAX
JL 0x0010134f
MOV EAX,dword ptr [RBP + -0x1ec]
CMP EAX,dword ptr [RBP + -0x1fc]
JL 0x001014f0
MOV EAX,dword ptr [RBP + -0x1e8]
CMP EAX,dword ptr [RBP + -0x200]
JG 0x001014f0
MOV EAX,dword ptr [RBP + -0x28]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x28],EDX
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
LEA RAX,[RAX + -0x10]
ADD RAX,RBP
LEA RDX,[RAX + -0x1d0]
MOV EAX,dword ptr [RBP + -0x1f0]
MOVSXD RCX,EAX
MOV RAX,RCX
SHL RAX,0x2
ADD RAX,RCX
ADD RAX,RAX
ADD RAX,RCX
SHL RAX,0x2
LEA RAX,[RAX + 0x10]
ADD RAX,RBP
MOV RCX,qword ptr [RAX]
MOV RBX,qword ptr [RAX + 0x8]
MOV qword ptr [RDX],RCX
MOV qword ptr [RDX + 0x8],RBX
MOV RCX,qword ptr [RAX + 0x10]
MOV RBX,qword ptr [RAX + 0x18]
MOV qword ptr [RDX + 0x10],RCX
MOV qword ptr [RDX + 0x18],RBX
MOV RCX,qword ptr [RAX + 0x1c]
MOV RBX,qword ptr [RAX + 0x24]
MOV qword ptr [RDX + 0x1c],RCX
MOV qword ptr [RDX + 0x24],RBX
LAB_001014f0:
ADD dword ptr [RBP + -0x1f0],0x1
LAB_001014f7:
MOV EAX,dword ptr [RBP + 0x1c8]
CMP dword ptr [RBP + -0x1f0],EAX
JL 0x001012e8
MOV RAX,qword ptr [RBP + -0x1f8]
MOV RDX,RAX
LEA RAX,[RBP + -0x1e0]
MOV ECX,0x1bc
MOV RSI,qword ptr [RAX]
MOV qword ptr [RDX],RSI
MOV ESI,ECX
ADD RSI,RDX
LEA RDI,[RSI + 0x8]
MOV ESI,ECX
ADD RSI,RAX
ADD RSI,0x8
MOV RSI,qword ptr [RSI + -0x10]
MOV qword ptr [RDI + -0x10],RSI
LEA RDI,[RDX + 0x8]
AND RDI,-0x8
SUB RDX,RDI
SUB RAX,RDX
ADD ECX,EDX
AND ECX,0xfffffff8
SHR ECX,0x3
MOV EDX,ECX
MOV EDX,EDX
MOV RSI,RAX
MOV RCX,RDX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101576
CALL 0x00101060
LAB_00101576:
MOV RAX,qword ptr [RBP + -0x1f8]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int8 uVar1;
int iVar2;
long lVar3;
ulong uVar4;
long lVar5;
int8 *puVar6;
int8 *puVar7;
long in_FS_OFFSET;
int param_11;
int local_1f8;
int local_1f4;
int local_1f0;
int local_1ec;
int8 local_1e8 [3];
int8 auStack_1cc [51];
int4 local_34;
int iStack_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iStack_30 = 0;
for (local_1f8 = 0; iVar2 = iStack_30, local_1f8 < param_11; local_1f8 = local_1f8 + 1) {
local_1f4 = *(int *)(&stack0x00000008 + (long)local_1f8 * 0x2c);
local_1f0 = *(int *)(&stack0x00000008 + (long)local_1f8 * 0x2c);
for (local_1ec = 1; local_1ec < *(int *)(&stack0x00000030 + (long)local_1f8 * 0x2c);
local_1ec = local_1ec + 1) {
if (*(int *)(&stack0x00000008 + (long)local_1f8 * 0x2c + (long)local_1ec * 4) < local_1f4) {
local_1f4 = *(int *)(&stack0x00000008 + (long)local_1f8 * 0x2c + (long)local_1ec * 4);
}
if (local_1f0 < *(int *)(&stack0x00000008 + (long)local_1f8 * 0x2c + (long)local_1ec * 4)) {
local_1f0 = *(int *)(&stack0x00000008 + (long)local_1f8 * 0x2c + (long)local_1ec * 4);
}
}
if ((param_2 <= local_1f4) && (local_1f0 <= param_3)) {
iStack_30 = iStack_30 + 1;
lVar5 = (long)iVar2 * 0x2c;
lVar3 = (long)local_1f8 * 0x2c;
uVar1 = *(int8 *)(&stack0x00000010 + lVar3);
*(int8 *)((long)local_1e8 + lVar5) = *(int8 *)(&stack0x00000008 + lVar3);
*(int8 *)((long)local_1e8 + lVar5 + 8) = uVar1;
uVar1 = *(int8 *)(&stack0x00000020 + lVar3);
*(int8 *)((long)local_1e8 + lVar5 + 0x10) = *(int8 *)(&stack0x00000018 + lVar3);
*(int8 *)(&stack0xfffffffffffffe30 + lVar5) = uVar1;
uVar1 = *(int8 *)(&stack0x0000002c + lVar3);
*(int8 *)((long)auStack_1cc + lVar5) = *(int8 *)(&stack0x00000024 + lVar3);
*(int8 *)((long)auStack_1cc + lVar5 + 8) = uVar1;
}
}
*param_1 = local_1e8[0];
*(ulong *)((long)param_1 + 0x1b4) = CONCAT44(iStack_30,local_34);
lVar5 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar6 = (int8 *)((long)local_1e8 - lVar5);
puVar7 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar4 = (ulong)((int)lVar5 + 0x1bcU >> 3); uVar4 != 0; uVar4 = uVar4 - 1) {
*puVar7 = *puVar6;
puVar6 = puVar6 + 1;
puVar7 = puVar7 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
7,369 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct {
int elements[10];
int size;
} IntList;
typedef struct {
IntList lists[10];
int size;
} ListOfLists;
int compare_lists(ListOfLists a, ListOfLists b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.lists[i].size != b.lists[i].size) return 0;
for(int j = 0; j < a.lists[i].size; j++) {
if(a.lists[i].elements[j] != b.lists[i].elements[j]) return 0;
}
}
return 1;
}
| ListOfLists func0(ListOfLists list1, int leftrange, int rigthrange) {
ListOfLists result;
result.size = 0;
for(int i = 0; i < list1.size; i++) {
int min = list1.lists[i].elements[0];
int max = list1.lists[i].elements[0];
for(int j = 1; j < list1.lists[i].size; j++) {
if(list1.lists[i].elements[j] < min) min = list1.lists[i].elements[j];
if(list1.lists[i].elements[j] > max) max = list1.lists[i].elements[j];
}
if(min >= leftrange && max <= rigthrange) {
result.lists[result.size++] = list1.lists[i];
}
}
return result;
}
| int main() {
ListOfLists list1;
list1.size = 6;
list1.lists[0].size = 1; list1.lists[0].elements[0] = 2;
list1.lists[1].size = 1; list1.lists[1].elements[0] = 0;
list1.lists[2].size = 3; list1.lists[2].elements[0] = 1; list1.lists[2].elements[1] = 2; list1.lists[2].elements[2] = 3;
list1.lists[3].size = 6; list1.lists[3].elements[0] = 0; list1.lists[3].elements[1] = 1; list1.lists[3].elements[2] = 2;
list1.lists[3].elements[3] = 3; list1.lists[3].elements[4] = 6; list1.lists[3].elements[5] = 7;
list1.lists[4].size = 2; list1.lists[4].elements[0] = 9; list1.lists[4].elements[1] = 11;
list1.lists[5].size = 4; list1.lists[5].elements[0] = 13; list1.lists[5].elements[1] = 14;
list1.lists[5].elements[2] = 15; list1.lists[5].elements[3] = 17;
ListOfLists expected1;
expected1.size = 1;
expected1.lists[0].size = 4; expected1.lists[0].elements[0] = 13; expected1.lists[0].elements[1] = 14;
expected1.lists[0].elements[2] = 15; expected1.lists[0].elements[3] = 17;
ListOfLists result1 = func0(list1, 13, 17);
assert(compare_lists(result1, expected1));
ListOfLists expected2;
expected2.size = 2;
expected2.lists[0].size = 1; expected2.lists[0].elements[0] = 2;
expected2.lists[1].size = 3; expected2.lists[1].elements[0] = 1; expected2.lists[1].elements[1] = 2; expected2.lists[1].elements[2] = 3;
ListOfLists result2 = func0(list1, 1, 3);
assert(compare_lists(result2, expected2));
ListOfLists expected3;
expected3.size = 4;
expected3.lists[0].size = 1; expected3.lists[0].elements[0] = 2;
expected3.lists[1].size = 1; expected3.lists[1].elements[0] = 0;
expected3.lists[2].size = 3; expected3.lists[2].elements[0] = 1; expected3.lists[2].elements[1] = 2; expected3.lists[2].elements[2] = 3;
expected3.lists[3].size = 6; expected3.lists[3].elements[0] = 0; expected3.lists[3].elements[1] = 1;
expected3.lists[3].elements[2] = 2; expected3.lists[3].elements[3] = 3; expected3.lists[3].elements[4] = 6; expected3.lists[3].elements[5] = 7;
ListOfLists result3 = func0(list1, 0, 7);
assert(compare_lists(result3, expected3));
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1d0,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x1c8(%rsp)
xor %eax,%eax
mov 0x3b8(%rsp),%eax
test %eax,%eax
jle 12f8 <func0+0xfa>
mov %esi,%ebp
mov %edx,%r13d
lea 0x204(%rsp),%r10
lea -0x1(%rax),%eax
add $0x1,%rax
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%r12
mov $0x0,%r11d
mov $0x0,%esi
lea 0x208(%rsp),%r14
jmp 127d <func0+0x7f>
mov %edi,%r8d
jmp 12b4 <func0+0xb6>
add $0x2c,%r10
add $0xb,%r11
cmp %r12,%r11
je 12fd <func0+0xff>
mov %r10,%rdx
mov -0x4(%r10),%edi
mov 0x24(%r10),%eax
cmp $0x1,%eax
jle 1267 <func0+0x69>
lea -0x2(%rax),%eax
add %r11,%rax
lea (%r14,%rax,4),%r9
mov %r10,%rcx
mov %edi,%r8d
mov (%rcx),%eax
cmp %eax,%edi
cmovg %eax,%edi
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x4,%rcx
cmp %r9,%rcx
jne 129d <func0+0x9f>
cmp %edi,%ebp
jg 126c <func0+0x6e>
cmp %r8d,%r13d
jl 126c <func0+0x6e>
movslq %esi,%rax
lea (%rax,%rax,4),%rcx
lea (%rax,%rcx,2),%rax
shl $0x2,%rax
lea (%rsp,%rax,1),%rcx
movdqu -0x4(%rdx),%xmm0
movups %xmm0,(%rsp,%rax,1)
movdqu 0xc(%rdx),%xmm1
movups %xmm1,0x10(%rcx)
mov 0x1c(%rdx),%rax
mov %rax,0x20(%rcx)
mov 0x24(%rdx),%eax
mov %eax,0x28(%rcx)
lea 0x1(%rsi),%esi
jmpq 126c <func0+0x6e>
mov $0x0,%esi
mov %esi,0x1b8(%rsp)
mov %rsp,%rsi
mov (%rsp),%rax
mov %rax,(%rbx)
mov 0x1b4(%rsp),%rax
mov %rax,0x1b4(%rbx)
lea 0x8(%rbx),%rdi
and $0xfffffffffffffff8,%rdi
mov %rbx,%rax
sub %rdi,%rax
sub %rax,%rsi
add $0x1bc,%eax
shr $0x3,%eax
mov %eax,%ecx
rep movsq %ds:(%rsi),%es:(%rdi)
mov 0x1c8(%rsp),%rax
xor %fs:0x28,%rax
jne 1361 <func0+0x163>
mov %rbx,%rax
add $0x1d0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1D0h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+1F8h+var_30], rax
xor eax, eax
mov eax, [rsp+1F8h+arg_1B8]
test eax, eax
jle loc_12F4
mov ebp, esi
mov r13d, edx
lea r8, [rsp+1F8h+arg_4]
mov eax, eax
lea rdx, [rax+rax*4]
lea r12, [rax+rdx*2]
mov r9d, 0
mov r11d, 0
lea r14, [rsp+1F8h+arg_8]
jmp short loc_1278
loc_1263:
mov esi, ecx
jmp short loc_12AC
loc_1267:
add r8, 2Ch ; ','
add r9, 0Bh
cmp r9, r12
jz loc_12FA
loc_1278:
mov r10, r8
mov ecx, [r8-4]
mov eax, [r8+24h]
cmp eax, 1
jle short loc_1263
lea eax, [rax-2]
add rax, r9
lea rdi, [r14+rax*4]
mov rdx, r8
mov esi, ecx
loc_1297:
mov eax, [rdx]
cmp ecx, eax
cmovg ecx, eax
cmp esi, eax
cmovl esi, eax
add rdx, 4
cmp rdx, rdi
jnz short loc_1297
loc_12AC:
cmp ebp, ecx
jg short loc_1267
cmp r13d, esi
jl short loc_1267
movsxd rax, r11d
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
shl rax, 2
lea rdx, [rsp+rax+1F8h+var_1F8]
movdqu xmm0, xmmword ptr [r10-4]
movups [rsp+rax+1F8h+var_1F8], xmm0
movdqu xmm1, xmmword ptr [r10+0Ch]
movups xmmword ptr [rdx+10h], xmm1
mov rax, [r10+1Ch]
mov [rdx+20h], rax
mov eax, [r10+24h]
mov [rdx+28h], eax
lea r11d, [r11+1]
jmp loc_1267
loc_12F4:
mov r11d, 0
loc_12FA:
mov [rsp+1F8h+var_40], r11d
mov rsi, rsp
mov rax, qword ptr [rsp+1F8h+var_1F8]
mov [rbx], rax
mov rax, [rsp+1B4h]
mov [rbx+1B4h], rax
lea rdi, [rbx+8]
and rdi, 0FFFFFFFFFFFFFFF8h
mov rax, rbx
sub rax, rdi
sub rsi, rax
add eax, 1BCh
shr eax, 3
mov ecx, eax
rep movsq
mov rax, [rsp+1F8h+var_30]
sub rax, fs:28h
jnz short loc_135F
mov rax, rbx
add rsp, 1D0h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_135F:
call ___stack_chk_fail | _QWORD * func0(
_QWORD *a1,
int a2,
int a3,
long long a4,
long long a5,
long long a6,
long long a7,
char a8,
int a9,
int a10,
int a11,
int a12,
int a13,
int a14,
int a15,
int a16,
int a17,
int a18,
int a19,
int a20,
int a21,
int a22,
int a23,
int a24,
int a25,
int a26,
int a27,
int a28,
int a29,
int a30,
int a31,
int a32,
int a33,
int a34,
int a35,
int a36,
int a37,
int a38,
int a39,
int a40,
int a41,
int a42,
int a43,
int a44,
int a45,
int a46,
int a47,
int a48,
int a49,
int a50,
int a51,
int a52,
int a53,
int a54,
int a55,
int a56,
int a57,
int a58,
int a59,
int a60,
int a61,
int a62)
{
char *v64; // r8
long long v65; // r12
long long v66; // r9
int v67; // r11d
int v68; // esi
int v69; // ecx
int v70; // eax
char *v71; // rdx
__m128i *v72; // rdx
_QWORD v74[54]; // [rsp+0h] [rbp-1F8h] BYREF
long long v75; // [rsp+1B4h] [rbp-44h]
unsigned long long v76; // [rsp+1C8h] [rbp-30h]
v76 = __readfsqword(0x28u);
if ( a62 <= 0 )
{
v67 = 0;
}
else
{
v64 = (char *)&a7 + 4;
v65 = 11LL * (unsigned int)a62;
v66 = 0LL;
v67 = 0;
do
{
v69 = *((_DWORD *)v64 - 1);
v70 = *((_DWORD *)v64 + 9);
if ( v70 <= 1 )
{
v68 = *((_DWORD *)v64 - 1);
}
else
{
v71 = v64;
v68 = *((_DWORD *)v64 - 1);
do
{
if ( v69 > *(_DWORD *)v71 )
v69 = *(_DWORD *)v71;
if ( v68 < *(_DWORD *)v71 )
v68 = *(_DWORD *)v71;
v71 += 4;
}
while ( v71 != &a8 + 4 * v66 + 4 * (unsigned int)(v70 - 2) );
}
if ( a2 <= v69 && a3 >= v68 )
{
v72 = (__m128i *)((char *)v74 + 44 * v67);
*v72 = _mm_loadu_si128((const __m128i *)(v64 - 4));
v72[1] = _mm_loadu_si128((const __m128i *)(v64 + 12));
v72[2].m128i_i64[0] = *(_QWORD *)(v64 + 28);
v72[2].m128i_i32[2] = *((_DWORD *)v64 + 9);
++v67;
}
v64 += 44;
v66 += 11LL;
}
while ( v66 != v65 );
}
HIDWORD(v75) = v67;
*a1 = v74[0];
*(_QWORD *)((char *)a1 + 436) = v75;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v74 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 444) >> 3));
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1d0
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1c8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RSP + 0x3b8]
TEST EAX,EAX
JLE 0x001012f4
MOV EBP,ESI
MOV R13D,EDX
LEA R8,[RSP + 0x204]
MOV EAX,EAX
LEA RDX,[RAX + RAX*0x4]
LEA R12,[RAX + RDX*0x2]
MOV R9D,0x0
MOV R11D,0x0
LEA R14,[RSP + 0x208]
JMP 0x00101278
LAB_00101263:
MOV ESI,ECX
JMP 0x001012ac
LAB_00101267:
ADD R8,0x2c
ADD R9,0xb
CMP R9,R12
JZ 0x001012fa
LAB_00101278:
MOV R10,R8
MOV ECX,dword ptr [R8 + -0x4]
MOV EAX,dword ptr [R8 + 0x24]
CMP EAX,0x1
JLE 0x00101263
LEA EAX,[RAX + -0x2]
ADD RAX,R9
LEA RDI,[R14 + RAX*0x4]
MOV RDX,R8
MOV ESI,ECX
LAB_00101297:
MOV EAX,dword ptr [RDX]
CMP ECX,EAX
CMOVG ECX,EAX
CMP ESI,EAX
CMOVL ESI,EAX
ADD RDX,0x4
CMP RDX,RDI
JNZ 0x00101297
LAB_001012ac:
CMP EBP,ECX
JG 0x00101267
CMP R13D,ESI
JL 0x00101267
MOVSXD RAX,R11D
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
SHL RAX,0x2
LEA RDX,[RSP + RAX*0x1]
MOVDQU XMM0,xmmword ptr [R10 + -0x4]
MOVUPS xmmword ptr [RSP + RAX*0x1],XMM0
MOVDQU XMM1,xmmword ptr [R10 + 0xc]
MOVUPS xmmword ptr [RDX + 0x10],XMM1
MOV RAX,qword ptr [R10 + 0x1c]
MOV qword ptr [RDX + 0x20],RAX
MOV EAX,dword ptr [R10 + 0x24]
MOV dword ptr [RDX + 0x28],EAX
LEA R11D,[R11 + 0x1]
JMP 0x00101267
LAB_001012f4:
MOV R11D,0x0
LAB_001012fa:
MOV dword ptr [RSP + 0x1b8],R11D
MOV RSI,RSP
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x1b4]
MOV qword ptr [RBX + 0x1b4],RAX
LEA RDI,[RBX + 0x8]
AND RDI,-0x8
MOV RAX,RBX
SUB RAX,RDI
SUB RSI,RAX
ADD EAX,0x1bc
SHR EAX,0x3
MOV ECX,EAX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RSP + 0x1c8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010135f
MOV RAX,RBX
ADD RSP,0x1d0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010135f:
CALL 0x00101060 | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int iVar1;
int8 uVar2;
long lVar3;
long lVar4;
int iVar5;
ulong uVar6;
int *piVar7;
int iVar8;
int8 *puVar9;
int8 *puVar10;
int *piVar11;
long lVar12;
int iVar13;
long in_FS_OFFSET;
uint in_stack_000001c0;
int8 local_1f8 [5];
int local_1d0 [99];
int4 local_44;
int iStack_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if ((int)in_stack_000001c0 < 1) {
iVar13 = 0;
}
else {
piVar11 = (int *)&stack0x0000000c;
lVar12 = 0;
iVar13 = 0;
do {
iVar5 = piVar11[-1];
iVar8 = iVar5;
if (1 < piVar11[9]) {
piVar7 = piVar11;
do {
iVar1 = *piVar7;
if (iVar1 < iVar5) {
iVar5 = iVar1;
}
if (iVar8 < iVar1) {
iVar8 = iVar1;
}
piVar7 = piVar7 + 1;
} while (piVar7 != (int *)(&stack0x00000010 + ((ulong)(piVar11[9] - 2) + lVar12) * 4));
}
if ((param_2 <= iVar5) && (iVar8 <= param_3)) {
lVar3 = (long)iVar13;
lVar4 = lVar3 * 0x2c;
uVar2 = *(int8 *)(piVar11 + 1);
*(int8 *)((long)local_1f8 + lVar4) = *(int8 *)(piVar11 + -1);
*(int8 *)((long)local_1f8 + lVar4 + 8) = uVar2;
uVar2 = *(int8 *)(piVar11 + 5);
*(int8 *)((long)local_1f8 + lVar4 + 0x10) = *(int8 *)(piVar11 + 3);
*(int8 *)(local_1d0 + lVar3 * 0xb + -4) = uVar2;
*(int8 *)(local_1d0 + lVar3 * 0xb + -2) = *(int8 *)(piVar11 + 7);
local_1d0[lVar3 * 0xb] = piVar11[9];
iVar13 = iVar13 + 1;
}
piVar11 = piVar11 + 0xb;
lVar12 = lVar12 + 0xb;
} while (lVar12 != (ulong)in_stack_000001c0 * 0xb);
}
iStack_40 = iVar13;
*param_1 = local_1f8[0];
*(ulong *)((long)param_1 + 0x1b4) = CONCAT44(iVar13,local_44);
lVar12 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar9 = (int8 *)((long)local_1f8 - lVar12);
puVar10 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar6 = (ulong)((int)lVar12 + 0x1bcU >> 3); uVar6 != 0; uVar6 = uVar6 - 1) {
*puVar10 = *puVar9;
puVar9 = puVar9 + 1;
puVar10 = puVar10 + 1;
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
7,370 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct {
int elements[10];
int size;
} IntList;
typedef struct {
IntList lists[10];
int size;
} ListOfLists;
int compare_lists(ListOfLists a, ListOfLists b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.lists[i].size != b.lists[i].size) return 0;
for(int j = 0; j < a.lists[i].size; j++) {
if(a.lists[i].elements[j] != b.lists[i].elements[j]) return 0;
}
}
return 1;
}
| ListOfLists func0(ListOfLists list1, int leftrange, int rigthrange) {
ListOfLists result;
result.size = 0;
for(int i = 0; i < list1.size; i++) {
int min = list1.lists[i].elements[0];
int max = list1.lists[i].elements[0];
for(int j = 1; j < list1.lists[i].size; j++) {
if(list1.lists[i].elements[j] < min) min = list1.lists[i].elements[j];
if(list1.lists[i].elements[j] > max) max = list1.lists[i].elements[j];
}
if(min >= leftrange && max <= rigthrange) {
result.lists[result.size++] = list1.lists[i];
}
}
return result;
}
| int main() {
ListOfLists list1;
list1.size = 6;
list1.lists[0].size = 1; list1.lists[0].elements[0] = 2;
list1.lists[1].size = 1; list1.lists[1].elements[0] = 0;
list1.lists[2].size = 3; list1.lists[2].elements[0] = 1; list1.lists[2].elements[1] = 2; list1.lists[2].elements[2] = 3;
list1.lists[3].size = 6; list1.lists[3].elements[0] = 0; list1.lists[3].elements[1] = 1; list1.lists[3].elements[2] = 2;
list1.lists[3].elements[3] = 3; list1.lists[3].elements[4] = 6; list1.lists[3].elements[5] = 7;
list1.lists[4].size = 2; list1.lists[4].elements[0] = 9; list1.lists[4].elements[1] = 11;
list1.lists[5].size = 4; list1.lists[5].elements[0] = 13; list1.lists[5].elements[1] = 14;
list1.lists[5].elements[2] = 15; list1.lists[5].elements[3] = 17;
ListOfLists expected1;
expected1.size = 1;
expected1.lists[0].size = 4; expected1.lists[0].elements[0] = 13; expected1.lists[0].elements[1] = 14;
expected1.lists[0].elements[2] = 15; expected1.lists[0].elements[3] = 17;
ListOfLists result1 = func0(list1, 13, 17);
assert(compare_lists(result1, expected1));
ListOfLists expected2;
expected2.size = 2;
expected2.lists[0].size = 1; expected2.lists[0].elements[0] = 2;
expected2.lists[1].size = 3; expected2.lists[1].elements[0] = 1; expected2.lists[1].elements[1] = 2; expected2.lists[1].elements[2] = 3;
ListOfLists result2 = func0(list1, 1, 3);
assert(compare_lists(result2, expected2));
ListOfLists expected3;
expected3.size = 4;
expected3.lists[0].size = 1; expected3.lists[0].elements[0] = 2;
expected3.lists[1].size = 1; expected3.lists[1].elements[0] = 0;
expected3.lists[2].size = 3; expected3.lists[2].elements[0] = 1; expected3.lists[2].elements[1] = 2; expected3.lists[2].elements[2] = 3;
expected3.lists[3].size = 6; expected3.lists[3].elements[0] = 0; expected3.lists[3].elements[1] = 1;
expected3.lists[3].elements[2] = 2; expected3.lists[3].elements[3] = 3; expected3.lists[3].elements[4] = 6; expected3.lists[3].elements[5] = 7;
ListOfLists result3 = func0(list1, 0, 7);
assert(compare_lists(result3, expected3));
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x1d8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1c8(%rsp)
xor %eax,%eax
mov 0x3b8(%rsp),%eax
test %eax,%eax
jle 1768 <func0+0x168>
sub $0x1,%eax
mov %edx,%ebp
lea 0x204(%rsp),%r10
xor %r11d,%r11d
add $0x1,%rax
lea 0x208(%rsp),%r13
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rbx
xor %edx,%edx
nopl 0x0(%rax)
mov 0x24(%r10),%eax
mov -0x4(%r10),%edi
cmp $0x1,%eax
jle 1760 <func0+0x160>
sub $0x2,%eax
mov %r10,%rcx
mov %edi,%r8d
add %r11,%rax
lea 0x0(%r13,%rax,4),%r9
nopw 0x0(%rax,%rax,1)
mov (%rcx),%eax
cmp %eax,%edi
cmovg %eax,%edi
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x4,%rcx
cmp %r9,%rcx
jne 1688 <func0+0x88>
cmp %edi,%esi
jg 16e1 <func0+0xe1>
cmp %r8d,%ebp
jl 16e1 <func0+0xe1>
movslq %edx,%rax
movdqu -0x4(%r10),%xmm0
movdqu 0xc(%r10),%xmm1
add $0x1,%edx
lea (%rax,%rax,4),%rcx
lea (%rax,%rcx,2),%rax
shl $0x2,%rax
lea (%rsp,%rax,1),%rcx
movups %xmm0,(%rsp,%rax,1)
mov 0x1c(%r10),%rax
movups %xmm1,0x10(%rcx)
mov %rax,0x20(%rcx)
mov 0x24(%r10),%eax
mov %eax,0x28(%rcx)
add $0xb,%r11
add $0x2c,%r10
cmp %rbx,%r11
jne 1660 <func0+0x60>
mov (%rsp),%rax
mov %edx,0x1b8(%rsp)
lea 0x8(%r12),%rdi
mov %rsp,%rsi
and $0xfffffffffffffff8,%rdi
mov %rax,(%r12)
mov 0x1b4(%rsp),%rax
mov %rax,0x1b4(%r12)
mov %r12,%rax
sub %rdi,%rax
sub %rax,%rsi
add $0x1bc,%eax
shr $0x3,%eax
mov %eax,%ecx
rep movsq %ds:(%rsi),%es:(%rdi)
mov 0x1c8(%rsp),%rax
xor %fs:0x28,%rax
jne 176c <func0+0x16c>
add $0x1d8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
mov %edi,%r8d
jmpq 169f <func0+0x9f>
xor %edx,%edx
jmp 16f2 <func0+0xf2>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
mov r11, rdi
push r12
push rbp
push rbx
sub rsp, 1D8h
mov rax, fs:28h
mov [rsp+1F8h+var_30], rax
xor eax, eax
movsxd rax, [rsp+1F8h+arg_1B8]
test eax, eax
jle loc_173F
mov r12d, edx
lea rdx, [rax+rax*4]
mov ebx, esi
xor r9d, r9d
lea r8, [rsp+1F8h+arg_4]
lea rbp, [rax+rdx*2]
xor r10d, r10d
lea r13, [rsp+1F8h+arg_8]
nop word ptr [rax+rax+00h]
loc_1640:
mov eax, [r8+24h]
mov ecx, [r8-4]
cmp eax, 1
jle loc_1738
sub eax, 2
mov rdx, r8
mov esi, ecx
add rax, r9
lea rdi, [r13+rax*4+0]
nop dword ptr [rax+00000000h]
loc_1668:
mov eax, [rdx]
cmp ecx, eax
cmovg ecx, eax
cmp esi, eax
cmovl esi, eax
add rdx, 4
cmp rdx, rdi
jnz short loc_1668
loc_167D:
cmp ebx, ecx
jg short loc_16C0
cmp r12d, esi
jl short loc_16C0
movsxd rax, r10d
movdqu xmm0, xmmword ptr [r8-4]
movdqu xmm1, xmmword ptr [r8+0Ch]
add r10d, 1
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
shl rax, 2
lea rdx, [rsp+rax+1F8h+var_1F8]
movups [rsp+rax+1F8h+var_1F8], xmm0
mov rax, [r8+1Ch]
movups xmmword ptr [rdx+10h], xmm1
mov [rdx+20h], rax
mov eax, [r8+24h]
mov [rdx+28h], eax
loc_16C0:
add r9, 0Bh
add r8, 2Ch ; ','
cmp r9, rbp
jnz loc_1640
loc_16D1:
mov rax, qword ptr [rsp+1F8h+var_1F8]
mov [rsp+1F8h+var_40], r10d
lea rdi, [r11+8]
mov rsi, rsp
and rdi, 0FFFFFFFFFFFFFFF8h
mov [r11], rax
mov rax, [rsp+1B4h]
mov [r11+1B4h], rax
mov rax, r11
sub rax, rdi
sub rsi, rax
add eax, 1BCh
shr eax, 3
mov ecx, eax
rep movsq
mov rax, [rsp+1F8h+var_30]
sub rax, fs:28h
jnz short loc_1744
add rsp, 1D8h
mov rax, r11
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1738:
mov esi, ecx
jmp loc_167D
loc_173F:
xor r10d, r10d
jmp short loc_16D1
loc_1744:
call ___stack_chk_fail | _QWORD * func0(
_QWORD *a1,
int a2,
int a3,
long long a4,
long long a5,
long long a6,
long long a7,
char a8,
int a9,
int a10,
int a11,
int a12,
int a13,
int a14,
int a15,
int a16,
int a17,
int a18,
int a19,
int a20,
int a21,
int a22,
int a23,
int a24,
int a25,
int a26,
int a27,
int a28,
int a29,
int a30,
int a31,
int a32,
int a33,
int a34,
int a35,
int a36,
int a37,
int a38,
int a39,
int a40,
int a41,
int a42,
int a43,
int a44,
int a45,
int a46,
int a47,
int a48,
int a49,
int a50,
int a51,
int a52,
int a53,
int a54,
int a55,
int a56,
int a57,
int a58,
int a59,
int a60,
int a61,
int a62)
{
long long v64; // r9
char *v65; // r8
long long v66; // rbp
int v67; // r10d
int v68; // eax
int v69; // ecx
char *v70; // rdx
int v71; // esi
long long v72; // rax
__m128i v73; // xmm1
__m128i *v74; // rdx
long long v75; // rax
_QWORD v77[54]; // [rsp+0h] [rbp-1F8h] BYREF
long long v78; // [rsp+1B4h] [rbp-44h]
unsigned long long v79; // [rsp+1C8h] [rbp-30h]
v79 = __readfsqword(0x28u);
if ( a62 <= 0 )
{
v67 = 0;
}
else
{
v64 = 0LL;
v65 = (char *)&a7 + 4;
v66 = 11LL * a62;
v67 = 0;
do
{
v68 = *((_DWORD *)v65 + 9);
v69 = *((_DWORD *)v65 - 1);
if ( v68 <= 1 )
{
v71 = *((_DWORD *)v65 - 1);
}
else
{
v70 = v65;
v71 = *((_DWORD *)v65 - 1);
do
{
if ( v69 > *(_DWORD *)v70 )
v69 = *(_DWORD *)v70;
if ( v71 < *(_DWORD *)v70 )
v71 = *(_DWORD *)v70;
v70 += 4;
}
while ( v70 != &a8 + 4 * v64 + 4 * (unsigned int)(v68 - 2) );
}
if ( a2 <= v69 && a3 >= v71 )
{
v72 = v67;
v73 = _mm_loadu_si128((const __m128i *)(v65 + 12));
++v67;
v74 = (__m128i *)((char *)v77 + 44 * v72);
*v74 = _mm_loadu_si128((const __m128i *)(v65 - 4));
v75 = *(_QWORD *)(v65 + 28);
v74[1] = v73;
v74[2].m128i_i64[0] = v75;
v74[2].m128i_i32[2] = *((_DWORD *)v65 + 9);
}
v64 += 11LL;
v65 += 44;
}
while ( v64 != v66 );
}
HIDWORD(v78) = v67;
*a1 = v77[0];
*(_QWORD *)((char *)a1 + 436) = v78;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v77 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 444) >> 3));
return a1;
} | func0:
ENDBR64
PUSH R13
MOV R11,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1d8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1c8],RAX
XOR EAX,EAX
MOVSXD RAX,dword ptr [RSP + 0x3b8]
TEST EAX,EAX
JLE 0x0010173f
MOV R12D,EDX
LEA RDX,[RAX + RAX*0x4]
MOV EBX,ESI
XOR R9D,R9D
LEA R8,[RSP + 0x204]
LEA RBP,[RAX + RDX*0x2]
XOR R10D,R10D
LEA R13,[RSP + 0x208]
NOP word ptr [RAX + RAX*0x1]
LAB_00101640:
MOV EAX,dword ptr [R8 + 0x24]
MOV ECX,dword ptr [R8 + -0x4]
CMP EAX,0x1
JLE 0x00101738
SUB EAX,0x2
MOV RDX,R8
MOV ESI,ECX
ADD RAX,R9
LEA RDI,[R13 + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101668:
MOV EAX,dword ptr [RDX]
CMP ECX,EAX
CMOVG ECX,EAX
CMP ESI,EAX
CMOVL ESI,EAX
ADD RDX,0x4
CMP RDX,RDI
JNZ 0x00101668
LAB_0010167d:
CMP EBX,ECX
JG 0x001016c0
CMP R12D,ESI
JL 0x001016c0
MOVSXD RAX,R10D
MOVDQU XMM0,xmmword ptr [R8 + -0x4]
MOVDQU XMM1,xmmword ptr [R8 + 0xc]
ADD R10D,0x1
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
SHL RAX,0x2
LEA RDX,[RSP + RAX*0x1]
MOVUPS xmmword ptr [RSP + RAX*0x1],XMM0
MOV RAX,qword ptr [R8 + 0x1c]
MOVUPS xmmword ptr [RDX + 0x10],XMM1
MOV qword ptr [RDX + 0x20],RAX
MOV EAX,dword ptr [R8 + 0x24]
MOV dword ptr [RDX + 0x28],EAX
LAB_001016c0:
ADD R9,0xb
ADD R8,0x2c
CMP R9,RBP
JNZ 0x00101640
LAB_001016d1:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RSP + 0x1b8],R10D
LEA RDI,[R11 + 0x8]
MOV RSI,RSP
AND RDI,-0x8
MOV qword ptr [R11],RAX
MOV RAX,qword ptr [RSP + 0x1b4]
MOV qword ptr [R11 + 0x1b4],RAX
MOV RAX,R11
SUB RAX,RDI
SUB RSI,RAX
ADD EAX,0x1bc
SHR EAX,0x3
MOV ECX,EAX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RSP + 0x1c8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101744
ADD RSP,0x1d8
MOV RAX,R11
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101738:
MOV ESI,ECX
JMP 0x0010167d
LAB_0010173f:
XOR R10D,R10D
JMP 0x001016d1
LAB_00101744:
CALL 0x00101060 | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int iVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
long lVar5;
long lVar6;
int iVar7;
ulong uVar8;
int *piVar9;
int iVar10;
int8 *puVar11;
int8 *puVar12;
int *piVar13;
long lVar14;
int iVar15;
long in_FS_OFFSET;
int in_stack_000001c0;
int8 local_1f8 [5];
int local_1d0 [99];
int4 local_44;
int iStack_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (in_stack_000001c0 < 1) {
iVar15 = 0;
}
else {
lVar14 = 0;
piVar13 = (int *)&stack0x0000000c;
iVar15 = 0;
do {
iVar7 = piVar13[-1];
iVar10 = iVar7;
if (1 < piVar13[9]) {
piVar9 = piVar13;
do {
iVar1 = *piVar9;
if (iVar1 < iVar7) {
iVar7 = iVar1;
}
if (iVar10 < iVar1) {
iVar10 = iVar1;
}
piVar9 = piVar9 + 1;
} while (piVar9 != (int *)(&stack0x00000010 + ((ulong)(piVar13[9] - 2) + lVar14) * 4));
}
if ((param_2 <= iVar7) && (iVar10 <= param_3)) {
lVar5 = (long)iVar15;
uVar2 = *(int8 *)(piVar13 + 1);
uVar3 = *(int8 *)(piVar13 + 3);
uVar4 = *(int8 *)(piVar13 + 5);
iVar15 = iVar15 + 1;
lVar6 = lVar5 * 0x2c;
*(int8 *)((long)local_1f8 + lVar6) = *(int8 *)(piVar13 + -1);
*(int8 *)((long)local_1f8 + lVar6 + 8) = uVar2;
uVar2 = *(int8 *)(piVar13 + 7);
*(int8 *)((long)local_1f8 + lVar6 + 0x10) = uVar3;
*(int8 *)(local_1d0 + lVar5 * 0xb + -4) = uVar4;
*(int8 *)(local_1d0 + lVar5 * 0xb + -2) = uVar2;
local_1d0[lVar5 * 0xb] = piVar13[9];
}
lVar14 = lVar14 + 0xb;
piVar13 = piVar13 + 0xb;
} while (lVar14 != (long)in_stack_000001c0 * 0xb);
}
iStack_40 = iVar15;
*param_1 = local_1f8[0];
*(ulong *)((long)param_1 + 0x1b4) = CONCAT44(iVar15,local_44);
lVar14 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar11 = (int8 *)((long)local_1f8 - lVar14);
puVar12 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar8 = (ulong)((int)lVar14 + 0x1bcU >> 3); uVar8 != 0; uVar8 = uVar8 - 1) {
*puVar12 = *puVar11;
puVar11 = puVar11 + 1;
puVar12 = puVar12 + 1;
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
7,371 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct {
int elements[10];
int size;
} IntList;
typedef struct {
IntList lists[10];
int size;
} ListOfLists;
int compare_lists(ListOfLists a, ListOfLists b) {
if(a.size != b.size) return 0;
for(int i = 0; i < a.size; i++) {
if(a.lists[i].size != b.lists[i].size) return 0;
for(int j = 0; j < a.lists[i].size; j++) {
if(a.lists[i].elements[j] != b.lists[i].elements[j]) return 0;
}
}
return 1;
}
| ListOfLists func0(ListOfLists list1, int leftrange, int rigthrange) {
ListOfLists result;
result.size = 0;
for(int i = 0; i < list1.size; i++) {
int min = list1.lists[i].elements[0];
int max = list1.lists[i].elements[0];
for(int j = 1; j < list1.lists[i].size; j++) {
if(list1.lists[i].elements[j] < min) min = list1.lists[i].elements[j];
if(list1.lists[i].elements[j] > max) max = list1.lists[i].elements[j];
}
if(min >= leftrange && max <= rigthrange) {
result.lists[result.size++] = list1.lists[i];
}
}
return result;
}
| int main() {
ListOfLists list1;
list1.size = 6;
list1.lists[0].size = 1; list1.lists[0].elements[0] = 2;
list1.lists[1].size = 1; list1.lists[1].elements[0] = 0;
list1.lists[2].size = 3; list1.lists[2].elements[0] = 1; list1.lists[2].elements[1] = 2; list1.lists[2].elements[2] = 3;
list1.lists[3].size = 6; list1.lists[3].elements[0] = 0; list1.lists[3].elements[1] = 1; list1.lists[3].elements[2] = 2;
list1.lists[3].elements[3] = 3; list1.lists[3].elements[4] = 6; list1.lists[3].elements[5] = 7;
list1.lists[4].size = 2; list1.lists[4].elements[0] = 9; list1.lists[4].elements[1] = 11;
list1.lists[5].size = 4; list1.lists[5].elements[0] = 13; list1.lists[5].elements[1] = 14;
list1.lists[5].elements[2] = 15; list1.lists[5].elements[3] = 17;
ListOfLists expected1;
expected1.size = 1;
expected1.lists[0].size = 4; expected1.lists[0].elements[0] = 13; expected1.lists[0].elements[1] = 14;
expected1.lists[0].elements[2] = 15; expected1.lists[0].elements[3] = 17;
ListOfLists result1 = func0(list1, 13, 17);
assert(compare_lists(result1, expected1));
ListOfLists expected2;
expected2.size = 2;
expected2.lists[0].size = 1; expected2.lists[0].elements[0] = 2;
expected2.lists[1].size = 3; expected2.lists[1].elements[0] = 1; expected2.lists[1].elements[1] = 2; expected2.lists[1].elements[2] = 3;
ListOfLists result2 = func0(list1, 1, 3);
assert(compare_lists(result2, expected2));
ListOfLists expected3;
expected3.size = 4;
expected3.lists[0].size = 1; expected3.lists[0].elements[0] = 2;
expected3.lists[1].size = 1; expected3.lists[1].elements[0] = 0;
expected3.lists[2].size = 3; expected3.lists[2].elements[0] = 1; expected3.lists[2].elements[1] = 2; expected3.lists[2].elements[2] = 3;
expected3.lists[3].size = 6; expected3.lists[3].elements[0] = 0; expected3.lists[3].elements[1] = 1;
expected3.lists[3].elements[2] = 2; expected3.lists[3].elements[3] = 3; expected3.lists[3].elements[4] = 6; expected3.lists[3].elements[5] = 7;
ListOfLists result3 = func0(list1, 0, 7);
assert(compare_lists(result3, expected3));
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x1d0,%rsp
mov %fs:0x28,%rax
mov %rax,0x1c8(%rsp)
xor %eax,%eax
mov 0x3b8(%rsp),%ebp
test %ebp,%ebp
jle 1900 <func0+0x230>
mov %esi,%ebx
mov %edx,%r13d
lea 0x200(%rsp),%rcx
xor %esi,%esi
xor %r11d,%r11d
jmpq 18eb <func0+0x21b>
lea -0x2(%r8),%edi
lea -0x1(%r8),%edx
cmp $0x2,%edi
jbe 196f <func0+0x29f>
movd %eax,%xmm5
movdqu 0x4(%rcx),%xmm3
mov %edx,%eax
pshufd $0x0,%xmm5,%xmm0
shr $0x2,%eax
movdqa %xmm0,%xmm1
movdqa %xmm3,%xmm2
pcmpgtd %xmm3,%xmm1
movdqa %xmm1,%xmm4
pand %xmm1,%xmm2
pandn %xmm0,%xmm4
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
por %xmm4,%xmm2
por %xmm1,%xmm0
cmp $0x1,%eax
je 17a2 <func0+0xd2>
movdqu 0x14(%rcx),%xmm1
movdqa %xmm1,%xmm3
pcmpgtd %xmm2,%xmm3
pand %xmm3,%xmm2
pandn %xmm1,%xmm3
por %xmm3,%xmm2
movdqa %xmm1,%xmm3
pcmpgtd %xmm0,%xmm3
pand %xmm3,%xmm1
pandn %xmm0,%xmm3
movdqa %xmm3,%xmm0
por %xmm1,%xmm0
movdqa %xmm0,%xmm3
mov %edx,%r10d
psrldq $0x8,%xmm3
and $0xfffffffc,%r10d
movdqa %xmm3,%xmm1
lea 0x1(%r10),%edi
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm3
pandn %xmm0,%xmm1
movdqa %xmm1,%xmm0
por %xmm3,%xmm0
movdqa %xmm0,%xmm3
psrldq $0x4,%xmm3
movdqa %xmm3,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm3
pandn %xmm0,%xmm1
por %xmm3,%xmm1
movd %xmm1,%r9d
movdqa %xmm2,%xmm1
psrldq $0x8,%xmm1
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm0,%xmm2
movdqa %xmm2,%xmm1
psrldq $0x4,%xmm1
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm0,%xmm2
movd %xmm2,%eax
cmp %edx,%r10d
je 18a0 <func0+0x1d0>
movslq %r11d,%rdx
movslq %edi,%r10
lea (%rdx,%rdx,4),%r14
lea (%rdx,%r14,2),%rdx
add %rdx,%r10
mov 0x200(%rsp,%r10,4),%r10d
cmp %r10d,%eax
cmovg %r10d,%eax
cmp %r10d,%r9d
cmovl %r10d,%r9d
lea 0x1(%rdi),%r10d
cmp %r8d,%r10d
jge 18a0 <func0+0x1d0>
movslq %r10d,%r10
add %rdx,%r10
mov 0x200(%rsp,%r10,4),%r10d
cmp %r10d,%eax
cmovg %r10d,%eax
cmp %r10d,%r9d
cmovl %r10d,%r9d
add $0x2,%edi
cmp %edi,%r8d
jle 18a0 <func0+0x1d0>
movslq %edi,%rdi
add %rdx,%rdi
mov 0x200(%rsp,%rdi,4),%edx
cmp %edx,%eax
cmovg %edx,%eax
cmp %edx,%r9d
cmovl %edx,%r9d
cmp %eax,%ebx
jg 18de <func0+0x20e>
cmp %r9d,%r13d
jl 18de <func0+0x20e>
movslq %esi,%rax
movdqu (%rcx),%xmm6
movdqu 0x10(%rcx),%xmm7
add $0x1,%esi
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rax
shl $0x2,%rax
lea (%rsp,%rax,1),%rdx
movups %xmm6,(%rsp,%rax,1)
mov 0x20(%rcx),%rax
movups %xmm7,0x10(%rdx)
mov %rax,0x20(%rdx)
mov 0x28(%rcx),%eax
mov %eax,0x28(%rdx)
add $0x1,%r11d
add $0x2c,%rcx
cmp %r11d,%ebp
je 1908 <func0+0x238>
mov 0x28(%rcx),%r8d
mov (%rcx),%eax
cmp $0x1,%r8d
jg 1720 <func0+0x50>
mov %eax,%r9d
jmp 18a0 <func0+0x1d0>
xor %esi,%esi
nopw 0x0(%rax,%rax,1)
mov (%rsp),%rax
mov %esi,0x1b8(%rsp)
lea 0x8(%r12),%rdi
mov %rsp,%rsi
and $0xfffffffffffffff8,%rdi
mov %rax,(%r12)
mov 0x1b4(%rsp),%rax
mov %rax,0x1b4(%r12)
mov %r12,%rax
sub %rdi,%rax
sub %rax,%rsi
add $0x1bc,%eax
shr $0x3,%eax
mov %eax,%ecx
rep movsq %ds:(%rsi),%es:(%rdi)
mov 0x1c8(%rsp),%rax
xor %fs:0x28,%rax
jne 197c <func0+0x2ac>
add $0x1d0,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov %eax,%r9d
mov $0x1,%edi
jmpq 1833 <func0+0x163>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov r11, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 1D0h
mov rax, fs:28h
mov [rsp+1F8h+var_30], rax
xor eax, eax
mov r12d, [rsp+1F8h+arg_1B8]
test r12d, r12d
jle loc_1896
mov ebp, esi
mov r13d, edx
lea rcx, [rsp+1F8h+arg_0]
xor ebx, ebx
xor r9d, r9d
jmp loc_1884
loc_16C8:
lea edi, [rsi-2]
lea edx, [rsi-1]
cmp edi, 2
jbe loc_1904
movd xmm5, eax
movdqu xmm3, xmmword ptr [rcx+4]
mov eax, edx
pshufd xmm2, xmm5, 0
shr eax, 2
movdqa xmm0, xmm2
movdqa xmm4, xmm3
pcmpgtd xmm0, xmm3
movdqa xmm1, xmm0
pand xmm4, xmm0
pandn xmm1, xmm2
pand xmm2, xmm0
pandn xmm0, xmm3
por xmm1, xmm4
por xmm0, xmm2
cmp eax, 1
jz short loc_1748
movdqu xmm2, xmmword ptr [rcx+14h]
movdqa xmm3, xmm2
pcmpgtd xmm3, xmm1
pand xmm1, xmm3
pandn xmm3, xmm2
por xmm1, xmm3
movdqa xmm3, xmm2
pcmpgtd xmm3, xmm0
pand xmm2, xmm3
pandn xmm3, xmm0
por xmm3, xmm2
movdqa xmm0, xmm3
loc_1748:
movdqa xmm3, xmm0
psrldq xmm3, 8
movdqa xmm2, xmm3
pcmpgtd xmm2, xmm0
pand xmm3, xmm2
pandn xmm2, xmm0
por xmm2, xmm3
movdqa xmm3, xmm2
movdqa xmm0, xmm2
psrldq xmm3, 4
movdqa xmm2, xmm3
pcmpgtd xmm2, xmm0
pand xmm3, xmm2
pandn xmm2, xmm0
por xmm2, xmm3
movd edi, xmm2
movdqa xmm2, xmm1
psrldq xmm2, 8
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm1, xmm0
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movd eax, xmm0
test dl, 3
jz short loc_183E
and edx, 0FFFFFFFCh
add edx, 1
loc_17D3:
movsxd r10, r9d
movsxd r8, edx
lea r14, [r10+r10*4]
lea r10, [r10+r14*2]
add r8, r10
mov r8d, [rsp+r8*4+1F8h+arg_0]
cmp eax, r8d
cmovg eax, r8d
cmp edi, r8d
cmovl edi, r8d
lea r8d, [rdx+1]
cmp r8d, esi
jge short loc_183E
movsxd r8, r8d
add r8, r10
mov r8d, [rsp+r8*4+1F8h+arg_0]
cmp eax, r8d
cmovg eax, r8d
cmp edi, r8d
cmovl edi, r8d
add edx, 2
cmp esi, edx
jle short loc_183E
movsxd rdx, edx
add r10, rdx
mov edx, [rsp+r10*4+1F8h+arg_0]
cmp eax, edx
cmovg eax, edx
cmp edi, edx
cmovl edi, edx
loc_183E:
cmp ebp, eax
jg short loc_1877
cmp r13d, edi
jl short loc_1877
movsxd rax, ebx
movdqu xmm6, xmmword ptr [rcx]
movdqu xmm7, xmmword ptr [rcx+10h]
add ebx, 1
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
shl rax, 2
movups [rsp+rax+1F8h+var_1F8], xmm6
movdqu xmm6, xmmword ptr [rcx+1Ch]
lea rdx, [rsp+rax+1F8h+var_1F8]
movups xmmword ptr [rdx+10h], xmm7
movups xmmword ptr [rdx+1Ch], xmm6
loc_1877:
add r9d, 1
add rcx, 2Ch ; ','
cmp r12d, r9d
jz short loc_18A0
loc_1884:
mov esi, [rcx+28h]
mov eax, [rcx]
cmp esi, 1
jg loc_16C8
mov edi, eax
jmp short loc_183E
loc_1896:
xor ebx, ebx
nop dword ptr [rax+rax+00000000h]
loc_18A0:
mov rax, qword ptr [rsp+1F8h+var_1F8]
mov [rsp+1F8h+var_40], ebx
lea rdi, [r11+8]
mov rsi, rsp
and rdi, 0FFFFFFFFFFFFFFF8h
mov [r11], rax
mov rax, [rsp+1B4h]
mov [r11+1B4h], rax
mov rax, r11
sub rax, rdi
sub rsi, rax
add eax, 1BCh
shr eax, 3
mov ecx, eax
rep movsq
mov rax, [rsp+1F8h+var_30]
sub rax, fs:28h
jnz short loc_1910
add rsp, 1D0h
mov rax, r11
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1904:
mov edi, eax
mov edx, 1
jmp loc_17D3
loc_1910:
call ___stack_chk_fail | _QWORD * func0(
_QWORD *a1,
signed int a2,
int a3,
long long a4,
long long a5,
long long a6,
int a7,
int a8,
int a9,
int a10,
int a11,
int a12,
int a13,
int a14,
int a15,
int a16,
int a17,
int a18,
int a19,
int a20,
int a21,
int a22,
int a23,
int a24,
int a25,
int a26,
int a27,
int a28,
int a29,
int a30,
int a31,
int a32,
int a33,
int a34,
int a35,
int a36,
int a37,
int a38,
int a39,
int a40,
int a41,
int a42,
int a43,
int a44,
int a45,
int a46,
int a47,
int a48,
int a49,
int a50,
int a51,
int a52,
int a53,
int a54,
int a55,
int a56,
int a57,
int a58,
int a59,
int a60,
int a61,
int a62)
{
int v63; // r12d
int *v66; // rcx
int v67; // ebx
int v68; // r9d
unsigned int v69; // edx
__m128i v70; // xmm3
__m128i v71; // xmm2
__m128i v72; // xmm0
__m128i v73; // xmm1
__m128i v74; // xmm0
__m128i v75; // xmm2
__m128i v76; // xmm3
__m128i v77; // xmm3
__m128i v78; // xmm3
__m128i v79; // xmm2
__m128i v80; // xmm0
__m128i v81; // xmm3
__m128i v82; // xmm2
int v83; // edi
__m128i v84; // xmm2
__m128i v85; // xmm0
__m128i v86; // xmm1
__m128i v87; // xmm2
__m128i v88; // xmm0
signed int v89; // eax
signed int v90; // edx
long long v91; // r10
signed int v92; // r8d
signed int v93; // r8d
int v94; // edx
signed int v95; // edx
long long v96; // rax
__m128i v97; // xmm7
__m128i v98; // xmm6
char *v99; // rdx
int v100; // esi
_QWORD v102[54]; // [rsp+0h] [rbp-1F8h] BYREF
long long v103; // [rsp+1B4h] [rbp-44h]
unsigned long long v104; // [rsp+1C8h] [rbp-30h]
v104 = __readfsqword(0x28u);
v63 = a62;
if ( a62 > 0 )
{
v66 = &a7;
v67 = 0;
v68 = 0;
while ( 1 )
{
v100 = v66[10];
v89 = *v66;
if ( v100 > 1 )
{
v69 = v100 - 1;
if ( (unsigned int)(v100 - 2) <= 2 )
{
v83 = *v66;
v90 = 1;
}
else
{
v70 = _mm_loadu_si128((const __m128i *)(v66 + 1));
v71 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v89), 0);
v72 = _mm_cmpgt_epi32(v71, v70);
v73 = _mm_or_si128(_mm_andnot_si128(v72, v71), _mm_and_si128(v70, v72));
v74 = _mm_or_si128(_mm_andnot_si128(v72, v70), _mm_and_si128(v71, v72));
if ( v69 >> 2 != 1 )
{
v75 = _mm_loadu_si128((const __m128i *)(v66 + 5));
v76 = _mm_cmpgt_epi32(v75, v73);
v73 = _mm_or_si128(_mm_and_si128(v73, v76), _mm_andnot_si128(v76, v75));
v77 = _mm_cmpgt_epi32(v75, v74);
v74 = _mm_or_si128(_mm_andnot_si128(v77, v74), _mm_and_si128(v75, v77));
}
v78 = _mm_srli_si128(v74, 8);
v79 = _mm_cmpgt_epi32(v78, v74);
v80 = _mm_or_si128(_mm_andnot_si128(v79, v74), _mm_and_si128(v78, v79));
v81 = _mm_srli_si128(v80, 4);
v82 = _mm_cmpgt_epi32(v81, v80);
v83 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v82, v80), _mm_and_si128(v81, v82)));
v84 = _mm_srli_si128(v73, 8);
v85 = _mm_cmpgt_epi32(v84, v73);
v86 = _mm_or_si128(_mm_and_si128(v73, v85), _mm_andnot_si128(v85, v84));
v87 = _mm_srli_si128(v86, 4);
v88 = _mm_cmpgt_epi32(v87, v86);
v89 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v88, v87), _mm_and_si128(v86, v88)));
if ( (v69 & 3) == 0 )
goto LABEL_22;
v90 = (v69 & 0xFFFFFFFC) + 1;
}
v91 = 11LL * v68;
v92 = *(&a7 + v91 + v90);
if ( v89 > v92 )
v89 = *(&a7 + v91 + v90);
if ( v83 < v92 )
v83 = *(&a7 + v91 + v90);
if ( v90 + 1 < v100 )
{
v93 = *(&a7 + v91 + v90 + 1);
if ( v89 > v93 )
v89 = *(&a7 + v91 + v90 + 1);
if ( v83 < v93 )
v83 = *(&a7 + v91 + v90 + 1);
v94 = v90 + 2;
if ( v100 > v94 )
{
v95 = *(&a7 + v94 + v91);
if ( v89 > v95 )
v89 = v95;
if ( v83 < v95 )
v83 = v95;
}
}
}
else
{
v83 = *v66;
}
LABEL_22:
if ( a2 <= v89 && a3 >= v83 )
{
v96 = v67;
v97 = _mm_loadu_si128((const __m128i *)v66 + 1);
++v67;
v96 *= 44LL;
*(__m128i *)((char *)v102 + v96) = _mm_loadu_si128((const __m128i *)v66);
v98 = _mm_loadu_si128((const __m128i *)(v66 + 7));
v99 = (char *)v102 + v96;
*((__m128i *)v99 + 1) = v97;
*(__m128i *)(v99 + 28) = v98;
}
++v68;
v66 += 11;
if ( v63 == v68 )
goto LABEL_29;
}
}
v67 = 0;
LABEL_29:
HIDWORD(v103) = v67;
*a1 = v102[0];
*(_QWORD *)((char *)a1 + 436) = v103;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v102 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 444) >> 3));
return a1;
} | func0:
ENDBR64
PUSH R14
MOV R11,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1d0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1c8],RAX
XOR EAX,EAX
MOV R12D,dword ptr [RSP + 0x3b8]
TEST R12D,R12D
JLE 0x00101896
MOV EBP,ESI
MOV R13D,EDX
LEA RCX,[RSP + 0x200]
XOR EBX,EBX
XOR R9D,R9D
JMP 0x00101884
LAB_001016c8:
LEA EDI,[RSI + -0x2]
LEA EDX,[RSI + -0x1]
CMP EDI,0x2
JBE 0x00101904
MOVD XMM5,EAX
MOVDQU XMM3,xmmword ptr [RCX + 0x4]
MOV EAX,EDX
PSHUFD XMM2,XMM5,0x0
SHR EAX,0x2
MOVDQA XMM0,XMM2
MOVDQA XMM4,XMM3
PCMPGTD XMM0,XMM3
MOVDQA XMM1,XMM0
PAND XMM4,XMM0
PANDN XMM1,XMM2
PAND XMM2,XMM0
PANDN XMM0,XMM3
POR XMM1,XMM4
POR XMM0,XMM2
CMP EAX,0x1
JZ 0x00101748
MOVDQU XMM2,xmmword ptr [RCX + 0x14]
MOVDQA XMM3,XMM2
PCMPGTD XMM3,XMM1
PAND XMM1,XMM3
PANDN XMM3,XMM2
POR XMM1,XMM3
MOVDQA XMM3,XMM2
PCMPGTD XMM3,XMM0
PAND XMM2,XMM3
PANDN XMM3,XMM0
POR XMM3,XMM2
MOVDQA XMM0,XMM3
LAB_00101748:
MOVDQA XMM3,XMM0
PSRLDQ XMM3,0x8
MOVDQA XMM2,XMM3
PCMPGTD XMM2,XMM0
PAND XMM3,XMM2
PANDN XMM2,XMM0
POR XMM2,XMM3
MOVDQA XMM3,XMM2
MOVDQA XMM0,XMM2
PSRLDQ XMM3,0x4
MOVDQA XMM2,XMM3
PCMPGTD XMM2,XMM0
PAND XMM3,XMM2
PANDN XMM2,XMM0
POR XMM2,XMM3
MOVD EDI,XMM2
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x8
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM1,XMM0
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVD EAX,XMM0
TEST DL,0x3
JZ 0x0010183e
AND EDX,0xfffffffc
ADD EDX,0x1
LAB_001017d3:
MOVSXD R10,R9D
MOVSXD R8,EDX
LEA R14,[R10 + R10*0x4]
LEA R10,[R10 + R14*0x2]
ADD R8,R10
MOV R8D,dword ptr [RSP + R8*0x4 + 0x200]
CMP EAX,R8D
CMOVG EAX,R8D
CMP EDI,R8D
CMOVL EDI,R8D
LEA R8D,[RDX + 0x1]
CMP R8D,ESI
JGE 0x0010183e
MOVSXD R8,R8D
ADD R8,R10
MOV R8D,dword ptr [RSP + R8*0x4 + 0x200]
CMP EAX,R8D
CMOVG EAX,R8D
CMP EDI,R8D
CMOVL EDI,R8D
ADD EDX,0x2
CMP ESI,EDX
JLE 0x0010183e
MOVSXD RDX,EDX
ADD R10,RDX
MOV EDX,dword ptr [RSP + R10*0x4 + 0x200]
CMP EAX,EDX
CMOVG EAX,EDX
CMP EDI,EDX
CMOVL EDI,EDX
LAB_0010183e:
CMP EBP,EAX
JG 0x00101877
CMP R13D,EDI
JL 0x00101877
MOVSXD RAX,EBX
MOVDQU XMM6,xmmword ptr [RCX]
MOVDQU XMM7,xmmword ptr [RCX + 0x10]
ADD EBX,0x1
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
SHL RAX,0x2
MOVUPS xmmword ptr [RSP + RAX*0x1],XMM6
MOVDQU XMM6,xmmword ptr [RCX + 0x1c]
LEA RDX,[RSP + RAX*0x1]
MOVUPS xmmword ptr [RDX + 0x10],XMM7
MOVUPS xmmword ptr [RDX + 0x1c],XMM6
LAB_00101877:
ADD R9D,0x1
ADD RCX,0x2c
CMP R12D,R9D
JZ 0x001018a0
LAB_00101884:
MOV ESI,dword ptr [RCX + 0x28]
MOV EAX,dword ptr [RCX]
CMP ESI,0x1
JG 0x001016c8
MOV EDI,EAX
JMP 0x0010183e
LAB_00101896:
XOR EBX,EBX
NOP dword ptr [RAX + RAX*0x1]
LAB_001018a0:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RSP + 0x1b8],EBX
LEA RDI,[R11 + 0x8]
MOV RSI,RSP
AND RDI,-0x8
MOV qword ptr [R11],RAX
MOV RAX,qword ptr [RSP + 0x1b4]
MOV qword ptr [R11 + 0x1b4],RAX
MOV RAX,R11
SUB RAX,RDI
SUB RSI,RAX
ADD EAX,0x1bc
SHR EAX,0x3
MOV ECX,EAX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RSP + 0x1c8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101910
ADD RSP,0x1d0
MOV RAX,R11
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101904:
MOV EDI,EAX
MOV EDX,0x1
JMP 0x001017d3
LAB_00101910:
CALL 0x00101060 | int8 * func0(int8 *param_1,int param_2,int param_3)
{
uint uVar1;
uint uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
long lVar7;
uint *puVar8;
ulong uVar9;
uint uVar10;
int iVar11;
int iVar12;
int8 *puVar13;
int8 *puVar14;
int iVar15;
long in_FS_OFFSET;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
uint uVar24;
uint uVar25;
uint uVar26;
uint uVar27;
int param_11;
int8 local_1f8 [3];
int8 auStack_1dc [51];
int4 local_44;
int iStack_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_11 < 1) {
iVar12 = 0;
}
else {
puVar8 = (uint *)&stack0x00000008;
iVar12 = 0;
iVar15 = 0;
do {
uVar1 = puVar8[10];
uVar27 = *puVar8;
uVar17 = uVar27;
if (1 < (int)uVar1) {
uVar10 = uVar1 - 1;
if (uVar1 - 2 < 3) {
iVar11 = 1;
}
else {
uVar17 = puVar8[1];
uVar19 = puVar8[2];
uVar21 = puVar8[3];
uVar2 = puVar8[4];
uVar16 = -(uint)((int)uVar17 < (int)uVar27);
uVar18 = -(uint)((int)uVar19 < (int)uVar27);
uVar20 = -(uint)((int)uVar21 < (int)uVar27);
uVar22 = -(uint)((int)uVar2 < (int)uVar27);
uVar23 = ~uVar16 & uVar27 | uVar17 & uVar16;
uVar24 = ~uVar18 & uVar27 | uVar19 & uVar18;
uVar25 = ~uVar20 & uVar27 | uVar21 & uVar20;
uVar26 = ~uVar22 & uVar27 | uVar2 & uVar22;
uVar17 = ~uVar16 & uVar17 | uVar27 & uVar16;
uVar19 = ~uVar18 & uVar19 | uVar27 & uVar18;
uVar21 = ~uVar20 & uVar21 | uVar27 & uVar20;
uVar27 = ~uVar22 & uVar2 | uVar27 & uVar22;
if (uVar10 >> 2 != 1) {
uVar2 = puVar8[5];
uVar16 = puVar8[6];
uVar18 = puVar8[7];
uVar20 = puVar8[8];
uVar23 = uVar23 & -(uint)((int)uVar23 < (int)uVar2) |
~-(uint)((int)uVar23 < (int)uVar2) & uVar2;
uVar24 = uVar24 & -(uint)((int)uVar24 < (int)uVar16) |
~-(uint)((int)uVar24 < (int)uVar16) & uVar16;
uVar25 = uVar25 & -(uint)((int)uVar25 < (int)uVar18) |
~-(uint)((int)uVar25 < (int)uVar18) & uVar18;
uVar26 = uVar26 & -(uint)((int)uVar26 < (int)uVar20) |
~-(uint)((int)uVar26 < (int)uVar20) & uVar20;
uVar17 = ~-(uint)((int)uVar17 < (int)uVar2) & uVar17 |
uVar2 & -(uint)((int)uVar17 < (int)uVar2);
uVar19 = ~-(uint)((int)uVar19 < (int)uVar16) & uVar19 |
uVar16 & -(uint)((int)uVar19 < (int)uVar16);
uVar21 = ~-(uint)((int)uVar21 < (int)uVar18) & uVar21 |
uVar18 & -(uint)((int)uVar21 < (int)uVar18);
uVar27 = ~-(uint)((int)uVar27 < (int)uVar20) & uVar27 |
uVar20 & -(uint)((int)uVar27 < (int)uVar20);
}
uVar17 = ~-(uint)((int)uVar17 < (int)uVar21) & uVar17 |
uVar21 & -(uint)((int)uVar17 < (int)uVar21);
uVar19 = ~-(uint)((int)uVar19 < (int)uVar27) & uVar19 |
uVar27 & -(uint)((int)uVar19 < (int)uVar27);
uVar27 = -(uint)((int)uVar17 < (int)uVar19);
uVar27 = ~uVar27 & uVar17 | uVar19 & uVar27;
uVar19 = uVar23 & -(uint)((int)uVar23 < (int)uVar25) |
~-(uint)((int)uVar23 < (int)uVar25) & uVar25;
uVar21 = uVar24 & -(uint)((int)uVar24 < (int)uVar26) |
~-(uint)((int)uVar24 < (int)uVar26) & uVar26;
uVar17 = -(uint)((int)uVar19 < (int)uVar21);
uVar17 = ~uVar17 & uVar21 | uVar19 & uVar17;
if ((uVar10 & 3) == 0) goto LAB_0010183e;
iVar11 = (uVar10 & 0xfffffffc) + 1;
}
lVar7 = (long)iVar15 * 0xb;
uVar10 = *(uint *)(&stack0x00000008 + (iVar11 + lVar7) * 4);
if ((int)uVar10 < (int)uVar17) {
uVar17 = uVar10;
}
if ((int)uVar27 < (int)uVar10) {
uVar27 = uVar10;
}
if (iVar11 + 1 < (int)uVar1) {
uVar10 = *(uint *)(&stack0x00000008 + ((iVar11 + 1) + lVar7) * 4);
if ((int)uVar10 < (int)uVar17) {
uVar17 = uVar10;
}
if ((int)uVar27 < (int)uVar10) {
uVar27 = uVar10;
}
if (iVar11 + 2 < (int)uVar1) {
uVar1 = *(uint *)(&stack0x00000008 + (lVar7 + (iVar11 + 2)) * 4);
if ((int)uVar1 < (int)uVar17) {
uVar17 = uVar1;
}
if ((int)uVar27 < (int)uVar1) {
uVar27 = uVar1;
}
}
}
}
LAB_0010183e:
if ((param_2 <= (int)uVar17) && ((int)uVar27 <= param_3)) {
lVar7 = (long)iVar12;
uVar3 = *(int8 *)(puVar8 + 2);
uVar4 = *(int8 *)(puVar8 + 4);
uVar5 = *(int8 *)(puVar8 + 6);
iVar12 = iVar12 + 1;
lVar7 = lVar7 * 0x2c;
*(int8 *)((long)local_1f8 + lVar7) = *(int8 *)puVar8;
*(int8 *)((long)local_1f8 + lVar7 + 8) = uVar3;
uVar3 = *(int8 *)(puVar8 + 7);
uVar6 = *(int8 *)(puVar8 + 9);
*(int8 *)((long)local_1f8 + lVar7 + 0x10) = uVar4;
*(int8 *)(&stack0xfffffffffffffe20 + lVar7) = uVar5;
*(int8 *)((long)auStack_1dc + lVar7) = uVar3;
*(int8 *)((long)auStack_1dc + lVar7 + 8) = uVar6;
}
iVar15 = iVar15 + 1;
puVar8 = puVar8 + 0xb;
} while (param_11 != iVar15);
}
iStack_40 = iVar12;
*param_1 = local_1f8[0];
*(ulong *)((long)param_1 + 0x1b4) = CONCAT44(iVar12,local_44);
lVar7 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar13 = (int8 *)((long)local_1f8 - lVar7);
puVar14 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar9 = (ulong)((int)lVar7 + 0x1bcU >> 3); uVar9 != 0; uVar9 = uVar9 - 1) {
*puVar14 = *puVar13;
puVar13 = puVar13 + 1;
puVar14 = puVar14 + 1;
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
7,372 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == 48);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == 50);
assert(func0(array3, sizeof(array3)/sizeof(array3[0])) == 522);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11bf <func0+0x56>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 11bb <func0+0x52>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
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_8], 0
mov [rbp+var_4], 0
jmp short loc_11BF
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short loc_11BB
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_11BB:
add [rbp+var_4], 1
loc_11BF:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) > 0 )
v3 += *(_DWORD *)(4LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011bf
LAB_00101188:
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]
TEST EAX,EAX
JLE 0x001011bb
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]
ADD dword ptr [RBP + -0x8],EAX
LAB_001011bb:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011bf:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (0 < *(int *)(param_1 + (long)local_c * 4)) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
}
return local_10;
} |
7,373 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == 48);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == 50);
assert(func0(array3, sizeof(array3)/sizeof(array3[0])) == 522);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1197 <func0+0x2e>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdi
mov $0x0,%edx
mov (%rax),%ecx
lea (%rdx,%rcx,1),%esi
test %ecx,%ecx
cmovg %esi,%edx
add $0x4,%rax
cmp %rdi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1194 <func0+0x2b>
| func0:
endbr64
test esi, esi
jle short loc_1197
mov rax, rdi
lea edx, [rsi-1]
lea rdi, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
mov ecx, [rax]
lea esi, [rdx+rcx]
test ecx, ecx
cmovg edx, esi
add rax, 4
cmp rax, rdi
jnz short loc_1181
loc_1194:
mov eax, edx
retn
loc_1197:
mov edx, 0
jmp short loc_1194 | long long func0(int *a1, int a2)
{
int *v2; // rax
long long v3; // rdi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
if ( *v2 > 0 )
v4 += *v2;
++v2;
}
while ( v2 != (int *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101197
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RDI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
TEST ECX,ECX
CMOVG EDX,ESI
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101181
LAB_00101194:
MOV EAX,EDX
RET
LAB_00101197:
MOV EDX,0x0
JMP 0x00101194 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if (0 < *param_1) {
iVar2 = iVar2 + *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
7,374 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == 48);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == 50);
assert(func0(array3, sizeof(array3)/sizeof(array3[0])) == 522);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13a0 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%edx
test %edx,%edx
lea (%rax,%rdx,1),%ecx
cmovg %ecx,%eax
add $0x4,%rdi
cmp %rsi,%rdi
jne 1388 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1390
lea eax, [rsi-1]
lea rsi, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1378:
mov edx, [rdi]
test edx, edx
lea ecx, [rax+rdx]
cmovg eax, ecx
add rdi, 4
cmp rdi, rsi
jnz short loc_1378
retn
loc_1390:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long v2; // rsi
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
result = 0LL;
do
{
if ( *a1 > 0 )
result = (unsigned int)(result + *a1);
++a1;
}
while ( a1 != (int *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101390
LEA EAX,[RSI + -0x1]
LEA RSI,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101378:
MOV EDX,dword ptr [RDI]
TEST EDX,EDX
LEA ECX,[RAX + RDX*0x1]
CMOVG EAX,ECX
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x00101378
RET
LAB_00101390:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if (0 < *param_1) {
iVar2 = iVar2 + *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
} |
7,375 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == 48);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == 50);
assert(func0(array3, sizeof(array3)/sizeof(array3[0])) == 522);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11f8 <func0+0xb8>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1201 <func0+0xc1>
mov %esi,%edx
pxor %xmm1,%xmm1
mov %rdi,%rax
shr $0x2,%edx
movdqa %xmm1,%xmm2
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm0
movdqu (%rax),%xmm3
add $0x10,%rax
pcmpgtd %xmm2,%xmm0
pand %xmm3,%xmm0
paddd %xmm0,%xmm1
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm1,%xmm0
mov %esi,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 1200 <func0+0xc0>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
lea (%rax,%rcx,1),%r8d
test %ecx,%ecx
lea 0x1(%rdx),%ecx
cmovg %r8d,%eax
cmp %esi,%ecx
jge 11fa <func0+0xba>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
test %ecx,%ecx
lea (%rax,%rcx,1),%r8d
cmovg %r8d,%eax
add $0x2,%edx
cmp %esi,%edx
jge 11fa <func0+0xba>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
lea (%rax,%rdx,1),%ecx
test %edx,%edx
cmovg %ecx,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 11b6 <func0+0x76>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1200
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1209
mov edx, esi
pxor xmm0, xmm0
mov rax, rdi
shr edx, 2
movdqa xmm2, xmm0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1178:
movdqu xmm1, xmmword ptr [rax]
movdqu xmm3, xmmword ptr [rax]
add rax, 10h
pcmpgtd xmm1, xmm2
pand xmm1, xmm3
paddd xmm0, xmm1
cmp rdx, rax
jnz short loc_1178
movdqa xmm1, xmm0
mov edx, ecx
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test cl, 3
jz short locret_1208
loc_11BD:
movsxd rsi, edx
lea r8, ds:0[rsi*4]
mov esi, [rdi+rsi*4]
lea r9d, [rax+rsi]
test esi, esi
lea esi, [rdx+1]
cmovg eax, r9d
cmp ecx, esi
jle short locret_1202
mov esi, [rdi+r8+4]
test esi, esi
lea r9d, [rax+rsi]
cmovg eax, r9d
add edx, 2
cmp ecx, edx
jle short locret_1202
mov edx, [rdi+r8+8]
lea ecx, [rax+rdx]
test edx, edx
cmovg eax, ecx
retn
loc_1200:
xor eax, eax
locret_1202:
retn
locret_1208:
retn
loc_1209:
xor edx, edx
xor eax, eax
jmp short loc_11BD | long long func0(const __m128i *a1, int a2)
{
__m128i v3; // xmm0
const __m128i *v4; // rax
__m128i v5; // xmm1
signed int v6; // edx
__m128i v7; // xmm0
long long result; // rax
long long v9; // r8
int v10; // esi
int v11; // esi
int v12; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v6 = 0;
result = 0LL;
}
else
{
v3 = 0LL;
v4 = a1;
do
{
v5 = _mm_loadu_si128(v4++);
v3 = _mm_add_epi32(v3, _mm_and_si128(_mm_cmpgt_epi32(v5, (__m128i)0LL), v5));
}
while ( &a1[(unsigned int)a2 >> 2] != v4 );
v6 = a2 & 0xFFFFFFFC;
v7 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v7, _mm_srli_si128(v7, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v9 = v6;
v10 = a1->m128i_i32[v9];
if ( v10 > 0 )
result = (unsigned int)(result + v10);
if ( a2 > v6 + 1 )
{
v11 = a1->m128i_i32[v9 + 1];
if ( v11 > 0 )
result = (unsigned int)(result + v11);
if ( a2 > v6 + 2 )
{
v12 = a1->m128i_i32[v9 + 2];
if ( v12 > 0 )
return (unsigned int)(result + v12);
}
}
return result;
} | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101200
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101209
MOV EDX,ESI
PXOR XMM0,XMM0
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM2,XMM0
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM1,xmmword ptr [RAX]
MOVDQU XMM3,xmmword ptr [RAX]
ADD RAX,0x10
PCMPGTD XMM1,XMM2
PAND XMM1,XMM3
PADDD XMM0,XMM1
CMP RDX,RAX
JNZ 0x00101178
MOVDQA XMM1,XMM0
MOV EDX,ECX
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x00101208
LAB_001011bd:
MOVSXD RSI,EDX
LEA R8,[RSI*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
LEA R9D,[RAX + RSI*0x1]
TEST ESI,ESI
LEA ESI,[RDX + 0x1]
CMOVG EAX,R9D
CMP ECX,ESI
JLE 0x00101202
MOV ESI,dword ptr [RDI + R8*0x1 + 0x4]
TEST ESI,ESI
LEA R9D,[RAX + RSI*0x1]
CMOVG EAX,R9D
ADD EDX,0x2
CMP ECX,EDX
JLE 0x00101202
MOV EDX,dword ptr [RDI + R8*0x1 + 0x8]
LEA ECX,[RAX + RDX*0x1]
TEST EDX,EDX
CMOVG EAX,ECX
RET
LAB_00101200:
XOR EAX,EAX
LAB_00101202:
RET
LAB_00101208:
RET
LAB_00101209:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011bd | int func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
if ((int)param_2 < 1) {
iVar10 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar9 = 0;
iVar10 = 0;
}
else {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
puVar8 = param_1;
do {
uVar9 = *puVar8;
puVar1 = puVar8 + 1;
puVar2 = puVar8 + 2;
puVar3 = puVar8 + 3;
uVar4 = *puVar8;
puVar5 = puVar8 + 1;
puVar6 = puVar8 + 2;
puVar7 = puVar8 + 3;
puVar8 = puVar8 + 4;
iVar10 = iVar10 + (-(uint)(0 < (int)uVar9) & uVar4);
iVar11 = iVar11 + (-(uint)(0 < (int)*puVar1) & *puVar5);
iVar12 = iVar12 + (-(uint)(0 < (int)*puVar2) & *puVar6);
iVar13 = iVar13 + (-(uint)(0 < (int)*puVar3) & *puVar7);
} while (param_1 + (ulong)(param_2 >> 2) * 4 != puVar8);
uVar9 = param_2 & 0xfffffffc;
iVar10 = iVar10 + iVar12 + iVar11 + iVar13;
if ((param_2 & 3) == 0) {
return iVar10;
}
}
if (0 < (int)param_1[(int)uVar9]) {
iVar10 = iVar10 + param_1[(int)uVar9];
}
if ((int)(uVar9 + 1) < (int)param_2) {
if (0 < (int)param_1[(long)(int)uVar9 + 1]) {
iVar10 = iVar10 + param_1[(long)(int)uVar9 + 1];
}
if ((int)(uVar9 + 2) < (int)param_2) {
if (0 < (int)param_1[(long)(int)uVar9 + 2]) {
iVar10 = iVar10 + param_1[(long)(int)uVar9 + 2];
}
return iVar10;
}
}
}
return iVar10;
} |
7,376 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *string1, char *string2) {
int size1 = strlen(string1);
int size2 = strlen(string2);
if (size1 != size2)
return 0;
char temp[2 * size1 + 1];
strcpy(temp, string1);
strcat(temp, string1);
if (strstr(temp, string2) != NULL)
return 1;
else
return 0;
}
| int main() {
assert(func0("abc", "cba") == 0);
assert(func0("abcd", "cdba") == 0);
assert(func0("abacd", "cdaba") == 1);
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 %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
mov -0x58(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x50(%rbp)
mov -0x60(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x4c(%rbp)
mov -0x50(%rbp),%eax
cmp -0x4c(%rbp),%eax
je 124b <func0+0x62>
mov $0x0,%eax
jmpq 133e <func0+0x155>
mov -0x50(%rbp),%eax
add %eax,%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x48(%rbp)
movslq %eax,%rdx
mov %rdx,%r14
mov $0x0,%r15d
movslq %eax,%rdx
mov %rdx,%r12
mov $0x0,%r13d
cltq
mov $0x10,%edx
sub $0x1,%rdx
add %rdx,%rax
mov $0x10,%ecx
mov $0x0,%edx
div %rcx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rcx
sub %rdx,%rcx
mov %rcx,%rdx
cmp %rdx,%rsp
je 12bf <func0+0xd6>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 12a8 <func0+0xbf>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 12e9 <func0+0x100>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x0,%rax
mov %rax,-0x40(%rbp)
mov -0x58(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10a0 <strcpy@plt>
mov -0x58(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10e0 <strcat@plt>
mov -0x60(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10f0 <strstr@plt>
test %rax,%rax
je 1339 <func0+0x150>
mov $0x1,%eax
jmp 133e <func0+0x155>
mov $0x0,%eax
mov %rbx,%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 1355 <func0+0x16c>
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 [rbp+needle], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_30], eax
mov rax, [rbp+needle]
mov rdi, rax; s
call _strlen
mov [rbp+var_2C], eax
mov eax, [rbp+var_30]
cmp eax, [rbp+var_2C]
jz short loc_1243
mov eax, 0
jmp loc_131B
loc_1243:
mov eax, [rbp+var_30]
add eax, eax
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_28], rdx
cdqe
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_1285:
cmp rsp, rdx
jz short loc_129C
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_1285
loc_129C:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12C6
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12C6:
mov rax, rsp
add rax, 0
mov [rbp+dest], rax
mov rdx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rdx, [rbp+s]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
mov rdx, [rbp+needle]
mov rax, [rbp+dest]
mov rsi, rdx; needle
mov rdi, rax; haystack
call _strstr
test rax, rax
jz short loc_1316
mov eax, 1
jmp short loc_131B
loc_1316:
mov eax, 0
loc_131B:
mov rsp, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1332
call ___stack_chk_fail
loc_1332:
mov rbx, [rbp+var_8]
leave
retn | _BOOL8 func0(char *a1, char *a2)
{
int v3; // eax
unsigned long long v4; // rax
void *v5; // rsp
char *needle; // [rsp+8h] [rbp-40h] BYREF
char *s; // [rsp+10h] [rbp-38h]
int v8; // [rsp+18h] [rbp-30h]
int v9; // [rsp+1Ch] [rbp-2Ch]
long long v10; // [rsp+20h] [rbp-28h]
char *dest; // [rsp+28h] [rbp-20h]
unsigned long long v12; // [rsp+30h] [rbp-18h]
s = a1;
needle = a2;
v12 = __readfsqword(0x28u);
v8 = strlen(a1);
v9 = strlen(a2);
if ( v8 != v9 )
return 0LL;
v3 = 2 * v8 + 1;
v10 = v3 - 1LL;
v4 = 16 * ((v3 + 15LL) / 0x10uLL);
while ( &needle != (char **)((char *)&needle - (v4 & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(char **)((char *)&needle + (v4 & 0xFFF) - 8) = *(char **)((char *)&needle + (v4 & 0xFFF) - 8);
dest = (char *)&needle;
strcpy((char *)&needle, s);
strcat(dest, s);
return strstr(dest, needle) != 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x2c]
JZ 0x00101243
MOV EAX,0x0
JMP 0x0010131b
LAB_00101243:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EAX
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
CDQE
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_00101285:
CMP RSP,RDX
JZ 0x0010129c
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101285
LAB_0010129c:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012c6
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012c6:
MOV RAX,RSP
ADD RAX,0x0
MOV qword ptr [RBP + -0x20],RAX
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010a0
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010e0
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010f0
TEST RAX,RAX
JZ 0x00101316
MOV EAX,0x1
JMP 0x0010131b
LAB_00101316:
MOV EAX,0x0
LAB_0010131b:
MOV RSP,RBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101332
CALL 0x001010c0
LAB_00101332:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int8 func0(char *param_1,char *param_2)
{
long lVar1;
char *pcVar2;
int iVar3;
size_t sVar4;
int8 uVar5;
ulong uVar6;
char *pcVar7;
char **ppcVar8;
long in_FS_OFFSET;
char *local_48;
char *local_40;
int local_38;
int local_34;
long local_30;
char *local_28;
long local_20;
ppcVar8 = &local_48;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = param_2;
local_40 = param_1;
sVar4 = strlen(param_1);
local_38 = (int)sVar4;
sVar4 = strlen(local_48);
local_34 = (int)sVar4;
if (local_38 == (int)sVar4) {
iVar3 = local_38 * 2 + 1;
local_30 = (long)iVar3 + -1;
uVar6 = (((long)iVar3 + 0xfU) / 0x10) * 0x10;
for (; ppcVar8 != (char **)((long)&local_48 - (uVar6 & 0xfffffffffffff000));
ppcVar8 = (char **)((long)ppcVar8 + -0x1000)) {
*(int8 *)((long)ppcVar8 + -8) = *(int8 *)((long)ppcVar8 + -8);
}
lVar1 = -(ulong)((uint)uVar6 & 0xfff);
if ((uVar6 & 0xfff) != 0) {
*(int8 *)((long)ppcVar8 + ((ulong)((uint)uVar6 & 0xfff) - 8) + lVar1) =
*(int8 *)((long)ppcVar8 + ((ulong)((uint)uVar6 & 0xfff) - 8) + lVar1);
}
pcVar7 = local_40;
local_28 = (char *)((long)ppcVar8 + lVar1);
*(int8 *)((long)ppcVar8 + lVar1 + -8) = 0x1012e4;
strcpy((char *)((long)ppcVar8 + lVar1),pcVar7);
pcVar2 = local_28;
pcVar7 = local_40;
*(int8 *)((long)ppcVar8 + lVar1 + -8) = 0x1012f7;
strcat(pcVar2,pcVar7);
pcVar2 = local_28;
pcVar7 = local_48;
*(int8 *)((long)ppcVar8 + lVar1 + -8) = 0x10130a;
pcVar7 = strstr(pcVar2,pcVar7);
if (pcVar7 == (char *)0x0) {
uVar5 = 0;
}
else {
uVar5 = 1;
}
}
else {
uVar5 = 0;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar5;
} |
7,377 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *string1, char *string2) {
int size1 = strlen(string1);
int size2 = strlen(string2);
if (size1 != size2)
return 0;
char temp[2 * size1 + 1];
strcpy(temp, string1);
strcat(temp, string1);
if (strstr(temp, string2) != NULL)
return 1;
else
return 0;
}
| int main() {
assert(func0("abc", "cba") == 0);
assert(func0("abcd", "cdba") == 0);
assert(func0("abacd", "cdaba") == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov $0xffffffffffffffff,%rsi
mov %rsi,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rdx
mov %rsi,%rcx
mov %r12,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
mov $0x0,%ecx
cmp %eax,%edx
je 1239 <func0+0x70>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
jne 12b5 <func0+0xec>
mov %ecx,%eax
lea -0x10(%rbp),%rsp
pop %rbx
pop %r12
pop %rbp
retq
lea 0x1(%rdx,%rdx,1),%eax
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je 1270 <func0+0xa7>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1259 <func0+0x90>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1286 <func0+0xbd>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rbx,%rsi
mov %rsp,%rdi
callq 1090 <strcpy@plt>
mov %rbx,%rsi
mov %rsp,%rdi
callq 10c0 <strcat@plt>
mov %r12,%rsi
mov %rsp,%rdi
callq 10d0 <strstr@plt>
test %rax,%rax
setne %cl
movzbl %cl,%ecx
jmpq 121b <func0+0x52>
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdi
mov r13, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov rbx, rax
mov rdi, r13
call _strlen
mov rdx, rax
mov eax, 0
cmp ebx, edx
jz short loc_1249
loc_122B:
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz loc_12C2
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_1249:
lea eax, [rbx+rbx+1]
cdqe
add rax, 0Fh
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_1266:
cmp rsp, rdx
jz short loc_127D
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_1266
loc_127D:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1293
or [rsp+rax+30h+var_38], 0
loc_1293:
mov rsi, r12
mov rdi, rsp
call _strcpy
mov rsi, r12
mov rdi, rsp
call _strcat
mov rsi, r13
mov rdi, rsp
call _strstr
test rax, rax
setnz al
movzx eax, al
jmp loc_122B
loc_12C2:
call ___stack_chk_fail | _BOOL8 func0(long long a1, long long a2)
{
int v2; // ebx
int v3; // edx
_BOOL8 result; // rax
signed long long v5; // rax
void *v6; // rsp
_QWORD v8[6]; // [rsp+8h] [rbp-30h] BYREF
v8[1] = __readfsqword(0x28u);
v2 = ((long long (*)(void))strlen)();
v3 = strlen(a2);
result = 0LL;
if ( v2 == v3 )
{
while ( v8 != (_QWORD *)((char *)v8 - ((2 * v2 + 1 + 15LL) & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = (2 * (_WORD)v2 + 16) & 0xFF0;
v6 = alloca(v5);
if ( ((2 * (_WORD)v2 + 16) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v8[-1] + v5) = *(_QWORD *)((char *)&v8[-1] + v5);
strcpy(v8, a1);
strcat(v8, a1);
return strstr(v8, a2) != 0;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV R13,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001010b0
MOV RBX,RAX
MOV RDI,R13
CALL 0x001010b0
MOV RDX,RAX
MOV EAX,0x0
CMP EBX,EDX
JZ 0x00101249
LAB_0010122b:
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012c2
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_00101249:
LEA EAX,[RBX + RBX*0x1 + 0x1]
CDQE
ADD RAX,0xf
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_00101266:
CMP RSP,RDX
JZ 0x0010127d
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101266
LAB_0010127d:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101293
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101293:
MOV RSI,R12
MOV RDI,RSP
CALL 0x001010a0
MOV RSI,R12
MOV RDI,RSP
CALL 0x001010e0
MOV RSI,R13
MOV RDI,RSP
CALL 0x001010f0
TEST RAX,RAX
SETNZ AL
MOVZX EAX,AL
JMP 0x0010122b
LAB_001012c2:
CALL 0x001010c0 | bool func0(char *param_1,char *param_2)
{
long lVar1;
size_t sVar2;
size_t sVar3;
ulong uVar4;
char *pcVar5;
int1 *puVar6;
int1 *puVar7;
long in_FS_OFFSET;
bool bVar8;
int1 auStack_38 [8];
long local_30;
puVar6 = auStack_38;
puVar7 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
bVar8 = false;
if ((int)sVar2 == (int)sVar3) {
uVar4 = (long)((int)sVar2 * 2 + 1) + 0xf;
for (; puVar7 != auStack_38 + -(uVar4 & 0xfffffffffffff000); puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
puVar6 = puVar7 + lVar1;
if (uVar4 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
*(int8 *)(puVar7 + lVar1 + -8) = 0x10129e;
strcpy(puVar7 + lVar1,param_1);
*(int8 *)(puVar7 + lVar1 + -8) = 0x1012a9;
strcat(puVar7 + lVar1,param_1);
*(int8 *)(puVar7 + lVar1 + -8) = 0x1012b4;
pcVar5 = strstr(puVar7 + lVar1,param_2);
bVar8 = pcVar5 != (char *)0x0;
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar8;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + -8) = main;
__stack_chk_fail();
} |
7,378 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *string1, char *string2) {
int size1 = strlen(string1);
int size2 = strlen(string2);
if (size1 != size2)
return 0;
char temp[2 * size1 + 1];
strcpy(temp, string1);
strcat(temp, string1);
if (strstr(temp, string2) != NULL)
return 1;
else
return 0;
}
| int main() {
assert(func0("abc", "cba") == 0);
assert(func0("abcd", "cdba") == 0);
assert(func0("abacd", "cdaba") == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
mov %rdi,%r13
push %r12
mov %rsi,%r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
callq 1090 <strlen@plt>
mov %r12,%rdi
mov %rax,%rbx
callq 1090 <strlen@plt>
mov %rax,%r8
xor %eax,%eax
cmp %r8d,%ebx
je 12f0 <func0+0x60>
mov -0x28(%rbp),%rcx
xor %fs:0x28,%rcx
jne 1378 <func0+0xe8>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
xchg %ax,%ax
lea 0x1(%rbx,%rbx,1),%eax
mov %rsp,%rcx
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 132a <func0+0x9a>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1315 <func0+0x85>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1370 <func0+0xe0>
mov %rbx,%rdx
mov %r13,%rsi
mov %rsp,%rdi
callq 10c0 <memcpy@plt>
lea (%rsp,%rbx,1),%rdi
lea 0x1(%rbx),%rdx
mov %r13,%rsi
callq 10c0 <memcpy@plt>
mov %r12,%rsi
mov %rsp,%rdi
callq 10d0 <strstr@plt>
test %rax,%rax
setne %al
movzbl %al,%eax
jmpq 12d0 <func0+0x40>
orq $0x0,-0x8(%rsp,%rdx,1)
jmp 1338 <func0+0xa8>
callq 10a0 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
mov r13, rdi
push r12
mov r12, rsi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov rdi, r12
mov rbx, rax
call _strlen
mov r8, rax
xor eax, eax
cmp ebx, r8d
jz short loc_12F0
loc_12D0:
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz loc_1378
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_12F0:
lea eax, [rbx+rbx+1]
mov rcx, rsp
cdqe
add rax, 0Fh
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1327
loc_1312:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_1312
loc_1327:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz short loc_1370
loc_1335:
mov rdx, rbx
mov rsi, r13
mov rdi, rsp
call _memcpy
lea rdi, [rsp+rbx+1030h+var_1030]
lea rdx, [rbx+1]
mov rsi, r13
call _memcpy
mov rsi, r12
mov rdi, rsp
call _strstr
test rax, rax
setnz al
movzx eax, al
jmp loc_12D0
loc_1370:
or [rsp+rdx+1030h+var_1038], 0
jmp short loc_1335
loc_1378:
call ___stack_chk_fail | _BOOL8 func0(long long a1, long long a2)
{
long long v2; // rbx
int v3; // r8d
_BOOL8 result; // rax
_BYTE *v5; // rcx
signed long long v6; // rdx
void *v7; // rsp
_BYTE v9[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v10[6]; // [rsp+1008h] [rbp-30h] BYREF
v10[1] = __readfsqword(0x28u);
v2 = ((long long (*)(void))strlen)();
v3 = strlen(a2);
result = 0LL;
if ( (_DWORD)v2 == v3 )
{
v5 = (char *)v10 - ((2 * (int)v2 + 1 + 15LL) & 0xFFFFFFFFFFFFF000LL);
if ( v10 != (_QWORD *)v5 )
{
while ( v9 != v5 )
;
}
v6 = (2 * (_WORD)v2 + 16) & 0xFF0;
v7 = alloca(v6);
if ( ((2 * (_WORD)v2 + 16) & 0xFF0) != 0 )
*(_QWORD *)&v9[v6 - 8] = *(_QWORD *)&v9[v6 - 8];
memcpy(v9, a1, v2);
memcpy(&v9[v2], a1, v2 + 1);
return strstr(v9, a2) != 0;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12,RSI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x00101090
MOV RDI,R12
MOV RBX,RAX
CALL 0x00101090
MOV R8,RAX
XOR EAX,EAX
CMP EBX,R8D
JZ 0x001012f0
LAB_001012d0:
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101378
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_001012f0:
LEA EAX,[RBX + RBX*0x1 + 0x1]
MOV RCX,RSP
CDQE
ADD RAX,0xf
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101327
LAB_00101312:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101312
LAB_00101327:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101370
LAB_00101335:
MOV RDX,RBX
MOV RSI,R13
MOV RDI,RSP
CALL 0x001010c0
LEA RDI,[RSP + RBX*0x1]
LEA RDX,[RBX + 0x1]
MOV RSI,R13
CALL 0x001010c0
MOV RSI,R12
MOV RDI,RSP
CALL 0x001010d0
TEST RAX,RAX
SETNZ AL
MOVZX EAX,AL
JMP 0x001012d0
LAB_00101370:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101335
LAB_00101378:
CALL 0x001010a0 | bool func0(char *param_1,char *param_2)
{
long lVar1;
int1 *puVar2;
size_t __n;
size_t sVar3;
ulong uVar4;
char *pcVar5;
int1 *puVar6;
int1 *puVar7;
long in_FS_OFFSET;
bool bVar9;
int1 auStack_38 [8];
long local_30;
int1 *puVar8;
puVar6 = auStack_38;
puVar8 = auStack_38;
puVar7 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__n = strlen(param_1);
sVar3 = strlen(param_2);
bVar9 = false;
if ((int)__n == (int)sVar3) {
uVar4 = (long)((int)__n * 2 + 1) + 0xf;
puVar2 = auStack_38;
while (puVar8 != auStack_38 + -(uVar4 & 0xfffffffffffff000)) {
puVar7 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar8 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
puVar6 = puVar7 + lVar1;
if (uVar4 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
*(int8 *)(puVar7 + lVar1 + -8) = 0x101343;
memcpy(puVar7 + lVar1,param_1,__n);
*(int8 *)(puVar7 + lVar1 + -8) = 0x101353;
memcpy(puVar7 + __n + lVar1,param_1,__n + 1);
*(int8 *)(puVar7 + lVar1 + -8) = 0x10135e;
pcVar5 = strstr(puVar7 + lVar1,param_2);
bVar9 = pcVar5 != (char *)0x0;
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + -8) = 0x10137d;
__stack_chk_fail();
}
return bVar9;
} |
7,379 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *string1, char *string2) {
int size1 = strlen(string1);
int size2 = strlen(string2);
if (size1 != size2)
return 0;
char temp[2 * size1 + 1];
strcpy(temp, string1);
strcat(temp, string1);
if (strstr(temp, string2) != NULL)
return 1;
else
return 0;
}
| int main() {
assert(func0("abc", "cba") == 0);
assert(func0("abcd", "cdba") == 0);
assert(func0("abacd", "cdaba") == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
mov %rdi,%r13
push %r12
mov %rsi,%r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
callq 1090 <strlen@plt>
mov %r12,%rdi
mov %rax,%rbx
callq 1090 <strlen@plt>
mov %rax,%r8
xor %eax,%eax
cmp %r8d,%ebx
je 12f0 <func0+0x60>
mov -0x28(%rbp),%rcx
xor %fs:0x28,%rcx
jne 1378 <func0+0xe8>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
xchg %ax,%ax
lea 0x1(%rbx,%rbx,1),%eax
mov %rsp,%rcx
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 132a <func0+0x9a>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1315 <func0+0x85>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1370 <func0+0xe0>
mov %rbx,%rdx
mov %r13,%rsi
mov %rsp,%rdi
callq 10c0 <memcpy@plt>
lea (%rsp,%rbx,1),%rdi
lea 0x1(%rbx),%rdx
mov %r13,%rsi
callq 10c0 <memcpy@plt>
mov %r12,%rsi
mov %rsp,%rdi
callq 10d0 <strstr@plt>
test %rax,%rax
setne %al
movzbl %al,%eax
jmpq 12d0 <func0+0x40>
orq $0x0,-0x8(%rsp,%rdx,1)
jmp 1338 <func0+0xa8>
callq 10a0 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov rdi, r13; s
mov rbx, rax
call _strlen
mov rdx, rax
xor eax, eax
cmp ebx, edx
jz short loc_12F8
loc_12D1:
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz loc_1388
lea rsp, [rbp-20h]
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_12F8:
lea r14d, [rbx+rbx+1]
mov rcx, rsp
movsxd r14, r14d
lea rax, [r14+0Fh]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1331
loc_131C:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_131C
loc_1331:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz short loc_1380
loc_133F:
mov rcx, r14
mov rdx, rbx
mov rsi, r12
mov rdi, rsp
call ___memcpy_chk
mov rcx, r14
lea rdx, [rbx+1]
lea rdi, [rsp+rbx+1030h+var_1030]
sub rcx, rbx
mov rsi, r12
call ___memcpy_chk
mov rsi, r13; needle
mov rdi, rsp; haystack
call _strstr
test rax, rax
setnz al
movzx eax, al
jmp loc_12D1
loc_1380:
or [rsp+rdx+1030h+var_1038], 0
jmp short loc_133F
loc_1388:
call ___stack_chk_fail | _BOOL8 func0(const char *a1, const char *a2)
{
size_t v2; // rbx
int v3; // edx
_BOOL8 result; // rax
long long v5; // r14
char *v6; // rcx
signed long long v7; // rdx
void *v8; // rsp
char v10[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v11[6]; // [rsp+1008h] [rbp-30h] BYREF
v11[1] = __readfsqword(0x28u);
v2 = strlen(a1);
v3 = strlen(a2);
result = 0LL;
if ( (_DWORD)v2 == v3 )
{
v5 = 2 * (int)v2 + 1;
v6 = (char *)v11 - ((v5 + 15) & 0xFFFFFFFFFFFFF000LL);
if ( v11 != (_QWORD *)v6 )
{
while ( v10 != v6 )
;
}
v7 = (2 * (_WORD)v2 + 16) & 0xFF0;
v8 = alloca(v7);
if ( ((2 * (_WORD)v2 + 16) & 0xFF0) != 0 )
*(_QWORD *)&v10[v7 - 8] = *(_QWORD *)&v10[v7 - 8];
__memcpy_chk(v10, a1, v2, 2 * (int)v2 + 1);
__memcpy_chk(&v10[v2], a1, v2 + 1, v5 - v2);
return strstr(v10, a2) != 0LL;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x00101090
MOV RDI,R13
MOV RBX,RAX
CALL 0x00101090
MOV RDX,RAX
XOR EAX,EAX
CMP EBX,EDX
JZ 0x001012f8
LAB_001012d1:
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101388
LEA RSP,[RBP + -0x20]
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_001012f8:
LEA R14D,[RBX + RBX*0x1 + 0x1]
MOV RCX,RSP
MOVSXD R14,R14D
LEA RAX,[R14 + 0xf]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101331
LAB_0010131c:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010131c
LAB_00101331:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101380
LAB_0010133f:
MOV RCX,R14
MOV RDX,RBX
MOV RSI,R12
MOV RDI,RSP
CALL 0x001010c0
MOV RCX,R14
LEA RDX,[RBX + 0x1]
LEA RDI,[RSP + RBX*0x1]
SUB RCX,RBX
MOV RSI,R12
CALL 0x001010c0
MOV RSI,R13
MOV RDI,RSP
CALL 0x001010d0
TEST RAX,RAX
SETNZ AL
MOVZX EAX,AL
JMP 0x001012d1
LAB_00101380:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010133f
LAB_00101388:
CALL 0x001010a0 | bool func0(char *param_1,char *param_2)
{
long lVar1;
int *puVar2;
size_t sVar3;
size_t sVar4;
char *pcVar5;
ulong uVar6;
int *puVar7;
int *puVar8;
long lVar10;
long in_FS_OFFSET;
bool bVar11;
int auStack_38 [8];
long local_30;
int *puVar9;
puVar7 = auStack_38;
puVar9 = auStack_38;
puVar8 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
sVar4 = strlen(param_2);
bVar11 = false;
if ((int)sVar3 == (int)sVar4) {
lVar10 = (long)((int)sVar3 * 2 + 1);
puVar2 = auStack_38;
while (puVar9 != auStack_38 + -(lVar10 + 0xfU & 0xfffffffffffff000)) {
puVar8 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar9 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar6 = (ulong)((uint)(lVar10 + 0xfU) & 0xff0);
lVar1 = -uVar6;
puVar7 = puVar8 + lVar1;
if (uVar6 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
*(int8 *)(puVar8 + lVar1 + -8) = 0x101350;
__memcpy_chk((long)puVar8 + lVar1,param_1,sVar3,lVar10);
*(int8 *)(puVar8 + lVar1 + -8) = 0x101366;
__memcpy_chk(puVar8 + sVar3 + lVar1,param_1,sVar3 + 1,lVar10 - sVar3);
*(int8 *)(puVar8 + lVar1 + -8) = 0x101371;
pcVar5 = strstr(puVar8 + lVar1,param_2);
bVar11 = pcVar5 != (char *)0x0;
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + -8) = 0x10138d;
__stack_chk_fail();
}
return bVar11;
} |
7,380 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int list1[][2], int size1, int list2[][2], int size2) {
for (int i = 0; i < size2; i++) {
bool found = false;
for (int j = 0; j < size1; j++) {
if (list1[j][0] == list2[i][0] && list1[j][1] == list2[i][1]) {
found = true;
break;
}
}
if (!found)
return false;
}
return true;
}
| int main() {
int list1[][2] = {{1, 3}, {5, 7}, {9, 11}, {13, 15}};
int list2[][2] = {{1, 3}, {13, 15}};
assert(func0(list1, 4, list2, 2) == true);
int list3[][2] = {{1, 2}, {2, 3}, {3, 4}, {5, 6}};
int list4[][2] = {{3, 4}, {5, 6}};
assert(func0(list3, 4, list4, 2) == true);
int list5[][2] = {{1, 2}, {3, 4}, {5, 7}, {8, 9}};
int list6[][2] = {{3, 4}, {5, 6}};
assert(func0(list5, 4, list6, 2) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1222 <func0+0xb9>
movb $0x0,-0x9(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1204 <func0+0x9b>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 1200 <func0+0x97>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
cmp %eax,%edx
jne 1200 <func0+0x97>
movb $0x1,-0x9(%rbp)
jmp 120c <func0+0xa3>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1198 <func0+0x2f>
movzbl -0x9(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 121e <func0+0xb5>
mov $0x0,%eax
jmp 1233 <func0+0xca>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 118b <func0+0x22>
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_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_8], 0
jmp loc_1222
loc_118B:
mov [rbp+var_9], 0
mov [rbp+var_4], 0
jmp short loc_1204
loc_1198:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_1200
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax+4]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax+4]
cmp edx, eax
jnz short loc_1200
mov [rbp+var_9], 1
jmp short loc_120C
loc_1200:
add [rbp+var_4], 1
loc_1204:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1198
loc_120C:
movzx eax, [rbp+var_9]
xor eax, 1
test al, al
jz short loc_121E
mov eax, 0
jmp short loc_1233
loc_121E:
add [rbp+var_8], 1
loc_1222:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_20]
jl loc_118B
mov eax, 1
loc_1233:
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
char v5; // [rsp+1Fh] [rbp-9h]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a4; ++i )
{
v5 = 0;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(8LL * j + a1) == *(_DWORD *)(8LL * i + a3)
&& *(_DWORD *)(8LL * j + a1 + 4) == *(_DWORD *)(8LL * i + a3 + 4) )
{
v5 = 1;
break;
}
}
if ( v5 != 1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101222
LAB_0010118b:
MOV byte ptr [RBP + -0x9],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101204
LAB_00101198:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x00101200
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,EAX
JNZ 0x00101200
MOV byte ptr [RBP + -0x9],0x1
JMP 0x0010120c
LAB_00101200:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101204:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101198
LAB_0010120c:
MOVZX EAX,byte ptr [RBP + -0x9]
XOR EAX,0x1
TEST AL,AL
JZ 0x0010121e
MOV EAX,0x0
JMP 0x00101233
LAB_0010121e:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101222:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x0010118b
MOV EAX,0x1
LAB_00101233:
POP RBP
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
bool bVar1;
int local_10;
int local_c;
local_10 = 0;
do {
if (param_4 <= local_10) {
return 1;
}
bVar1 = false;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(int *)(param_1 + (long)local_c * 8) == *(int *)(param_3 + (long)local_10 * 8)) &&
(*(int *)(param_1 + (long)local_c * 8 + 4) == *(int *)(param_3 + (long)local_10 * 8 + 4)))
{
bVar1 = true;
break;
}
}
if (!bVar1) {
return 0;
}
local_10 = local_10 + 1;
} while( true );
} |
7,381 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int list1[][2], int size1, int list2[][2], int size2) {
for (int i = 0; i < size2; i++) {
bool found = false;
for (int j = 0; j < size1; j++) {
if (list1[j][0] == list2[i][0] && list1[j][1] == list2[i][1]) {
found = true;
break;
}
}
if (!found)
return false;
}
return true;
}
| int main() {
int list1[][2] = {{1, 3}, {5, 7}, {9, 11}, {13, 15}};
int list2[][2] = {{1, 3}, {13, 15}};
assert(func0(list1, 4, list2, 2) == true);
int list3[][2] = {{1, 2}, {2, 3}, {3, 4}, {5, 6}};
int list4[][2] = {{3, 4}, {5, 6}};
assert(func0(list3, 4, list4, 2) == true);
int list5[][2] = {{1, 2}, {3, 4}, {5, 7}, {8, 9}};
int list6[][2] = {{3, 4}, {5, 6}};
assert(func0(list5, 4, list6, 2) == false);
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 1189 <func0+0x20>
mov %rdx,%r8
lea -0x1(%rcx),%eax
lea 0x8(%rdx,%rax,8),%r10
mov %rdi,%r9
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rcx
jmp 11af <func0+0x46>
mov $0x1,%eax
retq
add $0x8,%rax
cmp %rcx,%rax
je 11be <func0+0x55>
cmp %edx,(%rax)
jne 118f <func0+0x26>
mov 0x4(%rdi),%r11d
cmp %r11d,0x4(%rax)
jne 118f <func0+0x26>
add $0x8,%r8
cmp %r10,%r8
je 11ca <func0+0x61>
test %esi,%esi
jle 11c4 <func0+0x5b>
mov %r8,%rdi
mov (%r8),%edx
mov %r9,%rax
jmp 1198 <func0+0x2f>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
mov r9, rdi
mov r8d, esi
test ecx, ecx
jle short loc_118C
mov rdi, rdx
lea eax, [rcx-1]
lea r10, [rdx+rax*8+8]
lea eax, [rsi-1]
lea rcx, [r9+rax*8+8]
jmp short loc_11B2
loc_118C:
mov eax, 1
retn
loc_1192:
add rax, 8
cmp rax, rcx
jz short loc_11C1
loc_119B:
cmp [rax], edx
jnz short loc_1192
mov r11d, [rsi+4]
cmp [rax+4], r11d
jnz short loc_1192
add rdi, 8
cmp rdi, r10
jz short loc_11CD
loc_11B2:
test r8d, r8d
jle short loc_11C7
mov rsi, rdi
mov edx, [rdi]
mov rax, r9
jmp short loc_119B
loc_11C1:
mov eax, 0
retn
loc_11C7:
mov eax, 0
retn
loc_11CD:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 1LL;
v5 = a3;
while ( 2 )
{
if ( a2 <= 0 )
return 0LL;
v7 = a1;
while ( *v7 != *v5 || v7[1] != v5[1] )
{
v7 += 2;
if ( v7 == &a1[2 * (a2 - 1) + 2] )
return 0LL;
}
v5 += 2;
if ( v5 != &a3[2 * (a4 - 1) + 2] )
continue;
break;
}
return 1LL;
} | func0:
ENDBR64
MOV R9,RDI
MOV R8D,ESI
TEST ECX,ECX
JLE 0x0010118c
MOV RDI,RDX
LEA EAX,[RCX + -0x1]
LEA R10,[RDX + RAX*0x8 + 0x8]
LEA EAX,[RSI + -0x1]
LEA RCX,[R9 + RAX*0x8 + 0x8]
JMP 0x001011b2
LAB_0010118c:
MOV EAX,0x1
RET
LAB_00101192:
ADD RAX,0x8
CMP RAX,RCX
JZ 0x001011c1
LAB_0010119b:
CMP dword ptr [RAX],EDX
JNZ 0x00101192
MOV R11D,dword ptr [RSI + 0x4]
CMP dword ptr [RAX + 0x4],R11D
JNZ 0x00101192
ADD RDI,0x8
CMP RDI,R10
JZ 0x001011cd
LAB_001011b2:
TEST R8D,R8D
JLE 0x001011c7
MOV RSI,RDI
MOV EDX,dword ptr [RDI]
MOV RAX,R9
JMP 0x0010119b
LAB_001011c1:
MOV EAX,0x0
RET
LAB_001011c7:
MOV EAX,0x0
RET
LAB_001011cd:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (param_4 < 1) {
return 1;
}
piVar1 = param_3 + (ulong)(param_4 - 1) * 2 + 2;
do {
if (param_2 < 1) {
return 0;
}
piVar2 = param_1;
while ((*piVar2 != *param_3 || (piVar2[1] != param_3[1]))) {
piVar2 = piVar2 + 2;
if (piVar2 == param_1 + (ulong)(param_2 - 1) * 2 + 2) {
return 0;
}
}
param_3 = param_3 + 2;
} while (param_3 != piVar1);
return 1;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.