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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
5,882 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double SA = M_PI * r * (r + l);
return SA;
}
| int main() {
assert(func0(5, 12) == 282.7433388230814);
assert(func0(10, 15) == 880.5179353159282);
assert(func0(19, 17) == 2655.923961165254);
return 0;
}
| O2 | c | func0:
endbr64
mulsd %xmm1,%xmm1
movapd %xmm0,%xmm2
sub $0x18,%rsp
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
ja 11a3 <func0+0x43>
movsd 0xe76(%rip),%xmm0
add $0x18,%rsp
mulsd %xmm2,%xmm0
addsd %xmm3,%xmm2
mulsd %xmm2,%xmm0
retq
movs... | func0:
endbr64
mulsd xmm1, xmm1
movapd xmm2, xmm0
sub rsp, 18h
mulsd xmm0, xmm0
addsd xmm1, xmm0
pxor xmm0, xmm0
ucomisd xmm0, xmm1
ja short loc_119F
sqrtsd xmm1, xmm1
loc_1186:
movsd xmm0, cs:qword_2008
add rsp, 18h
mulsd xmm0, xmm2
addsd xmm2, xmm1
mulsd xmm0, xmm2
retn
loc_119F:
movap... | double func0(double a1, double a2)
{
double v3; // xmm1_8
double v4; // xmm1_8
v3 = a2 * a2 + a1 * a1;
if ( v3 < 0.0 )
v4 = sqrt(v3);
else
v4 = sqrt(v3);
return 3.141592653589793 * a1 * (a1 + v4);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MOVAPD XMM2,XMM0
SUB RSP,0x18
MULSD XMM0,XMM0
ADDSD XMM1,XMM0
PXOR XMM0,XMM0
UCOMISD XMM0,XMM1
JA 0x0010119f
SQRTSD XMM1,XMM1
LAB_00101186:
MOVSD XMM0,qword ptr [0x00102008]
ADD RSP,0x18
MULSD XMM0,XMM2
ADDSD XMM2,XMM1
MULSD XMM0,XMM2
RET
LAB_0010119f:
MOVAPD XMM0,XMM1
MOVSD qword ptr [RS... | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_2 * param_2 + param_1 * param_1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
return DAT_00102008 * param_1 * (param_1 + dVar1);
} |
5,883 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double SA = M_PI * r * (r + l);
return SA;
}
| int main() {
assert(func0(5, 12) == 282.7433388230814);
assert(func0(10, 15) == 880.5179353159282);
assert(func0(19, 17) == 2655.923961165254);
return 0;
}
| O3 | c | func0:
endbr64
mulsd %xmm1,%xmm1
movapd %xmm0,%xmm2
sub $0x18,%rsp
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
ja 11a3 <func0+0x43>
movsd 0xe76(%rip),%xmm0
add $0x18,%rsp
mulsd %xmm2,%xmm0
addsd %xmm3,%xmm2
mulsd %xmm2,%xmm0
retq
movs... | func0:
endbr64
mulsd xmm1, xmm1
movapd xmm2, xmm0
mulsd xmm0, xmm0
addsd xmm0, xmm1
movsd xmm1, cs:qword_2008
mulsd xmm1, xmm2
sqrtsd xmm0, xmm0
addsd xmm2, xmm0
mulsd xmm1, xmm2
movapd xmm0, xmm1
retn | __int128 __usercall func0@<xmm0>(double a1@<xmm0>, double a2@<xmm1>)
{
double v3; // xmm0_8
__int128 v4; // xmm1
v3 = a1 * a1 + a2 * a2;
v4 = 0x400921FB54442D18uLL;
*(double *)&v4 = 3.141592653589793 * a1 * (a1 + sqrt(v3));
return v4;
} | func0:
ENDBR64
MULSD XMM1,XMM1
MOVAPD XMM2,XMM0
MULSD XMM0,XMM0
ADDSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x00102008]
MULSD XMM1,XMM2
SQRTSD XMM0,XMM0
ADDSD XMM2,XMM0
MULSD XMM1,XMM2
MOVAPD XMM0,XMM1
RET | double func0(double param_1,double param_2)
{
return DAT_00102008 * param_1 * (param_1 + SQRT(param_1 * param_1 + param_2 * param_2));
} |
5,884 | func0 | #include <assert.h>
| int func0(int x, int y) {
int gcd = 1;
if (x % y == 0) {
return y;
}
for (int k = y / 2; k > 0; k--) {
if (x % k == 0 && y % k == 0) {
gcd = k;
break;
}
}
return gcd;
}
| int main() {
assert(func0(12, 17) == 1);
assert(func0(4, 6) == 2);
assert(func0(2, 9) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x1,-0x8(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1170 <func0+0x27>
mov -0x18(%rbp),%eax
jmp 11b0 <func0+0x67>
mov -0x18(%rbp),%eax
mov %eax,%edx
shr $... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 1
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov eax, edx
test eax, eax
jnz short loc_1170
mov eax, [rbp+var_18]
jmp short loc_11B0
loc_1170:
mov eax, [rbp+var_18]
mov ... | long long func0(int a1, signed int a2)
{
unsigned int v3; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v3 = 1;
if ( !(a1 % a2) )
return (unsigned int)a2;
for ( i = a2 / 2; i > 0; --i )
{
if ( !(a1 % i) && !(a2 % i) )
return (unsigned int)i;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101170
MOV EAX,dword ptr [RBP + -0x18]
JMP 0x001011b0
LAB_00101170:
MOV EAX,dword ptr [RBP ... | int func0(int param_1,int param_2)
{
int iVar1;
int local_10;
int local_c;
local_10 = 1;
iVar1 = param_2;
if (param_1 % param_2 != 0) {
for (local_c = param_2 / 2;
(iVar1 = local_10, 0 < local_c &&
((param_1 % local_c != 0 || (iVar1 = local_c, param_2 % local_c != 0))));
loca... |
5,885 | func0 | #include <assert.h>
| int func0(int x, int y) {
int gcd = 1;
if (x % y == 0) {
return y;
}
for (int k = y / 2; k > 0; k--) {
if (x % k == 0 && y % k == 0) {
gcd = k;
break;
}
}
return gcd;
}
| int main() {
assert(func0(12, 17) == 1);
assert(func0(4, 6) == 2);
assert(func0(2, 9) == 1);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
mov %esi,%ecx
test %edx,%edx
je 118b <func0+0x42>
shr $0x1f,%ecx
add %esi,%ecx
sar %ecx
cmp $0x1,%esi
jg 1172 <func0+0x29>
mov $0x1,%ecx
jmp 118b <func0+0x42>
sub $0x1,%ecx
test %ecx,%ecx
jle 1186 <func0+0x3d>
mov %edi,%eax
cltd
... | func0:
endbr64
mov eax, edi
cdq
idiv esi
mov ecx, esi
test edx, edx
jz short loc_118B
shr ecx, 1Fh
add ecx, esi
sar ecx, 1
cmp esi, 1
jg short loc_1172
mov ecx, 1
jmp short loc_118B
loc_116B:
sub ecx, 1
test ecx, ecx
jle short loc_1186
loc_1172:
mov eax, ed... | long long func0(int a1, int a2)
{
int v2; // ecx
v2 = a2;
if ( a1 % a2 )
{
v2 = a2 / 2;
if ( a2 > 1 )
{
while ( a1 % v2 || a2 % v2 )
{
if ( --v2 <= 0 )
return 1;
}
}
else
{
return 1;
}
}
return (unsigned int)v2;
} | func0:
ENDBR64
MOV EAX,EDI
CDQ
IDIV ESI
MOV ECX,ESI
TEST EDX,EDX
JZ 0x0010118b
SHR ECX,0x1f
ADD ECX,ESI
SAR ECX,0x1
CMP ESI,0x1
JG 0x00101172
MOV ECX,0x1
JMP 0x0010118b
LAB_0010116b:
SUB ECX,0x1
TEST ECX,ECX
JLE 0x00101186
LAB_00101172:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010116b
MOV EAX,ESI
CDQ
IDIV ECX
TEST ... | int func0(int param_1,int param_2)
{
int iVar1;
if (param_1 % param_2 != 0) {
iVar1 = param_2 / 2;
if (param_2 < 2) {
param_2 = 1;
}
else {
do {
if ((param_1 % iVar1 == 0) && (param_2 % iVar1 == 0)) {
return iVar1;
}
iVar1 = iVar1 + -1;
} while... |
5,886 | func0 | #include <assert.h>
| int func0(int x, int y) {
int gcd = 1;
if (x % y == 0) {
return y;
}
for (int k = y / 2; k > 0; k--) {
if (x % k == 0 && y % k == 0) {
gcd = k;
break;
}
}
return gcd;
}
| int main() {
assert(func0(12, 17) == 1);
assert(func0(4, 6) == 2);
assert(func0(2, 9) == 1);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
test %edx,%edx
je 1250 <func0+0x10>
jmp 1200 <func0.part.0>
mov %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
mov r8d, esi
shr r8d, 1Fh
add r8d, esi
sar r8d, 1
cmp esi, 1
jle short loc_1232
nop word ptr [rax+rax+00h]
loc_1218:
mov eax, edi
cdq
idiv r8d
test edx, edx
jnz short loc_122C
mov eax, esi
cdq
idiv r8d
test edx, edx
jz short loc_1238
loc_122C:
sub ... | long long func0_part_0(int a1, int a2)
{
int v2; // r8d
v2 = a2 / 2;
if ( a2 <= 1 )
{
return 1;
}
else
{
while ( a1 % v2 || a2 % v2 )
{
if ( !--v2 )
return 1;
}
}
return (unsigned int)v2;
} | func0.part.0:
MOV R8D,ESI
SHR R8D,0x1f
ADD R8D,ESI
SAR R8D,0x1
CMP ESI,0x1
JLE 0x00101232
NOP word ptr [RAX + RAX*0x1]
LAB_00101218:
MOV EAX,EDI
CDQ
IDIV R8D
TEST EDX,EDX
JNZ 0x0010122c
MOV EAX,ESI
CDQ
IDIV R8D
TEST EDX,EDX
JZ 0x00101238
LAB_0010122c:
SUB R8D,0x1
JNZ 0x00101218
LAB_00101232:
MOV R8D,0x1
LAB_00101238:
M... | int func0_part_0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_2 / 2;
if (1 < param_2) {
do {
if ((param_1 % iVar1 == 0) && (param_2 % iVar1 == 0)) {
return iVar1;
}
iVar1 = iVar1 + -1;
} while (iVar1 != 0);
}
return 1;
} |
5,887 | func0 | #include <assert.h>
| int func0(int x, int y) {
int gcd = 1;
if (x % y == 0) {
return y;
}
for (int k = y / 2; k > 0; k--) {
if (x % k == 0 && y % k == 0) {
gcd = k;
break;
}
}
return gcd;
}
| int main() {
assert(func0(12, 17) == 1);
assert(func0(4, 6) == 2);
assert(func0(2, 9) == 1);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
mov %esi,%r8d
cltd
idiv %esi
test %edx,%edx
je 1280 <func0+0x40>
mov %esi,%eax
shr $0x1f,%eax
add %eax,%r8d
sar %r8d
cmp $0x1,%esi
jle 127a <func0+0x3a>
mov %edi,%eax
cltd
idiv %r8d
test %edx,%edx
jne 1274 <func0+0x34>
mov %esi,%eax
cltd
idiv %... | func0_part_0:
mov ecx, esi
shr ecx, 1Fh
add ecx, esi
sar ecx, 1
cmp esi, 1
jle short loc_1233
xchg ax, ax
loc_1210:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_122E
loc_1219:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_1238
mov eax, edi
sub ... | long long func0_part_0(int a1, int a2)
{
int v2; // ecx
v2 = a2 / 2;
if ( a2 <= 1 )
{
return 1;
}
else
{
while ( a1 % v2 )
{
LABEL_5:
if ( !--v2 )
return 1;
}
while ( a2 % v2 )
{
--v2;
if ( a1 % v2 )
goto LABEL_5;
}
}
return (unsigned int... | func0.part.0:
MOV ECX,ESI
SHR ECX,0x1f
ADD ECX,ESI
SAR ECX,0x1
CMP ESI,0x1
JLE 0x00101233
NOP
LAB_00101210:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010122e
LAB_00101219:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101238
MOV EAX,EDI
SUB ECX,0x1
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101219
LAB_0010122e:
SUB ECX,0x1
JNZ... | int func0_part_0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_2 / 2;
if (1 < param_2) {
do {
for (; param_1 % iVar1 == 0; iVar1 = iVar1 + -1) {
if (param_2 % iVar1 == 0) {
return iVar1;
}
}
iVar1 = iVar1 + -1;
} while (iVar1 != 0);
}
return 1;
} |
5,888 | func0 |
#include <assert.h>
| int func0(int r) {
int diameter = 2 * r;
return diameter;
}
| int main() {
assert(func0(10) == 20);
assert(func0(40) == 80);
assert(func0(15) == 30);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
add %eax,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
add eax, eax
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(2 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EAX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
return param_1 * 2;
} |
5,889 | func0 |
#include <assert.h>
| int func0(int r) {
int diameter = 2 * r;
return diameter;
}
| int main() {
assert(func0(10) == 20);
assert(func0(40) == 80);
assert(func0(15) == 30);
return 0;
}
| O1 | c | func0:
endbr64
lea (%rdi,%rdi,1),%eax
retq
| func0:
endbr64
lea eax, [rdi+rdi]
retn | long long func0(int a1)
{
return (unsigned int)(2 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1)
{
return param_1 * 2;
} |
5,890 | func0 |
#include <assert.h>
| int func0(int r) {
int diameter = 2 * r;
return diameter;
}
| int main() {
assert(func0(10) == 20);
assert(func0(40) == 80);
assert(func0(15) == 30);
return 0;
}
| O2 | c | func0:
endbr64
lea (%rdi,%rdi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rdi]
retn | long long func0(int a1)
{
return (unsigned int)(2 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1)
{
return param_1 * 2;
} |
5,891 | func0 |
#include <assert.h>
| int func0(int r) {
int diameter = 2 * r;
return diameter;
}
| int main() {
assert(func0(10) == 20);
assert(func0(40) == 80);
assert(func0(15) == 30);
return 0;
}
| O3 | c | func0:
endbr64
lea (%rdi,%rdi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rdi]
retn | long long func0(int a1)
{
return (unsigned int)(2 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1)
{
return param_1 * 2;
} |
5,892 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* arr[], int size) {
static char ans[1000] = "";
strcpy(ans, " ");
for(int i = 0; i < size; i++) {
strcat(ans, " ");
strcat(ans, arr[i]);
}
return ans;
}
| int main() {
char* list1[] = {"hello", "there", "have", "a", "rocky", "day"};
char* list2[] = {"Hi", "there", "How", "are", "you"};
char* list3[] = {"Part", "of", "the", "journey", "is", "end"};
assert(strcmp(func0(list1, 6), " hello there have a rocky day") == 0);
assert(strcmp(func0(list2, 5), " Hi... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movw $0x20,0x2e7b(%rip)
movl $0x0,-0x4(%rbp)
jmp 122c <func0+0x83>
lea 0x2e6b(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov cs:ans_1, 20h ; ' '
mov [rbp+var_4], 0
jmp short loc_123C
loc_11EE:
lea rax, ans_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, ans_1
add rax, rdx
mov word pt... | char * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-4h]
strcpy(ans_1, " ");
for ( i = 0; i < a2; ++i )
{
*(_WORD *)&ans_1[strlen(ans_1)] = 32;
strcat(ans_1, *(const char **)(8LL * i + a1));
}
return ans_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV word ptr [0x00104040],0x20
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010123c
LAB_001011ee:
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101090
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x20
MO... | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
int local_c;
ans_1._0_2_ = 0x20;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
sVar1 = strlen(ans_1);
*(int2 *)(ans_1 + sVar1) = 0x20;
strcat(ans_1,*(char **)(param_1 + (long)local_c * 8));
}
return ans_1;
} |
5,893 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* arr[], int size) {
static char ans[1000] = "";
strcpy(ans, " ");
for(int i = 0; i < size; i++) {
strcat(ans, " ");
strcat(ans, arr[i]);
}
return ans;
}
| int main() {
char* list1[] = {"hello", "there", "have", "a", "rocky", "day"};
char* list2[] = {"Hi", "there", "How", "are", "you"};
char* list3[] = {"Part", "of", "the", "journey", "is", "end"};
assert(strcmp(func0(list1, 6), " hello there have a rocky day") == 0);
assert(strcmp(func0(list2, 5), " Hi... | O1 | c | func0:
endbr64
movw $0x20,0x2eaa(%rip)
test %esi,%esi
jle 11e9 <func0+0x60>
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r12
lea 0x2e90(%rip),%rbp
mov $0x3e8,%edx
lea 0xe48(%rip),%rsi
mov %rbp,%rdi
callq 1070 <__strcat_chk@plt>
mov $0x3e8,%e... | func0:
endbr64
mov cs:ans_1, 20h ; ' '
test esi, esi
jle short loc_1218
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
lea eax, [rsi-1]
lea r13, [rdi+rax*8+8]
lea r12, unk_2004
lea rbp, ans_1
loc_11DD:
mov edx, 3E8h
mov rsi, r12
mov rdi, rbp
call ... | __int16 * func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
ans_1 = 32;
if ( a2 <= 0 )
return &ans_1;
v2 = a1;
do
{
__strcat_chk(&ans_1, &unk_2004, 1000LL);
__strcat_chk(&ans_1, *v2++, 1000LL);
}
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
return &ans_1;
} | func0:
ENDBR64
MOV word ptr [0x00104040],0x20
TEST ESI,ESI
JLE 0x00101218
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R13,[RDI + RAX*0x8 + 0x8]
LEA R12,[0x102004]
LEA RBP,[0x104040]
LAB_001011dd:
MOV EDX,0x3e8
MOV RSI,R12
MOV RDI,RBP
CALL 0x00101080
MOV EDX,0x3e8
MOV RSI,qword p... | int1 * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
ans_1._0_2_ = 0x20;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
__strcat_chk(ans_1,&DAT_00102004,1000);
__strcat_chk(ans_1,*param_1,1000);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
retu... |
5,894 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* arr[], int size) {
static char ans[1000] = "";
strcpy(ans, " ");
for(int i = 0; i < size; i++) {
strcat(ans, " ");
strcat(ans, arr[i]);
}
return ans;
}
| int main() {
char* list1[] = {"hello", "there", "have", "a", "rocky", "day"};
char* list2[] = {"Hi", "there", "How", "are", "you"};
char* list3[] = {"Part", "of", "the", "journey", "is", "end"};
assert(strcmp(func0(list1, 6), " hello there have a rocky day") == 0);
assert(strcmp(func0(list2, 5), " Hi... | O2 | c | func0:
endbr64
mov $0x20,%edx
mov %dx,0x2cb0(%rip)
test %esi,%esi
jle 1420 <func0+0xa0>
lea -0x1(%rsi),%eax
push %r12
mov %rdi,%r12
push %rbp
lea 0x8(%rdi,%rax,8),%rbp
push %rbx
lea 0x307a(%rip),%rbx
xchg %ax,%ax
lea 0x2c89(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x10101... | func0:
endbr64
push r13
mov edx, 20h ; ' '
push r12
lea r12, ans_1
push rbp
push rbx
sub rsp, 8
mov cs:ans_1, dx
test esi, esi
jle short loc_1410
lea eax, [rsi-1]
mov rbx, rdi
lea rbp, [r12+3E8h]
lea r13, [rdi+rax*8+8]
nop dword ptr [rax+rax+00000000h]
loc_13E0:
mo... | __int16 * func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
ans_1 = 32;
if ( a2 > 0 )
{
v2 = a1;
do
{
v2 += 8LL;
v3 = strlen(&ans_1);
*(__int16 *)((char *)&ans_1 + v3) = 32;
__strcpy_chk((char *)&ans_1 + v3 + 1, *(_QWORD *)(v2 - 8), 1000 - (v3 + 1));
... | func0:
ENDBR64
PUSH R13
MOV EDX,0x20
PUSH R12
LEA R12,[0x104040]
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV word ptr [0x00104040],DX
TEST ESI,ESI
JLE 0x00101410
LEA EAX,[RSI + -0x1]
MOV RBX,RDI
LEA RBP,[R12 + 0x3e8]
LEA R13,[RDI + RAX*0x8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV RDI,R12
ADD RBX,0x8
CALL 0x00101090... | int1 * func0(int8 *param_1,int param_2)
{
size_t sVar1;
int8 *puVar2;
int8 *puVar3;
ans_1._0_2_ = 0x20;
if (0 < param_2) {
puVar2 = param_1;
do {
puVar3 = puVar2 + 1;
sVar1 = strlen(ans_1);
*(int2 *)(ans_1 + sVar1) = 0x20;
__strcpy_chk(sVar1 + 0x104041,*puVar2,(long)&_end -... |
5,895 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(char* arr[], int size) {
static char ans[1000] = "";
strcpy(ans, " ");
for(int i = 0; i < size; i++) {
strcat(ans, " ");
strcat(ans, arr[i]);
}
return ans;
}
| int main() {
char* list1[] = {"hello", "there", "have", "a", "rocky", "day"};
char* list2[] = {"Hi", "there", "How", "are", "you"};
char* list3[] = {"Part", "of", "the", "journey", "is", "end"};
assert(strcmp(func0(list1, 6), " hello there have a rocky day") == 0);
assert(strcmp(func0(list2, 5), " Hi... | O3 | c | func0:
endbr64
mov $0x20,%edx
mov %dx,0x2c80(%rip)
test %esi,%esi
jle 1450 <func0+0xa0>
lea -0x1(%rsi),%eax
push %r12
mov %rdi,%r12
push %rbp
lea 0x8(%rdi,%rax,8),%rbp
push %rbx
lea 0x304a(%rip),%rbx
xchg %ax,%ax
lea 0x2c59(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x10101... | func0:
endbr64
push r13
mov edx, 20h ; ' '
push r12
push rbp
push rbx
lea rbx, ans_1
sub rsp, 8
mov cs:ans_1, dx
test esi, esi
jle short loc_1450
movsxd rsi, esi
mov r13, rdi
lea rbp, [rbx+3E8h]
lea r12, [rdi+rsi*8]
nop word ptr [rax+rax+00000000h]
loc_1420:
mov r... | char * func0(long long a1, int a2)
{
long long v2; // r13
size_t v3; // rax
strcpy(ans_1, " ");
if ( a2 > 0 )
{
v2 = a1;
do
{
v2 += 8LL;
v3 = strlen(ans_1);
*(_WORD *)&ans_1[v3] = 32;
__strcpy_chk(&ans_1[v3 + 1], *(_QWORD *)(v2 - 8), 1000 - (v3 + 1));
}
while ( v2 ... | func0:
ENDBR64
PUSH R13
MOV EDX,0x20
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x104040]
SUB RSP,0x8
MOV word ptr [0x00104040],DX
TEST ESI,ESI
JLE 0x00101450
MOVSXD RSI,ESI
MOV R13,RDI
LEA RBP,[RBX + 0x3e8]
LEA R12,[RDI + RSI*0x8]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101420:
MOV RDI,RBX
ADD R13,0x8
CALL 0x00101090
MOV RDX,R... | int1 * func0(int8 *param_1,int param_2)
{
size_t sVar1;
int8 *puVar2;
int8 *puVar3;
ans_1._0_2_ = 0x20;
if (0 < param_2) {
puVar2 = param_1;
do {
puVar3 = puVar2 + 1;
sVar1 = strlen(ans_1);
*(int2 *)(ans_1 + sVar1) = 0x20;
__strcpy_chk(sVar1 + 0x104041,*puVar2,(long)&_end -... |
5,896 | func0 | #include <assert.h>
#include <math.h>
int ngcd(int x, int y) {
int gcd = 1;
int i = 1;
while (i <= x && i <= y) {
if (x % i == 0 && y % i == 0) {
gcd = i;
}
i++;
}
return gcd;
}
| int func0(int x, int y) {
int n = ngcd(x, y);
int result = 0;
int z = (int) sqrt(n);
int i = 1;
while (i <= z) {
if (n % i == 0) {
result += 2;
if (i == n / i) {
result -= 1;
}
}
i++;
}
return result;
... | int main() {
assert(func0(2, 4) == 2);
assert(func0(2, 8) == 2);
assert(func0(12, 24) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x18(%rbp),%edx
mov -0x14(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1169 <ngcd>
mov %eax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
cvtsi2sdl -0x8(%rbp),%xmm0
callq 1070 <sqrt@plt>
cvttsd2si %x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
mov esi, edx
mov edi, eax
call ngcd
mov [rbp+var_8], eax
mov [rbp+var_10], 0
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_8]
movq rax, ... | long long func0(unsigned int a1, unsigned int a2)
{
unsigned int v3; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
int v5; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
v5 = ngcd(a1, a2);
v3 = 0;
v6 = (int)sqrt((double)v5);
for ( i = 1; i <= v6; ++i )
{
if ( !(v5 % i) )
{
v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x10],0x0
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [... | int func0(int4 param_1,int4 param_2)
{
int iVar1;
int iVar2;
double dVar3;
int4 local_18;
int4 local_14;
iVar2 = ngcd(param_1,param_2);
local_18 = 0;
dVar3 = sqrt((double)iVar2);
for (local_14 = 1; local_14 <= (int)dVar3; local_14 = local_14 + 1) {
iVar1 = local_18;
if ((iVar2 % local_14 =... |
5,897 | func0 | #include <assert.h>
#include <math.h>
int ngcd(int x, int y) {
int gcd = 1;
int i = 1;
while (i <= x && i <= y) {
if (x % i == 0 && y % i == 0) {
gcd = i;
}
i++;
}
return gcd;
}
| int func0(int x, int y) {
int n = ngcd(x, y);
int result = 0;
int z = (int) sqrt(n);
int i = 1;
while (i <= z) {
if (n % i == 0) {
result += 2;
if (i == n / i) {
result -= 1;
}
}
i++;
}
return result;
... | int main() {
assert(func0(2, 4) == 2);
assert(func0(2, 8) == 2);
assert(func0(12, 24) == 6);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x10,%rsp
callq 1169 <ngcd>
mov %eax,%ebx
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 11fd <func0+0x49>
cvttsd2si 0x8(%rsp),%edi
test %edi,%edi
jle 122b <func0+0x77>
add $... | func0:
endbr64
push rbx
call ngcd
mov ebx, eax
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_11ED
sqrtsd xmm0, xmm0
loc_11D6:
cvttsd2si edi, xmm0
test edi, edi
jle short loc_121B
add edi, 1
mov ecx, 1
mov esi, 0
jmp short loc_11FB
loc_11E... | long long func0()
{
int v0; // ebx
double v1; // xmm0_8
double v2; // xmm0_8
int v3; // ecx
unsigned int v4; // esi
v0 = ngcd();
v1 = (double)v0;
if ( (double)v0 < 0.0 )
v2 = sqrt(v1);
else
v2 = sqrt(v1);
if ( (int)v2 <= 0 )
{
return 0;
}
else
{
v3 = 1;
v4 = 0;
do
... | func0:
ENDBR64
PUSH RBX
CALL 0x00101169
MOV EBX,EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x001011ed
SQRTSD XMM0,XMM0
LAB_001011d6:
CVTTSD2SI EDI,XMM0
TEST EDI,EDI
JLE 0x0010121b
ADD EDI,0x1
MOV ECX,0x1
MOV ESI,0x0
JMP 0x001011fb
LAB_001011ed:
CALL 0x00101070
JMP 0x001011d6
LAB_001011f4:
... | int func0(void)
{
int iVar1;
int iVar2;
int iVar3;
double dVar4;
iVar1 = ngcd();
dVar4 = (double)iVar1;
if (dVar4 < 0.0) {
dVar4 = sqrt(dVar4);
}
else {
dVar4 = SQRT(dVar4);
}
if ((int)dVar4 < 1) {
iVar3 = 0;
}
else {
iVar2 = 1;
iVar3 = 0;
do {
if (iVar1 % iVa... |
5,898 | func0 | #include <assert.h>
#include <math.h>
int ngcd(int x, int y) {
int gcd = 1;
int i = 1;
while (i <= x && i <= y) {
if (x % i == 0 && y % i == 0) {
gcd = i;
}
i++;
}
return gcd;
}
| int func0(int x, int y) {
int n = ngcd(x, y);
int result = 0;
int z = (int) sqrt(n);
int i = 1;
while (i <= z) {
if (n % i == 0) {
result += 2;
if (i == n / i) {
result -= 1;
}
}
i++;
}
return result;
... | int main() {
assert(func0(2, 4) == 2);
assert(func0(2, 8) == 2);
assert(func0(12, 24) == 6);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %esi,%r8d
sub $0x10,%rsp
cmp %esi,%edi
cmovle %edi,%r8d
test %r8d,%r8d
jle 1340 <func0+0xc0>
add $0x1,%r8d
mov $0x1,%ebx
mov $0x1,%ecx
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 12c3 <func0+0x43>
mov %esi,%eax
cltd
idiv %ecx
test... | func0:
endbr64
cmp edi, esi
mov r8d, esi
push rbx
cmovle r8d, edi
test r8d, r8d
jle loc_1320
add r8d, 1
mov ebx, 1
mov ecx, 1
nop dword ptr [rax]
loc_12A8:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_12BB
mov eax, esi
cdq
idiv ecx
test edx, edx
cmovz ... | long long func0(int a1, int a2)
{
int v2; // r8d
int v3; // r8d
int v4; // ebx
int v5; // ecx
double v6; // xmm0_8
double v7; // xmm0_8
int v8; // ecx
unsigned int v9; // r8d
v2 = a2;
if ( a1 <= a2 )
v2 = a1;
if ( v2 <= 0 )
{
v6 = 1.0;
v4 = 1;
LABEL_10:
v7 = sqrt(v6);
goto ... | func0:
ENDBR64
CMP EDI,ESI
MOV R8D,ESI
PUSH RBX
CMOVLE R8D,EDI
TEST R8D,R8D
JLE 0x00101320
ADD R8D,0x1
MOV EBX,0x1
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_001012a8:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001012bb
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ EBX,ECX
LAB_001012bb:
ADD ECX,0x1
CMP ECX,R8D
JNZ 0x001012a8
P... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
double dVar4;
iVar2 = param_2;
if (param_1 <= param_2) {
iVar2 = param_1;
}
if (iVar2 < 1) {
iVar3 = 1;
dVar4 = DAT_00102060;
}
else {
iVar3 = 1;
iVar1 = 1;
do {
if ((param_1 % iVar1 == 0) && (par... |
5,899 | func0 | #include <assert.h>
#include <math.h>
int ngcd(int x, int y) {
int gcd = 1;
int i = 1;
while (i <= x && i <= y) {
if (x % i == 0 && y % i == 0) {
gcd = i;
}
i++;
}
return gcd;
}
| int func0(int x, int y) {
int n = ngcd(x, y);
int result = 0;
int z = (int) sqrt(n);
int i = 1;
while (i <= z) {
if (n % i == 0) {
result += 2;
if (i == n / i) {
result -= 1;
}
}
i++;
}
return result;
... | int main() {
assert(func0(2, 4) == 2);
assert(func0(2, 8) == 2);
assert(func0(12, 24) == 6);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %esi,%r8d
sub $0x10,%rsp
cmp %esi,%edi
cmovle %edi,%r8d
test %r8d,%r8d
jle 1340 <func0+0xc0>
add $0x1,%r8d
mov $0x1,%ebx
mov $0x1,%ecx
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 12c3 <func0+0x43>
mov %esi,%eax
cltd
idiv %ecx
test... | func0:
endbr64
cmp edi, esi
mov r8d, esi
push rbx
cmovle r8d, edi
test r8d, r8d
jle loc_1320
add r8d, 1
mov ebx, 1
mov ecx, 1
nop dword ptr [rax]
loc_12A8:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_12BB
mov eax, esi
cdq
idiv ecx
test edx, edx
cmovz ... | long long func0(int a1, int a2)
{
int v2; // r8d
int v3; // r8d
int v4; // ebx
int v5; // ecx
double v6; // xmm0_8
int v7; // edi
int v8; // edi
int v9; // ecx
unsigned int v10; // esi
v2 = a2;
if ( a1 <= a2 )
v2 = a1;
if ( v2 <= 0 )
{
v7 = 1;
v4 = 1;
}
else
{
v3 = v2 +... | func0:
ENDBR64
CMP EDI,ESI
MOV R8D,ESI
PUSH RBX
CMOVLE R8D,EDI
TEST R8D,R8D
JLE 0x00101320
ADD R8D,0x1
MOV EBX,0x1
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_001012a8:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001012bb
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ EBX,ECX
LAB_001012bb:
ADD ECX,0x1
CMP R8D,ECX
JNZ 0x001012a8
P... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
double dVar5;
iVar4 = param_2;
if (param_1 <= param_2) {
iVar4 = param_1;
}
if (iVar4 < 1) {
iVar4 = 1;
iVar2 = 1;
}
else {
iVar2 = 1;
iVar1 = 1;
do {
if ((param_1 % iVar1 == 0) && (p... |
5,900 | func0 |
#include <assert.h>
| int func0(int n, int m) {
int r = n % m;
return r;
}
| int main() {
assert(func0(3, 3) == 0);
assert(func0(10, 3) == 1);
assert(func0(16, 5) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov [rbp+var_4], edx
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 % a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EDX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2)
{
return param_1 % param_2;
} |
5,901 | func0 |
#include <assert.h>
| int func0(int n, int m) {
int r = n % m;
return r;
}
| int main() {
assert(func0(3, 3) == 0);
assert(func0(10, 3) == 1);
assert(func0(16, 5) == 1);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
mov %edx,%eax
retq
| func0:
endbr64
mov eax, edi
cdq
idiv esi
mov eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 % a2);
} | func0:
ENDBR64
MOV EAX,EDI
CDQ
IDIV ESI
MOV EAX,EDX
RET | ulong func0(int param_1,int param_2)
{
return (long)param_1 % (long)param_2 & 0xffffffff;
} |
5,902 | func0 |
#include <assert.h>
| int func0(int n, int m) {
int r = n % m;
return r;
}
| int main() {
assert(func0(3, 3) == 0);
assert(func0(10, 3) == 1);
assert(func0(16, 5) == 1);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
mov %edx,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
cdq
idiv esi
mov eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 % a2);
} | func0:
ENDBR64
MOV EAX,EDI
CDQ
IDIV ESI
MOV EAX,EDX
RET | ulong func0(int param_1,int param_2)
{
return (long)param_1 % (long)param_2 & 0xffffffff;
} |
5,903 | func0 |
#include <assert.h>
| int func0(int n, int m) {
int r = n % m;
return r;
}
| int main() {
assert(func0(3, 3) == 0);
assert(func0(10, 3) == 1);
assert(func0(16, 5) == 1);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
mov %edx,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
cdq
idiv esi
mov eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 % a2);
} | func0:
ENDBR64
MOV EAX,EDI
CDQ
IDIV ESI
MOV EAX,EDX
RET | ulong func0(int param_1,int param_2)
{
return (long)param_1 % (long)param_2 & 0xffffffff;
} |
5,904 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int size, int result[]) {
for (int i = 0; i < size - 1; i++) {
result[i] = nums[i] + nums[i + 1];
}
}
| int main() {
int result1[7];
int nums1[] = {1, 1, 3, 4, 4, 5, 6, 7};
func0(nums1, 8, result1);
int exp1[] = {2, 4, 7, 8, 9, 11, 13};
for (int i = 0; i < 7; i++) {
assert(result1[i] == exp1[i]);
}
int result2[5];
int nums2[] = {4, 5, 8, 9, 6, 10};
func0(nums2, 6, r... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%eax
cltq
add $0x1,%ra... | 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_4], 0
jmp short loc_11F1
loc_11A5:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]
mov eax, [rbp+var_4]
... | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
int i; // [rsp+24h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = (unsigned int)(a2 - 1);
if ( i >= (int)result )
break;
*(_DWORD *)(4LL * i + a3) = *(_DWORD *)(4LL * i + a1) + *(_DWORD *)(4 * (i + 1LL) + a1);
}
re... | 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 + -0x4],0x0
JMP 0x001011f1
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV EA... | void func0(long param_1,int param_2,long param_3)
{
int4 local_c;
for (local_c = 0; local_c < param_2 + -1; local_c = local_c + 1) {
*(int *)(param_3 + (long)local_c * 4) =
*(int *)(param_1 + ((long)local_c + 1) * 4) + *(int *)(param_1 + (long)local_c * 4);
}
return;
} |
5,905 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int size, int result[]) {
for (int i = 0; i < size - 1; i++) {
result[i] = nums[i] + nums[i + 1];
}
}
| int main() {
int result1[7];
int nums1[] = {1, 1, 3, 4, 4, 5, 6, 7};
func0(nums1, 8, result1);
int exp1[] = {2, 4, 7, 8, 9, 11, 13};
for (int i = 0; i < 7; i++) {
assert(result1[i] == exp1[i]);
}
int result2[5];
int nums2[] = {4, 5, 8, 9, 6, 10};
func0(nums2, 6, r... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11b0 <func0+0x27>
lea -0x2(%rsi),%esi
mov $0x0,%eax
mov 0x4(%rdi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rsi,%rcx
jne 119a <func0+0x11>
retq
| func0:
endbr64
cmp esi, 1
jle short locret_11B0
lea esi, [rsi-2]
mov eax, 0
loc_119A:
mov ecx, [rdi+rax*4+4]
add ecx, [rdi+rax*4]
mov [rdx+rax*4], ecx
mov rcx, rax
add rax, 1
cmp rcx, rsi
jnz short loc_119A
locret_11B0:
retn | void func0(long long a1, int a2, long long a3)
{
long long v3; // rsi
long long v4; // rax
long long v5; // rcx
if ( a2 > 1 )
{
v3 = (unsigned int)(a2 - 2);
v4 = 0LL;
do
{
*(_DWORD *)(a3 + 4 * v4) = *(_DWORD *)(a1 + 4 * v4) + *(_DWORD *)(a1 + 4 * v4 + 4);
v5 = v4++;
}
whi... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011b0
LEA ESI,[RSI + -0x2]
MOV EAX,0x0
LAB_0010119a:
MOV ECX,dword ptr [RDI + RAX*0x4 + 0x4]
ADD ECX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],ECX
MOV RCX,RAX
ADD RAX,0x1
CMP RCX,RSI
JNZ 0x0010119a
LAB_001011b0:
RET | void func0(long param_1,int param_2,long param_3)
{
ulong uVar1;
bool bVar2;
if (1 < param_2) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 4) =
*(int *)(param_1 + 4 + uVar1 * 4) + *(int *)(param_1 + uVar1 * 4);
bVar2 = uVar1 != param_2 - 2;
uVar1 = uVar1 + 1;
} while (... |
5,906 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int size, int result[]) {
for (int i = 0; i < size - 1; i++) {
result[i] = nums[i] + nums[i + 1];
}
}
| int main() {
int result1[7];
int nums1[] = {1, 1, 3, 4, 4, 5, 6, 7};
func0(nums1, 8, result1);
int exp1[] = {2, 4, 7, 8, 9, 11, 13};
for (int i = 0; i < 7; i++) {
assert(result1[i] == exp1[i]);
}
int result2[5];
int nums2[] = {4, 5, 8, 9, 6, 10};
func0(nums2, 6, r... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1496 <func0+0x26>
sub $0x2,%esi
xor %eax,%eax
xchg %ax,%ax
mov 0x4(%rdi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rsi,%rcx
jne 1480 <func0+0x10>
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, 1
jle short locret_1496
sub esi, 2
xor eax, eax
xchg ax, ax
loc_1480:
mov ecx, [rdi+rax*4+4]
add ecx, [rdi+rax*4]
mov [rdx+rax*4], ecx
mov rcx, rax
add rax, 1
cmp rcx, rsi
jnz short loc_1480
locret_1496:
retn | void func0(long long a1, int a2, long long a3)
{
long long v3; // rsi
long long v4; // rax
long long v5; // rcx
if ( a2 > 1 )
{
v3 = (unsigned int)(a2 - 2);
v4 = 0LL;
do
{
*(_DWORD *)(a3 + 4 * v4) = *(_DWORD *)(a1 + 4 * v4) + *(_DWORD *)(a1 + 4 * v4 + 4);
v5 = v4++;
}
whi... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101496
SUB ESI,0x2
XOR EAX,EAX
NOP
LAB_00101480:
MOV ECX,dword ptr [RDI + RAX*0x4 + 0x4]
ADD ECX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],ECX
MOV RCX,RAX
ADD RAX,0x1
CMP RCX,RSI
JNZ 0x00101480
LAB_00101496:
RET | void func0(long param_1,int param_2,long param_3)
{
ulong uVar1;
bool bVar2;
if (1 < param_2) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 4) =
*(int *)(param_1 + 4 + uVar1 * 4) + *(int *)(param_1 + uVar1 * 4);
bVar2 = uVar1 != param_2 - 2;
uVar1 = uVar1 + 1;
} while (... |
5,907 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int nums[], int size, int result[]) {
for (int i = 0; i < size - 1; i++) {
result[i] = nums[i] + nums[i + 1];
}
}
| int main() {
int result1[7];
int nums1[] = {1, 1, 3, 4, 4, 5, 6, 7};
func0(nums1, 8, result1);
int exp1[] = {2, 4, 7, 8, 9, 11, 13};
for (int i = 0; i < 7; i++) {
assert(result1[i] == exp1[i]);
}
int result2[5];
int nums2[] = {4, 5, 8, 9, 6, 10};
func0(nums2, 6, r... | O3 | c | func0:
endbr64
lea -0x1(%rsi),%r8d
test %r8d,%r8d
jle 150e <func0+0xbe>
lea 0x10(%rdx),%rax
sub $0x2,%esi
cmp %rax,%rdi
lea 0x14(%rdi),%rax
setae %cl
cmp %rax,%rdx
setae %al
or %al,%cl
je 14f0 <func0+0xa0>
cmp $0x2,%esi
jbe 14f0 <func0+0xa0>
mov %r8d,%ecx
xor %eax,%eax
shr ... | func0:
endbr64
mov rcx, rdi
mov rdi, rdx
cmp esi, 1
jle short locret_11B8
cmp esi, 2
jz short loc_1194
lea rdx, [rcx+4]
mov rax, rdi
sub rax, rdx
cmp rax, 0Ch
ja short loc_11C0
loc_1194:
sub esi, 1
xor eax, eax
nop dword ptr [rax+00000000h]
loc_11A0:
mov edx... | void func0(long long a1, int a2, long long a3)
{
long long v5; // rsi
long long v6; // rax
int v7; // edx
unsigned int v8; // r8d
long long v9; // rax
long long v10; // r8
long long v11; // rdx
int v12; // esi
int v13; // eax
if ( a2 > 1 )
{
if ( a2 == 2 || (unsigned long long)(a3 - (a1 + 4)... | func0:
ENDBR64
MOV RCX,RDI
MOV RDI,RDX
CMP ESI,0x1
JLE 0x001011b8
CMP ESI,0x2
JZ 0x00101194
LEA RDX,[RCX + 0x4]
MOV RAX,RDI
SUB RAX,RDX
CMP RAX,0xc
JA 0x001011c0
LAB_00101194:
SUB ESI,0x1
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001011a0:
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
ADD EDX,dword ptr [RCX + RAX*0x4]
MOV dword pt... | void func0(long param_1,int param_2,long param_3)
{
uint uVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
int8 uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
ulong uVar13;
long lVar14;
uint uVar15;
if (1 < param_2) {
if ((param_2 == 2) || ((u... |
5,908 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return sum;
}
| int main() {
assert(func0(5) == 225);
assert(func0(2) == 9);
assert(func0(3) == 36);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1175 <func0+0x2c>
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1164 <func0+0x1b>
... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_1175
loc_1164:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_1175:
mov eax, [rbp+var_4]
cmp eax, [rbp+var... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += i * i * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101175
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101175:
MOV EAX,d... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = local_10 + local_c * local_c * local_c;
}
return local_10;
} |
5,909 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return sum;
}
| int main() {
assert(func0(5) == 225);
assert(func0(2) == 9);
assert(func0(3) == 36);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1172 <func0+0x29>
add $0x1,%edi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add %edx,%ecx
add $0x1,%eax
cmp %edi,%eax
jne 115e <func0+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 116f <func0+0x26>
| func0:
endbr64
test edi, edi
jle short loc_1172
add edi, 1
mov eax, 1
mov ecx, 0
loc_115E:
mov edx, eax
imul edx, eax
imul edx, eax
add ecx, edx
add eax, 1
cmp eax, edi
jnz short loc_115E
loc_116F:
mov eax, ecx
retn
loc_1172:
mov ecx, 0
jmp short loc_116F | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v3 += v2 * v2 * v2;
++v2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101172
ADD EDI,0x1
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115e:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD ECX,EDX
ADD EAX,0x1
CMP EAX,EDI
JNZ 0x0010115e
LAB_0010116f:
MOV EAX,ECX
RET
LAB_00101172:
MOV ECX,0x0
JMP 0x0010116f | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
return iVar2;
} |
5,910 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return sum;
}
| int main() {
assert(func0(5) == 225);
assert(func0(2) == 9);
assert(func0(3) == 36);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
add %edx,%r8d
cmp %eax,%edi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov ... | func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
add r8d, edx
cmp eax, edi
jnz short loc_1158
mov eax, r8d
retn
loc_1170:
xor r8d, r8d
mov ... | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // r8d
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
ADD R8D,EDX
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar3 = 0;
do {
iVar2 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar3 = iVar3 + iVar2;
} while (iVar1 != param_1 + 1);
return iVar3;
}
return 0;
} |
5,911 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return sum;
}
| int main() {
assert(func0(5) == 225);
assert(func0(2) == 9);
assert(func0(3) == 36);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
add %edx,%r8d
cmp %eax,%edi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov ... | func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
add ecx, edx
cmp edi, eax
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ecx, ecx
mov ... | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += v4;
}
while ( v1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
ADD ECX,EDX
CMP EDI,EAX
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar2 = iVar2 + iVar3;
} while (param_1 + 1 != iVar1);
return iVar2;
}
return 0;
} |
5,912 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int *A, int length) {
int k = 0;
for (int i = 0; i < length; i++) {
if (A[i]) {
A[k] = A[i];
k++;
}
}
for (int i = k; i < length; i++) {
A[i] = 0;
}
}
| int main() {
int array1[9] = {6, 0, 8, 2, 3, 0, 4, 0, 1};
int result1[9] = {6, 8, 2, 3, 4, 1, 0, 0, 0};
func0(array1, 9);
assert(memcmp(array1, result1, 9 * sizeof(int)) == 0);
int array2[9] = {4, 0, 2, 7, 0, 9, 0, 12, 0};
int result2[9] = {4, 2, 7, 9, 12, 0, 0, 0, 0};
func0(array2,... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f7 <func0+0x6e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
je 11f3 <func0+0x6a>
mo... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11F7
loc_11A8:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jz sho... | long long func0(long long a1, int a2)
{
long long result; // rax
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
unsigned int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) )
*(_DWORD *)(4LL * (int)v3++ + a1) = *(_DWORD *)(4LL *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f7
LAB_001011a8:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EA... | void func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if (*(int *)(param_1 + (long)local_10 * 4) != 0) {
*(int4 *)(param_1 + (long)local_14 * 4) = *(int4 *)(param_1 + (long)local_10 * 4);... |
5,913 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int *A, int length) {
int k = 0;
for (int i = 0; i < length; i++) {
if (A[i]) {
A[k] = A[i];
k++;
}
}
for (int i = k; i < length; i++) {
A[i] = 0;
}
}
| int main() {
int array1[9] = {6, 0, 8, 2, 3, 0, 4, 0, 1};
int result1[9] = {6, 8, 2, 3, 4, 1, 0, 0, 0};
func0(array1, 9);
assert(memcmp(array1, result1, 9 * sizeof(int)) == 0);
int array2[9] = {4, 0, 2, 7, 0, 9, 0, 12, 0};
int result2[9] = {4, 2, 7, 9, 12, 0, 0, 0, 0};
func0(array2,... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11e9 <func0+0x60>
mov %rdi,%rax
lea -0x1(%rsi),%r10d
lea 0x4(%rdi),%r11
mov %r10d,%edx
lea (%r11,%rdx,4),%r8
mov $0x0,%ecx
jmp 11b3 <func0+0x2a>
add $0x4,%rax
cmp %r8,%rax
je 11c5 <func0+0x3c>
mov (%rax),%edx
test %edx,%edx
je 11aa <func0+0x... | func0:
endbr64
test esi, esi
jle short locret_11E9
mov rax, rdi
lea r10d, [rsi-1]
lea r11, [rdi+4]
mov edx, r10d
lea r8, [r11+rdx*4]
mov ecx, 0
jmp short loc_11B3
loc_11AA:
add rax, 4
cmp rax, r8
jz short loc_11C5
loc_11B3:
mov edx, [rax]
test edx, edx
jz shor... | void func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
int v3; // ecx
_DWORD *v4; // rax
if ( a2 > 0 )
{
v2 = a1;
v3 = 0;
do
{
if ( *v2 )
a1[v3++] = *v2;
++v2;
}
while ( v2 != &a1[a2 - 1 + 1] );
if ( v3 < a2 )
{
v4 = &a1[v3];
do
*v4++ = 0;... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011e9
MOV RAX,RDI
LEA R10D,[RSI + -0x1]
LEA R11,[RDI + 0x4]
MOV EDX,R10D
LEA R8,[R11 + RDX*0x4]
MOV ECX,0x0
JMP 0x001011b3
LAB_001011aa:
ADD RAX,0x4
CMP RAX,R8
JZ 0x001011c5
LAB_001011b3:
MOV EDX,dword ptr [RAX]
TEST EDX,EDX
JZ 0x001011aa
MOVSXD R9,ECX
MOV dword ptr [RDI + R9*0x4],E... | void func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
piVar1 = param_1;
do {
if (*piVar1 != 0) {
param_1[iVar2] = *piVar1;
iVar2 = iVar2 + 1;
}
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)(param_2 - 1U) + 1);... |
5,914 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int *A, int length) {
int k = 0;
for (int i = 0; i < length; i++) {
if (A[i]) {
A[k] = A[i];
k++;
}
}
for (int i = k; i < length; i++) {
A[i] = 0;
}
}
| int main() {
int array1[9] = {6, 0, 8, 2, 3, 0, 4, 0, 1};
int result1[9] = {6, 8, 2, 3, 4, 1, 0, 0, 0};
func0(array1, 9);
assert(memcmp(array1, result1, 9 * sizeof(int)) == 0);
int array2[9] = {4, 0, 2, 7, 0, 9, 0, 12, 0};
int result2[9] = {4, 2, 7, 9, 12, 0, 0, 0, 0};
func0(array2,... | O2 | c | func0:
endbr64
test %esi,%esi
jle 151f <func0+0x5f>
lea -0x1(%rsi),%edx
lea 0x4(%rdi),%r11
mov %rdi,%rax
xor %ecx,%ecx
mov %rdx,%r10
lea (%r11,%rdx,4),%r8
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
test %edx,%edx
je 14f0 <func0+0x30>
movslq %ecx,%r9
add $0x1,%ecx
mov %edx,(%rdi,%r9,4)... | func0:
endbr64
test esi, esi
jle short locret_1540
lea edx, [rsi-1]
mov rax, rdi
xor ecx, ecx
mov r10, rdx
lea r8, [rdi+rdx*4+4]
nop dword ptr [rax+rax+00000000h]
loc_1500:
mov edx, [rax]
test edx, edx
jz short loc_1510
movsxd r9, ecx
add ecx, 1
mov [rdi+r9*4], edx
lo... | void func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
int v3; // ecx
long long v4; // r10
long long v5; // r9
if ( a2 > 0 )
{
v2 = a1;
v3 = 0;
v4 = (unsigned int)(a2 - 1);
do
{
if ( *v2 )
{
v5 = v3++;
a1[v5] = *v2;
}
++v2;
}
while ( v2 != &... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101540
LEA EDX,[RSI + -0x1]
MOV RAX,RDI
XOR ECX,ECX
MOV R10,RDX
LEA R8,[RDI + RDX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101500:
MOV EDX,dword ptr [RAX]
TEST EDX,EDX
JZ 0x00101510
MOVSXD R9,ECX
ADD ECX,0x1
MOV dword ptr [RDI + R9*0x4],EDX
LAB_00101510:
ADD RAX,0x4
CMP RAX,R8
... | void func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
iVar2 = 0;
piVar1 = param_1;
do {
if (*piVar1 != 0) {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
param_1[lVar3] = *piVar1;
}
piVar1 = piVar1 + 1;
} while (piVa... |
5,915 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int *A, int length) {
int k = 0;
for (int i = 0; i < length; i++) {
if (A[i]) {
A[k] = A[i];
k++;
}
}
for (int i = k; i < length; i++) {
A[i] = 0;
}
}
| int main() {
int array1[9] = {6, 0, 8, 2, 3, 0, 4, 0, 1};
int result1[9] = {6, 8, 2, 3, 4, 1, 0, 0, 0};
func0(array1, 9);
assert(memcmp(array1, result1, 9 * sizeof(int)) == 0);
int array2[9] = {4, 0, 2, 7, 0, 9, 0, 12, 0};
int result2[9] = {4, 2, 7, 9, 12, 0, 0, 0, 0};
func0(array2,... | O3 | c | func0:
endbr64
test %esi,%esi
jle 14b0 <func0+0x60>
lea -0x1(%rsi),%edx
mov %rdi,%rax
xor %ecx,%ecx
mov %rdx,%r10
lea 0x4(%rdi,%rdx,4),%r8
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
test %edx,%edx
je 1480 <func0+0x30>
movslq %ecx,%r9
add $0x1,%ecx
mov %edx,(%rdi,%r9,4)
add $0x4,%rax
c... | func0:
endbr64
test esi, esi
jle short locret_1480
movsxd rdx, esi
mov rax, rdi
xor ecx, ecx
lea r8, [rdi+rdx*4]
nop dword ptr [rax+00h]
loc_1448:
mov edx, [rax]
test edx, edx
jz short loc_1458
movsxd r9, ecx
add ecx, 1
mov [rdi+r9*4], edx
loc_1458:
add rax, 4
cmp r8... | void func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
int v3; // ecx
long long v4; // r9
if ( a2 > 0 )
{
v2 = a1;
v3 = 0;
do
{
if ( *v2 )
{
v4 = v3++;
a1[v4] = *v2;
}
++v2;
}
while ( &a1[a2] != v2 );
if ( v3 < a2 )
memset(&a1[v3], 0, 4L... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101480
MOVSXD RDX,ESI
MOV RAX,RDI
XOR ECX,ECX
LEA R8,[RDI + RDX*0x4]
NOP dword ptr [RAX]
LAB_00101448:
MOV EDX,dword ptr [RAX]
TEST EDX,EDX
JZ 0x00101458
MOVSXD R9,ECX
ADD ECX,0x1
MOV dword ptr [RDI + R9*0x4],EDX
LAB_00101458:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101448
CMP ECX,ESI
JGE 0x0... | void func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
iVar2 = 0;
piVar1 = param_1;
do {
if (*piVar1 != 0) {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
param_1[lVar3] = *piVar1;
}
piVar1 = piVar1 + 1;
} while (para... |
5,916 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n, int k) {
int P[n+1][k+1];
for (int i = 0; i <= n; i++) {
int minValue = (i < k) ? i : k;
for (int j = 0; j <= minValue; j++) {
if (j == 0) {
P[i][j] = 1;
} else {
P[i][j] = P[i - 1][j] + j * P[i - 1][j - 1];
... | int main() {
assert(func0(10, 2) == 90);
assert(func0(10, 3) == 720);
assert(func0(10, 1) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %edi,-0x64(%rbp)
mov %esi,-0x68(%rbp)
mov %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
mov %rsp,%rcx
mov %rcx,%r15
mov -0x68(%rbp),%ecx
lea 0x1(%rcx),%esi
mov -... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov [rbp+var_48], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov r11, rax
mov eax, [rbp+var_48]
lea edi, [rax+1]
mov eax, [rbp+var_44]
lea r8d, [rax+1]
movs... | long long func0(int a1, int a2)
{
int v2; // edi
unsigned long long v3; // rsi
unsigned long long v4; // rax
void *v5; // rsp
int v6; // eax
_BYTE v8[8]; // [rsp+8h] [rbp-50h] BYREF
int v9; // [rsp+10h] [rbp-48h]
int v10; // [rsp+14h] [rbp-44h]
int i; // [rsp+1Ch] [rbp-3Ch]
int j; // [rsp+20h] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV dword ptr [RBP + -0x48],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV R11,RAX
MOV EAX,dword ptr [RBP + -0x48]
LEA EDI,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x44]
LEA R8D,[RAX + 0x1... | int4 func0(int param_1,int param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_58 [8];
int local_50;
int local_4c;
int local_44;
int local_40;
int local_3c;
long local_38;
long local_30;
int *local_28;
long local_20;
local_4c = param_1;
loca... |
5,917 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n, int k) {
int P[n+1][k+1];
for (int i = 0; i <= n; i++) {
int minValue = (i < k) ? i : k;
for (int j = 0; j <= minValue; j++) {
if (j == 0) {
P[i][j] = 1;
} else {
P[i][j] = P[i - 1][j] + j * P[i - 1][j - 1];
... | int main() {
assert(func0(10, 2) == 90);
assert(func0(10, 3) == 720);
assert(func0(10, 1) == 10);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
movslq %eax,%rcx
lea 0x0(,%rcx,4),%r12
lea 0x1(%rdi),%edx
movslq %edx,%rax
imul %r... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebx, edi
mov [rbp+var_44], edi
mov edi, esi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea edx, [rsi+1]
movsxd rdx, edx
lea r12, ds:0[rdx*4]
lea eax, ... | long long func0(int a1, int a2)
{
long long v4; // rdx
unsigned long long v5; // r12
_DWORD *v6; // rdx
signed long long v7; // rax
void *v8; // rsp
_DWORD *v9; // r10
_DWORD *v10; // rsi
int v11; // r14d
_DWORD *v12; // r9
int v13; // r11d
long long v14; // rax
int v15; // eax
long long v16;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,EDI
MOV dword ptr [RBP + -0x44],EDI
MOV EDI,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EDX,[RSI + 0x1]
MOVSXD RDX,EDX
LEA R12,[RDX*0x4]
LEA EAX,[RBX + 0x1]
CDQE
IMUL RAX,RDX
LEA RAX... | int4 func0(int param_1,int param_2)
{
int iVar1;
long lVar2;
long lVar3;
int iVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
int1 *puVar8;
int1 *puVar9;
int1 *puVar10;
int1 *puVar11;
int iVar12;
long in_FS_OFFSET;
int1 auStack_58 [12];
int local_4c;
long local_40;
local_4c = param_1;
... |
5,918 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n, int k) {
int P[n+1][k+1];
for (int i = 0; i <= n; i++) {
int minValue = (i < k) ? i : k;
for (int j = 0; j <= minValue; j++) {
if (j == 0) {
P[i][j] = 1;
} else {
P[i][j] = P[i - 1][j] + j * P[i - 1][j - 1];
... | int main() {
assert(func0(10, 2) == 90);
assert(func0(10, 3) == 720);
assert(func0(10, 1) == 10);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
mov %edi,%r14d
push %r13
lea 0x1(%rdi),%r13d
push %r12
movslq %r13d,%rdx
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %rsp,%rbx
cltq
lea 0x0(,%rax,4),%r12
imul %... | func0:
endbr64
push rbp
lea edx, [rsi+1]
mov r8d, esi
movsxd rdx, edx
mov rbp, rsp
push r14
push r13
movsxd r13, edi
push r12
lea r12, ds:0[rdx*4]
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [r13+1]
mov rcx, rsp
cdqe
imul ... | long long func0(int a1, int a2)
{
long long v3; // rdx
long long v4; // r13
unsigned long long v5; // r12
long long v6; // rdx
_DWORD *v7; // rcx
__int16 v8; // dx
signed long long v9; // rdx
void *v10; // rsp
unsigned long long v11; // r14
_DWORD *v12; // rdi
int v13; // r10d
_DWORD *v14; // r... | func0:
ENDBR64
PUSH RBP
LEA EDX,[RSI + 0x1]
MOV R8D,ESI
MOVSXD RDX,EDX
MOV RBP,RSP
PUSH R14
PUSH R13
MOVSXD R13,EDI
PUSH R12
LEA R12,[RDX*0x4]
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[R13 + 0x1]
MOV RCX,RSP
CDQE
IMUL RAX,RDX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,R... | int4 func0(int param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
int1 *puVar5;
int1 *puVar7;
int1 *puVar8;
int iVar9;
ulong uVar10;
long in_FS_OFFSET;
bool bVar11;
int1 auStack_38 [8];
long local_30;
int1 *puVar6;
uVar4 = (ulong)(param_2 + 1);
puVar5 = auStack_38... |
5,919 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n, int k) {
int P[n+1][k+1];
for (int i = 0; i <= n; i++) {
int minValue = (i < k) ? i : k;
for (int j = 0; j <= minValue; j++) {
if (j == 0) {
P[i][j] = 1;
} else {
P[i][j] = P[i - 1][j] + j * P[i - 1][j - 1];
... | int main() {
assert(func0(10, 2) == 90);
assert(func0(10, 3) == 720);
assert(func0(10, 1) == 10);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
lea 0x1(%rdi),%edx
mov %rsp,%rbp
push %r15
push %r14
push %r13
mov %esi,%r13d
push %r12
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %rsp,%rbx
movslq %eax,%rcx
lea 0x0(,%rcx,4),%rax
mov %rax,-0x... | func0:
endbr64
push rbp
lea ecx, [rsi+1]
mov r10d, esi
mov edx, edi
movsxd rcx, ecx
mov rbp, rsp
push r15
lea r15, ds:0[rcx*4]
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdi+1]
mov rsi, rsp
... | long long func0(int a1, int a2)
{
long long v3; // rcx
unsigned long long v4; // r15
long long v5; // rcx
long long *v6; // rsi
__int16 v7; // cx
signed long long v8; // rcx
void *v9; // rsp
unsigned long long v10; // rsi
_DWORD *v11; // r8
long long v12; // r14
long long v13; // r13
_DWORD *v1... | func0:
ENDBR64
PUSH RBP
LEA ECX,[RSI + 0x1]
MOV R10D,ESI
MOV EDX,EDI
MOVSXD RCX,ECX
MOV RBP,RSP
PUSH R15
LEA R15,[RCX*0x4]
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
MOV RSI,RSP
CDQE
IMUL RAX,RCX
LEA RAX,[0xf + RAX*0x4]
MO... | int4 func0(int param_1,int param_2)
{
long lVar1;
long *plVar2;
int iVar3;
long lVar4;
int iVar5;
ulong uVar6;
int *piVar7;
int *puVar8;
long *plVar9;
ulong uVar11;
int *puVar12;
int iVar13;
int iVar14;
int iVar15;
long lVar16;
long lVar17;
long in_FS_OFFSET;
long local_58;
int lo... |
5,920 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(char *list1[], int list1_size, char *removewords[], int removewords_size) {
int i, j;
for (i = 0; i < list1_size; i++) {
for (j = 0; j < removewords_size; j++) {
if (strcmp(list1[i], removewords[j]) == 0) {
memmove(&list1[i], &list1[i + 1], (list1_size - i - 1... | int main() {
char *test_list1[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove1[] = {"white", "orange", NULL};
char *expected1[] = {"red", "green", "blue", "black", NULL};
char *test_list2[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove... | 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 %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1280 <func0+0xd7>
movl $0x0,-0x4(%rbp)
jmpq 1270 <func0+0xc7>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(... | 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_20], ecx
mov [rbp+var_8], 0
jmp loc_1280
loc_11CF:
mov [rbp+var_4], 0
jmp loc_1270
loc_11DB:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
... | _QWORD * func0(long long a1, int a2, long long a3, int a4)
{
_QWORD *result; // rax
int i; // [rsp+28h] [rbp-8h]
int j; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a4; ++j )
{
if ( !strcmp(*(const char **)(8LL * i + a1), *(const char **)(8LL * j + a3)) )
{
... | 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 + -0x20],ECX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101280
LAB_001011cf:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101270
LAB_001011db:
MOV EAX,dword ptr [RBP ... | void func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int4 local_24;
int4 local_10;
int4 local_c;
local_10 = 0;
local_24 = param_2;
do {
if (local_24 <= local_10) {
*(int8 *)(param_1 + (long)local_24 * 8) = 0;
return;
}
for (local_c = 0; local_c < param_4; ... |
5,921 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(char *list1[], int list1_size, char *removewords[], int removewords_size) {
int i, j;
for (i = 0; i < list1_size; i++) {
for (j = 0; j < removewords_size; j++) {
if (strcmp(list1[i], removewords[j]) == 0) {
memmove(&list1[i], &list1[i + 1], (list1_size - i - 1... | int main() {
char *test_list1[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove1[] = {"white", "orange", NULL};
char *expected1[] = {"red", "green", "blue", "black", NULL};
char *test_list2[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,(%rsp)
mov %esi,%r15d
mov %ecx,0x14(%rsp)
test %esi,%esi
jle 1253 <func0+0xaa>
mov %rdx,0x18(%rsp)
lea -0x1(%rcx),%eax
lea 0x8(%rdx,%rax,8),%r12
mov $0x0,%r13d
jmp 1217 <func0+0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_58], rdi
mov r14d, esi
mov [rsp+58h+var_40], rdx
mov [rsp+58h+var_44], ecx
test esi, esi
jle loc_1256
lea eax, [rcx-1]
lea r12, [rdx+rax*8+8]
mov r13d, 0
jmp sh... | long long func0(long long a1, int a2, _QWORD *a3, int a4)
{
int v4; // r14d
long long v5; // r12
int v6; // r13d
long long v7; // rbp
_QWORD *v8; // rbx
long long result; // rax
long long v10; // [rsp+8h] [rbp-50h]
v4 = a2;
if ( a2 > 0 )
{
v5 = (long long)&a3[(unsigned int)(a4 - 1) + 1];
v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],RDI
MOV R14D,ESI
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0x14],ECX
TEST ESI,ESI
JLE 0x00101256
LEA EAX,[RCX + -0x1]
LEA R12,[RDX + RAX*0x8 + 0x8]
MOV R13D,0x0
JMP 0x0010121a
LAB_001011e3:
MOV EDX,R14D
SUB E... | void func0(long param_1,int param_2,int8 *param_3,int param_4)
{
char *__s1;
int iVar1;
int8 *puVar2;
int iVar3;
int8 *__dest;
if (0 < param_2) {
iVar3 = 0;
do {
if (0 < param_4) {
__dest = (int8 *)(param_1 + (long)iVar3 * 8);
__s1 = (char *)*__dest;
puVar2 = param_... |
5,922 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(char *list1[], int list1_size, char *removewords[], int removewords_size) {
int i, j;
for (i = 0; i < list1_size; i++) {
for (j = 0; j < removewords_size; j++) {
if (strcmp(list1[i], removewords[j]) == 0) {
memmove(&list1[i], &list1[i + 1], (list1_size - i - 1... | int main() {
char *test_list1[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove1[] = {"white", "orange", NULL};
char *expected1[] = {"red", "green", "blue", "black", NULL};
char *test_list2[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %esi,%r14d
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,(%rsp)
mov %rdx,0x18(%rsp)
mov %ecx,0x14(%rsp)
test %esi,%esi
jle 15a8 <func0+0xb8>
mov %ecx,%eax
xor %r13d,%r13d
sub $0x1,%eax
lea 0x8(%rdx,%rax,8),%rbp
nopw 0... | func0:
endbr64
push r15
push r14
mov r14d, esi
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_58], rdi
mov [rsp+58h+var_40], rdx
mov [rsp+58h+var_44], ecx
test esi, esi
jle loc_15A8
mov eax, ecx
xor r13d, r13d
sub eax, 1
lea rbp, [rdx+rax*8... | long long func0(long long a1, int a2, _QWORD *a3, int a4)
{
int v4; // r14d
int v5; // r13d
long long v6; // rbp
_QWORD *v7; // r12
long long *v8; // r15
long long v9; // rbx
int v10; // edx
long long result; // rax
v4 = a2;
if ( a2 > 0 )
{
v5 = 0;
v6 = (long long)&a3[(unsigned int)(a4 -... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ESI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0x14],ECX
TEST ESI,ESI
JLE 0x001015a8
MOV EAX,ECX
XOR R13D,R13D
SUB EAX,0x1
LEA RBP,[RDX + RAX*0x8 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101530:
... | void func0(long param_1,int param_2,int8 *param_3,int param_4)
{
char *__s1;
int iVar1;
int8 *puVar2;
int iVar3;
int8 *__dest;
if (0 < param_2) {
iVar3 = 0;
do {
if (0 < param_4) {
__dest = (int8 *)(param_1 + (long)iVar3 * 8);
__s1 = (char *)*__dest;
puVar2 = param_... |
5,923 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(char *list1[], int list1_size, char *removewords[], int removewords_size) {
int i, j;
for (i = 0; i < list1_size; i++) {
for (j = 0; j < removewords_size; j++) {
if (strcmp(list1[i], removewords[j]) == 0) {
memmove(&list1[i], &list1[i + 1], (list1_size - i - 1... | int main() {
char *test_list1[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove1[] = {"white", "orange", NULL};
char *expected1[] = {"red", "green", "blue", "black", NULL};
char *test_list2[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %esi,%r14d
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,(%rsp)
mov %rdx,0x18(%rsp)
mov %ecx,0x14(%rsp)
test %esi,%esi
jle 1688 <func0+0xb8>
mov %ecx,%eax
xor %r13d,%r13d
sub $0x1,%eax
lea 0x8(%rdx,%rax,8),%rbp
nopw 0... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, esi
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_58], rdi
mov [rsp+58h+var_40], rdx
test esi, esi
jle loc_15F4
test ecx, ecx
jle loc_15F4
mov [rsp+58h+var_48], 0
movsxd rcx, ecx
xor r13d, r13d
lea ... | long long func0(long long a1, int a2, const char **a3, int a4)
{
int v4; // r12d
int v5; // r13d
const char **v6; // rbp
const char **v7; // r14
const char *v8; // rbx
int v9; // edx
long long result; // rax
const char **dest; // [rsp+8h] [rbp-50h]
long long v12; // [rsp+10h] [rbp-48h]
v4 = a2;
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x18],RDX
TEST ESI,ESI
JLE 0x001015f4
TEST ECX,ECX
JLE 0x001015f4
MOV qword ptr [RSP + 0x10],0x0
MOVSXD RCX,ECX
XOR R13D,R13D
LEA RBP,[RDX + RCX*0x8]
NOP dword ptr [RAX]
LAB_001015... | void func0(long param_1,int param_2,int8 *param_3,int param_4)
{
char *__s1;
int iVar1;
int8 *__dest;
int iVar2;
int8 *puVar3;
long local_48;
if ((0 < param_2) && (0 < param_4)) {
local_48 = 0;
iVar2 = 0;
LAB_00101588:
do {
__dest = (int8 *)(param_1 + local_48 * 8);
__s1 = (cha... |
5,924 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(char *l1[], char *l2[], int size1, int size2) {
int common_elements_size = 0;
char *common_elements[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
if (strcmp(l1[i], l2[j]) == 0) {
bool is_unique = true;
for (i... | int main() {
char *list1a[] = {"red", "green", "black", "orange"};
char *list2a[] = {"red", "pink", "green", "white", "black"};
char *list1b[] = {"red", "pink", "green", "white", "black"};
char *list2b[] = {"white", "orange", "pink", "black"};
char *list1c[] = {"red", "green", "black", "orange"... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x9c0,%rsp
mov %rdi,-0x9a8(%rbp)
mov %rsi,-0x9b0(%rbp)
mov %edx,-0x9b4(%rbp)
mov %ecx,-0x9b8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x99c(%rbp)
movl $0x0,-0x998(%rbp)
jmpq 1323 <func0+0x17a>
movl $0x0,-0x994(%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 9C0h
mov [rbp+var_9A8], rdi
mov [rbp+var_9B0], rsi
mov [rbp+var_9B4], edx
mov [rbp+var_9B8], ecx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_99C], 0
mov [rbp+var_998], 0
jmp loc_1323
loc_11FA:
mov [rb... | long long func0(long long a1, long long a2, int a3, int a4)
{
int v4; // eax
int v5; // eax
int v6; // eax
char v10; // [rsp+23h] [rbp-99Dh]
int v11; // [rsp+24h] [rbp-99Ch]
int i; // [rsp+28h] [rbp-998h]
int j; // [rsp+2Ch] [rbp-994h]
int k; // [rsp+30h] [rbp-990h]
int v15; // [rsp+34h] [rbp-98Ch]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x9c0
MOV qword ptr [RBP + -0x9a8],RDI
MOV qword ptr [RBP + -0x9b0],RSI
MOV dword ptr [RBP + -0x9b4],EDX
MOV dword ptr [RBP + -0x9b8],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x99c],0x0
MOV dword ptr [RBP + -0x998],0x0
J... | int8 func0(long param_1,long param_2,int param_3,int param_4)
{
bool bVar1;
int iVar2;
int8 uVar3;
long in_FS_OFFSET;
int local_9a4;
int local_9a0;
int local_99c;
int local_998;
int local_994;
int local_990;
int local_98c;
int local_988;
int local_984;
int local_980;
int local_97c;
int8... |
5,925 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(char *l1[], char *l2[], int size1, int size2) {
int common_elements_size = 0;
char *common_elements[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
if (strcmp(l1[i], l2[j]) == 0) {
bool is_unique = true;
for (i... | int main() {
char *list1a[] = {"red", "green", "black", "orange"};
char *list2a[] = {"red", "pink", "green", "white", "black"};
char *list1b[] = {"red", "pink", "green", "white", "black"};
char *list2b[] = {"white", "orange", "pink", "black"};
char *list1c[] = {"red", "green", "black", "orange"... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x9b8,%rsp
mov %rsi,0x30(%rsp)
mov %ecx,0x1c(%rsp)
mov %fs:0x28,%rax
mov %rax,0x9a8(%rsp)
xor %eax,%eax
test %edx,%edx
jle 13b3 <func0+0x20a>
mov %rdi,0x8(%rsp)
lea -0x1(%rdx),%eax
lea 0x8(%rdi,%r... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 9A8h
mov [rsp+9D8h+var_9B0], rsi
mov [rsp+9D8h+var_9C4], ecx
mov rcx, fs:28h
mov [rsp+9D8h+var_40], rcx
xor ecx, ecx
test edx, edx
jle loc_13A6
mov [rsp+9D8h+var_9D8], rdi
lea edx, [rdx... | long long func0(long long *a1, _QWORD *a2, int a3, int a4)
{
int v4; // r14d
long long v5; // r12
_QWORD *v6; // rbp
int v7; // r12d
_QWORD *v8; // rbx
long long v9; // rbp
int v10; // r13d
_QWORD *v11; // rbx
long long v12; // rbp
long long result; // rax
long long i; // rbx
_QWORD *v15; // rb... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x9a8
MOV qword ptr [RSP + 0x28],RSI
MOV dword ptr [RSP + 0x14],ECX
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x998],RCX
XOR ECX,ECX
TEST EDX,EDX
JLE 0x001013a6
MOV qword ptr [RSP],RDI
LEA EDX,[RDX + -0x1]
LEA RCX,[RDI + RDX*0x8 + 0x8]
... | int8 func0(int8 *param_1,int8 *param_2,int param_3,int param_4)
{
char *pcVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int8 uVar6;
int8 *puVar7;
ulong uVar8;
int8 *puVar9;
long in_FS_OFFSET;
bool bVar10;
int8 *local_9d8;
int8 *local_9d0;
int8 local_9a8 [100];
int8 auStack_688 [100];
... |
5,926 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(char *l1[], char *l2[], int size1, int size2) {
int common_elements_size = 0;
char *common_elements[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
if (strcmp(l1[i], l2[j]) == 0) {
bool is_unique = true;
for (i... | int main() {
char *list1a[] = {"red", "green", "black", "orange"};
char *list2a[] = {"red", "pink", "green", "white", "black"};
char *list1b[] = {"red", "pink", "green", "white", "black"};
char *list2b[] = {"white", "orange", "pink", "black"};
char *list1c[] = {"red", "green", "black", "orange"... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x9b8,%rsp
mov %rsi,0x38(%rsp)
mov %ecx,0x2c(%rsp)
mov %fs:0x28,%rax
mov %rax,0x9a8(%rsp)
xor %eax,%eax
test %edx,%edx
jle 15fc <func0+0x26c>
lea -0x1(%rdx),%eax
mov 0x38(%rsp),%rcx
mov %rdi,0x8(%... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 9B8h
mov [rsp+9E8h+var_9B0], rsi
mov [rsp+9E8h+var_9BC], ecx
mov rax, fs:28h
mov [rsp+9E8h+var_40], rax
xor eax, eax
test edx, edx
jle loc_15F9
lea eax, [rdx-1]
mov rdx, [rsp+9E8h+var_9... | long long func0(long long *a1, _QWORD *a2, int a3, int a4)
{
int v4; // r13d
long long v5; // r14
_QWORD *v6; // rbx
long long v7; // rbp
_QWORD *v8; // r15
long long v9; // rax
int v10; // ebx
long long v11; // r15
_QWORD *v12; // r14
long long v13; // r12
long long v14; // rax
int v15; // ebp... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x9b8
MOV qword ptr [RSP + 0x38],RSI
MOV dword ptr [RSP + 0x2c],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x9a8],RAX
XOR EAX,EAX
TEST EDX,EDX
JLE 0x001015f9
LEA EAX,[RDX + -0x1]
MOV RDX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x... | int8 func0(int8 *param_1,int8 *param_2,int param_3,int param_4)
{
char *pcVar1;
int iVar2;
int iVar3;
int iVar4;
long lVar5;
int8 uVar6;
int8 *puVar7;
int iVar8;
int8 *puVar9;
ulong uVar10;
long in_FS_OFFSET;
int8 *local_9e0;
int8 *local_9d8;
int8 *local_9d0;
int8 local_9a8 [100];
int8 ... |
5,927 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(char *l1[], char *l2[], int size1, int size2) {
int common_elements_size = 0;
char *common_elements[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
if (strcmp(l1[i], l2[j]) == 0) {
bool is_unique = true;
for (i... | int main() {
char *list1a[] = {"red", "green", "black", "orange"};
char *list2a[] = {"red", "pink", "green", "white", "black"};
char *list1b[] = {"red", "pink", "green", "white", "black"};
char *list2b[] = {"white", "orange", "pink", "black"};
char *list1c[] = {"red", "green", "black", "orange"... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x9b8,%rsp
mov %rsi,0x38(%rsp)
mov %ecx,0x2c(%rsp)
mov %fs:0x28,%rax
mov %rax,0x9a8(%rsp)
xor %eax,%eax
test %edx,%edx
jle 15dc <func0+0x25c>
lea -0x1(%rdx),%eax
mov %rdi,0x8(%rsp)
xor %r13d,%r13d... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 9B8h
mov [rsp+9E8h+var_9B8], rsi
mov [rsp+9E8h+var_9AC], ecx
mov rax, fs:28h
mov [rsp+9E8h+var_40], rax
xor eax, eax
test edx, edx
jle loc_166F
movsxd rdx, edx
mov [rsp+9E8h+var_9C8], rdi
... | bool func0(const char **a1, const char **a2, int a3, int a4)
{
const char **v4; // r13
int v5; // r15d
const char **v6; // rbx
const char *v7; // rbp
const char **v8; // r14
int v9; // ebx
const char **v10; // r13
const char *v11; // rbp
long long v12; // rax
long long v13; // r14
int v14; // r15... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x9b8
MOV qword ptr [RSP + 0x30],RSI
MOV dword ptr [RSP + 0x3c],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x9a8],RAX
XOR EAX,EAX
TEST EDX,EDX
JLE 0x0010166f
MOVSXD RDX,EDX
MOV qword ptr [RSP + 0x20],RDI
LEA RAX,[RDI + RDX*0x8]
MOV q... | bool func0(int8 *param_1,int8 *param_2,int param_3,int param_4)
{
char *pcVar1;
int iVar2;
int iVar3;
long lVar4;
long lVar5;
int8 *puVar6;
int8 *puVar7;
int8 *puVar8;
int iVar9;
long in_FS_OFFSET;
bool bVar10;
long local_9e0;
int8 *local_9d8;
int8 *local_9d0;
int8 *local_9c8;
int8 loca... |
5,928 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
if (n % 2 == 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0;
int count = 0;
while (n >= 1) {
count++;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(9) == 5);
assert(func0(5) == 3);
assert(func0(11) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1195 <func0+0x2c>
lea 0xe7f(%rip),%rdi
callq 1060 <puts@plt>
mov $0xffffffff,%eax
jmp 11c0 <func0+0x57>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jnz short loc_1198
lea rax, s; "Invalid Input"
mov rdi, rax; s
call _puts
mov eax, 0FFFFFFFFh
jmp short locret_11C3
loc_1198:
mov [rbp+var_8], 0
mov... | long long func0(int a1)
{
int v2; // [rsp+Ch] [rbp-14h]
int v3; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
v2 = a1;
if ( (a1 & 1) != 0 )
{
v3 = 0;
v4 = 0;
while ( v2 > 0 )
{
++v4;
v3 += v2;
v2 -= 2;
}
return (unsigned int)(v3 / v4);
}
else
{
put... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101198
LEA RAX,[0x102004]
MOV RDI,RAX
CALL 0x00101060
MOV EAX,0xffffffff
JMP 0x001011c3
LAB_00101198:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010... | ulong func0(uint param_1)
{
ulong uVar1;
uint local_1c;
int local_10;
int local_c;
if ((param_1 & 1) == 0) {
puts("Invalid Input");
uVar1 = 0xffffffff;
}
else {
local_10 = 0;
local_c = 0;
for (local_1c = param_1; 0 < (int)local_1c; local_1c = local_1c - 2) {
local_c = local_c... |
5,929 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
if (n % 2 == 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0;
int count = 0;
while (n >= 1) {
count++;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(9) == 5);
assert(func0(5) == 3);
assert(func0(11) == 6);
return 0;
}
| O1 | c | func0:
endbr64
test $0x1,%dil
je 11a7 <func0+0x3e>
mov %edi,%edx
mov $0x0,%ecx
mov $0x0,%eax
test %edi,%edi
jle 11a3 <func0+0x3a>
lea -0x1(%rdi),%ecx
sub $0x2,%edx
mov %ecx,%eax
and $0xfffffffe,%eax
sub %eax,%edx
mov $0x0,%eax
add %edi,%eax
sub $0x2,%edi
cmp %edx,%edi
jne ... | func0:
endbr64
test dil, 1
jz short loc_11A7
mov edx, edi
mov ecx, 0
mov eax, 0
test edi, edi
jle short loc_11A3
lea ecx, [rdi-1]
sub edx, 2
mov eax, ecx
and eax, 0FFFFFFFEh
sub edx, eax
mov eax, 0
loc_1195:
add eax, edi
sub edi, 2
cmp edi, edx
jnz shor... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
unsigned int v3; // ecx
unsigned int v4; // edx
if ( (a1 & 1) != 0 )
{
v1 = 0;
v2 = 0;
if ( a1 > 0 )
{
v3 = a1 - 1;
v4 = a1 - 2 - ((a1 - 1) & 0xFFFFFFFE);
v2 = 0;
do
{
v2 += a1;
a1 -= 2;
... | func0:
ENDBR64
TEST DIL,0x1
JZ 0x001011a7
MOV EDX,EDI
MOV ECX,0x0
MOV EAX,0x0
TEST EDI,EDI
JLE 0x001011a3
LEA ECX,[RDI + -0x1]
SUB EDX,0x2
MOV EAX,ECX
AND EAX,0xfffffffe
SUB EDX,EAX
MOV EAX,0x0
LAB_00101195:
ADD EAX,EDI
SUB EDI,0x2
CMP EDI,EDX
JNZ 0x00101195
SHR ECX,0x1
ADD ECX,0x1
LAB_001011a3:
CDQ
IDIV ECX
RET
LAB_00... | int1 [16] func0(uint param_1)
{
int iVar1;
uint uVar2;
int iVar3;
int8 extraout_RDX;
int1 auVar4 [16];
int1 auVar5 [16];
if ((param_1 & 1) != 0) {
iVar3 = 0;
iVar1 = 0;
if (0 < (int)param_1) {
uVar2 = param_1 - 1;
iVar3 = param_1 - 2;
iVar1 = 0;
do {
iVar1 ... |
5,930 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
if (n % 2 == 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0;
int count = 0;
while (n >= 1) {
count++;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(9) == 5);
assert(func0(5) == 3);
assert(func0(11) == 6);
return 0;
}
| O2 | c | func0:
endbr64
test $0x1,%dil
je 11ac <func0+0x3c>
test %edi,%edi
jle 11c6 <func0+0x56>
lea -0x1(%rdi),%esi
lea -0x2(%rdi),%ecx
mov %esi,%eax
mov %ecx,%edx
and $0xfffffffe,%eax
sub %eax,%edx
xor %eax,%eax
jmp 119b <func0+0x2b>
nopl 0x0(%rax)
sub $0x2,%ecx
add %edi,%eax
mov ... | func0:
endbr64
test dil, 1
jz short loc_11AC
test edi, edi
jle short loc_11C6
lea esi, [rdi-1]
lea edx, [rdi-2]
mov eax, esi
mov ecx, edx
and eax, 0FFFFFFFEh
sub ecx, eax
xor eax, eax
jmp short loc_119B
loc_1198:
sub edx, 2
loc_119B:
add eax, edi
mov edi, edx
c... | long long func0(int a1)
{
unsigned int v1; // esi
int v2; // edx
unsigned int v3; // ecx
int v4; // eax
if ( (a1 & 1) != 0 )
{
if ( a1 <= 0 )
func0_cold();
v1 = a1 - 1;
v2 = a1 - 2;
v3 = a1 - 2 - ((a1 - 1) & 0xFFFFFFFE);
v4 = 0;
while ( 1 )
{
v4 += a1;
a1 = v2... | func0:
ENDBR64
TEST DIL,0x1
JZ 0x001011ac
TEST EDI,EDI
JLE 0x001011c6
LEA ESI,[RDI + -0x1]
LEA EDX,[RDI + -0x2]
MOV EAX,ESI
MOV ECX,EDX
AND EAX,0xfffffffe
SUB ECX,EAX
XOR EAX,EAX
JMP 0x0010119b
LAB_00101198:
SUB EDX,0x2
LAB_0010119b:
ADD EAX,EDI
MOV EDI,EDX
CMP EDX,ECX
JNZ 0x00101198
SHR ESI,0x1
CDQ
ADD ESI,0x1
IDIV ES... | int1 [16] func0(uint param_1)
{
long lVar1;
uint uVar2;
int iVar3;
uint uVar4;
int8 extraout_RDX;
uint uVar5;
int1 auVar6 [16];
int1 auVar7 [16];
if ((param_1 & 1) == 0) {
puts("Invalid Input");
auVar7._8_8_ = extraout_RDX;
auVar7._0_8_ = 0xffffffff;
return auVar7;
}
if (0 < (... |
5,931 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
if (n % 2 == 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0;
int count = 0;
while (n >= 1) {
count++;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(9) == 5);
assert(func0(5) == 3);
assert(func0(11) == 6);
return 0;
}
| O3 | c | func0:
endbr64
test $0x1,%dil
je 121c <func0+0xac>
test %edi,%edi
jle 1236 <func0+0xc6>
lea -0x1(%rdi),%eax
mov %eax,%ecx
shr %ecx
add $0x1,%ecx
cmp $0x23,%eax
jbe 1218 <func0+0xa8>
movd %edi,%xmm4
mov %ecx,%edx
movdqa 0xe89(%rip),%xmm3
xor %eax,%eax
pshufd $0x0,%xmm4,%xmm1
paddd 0... | func0:
endbr64
test dil, 1
jz loc_1264
mov edx, edi
test edi, edi
jle loc_127E
lea eax, [rdi-1]
mov ecx, eax
shr ecx, 1
lea esi, [rcx+1]
cmp eax, 13h
jbe loc_1260
movd xmm4, edi
mov ecx, esi
movdqa xmm3, cs:xmmword_2030
xor eax, eax
pshufd xmm1, xmm4, 0
paddd xm... | long long func0(long long a1, long long a2)
{
int v2; // edx
signed int v3; // esi
__m128i si128; // xmm3
int v5; // eax
__m128i v6; // xmm1
__m128i v7; // xmm0
__m128i v8; // xmm2
__m128i v9; // xmm0
int v10; // eax
int v11; // edx
if ( (a1 & 1) != 0 )
{
v2 = a1;
if ( (int)a1 <= 0 )
... | func0:
ENDBR64
TEST DIL,0x1
JZ 0x00101264
MOV EDX,EDI
TEST EDI,EDI
JLE 0x0010127e
LEA EAX,[RDI + -0x1]
MOV ECX,EAX
SHR ECX,0x1
LEA ESI,[RCX + 0x1]
CMP EAX,0x13
JBE 0x00101260
MOVD XMM4,EDI
MOV ECX,ESI
MOVDQA XMM3,xmmword ptr [0x00102030]
XOR EAX,EAX
PSHUFD XMM1,XMM4,0x0
PADDD XMM1,xmmword ptr [0x00102020]
SHR ECX,0x2
P... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int [16] func0(uint param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
int8 extraout_RDX;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int auVar11 [16];
int auVar12 [16];
if... |
5,932 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n, int k) {
int dp[k+1][n+1];
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = dp[i][j-1];
if (arr[j-1]... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 8, 7, 2};
int arr3[] = {5, 6, 7, 8};
assert(func0(arr1, 4, 10) == 11);
assert(func0(arr2, 4, 50) == 9);
assert(func0(arr3, 4, 15) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %edx,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,-0x78(%rbp)
mov -0x6c(%rbp),%eax... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_50], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov eax, [rbp+var_4C]
lea r8d, [rax+1]
mov eax, [rbp+var_50]... | long long func0(long long a1, int a2, int a3)
{
unsigned long long v3; // rcx
unsigned long long v4; // rax
void *v5; // rsp
int v7; // [rsp+8h] [rbp-50h] BYREF
int v8; // [rsp+Ch] [rbp-4Ch]
long long v9; // [rsp+10h] [rbp-48h]
int i; // [rsp+18h] [rbp-40h]
int j; // [rsp+1Ch] [rbp-3Ch]
int k; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV dword ptr [RBP + -0x50],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV EAX,dword ptr [RBP + -0x4c]
LEA R8D,[RAX + 0x1]
MOV EAX,dword ptr ... | int4 func0(long param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int *piVar4;
long in_FS_OFFSET;
int local_58;
int local_54;
long local_50;
int local_48;
int local_44;
int local_40;
int local_3c;
long local_38;
long local_30;
int *local_28;
long local_20;
lo... |
5,933 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n, int k) {
int dp[k+1][n+1];
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = dp[i][j-1];
if (arr[j-1]... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 8, 7, 2};
int arr3[] = {5, 6, 7, 8};
assert(func0(arr1, 4, 10) == 11);
assert(func0(arr2, 4, 50) == 9);
assert(func0(arr3, 4, 15) == 4);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rdi,%rbx
mov %esi,%r13d
mov %edx,-0x54(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
movslq %eax,%rcx
lea 0x0(,%rcx,4),%rax
mov %rax,-... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov r13d, esi
mov edi, edx
mov [rbp+var_54], edx
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea edx, [rsi+1]
movsxd rdx, edx
lea rax, ds:0[rd... | long long func0(long long a1, unsigned int a2, int a3)
{
int v4; // r13d
long long v6; // rdx
_BYTE *v7; // rdx
signed long long v8; // rax
void *v9; // rsp
_BYTE *v10; // rdx
int v11; // edi
int v12; // ecx
unsigned long long v13; // rsi
_DWORD *v14; // rax
_BYTE *v15; // r14
int v16; // r10d
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R13D,ESI
MOV EDI,EDX
MOV dword ptr [RBP + -0x54],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EDX,[RSI + 0x1]
MOVSXD RDX,EDX
LEA RAX,[RDX*0x4]
MOV qword ptr [RBP + -0x48],RAX
... | int4 func0(long param_1,uint param_2,int param_3)
{
long lVar1;
int4 *puVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
int4 *puVar6;
int1 *puVar7;
int *piVar8;
int iVar9;
ulong uVar10;
int *piVar11;
long in_FS_OFFSET;
int1 auStack_68 [12];
int local_5c;
int local_58;
uint local_54;
ulong ... |
5,934 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n, int k) {
int dp[k+1][n+1];
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = dp[i][j-1];
if (arr[j-1]... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 8, 7, 2};
int arr3[] = {5, 6, 7, 8};
assert(func0(arr1, 4, 10) == 11);
assert(func0(arr2, 4, 50) == 9);
assert(func0(arr3, 4, 15) == 4);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbx
sub $0x28,%rsp
mov %edx,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
cltq
lea 0x0(,%rax,4),%rbx
mov %rbx,-0x48(%rbp)
lea 0x1(%rdx),%... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
mov r13d, esi
push r12
push rbx
mov rbx, rdi
mov edi, edx
sub rsp, 38h
mov [rbp+var_4C], edx
lea edx, [rsi+1]
movsxd rdx, edx
mov rcx, rsp
lea r14, ds:0[rdx*4]
mov rax, fs:28h
mov [rbp+var_38],... | long long func0(long long a1, int a2, int a3)
{
long long v6; // rdx
unsigned long long v7; // r14
long long v8; // rdx
long long *v9; // rcx
__int16 v10; // dx
signed long long v11; // rdx
void *v12; // rsp
_BYTE *v13; // rdi
int v14; // r15d
_BYTE *v15; // r15
int v16; // r10d
long long v17; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV EDI,EDX
SUB RSP,0x38
MOV dword ptr [RBP + -0x4c],EDX
LEA EDX,[RSI + 0x1]
MOVSXD RDX,EDX
MOV RCX,RSP
LEA R14,[RDX*0x4]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
... | int4 func0(long param_1,uint param_2,int param_3)
{
int iVar1;
long lVar2;
int1 *puVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
int1 *puVar7;
int *piVar9;
int iVar10;
int *piVar11;
long in_FS_OFFSET;
bool bVar12;
int1 auStack_68 [8];
size_t local_60;
int local_54;
ulong local_50;
long ... |
5,935 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n, int k) {
int dp[k+1][n+1];
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = dp[i][j-1];
if (arr[j-1]... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 8, 7, 2};
int arr3[] = {5, 6, 7, 8};
assert(func0(arr1, 4, 10) == 11);
assert(func0(arr2, 4, 50) == 9);
assert(func0(arr3, 4, 15) == 4);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbx
sub $0x48,%rsp
mov %edx,-0x50(%rbp)
add $0x1,%edx
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %edx,-0x54(%rbp)
movslq %... | func0:
endbr64
push rbp
mov ecx, edx
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
sub rsp, 38h
mov [rbp+var_44], edx
lea edx, [rsi+1]
mov [rbp+var_48], esi
movsxd rdx, edx
lea r14, ds:0[rdx*4]
mov rax, fs:28h
mov [rbp+var_38], rax
xor ... | long long func0(long long a1, int a2, int a3)
{
long long v5; // rdx
unsigned long long v6; // r14
long long v7; // rdx
long long *v8; // rcx
__int16 v9; // dx
signed long long v10; // rdx
void *v11; // rsp
unsigned long long v12; // r13
char *v13; // rdi
int v14; // r15d
char *v15; // rdi
int ... | func0:
ENDBR64
PUSH RBP
MOV ECX,EDX
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x38
MOV dword ptr [RBP + -0x44],EDX
LEA EDX,[RSI + 0x1]
MOV dword ptr [RBP + -0x48],ESI
MOVSXD RDX,EDX
LEA R14,[RDX*0x4]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RCX ... | int4 func0(long param_1,uint param_2,int param_3)
{
int iVar1;
long lVar2;
void *pvVar3;
ulong uVar4;
ulong uVar5;
int *puVar6;
int *piVar8;
int *puVar9;
int iVar10;
int *piVar11;
long in_FS_OFFSET;
bool bVar12;
int auStack_68 [8];
long local_60;
size_t local_58;
uint local_50;
int lo... |
5,936 | func0 |
#include <assert.h>
| int func0(int num) {
int sum = 0;
int i = 2;
while (i * i <= num) {
while (num % i == 0) {
sum += i;
num /= i;
}
i++;
}
sum += num;
return sum;
}
| int main() {
assert(func0(12) == 7);
assert(func0(105) == 15);
assert(func0(2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 1185 <func0+0x3c>
mov -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 2
jmp short loc_1185
loc_1164:
mov eax, [rbp+var_4]
add [rbp+var_8], eax
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov [rbp+var_14], eax
loc_1174:
mov eax, [rbp+var_14]
cdq
idiv ... | long long func0(int a1)
{
int v3; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v3 = 0;
for ( i = 2; a1 >= i * i; ++i )
{
while ( !(a1 % i) )
{
v3 += i;
a1 /= i;
}
}
return (unsigned int)(a1 + v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101185
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
LAB... | int func0(int param_1)
{
int4 local_1c;
int4 local_10;
int4 local_c;
local_10 = 0;
local_1c = param_1;
for (local_c = 2; local_c * local_c <= local_1c; local_c = local_c + 1) {
for (; local_1c % local_c == 0; local_1c = local_1c / local_c) {
local_10 = local_10 + local_c;
}
}
return lo... |
5,937 | func0 |
#include <assert.h>
| int func0(int num) {
int sum = 0;
int i = 2;
while (i * i <= num) {
while (num % i == 0) {
sum += i;
num /= i;
}
i++;
}
sum += num;
return sum;
}
| int main() {
assert(func0(12) == 7);
assert(func0(105) == 15);
assert(func0(2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x2,%ecx
mov $0x0,%esi
cmp $0x3,%edi
jg 117c <func0+0x33>
lea (%rdi,%rsi,1),%eax
retq
add %ecx,%esi
mov %edi,%eax
cltd
idiv %ecx
mov %eax,%edi
cltd
idiv %ecx
test %edx,%edx
je 1160 <func0+0x17>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg ... | func0:
endbr64
mov ecx, 2
mov esi, 0
cmp edi, 3
jg short loc_117C
loc_115C:
lea eax, [rdi+rsi]
retn
loc_1160:
add esi, ecx
mov eax, edi
cdq
idiv ecx
mov edi, eax
cdq
idiv ecx
test edx, edx
jz short loc_1160
loc_1170:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp ... | long long func0(int a1)
{
int v1; // ecx
int v2; // esi
v1 = 2;
v2 = 0;
if ( a1 > 3 )
{
do
{
for ( ; !(a1 % v1); a1 /= v1 )
v2 += v1;
++v1;
}
while ( v1 * v1 <= a1 );
}
return (unsigned int)(a1 + v2);
} | func0:
ENDBR64
MOV ECX,0x2
MOV ESI,0x0
CMP EDI,0x3
JG 0x0010117c
LAB_0010115c:
LEA EAX,[RDI + RSI*0x1]
RET
LAB_00101160:
ADD ESI,ECX
MOV EAX,EDI
CDQ
IDIV ECX
MOV EDI,EAX
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101160
LAB_00101170:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x0010115c
LAB_0010117c:
MOV EAX,EDI
CDQ
IDI... | int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
iVar2 = 2;
iVar4 = 0;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while (iVar3 == 0) {
iVar4 = iVar4 + iVar2;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
iVar3 = ... |
5,938 | func0 |
#include <assert.h>
| int func0(int num) {
int sum = 0;
int i = 2;
while (i * i <= num) {
while (num % i == 0) {
sum += i;
num /= i;
}
i++;
}
sum += num;
return sum;
}
| int main() {
assert(func0(12) == 7);
assert(func0(105) == 15);
assert(func0(2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x2,%ecx
xor %esi,%esi
cmp $0x3,%edi
jle 1210 <func0+0x40>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1200 <func0+0x30>
nopl 0x0(%rax)
mov %edi,%eax
add %ecx,%esi
cltd
idiv %ecx
cltd
mov %eax,%edi
idiv %ecx
test %edx,%edx
je 11f0 <func0+0x20>
add $0... | func0:
endbr64
mov ecx, 2
xor esi, esi
cmp edi, 3
jle short loc_1230
loc_1200:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1220
nop dword ptr [rax+00000000h]
loc_1210:
mov eax, edi
add esi, ecx
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jz ... | long long func0(int a1)
{
int v1; // ecx
int v2; // esi
int v3; // edx
v1 = 2;
v2 = 0;
if ( a1 <= 3 )
return (unsigned int)a1;
do
{
if ( !(a1 % v1) )
{
do
{
v2 += v1;
v3 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(__SPAIR64__(v3, a... | func0:
ENDBR64
MOV ECX,0x2
XOR ESI,ESI
CMP EDI,0x3
JLE 0x00101230
LAB_00101200:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101220
NOP dword ptr [RAX]
LAB_00101210:
MOV EAX,EDI
ADD ESI,ECX
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JZ 0x00101210
LAB_00101220:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
J... | int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
iVar2 = 2;
iVar4 = 0;
if (param_1 < 4) {
return param_1;
}
do {
iVar3 = param_1 % iVar2;
while (iVar3 == 0) {
iVar4 = iVar4 + iVar2;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
... |
5,939 | func0 |
#include <assert.h>
| int func0(int num) {
int sum = 0;
int i = 2;
while (i * i <= num) {
while (num % i == 0) {
sum += i;
num /= i;
}
i++;
}
sum += num;
return sum;
}
| int main() {
assert(func0(12) == 7);
assert(func0(105) == 15);
assert(func0(2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x2,%ecx
xor %esi,%esi
cmp $0x3,%edi
jle 1200 <func0+0x40>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 11f0 <func0+0x30>
nopl 0x0(%rax)
mov %edi,%eax
add %ecx,%esi
cltd
idiv %ecx
cltd
mov %eax,%edi
idiv %ecx
test %edx,%edx
je 11e0 <func0+0x20>
add $0... | func0:
endbr64
mov ecx, 2
xor esi, esi
cmp edi, 3
jle short loc_1200
loc_11D0:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_11F0
nop dword ptr [rax+00000000h]
loc_11E0:
mov eax, edi
add esi, ecx
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jz ... | long long func0(int a1)
{
int v1; // ecx
int v2; // esi
int v3; // edx
v1 = 2;
v2 = 0;
if ( a1 <= 3 )
return (unsigned int)a1;
do
{
if ( !(a1 % v1) )
{
do
{
v2 += v1;
v3 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(__SPAIR64__(v3, a... | func0:
ENDBR64
MOV ECX,0x2
XOR ESI,ESI
CMP EDI,0x3
JLE 0x00101200
LAB_001011d0:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001011f0
NOP dword ptr [RAX]
LAB_001011e0:
MOV EAX,EDI
ADD ESI,ECX
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JZ 0x001011e0
LAB_001011f0:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
J... | int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
iVar2 = 2;
iVar4 = 0;
if (param_1 < 4) {
return param_1;
}
do {
iVar3 = param_1 % iVar2;
while (iVar3 == 0) {
iVar4 = iVar4 + iVar2;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
... |
5,940 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int key;
int value;
} KeyValue;
void flatten(int *tup_array, int *flat_array, int *index, int size) {
for (int i = 0; i < size; i++) {
int curr = tup_array[i];
if (curr == -1) { // assuming -1 as the ma... | int *func0(int *tup_array, int size, int *result_size) {
int *flat_array = malloc(100 * sizeof(int)); // large enough size
int index = 0;
flatten(tup_array, flat_array, &index, size);
KeyValue *res = malloc(100 * sizeof(KeyValue)); // large enough size
*result_size = 0;
for (in... | int main() {
int test1[] = {5, 6, -1, 5, 6, -2, 7, -1, 8, 9, -2, 9, -2};
int test2[] = {6, 7, -1, 6, 7, -2, 8, -1, 9, 10, -2, 10, -2};
int test3[] = {7, 8, -1, 7, 8, -2, 9, -1, 10, 11, -2, 11, -2};
int result_size = 0;
KeyValue *result1 = (KeyValue *)func0(test1, sizeof(test1) / sizeof(test1[... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov $0x190,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x2c(%rbp)
mov -0x3c(%rbp),%ecx
lea -0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov edi, 190h; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_2C], 0
mov ecx, [rbp+var_3C]
lea ... | _DWORD * func0(long long a1, unsigned int a2, int *a3)
{
int v5; // [rsp+24h] [rbp-2Ch] BYREF
int i; // [rsp+28h] [rbp-28h]
int v7; // [rsp+2Ch] [rbp-24h]
int j; // [rsp+30h] [rbp-20h]
int v9; // [rsp+34h] [rbp-1Ch]
void *ptr; // [rsp+38h] [rbp-18h]
_DWORD *v11; // [rsp+40h] [rbp-10h]
unsigned long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EDI,0x190
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x2c],0x0
MOV ECX,dw... | void * func0(int8 param_1,int4 param_2,int *param_3)
{
long in_FS_OFFSET;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
void *local_20;
void *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = malloc(400);
local_34 = 0;
flatten(param_1,lo... |
5,941 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int key;
int value;
} KeyValue;
void flatten(int *tup_array, int *flat_array, int *index, int size) {
for (int i = 0; i < size; i++) {
int curr = tup_array[i];
if (curr == -1) { // assuming -1 as the ma... | int *func0(int *tup_array, int size, int *result_size) {
int *flat_array = malloc(100 * sizeof(int)); // large enough size
int index = 0;
flatten(tup_array, flat_array, &index, size);
KeyValue *res = malloc(100 * sizeof(KeyValue)); // large enough size
*result_size = 0;
for (in... | int main() {
int test1[] = {5, 6, -1, 5, 6, -2, 7, -1, 8, 9, -2, 9, -2};
int test2[] = {6, 7, -1, 6, 7, -2, 8, -1, 9, 10, -2, 10, -2};
int test3[] = {7, 8, -1, 7, 8, -2, 9, -1, 10, 11, -2, 11, -2};
int result_size = 0;
KeyValue *result1 = (KeyValue *)func0(test1, sizeof(test1) / sizeof(test1[... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %esi,%r13d
mov %rdx,%rbp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov $0x190,%edi
callq 10b0 <malloc@plt>
mov %rax,%r12
movl $0x0,0x4(%rsp)
lea 0x4(%rsp),%rdx
mov %r13d,%ecx
mov ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov r13d, esi
mov rbp, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov edi, 190h
call _malloc
mov r12, rax
mov [rsp+38h+var_34], 0
lea rdx, [rsp+38h+var_34]
mov ecx,... | long long func0(long long a1, unsigned int a2, int *a3)
{
long long v4; // r12
long long v5; // rbx
int *v6; // r8
int *v7; // r9
_DWORD *v8; // rax
int v9; // edx
int v10; // edi
_DWORD *v11; // rax
int v13; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v14; // [rsp+8h] [rbp-30h]
v14 = __readf... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R13D,ESI
MOV RBP,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV EDI,0x190
CALL 0x001010b0
MOV R12,RAX
MOV dword ptr [RSP + 0x4],0x0
LEA RDX,[RSP + 0x4]
MOV ECX,R13D
MOV RSI,RAX
MOV RDI,RBX
CALL 0x001011a9
MOV ... | int * func0(int8 param_1,int4 param_2,uint *param_3)
{
uint uVar1;
int *__ptr;
int *piVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
uint local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)malloc(400);
local_34 = 0;
flatten(param_1,__ptr,&local_34,param_2)... |
5,942 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int key;
int value;
} KeyValue;
void flatten(int *tup_array, int *flat_array, int *index, int size) {
for (int i = 0; i < size; i++) {
int curr = tup_array[i];
if (curr == -1) { // assuming -1 as the ma... | int *func0(int *tup_array, int size, int *result_size) {
int *flat_array = malloc(100 * sizeof(int)); // large enough size
int index = 0;
flatten(tup_array, flat_array, &index, size);
KeyValue *res = malloc(100 * sizeof(KeyValue)); // large enough size
*result_size = 0;
for (in... | int main() {
int test1[] = {5, 6, -1, 5, 6, -2, 7, -1, 8, 9, -2, 9, -2};
int test2[] = {6, 7, -1, 6, 7, -2, 8, -1, 9, 10, -2, 10, -2};
int test3[] = {7, 8, -1, 7, 8, -2, 9, -1, 10, 11, -2, 11, -2};
int result_size = 0;
KeyValue *result1 = (KeyValue *)func0(test1, sizeof(test1) / sizeof(test1[... | O2 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
mov %rdi,%r12
mov $0x190,%edi
push %rbp
push %rbx
mov %rdx,%rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
callq 10b0 <malloc@plt>
mov %r12,%rdi
lea 0x4(%rsp),%rdx
mov %r13d,%ecx
mov %rax,%rsi
mov %r... | func0:
endbr64
push r13
mov r13d, esi
push r12
mov r12, rdi
mov edi, 190h
push rbp
push rbx
mov rbx, rdx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
call _malloc
mov rdi, r12
lea rdx, [rsp+38h+var_34]
mov ecx, r13d
mov rsi, rax
mov ... | _DWORD * func0(long long a1, unsigned int a2, int *a3)
{
int *v4; // rbp
long long v5; // rax
_DWORD *v6; // r12
int *v7; // rdi
int *v8; // r8
int v9; // esi
int v10; // edx
_DWORD *v11; // rax
_DWORD *v12; // rax
int v14; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v15; // [rsp+8h] [rbp-30h]
... | func0:
ENDBR64
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12,RDI
MOV EDI,0x190
PUSH RBP
PUSH RBX
MOV RBX,RDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CALL 0x001010b0
MOV RDI,R12
LEA RDX,[RSP + 0x4]
MOV ECX,R13D
MOV RSI,RAX
MOV RBP,RAX
MOV dword ptr [RSP + 0x4],0x0
CALL 0x00101480
MOV ... | int * func0(int8 param_1,int4 param_2,int *param_3)
{
int *__ptr;
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
int *piVar5;
long in_FS_OFFSET;
uint local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)malloc(400);
local_34 = 0;
flatten(param_1,__ptr,&local_... |
5,943 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int key;
int value;
} KeyValue;
void flatten(int *tup_array, int *flat_array, int *index, int size) {
for (int i = 0; i < size; i++) {
int curr = tup_array[i];
if (curr == -1) { // assuming -1 as the ma... | int *func0(int *tup_array, int size, int *result_size) {
int *flat_array = malloc(100 * sizeof(int)); // large enough size
int index = 0;
flatten(tup_array, flat_array, &index, size);
KeyValue *res = malloc(100 * sizeof(KeyValue)); // large enough size
*result_size = 0;
for (in... | int main() {
int test1[] = {5, 6, -1, 5, 6, -2, 7, -1, 8, 9, -2, 9, -2};
int test2[] = {6, 7, -1, 6, 7, -2, 8, -1, 9, 10, -2, 10, -2};
int test3[] = {7, 8, -1, 7, 8, -2, 9, -1, 10, 11, -2, 11, -2};
int result_size = 0;
KeyValue *result1 = (KeyValue *)func0(test1, sizeof(test1) / sizeof(test1[... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdx,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,0x8(%rsp)
mov $0x190,%edi
mov %esi,(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
callq 10b0 <malloc@plt>
mov (%rsp),%r9d
mov 0x8(%rsp),%r8
movl $0x0,... | func0:
endbr64
push r15
mov r15d, esi
push r14
push r13
mov r13, rdi
mov edi, 190h; size
push r12
push rbp
xor ebp, ebp
push rbx
mov rbx, rdx
mov r14, rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
call _malloc
mov [rsp+0B8h+var_... | _DWORD * func0(long long a1, int a2, int *a3)
{
int v3; // r15d
int v5; // ebp
int *v7; // r14
_DWORD *v8; // rax
_DWORD *v9; // r11
long long v10; // rax
long long v11; // rsi
int v12; // edx
int v13; // ecx
long long v14; // r12
_DWORD *v15; // rax
void *v16; // r11
_DWORD *v17; // rbp
cha... | func0:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
PUSH R13
MOV R13,RDI
MOV EDI,0x190
PUSH R12
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDX
MOV R14,RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
CALL 0x001010b0
MOV dword ptr [RSP + 0x74],0x0
MOV R11,RAX
TEST R15D,R15D
JLE 0x00101b19
LAB... | int * func0(long param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int *__ptr;
long lVar3;
int *piVar4;
int *piVar5;
int iVar6;
int iVar7;
long lVar8;
int iVar9;
ulong uVar10;
ulong uVar11;
int iVar12;
long lVar13;
int *piVar14;
long lVar15;
long lVar16;
int iVar17;
int ... |
5,944 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(int* test_tup, int size, char* K) {
char** res = malloc(2 * size * sizeof(char*));
int j = 0;
for (int i = 0; i < size; i++) {
asprintf(&res[j++], "%d", test_tup[i]);
res[j++] = K;
}
return res;
}
| int main() {
int test_tup1[] = {5, 6, 7, 4, 9};
int test_tup1_size = sizeof(test_tup1) / sizeof(test_tup1[0]);
char** result1 = func0(test_tup1, test_tup1_size, "FDF");
assert(strcmp(result1[0], "5") == 0 && strcmp(result1[1], "FDF") == 0 && strcmp(result1[2], "6") == 0);
int test_tup2[] ... | 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
add %eax,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1100 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 12b0... | 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]
add eax, eax
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp ... | char ** func0(long long a1, int a2, char *a3)
{
int v3; // eax
int v6; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
char **v8; // [rsp+28h] [rbp-8h]
v8 = (char **)malloc(16LL * a2);
v6 = 0;
for ( i = 0; i < a2; ++i )
{
asprintf(&v8[v6], "%d", *(_DWORD *)(4LL * i + a1));
v3 = v6 + 1;
... | 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]
ADD EAX,EAX
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0... | void * func0(long param_1,int param_2,int8 param_3)
{
int iVar1;
void *pvVar2;
int local_18;
int local_14;
pvVar2 = malloc((long)(param_2 * 2) << 3);
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
iVar1 = local_18 + 1;
asprintf((char **)((long)pvVar2 + (long)lo... |
5,945 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(int* test_tup, int size, char* K) {
char** res = malloc(2 * size * sizeof(char*));
int j = 0;
for (int i = 0; i < size; i++) {
asprintf(&res[j++], "%d", test_tup[i]);
res[j++] = K;
}
return res;
}
| int main() {
int test_tup1[] = {5, 6, 7, 4, 9};
int test_tup1_size = sizeof(test_tup1) / sizeof(test_tup1[0]);
char** result1 = func0(test_tup1, test_tup1_size, "FDF");
assert(strcmp(result1[0], "5") == 0 && strcmp(result1[1], "FDF") == 0 && strcmp(result1[2], "6") == 0);
int test_tup2[] ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%r12d
mov %rdx,%r13
lea (%rsi,%rsi,1),%edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r14
test %r12d,%r12d
jle 1259 <func0+0x70>
mov %rax,%rbx
l... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12d, esi
mov r13, rdx
lea edi, [rsi+rsi]
movsxd rdi, edi
shl rdi, 3
call _malloc
mov r14, rax
test r12d, r12d
jle short loc_1273
mov rbx, rax
mov r12d, r12d
... | long long func0(unsigned int *a1, int a2, long long a3)
{
long long v5; // rax
long long v6; // r14
long long v7; // rbx
long long v8; // r12
v5 = malloc(16LL * a2);
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = v5 + 16LL * (unsigned int)a2;
do
{
asprintf(v7, &unk_2004, *a1);
*(_Q... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12D,ESI
MOV R13,RDX
LEA EDI,[RSI + RSI*0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x00101100
MOV R14,RAX
TEST R12D,R12D
JLE 0x00101273
MOV RBX,RAX
MOV R12D,R12D
SHL R12,0x4
ADD R12,RAX
LEA R15,[0x102004]
LAB_0010124f:
MOV EDX,dw... | char ** func0(uint *param_1,uint param_2,char *param_3)
{
char **ppcVar1;
char **__ptr;
ppcVar1 = (char **)malloc((long)(int)(param_2 * 2) << 3);
if (0 < (int)param_2) {
__ptr = ppcVar1;
do {
asprintf(__ptr,"%d",(ulong)*param_1);
__ptr[1] = param_3;
param_1 = param_1 + 1;
__p... |
5,946 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(int* test_tup, int size, char* K) {
char** res = malloc(2 * size * sizeof(char*));
int j = 0;
for (int i = 0; i < size; i++) {
asprintf(&res[j++], "%d", test_tup[i]);
res[j++] = K;
}
return res;
}
| int main() {
int test_tup1[] = {5, 6, 7, 4, 9};
int test_tup1_size = sizeof(test_tup1) / sizeof(test_tup1[0]);
char** result1 = func0(test_tup1, test_tup1_size, "FDF");
assert(strcmp(result1[0], "5") == 0 && strcmp(result1[1], "FDF") == 0 && strcmp(result1[2], "6") == 0);
int test_tup2[] ... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
lea (%rsi,%rsi,1),%edi
push %rbx
movslq %edi,%rdi
shl $0x3,%rdi
sub $0x8,%rsp
callq 10e0 <malloc@plt>
mov %rax,%r14
test %r12d,%r12d
jle 1481 <func0+0x71>
sub $0x1,%r12d
... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdx
push r12
mov r12d, esi
push rbp
mov rbp, rdi
lea edi, [r12+r12]
push rbx
movsxd rdi, edi
shl rdi, 3
sub rsp, 8
call _malloc
mov r14, rax
test r12d, r12d
jle short loc_1499
shl r12, 4
mov rbx, rax
lea ... | long long func0(unsigned int *a1, int a2, long long a3)
{
long long v5; // rax
long long v6; // r14
long long v7; // rbx
long long v8; // r12
long long v9; // rdx
long long v10; // rdi
v5 = malloc(16LL * a2);
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = v5 + 16LL * (unsigned int)a2;
do
{... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDI
LEA EDI,[R12 + R12*0x1]
PUSH RBX
MOVSXD RDI,EDI
SHL RDI,0x3
SUB RSP,0x8
CALL 0x00101100
MOV R14,RAX
TEST R12D,R12D
JLE 0x00101499
SHL R12,0x4
MOV RBX,RAX
LEA R15,[0x102004]
ADD R12,RAX
NOP dword ptr [RAX]
LAB_00101478:
MOV ... | char ** func0(uint *param_1,uint param_2,char *param_3)
{
uint uVar1;
char **ppcVar2;
char **__ptr;
char **ppcVar3;
ppcVar2 = (char **)malloc((long)(int)(param_2 * 2) << 3);
if (0 < (int)param_2) {
__ptr = ppcVar2;
do {
uVar1 = *param_1;
ppcVar3 = __ptr + 2;
param_1 = param_1 +... |
5,947 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(int* test_tup, int size, char* K) {
char** res = malloc(2 * size * sizeof(char*));
int j = 0;
for (int i = 0; i < size; i++) {
asprintf(&res[j++], "%d", test_tup[i]);
res[j++] = K;
}
return res;
}
| int main() {
int test_tup1[] = {5, 6, 7, 4, 9};
int test_tup1_size = sizeof(test_tup1) / sizeof(test_tup1[0]);
char** result1 = func0(test_tup1, test_tup1_size, "FDF");
assert(strcmp(result1[0], "5") == 0 && strcmp(result1[1], "FDF") == 0 && strcmp(result1[2], "6") == 0);
int test_tup2[] ... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
lea (%rsi,%rsi,1),%edi
push %rbx
movslq %edi,%rdi
shl $0x3,%rdi
sub $0x8,%rsp
callq 10e0 <malloc@plt>
mov %rax,%r14
test %r12d,%r12d
jle 1451 <func0+0x71>
sub $0x1,%r12d
... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdx
push r12
lea r12d, [rsi+rsi]
push rbp
movsxd r12, r12d
mov rbp, rdi
push rbx
shl r12, 3
mov ebx, esi
mov rdi, r12; size
sub rsp, 8
call _malloc
mov r14, rax
test ebx, ebx
jle short loc_1459
mov rbx, r... | char ** func0(int *a1, int a2, char *a3)
{
char **v5; // rax
char **v6; // r14
char **v7; // rbx
char **v8; // r12
int v9; // edx
char **v10; // rdi
v5 = (char **)malloc(16LL * a2);
v6 = v5;
if ( a2 > 0 )
{
v7 = v5;
v8 = &v5[2 * a2];
do
{
v9 = *a1;
v10 = v7;
v7 += ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
LEA R12D,[RSI + RSI*0x1]
PUSH RBP
MOVSXD R12,R12D
MOV RBP,RDI
PUSH RBX
SHL R12,0x3
MOV EBX,ESI
MOV RDI,R12
SUB RSP,0x8
CALL 0x00101100
MOV R14,RAX
TEST EBX,EBX
JLE 0x00101459
MOV RBX,RAX
ADD R12,RAX
LEA R15,[0x102004]
NOP dword ptr [RAX]
LAB_00101438:
MOV E... | char ** func0(uint *param_1,int param_2,char *param_3)
{
uint uVar1;
char **ppcVar2;
char **__ptr;
char **ppcVar3;
ppcVar2 = (char **)malloc((long)(param_2 * 2) * 8);
if (0 < param_2) {
__ptr = ppcVar2;
do {
uVar1 = *param_1;
ppcVar3 = __ptr + 2;
param_1 = param_1 + 1;
as... |
5,948 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *arr, int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {7, 8, 9, 1, 10, 7};
int arr2[] = {1, 2, 3, 4, 5, 6};
int arr3[] = {11, 12, 13, 45, 14};
assert(func0(arr1, 6) == 42);
assert(func0(arr2, 6) == 21);
assert(func0(arr3, 5) == 95);
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 11a5 <func0+0x3c>
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... | 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_11A5
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]
add [rbp+var_8], eax
add... | 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 )
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 0x001011a5
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]
ADD dwo... | 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) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
5,949 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *arr, int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {7, 8, 9, 1, 10, 7};
int arr2[] = {1, 2, 3, 4, 5, 6};
int arr3[] = {11, 12, 13, 45, 14};
assert(func0(arr1, 6) == 42);
assert(func0(arr2, 6) == 21);
assert(func0(arr3, 5) == 95);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118C:
mov eax, edx
retn
loc_118F:
mov edx, 0
jmp short loc_118C | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 += *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118c:
MOV EAX,EDX
RET
LAB_0010118f:
MOV EDX,0x0
JMP 0x0010118c | 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 {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
5,950 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *arr, int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {7, 8, 9, 1, 10, 7};
int arr2[] = {1, 2, 3, 4, 5, 6};
int arr3[] = {11, 12, 13, 45, 14};
assert(func0(arr1, 6) == 42);
assert(func0(arr2, 6) == 21);
assert(func0(arr3, 5) == 95);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1168 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12B8
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_12A8:
add eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_12A8
retn
loc_12B8:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
result = (unsigned int)(*a1++ + result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012b8
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001012a8:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x001012a8
RET
LAB_001012b8:
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 {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
} |
5,951 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *arr, int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {7, 8, 9, 1, 10, 7};
int arr2[] = {1, 2, 3, 4, 5, 6};
int arr3[] = {11, 12, 13, 45, 14};
assert(func0(arr1, 6) == 42);
assert(func0(arr2, 6) == 21);
assert(func0(arr3, 5) == 95);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11e0 <func0+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 11e9 <func0+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%... | func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11D8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11E1
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp ... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
... | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011d8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011e1
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XM... | int func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
iVar7 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
... |
5,952 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr[], int n, int m) {
if (n > m) {
return true;
}
bool DP[m];
for (int i = 0; i < m; i++) {
DP[i] = false;
}
for (int i = 0; i < n; i++) {
if (DP[0]) {
return true;
}
bool temp[m];
for (int k = 0; k < ... | int main() {
int arr1[] = {3, 1, 7, 5};
int arr2[] = {1, 7};
int arr3[] = {1, 6};
assert(func0(arr1, 4, 6) == true);
assert(func0(arr2, 2, 5) == false);
assert(func0(arr3, 2, 5) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %edx,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x6c(%rbp),%eax
cmp -0x70(%rbp),%eax
jle ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_50], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rdi, rax
mov eax, [rbp+var_4C]
cmp eax, [rbp+var_50]
jle short loc_11A6
mov ea... | long long func0(long long a1, int a2, int a3)
{
unsigned long long v4; // rax
void *v5; // rsp
unsigned long long v6; // rax
void *v7; // rsp
int v8; // [rsp+8h] [rbp-50h] BYREF
int v9; // [rsp+Ch] [rbp-4Ch]
long long v10; // [rsp+10h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-3Ch]
int j; // [rsp+20h] [rbp-... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV dword ptr [RBP + -0x50],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RDI,RAX
MOV EAX,dword ptr [RBP + -0x4c]
CMP EAX,dword ptr [RBP + -0x50]
JLE 0x001011a6
M... | char func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
char cVar3;
ulong uVar4;
int *piVar5;
int *puVar6;
long in_FS_OFFSET;
int local_58;
int local_54;
long local_50;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
char *local_... |
5,953 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr[], int n, int m) {
if (n > m) {
return true;
}
bool DP[m];
for (int i = 0; i < m; i++) {
DP[i] = false;
}
for (int i = 0; i < n; i++) {
if (DP[0]) {
return true;
}
bool temp[m];
for (int k = 0; k < ... | int main() {
int arr1[] = {3, 1, 7, 5};
int arr2[] = {1, 7};
int arr3[] = {1, 6};
assert(func0(arr1, 4, 6) == true);
assert(func0(arr2, 2, 5) == false);
assert(func0(arr3, 2, 5) == false);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov $0x1,%eax
cmp %edx,%esi
jg 1326 <func0+0x1bd>
mov %edx,%r8d
movslq %edx,%r10
lea 0xf(%r10),%rax
mov %rax,%rdx
and... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov eax, 1
cmp esi, edx
jg loc_1320
mov r8d, edx
movsxd r10, edx
lea rax, [r10+0Fh]
mov rcx, rax
and rcx, ... | long long func0(_DWORD *a1, int a2, int a3)
{
long long result; // rax
long long v5; // r10
__int16 v6; // cx
_BYTE *v7; // rdx
signed long long v8; // rax
void *v9; // rsp
_BYTE *v10; // rax
_DWORD *v11; // r9
long long v12; // r13
unsigned long long v13; // r10
long long v14; // rsi
signed lo... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV EAX,0x1
CMP ESI,EDX
JG 0x00101320
MOV R8D,EDX
MOVSXD R10,EDX
LEA RAX,[R10 + 0xf]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB... | char func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
long lVar2;
long lVar3;
char cVar4;
ulong uVar5;
int1 *puVar6;
int1 *puVar7;
long lVar8;
ulong uVar9;
int1 *puVar10;
int1 *puVar11;
long in_FS_OFFSET;
bool bVar12;
int1 auStack_48 [8];
long local_40;
puVar10 = auStack_48... |
5,954 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr[], int n, int m) {
if (n > m) {
return true;
}
bool DP[m];
for (int i = 0; i < m; i++) {
DP[i] = false;
}
for (int i = 0; i < n; i++) {
if (DP[0]) {
return true;
}
bool temp[m];
for (int k = 0; k < ... | int main() {
int arr1[] = {3, 1, 7, 5};
int arr2[] = {1, 7};
int arr3[] = {1, 6};
assert(func0(arr1, 4, 6) == true);
assert(func0(arr2, 2, 5) == false);
assert(func0(arr3, 2, 5) == false);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov $0x1,%eax
cmp %edx,%esi
jg 1469 <func0+0x1d9>
movslq %edx,%rcx
mov %edx,%r9d
mov %rsp,%rbx
add $0xf,%rcx
mov %... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov eax, 1
cmp esi, edx
jg loc_1469
mov ebx, edx
movsxd rdx, edx
mov r13d, esi
mov rcx, rsp
lea r15, [rdx+... | long long func0(int *a1, int a2, int a3)
{
long long result; // rax
long long v5; // r15
long long *v6; // rcx
signed long long v7; // rax
void *v8; // rsp
int *v9; // r13
_QWORD *v10; // rax
void *v11; // rsp
int v12; // r11d
long long v13; // r8
_BYTE *v14; // rsi
_BYTE *v15; // rcx
unsigne... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV EAX,0x1
CMP ESI,EDX
JG 0x00101469
MOV EBX,EDX
MOVSXD RDX,EDX
MOV R13D,ESI
MOV RCX,RSP
LEA R15,[RDX + 0xf]
MOV R14,RDI
MOV RSI,R15
MOV RAX,R15
AND RSI,... | char func0(int *param_1,int param_2,uint param_3)
{
char *pcVar1;
long lVar2;
long lVar3;
char cVar4;
ulong uVar5;
ulong uVar6;
int1 *puVar7;
long lVar8;
int1 *puVar9;
int1 *puVar11;
int iVar13;
long in_FS_OFFSET;
int1 auStack_78 [8];
long local_70;
ulong local_68;
ulong local_60;
int... |
5,955 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr[], int n, int m) {
if (n > m) {
return true;
}
bool DP[m];
for (int i = 0; i < m; i++) {
DP[i] = false;
}
for (int i = 0; i < n; i++) {
if (DP[0]) {
return true;
}
bool temp[m];
for (int k = 0; k < ... | int main() {
int arr1[] = {3, 1, 7, 5};
int arr2[] = {1, 7};
int arr3[] = {1, 6};
assert(func0(arr1, 4, 6) == true);
assert(func0(arr2, 2, 5) == false);
assert(func0(arr3, 2, 5) == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov $0x1,%eax
cmp %edx,%esi
jg 1479 <func0+0x1d9>
movslq %edx,%rcx
mov %edx,%r15d
mov %esi,%r12d
mov %rsp,%rsi
add ... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
movsxd rbx, esi
sub rsp, 48h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
cmp ebx, edx
jg loc_1450
movsxd r12, edx
mov r15d, edx
mov rdx, rsp
mov r13, rdi
lea rcx, [r1... | long long func0(int *a1, int a2, int a3)
{
long long v3; // r12
long long v5; // rcx
__int16 v6; // ax
long long *v7; // rdx
signed long long v8; // rax
void *v9; // rsp
long long v10; // r13
int *v11; // r12
_QWORD *v12; // rax
void *v13; // rsp
int v14; // r11d
_BYTE *v15; // rcx
unsigned i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOVSXD RBX,ESI
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CMP EBX,EDX
JG 0x00101450
MOVSXD R12,EDX
MOV R15D,EDX
MOV RDX,RSP
MOV R13,RDI
LEA RCX,[R12 + 0xf]
MOV RSI,RCX
MOV RAX,RCX
AND RSI,-0x1000
A... | int func0(int *param_1,int param_2,uint param_3)
{
long lVar1;
long lVar2;
int uVar3;
ulong uVar4;
int *puVar5;
char *pcVar6;
long lVar7;
int *puVar8;
int *puVar10;
int iVar11;
long lVar12;
long in_FS_OFFSET;
int auStack_78 [8];
long local_70;
ulong local_68;
ulong local_60;
int *loca... |
5,956 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#define RADIX 10
| void func0(int *nums, int size) {
int placement = 1;
int max_digit = nums[0];
for (int i = 1; i < size; i++) {
if (nums[i] > max_digit) {
max_digit = nums[i];
}
}
int *output = (int *)malloc(size * sizeof(int));
int *count = (int *)malloc(RADIX * sizeof(int... | int main() {
int nums1[] = {15, 79, 25, 68, 37};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
func0(nums1, size1);
int sorted1[] = {15, 25, 37, 68, 79};
for (int i = 0; i < size1; i++) {
assert(nums1[i] == sorted1[i]);
}
int nums2[] = {9, 11, 8, 7, 3, 2};
int size2 = ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
movl $0x1,-0x38(%rbp)
mov -0x48(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x34(%rbp)
movl $0x1,-0x30(%rbp)
jmp 120d <func0+0x64>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_38], 1
mov rax, [rbp+var_48]
mov eax, [rax]
mov [rbp+var_34], eax
mov [rbp+var_30], 1
jmp short loc_120D
loc_11D5:
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*4]... | void func0(int *a1, int a2)
{
int v2; // [rsp+18h] [rbp-38h]
int v3; // [rsp+1Ch] [rbp-34h]
int i; // [rsp+20h] [rbp-30h]
int j; // [rsp+24h] [rbp-2Ch]
int k; // [rsp+28h] [rbp-28h]
int m; // [rsp+2Ch] [rbp-24h]
int n; // [rsp+30h] [rbp-20h]
int ii; // [rsp+34h] [rbp-1Ch]
int v10; // [rsp+38h] [rbp-1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV dword ptr [RBP + -0x38],0x1
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV dword ptr [RBP + -0x30],0x1
JMP 0x0010120d
LAB_001011d5:
MOV EAX,dword ptr [RBP + -... | void func0(int *param_1,int param_2)
{
void *__ptr;
void *__ptr_00;
int *piVar1;
int iVar2;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
local_40 = 1;
local_3c = *param_1;
for (local_38 = 1; local_38 < param_2; local_38... |
5,957 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#define RADIX 10
| void func0(int *nums, int size) {
int placement = 1;
int max_digit = nums[0];
for (int i = 1; i < size; i++) {
if (nums[i] > max_digit) {
max_digit = nums[i];
}
}
int *output = (int *)malloc(size * sizeof(int));
int *count = (int *)malloc(RADIX * sizeof(int... | int main() {
int nums1[] = {15, 79, 25, 68, 37};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
func0(nums1, size1);
int sorted1[] = {15, 25, 37, 68, 79};
for (int i = 0; i < size1; i++) {
assert(nums1[i] == sorted1[i]);
}
int nums2[] = {9, 11, 8, 7, 3, 2};
int size2 = ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %esi,%r14d
mov (%rdi),%r13d
cmp $0x1,%esi
jle 11e7 <func0+0x3e>
lea 0x4(%rdi),%rax
lea -0x2(%rsi),%edx
lea 0x8(%rdi,%rdx,4),%rcx
mov (%rax),%edx
cmp %edx,%r13d
cmovl ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r14d, esi
mov r13d, [rdi]
cmp esi, 1
jle short loc_11E7
lea rax, [rdi+4]
lea edx, [rsi-2]
lea rcx, [rdi+rdx*4+8]
loc_11D5:
mov edx, [rax]
cmp r13d, edx
cmovl r... | long long func0(int *a1, int *a2)
{
int v3; // r14d
int v4; // r13d
int *v5; // rax
long long v6; // r12
long long v7; // rax
unsigned long long v8; // rdx
long long v9; // rcx
_DWORD *v10; // rbx
unsigned long long v11; // r8
_DWORD *v12; // rdi
int v13; // r10d
_DWORD *v14; // rax
_DWORD *v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R14D,ESI
MOV R13D,dword ptr [RDI]
CMP ESI,0x1
JLE 0x001011e7
LEA RAX,[RDI + 0x4]
LEA EDX,[RSI + -0x2]
LEA RCX,[RDI + RDX*0x4 + 0x8]
LAB_001011d5:
MOV EDX,dword ptr [RAX]
CMP R13D,EDX
CMOVL R13D,EDX
ADD RAX,0x4
CMP RAX,RCX
J... | void func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
void *__ptr;
int *piVar3;
int *piVar4;
ulong uVar5;
int iVar6;
long lVar7;
int iVar8;
bool bVar9;
iVar8 = *param_1;
if (1 < param_2) {
piVar3 = param_1 + 1;
do {
if (iVar8 < *piVar3) {
iVar8 = *piVar3;
}... |
5,958 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#define RADIX 10
| void func0(int *nums, int size) {
int placement = 1;
int max_digit = nums[0];
for (int i = 1; i < size; i++) {
if (nums[i] > max_digit) {
max_digit = nums[i];
}
}
int *output = (int *)malloc(size * sizeof(int));
int *count = (int *)malloc(RADIX * sizeof(int... | int main() {
int nums1[] = {15, 79, 25, 68, 37};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
func0(nums1, size1);
int sorted1[] = {15, 25, 37, 68, 79};
for (int i = 0; i < size1; i++) {
assert(nums1[i] == sorted1[i]);
}
int nums2[] = {9, 11, 8, 7, 3, 2};
int size2 = ... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %esi,%r14d
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x18,%rsp
mov (%rdi),%r13d
cmp $0x1,%esi
jle 1422 <func0+0x42>
lea -0x2(%rsi),%edx
lea 0x4(%rdi),%rax
lea 0x8(%rdi,%rdx,4),%rcx
nopl 0x0(%rax)
mov (%rax),%edx
cmp %... | func0:
endbr64
push r15
mov r9d, esi
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov r8d, [rdi]
cmp esi, 1
jle short loc_1432
lea edx, [rsi-2]
lea rax, [rdi+4]
lea rcx, [rdi+rdx*4+8]
nop dword ptr [rax+00h]
loc_1420:
mov edx, [rax]... | long long func0(int *a1, long long a2)
{
int v2; // r8d
int *v3; // rax
long long v4; // r13
long long v5; // rax
unsigned long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
long long v10; // rbp
long long v11; // rax
long long v12; // r15
int v13; // ebx
int v1... | func0:
ENDBR64
PUSH R15
MOV R9D,ESI
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R8D,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101432
LEA EDX,[RSI + -0x2]
LEA RAX,[RDI + 0x4]
LEA RCX,[RDI + RDX*0x4 + 0x8]
NOP dword ptr [RAX]
LAB_00101420:
MOV EDX,dword ptr [RAX]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,... | void func0(int *param_1,int param_2)
{
uint uVar1;
int iVar2;
int iVar3;
int *piVar4;
void *__src;
int1 (*__ptr) [16];
int *piVar5;
uint uVar6;
int *piVar7;
long lVar8;
int iVar9;
int iVar10;
iVar10 = *param_1;
if (1 < param_2) {
piVar4 = param_1 + 1;
do {
if (iVar10 < *piV... |
5,959 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#define RADIX 10
| void func0(int *nums, int size) {
int placement = 1;
int max_digit = nums[0];
for (int i = 1; i < size; i++) {
if (nums[i] > max_digit) {
max_digit = nums[i];
}
}
int *output = (int *)malloc(size * sizeof(int));
int *count = (int *)malloc(RADIX * sizeof(int... | int main() {
int nums1[] = {15, 79, 25, 68, 37};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
func0(nums1, size1);
int sorted1[] = {15, 25, 37, 68, 79};
for (int i = 0; i < size1; i++) {
assert(nums1[i] == sorted1[i]);
}
int nums2[] = {9, 11, 8, 7, 3, 2};
int size2 = ... | O3 | c | func0:
endbr64
push %r15
mov %esi,%r15d
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov (%rdi),%ebx
mov %ebx,(%rsp)
cmp $0x1,%esi
jle 14f6 <func0+0x106>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%ecx
cmp $0x2,%eax
jbe 16c4 <func0+0x2d4>
mov %ec... | func0:
endbr64
push r15
mov r9d, esi
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov r15d, [rdi]
cmp esi, 1
jle loc_1470
lea eax, [rsi-2]
lea ecx, [rsi-1]
cmp eax, 2
jbe loc_161D
mov edx, ecx
movd xmm3, r15d
mov rax, rdi
shr... | void func0(signed int *dest, int a2)
{
signed int v3; // r15d
unsigned int v4; // ecx
signed int *v5; // rax
__m128i v6; // xmm2
__m128i v7; // xmm0
__m128i v8; // xmm1
__m128i v9; // xmm1
signed int v10; // eax
__m128i v11; // xmm0
__m128i v12; // xmm0
__m128i v13; // xmm2
__m128i v14; // xmm1... | func0:
ENDBR64
PUSH R15
MOV R9D,ESI
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R15D,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101470
LEA EAX,[RSI + -0x2]
LEA ECX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x0010161d
MOV EDX,ECX
MOVD XMM3,R15D
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,R... | void func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
int iVar6;
int iVar7;
uint *puVar8;
void *__src;
int (*__ptr) [16];
int iVar9;
long lVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
uint uVar15;
uint uVar16;
uint uV... |
5,960 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list1[], int size) {
int max = list1[0];
for (int i = 0; i < size; i++) {
if (list1[i] > max) {
max = list1[i];
}
}
return max;
}
| int main() {
int array1[] = {1,2,3,4,-1};
int array2[] = {0,1,2,-5,-1,6};
int array3[] = {0,0,1,0};
assert(func0(array1, 5) == 4);
assert(func0(array2, 6) == 6);
assert(func0(array3, 4) == 1);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11e2 <func0+0x59>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
c... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_8], eax
mov [rbp+var_4], 0
jmp short loc_11E2
loc_11AA:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
... | long long func0(unsigned int *a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = *a1;
for ( i = 0; i < a2; ++i )
{
if ( (int)v3 < (int)a1[i] )
v3 = a1[i];
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011e2
LAB_001011aa:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [... | int func0(int *param_1,int param_2)
{
int local_10;
int local_c;
local_10 = *param_1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_10 < param_1[local_c]) {
local_10 = param_1[local_c];
}
}
return local_10;
} |
5,961 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list1[], int size) {
int max = list1[0];
for (int i = 0; i < size; i++) {
if (list1[i] > max) {
max = list1[i];
}
}
return max;
}
| int main() {
int array1[] = {1,2,3,4,-1};
int array2[] = {0,1,2,-5,-1,6};
int array3[] = {0,0,1,0};
assert(func0(array1, 5) == 4);
assert(func0(array2, 6) == 6);
assert(func0(array3, 4) == 1);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%edx
test %esi,%esi
jle 11ae <func0+0x25>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rsi
mov (%rax),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x4,%rax
cmp %rsi,%rax
jne 119e <func0+0x15>
mov %edx,%eax
retq
| func0:
endbr64
mov edx, [rdi]
test esi, esi
jle short loc_11AE
mov rax, rdi
lea ecx, [rsi-1]
lea rsi, [rdi+rcx*4+4]
loc_119E:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_119E
loc_11AE:
mov eax, edx
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // edx
unsigned int *v3; // rax
long long v4; // rsi
v2 = *a1;
if ( a2 > 0 )
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
do
{
if ( (int)v2 < (int)*v3 )
v2 = *v3;
++v3;
}
while ( v3 != (unsigned int *)v... | func0:
ENDBR64
MOV EDX,dword ptr [RDI]
TEST ESI,ESI
JLE 0x001011ae
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RSI,[RDI + RCX*0x4 + 0x4]
LAB_0010119e:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010119e
LAB_001011ae:
MOV EAX,EDX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
iVar2 = *param_1;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (iVar2 < *param_1) {
iVar2 = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
5,962 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list1[], int size) {
int max = list1[0];
for (int i = 0; i < size; i++) {
if (list1[i] > max) {
max = list1[i];
}
}
return max;
}
| int main() {
int array1[] = {1,2,3,4,-1};
int array2[] = {0,1,2,-5,-1,6};
int array3[] = {0,0,1,0};
assert(func0(array1, 5) == 4);
assert(func0(array2, 6) == 6);
assert(func0(array3, 4) == 1);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%eax
test %esi,%esi
jle 11a0 <func0+0x30>
lea -0x1(%rsi),%edx
add $0x4,%rdi
lea (%rdi,%rdx,4),%rcx
mov %eax,%edx
jmp 1196 <func0+0x26>
nopl 0x0(%rax)
mov (%rdi),%edx
add $0x4,%rdi
cmp %edx,%eax
cmovl %edx,%eax
cmp %rcx,%rdi
jne 1190 <func0+0x20>
retq
no... | func0:
endbr64
mov eax, [rdi]
test esi, esi
jle short locret_1270
lea edx, [rsi-1]
add rdi, 4
lea rcx, [rdi+rdx*4]
mov edx, eax
jmp short loc_1266
loc_1260:
mov edx, [rdi]
add rdi, 4
loc_1266:
cmp eax, edx
cmovl eax, edx
cmp rdi, rcx
jnz short loc_1260
locret_1270:
r... | long long func0(unsigned int *a1, int a2)
{
long long result; // rax
int *v3; // rdi
int *v4; // rcx
int i; // edx
result = *a1;
if ( a2 > 0 )
{
v3 = (int *)(a1 + 1);
v4 = &v3[a2 - 1];
for ( i = result; ; i = *v3++ )
{
if ( (int)result < i )
result = (unsigned int)i;
... | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
TEST ESI,ESI
JLE 0x00101270
LEA EDX,[RSI + -0x1]
ADD RDI,0x4
LEA RCX,[RDI + RDX*0x4]
MOV EDX,EAX
JMP 0x00101266
LAB_00101260:
MOV EDX,dword ptr [RDI]
ADD RDI,0x4
LAB_00101266:
CMP EAX,EDX
CMOVL EAX,EDX
CMP RDI,RCX
JNZ 0x00101260
LAB_00101270:
RET | void func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
iVar2 = *param_1;
if (0 < param_2) {
param_1 = param_1 + 1;
piVar1 = param_1 + (param_2 - 1);
iVar3 = iVar2;
while( true ) {
if (iVar2 < iVar3) {
iVar2 = iVar3;
}
if (param_1 == piVar1) brea... |
5,963 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list1[], int size) {
int max = list1[0];
for (int i = 0; i < size; i++) {
if (list1[i] > max) {
max = list1[i];
}
}
return max;
}
| int main() {
int array1[] = {1,2,3,4,-1};
int array2[] = {0,1,2,-5,-1,6};
int array3[] = {0,0,1,0};
assert(func0(array1, 5) == 4);
assert(func0(array2, 6) == 6);
assert(func0(array3, 4) == 1);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%eax
test %esi,%esi
jle 1245 <func0+0xd5>
lea -0x1(%rsi),%edx
cmp $0x2,%edx
jbe 1251 <func0+0xe1>
mov %esi,%edx
movd %eax,%xmm3
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm3,%xmm0
shl $0x4,%rdx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
add $... | func0:
endbr64
mov eax, [rdi]
mov ecx, esi
test esi, esi
jle locret_124A
lea edx, [rsi-1]
cmp edx, 2
jbe loc_1251
mov edx, esi
movd xmm3, eax
mov rax, rdi
shr edx, 2
pshufd xmm0, xmm3, 0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00h]
loc_11A8:
movdqu xmm1, xmmwor... | long long func0(const __m128i *a1, int a2)
{
long long result; // rax
__m128i v4; // xmm3
const __m128i *v5; // rax
__m128i v6; // xmm0
__m128i v7; // xmm1
__m128i v8; // xmm2
__m128i v9; // xmm2
signed int v10; // edx
__m128i v11; // xmm1
__m128i v12; // xmm1
__m128i v13; // xmm2
__m128i v14; ... | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
MOV ECX,ESI
TEST ESI,ESI
JLE 0x0010124a
LEA EDX,[RSI + -0x1]
CMP EDX,0x2
JBE 0x00101251
MOV EDX,ESI
MOVD XMM3,EAX
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM0,XMM3,0x0
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_001011a8:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM2,XMM1
PCMP... | uint func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uVar6 = *param_1;
if (0 < (int)param_2) {
if (param_2 - 1 < 3) {
uV... |
5,964 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double num) {
double sqrt_root = pow(num, 0.5);
return sqrt_root;
}
| int main() {
assert(func0(4) == 2);
assert(func0(16) == 4);
assert(func0(400) == 20);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movsd %xmm0,-0x18(%rbp)
movsd 0xef6(%rip),%xmm0
mov -0x18(%rbp),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movsd [rbp+x], xmm0
movsd xmm0, cs:y
mov rax, [rbp+x]
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq rax, xmm0
mov [rbp+var_8], rax
movsd xmm0, [rbp+var_8]
leave
retn | long long func0(double a1)
{
return pow(a1, 0.5);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM0,qword ptr [0x00102060]
MOV RAX,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x8],RAX
MOVSD XMM0,qword ptr [RBP + -0x8]
LEAVE
RET | double func0(double param_1)
{
double dVar1;
dVar1 = pow(param_1,DAT_00102060);
return dVar1;
} |
5,965 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double num) {
double sqrt_root = pow(num, 0.5);
return sqrt_root;
}
| int main() {
assert(func0(4) == 2);
assert(func0(16) == 4);
assert(func0(400) == 20);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
movsd 0xeff(%rip),%xmm1
callq 1060 <pow@plt>
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
movsd xmm1, cs:qword_2058
call _pow
add rsp, 8
retn | double func0(double a1)
{
return pow(a1, 0.5);
} | func0:
ENDBR64
SUB RSP,0x8
MOVSD XMM1,qword ptr [0x00102058]
CALL 0x00101060
ADD RSP,0x8
RET | void func0(double param_1)
{
pow(param_1,DAT_00102058);
return;
} |
5,966 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double num) {
double sqrt_root = pow(num, 0.5);
return sqrt_root;
}
| int main() {
assert(func0(4) == 2);
assert(func0(16) == 4);
assert(func0(400) == 20);
return 0;
}
| O2 | c | func0:
endbr64
movsd 0xe9c(%rip),%xmm1
jmpq 1050 <pow@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsd xmm1, cs:qword_2008
jmp _pow | double func0(double a1)
{
return pow(a1, 0.5);
} | func0:
ENDBR64
MOVSD XMM1,qword ptr [0x00102008]
JMP 0x00101050 | void func0(double param_1)
{
pow(param_1,DAT_00102008);
return;
} |
5,967 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double num) {
double sqrt_root = pow(num, 0.5);
return sqrt_root;
}
| int main() {
assert(func0(4) == 2);
assert(func0(16) == 4);
assert(func0(400) == 20);
return 0;
}
| O3 | c | func0:
endbr64
movsd 0xe9c(%rip),%xmm1
jmpq 1050 <pow@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsd xmm1, cs:y; y
jmp _pow | double func0(double a1)
{
return pow(a1, 0.5);
} | func0:
ENDBR64
MOVSD XMM1,qword ptr [0x00102008]
JMP 0x00101050 | void func0(double param_1)
{
pow(param_1,DAT_00102008);
return;
} |
5,968 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int num) {
double volume = (pow(num, 3) / (6 * sqrt(2)));
return round(volume * 100) / 100; // rounding to 2 decimal places
}
| int main() {
assert(func0(10) == 117.85);
assert(func0(15) == 397.75);
assert(func0(20) == 942.81);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd 0xee3(%rip),%xmm1
callq 1080 <pow@plt>
movsd 0xede(%rip),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm1
movsd 0xed0(%rip),%xmm0
mulsd %xmm1,%xmm0
callq 1070 <round@plt>... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movq rax, xmm2
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq rax, xmm0
movsd xmm1, cs:qword_2070
movq xmm0, rax
divsd xmm0, xmm1
movsd [r... | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
double v1; // rax
__int128 v2; // xmm1
double v4; // [rsp+18h] [rbp-8h]
v4 = pow((double)a1, 3.0) / 8.485281374238571;
v1 = round(v4 * 100.0);
v2 = *(unsigned long long *)&v1;
*(double *)&v2 = v1 / 100.0;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVQ RAX,XMM2
MOVSD XMM0,qword ptr [0x00102068]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101080
MOVQ RAX,XMM0
MOVSD XMM1,qword ptr [0x00102070]
MOVQ XMM0,RAX
DIVSD XMM0,XMM1
MOVSD qword p... | double func0(int param_1)
{
double dVar1;
dVar1 = pow((double)param_1,DAT_00102068);
dVar1 = round((dVar1 / DAT_00102070) * DAT_00102078);
return dVar1 / DAT_00102078;
} |
5,969 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int num) {
double volume = (pow(num, 3) / (6 * sqrt(2)));
return round(volume * 100) / 100; // rounding to 2 decimal places
}
| int main() {
assert(func0(10) == 117.85);
assert(func0(15) == 397.75);
assert(func0(20) == 942.81);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd 0xee7(%rip),%xmm1
callq 1080 <pow@plt>
divsd 0xee2(%rip),%xmm0
mulsd 0xee2(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xed5(%rip),%xmm0
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
movsd xmm1, cs:qword_2068
call _pow
divsd xmm0, cs:qword_2070
mulsd xmm0, cs:qword_2078
call _round
divsd xmm0, cs:qword_2078
add rsp, 8
retn | double func0(int a1)
{
double v1; // xmm0_8
v1 = pow((double)a1, 3.0);
return round(v1 / 8.485281374238571 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MOVSD XMM1,qword ptr [0x00102068]
CALL 0x00101080
DIVSD XMM0,qword ptr [0x00102070]
MULSD XMM0,qword ptr [0x00102078]
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102078]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = pow((double)param_1,DAT_00102068);
dVar1 = round((dVar1 / _DAT_00102070) * _DAT_00102078);
return dVar1 / _DAT_00102078;
} |
5,970 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int num) {
double volume = (pow(num, 3) / (6 * sqrt(2)));
return round(volume * 100) / 100; // rounding to 2 decimal places
}
| int main() {
assert(func0(10) == 117.85);
assert(func0(15) == 397.75);
assert(func0(20) == 942.81);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm0,%xmm0
sub $0x8,%rsp
movsd 0xe34(%rip),%xmm1
cvtsi2sd %edi,%xmm0
callq 1080 <pow@plt>
divsd 0xe2b(%rip),%xmm0
mulsd 0xe2b(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xe1e(%rip),%xmm0
add $0x8,%rsp
retq
| func0:
endbr64
pxor xmm0, xmm0
sub rsp, 8
movsd xmm1, cs:qword_2068
cvtsi2sd xmm0, edi
call _pow
divsd xmm0, cs:qword_2070
mulsd xmm0, cs:qword_2078
call _round
divsd xmm0, cs:qword_2078
add rsp, 8
retn | double func0(int a1)
{
double v1; // xmm0_8
v1 = pow((double)a1, 3.0);
return round(v1 / 8.485281374238571 * 100.0) / 100.0;
} | func0:
ENDBR64
PXOR XMM0,XMM0
SUB RSP,0x8
MOVSD XMM1,qword ptr [0x00102068]
CVTSI2SD XMM0,EDI
CALL 0x00101080
DIVSD XMM0,qword ptr [0x00102070]
MULSD XMM0,qword ptr [0x00102078]
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102078]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = pow((double)param_1,DAT_00102068);
dVar1 = round((dVar1 / _DAT_00102070) * _DAT_00102078);
return dVar1 / _DAT_00102078;
} |
5,971 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int num) {
double volume = (pow(num, 3) / (6 * sqrt(2)));
return round(volume * 100) / 100; // rounding to 2 decimal places
}
| int main() {
assert(func0(10) == 117.85);
assert(func0(15) == 397.75);
assert(func0(20) == 942.81);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm0,%xmm0
sub $0x8,%rsp
movsd 0xe34(%rip),%xmm1
cvtsi2sd %edi,%xmm0
callq 1080 <pow@plt>
divsd 0xe2b(%rip),%xmm0
mulsd 0xe2b(%rip),%xmm0
callq 1070 <round@plt>
divsd 0xe1e(%rip),%xmm0
add $0x8,%rsp
retq
| func0:
endbr64
pxor xmm0, xmm0
sub rsp, 8
movsd xmm1, cs:y; y
cvtsi2sd xmm0, edi; x
call _pow
divsd xmm0, cs:qword_2070
mulsd xmm0, cs:qword_2078; x
call _round
divsd xmm0, cs:qword_2078
add rsp, 8
retn | double func0(int a1)
{
double v1; // xmm0_8
v1 = pow((double)a1, 3.0);
return round(v1 / 8.485281374238571 * 100.0) / 100.0;
} | func0:
ENDBR64
PXOR XMM0,XMM0
SUB RSP,0x8
MOVSD XMM1,qword ptr [0x00102068]
CVTSI2SD XMM0,EDI
CALL 0x00101080
DIVSD XMM0,qword ptr [0x00102070]
MULSD XMM0,qword ptr [0x00102078]
CALL 0x00101070
DIVSD XMM0,qword ptr [0x00102078]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = pow((double)param_1,DAT_00102068);
dVar1 = round((dVar1 / _DAT_00102070) * _DAT_00102078);
return dVar1 / _DAT_00102078;
} |
5,972 | func0 |
#include <stdio.h>
#include <assert.h>
int find_lcm(int num1, int num2) {
int num, den, rem, gcd, lcm;
if (num1 > num2) {
num = num1;
den = num2;
} else {
num = num2;
den = num1;
}
rem = num % den;
while (rem != 0) {
num = den;
de... | int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int lcm = find_lcm(num1, num2);
for (int i = 2; i < size; i++) {
lcm = find_lcm(lcm, l[i]);
}
return lcm;
}
| int main() {
int list1[] = {2, 7, 3, 9, 4};
int list2[] = {1, 2, 8, 3};
int list3[] = {3, 8, 4, 10, 5};
assert(func0(list1, 5) == 252);
assert(func0(list2, 4) == 24);
assert(func0(list3, 5) == 120);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov 0x4(%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
mov %edx,%esi
mov %eax,... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_8], eax
mov rax, [rbp+var_18]
mov eax, [rax+4]
mov [rbp+var_4], eax
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
mov esi, ed... | long long func0(unsigned int *a1, int a2)
{
unsigned int lcm; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
lcm = find_lcm(*a1, a1[1]);
for ( i = 2; i < a2; ++i )
lcm = find_lcm(lcm, a1[i]);
return lcm;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0... | int4 func0(int4 *param_1,int param_2)
{
int4 local_18;
int local_14;
local_18 = find_lcm(*param_1,param_1[1]);
for (local_14 = 2; local_14 < param_2; local_14 = local_14 + 1) {
local_18 = find_lcm(local_18,param_1[local_14]);
}
return local_18;
} |
5,973 | func0 |
#include <stdio.h>
#include <assert.h>
int find_lcm(int num1, int num2) {
int num, den, rem, gcd, lcm;
if (num1 > num2) {
num = num1;
den = num2;
} else {
num = num2;
den = num1;
}
rem = num % den;
while (rem != 0) {
num = den;
de... | int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int lcm = find_lcm(num1, num2);
for (int i = 2; i < size; i++) {
lcm = find_lcm(lcm, l[i]);
}
return lcm;
}
| int main() {
int list1[] = {2, 7, 3, 9, 4};
int list2[] = {1, 2, 8, 3};
int list3[] = {3, 8, 4, 10, 5};
assert(func0(list1, 5) == 252);
assert(func0(list2, 4) == 24);
assert(func0(list3, 5) == 120);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%r12d
mov 0x4(%rdi),%esi
mov (%rdi),%edi
callq 1169 <find_lcm>
mov %eax,%edi
cmp $0x2,%r12d
jle 11e7 <func0+0x40>
lea 0x8(%rbp),%rbx
lea -0x3(%r12),%eax
lea 0xc(%rbp,%rax,4),%rbp
mov (%rbx),%esi
callq 1169 <find... | func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov r12d, esi
mov esi, [rdi+4]
mov edi, [rdi]
call find_lcm
mov edi, eax
cmp r12d, 2
jle short loc_11E7
lea rbx, [rbp+8]
lea eax, [r12-3]
lea rbp, [rbp+rax*4+0Ch]
loc_11D5:
mov esi, [rbx]
call find_lcm
mov ... | long long func0(unsigned int *a1, int a2)
{
long long lcm; // rdi
unsigned int *v4; // rbx
long long v5; // rbp
lcm = (unsigned int)find_lcm(*a1, a1[1]);
if ( a2 > 2 )
{
v4 = a1 + 2;
v5 = (long long)&a1[a2 - 3 + 3];
do
LODWORD(lcm) = find_lcm(lcm, *v4++);
while ( v4 != (unsigned int ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV R12D,ESI
MOV ESI,dword ptr [RDI + 0x4]
MOV EDI,dword ptr [RDI]
CALL 0x00101169
MOV EDI,EAX
CMP R12D,0x2
JLE 0x001011e7
LEA RBX,[RBP + 0x8]
LEA EAX,[R12 + -0x3]
LEA RBP,[RBP + RAX*0x4 + 0xc]
LAB_001011d5:
MOV ESI,dword ptr [RBX]
CALL 0x00101169
MOV EDI,EAX
ADD RB... | int4 func0(int4 *param_1,int param_2)
{
int4 uVar1;
int4 *puVar2;
uVar1 = find_lcm(*param_1,param_1[1]);
if (2 < param_2) {
puVar2 = param_1 + 2;
do {
uVar1 = find_lcm(uVar1,*puVar2);
puVar2 = puVar2 + 1;
} while (puVar2 != param_1 + (ulong)(param_2 - 3) + 3);
}
return uVar1;
} |
5,974 | func0 |
#include <stdio.h>
#include <assert.h>
int find_lcm(int num1, int num2) {
int num, den, rem, gcd, lcm;
if (num1 > num2) {
num = num1;
den = num2;
} else {
num = num2;
den = num1;
}
rem = num % den;
while (rem != 0) {
num = den;
de... | int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int lcm = find_lcm(num1, num2);
for (int i = 2; i < size; i++) {
lcm = find_lcm(lcm, l[i]);
}
return lcm;
}
| int main() {
int list1[] = {2, 7, 3, 9, 4};
int list2[] = {1, 2, 8, 3};
int list3[] = {3, 8, 4, 10, 5};
assert(func0(list1, 5) == 252);
assert(func0(list2, 4) == 24);
assert(func0(list3, 5) == 120);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%r8d
mov 0x4(%rdi),%r10d
cmp %r10d,%r8d
jg 13b0 <func0+0xb0>
mov %r10d,%eax
mov %r8d,%ecx
cltd
idiv %ecx
test %edx,%edx
je 13c1 <func0+0xc1>
nopl (%rax)
mov %ecx,%eax
mov %edx,%r9d
mov %edx,%ecx
cltd
idiv %r9d
test %edx,%edx
jne 1328 <func0+0x28>
im... | func0:
endbr64
mov r8d, [rdi]
mov r10d, [rdi+4]
mov r9d, esi
cmp r8d, r10d
jg loc_13B0
mov eax, r10d
mov ecx, r8d
cdq
idiv ecx
test edx, edx
jz loc_13C1
nop dword ptr [rax+rax+00000000h]
loc_1330:
mov eax, ecx
mov esi, edx
mov ecx, edx
cdq
idiv esi
test edx,... | long long func0(int *a1, int a2)
{
int v2; // r8d
int v3; // r10d
int v5; // ecx
int v6; // edx
int v7; // eax
int v8; // esi
int v9; // r8d
int *v10; // r10
long long v11; // r9
int v12; // edi
int v13; // ecx
int v14; // edx
int v15; // eax
int v16; // esi
v2 = *a1;
v3 = a1[1];
if ... | func0:
ENDBR64
MOV R8D,dword ptr [RDI]
MOV R10D,dword ptr [RDI + 0x4]
MOV R9D,ESI
CMP R8D,R10D
JG 0x001013b0
MOV EAX,R10D
MOV ECX,R8D
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013c1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101330:
MOV EAX,ECX
MOV ESI,EDX
MOV ECX,EDX
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x00101330
LAB_0010133d:
IMUL R8D,R1... | int1 [16] func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
ulong uVar3;
int iVar4;
int iVar5;
ulong uVar6;
int iVar7;
int iVar8;
int *piVar9;
int1 auVar10 [16];
iVar1 = *param_1;
iVar8 = param_1[1];
if (iVar8 < iVar1) {
lVar2 = (long)iVar1 % (long)iVar8;
iVar4 = (int)lVar2... |
5,975 | func0 |
#include <stdio.h>
#include <assert.h>
int find_lcm(int num1, int num2) {
int num, den, rem, gcd, lcm;
if (num1 > num2) {
num = num1;
den = num2;
} else {
num = num2;
den = num1;
}
rem = num % den;
while (rem != 0) {
num = den;
de... | int func0(int *l, int size) {
int num1 = l[0];
int num2 = l[1];
int lcm = find_lcm(num1, num2);
for (int i = 2; i < size; i++) {
lcm = find_lcm(lcm, l[i]);
}
return lcm;
}
| int main() {
int list1[] = {2, 7, 3, 9, 4};
int list2[] = {1, 2, 8, 3};
int list3[] = {3, 8, 4, 10, 5};
assert(func0(list1, 5) == 252);
assert(func0(list2, 4) == 24);
assert(func0(list3, 5) == 120);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%r8d
mov 0x4(%rdi),%r9d
mov %rdi,%r10
cmp %r9d,%r8d
jg 1387 <func0+0xb7>
mov %r8d,%ecx
mov %r9d,%edi
mov %edi,%eax
imul %r8d,%r9d
cltd
idiv %ecx
test %edx,%edx
je 1319 <func0+0x49>
nopw 0x0(%rax,%rax,1)
mov %ecx,%eax
mov %edx,%r8d
cltd
mov %r8d,%ec... | func0:
endbr64
mov r8d, [rdi]
mov r10d, [rdi+4]
mov r9, rdi
cmp r8d, r10d
jle loc_1387
mov ecx, r10d
mov edi, r8d
loc_12ED:
mov eax, edi
imul r8d, r10d
cdq
idiv ecx
test edx, edx
jz short loc_1313
nop word ptr [rax+rax+00h]
loc_1300:
mov eax, ecx
mov ecx, edx
cd... | long long func0(int *a1, int a2)
{
int v2; // r8d
int v3; // r10d
int v5; // ecx
int v6; // edi
int v7; // r8d
int v8; // edx
int v9; // eax
int *v10; // r8
long long v11; // r10
int v12; // esi
int v13; // r9d
int v14; // edi
int v15; // ecx
int v16; // edx
int v17; // eax
v2 = *a1;
... | func0:
ENDBR64
MOV R8D,dword ptr [RDI]
MOV R10D,dword ptr [RDI + 0x4]
MOV R9,RDI
CMP R8D,R10D
JLE 0x00101387
MOV ECX,R10D
MOV EDI,R8D
LAB_001012ed:
MOV EAX,EDI
IMUL R8D,R10D
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101313
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EAX,ECX
MOV ECX,EDX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010130... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
int iVar5;
int iVar6;
int *piVar7;
iVar1 = *param_1;
iVar2 = param_1[1];
iVar5 = iVar1;
iVar4 = iVar2;
if (iVar2 < iVar1) {
iVar5 = iVar2;
iVar4 = iVar1;
}
lVar3 = (long)iVar4 % (long)iVar5;
if (... |
5,976 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x != y && y != z && z != x) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == true);
assert(func0(6, 6, 12) == false);
assert(func0(6, 15, 20) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
je 1179 <func0+0x30>
mov -0x8(%rbp),%eax
cmp -0xc(%rbp),%eax
je 1179 <func0+0x30>
mov -0xc(%rbp),%eax
cmp -0x4(%rbp),%eax
je 1179 <func0+... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jz short loc_1179
mov eax, [rbp+var_8]
cmp eax, [rbp+var_C]
jz short loc_1179
mov eax, [rbp+var_C]
cmp eax, [rbp+var_4]
jz ... | _BOOL8 func0(int a1, int a2, int a3)
{
return a1 != a2 && a2 != a3 && a3 != a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JZ 0x00101179
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0xc]
JZ 0x00101179
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,... | int8 func0(int param_1,int param_2,int param_3)
{
int8 uVar1;
if (((param_1 == param_2) || (param_2 == param_3)) || (param_3 == param_1)) {
uVar1 = 0;
}
else {
uVar1 = 1;
}
return uVar1;
} |
5,977 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x != y && y != z && z != x) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == true);
assert(func0(6, 6, 12) == false);
assert(func0(6, 15, 20) == true);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
setne %al
cmp %edx,%edi
setne %cl
and %ecx,%eax
cmp %edx,%esi
setne %dl
and %edx,%eax
retq
| func0:
endbr64
cmp edi, esi
setnz al
cmp edi, edx
setnz cl
and eax, ecx
cmp esi, edx
setnz dl
and eax, edx
retn | long long func0(int a1, int a2, int a3, int a4)
{
unsigned int v4; // eax
LOBYTE(v4) = a1 != a2;
LOBYTE(a4) = a1 != a3;
LOBYTE(a3) = a2 != a3;
return a3 & a4 & v4;
} | func0:
ENDBR64
CMP EDI,ESI
SETNZ AL
CMP EDI,EDX
SETNZ CL
AND EAX,ECX
CMP ESI,EDX
SETNZ DL
AND EAX,EDX
RET | uint func0(int param_1,int param_2,int param_3,int4 param_4)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_1 != param_2) &
CONCAT31((int3)((uint)param_4 >> 8),param_1 != param_3) &
CONCAT31((int3)((uint)param_3 >> 8),param_2 != param_3);
} |
5,978 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x != y && y != z && z != x) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == true);
assert(func0(6, 6, 12) == false);
assert(func0(6, 15, 20) == true);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
setne %al
cmp %edx,%edi
setne %cl
and %ecx,%eax
cmp %edx,%esi
setne %dl
and %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
setnz al
cmp edi, edx
setnz cl
and eax, ecx
cmp esi, edx
setnz dl
and eax, edx
retn | long long func0(int a1, int a2, int a3, int a4)
{
unsigned int v4; // eax
LOBYTE(v4) = a1 != a2;
LOBYTE(a4) = a1 != a3;
LOBYTE(a3) = a2 != a3;
return a3 & a4 & v4;
} | func0:
ENDBR64
CMP EDI,ESI
SETNZ AL
CMP EDI,EDX
SETNZ CL
AND EAX,ECX
CMP ESI,EDX
SETNZ DL
AND EAX,EDX
RET | uint func0(int param_1,int param_2,int param_3,int4 param_4)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_1 != param_2) &
CONCAT31((int3)((uint)param_4 >> 8),param_1 != param_3) &
CONCAT31((int3)((uint)param_3 >> 8),param_2 != param_3);
} |
5,979 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x != y && y != z && z != x) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == true);
assert(func0(6, 6, 12) == false);
assert(func0(6, 15, 20) == true);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
setne %al
cmp %edx,%edi
setne %cl
and %ecx,%eax
cmp %edx,%esi
setne %dl
and %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
setnz al
cmp edi, edx
setnz cl
and eax, ecx
cmp esi, edx
setnz dl
and eax, edx
retn | long long func0(int a1, int a2, int a3, int a4)
{
unsigned int v4; // eax
LOBYTE(v4) = a1 != a2;
LOBYTE(a4) = a1 != a3;
LOBYTE(a3) = a2 != a3;
return a3 & a4 & v4;
} | func0:
ENDBR64
CMP EDI,ESI
SETNZ AL
CMP EDI,EDX
SETNZ CL
AND EAX,ECX
CMP ESI,EDX
SETNZ DL
AND EAX,EDX
RET | uint func0(int param_1,int param_2,int param_3,int4 param_4)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_1 != param_2) &
CONCAT31((int3)((uint)param_4 >> 8),param_1 != param_3) &
CONCAT31((int3)((uint)param_3 >> 8),param_2 != param_3);
} |
5,980 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int lis[n+1];
int lds[n+1];
int i, j, maximum;
for (i = 0; i <= n; i++) {
lis[i] = 1;
}
for (i = 1; i < n; i++) {
for (j = 0; j < i; j++) {
if (arr[i] > arr[j] && lis[i] < lis[j] + 1) {
lis[i] = lis[j] + ... | int main() {
int arr1[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
int arr2[] = {1, 11, 2, 10, 4, 5, 2, 1};
int arr3[] = {80, 60, 30, 40, 20, 10};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])) == 7);
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])) == 6);
assert(func0(a... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x6c(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_4C]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_28], rdx
cdqe
lea ... | long long func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
unsigned long long v4; // rax
void *v5; // rsp
_BYTE v7[4]; // [rsp+8h] [rbp-50h] BYREF
int v8; // [rsp+Ch] [rbp-4Ch]
long long v9; // [rsp+10h] [rbp-48h]
int i; // [rsp+24h] [rbp-34h]
int j; // [rsp+28h] [rbp-30h]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],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 + -0x4c]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
CDQE
LEA ... | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
ulong uVar3;
int *puVar4;
int *puVar5;
long in_FS_OFFSET;
int auStack_58 [4];
int local_54;
long local_50;
int local_3c;
int local_38;
int local_34;
long local_30;
int *local_28;
long local_20;
int *local_18;
long local_10;
... |
5,981 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int arr[], int n) {
int lis[n+1];
int lds[n+1];
int i, j, maximum;
for (i = 0; i <= n; i++) {
lis[i] = 1;
}
for (i = 1; i < n; i++) {
for (j = 0; j < i; j++) {
if (arr[i] > arr[j] && lis[i] < lis[j] + 1) {
lis[i] = lis[j] + ... | int main() {
int arr1[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
int arr2[] = {1, 11, 2, 10, 4, 5, 2, 1};
int arr3[] = {80, 60, 30, 40, 20, 10};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])) == 7);
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])) == 6);
assert(func0(a... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
cltq
shl $0x2,%rax
lea 0xf(%rax),%rdx
mov %rdx,%rcx
and $0xfffffffffffffff0,%rcx
and $0xfffffffffffff000,%rdx
mov %rsp,%... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov rcx, rdi
mov r9d, esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [rsi+1]
cdqe
shl rax, 2
lea rdx, [rax+0Fh]
mov rdi, rdx
and rdi, 0FFFFFFFFFFFFFFF0h
and rdx, ... | long long func0(long long a1, int a2)
{
long long v3; // rax
signed long long v4; // rdx
void *v5; // rsp
long long v6; // rax
__int16 v7; // dx
signed long long v8; // rax
void *v9; // rsp
_DWORD *v10; // rax
long long v11; // rdx
long long v12; // rax
long long v13; // rsi
int v14; // r13d
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RCX,RDI
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[RSI + 0x1]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + 0xf]
MOV RDI,RDX
AND RDI,-0x10
AND RDX,-0x1000
MOV RSI,RSP
SUB RSI,RDX
LAB_001011d0:
CMP RSP,RSI... | int func0(long param_1,uint param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
int4 *puVar4;
long lVar5;
int iVar6;
long lVar7;
int1 *puVar8;
int1 *puVar9;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar2 = (long)(int)(param_2 + 1) * 4;... |
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.