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
movsd %xmm2,0x8(%rsp)
movsd %xmm3,(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm3
jmp 118a <func0+0x2a>
| 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:
movapd xmm0, xmm1
movsd [rsp+18h+var_10], xmm2
call _sqrt
movsd xmm2, [rsp+18h+var_10]
movapd xmm1, xmm0
jmp short loc_1186 | 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 [RSP + 0x8],XMM2
CALL 0x00101050
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVAPD XMM1,XMM0
JMP 0x00101186 | 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
movsd %xmm2,0x8(%rsp)
movsd %xmm3,(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm3
jmp 118a <func0+0x2a>
| 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 $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x4(%rbp)
jmp 11a7 <func0+0x5e>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11a3 <func0+0x5a>
mov -0x18(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11a3 <func0+0x5a>
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11ad <func0+0x64>
subl $0x1,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jg 1181 <func0+0x38>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_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 edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_4], eax
jmp short loc_11A7
loc_1181:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_11A3
mov eax, [rbp+var_18]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_11A3
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
jmp short loc_11AD
loc_11A3:
sub [rbp+var_4], 1
loc_11A7:
cmp [rbp+var_4], 0
jg short loc_1181
loc_11AD:
mov eax, [rbp+var_8]
loc_11B0:
pop rbp
retn | 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 + -0x18]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011a7
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011a3
MOV EAX,dword ptr [RBP + -0x18]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011a3
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011ad
LAB_001011a3:
SUB dword ptr [RBP + -0x4],0x1
LAB_001011a7:
CMP dword ptr [RBP + -0x4],0x0
JG 0x00101181
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x8]
LAB_001011b0:
POP RBP
RET | 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))));
local_c = local_c + -1) {
}
}
return iVar1;
} |
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
idiv %ecx
test %edx,%edx
jne 116b <func0+0x22>
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 116b <func0+0x22>
jmp 118b <func0+0x42>
mov $0x1,%ecx
mov %ecx,%eax
retq
| 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, edi
cdq
idiv ecx
test edx, edx
jnz short loc_116B
mov eax, esi
cdq
idiv ecx
test edx, edx
jnz short loc_116B
jmp short loc_118B
loc_1186:
mov ecx, 1
loc_118B:
mov eax, ecx
retn | 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 EDX,EDX
JNZ 0x0010116b
JMP 0x0010118b
LAB_00101186:
MOV ECX,0x1
LAB_0010118b:
MOV EAX,ECX
RET | 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 (0 < iVar1);
param_2 = 1;
}
}
return param_2;
} |
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 r8d, 1
jnz short loc_1218
loc_1232:
mov r8d, 1
loc_1238:
mov eax, r8d
retn | 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:
MOV EAX,R8D
RET | 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 %r8d
test %edx,%edx
je 1280 <func0+0x40>
sub $0x1,%r8d
jne 1260 <func0+0x20>
mov $0x1,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| 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 ecx, 1
cdq
idiv ecx
test edx, edx
jz short loc_1219
loc_122E:
sub ecx, 1
jnz short loc_1210
loc_1233:
mov ecx, 1
loc_1238:
mov eax, ecx
retn | 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)v2;
} | 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 0x00101210
LAB_00101233:
MOV ECX,0x1
LAB_00101238:
MOV EAX,ECX
RET | 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 there How are you") == 0);
assert(strcmp(func0(list3, 6), " Part of the journey is end") == 0);
return 0;
}
| 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
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2e46(%rip),%rax
add %rdx,%rax
movw $0x20,(%rax)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rsi
lea 0x2e1d(%rip),%rdi
callq 10b0 <strcat@plt>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ce <func0+0x25>
lea 0x2e05(%rip),%rax
leaveq
retq
| 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 ptr [rax], 20h ; ' '
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rsi, rax; src
lea rax, ans_1
mov rdi, rax; dest
call _strcat
add [rbp+var_4], 1
loc_123C:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11EE
lea rax, ans_1
leave
retn | 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
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010d0
ADD dword ptr [RBP + -0x4],0x1
LAB_0010123c:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ee
LEA RAX,[0x104040]
LEAVE
RET | 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 there How are you") == 0);
assert(strcmp(func0(list3, 6), " Part of the journey is end") == 0);
return 0;
}
| 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,%edx
mov (%rbx),%rsi
mov %rbp,%rdi
callq 1070 <__strcat_chk@plt>
add $0x8,%rbx
cmp %r12,%rbx
jne 11b0 <func0+0x27>
lea 0x2e5c(%rip),%rax
pop %rbx
pop %rbp
pop %r12
retq
lea 0x2e50(%rip),%rax
retq
| 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 ___strcat_chk
mov edx, 3E8h
mov rsi, [rbx]
mov rdi, rbp
call ___strcat_chk
add rbx, 8
cmp rbx, r13
jnz short loc_11DD
lea rax, ans_1
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1218:
lea rax, ans_1
retn | __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 ptr [RBX]
MOV RDI,RBP
CALL 0x00101080
ADD RBX,0x8
CMP RBX,R13
JNZ 0x001011dd
LEA RAX,[0x104040]
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101218:
LEA RAX,[0x104040]
RET | 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);
return ans_1;
}
return ans_1;
} |
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 there How are you") == 0);
assert(strcmp(func0(list3, 6), " Part of the journey is end") == 0);
return 0;
}
| 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 -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 13b7 <func0+0x37>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %rbx,%rdx
mov %eax,%ecx
add %al,%cl
mov $0x20,%eax
sbb $0x3,%rdi
add $0x8,%r12
mov %ax,(%rdi)
add $0x1,%rdi
mov -0x8(%r12),%rsi
sub %rdi,%rdx
callq 1090 <__strcpy_chk@plt>
cmp %rbp,%r12
jne 13b0 <func0+0x30>
pop %rbx
lea 0x2c28(%rip),%rax
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
lea 0x2c19(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
| 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:
mov rdi, r12
add rbx, 8
call _strlen
mov rdx, rbp
lea rdi, [r12+rax]
mov eax, 20h ; ' '
mov [rdi], ax
add rdi, 1
mov rsi, [rbx-8]
sub rdx, rdi
call ___strcpy_chk
cmp rbx, r13
jnz short loc_13E0
loc_1410:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn | __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));
}
while ( v2 != a1 + 8LL * (unsigned int)(a2 - 1) + 8 );
}
return &ans_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
MOV RDX,RBP
LEA RDI,[R12 + RAX*0x1]
MOV EAX,0x20
MOV word ptr [RDI],AX
ADD RDI,0x1
MOV RSI,qword ptr [RBX + -0x8]
SUB RDX,RDI
CALL 0x001010d0
CMP RBX,R13
JNZ 0x001013e0
LAB_00101410:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET | 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 - (sVar1 + 0x104041));
puVar2 = puVar3;
} while (puVar3 != param_1 + (ulong)(param_2 - 1) + 1);
}
return ans_1;
} |
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 there How are you") == 0);
assert(strcmp(func0(list3, 6), " Part of the journey is end") == 0);
return 0;
}
| 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 -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 13e7 <func0+0x37>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %rbx,%rdx
mov %eax,%ecx
add %al,%cl
mov $0x20,%eax
sbb $0x3,%rdi
add $0x8,%r12
mov %ax,(%rdi)
add $0x1,%rdi
mov -0x8(%r12),%rsi
sub %rdi,%rdx
callq 1090 <__strcpy_chk@plt>
cmp %rbp,%r12
jne 13e0 <func0+0x30>
pop %rbx
lea 0x2bf8(%rip),%rax
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
lea 0x2be9(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
| 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 rdi, rbx; s
add r13, 8
call _strlen
mov rdx, rbp
lea rdi, [rbx+rax]
mov eax, 20h ; ' '
mov [rdi], ax
add rdi, 1
mov rsi, [r13-8]
sub rdx, rdi
call ___strcpy_chk
cmp r13, r12
jnz short loc_1420
loc_1450:
add rsp, 8
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
retn | 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 != a1 + 8LL * a2 );
}
return ans_1;
} | 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,RBP
LEA RDI,[RBX + RAX*0x1]
MOV EAX,0x20
MOV word ptr [RDI],AX
ADD RDI,0x1
MOV RSI,qword ptr [R13 + -0x8]
SUB RDX,RDI
CALL 0x001010d0
CMP R13,R12
JNZ 0x00101420
LAB_00101450:
ADD RSP,0x8
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
RET | 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 - (sVar1 + 0x104041));
puVar2 = puVar3;
} while (puVar3 != param_1 + param_2);
}
return ans_1;
} |
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 %xmm0,%eax
mov %eax,-0x4(%rbp)
movl $0x1,-0xc(%rbp)
jmp 122a <func0+0x6a>
mov -0x8(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1226 <func0+0x66>
addl $0x2,-0x10(%rbp)
mov -0x8(%rbp),%eax
cltd
idivl -0xc(%rbp)
cmp %eax,-0xc(%rbp)
jne 1226 <func0+0x66>
subl $0x1,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x4(%rbp),%eax
jle 1205 <func0+0x45>
mov -0x10(%rbp),%eax
leaveq
retq
| 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, xmm1
movq xmm0, rax; x
call _sqrt
cvttsd2si eax, xmm0
mov [rbp+var_4], eax
mov [rbp+var_C], 1
jmp short loc_1238
loc_1213:
mov eax, [rbp+var_8]
cdq
idiv [rbp+var_C]
mov eax, edx
test eax, eax
jnz short loc_1234
add [rbp+var_10], 2
mov eax, [rbp+var_8]
cdq
idiv [rbp+var_C]
cmp [rbp+var_C], eax
jnz short loc_1234
sub [rbp+var_10], 1
loc_1234:
add [rbp+var_C], 1
loc_1238:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_4]
jle short loc_1213
mov eax, [rbp+var_10]
leave
retn | 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) )
{
v3 += 2;
if ( i == v5 / i )
--v3;
}
}
return v3;
} | 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 [RBP + -0x8]
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101238
LAB_00101213:
MOV EAX,dword ptr [RBP + -0x8]
CDQ
IDIV dword ptr [RBP + -0xc]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101234
ADD dword ptr [RBP + -0x10],0x2
MOV EAX,dword ptr [RBP + -0x8]
CDQ
IDIV dword ptr [RBP + -0xc]
CMP dword ptr [RBP + -0xc],EAX
JNZ 0x00101234
SUB dword ptr [RBP + -0x10],0x1
LAB_00101234:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101238:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x4]
JLE 0x00101213
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET | 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 == 0) && (iVar1 = local_18 + 2, local_14 == iVar2 / local_14)) {
iVar1 = local_18 + 1;
}
local_18 = iVar1;
}
return local_18;
} |
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 $0x1,%edi
mov $0x1,%ecx
mov $0x0,%esi
jmp 120b <func0+0x57>
callq 1070 <sqrt@plt>
jmp 11e4 <func0+0x30>
add $0x1,%ecx
cmp %edi,%ecx
je 1230 <func0+0x7c>
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1204 <func0+0x50>
mov %ebx,%eax
cltd
idiv %ecx
mov %esi,%edx
cmp %ecx,%eax
setne %sil
movzbl %sil,%esi
lea 0x1(%rsi,%rdx,1),%esi
jmp 1204 <func0+0x50>
mov $0x0,%esi
mov %esi,%eax
add $0x10,%rsp
pop %rbx
retq
| 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_11ED:
call _sqrt
jmp short loc_11D6
loc_11F4:
add ecx, 1
cmp ecx, edi
jz short loc_1220
loc_11FB:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_11F4
mov eax, ebx
cdq
idiv ecx
mov edx, esi
cmp eax, ecx
setnz sil
movzx esi, sil
lea esi, [rsi+rdx+1]
jmp short loc_11F4
loc_121B:
mov esi, 0
loc_1220:
mov eax, esi
pop rbx
retn | 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
{
if ( !(v0 % v3) )
v4 += (v0 / v3 != v3) + 1;
++v3;
}
while ( v3 != (int)v2 + 1 );
}
return v4;
} | 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:
ADD ECX,0x1
CMP ECX,EDI
JZ 0x00101220
LAB_001011fb:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001011f4
MOV EAX,EBX
CDQ
IDIV ECX
MOV EDX,ESI
CMP EAX,ECX
SETNZ SIL
MOVZX ESI,SIL
LEA ESI,[RSI + RDX*0x1 + 0x1]
JMP 0x001011f4
LAB_0010121b:
MOV ESI,0x0
LAB_00101220:
MOV EAX,ESI
POP RBX
RET | 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 % iVar2 == 0) {
iVar3 = (iVar1 / iVar2 != iVar2) + 1 + iVar3;
}
iVar2 = iVar2 + 1;
} while (iVar2 != (int)dVar4 + 1);
}
return iVar3;
} |
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 %edx,%edx
cmove %ecx,%ebx
add $0x1,%ecx
cmp %r8d,%ecx
jne 12b0 <func0+0x30>
pxor %xmm0,%xmm0
pxor %xmm2,%xmm2
cvtsi2sd %ebx,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 134c <func0+0xcc>
cvttsd2si %xmm1,%esi
test %esi,%esi
jle 1330 <func0+0xb0>
add $0x1,%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 131a <func0+0x9a>
mov %r8d,%edx
xor %r8d,%r8d
cmp %ecx,%eax
setne %r8b
lea 0x1(%r8,%rdx,1),%r8d
add $0x1,%ecx
cmp %ecx,%esi
jne 1300 <func0+0x80>
add $0x10,%rsp
mov %r8d,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
add $0x10,%rsp
mov %r8d,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%ebx
mov $0x1,%esi
jmp 12ed <func0+0x6d>
movsd %xmm1,0x8(%rsp)
callq 1070 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 12e5 <func0+0x65>
| 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 ebx, ecx
loc_12BB:
add ecx, 1
cmp ecx, r8d
jnz short loc_12A8
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, ebx
ucomisd xmm1, xmm0
ja short loc_1338
loc_12D5:
sqrtsd xmm0, xmm0
loc_12D9:
cvttsd2si esi, xmm0
test esi, esi
jle short loc_1330
add esi, 1
mov ecx, 1
xor r8d, r8d
nop dword ptr [rax+00h]
loc_12F0:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_130A
mov edx, r8d
xor r8d, r8d
cmp eax, ecx
setnz r8b
lea r8d, [r8+rdx+1]
loc_130A:
add ecx, 1
cmp ecx, esi
jnz short loc_12F0
mov eax, r8d
pop rbx
retn
loc_1320:
movsd xmm0, cs:qword_2060
mov ebx, 1
jmp short loc_12D5
loc_1330:
xor r8d, r8d
pop rbx
mov eax, r8d
retn
loc_1338:
call _sqrt
jmp short loc_12D9 | 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 LABEL_11;
}
v3 = v2 + 1;
v4 = 1;
v5 = 1;
do
{
if ( !(a1 % v5) && !(a2 % v5) )
v4 = v5;
++v5;
}
while ( v5 != v3 );
v6 = (double)v4;
if ( (double)v4 >= 0.0 )
goto LABEL_10;
v7 = sqrt(v6);
LABEL_11:
if ( (int)v7 <= 0 )
return 0LL;
v8 = 1;
v9 = 0;
do
{
if ( !(v4 % v8) )
v9 += (v4 / v8 != v8) + 1;
++v8;
}
while ( v8 != (int)v7 + 1 );
return v9;
} | 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
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EBX
UCOMISD XMM1,XMM0
JA 0x00101338
LAB_001012d5:
SQRTSD XMM0,XMM0
LAB_001012d9:
CVTTSD2SI ESI,XMM0
TEST ESI,ESI
JLE 0x00101330
ADD ESI,0x1
MOV ECX,0x1
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_001012f0:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010130a
MOV EDX,R8D
XOR R8D,R8D
CMP EAX,ECX
SETNZ R8B
LEA R8D,[R8 + RDX*0x1 + 0x1]
LAB_0010130a:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x001012f0
MOV EAX,R8D
POP RBX
RET
LAB_00101320:
MOVSD XMM0,qword ptr [0x00102060]
MOV EBX,0x1
JMP 0x001012d5
LAB_00101330:
XOR R8D,R8D
POP RBX
MOV EAX,R8D
RET
LAB_00101338:
CALL 0x00101070
JMP 0x001012d9 | 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) && (param_2 % iVar1 == 0)) {
iVar3 = iVar1;
}
iVar1 = iVar1 + 1;
} while (iVar1 != iVar2 + 1);
dVar4 = (double)iVar3;
if (dVar4 < 0.0) {
dVar4 = sqrt(dVar4);
goto LAB_001012d9;
}
}
dVar4 = SQRT(dVar4);
LAB_001012d9:
if (0 < (int)dVar4) {
iVar2 = 1;
iVar1 = 0;
do {
if (iVar3 % iVar2 == 0) {
iVar1 = (iVar3 / iVar2 != iVar2) + 1 + iVar1;
}
iVar2 = iVar2 + 1;
} while (iVar2 != (int)dVar4 + 1);
return iVar1;
}
return 0;
} |
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 %edx,%edx
cmove %ecx,%ebx
add $0x1,%ecx
cmp %r8d,%ecx
jne 12b0 <func0+0x30>
pxor %xmm0,%xmm0
pxor %xmm2,%xmm2
cvtsi2sd %ebx,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 134c <func0+0xcc>
cvttsd2si %xmm1,%esi
test %esi,%esi
jle 1330 <func0+0xb0>
add $0x1,%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 131a <func0+0x9a>
mov %r8d,%edx
xor %r8d,%r8d
cmp %ecx,%eax
setne %r8b
lea 0x1(%r8,%rdx,1),%r8d
add $0x1,%ecx
cmp %esi,%ecx
jne 1300 <func0+0x80>
add $0x10,%rsp
mov %r8d,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
add $0x10,%rsp
mov %r8d,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%ebx
mov $0x1,%esi
jmp 12ed <func0+0x6d>
movsd %xmm1,0x8(%rsp)
callq 1070 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 12e5 <func0+0x65>
| 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 ebx, ecx
loc_12BB:
add ecx, 1
cmp r8d, ecx
jnz short loc_12A8
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, ebx; x
ucomisd xmm1, xmm0
ja short loc_132C
sqrtsd xmm0, xmm0
cvttsd2si edi, xmm0
loc_12DD:
test edi, edi
jle short loc_1318
loc_12E1:
add edi, 1
mov ecx, 1
xor esi, esi
nop dword ptr [rax+rax+00h]
loc_12F0:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_1307
mov edx, esi
xor esi, esi
cmp eax, ecx
setnz sil
lea esi, [rsi+rdx+1]
loc_1307:
add ecx, 1
cmp edi, ecx
jnz short loc_12F0
mov eax, esi
pop rbx
retn
loc_1318:
xor esi, esi
pop rbx
mov eax, esi
retn
loc_1320:
mov edi, 1
mov ebx, 1
jmp short loc_12E1
loc_132C:
call _sqrt
cvttsd2si edi, xmm0
jmp short loc_12DD | 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 + 1;
v4 = 1;
v5 = 1;
do
{
if ( !(a1 % v5) && !(a2 % v5) )
v4 = v5;
++v5;
}
while ( v3 != v5 );
v6 = (double)v4;
if ( (double)v4 < 0.0 )
v7 = (int)sqrt(v6);
else
v7 = (int)sqrt(v6);
if ( v7 <= 0 )
return 0LL;
}
v8 = v7 + 1;
v9 = 1;
v10 = 0;
do
{
if ( !(v4 % v9) )
v10 += (v4 / v9 != v9) + 1;
++v9;
}
while ( v8 != v9 );
return v10;
} | 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
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EBX
UCOMISD XMM1,XMM0
JA 0x0010132c
SQRTSD XMM0,XMM0
CVTTSD2SI EDI,XMM0
LAB_001012dd:
TEST EDI,EDI
JLE 0x00101318
LAB_001012e1:
ADD EDI,0x1
MOV ECX,0x1
XOR ESI,ESI
NOP dword ptr [RAX + RAX*0x1]
LAB_001012f0:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101307
MOV EDX,ESI
XOR ESI,ESI
CMP EAX,ECX
SETNZ SIL
LEA ESI,[RSI + RDX*0x1 + 0x1]
LAB_00101307:
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x001012f0
MOV EAX,ESI
POP RBX
RET
LAB_00101318:
XOR ESI,ESI
POP RBX
MOV EAX,ESI
RET
LAB_00101320:
MOV EDI,0x1
MOV EBX,0x1
JMP 0x001012e1
LAB_0010132c:
CALL 0x00101070
CVTTSD2SI EDI,XMM0
JMP 0x001012dd | 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) && (param_2 % iVar1 == 0)) {
iVar2 = iVar1;
}
iVar1 = iVar1 + 1;
} while (iVar4 + 1 != iVar1);
dVar5 = (double)iVar2;
if (dVar5 < 0.0) {
dVar5 = sqrt(dVar5);
}
else {
dVar5 = SQRT(dVar5);
}
iVar4 = (int)dVar5;
if (iVar4 < 1) {
return 0;
}
}
iVar1 = 1;
iVar3 = 0;
do {
if (iVar2 % iVar1 == 0) {
iVar3 = (iVar2 / iVar1 != iVar1) + 1 + iVar3;
}
iVar1 = iVar1 + 1;
} while (iVar4 + 1 != iVar1);
return iVar3;
} |
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, result2);
int exp2[] = {9, 13, 17, 15, 16};
for (int i = 0; i < 5; i++) {
assert(result2[i] == exp2[i]);
}
int result3[9];
int nums3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
func0(nums3, 10, result3);
int exp3[] = {3, 5, 7, 9, 11, 13, 15, 17, 19};
for (int i = 0; i < 9; i++) {
assert(result3[i] == exp3[i]);
}
printf("All assertions passed!\n");
return 0;
}
| 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,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x28(%rbp),%rax
add %rsi,%rax
add %ecx,%edx
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 11a5 <func0+0x1c>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_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]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rsi
add edx, ecx
mov [rax], edx
add [rbp+var_4], 1
loc_11F1:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_4], eax
jl short loc_11A5
nop
nop
pop rbp
retn | 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);
}
return result;
} | 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 EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RSI
ADD EDX,ECX
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011f1:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x001011a5
NOP
NOP
POP RBP
RET | 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, result2);
int exp2[] = {9, 13, 17, 15, 16};
for (int i = 0; i < 5; i++) {
assert(result2[i] == exp2[i]);
}
int result3[9];
int nums3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
func0(nums3, 10, result3);
int exp3[] = {3, 5, 7, 9, 11, 13, 15, 17, 19};
for (int i = 0; i < 9; i++) {
assert(result3[i] == exp3[i]);
}
printf("All assertions passed!\n");
return 0;
}
| 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++;
}
while ( v5 != v3 );
}
} | 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 (bVar2);
}
return;
} |
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, result2);
int exp2[] = {9, 13, 17, 15, 16};
for (int i = 0; i < 5; i++) {
assert(result2[i] == exp2[i]);
}
int result3[9];
int nums3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
func0(nums3, 10, result3);
int exp3[] = {3, 5, 7, 9, 11, 13, 15, 17, 19};
for (int i = 0; i < 9; i++) {
assert(result3[i] == exp3[i]);
}
printf("All assertions passed!\n");
return 0;
}
| 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++;
}
while ( v5 != v3 );
}
} | 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 (bVar2);
}
return;
} |
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, result2);
int exp2[] = {9, 13, 17, 15, 16};
for (int i = 0; i < 5; i++) {
assert(result2[i] == exp2[i]);
}
int result3[9];
int nums3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
func0(nums3, 10, result3);
int exp3[] = {3, 5, 7, 9, 11, 13, 15, 17, 19};
for (int i = 0; i < 9; i++) {
assert(result3[i] == exp3[i]);
}
printf("All assertions passed!\n");
return 0;
}
| 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 $0x2,%ecx
shl $0x4,%rcx
nopl (%rax)
movdqu (%rdi,%rax,1),%xmm0
movdqu 0x4(%rdi,%rax,1),%xmm1
paddd %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %rcx,%rax
jne 1490 <func0+0x40>
mov %r8d,%eax
and $0xfffffffc,%eax
test $0x3,%r8b
je 150e <func0+0xbe>
movslq %eax,%rcx
mov (%rdi,%rcx,4),%esi
add 0x4(%rdi,%rcx,4),%esi
mov %esi,(%rdx,%rcx,4)
lea 0x1(%rax),%ecx
cmp %ecx,%r8d
jle 150e <func0+0xbe>
movslq %ecx,%rcx
add $0x2,%eax
mov (%rdi,%rcx,4),%esi
add 0x4(%rdi,%rcx,4),%esi
mov %esi,(%rdx,%rcx,4)
cmp %eax,%r8d
jle 150e <func0+0xbe>
cltq
mov (%rdi,%rax,4),%ecx
add 0x4(%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
retq
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
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 14f8 <func0+0xa8>
retq
| 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, [rcx+rax*4+4]
add edx, [rcx+rax*4]
mov [rdi+rax*4], edx
add rax, 1
cmp rsi, rax
jnz short loc_11A0
retn
locret_11B8:
retn
loc_11C0:
lea edx, [rsi-1]
lea eax, [rsi-2]
mov r8d, edx
cmp eax, 2
jbe short loc_123F
shr r8d, 2
xor eax, eax
shl r8, 4
nop dword ptr [rax+rax+00000000h]
loc_11E0:
movdqu xmm0, xmmword ptr [rcx+rax]
movdqu xmm2, xmmword ptr [rcx+rax+4]
paddd xmm0, xmm2
movups xmmword ptr [rdi+rax], xmm0
add rax, 10h
cmp rax, r8
jnz short loc_11E0
test dl, 3
jz short locret_11B8
and edx, 0FFFFFFFCh
sub esi, edx
mov eax, edx
lea r8d, [rsi-1]
cmp esi, 2
jz short loc_1232
loc_1211:
movq xmm0, qword ptr [rcx+rdx*4+4]
movq xmm1, qword ptr [rcx+rdx*4]
paddd xmm0, xmm1
movq qword ptr [rdi+rdx*4], xmm0
test r8b, 1
jz short locret_11B8
and r8d, 0FFFFFFFEh
add eax, r8d
loc_1232:
cdqe
mov edx, [rcx+rax*4]
add edx, [rcx+rax*4+4]
mov [rdi+rax*4], edx
retn
loc_123F:
xor edx, edx
xor eax, eax
jmp short loc_1211 | 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)) <= 0xC )
{
v5 = (unsigned int)(a2 - 1);
v6 = 0LL;
do
{
*(_DWORD *)(a3 + 4 * v6) = *(_DWORD *)(a1 + 4 * v6) + *(_DWORD *)(a1 + 4 * v6 + 4);
++v6;
}
while ( v5 != v6 );
return;
}
v7 = a2 - 1;
v8 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v11 = 0LL;
v13 = 0;
LABEL_13:
*(_QWORD *)(a3 + 4 * v11) = _mm_add_epi32(
_mm_loadl_epi64((const __m128i *)(a1 + 4 * v11 + 4)),
_mm_loadl_epi64((const __m128i *)(a1 + 4 * v11))).m128i_u64[0];
if ( (v8 & 1) == 0 )
return;
v13 += v8 & 0xFFFFFFFE;
LABEL_15:
*(_DWORD *)(a3 + 4LL * v13) = *(_DWORD *)(a1 + 4LL * v13 + 4) + *(_DWORD *)(a1 + 4LL * v13);
return;
}
v9 = 0LL;
v10 = 16LL * (v8 >> 2);
do
{
*(__m128i *)(a3 + v9) = _mm_add_epi32(
_mm_loadu_si128((const __m128i *)(a1 + v9)),
_mm_loadu_si128((const __m128i *)(a1 + v9 + 4)));
v9 += 16LL;
}
while ( v9 != v10 );
if ( (v7 & 3) != 0 )
{
v11 = v7 & 0xFFFFFFFC;
v12 = a2 - v11;
v13 = v11;
v8 = v12 - 1;
if ( v12 == 2 )
goto LABEL_15;
goto LABEL_13;
}
}
} | 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 ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x001011a0
RET
LAB_001011b8:
RET
LAB_001011c0:
LEA EDX,[RSI + -0x1]
LEA EAX,[RSI + -0x2]
MOV R8D,EDX
CMP EAX,0x2
JBE 0x0010123f
SHR R8D,0x2
XOR EAX,EAX
SHL R8,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_001011e0:
MOVDQU XMM0,xmmword ptr [RCX + RAX*0x1]
MOVDQU XMM2,xmmword ptr [RCX + RAX*0x1 + 0x4]
PADDD XMM0,XMM2
MOVUPS xmmword ptr [RDI + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,R8
JNZ 0x001011e0
TEST DL,0x3
JZ 0x001011b8
AND EDX,0xfffffffc
SUB ESI,EDX
MOV EAX,EDX
LEA R8D,[RSI + -0x1]
CMP ESI,0x2
JZ 0x00101232
LAB_00101211:
MOVQ XMM0,qword ptr [RCX + RDX*0x4 + 0x4]
MOVQ XMM1,qword ptr [RCX + RDX*0x4]
PADDD XMM0,XMM1
MOVQ qword ptr [RDI + RDX*0x4],XMM0
TEST R8B,0x1
JZ 0x001011b8
AND R8D,0xfffffffe
ADD EAX,R8D
LAB_00101232:
CDQE
MOV EDX,dword ptr [RCX + RAX*0x4]
ADD EDX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
RET
LAB_0010123f:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x00101211 | 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) || ((ulong)(param_3 - (param_1 + 4)) < 0xd)) {
uVar13 = 0;
do {
*(int *)(param_3 + uVar13 * 4) =
*(int *)(param_1 + 4 + uVar13 * 4) + *(int *)(param_1 + uVar13 * 4);
uVar13 = uVar13 + 1;
} while (param_2 - 1 != uVar13);
return;
}
uVar1 = param_2 - 1;
if (param_2 - 2U < 3) {
uVar15 = 0;
}
else {
lVar14 = 0;
do {
piVar2 = (int *)(param_1 + lVar14);
iVar7 = piVar2[1];
iVar8 = piVar2[2];
iVar9 = piVar2[3];
piVar4 = (int *)(param_1 + 4 + lVar14);
iVar10 = piVar4[1];
iVar11 = piVar4[2];
iVar12 = piVar4[3];
piVar3 = (int *)(param_3 + lVar14);
*piVar3 = *piVar2 + *piVar4;
piVar3[1] = iVar7 + iVar10;
piVar3[2] = iVar8 + iVar11;
piVar3[3] = iVar9 + iVar12;
lVar14 = lVar14 + 0x10;
} while (lVar14 != (ulong)(uVar1 >> 2) << 4);
if ((uVar1 & 3) == 0) {
return;
}
uVar15 = uVar1 & 0xfffffffc;
uVar1 = (param_2 - uVar15) - 1;
if (param_2 - uVar15 == 2) goto LAB_00101232;
}
uVar13 = (ulong)uVar15;
uVar5 = *(int8 *)(param_1 + 4 + uVar13 * 4);
uVar6 = *(int8 *)(param_1 + uVar13 * 4);
*(ulong *)(param_3 + uVar13 * 4) =
CONCAT44((int)((ulong)uVar5 >> 0x20) + (int)((ulong)uVar6 >> 0x20),(int)uVar5 + (int)uVar6)
;
if ((uVar1 & 1) != 0) {
uVar15 = uVar15 + (uVar1 & 0xfffffffe);
LAB_00101232:
lVar14 = (long)(int)uVar15;
*(int *)(param_3 + lVar14 * 4) =
*(int *)(param_1 + lVar14 * 4) + *(int *)(param_1 + 4 + lVar14 * 4);
return;
}
}
return;
} |
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>
mov -0x8(%rbp),%eax
pop %rbp
retq
| 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_14]
jle short loc_1164
mov eax, [rbp+var_8]
pop rbp
retn | 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,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101164
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | 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 %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| 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 eax, r8d
retn | 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 %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| 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 eax, ecx
retn | 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, 9);
assert(memcmp(array2, result2, 9 * sizeof(int)) == 0);
int array3[9] = {3, 11, 0, 74, 14, 0, 1, 0, 2};
int result3[9] = {3, 11, 74, 14, 1, 2, 0, 0, 0};
func0(array3, 9);
assert(memcmp(array3, result3, 9 * sizeof(int)) == 0);
return 0;
}
| 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>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11a8 <func0+0x1f>
mov -0xc(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1225 <func0+0x9c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movl $0x0,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1207 <func0+0x7e>
pop %rbp
retq
| 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 short loc_11F3
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_C], 1
loc_11F3:
add [rbp+var_8], 1
loc_11F7:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_11A8
mov eax, [rbp+var_C]
mov [rbp+var_4], eax
jmp short loc_1225
loc_1207:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov dword ptr [rax], 0
add [rbp+var_4], 1
loc_1225:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1207
nop
nop
pop rbp
retn | 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 * i + a1);
}
for ( j = v3; ; ++j )
{
result = j;
if ( (int)j >= a2 )
break;
*(_DWORD *)(4LL * (int)j + a1) = 0;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -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 EAX,EAX
JZ 0x001011f3
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_001011f3:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f7:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011a8
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101225
LAB_00101207:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV dword ptr [RAX],0x0
ADD dword ptr [RBP + -0x4],0x1
LAB_00101225:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101207
NOP
NOP
POP RBP
RET | 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);
local_14 = local_14 + 1;
}
}
for (local_c = local_14; local_c < param_2; local_c = local_c + 1) {
*(int4 *)(param_1 + (long)local_c * 4) = 0;
}
return;
} |
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, 9);
assert(memcmp(array2, result2, 9 * sizeof(int)) == 0);
int array3[9] = {3, 11, 0, 74, 14, 0, 1, 0, 2};
int result3[9] = {3, 11, 74, 14, 1, 2, 0, 0, 0};
func0(array3, 9);
assert(memcmp(array3, result3, 9 * sizeof(int)) == 0);
return 0;
}
| 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+0x21>
movslq %ecx,%r9
mov %edx,(%rdi,%r9,4)
add $0x1,%ecx
jmp 11aa <func0+0x21>
cmp %esi,%ecx
jge 11e9 <func0+0x60>
movslq %ecx,%rdx
lea (%rdi,%rdx,4),%rax
sub %ecx,%r10d
add %rdx,%r10
lea (%r11,%r10,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 11da <func0+0x51>
retq
| 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 short loc_11AA
movsxd r9, ecx
mov [rdi+r9*4], edx
add ecx, 1
jmp short loc_11AA
loc_11C5:
cmp ecx, esi
jge short locret_11E9
movsxd rdx, ecx
lea rax, [rdi+rdx*4]
sub r10d, ecx
add r10, rdx
lea rdx, [r11+r10*4]
loc_11DA:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_11DA
locret_11E9:
retn | 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;
while ( v4 != &a1[v3 + 1 + (unsigned long long)(unsigned int)(a2 - 1 - v3)] );
}
}
} | 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],EDX
ADD ECX,0x1
JMP 0x001011aa
LAB_001011c5:
CMP ECX,ESI
JGE 0x001011e9
MOVSXD RDX,ECX
LEA RAX,[RDI + RDX*0x4]
SUB R10D,ECX
ADD R10,RDX
LEA RDX,[R11 + R10*0x4]
LAB_001011da:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011da
LAB_001011e9:
RET | 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);
if (iVar2 < param_2) {
piVar1 = param_1 + iVar2;
do {
*piVar1 = 0;
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)((param_2 - 1U) - iVar2) + (long)iVar2 + 1);
}
}
return;
} |
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, 9);
assert(memcmp(array2, result2, 9 * sizeof(int)) == 0);
int array3[9] = {3, 11, 0, 74, 14, 0, 1, 0, 2};
int result3[9] = {3, 11, 74, 14, 1, 2, 0, 0, 0};
func0(array3, 9);
assert(memcmp(array3, result3, 9 * sizeof(int)) == 0);
return 0;
}
| 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)
add $0x4,%rax
cmp %r8,%rax
jne 14e0 <func0+0x20>
cmp %esi,%ecx
jge 151f <func0+0x5f>
movslq %ecx,%rdx
sub %ecx,%r10d
add %rdx,%r10
lea (%rdi,%rdx,4),%rax
lea (%r11,%r10,4),%rdx
xchg %ax,%ax
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1510 <func0+0x50>
retq
| 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
loc_1510:
add rax, 4
cmp rax, r8
jnz short loc_1500
cmp ecx, esi
jge short locret_1540
sub r10d, ecx
movsxd rcx, ecx
xor esi, esi
lea rdx, ds:4[r10*4]
lea rdi, [rdi+rcx*4]
jmp _memset
locret_1540:
retn | 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 != &a1[v4 + 1] );
if ( v3 < a2 )
memset(&a1[v3], 0LL, 4LL * (unsigned int)(v4 - v3) + 4);
}
} | 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
JNZ 0x00101500
CMP ECX,ESI
JGE 0x00101540
SUB R10D,ECX
MOVSXD RCX,ECX
XOR ESI,ESI
LEA RDX,[0x4 + R10*0x4]
LEA RDI,[RDI + RCX*0x4]
JMP 0x00101090
LAB_00101540:
RET | 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 (piVar1 != param_1 + (ulong)(param_2 - 1U) + 1);
if (iVar2 < param_2) {
memset(param_1 + iVar2,0,(ulong)((param_2 - 1U) - iVar2) * 4 + 4);
return;
}
}
return;
} |
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, 9);
assert(memcmp(array2, result2, 9 * sizeof(int)) == 0);
int array3[9] = {3, 11, 0, 74, 14, 0, 1, 0, 2};
int result3[9] = {3, 11, 74, 14, 1, 2, 0, 0, 0};
func0(array3, 9);
assert(memcmp(array3, result3, 9 * sizeof(int)) == 0);
return 0;
}
| 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
cmp %rax,%r8
jne 1470 <func0+0x20>
cmp %esi,%ecx
jge 14b0 <func0+0x60>
sub %ecx,%r10d
movslq %ecx,%rcx
xor %esi,%esi
lea 0x4(,%r10,4),%rdx
lea (%rdi,%rcx,4),%rdi
jmpq 1090 <memset@plt>
nopw %cs:0x0(%rax,%rax,1)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| 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, rax
jnz short loc_1448
cmp ecx, esi
jge short locret_1480
sub esi, 1
sub esi, ecx
movsxd rcx, ecx
lea rdx, ds:4[rsi*4]; n
lea rdi, [rdi+rcx*4]; s
xor esi, esi; c
jmp _memset
locret_1480:
retn | 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, 4LL * (unsigned int)(a2 - 1 - v3) + 4);
}
} | 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 0x00101480
SUB ESI,0x1
SUB ESI,ECX
MOVSXD RCX,ECX
LEA RDX,[0x4 + RSI*0x4]
LEA RDI,[RDI + RCX*0x4]
XOR ESI,ESI
JMP 0x00101090
LAB_00101480:
RET | 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 (param_1 + param_2 != piVar1);
if (iVar2 < param_2) {
memset(param_1 + iVar2,0,(ulong)(uint)((param_2 + -1) - iVar2) * 4 + 4);
return;
}
}
return;
} |
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];
}
if (j < k) {
P[i][j + 1] = 0;
}
}
}
return P[n][k];
}
| 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 -0x64(%rbp),%ecx
lea 0x1(%rcx),%edi
movslq %esi,%rcx
sub $0x1,%rcx
mov %rcx,-0x50(%rbp)
movslq %esi,%rcx
mov %rcx,-0x80(%rbp)
movq $0x0,-0x78(%rbp)
movslq %esi,%rcx
shl $0x2,%rcx
movslq %edi,%rbx
sub $0x1,%rbx
mov %rbx,-0x48(%rbp)
movslq %esi,%rbx
mov %rbx,%r12
mov $0x0,%r13d
movslq %edi,%rbx
mov %rbx,%rax
mov $0x0,%edx
mov %r13,%r14
imul %rax,%r14
mov %rdx,%rbx
imul %r12,%rbx
add %r14,%rbx
mul %r12
add %rdx,%rbx
mov %rbx,%rdx
movslq %esi,%rax
mov %rax,%r10
mov $0x0,%r11d
movslq %edi,%rax
mov %rax,%r8
mov $0x0,%r9d
mov %r11,%rdx
imul %r8,%rdx
mov %r9,%rax
imul %r10,%rax
lea (%rdx,%rax,1),%rbx
mov %r10,%rax
mul %r8
lea (%rbx,%rdx,1),%r8
mov %r8,%rdx
movslq %esi,%rdx
movslq %edi,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 1292 <func0+0x129>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 127b <func0+0x112>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 12bc <func0+0x153>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x58(%rbp)
jmpq 13d9 <func0+0x270>
mov -0x58(%rbp),%eax
cmp %eax,-0x68(%rbp)
cmovle -0x68(%rbp),%eax
mov %eax,-0x54(%rbp)
movl $0x0,-0x5c(%rbp)
jmpq 13c9 <func0+0x260>
cmpl $0x0,-0x5c(%rbp)
jne 1321 <func0+0x1b8>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rsi
mov -0x58(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
movl $0x1,(%rax,%rdx,4)
jmp 1395 <func0+0x22c>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x58(%rbp),%eax
lea -0x1(%rax),%r8d
mov -0x40(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rsi
movslq %r8d,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%edx
mov %rcx,%r8
shr $0x2,%r8
mov -0x58(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x5c(%rbp),%eax
lea -0x1(%rax),%edi
mov -0x40(%rbp),%rax
movslq %edi,%rdi
movslq %esi,%rsi
imul %r8,%rsi
add %rdi,%rsi
mov (%rax,%rsi,4),%eax
imul -0x5c(%rbp),%eax
mov %rcx,%r8
shr $0x2,%r8
lea (%rdx,%rax,1),%esi
mov -0x40(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rdi
mov -0x58(%rbp),%edx
movslq %edx,%rdx
imul %r8,%rdx
add %rdi,%rdx
mov %esi,(%rax,%rdx,4)
mov -0x5c(%rbp),%eax
cmp -0x68(%rbp),%eax
jge 13c5 <func0+0x25c>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x5c(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x40(%rbp),%rax
movslq %edx,%rsi
mov -0x58(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
movl $0x0,(%rax,%rdx,4)
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x54(%rbp),%eax
jle 12f4 <func0+0x18b>
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 12db <func0+0x172>
shr $0x2,%rcx
mov %rcx,%rsi
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rcx
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %rsi,%rdx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov %r15,%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 141d <func0+0x2b4>
callq 1060 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 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]
movsxd rax, edi
sub rax, 1
mov [rbp+var_30], rax
movsxd rax, edi
lea rsi, ds:0[rax*4]
movsxd rax, r8d
sub rax, 1
mov [rbp+var_28], rax
movsxd rax, edi
mov rcx, rax
mov ebx, 0
movsxd rax, r8d
mov rax, rax
mov edx, 0
mov r10, rbx
imul r10, rax
mov r9, rdx
imul r9, rcx
add r9, r10
mul rcx
lea rcx, [r9+rdx]
mov rdx, rcx
movsxd rax, edi
mov rcx, rax
mov ebx, 0
movsxd rax, r8d
mov rax, rax
mov edx, 0
mov r10, rbx
imul r10, rax
mov r9, rdx
imul r9, rcx
add r9, r10
mul rcx
lea rcx, [r9+rdx]
mov rdx, rcx
movsxd rdx, edi
movsxd rax, r8d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov ebx, 10h
mov edx, 0
div rbx
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_1260:
cmp rsp, rdx
jz short loc_1277
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_1260
loc_1277:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12A1
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12A1:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_3C], 0
jmp loc_13BE
loc_12C0:
mov edx, [rbp+var_48]
mov eax, [rbp+var_3C]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_34], eax
mov [rbp+var_38], 0
jmp loc_13AE
loc_12DA:
cmp [rbp+var_38], 0
jnz short loc_1307
mov rdi, rsi
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_38]
movsxd rcx, edx
mov edx, [rbp+var_3C]
movsxd rdx, edx
imul rdx, rdi
add rdx, rcx
mov dword ptr [rax+rdx*4], 1
jmp short loc_137A
loc_1307:
mov rdi, rsi
shr rdi, 2
mov eax, [rbp+var_3C]
lea r8d, [rax-1]
mov rax, [rbp+var_20]
mov edx, [rbp+var_38]
movsxd rcx, edx
movsxd rdx, r8d
imul rdx, rdi
add rdx, rcx
mov ecx, [rax+rdx*4]
mov r8, rsi
shr r8, 2
mov eax, [rbp+var_3C]
lea edx, [rax-1]
mov eax, [rbp+var_38]
lea edi, [rax-1]
mov rax, [rbp+var_20]
movsxd rdi, edi
movsxd rdx, edx
imul rdx, r8
add rdx, rdi
mov eax, [rax+rdx*4]
imul eax, [rbp+var_38]
mov r8, rsi
shr r8, 2
add ecx, eax
mov rax, [rbp+var_20]
mov edx, [rbp+var_38]
movsxd rdi, edx
mov edx, [rbp+var_3C]
movsxd rdx, edx
imul rdx, r8
add rdx, rdi
mov [rax+rdx*4], ecx
loc_137A:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_48]
jge short loc_13AA
mov rdi, rsi
shr rdi, 2
mov eax, [rbp+var_38]
lea edx, [rax+1]
mov rax, [rbp+var_20]
movsxd rcx, edx
mov edx, [rbp+var_3C]
movsxd rdx, edx
imul rdx, rdi
add rdx, rcx
mov dword ptr [rax+rdx*4], 0
loc_13AA:
add [rbp+var_38], 1
loc_13AE:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jle loc_12DA
add [rbp+var_3C], 1
loc_13BE:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_44]
jle loc_12C0
shr rsi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_48]
movsxd rcx, edx
mov edx, [rbp+var_44]
movsxd rdx, edx
imul rdx, rsi
add rdx, rcx
mov eax, [rax+rdx*4]
mov rsp, r11
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_13FF
call ___stack_chk_fail
loc_13FF:
mov rbx, [rbp+var_8]
leave
retn | 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-38h]
int v13; // [rsp+24h] [rbp-34h]
long long v14; // [rsp+28h] [rbp-30h]
long long v15; // [rsp+30h] [rbp-28h]
_BYTE *v16; // [rsp+38h] [rbp-20h]
unsigned long long v17; // [rsp+40h] [rbp-18h]
v10 = a1;
v9 = a2;
v17 = __readfsqword(0x28u);
v2 = a2 + 1;
v14 = a2 + 1 - 1LL;
v3 = 4LL * (a2 + 1);
v15 = v10 + 1 - 1LL;
v4 = 16 * ((4 * v2 * (long long)(v10 + 1) + 15) / 0x10uLL);
while ( v8 != &v8[-(v4 & 0xFFFFFFFFFFFFF000LL)] )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)&v8[(v4 & 0xFFF) - 8] = *(_QWORD *)&v8[(v4 & 0xFFF) - 8];
v16 = v8;
for ( i = 0; i <= v10; ++i )
{
v6 = i;
if ( v9 <= i )
v6 = v9;
v13 = v6;
for ( j = 0; j <= v13; ++j )
{
if ( j )
*(_DWORD *)&v16[4 * j + 4 * (v3 >> 2) * i] = j * *(_DWORD *)&v16[4 * j - 4 + 4 * (v3 >> 2) * (i - 1)]
+ *(_DWORD *)&v16[4 * j + 4 * (v3 >> 2) * (i - 1)];
else
*(_DWORD *)&v16[4 * (v3 >> 2) * i] = 1;
if ( j < v9 )
*(_DWORD *)&v16[4 * j + 4 + 4 * (v3 >> 2) * i] = 0;
}
}
return *(unsigned int *)&v16[4 * v9 + 4 * (v3 >> 2) * v10];
} | 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]
MOVSXD RAX,EDI
SUB RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOVSXD RAX,EDI
LEA RSI,[RAX*0x4]
MOVSXD RAX,R8D
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RAX,EDI
MOV RCX,RAX
MOV EBX,0x0
MOVSXD RAX,R8D
MOV RAX,RAX
MOV EDX,0x0
MOV R10,RBX
IMUL R10,RAX
MOV R9,RDX
IMUL R9,RCX
ADD R9,R10
MUL RCX
LEA RCX,[R9 + RDX*0x1]
MOV RDX,RCX
MOVSXD RAX,EDI
MOV RCX,RAX
MOV EBX,0x0
MOVSXD RAX,R8D
MOV RAX,RAX
MOV EDX,0x0
MOV R10,RBX
IMUL R10,RAX
MOV R9,RDX
IMUL R9,RCX
ADD R9,R10
MUL RCX
LEA RCX,[R9 + RDX*0x1]
MOV RDX,RCX
MOVSXD RDX,EDI
MOVSXD RAX,R8D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EBX,0x10
MOV EDX,0x0
DIV RBX
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_00101260:
CMP RSP,RDX
JZ 0x00101277
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101260
LAB_00101277:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012a1
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012a1:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001013be
LAB_001012c0:
MOV EDX,dword ptr [RBP + -0x48]
MOV EAX,dword ptr [RBP + -0x3c]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x34],EAX
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001013ae
LAB_001012da:
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x00101307
MOV RDI,RSI
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RCX
MOV dword ptr [RAX + RDX*0x4],0x1
JMP 0x0010137a
LAB_00101307:
MOV RDI,RSI
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x3c]
LEA R8D,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RCX,EDX
MOVSXD RDX,R8D
IMUL RDX,RDI
ADD RDX,RCX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV R8,RSI
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x3c]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x38]
LEA EDI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDI,EDI
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RDI
MOV EAX,dword ptr [RAX + RDX*0x4]
IMUL EAX,dword ptr [RBP + -0x38]
MOV R8,RSI
SHR R8,0x2
ADD ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDI,EDX
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RDI
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_0010137a:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x48]
JGE 0x001013aa
MOV RDI,RSI
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RCX
MOV dword ptr [RAX + RDX*0x4],0x0
LAB_001013aa:
ADD dword ptr [RBP + -0x38],0x1
LAB_001013ae:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x001012da
ADD dword ptr [RBP + -0x3c],0x1
LAB_001013be:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x001012c0
SHR RSI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x48]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
IMUL RDX,RSI
ADD RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,R11
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013ff
CALL 0x00101060
LAB_001013ff:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | 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;
local_50 = param_2;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
param_2 = param_2 + 1;
local_38 = (long)param_2 + -1;
uVar2 = (ulong)param_2;
local_30 = (long)(param_1 + 1) + -1;
uVar3 = (((long)(param_1 + 1) * (long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar4 = auStack_58; puVar4 != auStack_58 + -(uVar3 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
for (local_44 = 0; local_44 <= local_4c; local_44 = local_44 + 1) {
local_3c = local_44;
if (local_50 <= local_44) {
local_3c = local_50;
}
for (local_40 = 0; local_40 <= local_3c; local_40 = local_40 + 1) {
if (local_40 == 0) {
*(int4 *)(puVar4 + (long)local_44 * (uVar2 & 0x3fffffffffffffff) * 4 + lVar1) = 1;
}
else {
*(int *)(puVar4 + ((long)local_44 * (uVar2 & 0x3fffffffffffffff) + (long)local_40) * 4 +
lVar1) =
*(int *)(puVar4 + ((long)(local_44 + -1) * (uVar2 & 0x3fffffffffffffff) +
(long)local_40) * 4 + lVar1) +
*(int *)(puVar4 + ((long)(local_44 + -1) * (uVar2 & 0x3fffffffffffffff) +
(long)(local_40 + -1)) * 4 + lVar1) * local_40;
}
if (local_40 < local_50) {
*(int4 *)
(puVar4 + ((long)local_44 * (uVar2 & 0x3fffffffffffffff) + (long)(local_40 + 1)) * 4 +
lVar1) = 0;
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
local_28 = puVar4 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)
(puVar4 + ((long)local_4c * (uVar2 & 0x3fffffffffffffff) + (long)local_50) * 4 + lVar1);
} |
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];
}
if (j < k) {
P[i][j + 1] = 0;
}
}
}
return P[n][k];
}
| 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 %rcx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11dd <func0+0x74>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11c6 <func0+0x5d>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11f3 <func0+0x8a>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r9
mov %r9,-0x50(%rbp)
mov %r9,%r13
mov -0x44(%rbp),%eax
test %eax,%eax
js 1290 <func0+0x127>
mov %r9,%r10
mov %r12,%r15
shr $0x2,%r15
mov %r9,%rdi
sub %r12,%rdi
lea 0x1(%rax),%r14d
mov $0x0,%r11d
jmp 1270 <func0+0x107>
movl $0x1,0x0(%r13,%rbx,4)
jmp 124f <func0+0xe6>
lea 0x1(%rax),%rdx
cmp %r8,%rax
je 125e <func0+0xf5>
mov %rdx,%rax
mov %eax,%ecx
test %eax,%eax
je 1224 <func0+0xbb>
mov %eax,%edx
imul -0x4(%rdi,%rax,4),%edx
add (%rdi,%rax,4),%edx
mov %edx,(%r9,%rax,4)
cmp %esi,%ecx
jge 122f <func0+0xc6>
movl $0x0,0x4(%r10,%rax,4)
jmp 122f <func0+0xc6>
add $0x1,%r11d
add %r12,%r10
add %r12,%rdi
add %r12,%r9
cmp %r14d,%r11d
je 1290 <func0+0x127>
cmp %r11d,%esi
mov %r11d,%r8d
cmovle %esi,%r8d
test %r8d,%r8d
js 125e <func0+0xf5>
mov %r8d,%r8d
mov $0x0,%eax
movslq %r11d,%rbx
imul %r15,%rbx
jmp 123b <func0+0xd2>
movslq %esi,%rsi
movslq -0x44(%rbp),%rax
shr $0x2,%r12
imul %rax,%r12
lea (%rsi,%r12,1),%rax
mov -0x50(%rbp),%rbx
mov (%rbx,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 12c8 <func0+0x15f>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| 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, [rbx+1]
cdqe
imul rax, rdx
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11C6:
cmp rsp, rdx
jz short loc_11DD
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_11C6
loc_11DD:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11F3
or [rsp+rax+50h+var_58], 0
loc_11F3:
mov r13, rsp
mov eax, [rbp+var_44]
test eax, eax
js loc_1288
mov r10, r13
mov r15, r12
shr r15, 2
mov rsi, r13
sub rsi, r12
lea r14d, [rax+1]
mov r9, r13
mov r11d, 0
jmp short loc_1269
loc_1220:
mov dword ptr [r13+rbx*4+0], 1
jmp short loc_1248
loc_122B:
add rax, 1
cmp rax, r8
jz short loc_1257
loc_1234:
mov ecx, eax
test eax, eax
jz short loc_1220
mov edx, eax
imul edx, [rsi+rax*4-4]
add edx, [rsi+rax*4]
mov [r9+rax*4], edx
loc_1248:
cmp ecx, edi
jge short loc_122B
mov dword ptr [r10+rax*4+4], 0
jmp short loc_122B
loc_1257:
add r11d, 1
add r10, r12
add rsi, r12
add r9, r12
cmp r11d, r14d
jz short loc_1288
loc_1269:
cmp edi, r11d
mov eax, r11d
cmovle eax, edi
test eax, eax
js short loc_1257
lea r8d, [rax+1]
mov eax, 0
movsxd rbx, r11d
imul rbx, r15
jmp short loc_1234
loc_1288:
movsxd rax, edi
movsxd rdx, [rbp+var_44]
shr r12, 2
imul rdx, r12
add rax, rdx
mov eax, [r13+rax*4+0]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_12BD
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12BD:
call ___stack_chk_fail | 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; // r8
_DWORD v19[3]; // [rsp+8h] [rbp-50h] BYREF
int v20; // [rsp+14h] [rbp-44h]
unsigned long long v21; // [rsp+20h] [rbp-38h]
v20 = a1;
v21 = __readfsqword(0x28u);
v4 = a2 + 1;
v5 = 4 * v4;
v6 = (_DWORD *)((char *)v19 - ((4 * v4 * (a1 + 1) + 15) & 0xFFFFFFFFFFFFF000LL));
while ( v19 != v6 )
;
v7 = (4 * ((_WORD)a2 + 1) * ((_WORD)a1 + 1) + 15) & 0xFF0;
v8 = alloca(v7);
if ( ((4 * ((_WORD)a2 + 1) * ((_WORD)a1 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v19[-2] + v7) = *(_QWORD *)((char *)&v19[-2] + v7);
if ( v20 >= 0 )
{
v9 = v19;
v10 = &v19[v5 / 0xFFFFFFFFFFFFFFFCLL];
v11 = v20 + 1;
v12 = v19;
v13 = 0;
do
{
v15 = v13;
if ( a2 <= v13 )
v15 = a2;
if ( v15 >= 0 )
{
v16 = (unsigned int)(v15 + 1);
v14 = 0LL;
do
{
if ( (_DWORD)v14 )
v12[v14] = v10[v14] + v10[v14 - 1] * v14;
else
v19[(v5 >> 2) * v13] = 1;
if ( (int)v14 < a2 )
v9[v14 + 1] = 0;
++v14;
}
while ( v14 != v16 );
}
++v13;
v9 = (_DWORD *)((char *)v9 + v5);
v10 = (_DWORD *)((char *)v10 + v5);
v12 = (_DWORD *)((char *)v12 + v5);
}
while ( v13 != v11 );
}
return (unsigned int)v19[(v5 >> 2) * v20 + a2];
} | 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,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011c6:
CMP RSP,RDX
JZ 0x001011dd
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011c6
LAB_001011dd:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011f3
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011f3:
MOV R13,RSP
MOV EAX,dword ptr [RBP + -0x44]
TEST EAX,EAX
JS 0x00101288
MOV R10,R13
MOV R15,R12
SHR R15,0x2
MOV RSI,R13
SUB RSI,R12
LEA R14D,[RAX + 0x1]
MOV R9,R13
MOV R11D,0x0
JMP 0x00101269
LAB_00101220:
MOV dword ptr [R13 + RBX*0x4],0x1
JMP 0x00101248
LAB_0010122b:
ADD RAX,0x1
CMP RAX,R8
JZ 0x00101257
LAB_00101234:
MOV ECX,EAX
TEST EAX,EAX
JZ 0x00101220
MOV EDX,EAX
IMUL EDX,dword ptr [RSI + RAX*0x4 + -0x4]
ADD EDX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [R9 + RAX*0x4],EDX
LAB_00101248:
CMP ECX,EDI
JGE 0x0010122b
MOV dword ptr [R10 + RAX*0x4 + 0x4],0x0
JMP 0x0010122b
LAB_00101257:
ADD R11D,0x1
ADD R10,R12
ADD RSI,R12
ADD R9,R12
CMP R11D,R14D
JZ 0x00101288
LAB_00101269:
CMP EDI,R11D
MOV EAX,R11D
CMOVLE EAX,EDI
TEST EAX,EAX
JS 0x00101257
LEA R8D,[RAX + 0x1]
MOV EAX,0x0
MOVSXD RBX,R11D
IMUL RBX,R15
JMP 0x00101234
LAB_00101288:
MOVSXD RAX,EDI
MOVSXD RDX,dword ptr [RBP + -0x44]
SHR R12,0x2
IMUL RDX,R12
ADD RAX,RDX
MOV EAX,dword ptr [R13 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012bd
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001012bd:
CALL 0x00101060 | 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;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar7 = (ulong)(param_2 + 1);
lVar2 = uVar7 * 4;
uVar6 = (long)(param_1 + 1) * uVar7 * 4 + 0xf;
for (puVar8 = auStack_58; puVar8 != auStack_58 + -(uVar6 & 0xfffffffffffff000);
puVar8 = puVar8 + -0x1000) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar3 = -uVar6;
puVar10 = puVar8 + lVar3;
puVar11 = puVar8 + lVar3;
if (uVar6 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if (-1 < local_4c) {
puVar9 = puVar8 + uVar7 * -4 + lVar3;
iVar1 = local_4c + 1;
iVar12 = 0;
do {
iVar5 = iVar12;
if (param_2 <= iVar12) {
iVar5 = param_2;
}
if (-1 < iVar5) {
uVar6 = 0;
do {
iVar4 = (int)uVar6;
if (iVar4 == 0) {
*(int4 *)(puVar8 + (long)iVar12 * (uVar7 & 0x3fffffffffffffff) * 4 + lVar3) = 1;
}
else {
*(int *)(puVar10 + uVar6 * 4) =
iVar4 * *(int *)(puVar9 + uVar6 * 4 + -4) + *(int *)(puVar9 + uVar6 * 4);
}
if (iVar4 < param_2) {
*(int4 *)(puVar11 + uVar6 * 4 + 4) = 0;
}
uVar6 = uVar6 + 1;
} while (uVar6 != iVar5 + 1);
}
iVar12 = iVar12 + 1;
puVar11 = puVar11 + lVar2;
puVar9 = puVar9 + lVar2;
puVar10 = puVar10 + lVar2;
} while (iVar12 != iVar1);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)
(puVar8 + ((long)param_2 + (long)local_4c * (uVar7 & 0x3fffffffffffffff)) * 4 + lVar3);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar8 + lVar3 + -8) = main;
__stack_chk_fail();
} |
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];
}
if (j < k) {
P[i][j + 1] = 0;
}
}
}
return P[n][k];
}
| 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 %rdx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 1297 <func0+0x77>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1282 <func0+0x62>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 136e <func0+0x14e>
mov %r12,%r15
mov %rsp,%rbx
shr $0x2,%r15
test %r14d,%r14d
js 133f <func0+0x11f>
mov %r15,%rax
mov %rbx,%r9
xor %r11d,%r11d
neg %rax
lea (%rbx,%rax,4),%r8
nopl 0x0(%rax)
cmp %r11d,%esi
mov %r11d,%edx
cmovle %esi,%edx
xor %eax,%eax
movslq %edx,%r10
test %edx,%edx
js 1330 <func0+0x110>
movslq %r11d,%rdi
imul %r15,%rdi
jmp 1319 <func0+0xf9>
nopl 0x0(%rax,%rax,1)
mov -0x4(%r8,%rax,4),%edx
imul %eax,%edx
add (%r8,%rax,4),%edx
mov %edx,(%r9,%rax,4)
cmp %ecx,%esi
jle 130d <func0+0xed>
movl $0x0,0x4(%r9,%rax,4)
lea 0x1(%rax),%rdx
cmp %r10,%rax
je 1330 <func0+0x110>
mov %rdx,%rax
mov %eax,%ecx
test %rax,%rax
jne 12f0 <func0+0xd0>
movl $0x1,(%rbx,%rdi,4)
jmp 1300 <func0+0xe0>
nopl 0x0(%rax)
add $0x1,%r11d
add %r12,%r9
add %r12,%r8
cmp %r13d,%r11d
jne 12d0 <func0+0xb0>
movslq %r14d,%rax
movslq %esi,%rsi
imul %rax,%r15
lea (%rsi,%r15,1),%rax
mov (%rbx,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 1379 <func0+0x159>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 12a9 <func0+0x89>
callq 1060 <__stack_chk_fail@plt>
xchg %ax,%ax
| 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 rax, rdx
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1295
loc_1280:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_1280
loc_1295:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1369
loc_12A7:
mov r14, r12
mov rbx, rsp
shr r14, 2
test r13d, r13d
js loc_1340
mov rax, r14
mov rdi, rbx
xor r10d, r10d
neg rax
lea rsi, [rbx+rax*4]
nop word ptr [rax+rax+00h]
loc_12D0:
cmp r8d, r10d
mov edx, r10d
cmovle edx, r8d
xor eax, eax
lea r9d, [rdx+1]
movsxd r9, r9d
test edx, edx
js short loc_1328
movsxd r11, r10d
imul r11, r14
jmp short loc_1313
loc_12F0:
mov edx, [rsi+rax*4-4]
imul edx, eax
add edx, [rsi+rax*4]
mov [rdi+rax*4], edx
loc_12FD:
cmp r8d, ecx
jle short loc_130A
mov dword ptr [rdi+rax*4+4], 0
loc_130A:
add rax, 1
cmp r9, rax
jz short loc_1328
loc_1313:
mov ecx, eax
test rax, rax
jnz short loc_12F0
mov dword ptr [rbx+r11*4], 1
jmp short loc_12FD
loc_1328:
lea eax, [r10+1]
add rdi, r12
add rsi, r12
cmp r13d, r10d
jz short loc_1340
mov r10d, eax
jmp short loc_12D0
loc_1340:
imul r13, r14
movsxd rax, r8d
add rax, r13
mov eax, [rbx+rax*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_1374
lea rsp, [rbp-20h]
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_1369:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_12A7
loc_1374:
call ___stack_chk_fail | 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; // rsi
int v15; // edx
long long v16; // rax
_DWORD v19[1022]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v20[6]; // [rsp+1008h] [rbp-30h] BYREF
v3 = a2 + 1;
v4 = a1;
v5 = 4 * v3;
v20[1] = __readfsqword(0x28u);
v6 = 4 * v3 * (a1 + 1) + 15;
v7 = (_DWORD *)((char *)v20 - (v6 & 0xFFFFFFFFFFFFF000LL));
v8 = v6 & 0xFFF0;
if ( v20 != (_QWORD *)v7 )
{
while ( v19 != v7 )
;
}
v9 = v8 & 0xFFF;
v10 = alloca(v9);
if ( v9 )
*(_QWORD *)((char *)&v19[-2] + v9) = *(_QWORD *)((char *)&v19[-2] + v9);
v11 = v5 >> 2;
if ( a1 >= 0 )
{
v12 = v19;
v13 = 0;
v14 = &v19[-v11];
while ( 1 )
{
v15 = v13;
if ( a2 <= v13 )
v15 = a2;
v16 = 0LL;
if ( v15 >= 0 )
{
do
{
if ( v16 )
v12[v16] = v14[v16] + v16 * v14[v16 - 1];
else
v19[v11 * v13] = 1;
if ( a2 > (int)v16 )
v12[v16 + 1] = 0;
++v16;
}
while ( v15 + 1 != v16 );
}
v12 = (_DWORD *)((char *)v12 + v5);
v14 = (_DWORD *)((char *)v14 + v5);
if ( (_DWORD)v4 == v13 )
break;
++v13;
}
}
return (unsigned int)v19[v11 * v4 + a2];
} | 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,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101295
LAB_00101280:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101280
LAB_00101295:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101369
LAB_001012a7:
MOV R14,R12
MOV RBX,RSP
SHR R14,0x2
TEST R13D,R13D
JS 0x00101340
MOV RAX,R14
MOV RDI,RBX
XOR R10D,R10D
NEG RAX
LEA RSI,[RBX + RAX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
CMP R8D,R10D
MOV EDX,R10D
CMOVLE EDX,R8D
XOR EAX,EAX
LEA R9D,[RDX + 0x1]
MOVSXD R9,R9D
TEST EDX,EDX
JS 0x00101328
MOVSXD R11,R10D
IMUL R11,R14
JMP 0x00101313
LAB_001012f0:
MOV EDX,dword ptr [RSI + RAX*0x4 + -0x4]
IMUL EDX,EAX
ADD EDX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
LAB_001012fd:
CMP R8D,ECX
JLE 0x0010130a
MOV dword ptr [RDI + RAX*0x4 + 0x4],0x0
LAB_0010130a:
ADD RAX,0x1
CMP R9,RAX
JZ 0x00101328
LAB_00101313:
MOV ECX,EAX
TEST RAX,RAX
JNZ 0x001012f0
MOV dword ptr [RBX + R11*0x4],0x1
JMP 0x001012fd
LAB_00101328:
LEA EAX,[R10 + 0x1]
ADD RDI,R12
ADD RSI,R12
CMP R13D,R10D
JZ 0x00101340
MOV R10D,EAX
JMP 0x001012d0
LAB_00101340:
IMUL R13,R14
MOVSXD RAX,R8D
ADD RAX,R13
MOV EAX,dword ptr [RBX + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101374
LEA RSP,[RBP + -0x20]
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00101369:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012a7
LAB_00101374:
CALL 0x00101060 | 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;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar10 = (long)(param_1 + 1) * uVar4 * 4 + 0xf;
puVar6 = auStack_38;
puVar8 = auStack_38;
while (puVar6 != auStack_38 + -(uVar10 & 0xfffffffffffff000)) {
puVar5 = puVar8 + -0x1000;
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
puVar6 = puVar8 + -0x1000;
puVar8 = puVar8 + -0x1000;
}
uVar10 = (ulong)((uint)uVar10 & 0xff0);
lVar1 = -uVar10;
puVar8 = puVar5 + lVar1;
if (uVar10 != 0) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
uVar10 = uVar4 & 0x3fffffffffffffff;
if (-1 < param_1) {
puVar7 = puVar5 + uVar10 * -4 + lVar1;
iVar9 = 0;
do {
iVar3 = iVar9;
if (param_2 <= iVar9) {
iVar3 = param_2;
}
lVar2 = 0;
if (-1 < iVar3) {
do {
if (lVar2 == 0) {
*(int4 *)(puVar5 + (long)iVar9 * uVar10 * 4 + lVar1) = 1;
}
else {
*(int *)(puVar8 + lVar2 * 4) =
*(int *)(puVar7 + lVar2 * 4 + -4) * (int)lVar2 + *(int *)(puVar7 + lVar2 * 4);
}
if ((int)lVar2 < param_2) {
*(int4 *)(puVar8 + lVar2 * 4 + 4) = 0;
}
lVar2 = lVar2 + 1;
} while (iVar3 + 1 != lVar2);
}
puVar8 = puVar8 + uVar4 * 4;
puVar7 = puVar7 + uVar4 * 4;
bVar11 = param_1 != iVar9;
iVar9 = iVar9 + 1;
} while (bVar11);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar5 + ((long)param_2 + (long)param_1 * uVar10) * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar5 + lVar1 + -8) = 0x101379;
__stack_chk_fail();
} |
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];
}
if (j < k) {
P[i][j + 1] = 0;
}
}
}
return P[n][k];
}
| 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,-0x58(%rbp)
movslq %edx,%rax
imul %rcx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 129b <func0+0x7b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1286 <func0+0x66>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 141f <func0+0x1ff>
mov -0x58(%rbp),%rax
mov %rsp,%r10
shr $0x2,%rax
mov %rax,-0x60(%rbp)
test %edi,%edi
js 142a <func0+0x20a>
mov %rax,%r14
neg %rax
mov %r10,%rsi
mov $0xffffffffffffffff,%r15
lea (%r10,%rax,4),%rbx
movslq %edi,%rax
xor %r12d,%r12d
mov %rax,-0x50(%rbp)
nopw 0x0(%rax,%rax,1)
cmp %r12d,%r13d
mov %r12d,%r8d
mov %r12d,-0x44(%rbp)
cmovle %r13d,%r8d
test %r8d,%r8d
js 13c8 <func0+0x1a8>
test %r13d,%r13d
jle 1418 <func0+0x1f8>
lea 0x1(%r8),%r9d
movslq -0x44(%rbp),%r11
mov %r15,%rdi
mov %rsi,%rdx
cmp %r13d,%r9d
cmovg %r13d,%r9d
imul %r14,%r11
sub %r12,%rdi
xor %eax,%eax
imul %r14,%rdi
nopw 0x0(%rax,%rax,1)
test %eax,%eax
jne 1351 <func0+0x131>
movl $0x1,(%r10,%r11,4)
add $0x4,%rdx
mov $0x1,%eax
movl $0x0,(%rdx)
cmp $0x1,%r9d
je 1370 <func0+0x150>
mov -0x4(%rdx,%rdi,4),%ecx
imul %eax,%ecx
add $0x1,%eax
add (%rdx,%rdi,4),%ecx
movl $0x0,0x4(%rdx)
mov %ecx,(%rdx)
add $0x4,%rdx
cmp %r9d,%eax
jl 1330 <func0+0x110>
cmp %eax,%r8d
jl 13c8 <func0+0x1a8>
movslq -0x44(%rbp),%rdi
movslq %r15d,%rcx
cltq
imul %r14,%rcx
imul %r14,%rdi
jmp 13b3 <func0+0x193>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rax),%edx
movslq %edx,%rdx
add %rcx,%rdx
mov (%r10,%rdx,4),%r11d
mov (%rbx,%rax,4),%edx
imul %eax,%r11d
add %r11d,%edx
mov %edx,(%rsi,%rax,4)
add $0x1,%rax
cmp %eax,%r8d
jl 13c8 <func0+0x1a8>
test %eax,%eax
jne 1390 <func0+0x170>
add $0x1,%rax
movl $0x1,(%r10,%rdi,4)
cmp %eax,%r8d
jge 13b3 <func0+0x193>
mov -0x58(%rbp),%rax
add $0x1,%r12
add $0x1,%r15
add %rax,%rsi
add %rax,%rbx
cmp -0x50(%rbp),%r15
jne 12e8 <func0+0xc8>
mov -0x50(%rbp),%rdx
imul -0x60(%rbp),%rdx
movslq %r13d,%rax
add %rdx,%rax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%r10,%rax,4),%eax
jne 1433 <func0+0x213>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopl (%rax)
xor %eax,%eax
jmpq 1375 <func0+0x155>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 12ad <func0+0x8d>
movslq %edi,%rax
mov %rax,-0x50(%rbp)
jmp 13e4 <func0+0x1c4>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| 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
cdqe
imul rax, rcx
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_1295
loc_1280:
sub rsp, 1000h
or [rsp+1050h+var_58], 0
cmp rsp, rsi
jnz short loc_1280
loc_1295:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_1422
loc_12A7:
mov rsi, r15
mov r9, rsp
shr rsi, 2
test edx, edx
js loc_142D
mov rax, rsi
mov r8, r9
mov r14, 0FFFFFFFFFFFFFFFFh
xor r13d, r13d
neg rax
lea rbx, [r9+rax*4]
movsxd rax, edx
mov [rbp+var_50], rax
nop word ptr [rax+rax+00000000h]
loc_12E0:
mov ecx, r13d
cmp r10d, r13d
movsxd rdi, r13d
cmovle ecx, r10d
test ecx, ecx
js loc_137F
test r10d, r10d
jle loc_13D0
lea r12d, [rcx+1]
movsxd rax, edi
cmp r12d, r10d
cmovg r12d, r10d
imul rax, rsi
mov dword ptr [r9+rax*4], 1
mov eax, 1
mov dword ptr [r8+4], 0
cmp r12d, 1
jnz loc_13E0
nop
loc_1330:
cmp ecx, eax
jl short loc_137F
loc_1334:
movsxd r11, r14d
imul rdi, rsi
cdqe
imul r11, rsi
jmp short loc_136B
loc_1348:
lea edx, [rax-1]
movsxd rdx, edx
add rdx, r11
mov r12d, [r9+rdx*4]
mov edx, [rbx+rax*4]
imul r12d, eax
add edx, r12d
mov [r8+rax*4], edx
add rax, 1
cmp ecx, eax
jl short loc_137F
loc_136B:
test eax, eax
jnz short loc_1348
add rax, 1
mov dword ptr [r9+rdi*4], 1
cmp ecx, eax
jge short loc_136B
loc_137F:
mov rax, [rbp+var_50]
add r14, 1
add r13, 1
add rbx, r15
add r8, r15
cmp r14, rax
jnz loc_12E0
loc_139A:
mov rdx, rax
movsxd rax, r10d
imul rdx, rsi
add rax, rdx
mov eax, [r9+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1439
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13D0:
xor eax, eax
jmp loc_1334
loc_13E0:
mov r11, r14
mov [rbp+var_44], ecx
lea rdx, [r8+4]
mov ecx, r12d
sub r11, r13
imul r11, rsi
nop dword ptr [rax+00h]
loc_13F8:
mov r12d, [rdx+r11*4-4]
imul r12d, eax
add eax, 1
add r12d, [rdx+r11*4]
add rdx, 4
mov [rdx-4], r12d
mov dword ptr [rdx], 0
cmp eax, ecx
jl short loc_13F8
mov ecx, [rbp+var_44]
jmp loc_1330
loc_1422:
or [rsp+rcx+1050h+var_1058], 0
jmp loc_12A7
loc_142D:
movsxd rax, edx
mov [rbp+var_50], rax
jmp loc_139A
loc_1439:
call ___stack_chk_fail | 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 *v14; // rbx
int v15; // ecx
int v16; // r12d
long long v17; // rax
long long v18; // rax
_DWORD *v20; // rdx
int v21; // ecx
long long v22; // r11
int v23; // r12d
unsigned int v24; // r12d
_DWORD v26[1022]; // [rsp+8h] [rbp-1050h] BYREF
long long v27; // [rsp+1008h] [rbp-50h] BYREF
int v28; // [rsp+1014h] [rbp-44h]
unsigned long long v29; // [rsp+1020h] [rbp-38h]
v3 = a2 + 1;
v4 = 4 * v3;
v29 = __readfsqword(0x28u);
v5 = 4 * v3 * (a1 + 1) + 15;
v6 = (long long *)((char *)&v27 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( &v27 != v6 )
{
while ( v26 != (_DWORD *)v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)((char *)&v26[-2] + v8) = *(_QWORD *)((char *)&v26[-2] + v8);
v10 = v4 >> 2;
if ( a1 >= 0 )
{
v11 = v26;
v12 = -1LL;
v13 = 0LL;
v14 = &v26[-v10];
v27 = a1;
while ( 1 )
{
v15 = v13;
if ( a2 <= (int)v13 )
v15 = a2;
if ( v15 >= 0 )
{
if ( a2 <= 0 )
{
LODWORD(v17) = 0;
LABEL_15:
v17 = (int)v17;
do
{
while ( (_DWORD)v17 )
{
v11[v17] = v17 * v26[v10 * (int)v12 - 1 + (int)v17] + v14[v17];
if ( v15 < (int)++v17 )
goto LABEL_19;
}
++v17;
v26[v10 * (int)v13] = 1;
}
while ( v15 >= (int)v17 );
goto LABEL_19;
}
v16 = v15 + 1;
if ( v15 + 1 > a2 )
v16 = a2;
v26[v10 * (int)v13] = 1;
LODWORD(v17) = 1;
v11[1] = 0;
if ( v16 != 1 )
{
v28 = v15;
v20 = v11 + 1;
v21 = v16;
v22 = v10 * (v12 - v13);
do
{
v23 = v17 * v20[v22 - 1];
LODWORD(v17) = v17 + 1;
v24 = v20[v22] + v23;
*(_QWORD *)v20++ = v24;
}
while ( (int)v17 < v21 );
v15 = v28;
}
if ( v15 >= (int)v17 )
goto LABEL_15;
}
LABEL_19:
v18 = v27;
++v12;
++v13;
v14 = (_DWORD *)((char *)v14 + v4);
v11 = (_DWORD *)((char *)v11 + v4);
if ( v12 == v27 )
return (unsigned int)v26[v10 * v18 + a2];
}
}
v18 = a1;
v27 = a1;
return (unsigned int)v26[v10 * v18 + a2];
} | 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]
MOV RCX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x00101295
LAB_00101280:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x00101280
LAB_00101295:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x00101422
LAB_001012a7:
MOV RSI,R15
MOV R9,RSP
SHR RSI,0x2
TEST EDX,EDX
JS 0x0010142d
MOV RAX,RSI
MOV R8,R9
MOV R14,-0x1
XOR R13D,R13D
NEG RAX
LEA RBX,[R9 + RAX*0x4]
MOVSXD RAX,EDX
MOV qword ptr [RBP + -0x50],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_001012e0:
MOV ECX,R13D
CMP R10D,R13D
MOVSXD RDI,R13D
CMOVLE ECX,R10D
TEST ECX,ECX
JS 0x0010137f
TEST R10D,R10D
JLE 0x001013d0
LEA R12D,[RCX + 0x1]
MOVSXD RAX,EDI
CMP R12D,R10D
CMOVG R12D,R10D
IMUL RAX,RSI
MOV dword ptr [R9 + RAX*0x4],0x1
MOV EAX,0x1
MOV dword ptr [R8 + 0x4],0x0
CMP R12D,0x1
JNZ 0x001013e0
NOP
LAB_00101330:
CMP ECX,EAX
JL 0x0010137f
LAB_00101334:
MOVSXD R11,R14D
IMUL RDI,RSI
CDQE
IMUL R11,RSI
JMP 0x0010136b
LAB_00101348:
LEA EDX,[RAX + -0x1]
MOVSXD RDX,EDX
ADD RDX,R11
MOV R12D,dword ptr [R9 + RDX*0x4]
MOV EDX,dword ptr [RBX + RAX*0x4]
IMUL R12D,EAX
ADD EDX,R12D
MOV dword ptr [R8 + RAX*0x4],EDX
ADD RAX,0x1
CMP ECX,EAX
JL 0x0010137f
LAB_0010136b:
TEST EAX,EAX
JNZ 0x00101348
ADD RAX,0x1
MOV dword ptr [R9 + RDI*0x4],0x1
CMP ECX,EAX
JGE 0x0010136b
LAB_0010137f:
MOV RAX,qword ptr [RBP + -0x50]
ADD R14,0x1
ADD R13,0x1
ADD RBX,R15
ADD R8,R15
CMP R14,RAX
JNZ 0x001012e0
LAB_0010139a:
MOV RDX,RAX
MOVSXD RAX,R10D
IMUL RDX,RSI
ADD RAX,RDX
MOV EAX,dword ptr [R9 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101439
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001013d0:
XOR EAX,EAX
JMP 0x00101334
LAB_001013e0:
MOV R11,R14
MOV dword ptr [RBP + -0x44],ECX
LEA RDX,[R8 + 0x4]
MOV ECX,R12D
SUB R11,R13
IMUL R11,RSI
NOP dword ptr [RAX]
LAB_001013f8:
MOV R12D,dword ptr [RDX + R11*0x4 + -0x4]
IMUL R12D,EAX
ADD EAX,0x1
ADD R12D,dword ptr [RDX + R11*0x4]
ADD RDX,0x4
MOV dword ptr [RDX + -0x4],R12D
MOV dword ptr [RDX],0x0
CMP EAX,ECX
JL 0x001013f8
MOV ECX,dword ptr [RBP + -0x44]
JMP 0x00101330
LAB_00101422:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x001012a7
LAB_0010142d:
MOVSXD RAX,EDX
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0010139a
LAB_00101439:
CALL 0x00101060 | 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 local_4c;
long local_40;
long *plVar10;
uVar6 = (ulong)(param_2 + 1);
plVar9 = &local_58;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar11 = (long)(param_1 + 1) * uVar6 * 4 + 0xf;
plVar10 = &local_58;
plVar2 = &local_58;
while (plVar10 != (long *)((long)&local_58 - (uVar11 & 0xfffffffffffff000))) {
plVar9 = (long *)((long)plVar2 + -0x1000);
*(int8 *)((long)plVar2 + -8) = *(int8 *)((long)plVar2 + -8);
plVar10 = (long *)((long)plVar2 + -0x1000);
plVar2 = (long *)((long)plVar2 + -0x1000);
}
uVar11 = (ulong)((uint)uVar11 & 0xff0);
lVar1 = -uVar11;
puVar12 = (int *)((long)plVar9 + lVar1);
if (uVar11 != 0) {
*(int8 *)((long)plVar9 + -8) = *(int8 *)((long)plVar9 + -8);
}
uVar11 = uVar6 & 0x3fffffffffffffff;
if (param_1 < 0) {
local_58 = (long)param_1;
}
else {
lVar17 = -1;
lVar16 = 0;
puVar8 = (int *)((long)plVar9 + uVar11 * -4 + lVar1);
local_58 = (long)param_1;
do {
iVar15 = (int)lVar16;
iVar5 = iVar15;
if (param_2 <= iVar15) {
iVar5 = param_2;
}
if (-1 < iVar5) {
if (param_2 < 1) {
iVar3 = 0;
}
else {
iVar13 = iVar5 + 1;
if (param_2 < iVar5 + 1) {
iVar13 = param_2;
}
*(int4 *)((long)plVar9 + (long)iVar15 * uVar11 * 4 + lVar1) = 1;
iVar3 = 1;
*(int4 *)(puVar12 + 4) = 0;
if (iVar13 != 1) {
lVar4 = (lVar17 - lVar16) * uVar11;
piVar7 = (int *)(puVar12 + 4);
do {
iVar14 = piVar7[lVar4 + -1] * iVar3;
iVar3 = iVar3 + 1;
*piVar7 = iVar14 + piVar7[lVar4];
piVar7[1] = 0;
piVar7 = piVar7 + 1;
local_4c = iVar5;
} while (iVar3 < iVar13);
}
if (iVar5 < iVar3) goto LAB_0010137f;
}
lVar4 = (long)iVar3;
do {
while (iVar3 = (int)lVar4, iVar3 != 0) {
*(int *)(puVar12 + lVar4 * 4) =
*(int *)(puVar8 + lVar4 * 4) +
*(int *)((long)plVar9 +
((long)(iVar3 + -1) + (long)(int)lVar17 * uVar11) * 4 + lVar1) * iVar3;
lVar4 = lVar4 + 1;
if (iVar5 < (int)lVar4) goto LAB_0010137f;
}
lVar4 = lVar4 + 1;
*(int4 *)((long)plVar9 + (long)iVar15 * uVar11 * 4 + lVar1) = 1;
} while ((int)lVar4 <= iVar5);
}
LAB_0010137f:
lVar17 = lVar17 + 1;
lVar16 = lVar16 + 1;
puVar8 = puVar8 + uVar6 * 4;
puVar12 = puVar12 + uVar6 * 4;
} while (lVar17 != local_58);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)plVar9 + ((long)param_2 + local_58 * uVar11) * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(int8 *)((long)plVar9 + lVar1 + -8) = 0x10143e;
__stack_chk_fail();
} |
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) * sizeof(char *));
list1_size--;
i--;
break;
}
}
}
list1[list1_size] = NULL;
}
| 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 *remove2[] = {"black", "orange", NULL};
char *expected2[] = {"red", "green", "blue", "white", NULL};
char *test_list3[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove3[] = {"blue", "white", NULL};
char *expected3[] = {"red", "green", "black", "orange", NULL};
func0(test_list1, 6, remove1, 2);
for (int i = 0; test_list1[i] != NULL; i++) {
assert(strcmp(test_list1[i], expected1[i]) == 0);
}
func0(test_list2, 6, remove2, 2);
for (int i = 0; test_list2[i] != NULL; i++) {
assert(strcmp(test_list2[i], expected2[i]) == 0);
}
func0(test_list3, 6, remove3, 2);
for (int i = 0; test_list3[i] != NULL; i++) {
assert(strcmp(test_list3[i], expected3[i]) == 0);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
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(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10a0 <strcmp@plt>
test %eax,%eax
jne 126c <func0+0xc3>
mov -0x1c(%rbp),%eax
sub -0x8(%rbp),%eax
sub $0x1,%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rax,%rcx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rsi
mov -0x18(%rbp),%rax
add %rsi,%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 10b0 <memmove@plt>
subl $0x1,-0x1c(%rbp)
subl $0x1,-0x8(%rbp)
jmp 127c <func0+0xd3>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11db <func0+0x32>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11cf <func0+0x26>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movq $0x0,(%rax)
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [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]
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_126C
mov eax, [rbp+var_1C]
sub eax, [rbp+var_8]
sub eax, 1
cdqe
lea rdx, ds:0[rax*8]; n
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rcx, rax
mov eax, [rbp+var_8]
cdqe
lea rsi, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rsi
mov rsi, rcx; src
mov rdi, rax; dest
call _memmove
sub [rbp+var_1C], 1
sub [rbp+var_8], 1
jmp short loc_127C
loc_126C:
add [rbp+var_4], 1
loc_1270:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jl loc_11DB
loc_127C:
add [rbp+var_8], 1
loc_1280:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_11CF
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov qword ptr [rax], 0
nop
leave
retn | _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)) )
{
memmove((void *)(8LL * i + a1), (const void *)(a1 + 8 * (i + 1LL)), 8LL * (a2 - i - 1));
--a2;
--i;
break;
}
}
}
result = (_QWORD *)(8LL * a2 + a1);
*result = 0LL;
return result;
} | 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 + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010a0
TEST EAX,EAX
JNZ 0x0010126c
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,dword ptr [RBP + -0x8]
SUB EAX,0x1
CDQE
LEA RDX,[RAX*0x8]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RCX,RAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RSI,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RSI
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010b0
SUB dword ptr [RBP + -0x1c],0x1
SUB dword ptr [RBP + -0x8],0x1
JMP 0x0010127c
LAB_0010126c:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101270:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011db
LAB_0010127c:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101280:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011cf
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV qword ptr [RAX],0x0
NOP
LEAVE
RET | 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; local_c = local_c + 1) {
iVar1 = strcmp(*(char **)(param_1 + (long)local_10 * 8),
*(char **)(param_3 + (long)local_c * 8));
if (iVar1 == 0) {
memmove((void *)(param_1 + (long)local_10 * 8),(void *)(((long)local_10 + 1) * 8 + param_1),
(long)((local_24 - local_10) + -1) * 8);
local_24 = local_24 + -1;
local_10 = local_10 + -1;
break;
}
}
local_10 = local_10 + 1;
} while( true );
} |
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) * sizeof(char *));
list1_size--;
i--;
break;
}
}
}
list1[list1_size] = NULL;
}
| 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 *remove2[] = {"black", "orange", NULL};
char *expected2[] = {"red", "green", "blue", "white", NULL};
char *test_list3[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove3[] = {"blue", "white", NULL};
char *expected3[] = {"red", "green", "black", "orange", NULL};
func0(test_list1, 6, remove1, 2);
for (int i = 0; test_list1[i] != NULL; i++) {
assert(strcmp(test_list1[i], expected1[i]) == 0);
}
func0(test_list2, 6, remove2, 2);
for (int i = 0; test_list2[i] != NULL; i++) {
assert(strcmp(test_list2[i], expected2[i]) == 0);
}
func0(test_list3, 6, remove3, 2);
for (int i = 0; test_list3[i] != NULL; i++) {
assert(strcmp(test_list3[i], expected3[i]) == 0);
}
return 0;
}
| 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+0x6e>
mov %r15d,%edx
sub %r13d,%edx
sub $0x1,%edx
movslq %edx,%rdx
shl $0x3,%rdx
mov (%rsp),%rax
lea 0x8(%rax,%r14,1),%rsi
mov 0x8(%rsp),%rdi
callq 10b0 <memmove@plt>
sub $0x1,%r15d
sub $0x1,%r13d
add $0x1,%r13d
cmp %r13d,%r15d
jle 1253 <func0+0xaa>
cmpl $0x0,0x14(%rsp)
jle 120e <func0+0x65>
movslq %r13d,%r14
shl $0x3,%r14
mov (%rsp),%rax
add %r14,%rax
mov %rax,0x8(%rsp)
mov (%rax),%rbp
mov 0x18(%rsp),%rbx
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10a0 <strcmp@plt>
test %eax,%eax
je 11e3 <func0+0x3a>
add $0x8,%rbx
cmp %r12,%rbx
jne 1239 <func0+0x90>
jmp 120e <func0+0x65>
movslq %r15d,%r15
mov (%rsp),%rax
movq $0x0,(%rax,%r15,8)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 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 short loc_121A
loc_11E3:
mov edx, r14d
sub edx, r13d
sub edx, 1
movsxd rdx, edx
shl rdx, 3
mov rax, [rsp+58h+var_58]
mov rcx, [rsp+58h+var_50]
lea rsi, [rax+rcx+8]
mov rdi, r15
call _memmove
sub r14d, 1
sub r13d, 1
loc_1211:
add r13d, 1
cmp r14d, r13d
jle short loc_1256
loc_121A:
cmp [rsp+58h+var_44], 0
jle short loc_1211
movsxd rax, r13d
shl rax, 3
mov [rsp+58h+var_50], rax
mov r15, [rsp+58h+var_58]
add r15, rax
mov rbp, [r15]
mov rbx, [rsp+58h+var_40]
loc_123C:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_11E3
add rbx, 8
cmp rbx, r12
jnz short loc_123C
jmp short loc_1211
loc_1256:
movsxd r14, r14d
mov rax, [rsp+58h+var_58]
mov qword ptr [rax+r14*8], 0
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | 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];
v6 = 0;
do
{
if ( a4 > 0 )
{
v10 = 8LL * v6;
v7 = *(_QWORD *)(v10 + a1);
v8 = a3;
while ( (unsigned int)strcmp(v7, *v8) )
{
if ( ++v8 == (_QWORD *)v5 )
goto LABEL_4;
}
memmove(v10 + a1, a1 + v10 + 8, 8LL * (v4 - v6 - 1));
--v4;
--v6;
}
LABEL_4:
++v6;
}
while ( v4 > v6 );
}
result = a1;
*(_QWORD *)(a1 + 8LL * v4) = 0LL;
return result;
} | 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 EDX,R13D
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x3
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
LEA RSI,[RAX + RCX*0x1 + 0x8]
MOV RDI,R15
CALL 0x001010b0
SUB R14D,0x1
SUB R13D,0x1
LAB_00101211:
ADD R13D,0x1
CMP R14D,R13D
JLE 0x00101256
LAB_0010121a:
CMP dword ptr [RSP + 0x14],0x0
JLE 0x00101211
MOVSXD RAX,R13D
SHL RAX,0x3
MOV qword ptr [RSP + 0x8],RAX
MOV R15,qword ptr [RSP]
ADD R15,RAX
MOV RBP,qword ptr [R15]
MOV RBX,qword ptr [RSP + 0x18]
LAB_0010123c:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010a0
TEST EAX,EAX
JZ 0x001011e3
ADD RBX,0x8
CMP RBX,R12
JNZ 0x0010123c
JMP 0x00101211
LAB_00101256:
MOVSXD R14,R14D
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX + R14*0x8],0x0
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | 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_3;
do {
iVar1 = strcmp(__s1,(char *)*puVar2);
if (iVar1 == 0) {
memmove(__dest,(void *)(param_1 + 8 + (long)iVar3 * 8),
(long)((param_2 - iVar3) + -1) << 3);
param_2 = param_2 + -1;
iVar3 = iVar3 + -1;
break;
}
puVar2 = puVar2 + 1;
} while (puVar2 != param_3 + (ulong)(param_4 - 1) + 1);
}
iVar3 = iVar3 + 1;
} while (iVar3 < param_2);
}
*(int8 *)(param_1 + (long)param_2 * 8) = 0;
return;
} |
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) * sizeof(char *));
list1_size--;
i--;
break;
}
}
}
list1[list1_size] = NULL;
}
| 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 *remove2[] = {"black", "orange", NULL};
char *expected2[] = {"red", "green", "blue", "white", NULL};
char *test_list3[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove3[] = {"blue", "white", NULL};
char *expected3[] = {"red", "green", "black", "orange", NULL};
func0(test_list1, 6, remove1, 2);
for (int i = 0; test_list1[i] != NULL; i++) {
assert(strcmp(test_list1[i], expected1[i]) == 0);
}
func0(test_list2, 6, remove2, 2);
for (int i = 0; test_list2[i] != NULL; i++) {
assert(strcmp(test_list2[i], expected2[i]) == 0);
}
func0(test_list3, 6, remove3, 2);
for (int i = 0; test_list3[i] != NULL; i++) {
assert(strcmp(test_list3[i], expected3[i]) == 0);
}
return 0;
}
| 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 0x0(%rax,%rax,1)
mov 0x14(%rsp),%eax
test %eax,%eax
jle 15d0 <func0+0xe0>
movslq %r13d,%r12
mov (%rsp),%r15
lea 0x0(,%r12,8),%rax
mov 0x18(%rsp),%r12
add %rax,%r15
mov %rax,0x8(%rsp)
mov (%r15),%rbx
jmp 1569 <func0+0x79>
nopl (%rax)
add $0x8,%r12
cmp %r12,%rbp
je 15d0 <func0+0xe0>
mov (%r12),%rsi
mov %rbx,%rdi
callq 10a0 <strcmp@plt>
test %eax,%eax
jne 1560 <func0+0x70>
mov %r14d,%edx
mov (%rsp),%rax
mov 0x8(%rsp),%rcx
mov %r15,%rdi
sub %r13d,%edx
sub $0x1,%r14d
sub $0x1,%edx
lea 0x8(%rax,%rcx,1),%rsi
movslq %edx,%rdx
shl $0x3,%rdx
callq 10b0 <memmove@plt>
cmp %r13d,%r14d
jg 1530 <func0+0x40>
mov (%rsp),%rax
movslq %r14d,%r14
movq $0x0,(%rax,%r14,8)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%r13d
jmp 15a3 <func0+0xb3>
nopw %cs:0x0(%rax,%rax,1)
| 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+8]
nop word ptr [rax+rax+00000000h]
loc_1530:
mov eax, [rsp+58h+var_44]
test eax, eax
jle loc_15D0
movsxd r12, r13d
mov r15, [rsp+58h+var_58]
lea rax, ds:0[r12*8]
mov r12, [rsp+58h+var_40]
add r15, rax
mov [rsp+58h+var_50], rax
mov rbx, [r15]
jmp short loc_1569
loc_1560:
add r12, 8
cmp rbp, r12
jz short loc_15D0
loc_1569:
mov rsi, [r12]
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_1560
mov edx, r14d
mov rax, [rsp+58h+var_58]
mov rcx, [rsp+58h+var_50]
mov rdi, r15
sub edx, r13d
sub r14d, 1
sub edx, 1
lea rsi, [rax+rcx+8]
movsxd rdx, edx
shl rdx, 3
call _memmove
loc_15A3:
cmp r14d, r13d
jg short loc_1530
loc_15A8:
mov rax, [rsp+58h+var_58]
movsxd r14, r14d
mov qword ptr [rax+r14*8], 0
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15D0:
add r13d, 1
jmp short loc_15A3 | 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 - 1) + 1];
do
{
if ( a4 <= 0 )
{
LABEL_10:
++v5;
}
else
{
v7 = a3;
v8 = (long long *)(8LL * v5 + a1);
v9 = *v8;
while ( (unsigned int)strcmp(v9, *v7) )
{
if ( (_QWORD *)v6 == ++v7 )
goto LABEL_10;
}
v10 = v4 - v5;
--v4;
memmove(v8, a1 + 8LL * v5 + 8, 8LL * (v10 - 1));
}
}
while ( v4 > v5 );
}
result = a1;
*(_QWORD *)(a1 + 8LL * v4) = 0LL;
return result;
} | 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:
MOV EAX,dword ptr [RSP + 0x14]
TEST EAX,EAX
JLE 0x001015d0
MOVSXD R12,R13D
MOV R15,qword ptr [RSP]
LEA RAX,[R12*0x8]
MOV R12,qword ptr [RSP + 0x18]
ADD R15,RAX
MOV qword ptr [RSP + 0x8],RAX
MOV RBX,qword ptr [R15]
JMP 0x00101569
LAB_00101560:
ADD R12,0x8
CMP RBP,R12
JZ 0x001015d0
LAB_00101569:
MOV RSI,qword ptr [R12]
MOV RDI,RBX
CALL 0x001010a0
TEST EAX,EAX
JNZ 0x00101560
MOV EDX,R14D
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDI,R15
SUB EDX,R13D
SUB R14D,0x1
SUB EDX,0x1
LEA RSI,[RAX + RCX*0x1 + 0x8]
MOVSXD RDX,EDX
SHL RDX,0x3
CALL 0x001010b0
LAB_001015a3:
CMP R14D,R13D
JG 0x00101530
LAB_001015a8:
MOV RAX,qword ptr [RSP]
MOVSXD R14,R14D
MOV qword ptr [RAX + R14*0x8],0x0
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015d0:
ADD R13D,0x1
JMP 0x001015a3 | 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_3;
do {
iVar1 = strcmp(__s1,(char *)*puVar2);
if (iVar1 == 0) {
iVar1 = param_2 - iVar3;
param_2 = param_2 + -1;
memmove(__dest,(void *)(param_1 + 8 + (long)iVar3 * 8),(long)(iVar1 + -1) << 3);
goto LAB_001015a3;
}
puVar2 = puVar2 + 1;
} while (param_3 + (ulong)(param_4 - 1) + 1 != puVar2);
}
iVar3 = iVar3 + 1;
LAB_001015a3:
} while (iVar3 < param_2);
}
*(int8 *)(param_1 + (long)param_2 * 8) = 0;
return;
} |
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) * sizeof(char *));
list1_size--;
i--;
break;
}
}
}
list1[list1_size] = NULL;
}
| 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 *remove2[] = {"black", "orange", NULL};
char *expected2[] = {"red", "green", "blue", "white", NULL};
char *test_list3[] = {"red", "green", "blue", "white", "black", "orange", NULL};
char *remove3[] = {"blue", "white", NULL};
char *expected3[] = {"red", "green", "black", "orange", NULL};
func0(test_list1, 6, remove1, 2);
for (int i = 0; test_list1[i] != NULL; i++) {
assert(strcmp(test_list1[i], expected1[i]) == 0);
}
func0(test_list2, 6, remove2, 2);
for (int i = 0; test_list2[i] != NULL; i++) {
assert(strcmp(test_list2[i], expected2[i]) == 0);
}
func0(test_list3, 6, remove3, 2);
for (int i = 0; test_list3[i] != NULL; i++) {
assert(strcmp(test_list3[i], expected3[i]) == 0);
}
return 0;
}
| 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 0x0(%rax,%rax,1)
mov 0x14(%rsp),%eax
test %eax,%eax
jle 16b0 <func0+0xe0>
movslq %r13d,%r12
mov (%rsp),%r15
lea 0x0(,%r12,8),%rax
mov 0x18(%rsp),%r12
add %rax,%r15
mov %rax,0x8(%rsp)
mov (%r15),%rbx
jmp 1649 <func0+0x79>
nopl (%rax)
add $0x8,%r12
cmp %rbp,%r12
je 16b0 <func0+0xe0>
mov (%r12),%rsi
mov %rbx,%rdi
callq 10a0 <strcmp@plt>
test %eax,%eax
jne 1640 <func0+0x70>
mov %r14d,%edx
mov (%rsp),%rax
mov 0x8(%rsp),%rcx
mov %r15,%rdi
sub %r13d,%edx
sub $0x1,%r14d
sub $0x1,%edx
lea 0x8(%rax,%rcx,1),%rsi
movslq %edx,%rdx
shl $0x3,%rdx
callq 10b0 <memmove@plt>
cmp %r13d,%r14d
jg 1610 <func0+0x40>
mov (%rsp),%rax
movslq %r14d,%r14
movq $0x0,(%rax,%r14,8)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%r13d
jmp 1683 <func0+0xb3>
nopw %cs:0x0(%rax,%rax,1)
| 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 rbp, [rdx+rcx*8]
nop dword ptr [rax+00000000h]
loc_1588:
mov rax, [rsp+58h+var_48]
mov r14, [rsp+58h+var_40]
lea r15, ds:0[rax*8]
mov rax, [rsp+58h+var_58]
add rax, r15
mov [rsp+58h+dest], rax
mov rbx, [rax]
jmp short loc_15B9
loc_15B0:
add r14, 8
cmp rbp, r14
jz short loc_1618
loc_15B9:
mov rsi, [r14]; s2
mov rdi, rbx; s1
call _strcmp
test eax, eax
jnz short loc_15B0
mov edx, r12d
mov rax, [rsp+58h+var_58]
mov rdi, [rsp+58h+dest]; dest
sub r12d, 1
sub edx, r13d
sub edx, 1
lea rsi, [rax+r15+8]; src
movsxd rdx, edx
shl rdx, 3; n
call _memmove
cmp r13d, r12d
jl short loc_1588
loc_15F4:
mov rax, [rsp+58h+var_58]
movsxd r12, r12d
mov qword ptr [rax+r12*8], 0
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1618:
add r13d, 1
cmp r12d, r13d
jle short loc_15F4
movsxd rax, r13d
mov [rsp+58h+var_48], rax
jmp loc_1588 | 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;
if ( a2 > 0 && a4 > 0 )
{
v12 = 0LL;
v5 = 0;
v6 = &a3[a4];
LABEL_4:
while ( 2 )
{
v7 = a3;
dest = (const char **)(8 * v12 + a1);
v8 = *dest;
while ( strcmp(v8, *v7) )
{
if ( v6 == ++v7 )
{
if ( v4 <= ++v5 )
goto LABEL_8;
v12 = v5;
goto LABEL_4;
}
}
v9 = v4--;
memmove(dest, (const void *)(a1 + 8 * v12 + 8), 8LL * (v9 - v5 - 1));
if ( v5 < v4 )
continue;
break;
}
}
LABEL_8:
result = a1;
*(_QWORD *)(a1 + 8LL * v4) = 0LL;
return result;
} | 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_00101588:
MOV RAX,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RSP + 0x18]
LEA R15,[RAX*0x8]
MOV RAX,qword ptr [RSP]
ADD RAX,R15
MOV qword ptr [RSP + 0x8],RAX
MOV RBX,qword ptr [RAX]
JMP 0x001015b9
LAB_001015b0:
ADD R14,0x8
CMP RBP,R14
JZ 0x00101618
LAB_001015b9:
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x001010a0
TEST EAX,EAX
JNZ 0x001015b0
MOV EDX,R12D
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RSP + 0x8]
SUB R12D,0x1
SUB EDX,R13D
SUB EDX,0x1
LEA RSI,[RAX + R15*0x1 + 0x8]
MOVSXD RDX,EDX
SHL RDX,0x3
CALL 0x001010b0
CMP R13D,R12D
JL 0x00101588
LAB_001015f4:
MOV RAX,qword ptr [RSP]
MOVSXD R12,R12D
MOV qword ptr [RAX + R12*0x8],0x0
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101618:
ADD R13D,0x1
CMP R12D,R13D
JLE 0x001015f4
MOVSXD RAX,R13D
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00101588 | 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 = (char *)*__dest;
puVar3 = param_3;
do {
iVar1 = strcmp(__s1,(char *)*puVar3);
if (iVar1 == 0) {
iVar1 = param_2 + -1;
memmove(__dest,(void *)(param_1 + 8 + local_48 * 8),(long)((param_2 - iVar2) + -1) << 3);
param_2 = iVar1;
if (iVar1 <= iVar2) goto LAB_001015f4;
goto LAB_00101588;
}
puVar3 = puVar3 + 1;
} while (param_3 + param_4 != puVar3);
iVar2 = iVar2 + 1;
if (param_2 <= iVar2) break;
local_48 = (long)iVar2;
} while( true );
}
LAB_001015f4:
*(int8 *)(param_1 + (long)param_2 * 8) = 0;
return;
} |
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 (int k = 0; k < common_elements_size; k++) {
if (strcmp(common_elements[k], l1[i]) == 0) {
is_unique = false;
break;
}
}
if (is_unique) {
common_elements[common_elements_size++] = l1[i];
}
}
}
}
int index1 = 0;
int index2 = 0;
char *ordered_l1[100];
char *ordered_l2[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l1[i], common_elements[j]) == 0) {
ordered_l1[index1++] = l1[i];
}
}
}
for (int i = 0; i < size2; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l2[i], common_elements[j]) == 0) {
ordered_l2[index2++] = l2[i];
}
}
}
if (index1 != index2) {
return false;
}
for (int i = 0; i < index1; i++) {
if (strcmp(ordered_l1[i], ordered_l2[i]) != 0) {
return false;
}
}
return true;
}
| 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"};
char *list2c[] = {"red", "pink", "green", "white", "black"};
assert(func0(list1a, list2a, 4, 5) == true);
assert(func0(list1b, list2b, 5, 4) == false);
assert(func0(list1c, list2c, 4, 5) == true);
printf("All tests passed!\n");
return 0;
}
| 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(%rbp)
jmpq 130a <func0+0x161>
mov -0x994(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x9b0(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x998(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x9a8(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 1303 <func0+0x15a>
movb $0x1,-0x99d(%rbp)
movl $0x0,-0x990(%rbp)
jmp 12b5 <func0+0x10c>
mov -0x998(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x9a8(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x990(%rbp),%eax
cltq
mov -0x970(%rbp,%rax,8),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 12ae <func0+0x105>
movb $0x0,-0x99d(%rbp)
jmp 12c3 <func0+0x11a>
addl $0x1,-0x990(%rbp)
mov -0x990(%rbp),%eax
cmp -0x99c(%rbp),%eax
jl 1269 <func0+0xc0>
cmpb $0x0,-0x99d(%rbp)
je 1303 <func0+0x15a>
mov -0x998(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x9a8(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x99c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x99c(%rbp)
mov (%rcx),%rdx
cltq
mov %rdx,-0x970(%rbp,%rax,8)
addl $0x1,-0x994(%rbp)
mov -0x994(%rbp),%eax
cmp -0x9b8(%rbp),%eax
jl 1209 <func0+0x60>
addl $0x1,-0x998(%rbp)
mov -0x998(%rbp),%eax
cmp -0x9b4(%rbp),%eax
jl 11fa <func0+0x51>
movl $0x0,-0x98c(%rbp)
movl $0x0,-0x988(%rbp)
movl $0x0,-0x984(%rbp)
jmpq 13f7 <func0+0x24e>
movl $0x0,-0x980(%rbp)
jmp 13de <func0+0x235>
mov -0x980(%rbp),%eax
cltq
mov -0x970(%rbp,%rax,8),%rdx
mov -0x984(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x9a8(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 13d7 <func0+0x22e>
mov -0x984(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x9a8(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x98c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x98c(%rbp)
mov (%rcx),%rdx
cltq
mov %rdx,-0x650(%rbp,%rax,8)
addl $0x1,-0x980(%rbp)
mov -0x980(%rbp),%eax
cmp -0x99c(%rbp),%eax
jl 1364 <func0+0x1bb>
addl $0x1,-0x984(%rbp)
mov -0x984(%rbp),%eax
cmp -0x9b4(%rbp),%eax
jl 1358 <func0+0x1af>
movl $0x0,-0x97c(%rbp)
jmpq 14b7 <func0+0x30e>
movl $0x0,-0x978(%rbp)
jmp 149e <func0+0x2f5>
mov -0x978(%rbp),%eax
cltq
mov -0x970(%rbp,%rax,8),%rdx
mov -0x97c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x9b0(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 1497 <func0+0x2ee>
mov -0x97c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x9b0(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x988(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x988(%rbp)
mov (%rcx),%rdx
cltq
mov %rdx,-0x330(%rbp,%rax,8)
addl $0x1,-0x978(%rbp)
mov -0x978(%rbp),%eax
cmp -0x99c(%rbp),%eax
jl 1424 <func0+0x27b>
addl $0x1,-0x97c(%rbp)
mov -0x97c(%rbp),%eax
cmp -0x9b8(%rbp),%eax
jl 1418 <func0+0x26f>
mov -0x98c(%rbp),%eax
cmp -0x988(%rbp),%eax
je 14de <func0+0x335>
mov $0x0,%eax
jmp 153a <func0+0x391>
movl $0x0,-0x974(%rbp)
jmp 1527 <func0+0x37e>
mov -0x974(%rbp),%eax
cltq
mov -0x330(%rbp,%rax,8),%rdx
mov -0x974(%rbp),%eax
cltq
mov -0x650(%rbp,%rax,8),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1520 <func0+0x377>
mov $0x0,%eax
jmp 153a <func0+0x391>
addl $0x1,-0x974(%rbp)
mov -0x974(%rbp),%eax
cmp -0x98c(%rbp),%eax
jl 14ea <func0+0x341>
mov $0x1,%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 154e <func0+0x3a5>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
| 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 [rbp+var_994], 0
jmp loc_130A
loc_1209:
mov eax, [rbp+var_994]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_9B0]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_998]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_9A8]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz loc_1303
mov [rbp+var_99D], 1
mov [rbp+var_990], 0
jmp short loc_12B5
loc_1269:
mov eax, [rbp+var_998]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_9A8]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_990]
cdqe
mov rax, [rbp+rax*8+s1]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_12AE
mov [rbp+var_99D], 0
jmp short loc_12C3
loc_12AE:
add [rbp+var_990], 1
loc_12B5:
mov eax, [rbp+var_990]
cmp eax, [rbp+var_99C]
jl short loc_1269
loc_12C3:
cmp [rbp+var_99D], 0
jz short loc_1303
mov eax, [rbp+var_998]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_9A8]
lea rcx, [rdx+rax]
mov eax, [rbp+var_99C]
lea edx, [rax+1]
mov [rbp+var_99C], edx
mov rdx, [rcx]
cdqe
mov [rbp+rax*8+s1], rdx
loc_1303:
add [rbp+var_994], 1
loc_130A:
mov eax, [rbp+var_994]
cmp eax, [rbp+var_9B8]
jl loc_1209
add [rbp+var_998], 1
loc_1323:
mov eax, [rbp+var_998]
cmp eax, [rbp+var_9B4]
jl loc_11FA
mov [rbp+var_98C], 0
mov [rbp+var_988], 0
mov [rbp+var_984], 0
jmp loc_13F7
loc_1358:
mov [rbp+var_980], 0
jmp short loc_13DE
loc_1364:
mov eax, [rbp+var_980]
cdqe
mov rdx, [rbp+rax*8+s1]
mov eax, [rbp+var_984]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_9A8]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_13D7
mov eax, [rbp+var_984]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_9A8]
lea rcx, [rdx+rax]
mov eax, [rbp+var_98C]
lea edx, [rax+1]
mov [rbp+var_98C], edx
mov rdx, [rcx]
cdqe
mov [rbp+rax*8+var_650], rdx
loc_13D7:
add [rbp+var_980], 1
loc_13DE:
mov eax, [rbp+var_980]
cmp eax, [rbp+var_99C]
jl loc_1364
add [rbp+var_984], 1
loc_13F7:
mov eax, [rbp+var_984]
cmp eax, [rbp+var_9B4]
jl loc_1358
mov [rbp+var_97C], 0
jmp loc_14B7
loc_1418:
mov [rbp+var_978], 0
jmp short loc_149E
loc_1424:
mov eax, [rbp+var_978]
cdqe
mov rdx, [rbp+rax*8+s1]
mov eax, [rbp+var_97C]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_9B0]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1497
mov eax, [rbp+var_97C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_9B0]
lea rcx, [rdx+rax]
mov eax, [rbp+var_988]
lea edx, [rax+1]
mov [rbp+var_988], edx
mov rdx, [rcx]
cdqe
mov [rbp+rax*8+s2], rdx
loc_1497:
add [rbp+var_978], 1
loc_149E:
mov eax, [rbp+var_978]
cmp eax, [rbp+var_99C]
jl loc_1424
add [rbp+var_97C], 1
loc_14B7:
mov eax, [rbp+var_97C]
cmp eax, [rbp+var_9B8]
jl loc_1418
mov eax, [rbp+var_98C]
cmp eax, [rbp+var_988]
jz short loc_14DE
mov eax, 0
jmp short loc_153A
loc_14DE:
mov [rbp+var_974], 0
jmp short loc_1527
loc_14EA:
mov eax, [rbp+var_974]
cdqe
mov rdx, [rbp+rax*8+s2]
mov eax, [rbp+var_974]
cdqe
mov rax, [rbp+rax*8+var_650]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1520
mov eax, 0
jmp short loc_153A
loc_1520:
add [rbp+var_974], 1
loc_1527:
mov eax, [rbp+var_974]
cmp eax, [rbp+var_98C]
jl short loc_14EA
mov eax, 1
loc_153A:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_154E
call ___stack_chk_fail
locret_154E:
leave
retn | 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]
int v16; // [rsp+38h] [rbp-988h]
int m; // [rsp+3Ch] [rbp-984h]
int n; // [rsp+40h] [rbp-980h]
int ii; // [rsp+44h] [rbp-97Ch]
int jj; // [rsp+48h] [rbp-978h]
int kk; // [rsp+4Ch] [rbp-974h]
char *s1[302]; // [rsp+50h] [rbp-970h]
s1[301] = (char *)__readfsqword(0x28u);
v11 = 0;
for ( i = 0; i < a3; ++i )
{
for ( j = 0; j < a4; ++j )
{
if ( !strcmp(*(const char **)(8LL * i + a1), *(const char **)(8LL * j + a2)) )
{
v10 = 1;
for ( k = 0; k < v11; ++k )
{
if ( !strcmp(s1[k], *(const char **)(8LL * i + a1)) )
{
v10 = 0;
break;
}
}
if ( v10 )
{
v4 = v11++;
s1[v4] = *(char **)(8LL * i + a1);
}
}
}
}
v15 = 0;
v16 = 0;
for ( m = 0; m < a3; ++m )
{
for ( n = 0; n < v11; ++n )
{
if ( !strcmp(*(const char **)(8LL * m + a1), s1[n]) )
{
v5 = v15++;
s1[v5 + 100] = *(char **)(8LL * m + a1);
}
}
}
for ( ii = 0; ii < a4; ++ii )
{
for ( jj = 0; jj < v11; ++jj )
{
if ( !strcmp(*(const char **)(8LL * ii + a2), s1[jj]) )
{
v6 = v16++;
s1[v6 + 200] = *(char **)(8LL * ii + a2);
}
}
}
if ( v15 != v16 )
return 0LL;
for ( kk = 0; kk < v15; ++kk )
{
if ( strcmp(s1[kk + 100], s1[kk + 200]) )
return 0LL;
}
return 1LL;
} | 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
JMP 0x00101323
LAB_001011fa:
MOV dword ptr [RBP + -0x994],0x0
JMP 0x0010130a
LAB_00101209:
MOV EAX,dword ptr [RBP + -0x994]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9b0]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x998]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9a8]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x00101303
MOV byte ptr [RBP + -0x99d],0x1
MOV dword ptr [RBP + -0x990],0x0
JMP 0x001012b5
LAB_00101269:
MOV EAX,dword ptr [RBP + -0x998]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9a8]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x990]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x970]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001012ae
MOV byte ptr [RBP + -0x99d],0x0
JMP 0x001012c3
LAB_001012ae:
ADD dword ptr [RBP + -0x990],0x1
LAB_001012b5:
MOV EAX,dword ptr [RBP + -0x990]
CMP EAX,dword ptr [RBP + -0x99c]
JL 0x00101269
LAB_001012c3:
CMP byte ptr [RBP + -0x99d],0x0
JZ 0x00101303
MOV EAX,dword ptr [RBP + -0x998]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9a8]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x99c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x99c],EDX
MOV RDX,qword ptr [RCX]
CDQE
MOV qword ptr [RBP + RAX*0x8 + -0x970],RDX
LAB_00101303:
ADD dword ptr [RBP + -0x994],0x1
LAB_0010130a:
MOV EAX,dword ptr [RBP + -0x994]
CMP EAX,dword ptr [RBP + -0x9b8]
JL 0x00101209
ADD dword ptr [RBP + -0x998],0x1
LAB_00101323:
MOV EAX,dword ptr [RBP + -0x998]
CMP EAX,dword ptr [RBP + -0x9b4]
JL 0x001011fa
MOV dword ptr [RBP + -0x98c],0x0
MOV dword ptr [RBP + -0x988],0x0
MOV dword ptr [RBP + -0x984],0x0
JMP 0x001013f7
LAB_00101358:
MOV dword ptr [RBP + -0x980],0x0
JMP 0x001013de
LAB_00101364:
MOV EAX,dword ptr [RBP + -0x980]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x970]
MOV EAX,dword ptr [RBP + -0x984]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9a8]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001013d7
MOV EAX,dword ptr [RBP + -0x984]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9a8]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x98c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x98c],EDX
MOV RDX,qword ptr [RCX]
CDQE
MOV qword ptr [RBP + RAX*0x8 + -0x650],RDX
LAB_001013d7:
ADD dword ptr [RBP + -0x980],0x1
LAB_001013de:
MOV EAX,dword ptr [RBP + -0x980]
CMP EAX,dword ptr [RBP + -0x99c]
JL 0x00101364
ADD dword ptr [RBP + -0x984],0x1
LAB_001013f7:
MOV EAX,dword ptr [RBP + -0x984]
CMP EAX,dword ptr [RBP + -0x9b4]
JL 0x00101358
MOV dword ptr [RBP + -0x97c],0x0
JMP 0x001014b7
LAB_00101418:
MOV dword ptr [RBP + -0x978],0x0
JMP 0x0010149e
LAB_00101424:
MOV EAX,dword ptr [RBP + -0x978]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x970]
MOV EAX,dword ptr [RBP + -0x97c]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9b0]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x00101497
MOV EAX,dword ptr [RBP + -0x97c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x9b0]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x988]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x988],EDX
MOV RDX,qword ptr [RCX]
CDQE
MOV qword ptr [RBP + RAX*0x8 + -0x330],RDX
LAB_00101497:
ADD dword ptr [RBP + -0x978],0x1
LAB_0010149e:
MOV EAX,dword ptr [RBP + -0x978]
CMP EAX,dword ptr [RBP + -0x99c]
JL 0x00101424
ADD dword ptr [RBP + -0x97c],0x1
LAB_001014b7:
MOV EAX,dword ptr [RBP + -0x97c]
CMP EAX,dword ptr [RBP + -0x9b8]
JL 0x00101418
MOV EAX,dword ptr [RBP + -0x98c]
CMP EAX,dword ptr [RBP + -0x988]
JZ 0x001014de
MOV EAX,0x0
JMP 0x0010153a
LAB_001014de:
MOV dword ptr [RBP + -0x974],0x0
JMP 0x00101527
LAB_001014ea:
MOV EAX,dword ptr [RBP + -0x974]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x330]
MOV EAX,dword ptr [RBP + -0x974]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x650]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101520
MOV EAX,0x0
JMP 0x0010153a
LAB_00101520:
ADD dword ptr [RBP + -0x974],0x1
LAB_00101527:
MOV EAX,dword ptr [RBP + -0x974]
CMP EAX,dword ptr [RBP + -0x98c]
JL 0x001014ea
MOV EAX,0x1
LAB_0010153a:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010154e
CALL 0x00101090
LAB_0010154e:
LEAVE
RET | 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 auStack_978 [100];
int8 auStack_658 [100];
int8 auStack_338 [101];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_9a4 = 0;
for (local_9a0 = 0; local_9a0 < param_3; local_9a0 = local_9a0 + 1) {
for (local_99c = 0; local_99c < param_4; local_99c = local_99c + 1) {
iVar2 = strcmp(*(char **)(param_1 + (long)local_9a0 * 8),
*(char **)(param_2 + (long)local_99c * 8));
if (iVar2 == 0) {
bVar1 = true;
for (local_998 = 0; local_998 < local_9a4; local_998 = local_998 + 1) {
iVar2 = strcmp((char *)auStack_978[local_998],*(char **)(param_1 + (long)local_9a0 * 8));
if (iVar2 == 0) {
bVar1 = false;
break;
}
}
if (bVar1) {
auStack_978[local_9a4] = *(int8 *)((long)local_9a0 * 8 + param_1);
local_9a4 = local_9a4 + 1;
}
}
}
}
local_994 = 0;
local_990 = 0;
for (local_98c = 0; local_98c < param_3; local_98c = local_98c + 1) {
for (local_988 = 0; local_988 < local_9a4; local_988 = local_988 + 1) {
iVar2 = strcmp(*(char **)(param_1 + (long)local_98c * 8),(char *)auStack_978[local_988]);
if (iVar2 == 0) {
auStack_658[local_994] = *(int8 *)((long)local_98c * 8 + param_1);
local_994 = local_994 + 1;
}
}
}
for (local_984 = 0; local_984 < param_4; local_984 = local_984 + 1) {
for (local_980 = 0; local_980 < local_9a4; local_980 = local_980 + 1) {
iVar2 = strcmp(*(char **)(param_2 + (long)local_984 * 8),(char *)auStack_978[local_980]);
if (iVar2 == 0) {
auStack_338[local_990] = *(int8 *)((long)local_984 * 8 + param_2);
local_990 = local_990 + 1;
}
}
}
if (local_994 == local_990) {
for (local_97c = 0; local_97c < local_994; local_97c = local_97c + 1) {
iVar2 = strcmp((char *)auStack_658[local_97c],(char *)auStack_338[local_97c]);
if (iVar2 != 0) {
uVar3 = 0;
goto LAB_0010153a;
}
}
uVar3 = 1;
}
else {
uVar3 = 0;
}
LAB_0010153a:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
} |
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 (int k = 0; k < common_elements_size; k++) {
if (strcmp(common_elements[k], l1[i]) == 0) {
is_unique = false;
break;
}
}
if (is_unique) {
common_elements[common_elements_size++] = l1[i];
}
}
}
}
int index1 = 0;
int index2 = 0;
char *ordered_l1[100];
char *ordered_l2[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l1[i], common_elements[j]) == 0) {
ordered_l1[index1++] = l1[i];
}
}
}
for (int i = 0; i < size2; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l2[i], common_elements[j]) == 0) {
ordered_l2[index2++] = l2[i];
}
}
}
if (index1 != index2) {
return false;
}
for (int i = 0; i < index1; i++) {
if (strcmp(ordered_l1[i], ordered_l2[i]) != 0) {
return false;
}
}
return true;
}
| 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"};
char *list2c[] = {"red", "pink", "green", "white", "black"};
assert(func0(list1a, list2a, 4, 5) == true);
assert(func0(list1b, list2b, 5, 4) == false);
assert(func0(list1c, list2c, 4, 5) == true);
printf("All tests passed!\n");
return 0;
}
| 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,%rax,8),%rax
mov %rax,0x28(%rsp)
mov 0x30(%rsp),%rdx
mov %rdx,0x38(%rsp)
mov 0x1c(%rsp),%eax
lea -0x1(%rax),%eax
lea 0x8(%rdx,%rax,8),%r15
mov %rdi,0x10(%rsp)
mov $0x0,%r14d
lea 0x48(%rsp),%rax
mov %rax,0x20(%rsp)
jmp 1233 <func0+0x8a>
addq $0x8,0x10(%rsp)
mov 0x10(%rsp),%rax
cmp 0x28(%rsp),%rax
je 124c <func0+0xa3>
cmpl $0x0,0x1c(%rsp)
jle 1221 <func0+0x78>
mov 0x10(%rsp),%rax
mov (%rax),%r12
mov 0x38(%rsp),%rbp
jmpq 13ed <func0+0x244>
lea 0x40(%rsp),%r15
lea -0x1(%r14),%eax
lea 0x48(%rsp,%rax,8),%r13
mov $0x0,%r12d
jmp 129e <func0+0xf5>
add $0x8,%rbx
cmp %r13,%rbx
je 128c <func0+0xe3>
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 1262 <func0+0xb9>
movslq %r12d,%rax
mov %rbp,0x360(%rsp,%rax,8)
lea 0x1(%r12),%r12d
jmp 1262 <func0+0xb9>
addq $0x8,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp 0x28(%rsp),%rax
je 12b0 <func0+0x107>
test %r14d,%r14d
jle 128c <func0+0xe3>
mov 0x8(%rsp),%rax
mov (%rax),%rbp
mov %r15,%rbx
jmp 126b <func0+0xc2>
cmpl $0x0,0x1c(%rsp)
jle 132f <func0+0x186>
lea 0x40(%rsp),%rax
mov %rax,0x10(%rsp)
lea -0x1(%r14),%eax
lea 0x48(%rsp,%rax,8),%r15
movq $0x0,0x8(%rsp)
mov $0x0,%r13d
jmp 1315 <func0+0x16c>
add $0x8,%rbx
cmp %rbx,%r15
je 1304 <func0+0x15b>
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 12db <func0+0x132>
movslq %r13d,%rax
mov %rbp,0x680(%rsp,%rax,8)
lea 0x1(%r13),%r13d
jmp 12db <func0+0x132>
addq $0x1,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp %eax,0x1c(%rsp)
jle 1335 <func0+0x18c>
test %r14d,%r14d
jle 1304 <func0+0x15b>
mov 0x30(%rsp),%rax
mov 0x8(%rsp),%rdx
mov (%rax,%rdx,8),%rbp
mov 0x10(%rsp),%rbx
jmp 12e4 <func0+0x13b>
mov $0x0,%r13d
mov $0x0,%eax
cmp %r13d,%r12d
je 1368 <func0+0x1bf>
mov 0x9a8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 142e <func0+0x285>
add $0x9b8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
test %r12d,%r12d
jle 13a5 <func0+0x1fc>
lea -0x1(%r12),%ebp
mov $0x0,%ebx
jmp 137c <func0+0x1d3>
mov %rax,%rbx
mov 0x680(%rsp,%rbx,8),%rsi
mov 0x360(%rsp,%rbx,8),%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 13ac <func0+0x203>
lea 0x1(%rbx),%rax
cmp %rbp,%rbx
jne 1379 <func0+0x1d0>
mov $0x1,%eax
jmp 133f <func0+0x196>
mov $0x1,%eax
jmp 133f <func0+0x196>
mov $0x0,%eax
jmp 133f <func0+0x196>
mov $0x0,%r12d
mov $0x0,%r14d
mov $0x1,%eax
cmpl $0x0,0x1c(%rsp)
jg 12b7 <func0+0x10e>
jmpq 133f <func0+0x196>
movslq %r14d,%rax
mov %r12,0x40(%rsp,%rax,8)
lea 0x1(%r14),%r14d
add $0x8,%rbp
cmp %r15,%rbp
je 1221 <func0+0x78>
mov 0x0(%rbp),%rsi
mov %r12,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 13e0 <func0+0x237>
test %r14d,%r14d
jle 13d4 <func0+0x22b>
lea 0x40(%rsp),%rbx
lea -0x1(%r14),%eax
mov 0x20(%rsp),%rcx
lea (%rcx,%rax,8),%r13
mov %r12,%rsi
mov (%rbx),%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 13e0 <func0+0x237>
add $0x8,%rbx
cmp %r13,%rbx
jne 1414 <func0+0x26b>
jmp 13d4 <func0+0x22b>
callq 1090 <__stack_chk_fail@plt>
| 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-1]
lea rcx, [rdi+rdx*8+8]
mov [rsp+9D8h+var_9B8], rcx
mov ecx, [rsp+9D8h+var_9C4]
lea edx, [rcx-1]
mov rcx, [rsp+9D8h+var_9B0]
lea r15, [rcx+rdx*8+8]
mov [rsp+9D8h+var_9D0], rdi
mov r14d, 0
lea rax, [rsp+9D8h+var_9A0]
mov [rsp+9D8h+var_9C0], rax
jmp short loc_122D
loc_121B:
add [rsp+9D8h+var_9D0], 8
mov rax, [rsp+9D8h+var_9D0]
cmp rax, [rsp+9D8h+var_9B8]
jz short loc_1246
loc_122D:
cmp [rsp+9D8h+var_9C4], 0
jle short loc_121B
mov rax, [rsp+9D8h+var_9D0]
mov r12, [rax]
mov rbp, [rsp+9D8h+var_9B0]
jmp loc_13E0
loc_1246:
lea r15, [rsp+9D8h+var_9A8]
lea eax, [r14-1]
lea r13, [rsp+rax*8+9D8h+var_9A0]
mov r12d, 0
jmp short loc_1296
loc_125C:
add rbx, 8
cmp rbx, r13
jz short loc_1286
loc_1265:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jnz short loc_125C
movsxd rax, r12d
mov [rsp+rax*8+9D8h+var_688], rbp
lea r12d, [r12+1]
jmp short loc_125C
loc_1286:
add [rsp+9D8h+var_9D8], 8
mov rax, [rsp+9D8h+var_9D8]
cmp rax, [rsp+9D8h+var_9B8]
jz short loc_12A7
loc_1296:
test r14d, r14d
jle short loc_1286
mov rax, [rsp+9D8h+var_9D8]
mov rbp, [rax]
mov rbx, r15
jmp short loc_1265
loc_12A7:
cmp [rsp+9D8h+var_9C4], 0
jle short loc_1322
loc_12AE:
lea rax, [rsp+9D8h+var_9A8]
mov [rsp+9D8h+var_9D0], rax
lea eax, [r14-1]
lea r15, [rsp+rax*8+9D8h+var_9A0]
mov [rsp+9D8h+var_9D8], 0
mov r13d, 0
jmp short loc_1309
loc_12D1:
add rbx, 8
cmp r15, rbx
jz short loc_12FA
loc_12DA:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jnz short loc_12D1
movsxd rax, r13d
mov [rsp+rax*8+9D8h+var_368], rbp
lea r13d, [r13+1]
jmp short loc_12D1
loc_12FA:
add [rsp+9D8h+var_9D8], 1
mov rax, [rsp+9D8h+var_9D8]
cmp [rsp+9D8h+var_9C4], eax
jle short loc_1328
loc_1309:
test r14d, r14d
jle short loc_12FA
mov rax, [rsp+9D8h+var_9B0]
mov rdx, [rsp+9D8h+var_9D8]
mov rbp, [rax+rdx*8]
mov rbx, [rsp+9D8h+var_9D0]
jmp short loc_12DA
loc_1322:
mov r13d, 0
loc_1328:
mov eax, 0
cmp r12d, r13d
jz short loc_135B
loc_1332:
mov rdx, [rsp+9D8h+var_40]
sub rdx, fs:28h
jnz loc_1421
add rsp, 9A8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_135B:
test r12d, r12d
jle short loc_1398
lea ebp, [r12-1]
mov ebx, 0
jmp short loc_136F
loc_136C:
mov rbx, rax
loc_136F:
mov rsi, [rsp+rbx*8+9D8h+var_368]
mov rdi, [rsp+rbx*8+9D8h+var_688]
call _strcmp
test eax, eax
jnz short loc_139F
lea rax, [rbx+1]
cmp rbx, rbp
jnz short loc_136C
mov eax, 1
jmp short loc_1332
loc_1398:
mov eax, 1
jmp short loc_1332
loc_139F:
mov eax, 0
jmp short loc_1332
loc_13A6:
mov r12d, 0
mov r14d, 0
mov eax, 1
cmp [rsp+9D8h+var_9C4], 0
jg loc_12AE
jmp loc_1332
loc_13C7:
movsxd rax, r14d
mov [rsp+rax*8+9D8h+var_9A8], r12
lea r14d, [r14+1]
loc_13D3:
add rbp, 8
cmp rbp, r15
jz loc_121B
loc_13E0:
mov rsi, [rbp+0]
mov rdi, r12
call _strcmp
test eax, eax
jnz short loc_13D3
test r14d, r14d
jle short loc_13C7
lea rbx, [rsp+9D8h+var_9A8]
lea eax, [r14-1]
mov rcx, [rsp+9D8h+var_9C0]
lea r13, [rcx+rax*8]
loc_1407:
mov rsi, r12
mov rdi, [rbx]
call _strcmp
test eax, eax
jz short loc_13D3
add rbx, 8
cmp rbx, r13
jnz short loc_1407
jmp short loc_13C7
loc_1421:
call ___stack_chk_fail | 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; // rbx
long long *v16; // [rsp+0h] [rbp-9D8h]
long long v17; // [rsp+0h] [rbp-9D8h]
long long *v18; // [rsp+8h] [rbp-9D0h]
long long v20; // [rsp+20h] [rbp-9B8h]
_QWORD v21[309]; // [rsp+30h] [rbp-9A8h] BYREF
v21[301] = __readfsqword(0x28u);
if ( a3 <= 0 )
{
v7 = 0;
v4 = 0;
result = 1LL;
if ( a4 <= 0 )
return result;
}
else
{
v16 = a1;
v20 = (long long)&a1[(unsigned int)(a3 - 1) + 1];
v18 = a1;
v4 = 0;
do
{
if ( a4 > 0 )
{
v5 = *v18;
v6 = a2;
do
{
if ( !(unsigned int)strcmp(v5, *v6) )
{
if ( v4 <= 0 )
{
LABEL_33:
v21[v4++] = v5;
}
else
{
v15 = v21;
while ( (unsigned int)strcmp(*v15, v5) )
{
if ( ++v15 == &v21[(unsigned int)(v4 - 1) + 1] )
goto LABEL_33;
}
}
}
++v6;
}
while ( v6 != &a2[(unsigned int)(a4 - 1) + 1] );
}
++v18;
}
while ( v18 != (long long *)v20 );
v7 = 0;
do
{
if ( v4 > 0 )
{
v9 = *v16;
v8 = v21;
do
{
if ( !(unsigned int)strcmp(v9, *v8) )
v21[v7++ + 100] = v9;
++v8;
}
while ( v8 != &v21[(unsigned int)(v4 - 1) + 1] );
}
++v16;
}
while ( v16 != (long long *)v20 );
if ( a4 <= 0 )
{
v10 = 0;
goto LABEL_22;
}
}
v17 = 0LL;
v10 = 0;
do
{
if ( v4 > 0 )
{
v12 = a2[v17];
v11 = v21;
do
{
if ( !(unsigned int)strcmp(v12, *v11) )
v21[v10++ + 200] = v12;
++v11;
}
while ( &v21[(unsigned int)(v4 - 1) + 1] != v11 );
}
++v17;
}
while ( a4 > (int)v17 );
LABEL_22:
result = 0LL;
if ( v7 == v10 )
{
if ( v7 <= 0 )
{
return 1LL;
}
else
{
for ( i = 0LL; !(unsigned int)strcmp(v21[i + 100], v21[i + 200]); ++i )
{
if ( i == v7 - 1 )
return 1LL;
}
return 0LL;
}
}
return result;
} | 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]
MOV qword ptr [RSP + 0x20],RCX
MOV ECX,dword ptr [RSP + 0x14]
LEA EDX,[RCX + -0x1]
MOV RCX,qword ptr [RSP + 0x28]
LEA R15,[RCX + RDX*0x8 + 0x8]
MOV qword ptr [RSP + 0x8],RDI
MOV R14D,0x0
LEA RAX,[RSP + 0x38]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0010122d
LAB_0010121b:
ADD qword ptr [RSP + 0x8],0x8
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP + 0x20]
JZ 0x00101246
LAB_0010122d:
CMP dword ptr [RSP + 0x14],0x0
JLE 0x0010121b
MOV RAX,qword ptr [RSP + 0x8]
MOV R12,qword ptr [RAX]
MOV RBP,qword ptr [RSP + 0x28]
JMP 0x001013e0
LAB_00101246:
LEA R15,[RSP + 0x30]
LEA EAX,[R14 + -0x1]
LEA R13,[RSP + RAX*0x8 + 0x38]
MOV R12D,0x0
JMP 0x00101296
LAB_0010125c:
ADD RBX,0x8
CMP RBX,R13
JZ 0x00101286
LAB_00101265:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x0010125c
MOVSXD RAX,R12D
MOV qword ptr [RSP + RAX*0x8 + 0x350],RBP
LEA R12D,[R12 + 0x1]
JMP 0x0010125c
LAB_00101286:
ADD qword ptr [RSP],0x8
MOV RAX,qword ptr [RSP]
CMP RAX,qword ptr [RSP + 0x20]
JZ 0x001012a7
LAB_00101296:
TEST R14D,R14D
JLE 0x00101286
MOV RAX,qword ptr [RSP]
MOV RBP,qword ptr [RAX]
MOV RBX,R15
JMP 0x00101265
LAB_001012a7:
CMP dword ptr [RSP + 0x14],0x0
JLE 0x00101322
LAB_001012ae:
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
LEA EAX,[R14 + -0x1]
LEA R15,[RSP + RAX*0x8 + 0x38]
MOV qword ptr [RSP],0x0
MOV R13D,0x0
JMP 0x00101309
LAB_001012d1:
ADD RBX,0x8
CMP R15,RBX
JZ 0x001012fa
LAB_001012da:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001012d1
MOVSXD RAX,R13D
MOV qword ptr [RSP + RAX*0x8 + 0x670],RBP
LEA R13D,[R13 + 0x1]
JMP 0x001012d1
LAB_001012fa:
ADD qword ptr [RSP],0x1
MOV RAX,qword ptr [RSP]
CMP dword ptr [RSP + 0x14],EAX
JLE 0x00101328
LAB_00101309:
TEST R14D,R14D
JLE 0x001012fa
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP]
MOV RBP,qword ptr [RAX + RDX*0x8]
MOV RBX,qword ptr [RSP + 0x8]
JMP 0x001012da
LAB_00101322:
MOV R13D,0x0
LAB_00101328:
MOV EAX,0x0
CMP R12D,R13D
JZ 0x0010135b
LAB_00101332:
MOV RDX,qword ptr [RSP + 0x998]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101421
ADD RSP,0x9a8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010135b:
TEST R12D,R12D
JLE 0x00101398
LEA EBP,[R12 + -0x1]
MOV EBX,0x0
JMP 0x0010136f
LAB_0010136c:
MOV RBX,RAX
LAB_0010136f:
MOV RSI,qword ptr [RSP + RBX*0x8 + 0x670]
MOV RDI,qword ptr [RSP + RBX*0x8 + 0x350]
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x0010139f
LEA RAX,[RBX + 0x1]
CMP RBX,RBP
JNZ 0x0010136c
MOV EAX,0x1
JMP 0x00101332
LAB_00101398:
MOV EAX,0x1
JMP 0x00101332
LAB_0010139f:
MOV EAX,0x0
JMP 0x00101332
LAB_001013a6:
MOV R12D,0x0
MOV R14D,0x0
MOV EAX,0x1
CMP dword ptr [RSP + 0x14],0x0
JG 0x001012ae
JMP 0x00101332
LAB_001013c7:
MOVSXD RAX,R14D
MOV qword ptr [RSP + RAX*0x8 + 0x30],R12
LEA R14D,[R14 + 0x1]
LAB_001013d3:
ADD RBP,0x8
CMP RBP,R15
JZ 0x0010121b
LAB_001013e0:
MOV RSI,qword ptr [RBP]
MOV RDI,R12
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001013d3
TEST R14D,R14D
JLE 0x001013c7
LEA RBX,[RSP + 0x30]
LEA EAX,[R14 + -0x1]
MOV RCX,qword ptr [RSP + 0x18]
LEA R13,[RCX + RAX*0x8]
LAB_00101407:
MOV RSI,R12
MOV RDI,qword ptr [RBX]
CALL 0x001010b0
TEST EAX,EAX
JZ 0x001013d3
ADD RBX,0x8
CMP RBX,R13
JNZ 0x00101407
JMP 0x001013c7
LAB_00101421:
CALL 0x00101090 | 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];
int8 auStack_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 < 1) {
iVar5 = 0;
iVar4 = 0;
uVar6 = 1;
if (param_4 < 1) goto LAB_00101332;
LAB_001012ae:
local_9d8 = (int8 *)0x0;
iVar2 = 0;
do {
if (0 < iVar4) {
pcVar1 = (char *)param_2[(long)local_9d8];
puVar7 = local_9a8;
do {
iVar3 = strcmp(pcVar1,(char *)*puVar7);
if (iVar3 == 0) {
auStack_368[iVar2] = pcVar1;
iVar2 = iVar2 + 1;
}
puVar7 = puVar7 + 1;
} while (auStack_688 + ((ulong)(iVar4 - 1) - 99) != puVar7);
}
local_9d8 = (int8 *)((long)local_9d8 + 1);
} while ((int)local_9d8 < param_4);
}
else {
iVar4 = 0;
local_9d0 = param_1;
do {
if (0 < param_4) {
pcVar1 = (char *)*local_9d0;
puVar7 = param_2;
do {
iVar5 = strcmp(pcVar1,(char *)*puVar7);
if (iVar5 == 0) {
if (0 < iVar4) {
puVar9 = local_9a8;
do {
iVar5 = strcmp((char *)*puVar9,pcVar1);
if (iVar5 == 0) goto LAB_001013d3;
puVar9 = puVar9 + 1;
} while (puVar9 != auStack_688 + ((ulong)(iVar4 - 1) - 99));
}
local_9a8[iVar4] = pcVar1;
iVar4 = iVar4 + 1;
}
LAB_001013d3:
puVar7 = puVar7 + 1;
} while (puVar7 != param_2 + (ulong)(param_4 - 1) + 1);
}
local_9d0 = local_9d0 + 1;
} while (local_9d0 != param_1 + (ulong)(param_3 - 1) + 1);
iVar5 = 0;
local_9d8 = param_1;
do {
if (0 < iVar4) {
pcVar1 = (char *)*local_9d8;
puVar7 = local_9a8;
do {
iVar2 = strcmp(pcVar1,(char *)*puVar7);
if (iVar2 == 0) {
auStack_688[iVar5] = pcVar1;
iVar5 = iVar5 + 1;
}
puVar7 = puVar7 + 1;
} while (puVar7 != auStack_688 + ((ulong)(iVar4 - 1) - 99));
}
local_9d8 = local_9d8 + 1;
} while (local_9d8 != param_1 + (ulong)(param_3 - 1) + 1);
if (0 < param_4) goto LAB_001012ae;
iVar2 = 0;
}
uVar6 = 0;
if (iVar5 == iVar2) {
if (iVar5 < 1) {
uVar6 = 1;
}
else {
uVar8 = 0;
do {
iVar4 = strcmp((char *)auStack_688[uVar8],(char *)auStack_368[uVar8]);
if (iVar4 != 0) {
uVar6 = 0;
goto LAB_00101332;
}
bVar10 = uVar8 != iVar5 - 1;
uVar8 = uVar8 + 1;
} while (bVar10);
uVar6 = 1;
}
}
LAB_00101332:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6;
} |
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 (int k = 0; k < common_elements_size; k++) {
if (strcmp(common_elements[k], l1[i]) == 0) {
is_unique = false;
break;
}
}
if (is_unique) {
common_elements[common_elements_size++] = l1[i];
}
}
}
}
int index1 = 0;
int index2 = 0;
char *ordered_l1[100];
char *ordered_l2[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l1[i], common_elements[j]) == 0) {
ordered_l1[index1++] = l1[i];
}
}
}
for (int i = 0; i < size2; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l2[i], common_elements[j]) == 0) {
ordered_l2[index2++] = l2[i];
}
}
}
if (index1 != index2) {
return false;
}
for (int i = 0; i < index1; i++) {
if (strcmp(ordered_l1[i], ordered_l2[i]) != 0) {
return false;
}
}
return true;
}
| 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"};
char *list2c[] = {"red", "pink", "green", "white", "black"};
assert(func0(list1a, list2a, 4, 5) == true);
assert(func0(list1b, list2b, 5, 4) == false);
assert(func0(list1c, list2c, 4, 5) == true);
printf("All tests passed!\n");
return 0;
}
| 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(%rsp)
xor %r13d,%r13d
lea 0x8(%rdi,%rax,8),%rax
mov %rdi,0x10(%rsp)
mov %rax,0x30(%rsp)
mov 0x2c(%rsp),%eax
sub $0x1,%eax
lea 0x8(%rcx,%rax,8),%r14
lea 0x40(%rsp),%rax
mov %rax,0x18(%rsp)
lea 0x48(%rsp),%rax
mov %rax,0x20(%rsp)
nopl 0x0(%rax,%rax,1)
mov 0x2c(%rsp),%ecx
test %ecx,%ecx
jle 1490 <func0+0x100>
mov 0x10(%rsp),%rax
mov 0x38(%rsp),%rbx
mov (%rax),%rbp
jmp 1439 <func0+0xa9>
nopw 0x0(%rax,%rax,1)
add $0x8,%rbx
cmp %r14,%rbx
je 1490 <func0+0x100>
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 1430 <func0+0xa0>
test %r13d,%r13d
je 1478 <func0+0xe8>
mov 0x20(%rsp),%rcx
lea -0x1(%r13),%eax
mov 0x18(%rsp),%r15
lea (%rcx,%rax,8),%r12
mov (%r15),%rdi
mov %rbp,%rsi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1430 <func0+0xa0>
add $0x8,%r15
cmp %r12,%r15
jne 1460 <func0+0xd0>
movslq %r13d,%rax
add $0x8,%rbx
add $0x1,%r13d
mov %rbp,0x40(%rsp,%rax,8)
cmp %r14,%rbx
jne 1439 <func0+0xa9>
nopl (%rax)
addq $0x8,0x10(%rsp)
mov 0x10(%rsp),%rax
cmp 0x30(%rsp),%rax
jne 1410 <func0+0x80>
mov 0x20(%rsp),%rcx
lea -0x1(%r13),%eax
xor %ebx,%ebx
mov %rax,%r15
lea (%rcx,%rax,8),%rbp
nopl 0x0(%rax,%rax,1)
test %r13d,%r13d
je 14fe <func0+0x16e>
mov 0x8(%rsp),%rax
mov 0x18(%rsp),%r14
mov (%rax),%r12
nopw 0x0(%rax,%rax,1)
mov (%r14),%rsi
mov %r12,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 14f5 <func0+0x165>
movslq %ebx,%rax
add $0x1,%ebx
mov %r12,0x360(%rsp,%rax,8)
add $0x8,%r14
cmp %r14,%rbp
jne 14d8 <func0+0x148>
addq $0x8,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp 0x30(%rsp),%rax
jne 14c0 <func0+0x130>
mov 0x2c(%rsp),%edx
test %edx,%edx
jle 1628 <func0+0x298>
mov 0x20(%rsp),%rax
mov %r15d,%r12d
xor %ebp,%ebp
movq $0x0,0x8(%rsp)
lea (%rax,%r12,8),%r12
nopl 0x0(%rax,%rax,1)
test %r13d,%r13d
je 1576 <func0+0x1e6>
mov 0x38(%rsp),%rax
mov 0x8(%rsp),%rdx
mov 0x18(%rsp),%r15
mov (%rax,%rdx,8),%r14
mov (%r15),%rsi
mov %r14,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 156d <func0+0x1dd>
movslq %ebp,%rax
add $0x1,%ebp
mov %r14,0x680(%rsp,%rax,8)
add $0x8,%r15
cmp %r15,%r12
jne 1550 <func0+0x1c0>
addq $0x1,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp %eax,0x2c(%rsp)
jg 1538 <func0+0x1a8>
xor %eax,%eax
cmp %ebp,%ebx
jne 15d0 <func0+0x240>
test %ebx,%ebx
je 15f5 <func0+0x265>
lea -0x1(%rbx),%ebp
lea 0x680(%rsp),%r13
xor %ebx,%ebx
lea 0x360(%rsp),%r12
jmp 15bc <func0+0x22c>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rbx),%rax
cmp %rbx,%rbp
je 15f5 <func0+0x265>
mov %rax,%rbx
mov 0x0(%r13,%rbx,8),%rsi
mov (%r12,%rbx,8),%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 15b0 <func0+0x220>
xor %eax,%eax
mov 0x9a8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 162f <func0+0x29f>
add $0x9b8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%eax
jmp 15d0 <func0+0x240>
mov 0x2c(%rsp),%eax
test %eax,%eax
jle 15f5 <func0+0x265>
lea 0x40(%rsp),%rax
xor %r13d,%r13d
xor %ebx,%ebx
mov $0xffffffff,%r15d
mov %rax,0x18(%rsp)
lea 0x48(%rsp),%rax
mov %rax,0x20(%rsp)
jmpq 151c <func0+0x18c>
xor %ebp,%ebp
jmpq 1587 <func0+0x1f7>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| 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_9B0]
mov [rsp+9E8h+var_9E0], rdi
xor r13d, r13d
lea rax, [rdi+rax*8+8]
mov [rsp+9E8h+var_9D8], rdi
mov [rsp+9E8h+var_9B8], rax
mov eax, [rsp+9E8h+var_9BC]
sub eax, 1
lea r14, [rdx+rax*8+8]
lea rax, [rsp+9E8h+var_9A8]
mov [rsp+9E8h+var_9D0], rax
lea rax, [rsp+9E8h+var_9A0]
mov [rsp+9E8h+var_9C8], rax
nop dword ptr [rax+rax+00000000h]
loc_1410:
mov ecx, [rsp+9E8h+var_9BC]
test ecx, ecx
jle short loc_1490
mov rax, [rsp+9E8h+var_9D8]
mov rbx, [rsp+9E8h+var_9B0]
mov rbp, [rax]
jmp short loc_1439
loc_1430:
add rbx, 8
cmp rbx, r14
jz short loc_1490
loc_1439:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jnz short loc_1430
test r13d, r13d
jz short loc_1478
mov rcx, [rsp+9E8h+var_9C8]
lea eax, [r13-1]
mov r15, [rsp+9E8h+var_9D0]
lea r12, [rcx+rax*8]
nop
loc_1460:
mov rdi, [r15]
mov rsi, rbp
call _strcmp
test eax, eax
jz short loc_1430
add r15, 8
cmp r15, r12
jnz short loc_1460
loc_1478:
movsxd rax, r13d
add rbx, 8
add r13d, 1
mov [rsp+rax*8+9E8h+var_9A8], rbp
cmp rbx, r14
jnz short loc_1439
nop dword ptr [rax]
loc_1490:
add [rsp+9E8h+var_9D8], 8
mov rax, [rsp+9E8h+var_9D8]
cmp rax, [rsp+9E8h+var_9B8]
jnz loc_1410
mov rdx, [rsp+9E8h+var_9C8]
lea eax, [r13-1]
xor ebx, ebx
mov r15, rax
lea rbp, [rdx+rax*8]
nop dword ptr [rax+rax+00000000h]
loc_14C0:
test r13d, r13d
jz short loc_14FE
mov rax, [rsp+9E8h+var_9E0]
mov r14, [rsp+9E8h+var_9D0]
mov r12, [rax]
nop word ptr [rax+rax+00h]
loc_14D8:
mov rsi, [r14]
mov rdi, r12
call _strcmp
test eax, eax
jnz short loc_14F5
movsxd rax, ebx
add ebx, 1
mov [rsp+rax*8+9E8h+var_688], r12
loc_14F5:
add r14, 8
cmp rbp, r14
jnz short loc_14D8
loc_14FE:
add [rsp+9E8h+var_9E0], 8
mov rax, [rsp+9E8h+var_9E0]
cmp rax, [rsp+9E8h+var_9B8]
jnz short loc_14C0
mov edx, [rsp+9E8h+var_9BC]
test edx, edx
jle loc_1625
loc_151C:
mov rax, [rsp+9E8h+var_9C8]
mov r12d, r15d
xor ebp, ebp
mov [rsp+9E8h+var_9E0], 0
lea r12, [rax+r12*8]
nop dword ptr [rax+rax+00h]
loc_1538:
test r13d, r13d
jz short loc_1576
mov rax, [rsp+9E8h+var_9B0]
mov rdx, [rsp+9E8h+var_9E0]
mov r15, [rsp+9E8h+var_9D0]
mov r14, [rax+rdx*8]
loc_1550:
mov rsi, [r15]
mov rdi, r14
call _strcmp
test eax, eax
jnz short loc_156D
movsxd rax, ebp
add ebp, 1
mov [rsp+rax*8+9E8h+var_368], r14
loc_156D:
add r15, 8
cmp r15, r12
jnz short loc_1550
loc_1576:
add [rsp+9E8h+var_9E0], 1
mov rax, [rsp+9E8h+var_9E0]
cmp [rsp+9E8h+var_9BC], eax
jg short loc_1538
loc_1587:
xor eax, eax
cmp ebx, ebp
jnz short loc_15CD
test ebx, ebx
jz short loc_15F2
movsxd rbx, ebx
xor ebp, ebp
lea r13, [rsp+9E8h+var_368]
lea r12, [rsp+9E8h+var_688]
jmp short loc_15B9
loc_15B0:
add rbp, 1
cmp rbx, rbp
jz short loc_15F2
loc_15B9:
mov rsi, [r13+rbp*8+0]
mov rdi, [r12+rbp*8]
call _strcmp
test eax, eax
jz short loc_15B0
xor eax, eax
loc_15CD:
mov rdx, [rsp+9E8h+var_40]
sub rdx, fs:28h
jnz short loc_162C
add rsp, 9B8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15F2:
mov eax, 1
jmp short loc_15CD
loc_15F9:
mov eax, [rsp+9E8h+var_9BC]
test eax, eax
jle short loc_15F2
lea rax, [rsp+9E8h+var_9A8]
xor r13d, r13d
xor ebx, ebx
mov r15d, 0FFFFFFFFh
mov [rsp+9E8h+var_9D0], rax
lea rax, [rsp+9E8h+var_9A0]
mov [rsp+9E8h+var_9C8], rax
jmp loc_151C
loc_1625:
xor ebp, ebp
jmp loc_1587
loc_162C:
call ___stack_chk_fail | 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
_QWORD *v16; // r12
_QWORD *v17; // r15
long long v18; // r14
long long v19; // rax
long long result; // rax
long long v21; // rbp
long long *v22; // [rsp+8h] [rbp-9E0h]
long long v23; // [rsp+8h] [rbp-9E0h]
long long *v24; // [rsp+10h] [rbp-9D8h]
long long v26; // [rsp+30h] [rbp-9B8h]
_QWORD v27[309]; // [rsp+40h] [rbp-9A8h] BYREF
v27[301] = __readfsqword(0x28u);
if ( a3 <= 0 )
{
if ( a4 > 0 )
{
v4 = 0;
v10 = 0;
LODWORD(v11) = -1;
goto LABEL_21;
}
return 1LL;
}
v22 = a1;
v4 = 0;
v24 = a1;
v26 = (long long)&a1[(unsigned int)(a3 - 1) + 1];
v5 = (long long)&a2[(unsigned int)(a4 - 1) + 1];
do
{
if ( a4 > 0 )
{
v6 = a2;
v7 = *v24;
do
{
while ( (unsigned int)strcmp(v7, *v6) )
{
LABEL_5:
if ( ++v6 == (_QWORD *)v5 )
goto LABEL_12;
}
if ( v4 )
{
v8 = v27;
while ( (unsigned int)strcmp(*v8, v7) )
{
if ( ++v8 == &v27[(unsigned int)(v4 - 1) + 1] )
goto LABEL_11;
}
goto LABEL_5;
}
LABEL_11:
v9 = v4;
++v6;
++v4;
v27[v9] = v7;
}
while ( v6 != (_QWORD *)v5 );
}
LABEL_12:
++v24;
}
while ( v24 != (long long *)v26 );
v10 = 0;
v11 = (unsigned int)(v4 - 1);
do
{
if ( v4 )
{
v12 = v27;
v13 = *v22;
do
{
if ( !(unsigned int)strcmp(v13, *v12) )
{
v14 = v10++;
v27[v14 + 100] = v13;
}
++v12;
}
while ( &v27[v11 + 1] != v12 );
}
++v22;
}
while ( v22 != (long long *)v26 );
if ( a4 <= 0 )
{
v15 = 0;
}
else
{
LABEL_21:
v15 = 0;
v23 = 0LL;
v16 = &v27[(unsigned int)v11 + 1];
do
{
if ( v4 )
{
v17 = v27;
v18 = a2[v23];
do
{
if ( !(unsigned int)strcmp(v18, *v17) )
{
v19 = v15++;
v27[v19 + 200] = v18;
}
++v17;
}
while ( v17 != v16 );
}
++v23;
}
while ( a4 > (int)v23 );
}
result = 0LL;
if ( v10 == v15 )
{
if ( v10 )
{
v21 = 0LL;
while ( !(unsigned int)strcmp(v27[v21 + 100], v27[v21 + 200]) )
{
if ( v10 == ++v21 )
return 1LL;
}
return 0LL;
}
return 1LL;
}
return result;
} | 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 + 0x8],RDI
XOR R13D,R13D
LEA RAX,[RDI + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0x2c]
SUB EAX,0x1
LEA R14,[RDX + RAX*0x8 + 0x8]
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0x20],RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101410:
MOV ECX,dword ptr [RSP + 0x2c]
TEST ECX,ECX
JLE 0x00101490
MOV RAX,qword ptr [RSP + 0x10]
MOV RBX,qword ptr [RSP + 0x38]
MOV RBP,qword ptr [RAX]
JMP 0x00101439
LAB_00101430:
ADD RBX,0x8
CMP RBX,R14
JZ 0x00101490
LAB_00101439:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x00101430
TEST R13D,R13D
JZ 0x00101478
MOV RCX,qword ptr [RSP + 0x20]
LEA EAX,[R13 + -0x1]
MOV R15,qword ptr [RSP + 0x18]
LEA R12,[RCX + RAX*0x8]
NOP
LAB_00101460:
MOV RDI,qword ptr [R15]
MOV RSI,RBP
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101430
ADD R15,0x8
CMP R15,R12
JNZ 0x00101460
LAB_00101478:
MOVSXD RAX,R13D
ADD RBX,0x8
ADD R13D,0x1
MOV qword ptr [RSP + RAX*0x8 + 0x40],RBP
CMP RBX,R14
JNZ 0x00101439
NOP dword ptr [RAX]
LAB_00101490:
ADD qword ptr [RSP + 0x10],0x8
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,qword ptr [RSP + 0x30]
JNZ 0x00101410
MOV RDX,qword ptr [RSP + 0x20]
LEA EAX,[R13 + -0x1]
XOR EBX,EBX
MOV R15,RAX
LEA RBP,[RDX + RAX*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014c0:
TEST R13D,R13D
JZ 0x001014fe
MOV RAX,qword ptr [RSP + 0x8]
MOV R14,qword ptr [RSP + 0x18]
MOV R12,qword ptr [RAX]
NOP word ptr [RAX + RAX*0x1]
LAB_001014d8:
MOV RSI,qword ptr [R14]
MOV RDI,R12
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001014f5
MOVSXD RAX,EBX
ADD EBX,0x1
MOV qword ptr [RSP + RAX*0x8 + 0x360],R12
LAB_001014f5:
ADD R14,0x8
CMP RBP,R14
JNZ 0x001014d8
LAB_001014fe:
ADD qword ptr [RSP + 0x8],0x8
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP + 0x30]
JNZ 0x001014c0
MOV EDX,dword ptr [RSP + 0x2c]
TEST EDX,EDX
JLE 0x00101625
LAB_0010151c:
MOV RAX,qword ptr [RSP + 0x20]
MOV R12D,R15D
XOR EBP,EBP
MOV qword ptr [RSP + 0x8],0x0
LEA R12,[RAX + R12*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101538:
TEST R13D,R13D
JZ 0x00101576
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x8]
MOV R15,qword ptr [RSP + 0x18]
MOV R14,qword ptr [RAX + RDX*0x8]
LAB_00101550:
MOV RSI,qword ptr [R15]
MOV RDI,R14
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x0010156d
MOVSXD RAX,EBP
ADD EBP,0x1
MOV qword ptr [RSP + RAX*0x8 + 0x680],R14
LAB_0010156d:
ADD R15,0x8
CMP R15,R12
JNZ 0x00101550
LAB_00101576:
ADD qword ptr [RSP + 0x8],0x1
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RSP + 0x2c],EAX
JG 0x00101538
LAB_00101587:
XOR EAX,EAX
CMP EBX,EBP
JNZ 0x001015cd
TEST EBX,EBX
JZ 0x001015f2
MOVSXD RBX,EBX
XOR EBP,EBP
LEA R13,[RSP + 0x680]
LEA R12,[RSP + 0x360]
JMP 0x001015b9
LAB_001015b0:
ADD RBP,0x1
CMP RBX,RBP
JZ 0x001015f2
LAB_001015b9:
MOV RSI,qword ptr [R13 + RBP*0x8]
MOV RDI,qword ptr [R12 + RBP*0x8]
CALL 0x001010b0
TEST EAX,EAX
JZ 0x001015b0
XOR EAX,EAX
LAB_001015cd:
MOV RDX,qword ptr [RSP + 0x9a8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010162c
ADD RSP,0x9b8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015f2:
MOV EAX,0x1
JMP 0x001015cd
LAB_001015f9:
MOV EAX,dword ptr [RSP + 0x2c]
TEST EAX,EAX
JLE 0x001015f2
LEA RAX,[RSP + 0x40]
XOR R13D,R13D
XOR EBX,EBX
MOV R15D,0xffffffff
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0010151c
LAB_00101625:
XOR EBP,EBP
JMP 0x00101587
LAB_0010162c:
CALL 0x00101090 | 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 local_688 [100];
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 < 1) {
if (0 < param_4) {
iVar8 = 0;
iVar2 = 0;
uVar10 = 0xffffffff;
goto LAB_0010151c;
}
}
else {
iVar8 = 0;
local_9d8 = param_1;
do {
if (0 < param_4) {
pcVar1 = (char *)*local_9d8;
puVar7 = param_2;
do {
while( true ) {
iVar2 = strcmp(pcVar1,(char *)*puVar7);
if (iVar2 != 0) break;
if (iVar8 != 0) {
puVar9 = local_9a8;
do {
iVar2 = strcmp((char *)*puVar9,pcVar1);
if (iVar2 == 0) goto LAB_00101430;
puVar9 = puVar9 + 1;
} while (puVar9 != local_688 + ((ulong)(iVar8 - 1) - 99));
}
lVar5 = (long)iVar8;
puVar7 = puVar7 + 1;
iVar8 = iVar8 + 1;
local_9a8[lVar5] = pcVar1;
if (puVar7 == param_2 + (ulong)(param_4 - 1) + 1) goto LAB_00101490;
}
LAB_00101430:
puVar7 = puVar7 + 1;
} while (puVar7 != param_2 + (ulong)(param_4 - 1) + 1);
}
LAB_00101490:
local_9d8 = local_9d8 + 1;
} while (local_9d8 != param_1 + (ulong)(param_3 - 1) + 1);
uVar10 = (ulong)(iVar8 - 1);
iVar2 = 0;
local_9e0 = param_1;
do {
if (iVar8 != 0) {
pcVar1 = (char *)*local_9e0;
puVar7 = local_9a8;
do {
iVar3 = strcmp(pcVar1,(char *)*puVar7);
if (iVar3 == 0) {
lVar5 = (long)iVar2;
iVar2 = iVar2 + 1;
local_688[lVar5] = pcVar1;
}
puVar7 = puVar7 + 1;
} while (local_688 + (uVar10 - 99) != puVar7);
}
local_9e0 = local_9e0 + 1;
} while (local_9e0 != param_1 + (ulong)(param_3 - 1) + 1);
if (param_4 < 1) {
iVar3 = 0;
}
else {
LAB_0010151c:
local_9d0 = local_9a8;
iVar3 = 0;
local_9e0 = (int8 *)0x0;
do {
if (iVar8 != 0) {
pcVar1 = (char *)param_2[(long)local_9e0];
puVar7 = local_9d0;
do {
iVar4 = strcmp(pcVar1,(char *)*puVar7);
if (iVar4 == 0) {
lVar5 = (long)iVar3;
iVar3 = iVar3 + 1;
local_368[lVar5] = pcVar1;
}
puVar7 = puVar7 + 1;
} while (puVar7 != local_688 + (uVar10 - 99));
}
local_9e0 = (int8 *)((long)local_9e0 + 1);
} while ((int)local_9e0 < param_4);
}
uVar6 = 0;
if (iVar2 != iVar3) goto LAB_001015cd;
if (iVar2 != 0) {
lVar5 = 0;
do {
iVar8 = strcmp((char *)local_688[lVar5],(char *)local_368[lVar5]);
if (iVar8 != 0) {
uVar6 = 0;
goto LAB_001015cd;
}
lVar5 = lVar5 + 1;
} while (iVar2 != lVar5);
}
}
uVar6 = 1;
LAB_001015cd:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
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 (int k = 0; k < common_elements_size; k++) {
if (strcmp(common_elements[k], l1[i]) == 0) {
is_unique = false;
break;
}
}
if (is_unique) {
common_elements[common_elements_size++] = l1[i];
}
}
}
}
int index1 = 0;
int index2 = 0;
char *ordered_l1[100];
char *ordered_l2[100];
for (int i = 0; i < size1; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l1[i], common_elements[j]) == 0) {
ordered_l1[index1++] = l1[i];
}
}
}
for (int i = 0; i < size2; i++) {
for (int j = 0; j < common_elements_size; j++) {
if (strcmp(l2[i], common_elements[j]) == 0) {
ordered_l2[index2++] = l2[i];
}
}
}
if (index1 != index2) {
return false;
}
for (int i = 0; i < index1; i++) {
if (strcmp(ordered_l1[i], ordered_l2[i]) != 0) {
return false;
}
}
return true;
}
| 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"};
char *list2c[] = {"red", "pink", "green", "white", "black"};
assert(func0(list1a, list2a, 4, 5) == true);
assert(func0(list1b, list2b, 5, 4) == false);
assert(func0(list1c, list2c, 4, 5) == true);
printf("All tests passed!\n");
return 0;
}
| 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
lea 0x8(%rdi,%rax,8),%rax
mov %rdi,0x10(%rsp)
mov %rax,0x30(%rsp)
mov 0x2c(%rsp),%eax
sub $0x1,%eax
lea 0x8(%rsi,%rax,8),%r14
lea 0x40(%rsp),%rax
mov %rax,0x18(%rsp)
lea 0x48(%rsp),%rax
mov %rax,0x20(%rsp)
nopl 0x0(%rax,%rax,1)
mov 0x2c(%rsp),%ecx
test %ecx,%ecx
jle 1470 <func0+0xf0>
mov 0x10(%rsp),%rax
mov 0x38(%rsp),%rbx
mov (%rax),%rbp
jmp 1419 <func0+0x99>
add $0x8,%rbx
cmp %r14,%rbx
je 1470 <func0+0xf0>
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 1410 <func0+0x90>
test %r13d,%r13d
je 1458 <func0+0xd8>
mov 0x20(%rsp),%rcx
lea -0x1(%r13),%eax
mov 0x18(%rsp),%r15
lea (%rcx,%rax,8),%r12
mov (%r15),%rdi
mov %rbp,%rsi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1410 <func0+0x90>
add $0x8,%r15
cmp %r12,%r15
jne 1440 <func0+0xc0>
movslq %r13d,%rax
add $0x8,%rbx
add $0x1,%r13d
mov %rbp,0x40(%rsp,%rax,8)
cmp %r14,%rbx
jne 1419 <func0+0x99>
nopl (%rax)
addq $0x8,0x10(%rsp)
mov 0x10(%rsp),%rax
cmp 0x30(%rsp),%rax
jne 13f8 <func0+0x78>
mov 0x20(%rsp),%rcx
lea -0x1(%r13),%eax
xor %ebx,%ebx
mov %rax,%r15
lea (%rcx,%rax,8),%rbp
nopl 0x0(%rax,%rax,1)
test %r13d,%r13d
je 14de <func0+0x15e>
mov 0x8(%rsp),%rax
mov 0x18(%rsp),%r14
mov (%rax),%r12
nopw 0x0(%rax,%rax,1)
mov (%r14),%rsi
mov %r12,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 14d5 <func0+0x155>
movslq %ebx,%rax
add $0x1,%ebx
mov %r12,0x360(%rsp,%rax,8)
add $0x8,%r14
cmp %r14,%rbp
jne 14b8 <func0+0x138>
addq $0x8,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp 0x30(%rsp),%rax
jne 14a0 <func0+0x120>
mov 0x2c(%rsp),%edx
test %edx,%edx
jle 1608 <func0+0x288>
mov 0x20(%rsp),%rax
mov %r15d,%r12d
xor %ebp,%ebp
movq $0x0,0x8(%rsp)
lea (%rax,%r12,8),%r12
nopl 0x0(%rax,%rax,1)
test %r13d,%r13d
je 1556 <func0+0x1d6>
mov 0x38(%rsp),%rax
mov 0x8(%rsp),%rdx
mov 0x18(%rsp),%r15
mov (%rax,%rdx,8),%r14
mov (%r15),%rsi
mov %r14,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 154d <func0+0x1cd>
movslq %ebp,%rax
add $0x1,%ebp
mov %r14,0x680(%rsp,%rax,8)
add $0x8,%r15
cmp %r15,%r12
jne 1530 <func0+0x1b0>
addq $0x1,0x8(%rsp)
mov 0x8(%rsp),%rax
cmp %eax,0x2c(%rsp)
jg 1518 <func0+0x198>
xor %eax,%eax
cmp %ebp,%ebx
jne 15b0 <func0+0x230>
test %ebx,%ebx
je 15d5 <func0+0x255>
lea -0x1(%rbx),%ebp
lea 0x680(%rsp),%r13
xor %ebx,%ebx
lea 0x360(%rsp),%r12
jmp 159c <func0+0x21c>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rbx),%rax
cmp %rbx,%rbp
je 15d5 <func0+0x255>
mov %rax,%rbx
mov 0x0(%r13,%rbx,8),%rsi
mov (%r12,%rbx,8),%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1590 <func0+0x210>
xor %eax,%eax
mov 0x9a8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 160f <func0+0x28f>
add $0x9b8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%eax
jmp 15b0 <func0+0x230>
mov 0x2c(%rsp),%eax
test %eax,%eax
jle 15d5 <func0+0x255>
lea 0x40(%rsp),%rax
xor %r13d,%r13d
xor %ebx,%ebx
mov $0xffffffff,%r15d
mov %rax,0x18(%rsp)
lea 0x48(%rsp),%rax
mov %rax,0x20(%rsp)
jmpq 14fc <func0+0x17c>
xor %ebp,%ebp
jmpq 1567 <func0+0x1e7>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| 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
lea rax, [rdi+rdx*8]
mov [rsp+9E8h+var_9D0], rdi
mov rdx, [rsp+9E8h+var_9B8]
mov [rsp+9E8h+var_9C0], rax
movsxd rax, [rsp+9E8h+var_9AC]
lea r13, [rdx+rax*8]
loc_13ED:
mov ecx, [rsp+9E8h+var_9AC]
test ecx, ecx
jle loc_1631
lea rax, [rsp+9E8h+var_9A8]
xor r15d, r15d
mov [rsp+9E8h+var_9E0], 0
mov [rsp+9E8h+var_9D8], rax
nop
loc_1410:
mov rax, [rsp+9E8h+var_9D0]
mov rbx, [rsp+9E8h+var_9B8]
mov rbp, [rax]
jmp short loc_1429
loc_1420:
add rbx, 8
cmp rbx, r13
jz short loc_1490
loc_1429:
mov rsi, [rbx]; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jnz short loc_1420
test r15d, r15d
jle short loc_1468
mov rax, [rsp+9E8h+var_9D8]
mov rcx, [rsp+9E8h+var_9E0]
mov r14, rax
lea r12, [rax+rcx*8]
xchg ax, ax
loc_1450:
mov rdi, [r14]; s1
mov rsi, rbp; s2
call _strcmp
test eax, eax
jz short loc_1420
add r14, 8
cmp r14, r12
jnz short loc_1450
loc_1468:
mov rax, [rsp+9E8h+var_9E0]
add r15d, 1
add rbx, 8
mov [rsp+rax*8+9E8h+var_9A8], rbp
movsxd rax, r15d
mov [rsp+9E8h+var_9E0], rax
cmp rbx, r13
jnz short loc_1429
nop word ptr [rax+rax+00000000h]
loc_1490:
add [rsp+9E8h+var_9D0], 8
mov rdx, [rsp+9E8h+var_9C0]
mov rax, [rsp+9E8h+var_9D0]
cmp rax, rdx
jnz loc_1410
loc_14A9:
mov rax, [rsp+9E8h+var_9D8]
mov rdx, [rsp+9E8h+var_9E0]
lea r12, [rax+rdx*8]
loc_14B7:
test r15d, r15d
jle loc_1611
xor ebx, ebx
nop word ptr [rax+rax+00h]
loc_14C8:
mov rax, [rsp+9E8h+var_9C8]
mov r13, [rsp+9E8h+var_9D8]
mov rbp, [rax]
nop dword ptr [rax]
loc_14D8:
mov rsi, [r13+0]; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jnz short loc_14F6
movsxd rax, ebx
add ebx, 1
mov [rsp+rax*8+9E8h+var_688], rbp
loc_14F6:
add r13, 8
cmp r12, r13
jnz short loc_14D8
add [rsp+9E8h+var_9C8], 8
mov rdx, [rsp+9E8h+var_9C0]
mov rax, [rsp+9E8h+var_9C8]
cmp rax, rdx
jnz short loc_14C8
loc_1514:
mov eax, [rsp+9E8h+var_9AC]
test eax, eax
jle loc_1694
loc_1520:
mov rax, [rsp+9E8h+var_9D8]
mov rdx, [rsp+9E8h+var_9E0]
xor r14d, r14d
lea r12, [rax+rdx*8]
loc_1531:
test r15d, r15d
jle loc_15FA
xor r15d, r15d
nop dword ptr [rax]
loc_1540:
mov rax, [rsp+9E8h+var_9B8]
mov r13, [rsp+9E8h+var_9D8]
mov rbp, [rax+r14*8]
xchg ax, ax
loc_1550:
mov rsi, [r13+0]; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jnz short loc_156F
movsxd rax, r15d
add r15d, 1
mov [rsp+rax*8+9E8h+var_368], rbp
loc_156F:
add r13, 8
cmp r12, r13
jnz short loc_1550
add r14, 1
cmp [rsp+9E8h+var_9AC], r14d
jg short loc_1540
loc_1583:
xor eax, eax
cmp ebx, r15d
jnz short loc_15D1
test ebx, ebx
jle loc_1665
movsxd rbx, ebx
xor ebp, ebp
lea r13, [rsp+9E8h+var_368]
shl rbx, 3
lea r12, [rsp+9E8h+var_688]
jmp short loc_15BD
loc_15B0:
add rbp, 8
cmp rbx, rbp
jz loc_1665
loc_15BD:
mov rsi, [r13+rbp+0]; s2
mov rdi, [r12+rbp]; s1
call _strcmp
test eax, eax
jz short loc_15B0
xor eax, eax
loc_15D1:
mov rdx, [rsp+9E8h+var_40]
sub rdx, fs:28h
jnz loc_169E
add rsp, 9B8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15FA:
add r14, 1
cmp [rsp+9E8h+var_9AC], r14d
jg loc_1531
xor r15d, r15d
jmp loc_1583
loc_1611:
add [rsp+9E8h+var_9C8], 8
mov rdx, [rsp+9E8h+var_9C0]
mov rax, [rsp+9E8h+var_9C8]
cmp rax, rdx
jnz loc_14B7
xor ebx, ebx
jmp loc_1514
loc_1631:
add [rsp+9E8h+var_9D0], 8
mov rdx, [rsp+9E8h+var_9C0]
mov rax, [rsp+9E8h+var_9D0]
cmp rax, rdx
jnz loc_13ED
lea rax, [rsp+9E8h+var_9A8]
xor r15d, r15d
mov [rsp+9E8h+var_9E0], 0
mov [rsp+9E8h+var_9D8], rax
jmp loc_14A9
loc_1665:
mov eax, 1
jmp loc_15D1
loc_166F:
mov edx, [rsp+9E8h+var_9AC]
test edx, edx
jle short loc_1665
lea rax, [rsp+9E8h+var_9A8]
xor ebx, ebx
xor r15d, r15d
mov [rsp+9E8h+var_9E0], 0
mov [rsp+9E8h+var_9D8], rax
jmp loc_1520
loc_1694:
test ebx, ebx
setz al
jmp loc_15D1
loc_169E:
call ___stack_chk_fail | 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; // r15d
const char **v15; // r13
const char *v16; // rbp
long long v17; // rax
bool result; // al
unsigned long long v19; // rbp
long long v20; // rbx
long long v21; // [rsp+8h] [rbp-9E0h]
const char **v22; // [rsp+18h] [rbp-9D0h]
const char **v23; // [rsp+20h] [rbp-9C8h]
const char **v24; // [rsp+28h] [rbp-9C0h]
_QWORD v26[309]; // [rsp+40h] [rbp-9A8h] BYREF
v26[301] = __readfsqword(0x28u);
if ( a3 <= 0 )
{
if ( a4 > 0 )
{
v9 = 0;
v5 = 0;
v21 = 0LL;
goto LABEL_22;
}
return 1;
}
v23 = a1;
v22 = a1;
v24 = &a1[a3];
v4 = &a2[a4];
do
{
if ( a4 > 0 )
{
v5 = 0;
v21 = 0LL;
while ( 1 )
{
v6 = a2;
v7 = *v22;
do
{
while ( strcmp(v7, *v6) )
{
LABEL_6:
if ( ++v6 == v4 )
goto LABEL_13;
}
if ( v5 > 0 )
{
v8 = (const char **)v26;
while ( strcmp(*v8, v7) )
{
if ( ++v8 == &v26[v21] )
goto LABEL_12;
}
goto LABEL_6;
}
LABEL_12:
++v5;
++v6;
v26[v21] = v7;
v21 = v5;
}
while ( v6 != v4 );
LABEL_13:
if ( ++v22 == v24 )
goto LABEL_14;
}
}
++v22;
}
while ( v22 != v24 );
v5 = 0;
v21 = 0LL;
LABEL_14:
while ( v5 <= 0 )
{
if ( ++v23 == v24 )
{
v9 = 0;
goto LABEL_21;
}
}
v9 = 0;
do
{
v10 = (const char **)v26;
v11 = *v23;
do
{
if ( !strcmp(v11, *v10) )
{
v12 = v9++;
v26[v12 + 100] = v11;
}
++v10;
}
while ( &v26[v21] != v10 );
++v23;
}
while ( v23 != v24 );
LABEL_21:
if ( a4 <= 0 )
return v9 == 0;
LABEL_22:
v13 = 0LL;
while ( v5 <= 0 )
{
if ( a4 <= (int)++v13 )
{
v14 = 0;
goto LABEL_30;
}
}
v14 = 0;
do
{
v15 = (const char **)v26;
v16 = a2[v13];
do
{
if ( !strcmp(v16, *v15) )
{
v17 = v14++;
v26[v17 + 200] = v16;
}
++v15;
}
while ( &v26[v21] != v15 );
++v13;
}
while ( a4 > (int)v13 );
LABEL_30:
result = 0;
if ( v9 == v14 )
{
if ( v9 > 0 )
{
v19 = 0LL;
v20 = 8LL * v9;
while ( !strcmp((const char *)v26[v19 / 8 + 100], (const char *)v26[v19 / 8 + 200]) )
{
v19 += 8LL;
if ( v20 == v19 )
return 1;
}
return 0;
}
return 1;
}
return result;
} | 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 qword ptr [RSP + 0x18],RDI
MOV RDX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x28],RAX
MOVSXD RAX,dword ptr [RSP + 0x3c]
LEA R13,[RDX + RAX*0x8]
LAB_001013ed:
MOV ECX,dword ptr [RSP + 0x3c]
TEST ECX,ECX
JLE 0x00101631
LEA RAX,[RSP + 0x40]
XOR R15D,R15D
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
NOP
LAB_00101410:
MOV RAX,qword ptr [RSP + 0x18]
MOV RBX,qword ptr [RSP + 0x30]
MOV RBP,qword ptr [RAX]
JMP 0x00101429
LAB_00101420:
ADD RBX,0x8
CMP RBX,R13
JZ 0x00101490
LAB_00101429:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x00101420
TEST R15D,R15D
JLE 0x00101468
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x8]
MOV R14,RAX
LEA R12,[RAX + RCX*0x8]
NOP
LAB_00101450:
MOV RDI,qword ptr [R14]
MOV RSI,RBP
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101420
ADD R14,0x8
CMP R14,R12
JNZ 0x00101450
LAB_00101468:
MOV RAX,qword ptr [RSP + 0x8]
ADD R15D,0x1
ADD RBX,0x8
MOV qword ptr [RSP + RAX*0x8 + 0x40],RBP
MOVSXD RAX,R15D
MOV qword ptr [RSP + 0x8],RAX
CMP RBX,R13
JNZ 0x00101429
NOP word ptr [RAX + RAX*0x1]
LAB_00101490:
ADD qword ptr [RSP + 0x18],0x8
MOV RDX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,RDX
JNZ 0x00101410
LAB_001014a9:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
LEA R12,[RAX + RDX*0x8]
LAB_001014b7:
TEST R15D,R15D
JLE 0x00101611
XOR EBX,EBX
NOP word ptr [RAX + RAX*0x1]
LAB_001014c8:
MOV RAX,qword ptr [RSP + 0x20]
MOV R13,qword ptr [RSP + 0x10]
MOV RBP,qword ptr [RAX]
NOP dword ptr [RAX]
LAB_001014d8:
MOV RSI,qword ptr [R13]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001014f6
MOVSXD RAX,EBX
ADD EBX,0x1
MOV qword ptr [RSP + RAX*0x8 + 0x360],RBP
LAB_001014f6:
ADD R13,0x8
CMP R12,R13
JNZ 0x001014d8
ADD qword ptr [RSP + 0x20],0x8
MOV RDX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,RDX
JNZ 0x001014c8
LAB_00101514:
MOV EAX,dword ptr [RSP + 0x3c]
TEST EAX,EAX
JLE 0x00101694
LAB_00101520:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
XOR R14D,R14D
LEA R12,[RAX + RDX*0x8]
LAB_00101531:
TEST R15D,R15D
JLE 0x001015fa
XOR R15D,R15D
NOP dword ptr [RAX]
LAB_00101540:
MOV RAX,qword ptr [RSP + 0x30]
MOV R13,qword ptr [RSP + 0x10]
MOV RBP,qword ptr [RAX + R14*0x8]
NOP
LAB_00101550:
MOV RSI,qword ptr [R13]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x0010156f
MOVSXD RAX,R15D
ADD R15D,0x1
MOV qword ptr [RSP + RAX*0x8 + 0x680],RBP
LAB_0010156f:
ADD R13,0x8
CMP R12,R13
JNZ 0x00101550
ADD R14,0x1
CMP dword ptr [RSP + 0x3c],R14D
JG 0x00101540
LAB_00101583:
XOR EAX,EAX
CMP EBX,R15D
JNZ 0x001015d1
TEST EBX,EBX
JLE 0x00101665
MOVSXD RBX,EBX
XOR EBP,EBP
LEA R13,[RSP + 0x680]
SHL RBX,0x3
LEA R12,[RSP + 0x360]
JMP 0x001015bd
LAB_001015b0:
ADD RBP,0x8
CMP RBX,RBP
JZ 0x00101665
LAB_001015bd:
MOV RSI,qword ptr [R13 + RBP*0x1]
MOV RDI,qword ptr [R12 + RBP*0x1]
CALL 0x001010b0
TEST EAX,EAX
JZ 0x001015b0
XOR EAX,EAX
LAB_001015d1:
MOV RDX,qword ptr [RSP + 0x9a8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010169e
ADD RSP,0x9b8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015fa:
ADD R14,0x1
CMP dword ptr [RSP + 0x3c],R14D
JG 0x00101531
XOR R15D,R15D
JMP 0x00101583
LAB_00101611:
ADD qword ptr [RSP + 0x20],0x8
MOV RDX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,RDX
JNZ 0x001014b7
XOR EBX,EBX
JMP 0x00101514
LAB_00101631:
ADD qword ptr [RSP + 0x18],0x8
MOV RDX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,RDX
JNZ 0x001013ed
LEA RAX,[RSP + 0x40]
XOR R15D,R15D
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001014a9
LAB_00101665:
MOV EAX,0x1
JMP 0x001015d1
LAB_0010166f:
MOV EDX,dword ptr [RSP + 0x3c]
TEST EDX,EDX
JLE 0x00101665
LEA RAX,[RSP + 0x40]
XOR EBX,EBX
XOR R15D,R15D
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00101520
LAB_00101694:
TEST EBX,EBX
SETZ AL
JMP 0x001015d1
LAB_0010169e:
CALL 0x00101090 | 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 local_9a8 [100];
int8 local_688 [100];
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < param_3) {
puVar7 = param_1 + param_3;
local_9d0 = param_1;
LAB_001013ed:
if (param_4 < 1) goto LAB_00101631;
iVar9 = 0;
local_9e0 = 0;
do {
pcVar1 = (char *)*local_9d0;
puVar6 = param_2;
do {
while (iVar2 = strcmp(pcVar1,(char *)*puVar6), iVar2 == 0) {
if (0 < iVar9) {
puVar8 = local_9a8;
do {
iVar2 = strcmp((char *)*puVar8,pcVar1);
if (iVar2 == 0) goto LAB_00101420;
puVar8 = puVar8 + 1;
} while (puVar8 != local_9a8 + local_9e0);
}
iVar9 = iVar9 + 1;
puVar6 = puVar6 + 1;
local_688[local_9e0 + -100] = pcVar1;
local_9e0 = (long)iVar9;
if (puVar6 == param_2 + param_4) goto LAB_00101490;
}
LAB_00101420:
puVar6 = puVar6 + 1;
} while (puVar6 != param_2 + param_4);
LAB_00101490:
local_9d0 = local_9d0 + 1;
} while (local_9d0 != puVar7);
goto LAB_001014a9;
}
if (0 < param_4) {
iVar2 = 0;
iVar9 = 0;
local_9e0 = 0;
goto LAB_00101520;
}
goto LAB_00101665;
LAB_00101631:
local_9d0 = local_9d0 + 1;
if (local_9d0 == puVar7) goto code_r0x0010164a;
goto LAB_001013ed;
code_r0x0010164a:
iVar9 = 0;
local_9e0 = 0;
LAB_001014a9:
local_9d8 = local_9a8;
local_9c8 = param_1;
LAB_001014b7:
if (iVar9 < 1) goto LAB_00101611;
iVar2 = 0;
do {
pcVar1 = (char *)*local_9c8;
puVar6 = local_9d8;
do {
iVar3 = strcmp(pcVar1,(char *)*puVar6);
if (iVar3 == 0) {
lVar4 = (long)iVar2;
iVar2 = iVar2 + 1;
local_688[lVar4] = pcVar1;
}
puVar6 = puVar6 + 1;
} while (local_9d8 + local_9e0 != puVar6);
local_9c8 = local_9c8 + 1;
} while (local_9c8 != puVar7);
goto LAB_00101514;
LAB_00101611:
local_9c8 = local_9c8 + 1;
if (local_9c8 == puVar7) goto code_r0x0010162a;
goto LAB_001014b7;
code_r0x0010162a:
iVar2 = 0;
LAB_00101514:
if (0 < param_4) {
LAB_00101520:
local_9d8 = local_9a8;
lVar4 = 0;
LAB_00101531:
if (iVar9 < 1) goto LAB_001015fa;
iVar9 = 0;
do {
pcVar1 = (char *)param_2[lVar4];
puVar7 = local_9d8;
do {
iVar3 = strcmp(pcVar1,(char *)*puVar7);
if (iVar3 == 0) {
lVar5 = (long)iVar9;
iVar9 = iVar9 + 1;
local_368[lVar5] = pcVar1;
}
puVar7 = puVar7 + 1;
} while (local_9d8 + local_9e0 != puVar7);
lVar4 = lVar4 + 1;
} while ((int)lVar4 < param_4);
goto LAB_00101583;
}
bVar10 = iVar2 == 0;
goto LAB_001015d1;
LAB_001015fa:
lVar4 = lVar4 + 1;
if (param_4 <= (int)lVar4) goto code_r0x00101609;
goto LAB_00101531;
code_r0x00101609:
iVar9 = 0;
LAB_00101583:
bVar10 = false;
if (iVar2 != iVar9) goto LAB_001015d1;
if (0 < iVar2) {
lVar4 = 0;
do {
iVar9 = strcmp(*(char **)((long)local_688 + lVar4),*(char **)((long)local_368 + lVar4));
if (iVar9 != 0) {
bVar10 = false;
goto LAB_001015d1;
}
lVar4 = lVar4 + 8;
} while ((long)iVar2 * 8 != lVar4);
}
LAB_00101665:
bVar10 = true;
LAB_001015d1:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return bVar10;
} |
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 11b3 <func0+0x4a>
addl $0x1,-0x4(%rbp)
mov -0x14(%rbp),%eax
add %eax,-0x8(%rbp)
subl $0x2,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 11a5 <func0+0x3c>
mov -0x8(%rbp),%eax
cltd
idivl -0x4(%rbp)
leaveq
retq
| 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 [rbp+var_4], 0
jmp short loc_11B6
loc_11A8:
add [rbp+var_4], 1
mov eax, [rbp+var_14]
add [rbp+var_8], eax
sub [rbp+var_14], 2
loc_11B6:
cmp [rbp+var_14], 0
jg short loc_11A8
mov eax, [rbp+var_8]
cdq
idiv [rbp+var_4]
locret_11C3:
leave
retn | 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
{
puts("Invalid Input");
return 0xFFFFFFFFLL;
}
} | 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 0x001011b6
LAB_001011a8:
ADD dword ptr [RBP + -0x4],0x1
MOV EAX,dword ptr [RBP + -0x14]
ADD dword ptr [RBP + -0x8],EAX
SUB dword ptr [RBP + -0x14],0x2
LAB_001011b6:
CMP dword ptr [RBP + -0x14],0x0
JG 0x001011a8
MOV EAX,dword ptr [RBP + -0x8]
CDQ
IDIV dword ptr [RBP + -0x4]
LAB_001011c3:
LEAVE
RET | 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 + 1;
local_10 = local_10 + local_1c;
}
uVar1 = (long)local_10 / (long)local_c & 0xffffffff;
}
return uVar1;
} |
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 1195 <func0+0x2c>
shr %ecx
add $0x1,%ecx
cltd
idiv %ecx
retq
sub $0x8,%rsp
lea 0xe52(%rip),%rdi
callq 1060 <puts@plt>
mov $0xffffffff,%eax
add $0x8,%rsp
retq
| 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 short loc_1195
shr ecx, 1
add ecx, 1
loc_11A3:
cdq
idiv ecx
retn
loc_11A7:
sub rsp, 8
lea rdi, aInvalidInput; "Invalid Input"
call _puts
mov eax, 0FFFFFFFFh
add rsp, 8
retn | 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;
}
while ( a1 != v4 );
v1 = (v3 >> 1) + 1;
}
return (unsigned int)(v2 / v1);
}
else
{
puts("Invalid Input");
return 0xFFFFFFFFLL;
}
} | 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_001011a7:
SUB RSP,0x8
LEA RDI,[0x102004]
CALL 0x00101060
MOV EAX,0xffffffff
ADD RSP,0x8
RET | 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 = iVar1 + param_1;
param_1 = param_1 - 2;
} while (param_1 != iVar3 - (uVar2 & 0xfffffffe));
iVar3 = (uVar2 >> 1) + 1;
}
auVar4._0_4_ = iVar1 / iVar3;
auVar4._4_4_ = 0;
auVar4._8_4_ = iVar1 % iVar3;
auVar4._12_4_ = 0;
return auVar4;
}
puts("Invalid Input");
auVar5._8_8_ = extraout_RDX;
auVar5._0_8_ = 0xffffffff;
return auVar5;
} |
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 %ecx,%edi
cmp %edx,%ecx
jne 1198 <func0+0x28>
shr %esi
cltd
add $0x1,%esi
idiv %esi
retq
sub $0x8,%rsp
lea 0xe4d(%rip),%rdi
callq 1050 <puts@plt>
mov $0xffffffff,%eax
add $0x8,%rsp
retq
jmpq 1060 <func0.cold>
nopl 0x0(%rax,%rax,1)
| 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
cmp edx, ecx
jnz short loc_1198
shr esi, 1
cdq
add esi, 1
idiv esi
retn
loc_11AC:
sub rsp, 8
lea rdi, aInvalidInput; "Invalid Input"
call _puts
mov eax, 0FFFFFFFFh
add rsp, 8
retn
loc_11C6:
jmp func0_cold | 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;
if ( v2 == v3 )
break;
v2 -= 2;
}
return (unsigned int)(v4 / (int)((v1 >> 1) + 1));
}
else
{
puts("Invalid Input");
return 0xFFFFFFFFLL;
}
} | 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 ESI
RET
LAB_001011ac:
SUB RSP,0x8
LEA RDI,[0x102004]
CALL 0x00101050
MOV EAX,0xffffffff
ADD RSP,0x8
RET
LAB_001011c6:
JMP 0x00101060 | 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 < (int)param_1) {
iVar3 = 0;
uVar2 = param_1 - 2;
uVar5 = param_1;
while( true ) {
uVar4 = uVar2;
iVar3 = iVar3 + uVar5;
if (uVar4 == (param_1 - 2) - (param_1 - 1 & 0xfffffffe)) break;
uVar2 = uVar4 - 2;
uVar5 = uVar4;
}
lVar1 = (long)(int)((param_1 - 1 >> 1) + 1);
auVar6._0_8_ = (long)iVar3 / lVar1 & 0xffffffff;
auVar6._8_8_ = (long)iVar3 % lVar1 & 0xffffffff;
return auVar6;
}
auVar7 = func0_cold();
return auVar7;
} |
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 0xe6a(%rip),%xmm1
shr $0x2,%edx
pxor %xmm0,%xmm0
nopl (%rax)
movdqa %xmm1,%xmm2
add $0x1,%eax
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
cmp %edx,%eax
jne 11c0 <func0+0x50>
movdqa %xmm0,%xmm1
mov %ecx,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
mov %edx,%esi
movdqa %xmm0,%xmm1
neg %esi
psrldq $0x4,%xmm1
lea (%rdi,%rsi,2),%edi
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %edx,%ecx
je 1211 <func0+0xa1>
nopl 0x0(%rax)
add %edi,%eax
sub $0x2,%edi
test %edi,%edi
jg 1208 <func0+0x98>
cltd
idiv %ecx
retq
nopl (%rax)
xor %eax,%eax
jmp 1208 <func0+0x98>
sub $0x8,%rsp
lea 0xddd(%rip),%rdi
callq 1050 <puts@plt>
mov $0xffffffff,%eax
add $0x8,%rsp
retq
jmpq 1060 <func0.cold>
nopl 0x0(%rax,%rax,1)
| 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 xmm1, cs:xmmword_2020
shr ecx, 2
pxor xmm0, xmm0
nop
loc_11C0:
movdqa xmm2, xmm1
add eax, 1
paddd xmm1, xmm3
paddd xmm0, xmm2
cmp eax, ecx
jnz short loc_11C0
movdqa xmm1, xmm0
mov ecx, esi
psrldq xmm1, 8
and ecx, 0FFFFFFFCh
paddd xmm0, xmm1
neg ecx
movdqa xmm1, xmm0
lea edx, [rdx+rcx*2]
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short loc_1256
loc_1201:
lea ecx, [rdx-2]
add eax, edx
test ecx, ecx
jle short loc_1256
add eax, ecx
lea ecx, [rdx-4]
test ecx, ecx
jle short loc_1256
add eax, ecx
lea ecx, [rdx-6]
test ecx, ecx
jle short loc_1256
add eax, ecx
lea ecx, [rdx-8]
test ecx, ecx
jle short loc_1256
add eax, ecx
lea ecx, [rdx-0Ah]
test ecx, ecx
jle short loc_1256
add eax, ecx
lea ecx, [rdx-0Ch]
test ecx, ecx
jle short loc_1256
add eax, ecx
lea ecx, [rdx-0Eh]
test ecx, ecx
jle short loc_1256
add eax, ecx
lea ecx, [rdx-10h]
test ecx, ecx
jle short loc_1256
add eax, ecx
sub edx, 12h
lea ecx, [rax+rdx]
test edx, edx
cmovg eax, ecx
loc_1256:
cdq
idiv esi
retn
loc_1260:
xor eax, eax
jmp short loc_1201
loc_1264:
sub rsp, 8
lea rdi, s; "Invalid Input"
call _puts
mov eax, 0FFFFFFFFh
add rsp, 8
retn
loc_127E:
jmp func0_cold | 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_cold(a1, a2, (unsigned int)a1);
v3 = ((unsigned int)(a1 - 1) >> 1) + 1;
if ( (unsigned int)(a1 - 1) <= 0x13 )
{
v10 = 0;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2030);
v5 = 0;
v6 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(a1), 0), (__m128i)xmmword_2020);
v7 = 0LL;
do
{
v8 = v6;
++v5;
v6 = _mm_add_epi32(v6, si128);
v7 = _mm_add_epi32(v7, v8);
}
while ( v5 != (unsigned int)v3 >> 2 );
v9 = _mm_add_epi32(v7, _mm_srli_si128(v7, 8));
v2 = a1 - 2 * (v3 & 0xFFFFFFFC);
v10 = _mm_cvtsi128_si32(_mm_add_epi32(v9, _mm_srli_si128(v9, 4)));
if ( (v3 & 3) == 0 )
return (unsigned int)(v10 / v3);
}
v10 += v2;
if ( v2 - 2 > 0 )
{
v10 += v2 - 2;
if ( v2 - 4 > 0 )
{
v10 += v2 - 4;
if ( v2 - 6 > 0 )
{
v10 += v2 - 6;
if ( v2 - 8 > 0 )
{
v10 += v2 - 8;
if ( v2 - 10 > 0 )
{
v10 += v2 - 10;
if ( v2 - 12 > 0 )
{
v10 += v2 - 12;
if ( v2 - 14 > 0 )
{
v10 += v2 - 14;
if ( v2 - 16 > 0 )
{
v10 += v2 - 16;
v11 = v2 - 18;
if ( v11 > 0 )
v10 += v11;
}
}
}
}
}
}
}
}
return (unsigned int)(v10 / v3);
}
puts("Invalid Input");
return 0xFFFFFFFFLL;
} | 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
PXOR XMM0,XMM0
NOP
LAB_001011c0:
MOVDQA XMM2,XMM1
ADD EAX,0x1
PADDD XMM1,XMM3
PADDD XMM0,XMM2
CMP EAX,ECX
JNZ 0x001011c0
MOVDQA XMM1,XMM0
MOV ECX,ESI
PSRLDQ XMM1,0x8
AND ECX,0xfffffffc
PADDD XMM0,XMM1
NEG ECX
MOVDQA XMM1,XMM0
LEA EDX,[RDX + RCX*0x2]
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x00101256
LAB_00101201:
LEA ECX,[RDX + -0x2]
ADD EAX,EDX
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
LEA ECX,[RDX + -0x4]
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
LEA ECX,[RDX + -0x6]
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
LEA ECX,[RDX + -0x8]
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
LEA ECX,[RDX + -0xa]
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
LEA ECX,[RDX + -0xc]
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
LEA ECX,[RDX + -0xe]
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
LEA ECX,[RDX + -0x10]
TEST ECX,ECX
JLE 0x00101256
ADD EAX,ECX
SUB EDX,0x12
LEA ECX,[RAX + RDX*0x1]
TEST EDX,EDX
CMOVG EAX,ECX
LAB_00101256:
CDQ
IDIV ESI
RET
LAB_00101260:
XOR EAX,EAX
JMP 0x00101201
LAB_00101264:
SUB RSP,0x8
LEA RDI,[0x102004]
CALL 0x00101050
MOV EAX,0xffffffff
ADD RSP,0x8
RET
LAB_0010127e:
JMP 0x00101060 | /* 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 ((param_1 & 1) == 0) {
puts("Invalid Input");
auVar12._8_8_ = extraout_RDX;
auVar12._0_8_ = 0xffffffff;
return auVar12;
}
if ((int)param_1 < 1) {
auVar12 = func0_cold();
return auVar12;
}
uVar1 = (param_1 - 1 >> 1) + 1;
if (param_1 - 1 < 0x14) {
iVar5 = 0;
}
else {
uVar2 = 0;
iVar4 = 0;
iVar6 = 0;
iVar7 = 0;
iVar8 = 0;
iVar5 = param_1 + _DAT_00102020;
iVar3 = param_1 + _UNK_00102024;
iVar9 = param_1 + _UNK_00102028;
iVar10 = param_1 + _UNK_0010202c;
do {
uVar2 = uVar2 + 1;
iVar4 = iVar4 + iVar5;
iVar6 = iVar6 + iVar3;
iVar7 = iVar7 + iVar9;
iVar8 = iVar8 + iVar10;
iVar5 = iVar5 + _DAT_00102030;
iVar3 = iVar3 + _UNK_00102034;
iVar9 = iVar9 + _UNK_00102038;
iVar10 = iVar10 + _UNK_0010203c;
} while (uVar2 != uVar1 >> 2);
param_1 = param_1 + (uVar1 & 0xfffffffc) * -2;
iVar5 = iVar4 + iVar7 + iVar6 + iVar8;
iVar3 = iVar5;
if ((uVar1 & 3) == 0) goto LAB_00101256;
}
iVar3 = iVar5 + param_1;
if (0 < (int)(param_1 - 2)) {
iVar3 = iVar5 + param_1 + (param_1 - 2);
if (0 < (int)(param_1 - 4)) {
iVar3 = iVar3 + (param_1 - 4);
if (0 < (int)(param_1 - 6)) {
iVar3 = iVar3 + (param_1 - 6);
if (0 < (int)(param_1 - 8)) {
iVar3 = iVar3 + (param_1 - 8);
if (0 < (int)(param_1 - 10)) {
iVar3 = iVar3 + (param_1 - 10);
if (0 < (int)(param_1 - 0xc)) {
iVar3 = iVar3 + (param_1 - 0xc);
if (0 < (int)(param_1 - 0xe)) {
iVar3 = iVar3 + (param_1 - 0xe);
if (0 < (int)(param_1 - 0x10)) {
iVar3 = iVar3 + (param_1 - 0x10);
if (0 < (int)(param_1 - 0x12)) {
iVar3 = iVar3 + (param_1 - 0x12);
}
}
}
}
}
}
}
}
}
LAB_00101256:
auVar11._0_4_ = iVar3 / (int)uVar1;
auVar11._4_4_ = 0;
auVar11._8_4_ = iVar3 % (int)uVar1;
auVar11._12_4_ = 0;
return auVar11;
} |
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] <= i && arr[j-1] > 0) {
dp[i][j] += dp[i / arr[j-1]][j-1] + 1;
}
}
}
return dp[k][n];
}
| 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
lea 0x1(%rax),%esi
mov -0x70(%rbp),%eax
lea 0x1(%rax),%edi
movslq %esi,%rax
sub $0x1,%rax
mov %rax,-0x50(%rbp)
movslq %esi,%rax
mov %rax,%rcx
mov $0x0,%ebx
movslq %esi,%rax
lea 0x0(,%rax,4),%rcx
movslq %edi,%rax
sub $0x1,%rax
mov %rax,-0x48(%rbp)
movslq %esi,%rax
mov %rax,%r14
mov $0x0,%r15d
movslq %edi,%rax
mov %rax,%r12
mov $0x0,%r13d
mov %r15,%rdx
imul %r12,%rdx
mov %r13,%rax
imul %r14,%rax
lea (%rdx,%rax,1),%rbx
mov %r14,%rax
mul %r12
add %rdx,%rbx
mov %rbx,%rdx
movslq %esi,%rax
mov %rax,%r10
mov $0x0,%r11d
movslq %edi,%rax
mov %rax,%r8
mov $0x0,%r9d
mov %r11,%rdx
imul %r8,%rdx
mov %r9,%rax
imul %r10,%rax
lea (%rdx,%rax,1),%rbx
mov %r10,%rax
mul %r8
lea (%rbx,%rdx,1),%r8
mov %r8,%rdx
movslq %esi,%rdx
movslq %edi,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 129c <func0+0x133>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1285 <func0+0x11c>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 12c6 <func0+0x15d>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x54(%rbp)
jmp 1320 <func0+0x1b7>
movl $0x0,-0x58(%rbp)
jmp 1314 <func0+0x1ab>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x58(%rbp),%edx
movslq %edx,%rsi
mov -0x54(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
movl $0x0,(%rax,%rdx,4)
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x6c(%rbp),%eax
jle 12eb <func0+0x182>
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x70(%rbp),%eax
jle 12e2 <func0+0x179>
movl $0x1,-0x5c(%rbp)
jmpq 145d <func0+0x2f4>
movl $0x1,-0x60(%rbp)
jmpq 144d <func0+0x2e4>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x60(%rbp),%eax
lea -0x1(%rax),%edx
mov %rcx,%r8
shr $0x2,%r8
mov -0x40(%rbp),%rax
movslq %edx,%rsi
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%edx
mov -0x40(%rbp),%rax
mov -0x60(%rbp),%esi
movslq %esi,%rdi
mov -0x5c(%rbp),%esi
movslq %esi,%rsi
imul %r8,%rsi
add %rdi,%rsi
mov %edx,(%rax,%rsi,4)
mov -0x60(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x5c(%rbp)
jl 1449 <func0+0x2e0>
mov -0x60(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 1449 <func0+0x2e0>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x60(%rbp),%edx
movslq %edx,%rsi
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%esi
mov %rcx,%r8
shr $0x2,%r8
mov -0x60(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%ebx
mov -0x5c(%rbp),%eax
cltd
idiv %ebx
mov %eax,%r9d
mov -0x60(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x40(%rbp),%rax
movslq %edx,%rdi
movslq %r9d,%rdx
imul %r8,%rdx
add %rdi,%rdx
mov (%rax,%rdx,4),%eax
add $0x1,%eax
mov %rcx,%r8
shr $0x2,%r8
add %eax,%esi
mov -0x40(%rbp),%rax
mov -0x60(%rbp),%edx
movslq %edx,%rdi
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
imul %r8,%rdx
add %rdi,%rdx
mov %esi,(%rax,%rdx,4)
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x6c(%rbp),%eax
jle 1340 <func0+0x1d7>
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x70(%rbp),%eax
jle 1334 <func0+0x1cb>
shr $0x2,%rcx
mov %rcx,%rsi
mov -0x40(%rbp),%rax
mov -0x6c(%rbp),%edx
movslq %edx,%rcx
mov -0x70(%rbp),%edx
movslq %edx,%rdx
imul %rsi,%rdx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov -0x78(%rbp),%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 14a2 <func0+0x339>
callq 1060 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 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]
lea r9d, [rax+1]
movsxd rax, r8d
sub rax, 1
mov [rbp+var_30], rax
movsxd rax, r8d
lea rcx, ds:0[rax*4]
movsxd rax, r9d
sub rax, 1
mov [rbp+var_28], rax
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rdx, r8d
movsxd rax, r9d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rsi, rax
and rsi, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rsi
loc_1265:
cmp rsp, rdx
jz short loc_127C
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_1265
loc_127C:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12A6
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12A6:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_40], 0
jmp short loc_1300
loc_12C2:
mov [rbp+var_3C], 0
jmp short loc_12F4
loc_12CB:
mov rdi, rcx
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_3C]
movsxd rsi, edx
mov edx, [rbp+var_40]
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov dword ptr [rax+rdx*4], 0
add [rbp+var_3C], 1
loc_12F4:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_4C]
jle short loc_12CB
add [rbp+var_40], 1
loc_1300:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_50]
jle short loc_12C2
mov [rbp+var_38], 1
jmp loc_143D
loc_1314:
mov [rbp+var_34], 1
jmp loc_142D
loc_1320:
mov rdi, rcx
shr rdi, 2
mov eax, [rbp+var_34]
lea edx, [rax-1]
mov r8, rcx
shr r8, 2
mov rax, [rbp+var_20]
movsxd rsi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov edx, [rax+rdx*4]
mov rax, [rbp+var_20]
mov esi, [rbp+var_34]
movsxd rdi, esi
mov esi, [rbp+var_38]
movsxd rsi, esi
imul rsi, r8
add rsi, rdi
mov [rax+rsi*4], edx
mov eax, [rbp+var_34]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_38], eax
jl loc_1429
mov eax, [rbp+var_34]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
test eax, eax
jle loc_1429
mov rdi, rcx
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rsi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov esi, [rax+rdx*4]
mov r8, rcx
shr r8, 2
mov eax, [rbp+var_34]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_48]
add rax, rdx
mov edi, [rax]
mov eax, [rbp+var_38]
cdq
idiv edi
mov r9d, eax
mov eax, [rbp+var_34]
lea edx, [rax-1]
mov rax, [rbp+var_20]
movsxd rdi, edx
movsxd rdx, r9d
imul rdx, r8
add rdx, rdi
mov eax, [rax+rdx*4]
add eax, 1
mov r8, rcx
shr r8, 2
add esi, eax
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdi, edx
mov edx, [rbp+var_38]
movsxd rdx, edx
imul rdx, r8
add rdx, rdi
mov [rax+rdx*4], esi
loc_1429:
add [rbp+var_34], 1
loc_142D:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_4C]
jle loc_1320
add [rbp+var_38], 1
loc_143D:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_50]
jle loc_1314
shr rcx, 2
mov rsi, rcx
mov rax, [rbp+var_20]
mov edx, [rbp+var_4C]
movsxd rcx, edx
mov edx, [rbp+var_50]
movsxd rdx, edx
imul rdx, rsi
add rdx, rcx
mov eax, [rax+rdx*4]
mov rsp, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1481
call ___stack_chk_fail
loc_1481:
mov rbx, [rbp+var_8]
leave
retn | 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; // [rsp+20h] [rbp-38h]
int m; // [rsp+24h] [rbp-34h]
long long v14; // [rsp+28h] [rbp-30h]
long long v15; // [rsp+30h] [rbp-28h]
int *v16; // [rsp+38h] [rbp-20h]
unsigned long long v17; // [rsp+40h] [rbp-18h]
v9 = a1;
v8 = a2;
v7 = a3;
v17 = __readfsqword(0x28u);
v14 = a2 + 1 - 1LL;
v3 = 4LL * (a2 + 1);
v15 = a3 + 1 - 1LL;
v4 = 16 * ((4 * (a2 + 1) * (long long)(a3 + 1) + 15) / 0x10uLL);
while ( &v7 != (int *)((char *)&v7 - (v4 & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v7 + (v4 & 0xFFF) - 8) = *(_QWORD *)((char *)&v7 + (v4 & 0xFFF) - 8);
v16 = &v7;
for ( i = 0; i <= v7; ++i )
{
for ( j = 0; j <= v8; ++j )
v16[j + (v3 >> 2) * i] = 0;
}
for ( k = 1; k <= v7; ++k )
{
for ( m = 1; m <= v8; ++m )
{
v16[m + (v3 >> 2) * k] = v16[m - 1 + (v3 >> 2) * k];
if ( k >= *(_DWORD *)(4LL * m - 4 + v9) && *(int *)(4LL * m - 4 + v9) > 0 )
v16[m + (v3 >> 2) * k] += v16[m - 1 + (v3 >> 2) * (k / *(_DWORD *)(4LL * m - 4 + v9))] + 1;
}
}
return (unsigned int)v16[v8 + (v3 >> 2) * v7];
} | 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 [RBP + -0x50]
LEA R9D,[RAX + 0x1]
MOVSXD RAX,R8D
SUB RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOVSXD RAX,R8D
LEA RCX,[RAX*0x4]
MOVSXD RAX,R9D
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RDX,R8D
MOVSXD RAX,R9D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RSI,RAX
AND RSI,-0x1000
MOV RDX,RSP
SUB RDX,RSI
LAB_00101265:
CMP RSP,RDX
JZ 0x0010127c
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101265
LAB_0010127c:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012a6
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012a6:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101300
LAB_001012c2:
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001012f4
LAB_001012cb:
MOV RDI,RCX
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV dword ptr [RAX + RDX*0x4],0x0
ADD dword ptr [RBP + -0x3c],0x1
LAB_001012f4:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x4c]
JLE 0x001012cb
ADD dword ptr [RBP + -0x40],0x1
LAB_00101300:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x50]
JLE 0x001012c2
MOV dword ptr [RBP + -0x38],0x1
JMP 0x0010143d
LAB_00101314:
MOV dword ptr [RBP + -0x34],0x1
JMP 0x0010142d
LAB_00101320:
MOV RDI,RCX
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + -0x1]
MOV R8,RCX
SHR R8,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x34]
MOVSXD RDI,ESI
MOV ESI,dword ptr [RBP + -0x38]
MOVSXD RSI,ESI
IMUL RSI,R8
ADD RSI,RDI
MOV dword ptr [RAX + RSI*0x4],EDX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x38],EAX
JL 0x00101429
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x00101429
MOV RDI,RCX
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV ESI,dword ptr [RAX + RDX*0x4]
MOV R8,RCX
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x38]
CDQ
IDIV EDI
MOV R9D,EAX
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDI,EDX
MOVSXD RDX,R9D
IMUL RDX,R8
ADD RDX,RDI
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD EAX,0x1
MOV R8,RCX
SHR R8,0x2
ADD ESI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDI,EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RDI
MOV dword ptr [RAX + RDX*0x4],ESI
LAB_00101429:
ADD dword ptr [RBP + -0x34],0x1
LAB_0010142d:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x4c]
JLE 0x00101320
ADD dword ptr [RBP + -0x38],0x1
LAB_0010143d:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x50]
JLE 0x00101314
SHR RCX,0x2
MOV RSI,RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4c]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x50]
MOVSXD RDX,EDX
IMUL RDX,RSI
ADD RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101481
CALL 0x00101060
LAB_00101481:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | 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;
local_50 = param_1;
local_54 = param_2;
local_58 = param_3;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
param_2 = param_2 + 1;
local_38 = (long)param_2 + -1;
uVar2 = (ulong)param_2;
local_30 = (long)(param_3 + 1) + -1;
uVar3 = (((long)(param_3 + 1) * (long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (piVar4 = &local_58; piVar4 != (int *)((long)&local_58 - (uVar3 & 0xfffffffffffff000));
piVar4 = (int *)((long)piVar4 + -0x1000)) {
*(int8 *)((long)piVar4 + -8) = *(int8 *)((long)piVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
for (local_48 = 0; local_48 <= local_58; local_48 = local_48 + 1) {
for (local_44 = 0; local_44 <= local_54; local_44 = local_44 + 1) {
*(int4 *)
((long)piVar4 + ((long)local_48 * (uVar2 & 0x3fffffffffffffff) + (long)local_44) * 4 + lVar1)
= 0;
}
}
for (local_40 = 1; local_40 <= local_58; local_40 = local_40 + 1) {
for (local_3c = 1; local_3c <= local_54; local_3c = local_3c + 1) {
*(int4 *)
((long)piVar4 + ((long)local_40 * (uVar2 & 0x3fffffffffffffff) + (long)local_3c) * 4 + lVar1)
= *(int4 *)
((long)piVar4 +
((long)local_40 * (uVar2 & 0x3fffffffffffffff) + (long)(local_3c + -1)) * 4 + lVar1);
if ((*(int *)(local_50 + (long)local_3c * 4 + -4) <= local_40) &&
(0 < *(int *)(local_50 + (long)local_3c * 4 + -4))) {
*(int *)((long)piVar4 +
((long)local_40 * (uVar2 & 0x3fffffffffffffff) + (long)local_3c) * 4 + lVar1) =
*(int *)((long)piVar4 +
((long)local_40 * (uVar2 & 0x3fffffffffffffff) + (long)local_3c) * 4 + lVar1) +
*(int *)((long)piVar4 +
((long)(local_40 / *(int *)(local_50 + (long)local_3c * 4 + -4)) *
(uVar2 & 0x3fffffffffffffff) + (long)(local_3c + -1)) * 4 + lVar1) + 1;
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
local_28 = (int *)((long)piVar4 + lVar1);
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)
((long)piVar4 +
((long)local_58 * (uVar2 & 0x3fffffffffffffff) + (long)local_54) * 4 + lVar1);
} |
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] <= i && arr[j-1] > 0) {
dp[i][j] += dp[i / arr[j-1]][j-1] + 1;
}
}
}
return dp[k][n];
}
| 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,-0x48(%rbp)
add $0x1,%edx
movslq %edx,%rax
imul %rcx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je 11e7 <func0+0x7e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11d0 <func0+0x67>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11fd <func0+0x94>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%rax
mov %rax,-0x60(%rbp)
mov %rax,%r15
mov -0x54(%rbp),%ecx
test %ecx,%ecx
js 124f <func0+0xe6>
mov %r13d,%esi
lea 0x4(%rax,%rsi,4),%rdx
lea 0x1(%rcx),%edi
mov $0x0,%ecx
not %rsi
shl $0x2,%rsi
mov -0x48(%rbp),%r8
jmp 1235 <func0+0xcc>
add $0x1,%ecx
add %r8,%rdx
cmp %edi,%ecx
je 124f <func0+0xe6>
lea (%rsi,%rdx,1),%rax
test %r13d,%r13d
js 122b <func0+0xc2>
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 123e <func0+0xd5>
jmp 122b <func0+0xc2>
mov -0x54(%rbp),%esi
test %esi,%esi
jle 12ea <func0+0x181>
mov -0x48(%rbp),%rdx
mov %rdx,%rax
shr $0x2,%rax
mov -0x60(%rbp),%rcx
lea 0x4(%rcx,%rdx,1),%r14
lea 0x1(%rsi),%edx
mov %edx,-0x50(%rbp)
mov $0x1,%esi
lea -0x1(%r13),%r12d
mov %r13d,-0x4c(%rbp)
mov %rax,%r13
jmp 12d6 <func0+0x16d>
lea 0x1(%rdi),%rax
add $0x4,%rcx
cmp %rdi,%r12
je 12ca <func0+0x161>
mov %rax,%rdi
mov -0x4(%rcx),%r10d
mov %r10d,(%rcx)
mov (%rbx,%rdi,4),%r8d
test %r8d,%r8d
jle 1286 <func0+0x11d>
cmp %esi,%r8d
jg 1286 <func0+0x11d>
movslq %edi,%r9
mov %esi,%eax
cltd
idiv %r8d
cltq
imul %r13,%rax
add %r9,%rax
mov (%r15,%rax,4),%eax
lea 0x1(%r10,%rax,1),%eax
mov %eax,(%rcx)
jmp 1286 <func0+0x11d>
add $0x1,%esi
add -0x48(%rbp),%r14
cmp -0x50(%rbp),%esi
je 12e6 <func0+0x17d>
mov %r14,%rcx
mov $0x0,%edi
cmpl $0x0,-0x4c(%rbp)
jg 1296 <func0+0x12d>
jmp 12ca <func0+0x161>
mov -0x4c(%rbp),%r13d
movslq %r13d,%r13
movslq -0x54(%rbp),%rdx
mov -0x48(%rbp),%rax
shr $0x2,%rax
imul %rdx,%rax
add %r13,%rax
mov -0x60(%rbp),%rbx
mov (%rbx,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 1325 <func0+0x1bc>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| 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[rdx*4]
mov [rbp+var_48], rax
lea eax, [rdi+1]
cdqe
imul rax, rdx
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11CE:
cmp rsp, rdx
jz short loc_11E5
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_11CE
loc_11E5:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11FB
or [rsp+rax+60h+var_68], 0
loc_11FB:
mov r15, rsp
mov eax, [rbp+var_54]
test eax, eax
js short loc_1243
mov esi, r13d
lea rdx, [r15+rsi*4+4]
lea edi, [rax+1]
mov ecx, 0
not rsi
shl rsi, 2
jmp short loc_1238
loc_121E:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_121E
loc_122D:
add ecx, 1
add rdx, [rbp+var_48]
cmp ecx, edi
jz short loc_1243
loc_1238:
lea rax, [rsi+rdx]
test r13d, r13d
jns short loc_121E
jmp short loc_122D
loc_1243:
mov edi, [rbp+var_54]
test edi, edi
jle loc_12D7
mov rdx, [rbp+var_48]
mov rax, rdx
shr rax, 2
lea r14, [r15+rdx+4]
lea edx, [rdi+1]
mov [rbp+var_50], edx
mov r10d, 1
mov r12d, r13d
mov [rbp+var_4C], r13d
mov r13, rax
jmp short loc_12C3
loc_1276:
add rcx, 1
add rsi, 4
cmp r12, rcx
jz short loc_12B5
loc_1283:
mov r9d, [rsi-4]
mov [rsi], r9d
mov edi, [rbx+rcx*4]
test edi, edi
jle short loc_1276
cmp edi, r10d
jg short loc_1276
movsxd r8, ecx
mov eax, r10d
cdq
idiv edi
cdqe
imul rax, r13
add r8, rax
mov eax, [r15+r8*4]
lea eax, [r9+rax+1]
mov [rsi], eax
jmp short loc_1276
loc_12B5:
add r10d, 1
add r14, [rbp+var_48]
cmp r10d, [rbp+var_50]
jz short loc_12D3
loc_12C3:
mov rsi, r14
mov ecx, 0
cmp [rbp+var_4C], 0
jg short loc_1283
jmp short loc_12B5
loc_12D3:
mov r13d, [rbp+var_4C]
loc_12D7:
movsxd rax, r13d
movsxd rcx, [rbp+var_54]
mov rdx, [rbp+var_48]
shr rdx, 2
imul rdx, rcx
add rax, rdx
mov eax, [r15+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_130F
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_130F:
call ___stack_chk_fail | 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
long long v17; // r12
unsigned long long v18; // r13
long long v19; // rcx
_DWORD *v20; // rsi
int v21; // r9d
int v22; // edi
_BYTE v25[12]; // [rsp+8h] [rbp-60h] BYREF
int v26; // [rsp+14h] [rbp-54h]
int v27; // [rsp+18h] [rbp-50h]
int v28; // [rsp+1Ch] [rbp-4Ch]
unsigned long long v29; // [rsp+20h] [rbp-48h]
unsigned long long v30; // [rsp+30h] [rbp-38h]
v4 = a2;
v26 = a3;
v30 = __readfsqword(0x28u);
v6 = (int)(a2 + 1);
v29 = 4 * v6;
v7 = &v25[-((4 * v6 * (a3 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)];
while ( v25 != v7 )
;
v8 = (4 * ((_WORD)a2 + 1) * ((_WORD)a3 + 1) + 15) & 0xFF0;
v9 = alloca(v8);
if ( ((4 * ((_WORD)a2 + 1) * ((_WORD)a3 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)&v25[v8 - 8] = *(_QWORD *)&v25[v8 - 8];
if ( v26 >= 0 )
{
v10 = &v25[4 * a2 + 4];
v11 = v26 + 1;
v12 = 0;
v13 = 4 * ~(unsigned long long)a2;
do
{
v14 = &v10[v13];
if ( v4 >= 0 )
{
do
*v14++ = 0;
while ( v14 != (_DWORD *)v10 );
}
++v12;
v10 += v29;
}
while ( v12 != v11 );
}
if ( v26 > 0 )
{
v15 = &v25[v29 + 4];
v27 = v26 + 1;
v16 = 1;
v17 = (unsigned int)v4;
v28 = v4;
v18 = v29 >> 2;
do
{
v20 = v15;
v19 = 0LL;
if ( v28 > 0 )
{
do
{
v21 = *(v20 - 1);
*v20 = v21;
v22 = *(_DWORD *)(a1 + 4 * v19);
if ( v22 > 0 && v22 <= v16 )
*v20 = v21 + *(_DWORD *)&v25[4 * v18 * (v16 / v22) + 4 * (int)v19] + 1;
++v19;
++v20;
}
while ( v17 != v19 );
}
++v16;
v15 += v29;
}
while ( v16 != v27 );
v4 = v28;
}
return *(unsigned int *)&v25[4 * v26 * (v29 >> 2) + 4 * v4];
} | 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
LEA EAX,[RDI + 0x1]
CDQE
IMUL RAX,RDX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011ce:
CMP RSP,RDX
JZ 0x001011e5
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ce
LAB_001011e5:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011fb
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011fb:
MOV R15,RSP
MOV EAX,dword ptr [RBP + -0x54]
TEST EAX,EAX
JS 0x00101243
MOV ESI,R13D
LEA RDX,[R15 + RSI*0x4 + 0x4]
LEA EDI,[RAX + 0x1]
MOV ECX,0x0
NOT RSI
SHL RSI,0x2
JMP 0x00101238
LAB_0010121e:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010121e
LAB_0010122d:
ADD ECX,0x1
ADD RDX,qword ptr [RBP + -0x48]
CMP ECX,EDI
JZ 0x00101243
LAB_00101238:
LEA RAX,[RSI + RDX*0x1]
TEST R13D,R13D
JNS 0x0010121e
JMP 0x0010122d
LAB_00101243:
MOV EDI,dword ptr [RBP + -0x54]
TEST EDI,EDI
JLE 0x001012d7
MOV RDX,qword ptr [RBP + -0x48]
MOV RAX,RDX
SHR RAX,0x2
LEA R14,[R15 + RDX*0x1 + 0x4]
LEA EDX,[RDI + 0x1]
MOV dword ptr [RBP + -0x50],EDX
MOV R10D,0x1
MOV R12D,R13D
MOV dword ptr [RBP + -0x4c],R13D
MOV R13,RAX
JMP 0x001012c3
LAB_00101276:
ADD RCX,0x1
ADD RSI,0x4
CMP R12,RCX
JZ 0x001012b5
LAB_00101283:
MOV R9D,dword ptr [RSI + -0x4]
MOV dword ptr [RSI],R9D
MOV EDI,dword ptr [RBX + RCX*0x4]
TEST EDI,EDI
JLE 0x00101276
CMP EDI,R10D
JG 0x00101276
MOVSXD R8,ECX
MOV EAX,R10D
CDQ
IDIV EDI
CDQE
IMUL RAX,R13
ADD R8,RAX
MOV EAX,dword ptr [R15 + R8*0x4]
LEA EAX,[R9 + RAX*0x1 + 0x1]
MOV dword ptr [RSI],EAX
JMP 0x00101276
LAB_001012b5:
ADD R10D,0x1
ADD R14,qword ptr [RBP + -0x48]
CMP R10D,dword ptr [RBP + -0x50]
JZ 0x001012d3
LAB_001012c3:
MOV RSI,R14
MOV ECX,0x0
CMP dword ptr [RBP + -0x4c],0x0
JG 0x00101283
JMP 0x001012b5
LAB_001012d3:
MOV R13D,dword ptr [RBP + -0x4c]
LAB_001012d7:
MOVSXD RAX,R13D
MOVSXD RCX,dword ptr [RBP + -0x54]
MOV RDX,qword ptr [RBP + -0x48]
SHR RDX,0x2
IMUL RDX,RCX
ADD RAX,RDX
MOV EAX,dword ptr [R15 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010130f
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010130f:
CALL 0x00101060 | 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 local_50;
long local_40;
uVar10 = (ulong)param_2;
local_5c = param_3;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = (long)(int)(param_2 + 1) * 4;
uVar3 = (long)(param_3 + 1) * (long)(int)(param_2 + 1) * 4 + 0xf;
for (puVar7 = auStack_68; puVar7 != auStack_68 + -(uVar3 & 0xfffffffffffff000);
puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
if (uVar3 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (-1 < local_5c) {
puVar6 = (int4 *)(puVar7 + uVar10 * 4 + lVar1 + 4);
iVar9 = local_5c + 1;
iVar4 = 0;
do {
puVar2 = puVar6 + ~uVar10;
if (-1 < (int)param_2) {
do {
*puVar2 = 0;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar6);
}
iVar4 = iVar4 + 1;
puVar6 = (int4 *)((long)puVar6 + local_50);
} while (iVar4 != iVar9);
}
if (0 < local_5c) {
uVar3 = local_50 >> 2;
piVar11 = (int *)(puVar7 + local_50 + lVar1 + 4);
local_58 = local_5c + 1;
iVar9 = 1;
local_54 = param_2;
do {
uVar5 = 0;
piVar8 = piVar11;
if (0 < (int)local_54) {
do {
*piVar8 = piVar8[-1];
iVar4 = *(int *)(param_1 + uVar5 * 4);
if ((0 < iVar4) && (iVar4 <= iVar9)) {
*piVar8 = piVar8[-1] + 1 +
*(int *)(puVar7 + ((long)(int)uVar5 + (long)(iVar9 / iVar4) * uVar3) * 4 +
lVar1);
}
uVar5 = uVar5 + 1;
piVar8 = piVar8 + 1;
} while (uVar10 != uVar5);
}
iVar9 = iVar9 + 1;
piVar11 = (int *)((long)piVar11 + local_50);
param_2 = local_54;
} while (iVar9 != local_58);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar1 + -8) = main;
__stack_chk_fail();
}
return *(int4 *)
(puVar7 + ((long)(int)param_2 + (local_50 >> 2) * (long)local_5c) * 4 + lVar1);
} |
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] <= i && arr[j-1] > 0) {
dp[i][j] += dp[i / arr[j-1]][j-1] + 1;
}
}
}
return dp[k][n];
}
| 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),%ebx
movslq %ebx,%rdx
mov %ebx,-0x4c(%rbp)
mov %rsp,%rbx
imul %rdx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 1330 <func0+0x80>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 131b <func0+0x6b>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1450 <func0+0x1a0>
mov -0x48(%rbp),%r8
mov -0x50(%rbp),%edx
mov %rsp,%r14
mov %r8,%r15
shr $0x2,%r15
test %edx,%edx
js 141f <func0+0x16f>
mov %r12d,%esi
mov -0x4c(%rbp),%r9d
xor %ecx,%ecx
add $0x1,%rsi
lea (%r14,%rsi,4),%rdx
neg %rsi
shl $0x2,%rsi
nopl 0x0(%rax,%rax,1)
lea (%rsi,%rdx,1),%rax
test %r12d,%r12d
js 1397 <func0+0xe7>
nopl 0x0(%rax)
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1388 <func0+0xd8>
add $0x1,%ecx
add %r8,%rdx
cmp %r9d,%ecx
jne 1378 <func0+0xc8>
mov -0x50(%rbp),%eax
test %eax,%eax
jle 141f <func0+0x16f>
mov -0x48(%rbp),%rax
mov $0x1,%esi
lea -0x1(%r12),%ebx
lea 0x4(%r14,%rax,1),%r13
nopl 0x0(%rax)
mov %r13,%r8
xor %ecx,%ecx
test %r12d,%r12d
jg 13d3 <func0+0x123>
jmp 1413 <func0+0x163>
nopl 0x0(%rax)
mov %rax,%rcx
mov -0x4(%r8),%r11d
mov (%rdi,%rcx,4),%r9d
movslq %ecx,%r10
mov %r11d,(%r8)
cmp %esi,%r9d
jg 1406 <func0+0x156>
test %r9d,%r9d
jle 1406 <func0+0x156>
mov %esi,%eax
cltd
idiv %r9d
cltq
imul %r15,%rax
add %r10,%rax
mov (%r14,%rax,4),%eax
lea 0x1(%r11,%rax,1),%eax
mov %eax,(%r8)
lea 0x1(%rcx),%rax
add $0x4,%r8
cmp %rcx,%rbx
jne 13d0 <func0+0x120>
add $0x1,%esi
add -0x48(%rbp),%r13
cmp %esi,-0x4c(%rbp)
jne 13c0 <func0+0x110>
movslq -0x50(%rbp),%rax
movslq %r12d,%r12
imul %rax,%r15
mov -0x38(%rbp),%rdi
xor %fs:0x28,%rdi
lea (%r12,%r15,1),%rax
mov (%r14,%rax,4),%eax
jne 145b <func0+0x1ab>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1342 <func0+0x92>
callq 1060 <__stack_chk_fail@plt>
| 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], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
imul rax, rdx
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_134B
loc_1336:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rcx
jnz short loc_1336
loc_134B:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1466
loc_135D:
mov rax, r14
mov edx, [rbp+var_4C]
mov r12, rsp
shr rax, 2
mov [rbp+var_48], rax
test edx, edx
js loc_1430
mov eax, r13d
mov rdi, r12
xor r15d, r15d
lea rax, ds:4[rax*4]
mov [rbp+var_58], rax
jmp short loc_1393
loc_1390:
mov r15d, eax
loc_1393:
test r13d, r13d
js short loc_13A6
mov rdx, [rbp+var_58]
xor esi, esi
call _memset
mov rdi, rax
loc_13A6:
lea eax, [r15+1]
add rdi, r14
cmp [rbp+var_4C], r15d
jnz short loc_1390
mov eax, [rbp+var_4C]
test eax, eax
jle short loc_1430
lea r15, [r12+r14+4]
mov r10d, 1
movsxd r11, r13d
nop dword ptr [rax+rax+00000000h]
loc_13D0:
mov rsi, r15
xor ecx, ecx
test r13d, r13d
jle short loc_141E
nop word ptr [rax+rax+00h]
loc_13E0:
mov r9d, [rsi-4]
mov edi, [rbx+rcx*4]
movsxd r8, ecx
mov [rsi], r9d
cmp edi, r10d
jg short loc_1411
test edi, edi
jle short loc_1411
mov eax, r10d
cdq
idiv edi
cdqe
imul rax, [rbp+var_48]
add r8, rax
mov eax, [r12+r8*4]
lea eax, [r9+rax+1]
mov [rsi], eax
loc_1411:
add rcx, 1
add rsi, 4
cmp r11, rcx
jnz short loc_13E0
loc_141E:
lea eax, [r10+1]
add r15, r14
cmp [rbp+var_4C], r10d
jz short loc_1438
mov r10d, eax
jmp short loc_13D0
loc_1430:
movsxd r11, r13d
nop dword ptr [rax+rax+00h]
loc_1438:
movsxd rax, [rbp+var_4C]
imul rax, [rbp+var_48]
add r11, rax
mov eax, [r12+r11*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1471
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1466:
or [rsp+rdx+1060h+var_1068], 0
jmp loc_135D
loc_1471:
call ___stack_chk_fail | 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; // r11
_DWORD *v18; // rsi
long long v19; // rcx
int v20; // r9d
int v21; // edi
_BYTE v24[4088]; // [rsp+8h] [rbp-1060h] BYREF
long long v25; // [rsp+1008h] [rbp-60h] BYREF
long long v26; // [rsp+1010h] [rbp-58h]
int v27; // [rsp+101Ch] [rbp-4Ch]
unsigned long long v28; // [rsp+1020h] [rbp-48h]
unsigned long long v29; // [rsp+1030h] [rbp-38h]
v27 = a3;
v6 = a2 + 1;
v7 = 4 * v6;
v29 = __readfsqword(0x28u);
v8 = 4 * v6 * (a3 + 1) + 15;
v9 = (long long *)((char *)&v25 - (v8 & 0xFFFFFFFFFFFFF000LL));
v10 = v8 & 0xFFF0;
if ( &v25 != v9 )
{
while ( v24 != (_BYTE *)v9 )
;
}
v11 = v10 & 0xFFF;
v12 = alloca(v11);
if ( v11 )
*(_QWORD *)&v24[v11 - 8] = *(_QWORD *)&v24[v11 - 8];
v28 = v7 >> 2;
if ( v27 < 0 )
goto LABEL_20;
v13 = v24;
v14 = 0;
v26 = 4LL * (unsigned int)a2 + 4;
while ( 1 )
{
if ( a2 >= 0 )
v13 = (_BYTE *)memset(v13, 0LL, v26);
v13 += v7;
if ( v27 == v14 )
break;
++v14;
}
if ( v27 <= 0 )
{
LABEL_20:
v17 = a2;
}
else
{
v15 = &v24[v7 + 4];
v16 = 1;
v17 = a2;
while ( 1 )
{
v18 = v15;
v19 = 0LL;
if ( a2 > 0 )
{
do
{
v20 = *(v18 - 1);
v21 = *(_DWORD *)(a1 + 4 * v19);
*v18 = v20;
if ( v21 <= v16 && v21 > 0 )
*v18 = v20 + *(_DWORD *)&v24[4 * v28 * (v16 / v21) + 4 * (int)v19] + 1;
++v19;
++v18;
}
while ( a2 != v19 );
}
v15 += v7;
if ( v27 == v16 )
break;
++v16;
}
}
return *(unsigned int *)&v24[4 * v28 * v27 + 4 * 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]
CDQE
IMUL RAX,RDX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010134b
LAB_00101336:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101336
LAB_0010134b:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101466
LAB_0010135d:
MOV RAX,R14
MOV EDX,dword ptr [RBP + -0x4c]
MOV R12,RSP
SHR RAX,0x2
MOV qword ptr [RBP + -0x48],RAX
TEST EDX,EDX
JS 0x00101430
MOV EAX,R13D
MOV RDI,R12
XOR R15D,R15D
LEA RAX,[0x4 + RAX*0x4]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00101393
LAB_00101390:
MOV R15D,EAX
LAB_00101393:
TEST R13D,R13D
JS 0x001013a6
MOV RDX,qword ptr [RBP + -0x58]
XOR ESI,ESI
CALL 0x00101090
MOV RDI,RAX
LAB_001013a6:
LEA EAX,[R15 + 0x1]
ADD RDI,R14
CMP dword ptr [RBP + -0x4c],R15D
JNZ 0x00101390
MOV EAX,dword ptr [RBP + -0x4c]
TEST EAX,EAX
JLE 0x00101430
LEA R15,[R12 + R14*0x1 + 0x4]
MOV R10D,0x1
MOVSXD R11,R13D
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
MOV RSI,R15
XOR ECX,ECX
TEST R13D,R13D
JLE 0x0010141e
NOP word ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV R9D,dword ptr [RSI + -0x4]
MOV EDI,dword ptr [RBX + RCX*0x4]
MOVSXD R8,ECX
MOV dword ptr [RSI],R9D
CMP EDI,R10D
JG 0x00101411
TEST EDI,EDI
JLE 0x00101411
MOV EAX,R10D
CDQ
IDIV EDI
CDQE
IMUL RAX,qword ptr [RBP + -0x48]
ADD R8,RAX
MOV EAX,dword ptr [R12 + R8*0x4]
LEA EAX,[R9 + RAX*0x1 + 0x1]
MOV dword ptr [RSI],EAX
LAB_00101411:
ADD RCX,0x1
ADD RSI,0x4
CMP R11,RCX
JNZ 0x001013e0
LAB_0010141e:
LEA EAX,[R10 + 0x1]
ADD R15,R14
CMP dword ptr [RBP + -0x4c],R10D
JZ 0x00101438
MOV R10D,EAX
JMP 0x001013d0
LAB_00101430:
MOVSXD R11,R13D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101438:
MOVSXD RAX,dword ptr [RBP + -0x4c]
IMUL RAX,qword ptr [RBP + -0x48]
ADD R11,RAX
MOV EAX,dword ptr [R12 + R11*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101471
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101466:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010135d
LAB_00101471:
CALL 0x00101070 | 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 local_40;
int1 *puVar8;
puVar7 = auStack_68;
uVar5 = (ulong)(int)(param_2 + 1);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)(param_3 + 1) * uVar5 * 4 + 0xf;
puVar8 = auStack_68;
puVar3 = auStack_68;
while (puVar8 != auStack_68 + -(uVar6 & 0xfffffffffffff000)) {
puVar7 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar8 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar2 = -uVar6;
puVar3 = puVar7 + lVar2;
if (uVar6 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
local_50 = uVar5 & 0x3fffffffffffffff;
local_54 = param_3;
if (-1 < param_3) {
local_60 = (ulong)param_2 * 4 + 4;
iVar10 = 0;
do {
if (-1 < (int)param_2) {
*(int8 *)(puVar7 + lVar2 + -8) = 0x1013a3;
puVar3 = (int1 *)memset(puVar3,0,local_60);
}
puVar3 = puVar3 + uVar5 * 4;
bVar12 = local_54 != iVar10;
iVar10 = iVar10 + 1;
} while (bVar12);
if (0 < local_54) {
piVar11 = (int *)(puVar7 + lVar2 + 4);
iVar10 = 1;
do {
piVar11 = piVar11 + uVar5;
lVar4 = 0;
piVar9 = piVar11;
if (0 < (int)param_2) {
do {
iVar1 = *(int *)(param_1 + lVar4 * 4);
*piVar9 = piVar9[-1];
if ((iVar1 <= iVar10) && (0 < iVar1)) {
*piVar9 = piVar9[-1] + 1 +
*(int *)(puVar7 + ((long)(int)lVar4 + (long)(iVar10 / iVar1) * local_50) * 4
+ lVar2);
}
lVar4 = lVar4 + 1;
piVar9 = piVar9 + 1;
} while ((int)param_2 != lVar4);
}
bVar12 = local_54 != iVar10;
iVar10 = iVar10 + 1;
} while (bVar12);
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar7 + ((long)(int)param_2 + (long)local_54 * local_50) * 4 + lVar2);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar2 + -8) = 0x101476;
__stack_chk_fail();
} |
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] <= i && arr[j-1] > 0) {
dp[i][j] += dp[i / arr[j-1]][j-1] + 1;
}
}
}
return dp[k][n];
}
| 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 %edx,%rdx
cltq
lea 0x0(,%rax,4),%rbx
imul %rdx,%rax
mov %rbx,-0x48(%rbp)
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 1313 <func0+0x83>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12fe <func0+0x6e>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1451 <func0+0x1c1>
mov -0x48(%rbp),%rbx
mov -0x50(%rbp),%ecx
mov %rsp,%r13
shr $0x2,%rbx
test %ecx,%ecx
js 1469 <func0+0x1d9>
mov -0x4c(%rbp),%edx
test %edx,%edx
js 145c <func0+0x1cc>
movslq -0x4c(%rbp),%rax
xor %r15d,%r15d
mov %rbx,-0x68(%rbp)
mov %r13,%rdi
mov %r12,-0x70(%rbp)
mov -0x48(%rbp),%rbx
mov %r15d,%r12d
mov %rax,-0x60(%rbp)
mov -0x54(%rbp),%r15d
lea 0x4(,%rax,4),%r14
mov %r14,%rdx
xor %esi,%esi
add $0x1,%r12d
callq 1090 <memset@plt>
mov %rax,%rdi
add %rbx,%rdi
cmp %r15d,%r12d
jne 1370 <func0+0xe0>
mov -0x68(%rbp),%rbx
mov -0x70(%rbp),%r12
mov -0x50(%rbp),%eax
test %eax,%eax
jle 141f <func0+0x18f>
mov -0x4c(%rbp),%eax
test %eax,%eax
jle 141f <func0+0x18f>
mov -0x48(%rbp),%rdx
mov -0x54(%rbp),%r10d
mov $0x1,%r11d
lea -0x1(%rax),%r15d
lea 0x4(%r13,%rdx,1),%r14
nopw 0x0(%rax,%rax,1)
mov %r14,%rsi
xor %ecx,%ecx
jmp 13d3 <func0+0x143>
nopw 0x0(%rax,%rax,1)
mov %rax,%rcx
mov -0x4(%rsi),%r9d
mov (%r12,%rcx,4),%edi
movslq %ecx,%r8
mov %r9d,(%rsi)
cmp %r11d,%edi
jg 1405 <func0+0x175>
test %edi,%edi
jle 1405 <func0+0x175>
mov %r11d,%eax
cltd
idiv %edi
cltq
imul %rbx,%rax
add %r8,%rax
mov 0x0(%r13,%rax,4),%eax
lea 0x1(%r9,%rax,1),%eax
mov %eax,(%rsi)
lea 0x1(%rcx),%rax
add $0x4,%rsi
cmp %r15,%rcx
jne 13d0 <func0+0x140>
add $0x1,%r11d
add -0x48(%rbp),%r14
cmp %r10d,%r11d
jne 13c0 <func0+0x130>
movslq -0x50(%rbp),%rax
mov -0x60(%rbp),%r9
imul %rbx,%rax
add %rax,%r9
mov -0x38(%rbp),%rdx
xor %fs:0x28,%rdx
mov 0x0(%r13,%r9,4),%eax
jne 1473 <func0+0x1e3>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1325 <func0+0x95>
movslq -0x4c(%rbp),%rax
mov %rax,-0x60(%rbp)
jmpq 1391 <func0+0x101>
movslq -0x4c(%rbp),%rax
mov %rax,-0x60(%rbp)
jmp 141f <func0+0x18f>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| 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 eax, eax
lea eax, [rcx+1]
mov rcx, rsp
cdqe
imul rax, rdx
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_130B
loc_12F6:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rcx
jnz short loc_12F6
loc_130B:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1431
loc_131D:
mov ecx, [rbp+var_44]
mov r13, r14
mov r12, rsp
shr r13, 2
test ecx, ecx
js loc_13F7
mov edx, [rbp+var_48]
test edx, edx
js loc_13F7
movsxd rax, [rbp+var_48]
mov rdi, r12; s
xor r15d, r15d
mov [rbp+var_58], rax
lea rax, ds:4[rax*4]
mov [rbp+n], rax
nop word ptr [rax+rax+00000000h]
loc_1360:
mov rdx, [rbp+n]; n
xor esi, esi; c
call _memset
mov rdi, rax
mov eax, r15d
add r15d, 1
add rdi, r14
cmp [rbp+var_44], eax
jnz short loc_1360
mov eax, [rbp+var_44]
test eax, eax
jz short loc_1400
mov eax, [rbp+var_48]
test eax, eax
jz short loc_1400
lea r15, [r12+r14+4]
mov r10d, 1
mov r11d, eax
nop dword ptr [rax+00000000h]
loc_13A0:
mov rsi, r15
xor ecx, ecx
nop dword ptr [rax]
loc_13A8:
mov r8d, [rsi-4]
mov edi, [rbx+rcx*4]
mov [rsi], r8d
test edi, edi
jle short loc_13D8
cmp edi, r10d
jg short loc_13D8
mov eax, r10d
movsxd r9, ecx
cdq
idiv edi
cdqe
imul rax, r13
add r9, rax
mov eax, [r12+r9*4]
lea eax, [r8+rax+1]
mov [rsi], eax
loc_13D8:
add rcx, 1
add rsi, 4
cmp r11, rcx
jnz short loc_13A8
lea eax, [r10+1]
add r15, r14
cmp [rbp+var_44], r10d
jz short loc_1400
mov r10d, eax
jmp short loc_13A0
loc_13F7:
movsxd rax, [rbp+var_48]
mov [rbp+var_58], rax
nop
loc_1400:
movsxd rax, [rbp+var_44]
mov rdx, [rbp+var_58]
imul rax, r13
add rdx, rax
mov eax, [r12+rdx*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_143C
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1431:
or [rsp+rdx+1060h+var_1068], 0
jmp loc_131D
loc_143C:
call ___stack_chk_fail | 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 v16; // eax
_BYTE *v17; // r15
int v18; // r10d
long long v19; // r11
_DWORD *v20; // rsi
long long i; // rcx
int v22; // r8d
int v23; // edi
_BYTE v26[4088]; // [rsp+8h] [rbp-1060h] BYREF
long long v27; // [rsp+1008h] [rbp-60h] BYREF
long long v28; // [rsp+1010h] [rbp-58h]
size_t n; // [rsp+1018h] [rbp-50h]
int v30; // [rsp+1020h] [rbp-48h]
int v31; // [rsp+1024h] [rbp-44h]
unsigned long long v32; // [rsp+1030h] [rbp-38h]
v31 = a3;
v30 = a2;
v5 = a2 + 1;
v6 = 4 * v5;
v32 = __readfsqword(0x28u);
v7 = 4 * v5 * (a3 + 1) + 15;
v8 = (long long *)((char *)&v27 - (v7 & 0xFFFFFFFFFFFFF000LL));
v9 = v7 & 0xFFF0;
if ( &v27 != v8 )
{
while ( v26 != (_BYTE *)v8 )
;
}
v10 = v9 & 0xFFF;
v11 = alloca(v10);
if ( v10 )
*(_QWORD *)&v26[v10 - 8] = *(_QWORD *)&v26[v10 - 8];
v12 = v6 >> 2;
if ( v31 < 0 || v30 < 0 )
{
v28 = v30;
}
else
{
v13 = v26;
v14 = 0;
v28 = v30;
n = 4LL * v30 + 4;
do
{
v15 = (char *)memset(v13, 0, n);
v16 = v14++;
v13 = &v15[v6];
}
while ( v31 != v16 );
if ( v31 && v30 )
{
v17 = &v26[v6 + 4];
v18 = 1;
v19 = (unsigned int)v30;
while ( 1 )
{
v20 = v17;
for ( i = 0LL; i != v19; ++i )
{
v22 = *(v20 - 1);
v23 = *(_DWORD *)(a1 + 4 * i);
*v20 = v22;
if ( v23 > 0 && v23 <= v18 )
*v20 = v22 + *(_DWORD *)&v26[4 * v12 * (v18 / v23) + 4 * (int)i] + 1;
++v20;
}
v17 += v6;
if ( v31 == v18 )
break;
++v18;
}
}
}
return *(unsigned int *)&v26[4 * v12 * v31 + 4 * v28];
} | 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 + 0x1]
MOV RCX,RSP
CDQE
IMUL RAX,RDX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010130b
LAB_001012f6:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012f6
LAB_0010130b:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101431
LAB_0010131d:
MOV ECX,dword ptr [RBP + -0x44]
MOV R13,R14
MOV R12,RSP
SHR R13,0x2
TEST ECX,ECX
JS 0x001013f7
MOV EDX,dword ptr [RBP + -0x48]
TEST EDX,EDX
JS 0x001013f7
MOVSXD RAX,dword ptr [RBP + -0x48]
MOV RDI,R12
XOR R15D,R15D
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[0x4 + RAX*0x4]
MOV qword ptr [RBP + -0x50],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101360:
MOV RDX,qword ptr [RBP + -0x50]
XOR ESI,ESI
CALL 0x00101090
MOV RDI,RAX
MOV EAX,R15D
ADD R15D,0x1
ADD RDI,R14
CMP dword ptr [RBP + -0x44],EAX
JNZ 0x00101360
MOV EAX,dword ptr [RBP + -0x44]
TEST EAX,EAX
JZ 0x00101400
MOV EAX,dword ptr [RBP + -0x48]
TEST EAX,EAX
JZ 0x00101400
LEA R15,[R12 + R14*0x1 + 0x4]
MOV R10D,0x1
MOV R11D,EAX
NOP dword ptr [RAX]
LAB_001013a0:
MOV RSI,R15
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_001013a8:
MOV R8D,dword ptr [RSI + -0x4]
MOV EDI,dword ptr [RBX + RCX*0x4]
MOV dword ptr [RSI],R8D
TEST EDI,EDI
JLE 0x001013d8
CMP EDI,R10D
JG 0x001013d8
MOV EAX,R10D
MOVSXD R9,ECX
CDQ
IDIV EDI
CDQE
IMUL RAX,R13
ADD R9,RAX
MOV EAX,dword ptr [R12 + R9*0x4]
LEA EAX,[R8 + RAX*0x1 + 0x1]
MOV dword ptr [RSI],EAX
LAB_001013d8:
ADD RCX,0x1
ADD RSI,0x4
CMP R11,RCX
JNZ 0x001013a8
LEA EAX,[R10 + 0x1]
ADD R15,R14
CMP dword ptr [RBP + -0x44],R10D
JZ 0x00101400
MOV R10D,EAX
JMP 0x001013a0
LAB_001013f7:
MOVSXD RAX,dword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x58],RAX
NOP
LAB_00101400:
MOVSXD RAX,dword ptr [RBP + -0x44]
MOV RDX,qword ptr [RBP + -0x58]
IMUL RAX,R13
ADD RDX,RAX
MOV EAX,dword ptr [R12 + RDX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010143c
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101431:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010131d
LAB_0010143c:
CALL 0x00101070 | 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 local_4c;
long local_40;
int *puVar7;
puVar6 = auStack_68;
uVar5 = (ulong)(int)(param_2 + 1);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(param_3 + 1) * uVar5 * 4 + 0xf;
puVar7 = auStack_68;
puVar9 = auStack_68;
while (puVar7 != auStack_68 + -(uVar4 & 0xfffffffffffff000)) {
puVar6 = puVar9 + -0x1000;
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
puVar7 = puVar9 + -0x1000;
puVar9 = puVar9 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar2 = -uVar4;
puVar9 = puVar6 + lVar2;
if (uVar4 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
local_50 = param_2;
local_4c = param_3;
if ((param_3 < 0) || ((int)param_2 < 0)) {
local_60 = (long)(int)param_2;
}
else {
local_60 = (long)(int)param_2;
local_58 = local_60 * 4 + 4;
iVar10 = 0;
do {
*(int8 *)(puVar6 + lVar2 + -8) = 0x10136b;
pvVar3 = memset(puVar9,0,local_58);
puVar9 = (int *)((long)pvVar3 + uVar5 * 4);
bVar12 = local_4c != iVar10;
iVar10 = iVar10 + 1;
} while (bVar12);
if ((local_4c != 0) && (local_50 != 0)) {
piVar11 = (int *)(puVar6 + lVar2 + 4);
iVar10 = 1;
do {
piVar11 = piVar11 + uVar5;
uVar4 = 0;
piVar8 = piVar11;
do {
iVar1 = *(int *)(param_1 + uVar4 * 4);
*piVar8 = piVar8[-1];
if ((0 < iVar1) && (iVar1 <= iVar10)) {
*piVar8 = piVar8[-1] + 1 +
*(int *)(puVar6 + ((long)(int)uVar4 +
(long)(iVar10 / iVar1) * (uVar5 & 0x3fffffffffffffff)) * 4 +
lVar2);
}
uVar4 = uVar4 + 1;
piVar8 = piVar8 + 1;
} while (local_50 != uVar4);
bVar12 = local_4c != iVar10;
iVar10 = iVar10 + 1;
} while (bVar12);
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)
(puVar6 + (local_60 + (long)local_4c * (uVar5 & 0x3fffffffffffffff)) * 4 + lVar2);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar2 + -8) = 0x101441;
__stack_chk_fail();
} |
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
test %eax,%eax
je 1164 <func0+0x1b>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 1174 <func0+0x2b>
mov -0x14(%rbp),%eax
add %eax,-0x8(%rbp)
mov -0x8(%rbp),%eax
pop %rbp
retq
| 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 [rbp+var_4]
mov eax, edx
test eax, eax
jz short loc_1164
add [rbp+var_4], 1
loc_1185:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_1174
mov eax, [rbp+var_14]
add [rbp+var_8], eax
mov eax, [rbp+var_8]
pop rbp
retn | 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_00101174:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x00101164
ADD dword ptr [RBP + -0x4],0x1
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x00101174
MOV EAX,dword ptr [RBP + -0x14]
ADD dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | 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 local_10 + local_1c;
} |
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 115c <func0+0x13>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1160 <func0+0x17>
jmp 1170 <func0+0x27>
| 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 eax, edi
jg short loc_115C
loc_117C:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1160
jmp short loc_1170 | 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
IDIV ECX
TEST EDX,EDX
JZ 0x00101160
JMP 0x00101170 | 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 = (int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
}
return param_1 + iVar4;
} |
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 $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 11e0 <func0+0x10>
lea (%rdi,%rsi,1),%eax
retq
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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 short loc_1210
loc_1220:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1200
lea eax, [rdi+rsi]
retn
loc_1230:
mov eax, edi
retn | 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, a1) % v1) );
}
++v1;
}
while ( v1 * v1 <= a1 );
return (unsigned int)(a1 + v2);
} | 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
JLE 0x00101200
LEA EAX,[RDI + RSI*0x1]
RET
LAB_00101230:
MOV EAX,EDI
RET | 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);
iVar3 = (int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
return param_1 + iVar4;
} |
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 $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 11d0 <func0+0x10>
lea (%rdi,%rsi,1),%eax
retq
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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 short loc_11E0
loc_11F0:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_11D0
lea eax, [rdi+rsi]
retn
loc_1200:
mov eax, edi
retn | 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, a1) % v1) );
}
++v1;
}
while ( v1 * v1 <= a1 );
return (unsigned int)(a1 + v2);
} | 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
JLE 0x001011d0
LEA EAX,[RDI + RSI*0x1]
RET
LAB_00101200:
MOV EAX,EDI
RET | 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);
iVar3 = (int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
return param_1 + iVar4;
} |
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 marker for nested tuple start
// calculate the size of the nested tuple
int nested_size = 0;
i++; // move to the first element of the nested tuple
while (tup_array[i + nested_size] != -2) { // assuming -2 as the marker for nested tuple end
nested_size++;
}
flatten(tup_array + i, flat_array, index, nested_size);
i += nested_size; // skip over the nested tuple
} else if (curr != -2) {
flat_array[(*index)++] = curr;
}
}
}
| 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 (int i = 0; i < index; i++) {
int ele = flat_array[i];
int found = 0;
for (int j = 0; j < *result_size; j++) {
if (res[j].key == ele) {
res[j].value++;
found = 1;
break;
}
}
if (!found) {
res[*result_size].key = ele;
res[*result_size].value = 1;
(*result_size)++;
}
}
free(flat_array);
return (int *)res;
}
| 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[0]), &result_size);
KeyValue *result2 = (KeyValue *)func0(test2, sizeof(test2) / sizeof(test2[0]), &result_size);
KeyValue *result3 = (KeyValue *)func0(test3, sizeof(test3) / sizeof(test3[0]), &result_size);
assert(result1[0].value == 2 && result1[1].value == 2 && result1[2].value == 1 && result1[3].value == 1 && result1[4].value == 2);
assert(result2[0].value == 2 && result2[1].value == 2 && result2[2].value == 1 && result2[3].value == 1 && result2[4].value == 2);
assert(result3[0].value == 2 && result3[1].value == 2 && result3[2].value == 1 && result3[3].value == 1 && result3[4].value == 2);
free(result1);
free(result2);
free(result3);
return 0;
}
| 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 -0x2c(%rbp),%rdx
mov -0x18(%rbp),%rsi
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 11a9 <flatten>
mov $0x320,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x10(%rbp)
mov -0x48(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0x28(%rbp)
jmpq 13d1 <func0+0x142>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x1c(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmp 1373 <func0+0xe4>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x1c(%rbp)
jne 136f <func0+0xe0>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
add $0x1,%edx
mov %edx,0x4(%rax)
movl $0x1,-0x24(%rbp)
jmp 137e <func0+0xef>
addl $0x1,-0x20(%rbp)
mov -0x48(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jl 132e <func0+0x9f>
cmpl $0x0,-0x24(%rbp)
jne 13cd <func0+0x13e>
mov -0x48(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rax,%rdx
mov -0x1c(%rbp),%eax
mov %eax,(%rdx)
mov -0x48(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
movl $0x1,0x4(%rax)
mov -0x48(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x48(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0x28(%rbp)
mov -0x2c(%rbp),%eax
cmp %eax,-0x28(%rbp)
jl 1305 <func0+0x76>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1401 <func0+0x172>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
| 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 rdx, [rbp+var_2C]
mov rsi, [rbp+ptr]
mov rax, [rbp+var_38]
mov rdi, rax
call flatten
mov edi, 320h; size
call _malloc
mov [rbp+var_10], rax
mov rax, [rbp+var_48]
mov dword ptr [rax], 0
mov [rbp+var_28], 0
jmp loc_13D1
loc_1305:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_1C], eax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp short loc_1373
loc_132E:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_1C], eax
jnz short loc_136F
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rax, rdx
mov edx, [rax+4]
add edx, 1
mov [rax+4], edx
mov [rbp+var_24], 1
jmp short loc_137E
loc_136F:
add [rbp+var_20], 1
loc_1373:
mov rax, [rbp+var_48]
mov eax, [rax]
cmp [rbp+var_20], eax
jl short loc_132E
loc_137E:
cmp [rbp+var_24], 0
jnz short loc_13CD
mov rax, [rbp+var_48]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rdx, rax
mov eax, [rbp+var_1C]
mov [rdx], eax
mov rax, [rbp+var_48]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rax, rdx
mov dword ptr [rax+4], 1
mov rax, [rbp+var_48]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_48]
mov [rax], edx
loc_13CD:
add [rbp+var_28], 1
loc_13D1:
mov eax, [rbp+var_2C]
cmp [rbp+var_28], eax
jl loc_1305
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1401
call ___stack_chk_fail
locret_1401:
leave
retn | _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 v12; // [rsp+48h] [rbp-8h]
v12 = __readfsqword(0x28u);
ptr = malloc(0x190uLL);
v5 = 0;
flatten(a1, ptr, &v5, a2);
v11 = malloc(0x320uLL);
*a3 = 0;
for ( i = 0; i < v5; ++i )
{
v9 = *((_DWORD *)ptr + i);
v7 = 0;
for ( j = 0; j < *a3; ++j )
{
if ( v9 == v11[2 * j] )
{
++v11[2 * j + 1];
v7 = 1;
break;
}
}
if ( !v7 )
{
v11[2 * *a3] = v9;
v11[2 * (*a3)++ + 1] = 1;
}
}
free(ptr);
return v11;
} | 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,dword ptr [RBP + -0x3c]
LEA RDX,[RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001011a9
MOV EDI,0x320
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001013d1
LAB_00101305:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101373
LAB_0010132e:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1c],EAX
JNZ 0x0010136f
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
ADD EDX,0x1
MOV dword ptr [RAX + 0x4],EDX
MOV dword ptr [RBP + -0x24],0x1
JMP 0x0010137e
LAB_0010136f:
ADD dword ptr [RBP + -0x20],0x1
LAB_00101373:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JL 0x0010132e
LAB_0010137e:
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x001013cd
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],0x1
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],EDX
LAB_001013cd:
ADD dword ptr [RBP + -0x28],0x1
LAB_001013d1:
MOV EAX,dword ptr [RBP + -0x2c]
CMP dword ptr [RBP + -0x28],EAX
JL 0x00101305
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101401
CALL 0x00101090
LAB_00101401:
LEAVE
RET | 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,local_20,&local_34,param_2);
local_18 = malloc(800);
*param_3 = 0;
local_30 = 0;
do {
if (local_34 <= local_30) {
free(local_20);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_18;
}
local_24 = *(int *)((long)local_20 + (long)local_30 * 4);
local_2c = 0;
for (local_28 = 0; local_28 < *param_3; local_28 = local_28 + 1) {
if (local_24 == *(int *)((long)local_18 + (long)local_28 * 8)) {
*(int *)((long)local_18 + (long)local_28 * 8 + 4) =
*(int *)((long)local_18 + (long)local_28 * 8 + 4) + 1;
local_2c = 1;
break;
}
}
if (local_2c == 0) {
*(int *)((long)*param_3 * 8 + (long)local_18) = local_24;
*(int4 *)((long)local_18 + (long)*param_3 * 8 + 4) = 1;
*param_3 = *param_3 + 1;
}
local_30 = local_30 + 1;
} while( true );
} |
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 marker for nested tuple start
// calculate the size of the nested tuple
int nested_size = 0;
i++; // move to the first element of the nested tuple
while (tup_array[i + nested_size] != -2) { // assuming -2 as the marker for nested tuple end
nested_size++;
}
flatten(tup_array + i, flat_array, index, nested_size);
i += nested_size; // skip over the nested tuple
} else if (curr != -2) {
flat_array[(*index)++] = curr;
}
}
}
| 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 (int i = 0; i < index; i++) {
int ele = flat_array[i];
int found = 0;
for (int j = 0; j < *result_size; j++) {
if (res[j].key == ele) {
res[j].value++;
found = 1;
break;
}
}
if (!found) {
res[*result_size].key = ele;
res[*result_size].value = 1;
(*result_size)++;
}
}
free(flat_array);
return (int *)res;
}
| 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[0]), &result_size);
KeyValue *result2 = (KeyValue *)func0(test2, sizeof(test2) / sizeof(test2[0]), &result_size);
KeyValue *result3 = (KeyValue *)func0(test3, sizeof(test3) / sizeof(test3[0]), &result_size);
assert(result1[0].value == 2 && result1[1].value == 2 && result1[2].value == 1 && result1[3].value == 1 && result1[4].value == 2);
assert(result2[0].value == 2 && result2[1].value == 2 && result2[2].value == 1 && result2[3].value == 1 && result2[4].value == 2);
assert(result3[0].value == 2 && result3[1].value == 2 && result3[2].value == 1 && result3[3].value == 1 && result3[4].value == 2);
free(result1);
free(result2);
free(result3);
return 0;
}
| 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 %rax,%rsi
mov %rbx,%rdi
callq 11a9 <flatten>
mov $0x320,%edi
callq 10b0 <malloc@plt>
mov %rax,%rbx
movl $0x0,0x0(%rbp)
mov 0x4(%rsp),%eax
test %eax,%eax
jle 1316 <func0+0xc1>
mov %r12,%r8
lea -0x1(%rax),%eax
lea 0x4(%r12,%rax,4),%r9
jmp 12f2 <func0+0x9d>
addl $0x1,0x4(%rax)
jmp 12e9 <func0+0x94>
movslq %edi,%rax
lea (%rbx,%rax,8),%rax
mov %edx,(%rax)
movl $0x1,0x4(%rax)
add $0x1,%edi
mov %edi,0x0(%rbp)
add $0x4,%r8
cmp %r9,%r8
je 1316 <func0+0xc1>
mov (%r8),%edx
mov 0x0(%rbp),%edi
test %edi,%edi
jle 12d3 <func0+0x7e>
mov %rbx,%rax
lea -0x1(%rdi),%ecx
lea 0x8(%rbx,%rcx,8),%rsi
cmp %edx,(%rax)
je 12cd <func0+0x78>
add $0x8,%rax
cmp %rsi,%rax
jne 1307 <func0+0xb2>
jmp 12d3 <func0+0x7e>
mov %r12,%rdi
callq 1080 <free@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 133c <func0+0xe7>
mov %rbx,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1090 <__stack_chk_fail@plt>
| 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, r13d
mov rsi, rax
mov rdi, rbx
call flatten
mov edi, 320h
call _malloc
mov rbx, rax
mov dword ptr [rbp+0], 0
mov eax, [rsp+38h+var_34]
test eax, eax
jle short loc_1310
mov r8, r12
mov eax, eax
lea r9, [r12+rax*4]
jmp short loc_12EE
loc_12C9:
add dword ptr [rax+4], 1
jmp short loc_12E5
loc_12CF:
movsxd rax, edi
lea rax, [rbx+rax*8]
mov [rax], edx
mov dword ptr [rax+4], 1
add edi, 1
mov [rbp+0], edi
loc_12E5:
add r8, 4
cmp r8, r9
jz short loc_1310
loc_12EE:
mov edx, [r8]
mov edi, [rbp+0]
test edi, edi
jle short loc_12CF
mov rax, rbx
mov ecx, edi
lea rsi, [rbx+rcx*8]
loc_1301:
cmp [rax], edx
jz short loc_12C9
add rax, 8
cmp rax, rsi
jnz short loc_1301
jmp short loc_12CF
loc_1310:
mov rdi, r12
call _free
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1336
mov rax, rbx
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1336:
call ___stack_chk_fail | 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 = __readfsqword(0x28u);
v4 = malloc(400LL);
v13 = 0;
flatten(a1, v4, &v13, a2);
v5 = malloc(800LL);
*a3 = 0;
if ( v13 > 0 )
{
v6 = (int *)v4;
v7 = (int *)(v4 + 4LL * (unsigned int)v13);
do
{
v9 = *v6;
v10 = *a3;
if ( *a3 <= 0 )
{
LABEL_4:
v8 = (_DWORD *)(v5 + 8LL * v10);
*v8 = v9;
v8[1] = 1;
*a3 = v10 + 1;
}
else
{
v11 = (_DWORD *)v5;
while ( *v11 != v9 )
{
v11 += 2;
if ( v11 == (_DWORD *)(v5 + 8LL * (unsigned int)v10) )
goto LABEL_4;
}
++v11[1];
}
++v6;
}
while ( v6 != v7 );
}
free(v4);
return v5;
} | 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 EDI,0x320
CALL 0x001010b0
MOV RBX,RAX
MOV dword ptr [RBP],0x0
MOV EAX,dword ptr [RSP + 0x4]
TEST EAX,EAX
JLE 0x00101310
MOV R8,R12
MOV EAX,EAX
LEA R9,[R12 + RAX*0x4]
JMP 0x001012ee
LAB_001012c9:
ADD dword ptr [RAX + 0x4],0x1
JMP 0x001012e5
LAB_001012cf:
MOVSXD RAX,EDI
LEA RAX,[RBX + RAX*0x8]
MOV dword ptr [RAX],EDX
MOV dword ptr [RAX + 0x4],0x1
ADD EDI,0x1
MOV dword ptr [RBP],EDI
LAB_001012e5:
ADD R8,0x4
CMP R8,R9
JZ 0x00101310
LAB_001012ee:
MOV EDX,dword ptr [R8]
MOV EDI,dword ptr [RBP]
TEST EDI,EDI
JLE 0x001012cf
MOV RAX,RBX
MOV ECX,EDI
LEA RSI,[RBX + RCX*0x8]
LAB_00101301:
CMP dword ptr [RAX],EDX
JZ 0x001012c9
ADD RAX,0x8
CMP RAX,RSI
JNZ 0x00101301
JMP 0x001012cf
LAB_00101310:
MOV RDI,R12
CALL 0x00101080
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101336
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101336:
CALL 0x00101090 | 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);
piVar2 = (int *)malloc(800);
*param_3 = 0;
if (0 < (int)local_34) {
piVar4 = __ptr;
do {
uVar1 = *param_3;
if (0 < (int)uVar1) {
piVar3 = piVar2;
do {
if (*piVar3 == *piVar4) {
piVar3[1] = piVar3[1] + 1;
goto LAB_001012e5;
}
piVar3 = piVar3 + 2;
} while (piVar3 != piVar2 + (ulong)uVar1 * 2);
}
piVar2[(long)(int)uVar1 * 2] = *piVar4;
(piVar2 + (long)(int)uVar1 * 2)[1] = 1;
*param_3 = uVar1 + 1;
LAB_001012e5:
piVar4 = piVar4 + 1;
} while (piVar4 != __ptr + local_34);
}
free(__ptr);
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return piVar2;
} |
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 marker for nested tuple start
// calculate the size of the nested tuple
int nested_size = 0;
i++; // move to the first element of the nested tuple
while (tup_array[i + nested_size] != -2) { // assuming -2 as the marker for nested tuple end
nested_size++;
}
flatten(tup_array + i, flat_array, index, nested_size);
i += nested_size; // skip over the nested tuple
} else if (curr != -2) {
flat_array[(*index)++] = curr;
}
}
}
| 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 (int i = 0; i < index; i++) {
int ele = flat_array[i];
int found = 0;
for (int j = 0; j < *result_size; j++) {
if (res[j].key == ele) {
res[j].value++;
found = 1;
break;
}
}
if (!found) {
res[*result_size].key = ele;
res[*result_size].value = 1;
(*result_size)++;
}
}
free(flat_array);
return (int *)res;
}
| 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[0]), &result_size);
KeyValue *result2 = (KeyValue *)func0(test2, sizeof(test2) / sizeof(test2[0]), &result_size);
KeyValue *result3 = (KeyValue *)func0(test3, sizeof(test3) / sizeof(test3[0]), &result_size);
assert(result1[0].value == 2 && result1[1].value == 2 && result1[2].value == 1 && result1[3].value == 1 && result1[4].value == 2);
assert(result2[0].value == 2 && result2[1].value == 2 && result2[2].value == 1 && result2[3].value == 1 && result2[4].value == 2);
assert(result3[0].value == 2 && result3[1].value == 2 && result3[2].value == 1 && result3[3].value == 1 && result3[4].value == 2);
free(result1);
free(result2);
free(result3);
return 0;
}
| 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 %rax,%rbp
movl $0x0,0x4(%rsp)
callq 1480 <flatten>
mov $0x320,%edi
callq 10b0 <malloc@plt>
movl $0x0,(%rbx)
mov %rax,%r12
mov 0x4(%rsp),%eax
test %eax,%eax
jle 160e <func0+0xde>
mov %rbp,%r8
sub $0x1,%eax
lea 0x8(%r12),%r10
xor %edi,%edi
mov (%r8),%ecx
lea 0x4(%rbp,%rax,4),%r9
test %edi,%edi
jle 15f0 <func0+0xc0>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rdi),%eax
mov %r12,%rdx
lea (%r10,%rax,8),%rsi
jmp 15d1 <func0+0xa1>
nopl 0x0(%rax)
add $0x8,%rdx
cmp %rsi,%rdx
je 15f0 <func0+0xc0>
cmp %ecx,(%rdx)
jne 15c8 <func0+0x98>
add $0x4,%r8
addl $0x1,0x4(%rdx)
cmp %r9,%r8
je 160e <func0+0xde>
mov (%rbx),%edi
mov (%r8),%ecx
test %edi,%edi
jg 15b8 <func0+0x88>
nopl 0x0(%rax,%rax,1)
movslq %edi,%rax
add $0x4,%r8
add $0x1,%edi
lea (%r12,%rax,8),%rax
mov %edi,(%rbx)
mov %ecx,(%rax)
movl $0x1,0x4(%rax)
cmp %r9,%r8
jne 15e2 <func0+0xb2>
mov %rbp,%rdi
callq 1080 <free@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1634 <func0+0x104>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1090 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| 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 rbp, rax
mov [rsp+38h+var_34], 0
call flatten
mov edi, 320h
call _malloc
mov dword ptr [rbx], 0
mov r12, rax
mov eax, [rsp+38h+var_34]
test eax, eax
jle short loc_1606
mov rdi, rbp
lea r8, [rbp+rax*4+0]
lea r9, [r12+8]
xor esi, esi
mov edx, [rdi]
test esi, esi
jle short loc_15E8
nop
loc_15B0:
lea ecx, [rsi-1]
mov rax, r12
lea rcx, [r9+rcx*8]
jmp short loc_15C9
loc_15C0:
add rax, 8
cmp rax, rcx
jz short loc_15E8
loc_15C9:
cmp [rax], edx
jnz short loc_15C0
add rdi, 4
add dword ptr [rax+4], 1
cmp rdi, r8
jz short loc_1606
loc_15DA:
mov esi, [rbx]
mov edx, [rdi]
test esi, esi
jg short loc_15B0
nop word ptr [rax+rax+00h]
loc_15E8:
movsxd rax, esi
add rdi, 4
add esi, 1
lea rax, [r12+rax*8]
mov [rbx], esi
mov [rax], edx
mov dword ptr [rax+4], 1
cmp rdi, r8
jnz short loc_15DA
loc_1606:
mov rdi, rbp
call _free
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_162C
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_162C:
call ___stack_chk_fail | _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]
v15 = __readfsqword(0x28u);
v4 = (int *)malloc(400LL);
v14 = 0;
flatten(a1, v4, &v14, a2);
v5 = malloc(800LL);
*a3 = 0;
v6 = (_DWORD *)v5;
if ( v14 > 0 )
{
v7 = v4;
v8 = &v4[v14];
v9 = 0;
v10 = *v4;
LABEL_8:
while ( 1 )
{
++v7;
v12 = &v6[2 * v9];
*a3 = v9 + 1;
*v12 = v10;
v12[1] = 1;
if ( v7 == v8 )
break;
while ( 1 )
{
v9 = *a3;
v10 = *v7;
if ( *a3 <= 0 )
break;
v11 = v6;
while ( *v11 != v10 )
{
v11 += 2;
if ( v11 == &v6[2 * (v9 - 1) + 2] )
goto LABEL_8;
}
++v7;
++v11[1];
if ( v7 == v8 )
goto LABEL_9;
}
}
}
LABEL_9:
free(v4);
return v6;
} | 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 EDI,0x320
CALL 0x001010b0
MOV dword ptr [RBX],0x0
MOV R12,RAX
MOV EAX,dword ptr [RSP + 0x4]
TEST EAX,EAX
JLE 0x00101606
MOV RDI,RBP
LEA R8,[RBP + RAX*0x4]
LEA R9,[R12 + 0x8]
XOR ESI,ESI
MOV EDX,dword ptr [RDI]
TEST ESI,ESI
JLE 0x001015e8
NOP
LAB_001015b0:
LEA ECX,[RSI + -0x1]
MOV RAX,R12
LEA RCX,[R9 + RCX*0x8]
JMP 0x001015c9
LAB_001015c0:
ADD RAX,0x8
CMP RAX,RCX
JZ 0x001015e8
LAB_001015c9:
CMP dword ptr [RAX],EDX
JNZ 0x001015c0
ADD RDI,0x4
ADD dword ptr [RAX + 0x4],0x1
CMP RDI,R8
JZ 0x00101606
LAB_001015da:
MOV ESI,dword ptr [RBX]
MOV EDX,dword ptr [RDI]
TEST ESI,ESI
JG 0x001015b0
NOP word ptr [RAX + RAX*0x1]
LAB_001015e8:
MOVSXD RAX,ESI
ADD RDI,0x4
ADD ESI,0x1
LEA RAX,[R12 + RAX*0x8]
MOV dword ptr [RBX],ESI
MOV dword ptr [RAX],EDX
MOV dword ptr [RAX + 0x4],0x1
CMP RDI,R8
JNZ 0x001015da
LAB_00101606:
MOV RDI,RBP
CALL 0x00101080
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010162c
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010162c:
CALL 0x00101090 | 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_34,param_2);
piVar1 = (int *)malloc(800);
*param_3 = 0;
if (0 < (int)local_34) {
iVar4 = 0;
iVar3 = *__ptr;
piVar5 = __ptr;
LAB_001015e8:
piVar5 = piVar5 + 1;
*param_3 = iVar4 + 1;
piVar1[(long)iVar4 * 2] = iVar3;
(piVar1 + (long)iVar4 * 2)[1] = 1;
if (piVar5 != __ptr + local_34) {
while( true ) {
iVar4 = *param_3;
iVar3 = *piVar5;
if (iVar4 < 1) break;
piVar2 = piVar1;
while (*piVar2 != iVar3) {
piVar2 = piVar2 + 2;
if (piVar2 == piVar1 + (ulong)(iVar4 - 1) * 2 + 2) goto LAB_001015e8;
}
piVar5 = piVar5 + 1;
piVar2[1] = piVar2[1] + 1;
if (piVar5 == __ptr + local_34) goto LAB_00101606;
}
goto LAB_001015e8;
}
}
LAB_00101606:
free(__ptr);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return piVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
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 marker for nested tuple start
// calculate the size of the nested tuple
int nested_size = 0;
i++; // move to the first element of the nested tuple
while (tup_array[i + nested_size] != -2) { // assuming -2 as the marker for nested tuple end
nested_size++;
}
flatten(tup_array + i, flat_array, index, nested_size);
i += nested_size; // skip over the nested tuple
} else if (curr != -2) {
flat_array[(*index)++] = curr;
}
}
}
| 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 (int i = 0; i < index; i++) {
int ele = flat_array[i];
int found = 0;
for (int j = 0; j < *result_size; j++) {
if (res[j].key == ele) {
res[j].value++;
found = 1;
break;
}
}
if (!found) {
res[*result_size].key = ele;
res[*result_size].value = 1;
(*result_size)++;
}
}
free(flat_array);
return (int *)res;
}
| 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[0]), &result_size);
KeyValue *result2 = (KeyValue *)func0(test2, sizeof(test2) / sizeof(test2[0]), &result_size);
KeyValue *result3 = (KeyValue *)func0(test3, sizeof(test3) / sizeof(test3[0]), &result_size);
assert(result1[0].value == 2 && result1[1].value == 2 && result1[2].value == 1 && result1[3].value == 1 && result1[4].value == 2);
assert(result2[0].value == 2 && result2[1].value == 2 && result2[2].value == 1 && result2[3].value == 1 && result2[4].value == 2);
assert(result3[0].value == 2 && result3[1].value == 2 && result3[2].value == 1 && result3[3].value == 1 && result3[4].value == 2);
free(result1);
free(result2);
free(result3);
return 0;
}
| 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,0x54(%rsp)
mov %rax,%r15
lea 0x54(%rsp),%rax
test %r9d,%r9d
mov %rax,0x10(%rsp)
jle 1548 <func0+0xa8>
mov %r14,(%rsp)
mov %r9d,%eax
xor %r10d,%r10d
mov %r15,%r9
mov %eax,%r15d
movslq %r10d,%rax
lea 0x1(%r10),%esi
shl $0x2,%rax
lea (%r8,%rax,1),%rcx
mov (%rcx),%edx
cmp $0xffffffff,%edx
je 15f8 <func0+0x158>
mov %esi,%r10d
cmp $0xfffffffe,%edx
je 153c <func0+0x9c>
movslq 0x54(%rsp),%rax
lea 0x1(%rax),%ecx
mov %edx,(%r9,%rax,4)
mov %ecx,0x54(%rsp)
cmp %r10d,%r15d
jg 150a <func0+0x6a>
mov (%rsp),%r14
mov %r9,%r15
mov $0x320,%edi
callq 10b0 <malloc@plt>
movl $0x0,(%r14)
mov %rax,%r12
mov 0x54(%rsp),%eax
test %eax,%eax
jle 15b2 <func0+0x112>
sub $0x1,%eax
mov %r15,%r8
lea 0x8(%r12),%r10
xor %edi,%edi
lea 0x4(%r15,%rax,4),%r9
nopw %cs:0x0(%rax,%rax,1)
mov (%r8),%edx
test %edi,%edi
je 15e0 <func0+0x140>
lea -0x1(%rdi),%ecx
mov %r12,%rax
lea (%r10,%rcx,8),%rcx
jmp 15a1 <func0+0x101>
nopl 0x0(%rax,%rax,1)
add $0x8,%rax
cmp %rcx,%rax
je 15e0 <func0+0x140>
cmp %edx,(%rax)
jne 1598 <func0+0xf8>
addl $0x1,0x4(%rax)
add $0x4,%r8
cmp %r8,%r9
jne 1580 <func0+0xe0>
mov %r15,%rdi
callq 1080 <free@plt>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1990 <func0+0x4f0>
add $0x68,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movslq %edi,%rax
add $0x1,%edi
lea (%r12,%rax,8),%rax
mov %edi,(%r14)
mov %edx,(%rax)
movl $0x1,0x4(%rax)
jmp 15a9 <func0+0x109>
lea 0x4(%r8,%rax,1),%r13
add $0x2,%r10d
xor %eax,%eax
mov 0x0(%r13),%edx
cmp $0xfffffffe,%edx
je 153c <func0+0x9c>
mov %eax,%r12d
lea (%r10,%rax,1),%r14d
add $0x1,%rax
cmpl $0xfffffffe,0x4(%rcx,%rax,4)
jne 1610 <func0+0x170>
xor %r10d,%r10d
mov %r8,0x18(%rsp)
mov %r13,%r8
mov %r15d,0x28(%rsp)
lea 0x1(%r10),%eax
mov %r12d,%r15d
mov %r14d,0x8(%rsp)
cmp $0xffffffff,%edx
je 1674 <func0+0x1d4>
cmp $0xfffffffe,%edx
je 1658 <func0+0x1b8>
movslq 0x54(%rsp),%rcx
lea 0x1(%rcx),%esi
mov %edx,(%r9,%rcx,4)
mov %esi,0x54(%rsp)
cmp %r15d,%r10d
jge 18e0 <func0+0x440>
movslq %eax,%rdx
mov %eax,%r10d
mov (%r8,%rdx,4),%edx
lea 0x1(%r10),%eax
cmp $0xffffffff,%edx
jne 1643 <func0+0x1a3>
movslq %eax,%rcx
shl $0x2,%rcx
lea (%r8,%rcx,1),%r13
mov 0x0(%r13),%edx
cmp $0xfffffffe,%edx
je 194f <func0+0x4af>
lea -0x4(%r8,%rcx,1),%rsi
xor %eax,%eax
lea 0x2(%r10),%ecx
nopw 0x0(%rax,%rax,1)
mov %eax,%r12d
lea (%rcx,%rax,1),%r14d
add $0x1,%rax
cmpl $0xfffffffe,0x4(%rsi,%rax,4)
jne 16a0 <func0+0x200>
xor %r10d,%r10d
mov %r8,0x20(%rsp)
mov %r12d,%r8d
mov %r15d,0x2c(%rsp)
lea 0x1(%r10),%eax
mov %r14d,0x38(%rsp)
cmp $0xffffffff,%edx
je 1702 <func0+0x262>
cmp $0xfffffffe,%edx
je 16e5 <func0+0x245>
movslq 0x54(%rsp),%rcx
lea 0x1(%rcx),%esi
mov %edx,(%r9,%rcx,4)
mov %esi,0x54(%rsp)
cmp %r8d,%r10d
jge 18f8 <func0+0x458>
movslq %eax,%rdx
mov %eax,%r10d
mov 0x0(%r13,%rdx,4),%edx
lea 0x1(%r10),%eax
cmp $0xffffffff,%edx
jne 16d0 <func0+0x230>
movslq %eax,%rcx
shl $0x2,%rcx
lea 0x0(%r13,%rcx,1),%r14
mov (%r14),%edx
cmp $0xfffffffe,%edx
je 195d <func0+0x4bd>
lea -0x4(%r13,%rcx,1),%rsi
xor %eax,%eax
lea 0x2(%r10),%ecx
nopl (%rax)
mov %eax,%r11d
lea (%rcx,%rax,1),%r15d
add $0x1,%rax
cmpl $0xfffffffe,0x4(%rsi,%rax,4)
jne 1728 <func0+0x288>
xor %r10d,%r10d
mov %r13,0x30(%rsp)
mov %r9,%r13
mov %r8d,0x3c(%rsp)
lea 0x1(%r10),%eax
mov %r15d,0x48(%rsp)
cmp $0xffffffff,%edx
je 178a <func0+0x2ea>
cmp $0xfffffffe,%edx
je 176e <func0+0x2ce>
movslq 0x54(%rsp),%rcx
lea 0x1(%rcx),%esi
mov %edx,0x0(%r13,%rcx,4)
mov %esi,0x54(%rsp)
cmp %r11d,%r10d
jge 1913 <func0+0x473>
movslq %eax,%rdx
mov %eax,%r10d
mov (%r14,%rdx,4),%edx
lea 0x1(%r10),%eax
cmp $0xffffffff,%edx
jne 1758 <func0+0x2b8>
movslq %eax,%rcx
shl $0x2,%rcx
lea (%r14,%rcx,1),%r8
mov (%r8),%edx
cmp $0xfffffffe,%edx
je 196b <func0+0x4cb>
lea -0x4(%r14,%rcx,1),%rsi
xor %eax,%eax
lea 0x2(%r10),%ecx
nopl 0x0(%rax)
mov %eax,%ebp
lea (%rcx,%rax,1),%r10d
add $0x1,%rax
cmpl $0xfffffffe,0x4(%rsi,%rax,4)
jne 17b0 <func0+0x310>
xor %ebx,%ebx
mov %r8,%r15
lea 0x1(%rbx),%eax
cmp $0xffffffff,%edx
je 17fd <func0+0x35d>
cmp $0xfffffffe,%edx
je 17e4 <func0+0x344>
movslq 0x54(%rsp),%rcx
lea 0x1(%rcx),%esi
mov %edx,0x0(%r13,%rcx,4)
mov %esi,0x54(%rsp)
cmp %ebp,%ebx
jge 1931 <func0+0x491>
movslq %eax,%rdx
mov %eax,%ebx
mov (%r15,%rdx,4),%edx
lea 0x1(%rbx),%eax
cmp $0xffffffff,%edx
jne 17ce <func0+0x32e>
movslq %eax,%rcx
shl $0x2,%rcx
lea (%r15,%rcx,1),%r12
mov (%r12),%edx
cmp $0xfffffffe,%edx
je 1979 <func0+0x4d9>
lea -0x4(%r15,%rcx,1),%rsi
xor %eax,%eax
lea 0x2(%rbx),%ecx
mov %eax,%r8d
lea (%rcx,%rax,1),%ebx
add $0x1,%rax
cmpl $0xfffffffe,0x4(%rsi,%rax,4)
jne 181f <func0+0x37f>
xor %r9d,%r9d
mov %ebx,%eax
mov %r13,%rsi
mov %r11d,%ebx
lea 0x1(%r9),%ecx
mov %r8d,%r11d
mov %r10d,%r13d
mov %eax,%r8d
mov %ecx,%eax
cmp $0xffffffff,%edx
je 1881 <func0+0x3e1>
cmp $0xfffffffe,%edx
je 1863 <func0+0x3c3>
movslq 0x54(%rsp),%rcx
lea 0x1(%rcx),%edi
mov %edx,(%rsi,%rcx,4)
mov %edi,0x54(%rsp)
cmp %r11d,%r9d
jge 193a <func0+0x49a>
movslq %eax,%rdx
mov %eax,%r9d
mov (%r12,%rdx,4),%edx
lea 0x1(%r9),%ecx
mov %ecx,%eax
cmp $0xffffffff,%edx
jne 184f <func0+0x3af>
movslq %ecx,%rax
shl $0x2,%rax
lea (%r12,%rax,1),%rdi
cmpl $0xfffffffe,(%rdi)
je 1985 <func0+0x4e5>
lea -0x4(%r12,%rax,1),%rdx
mov $0x1,%eax
mov %eax,%r9d
lea (%rcx,%rax,1),%r10d
add $0x1,%rax
cmpl $0xfffffffe,(%rdx,%rax,4)
jne 189f <func0+0x3ff>
mov 0x10(%rsp),%rdx
mov %r9d,%ecx
mov %r8d,0x4c(%rsp)
mov %rsi,0x40(%rsp)
callq 13f0 <flatten>
mov 0x40(%rsp),%rsi
mov 0x4c(%rsp),%r8d
lea 0x1(%r10),%eax
mov %r10d,%r9d
jmp 1863 <func0+0x3c3>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsp),%r14d
mov 0x18(%rsp),%r8
mov 0x28(%rsp),%r15d
lea 0x1(%r14),%r10d
jmpq 153c <func0+0x9c>
mov 0x38(%rsp),%r14d
mov 0x20(%rsp),%r8
mov 0x2c(%rsp),%r15d
lea 0x1(%r14),%eax
mov %r14d,%r10d
jmpq 1658 <func0+0x1b8>
mov 0x48(%rsp),%r15d
mov %r13,%r9
mov 0x3c(%rsp),%r8d
mov 0x30(%rsp),%r13
lea 0x1(%r15),%eax
mov %r15d,%r10d
jmpq 16e5 <func0+0x245>
lea 0x1(%r10),%eax
jmpq 176e <func0+0x2ce>
mov %ebx,%r11d
mov %r13d,%r10d
mov %r8d,%ebx
mov %rsi,%r13
lea 0x1(%r8),%eax
jmpq 17e4 <func0+0x344>
lea 0x2(%r10),%edx
mov %eax,%r10d
mov %edx,%eax
jmpq 1658 <func0+0x1b8>
lea 0x2(%r10),%edx
mov %eax,%r10d
mov %edx,%eax
jmpq 16e5 <func0+0x245>
lea 0x2(%r10),%edx
mov %eax,%r10d
mov %edx,%eax
jmpq 176e <func0+0x2ce>
lea 0x2(%rbx),%edx
mov %eax,%ebx
mov %edx,%eax
jmpq 17e4 <func0+0x344>
mov %ecx,%r10d
xor %r9d,%r9d
jmpq 18b0 <func0+0x410>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| 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_44], 0
mov r11, rax
test r15d, r15d
jle loc_1B19
loc_17D1:
movsxd rax, ebp
shl rax, 2
lea rsi, [r13+rax+0]
mov edx, [rsi]
cmp edx, 0FFFFFFFFh
jz loc_18CF
cmp edx, 0FFFFFFFEh
jz short loc_17FD
movsxd rax, [rsp+0B8h+var_44]
lea ecx, [rax+1]
mov [r11+rax*4], edx
mov [rsp+0B8h+var_44], ecx
loc_17FD:
add ebp, 1
cmp r15d, ebp
jg short loc_17D1
movsxd r12, [rsp+0B8h+var_44]
mov edi, 320h; size
mov [rsp+0B8h+ptr], r11
mov rbx, r14
call _malloc
mov dword ptr [r14], 0
mov r11, [rsp+0B8h+ptr]
test r12d, r12d
mov rbp, rax
jle short loc_189E
mov rdi, r11
lea r9, [r11+r12*4]
xor r8d, r8d
nop word ptr [rax+rax+00h]
loc_1840:
movsxd rsi, r8d
mov edx, [rdi]
lea rcx, [rbp+rsi*8+0]
test r8d, r8d
jle short loc_1880
loc_184F:
mov rax, rbp
jmp short loc_1861
loc_1858:
add rax, 8
cmp rax, rcx
jz short loc_1880
loc_1861:
cmp [rax], edx
jnz short loc_1858
add rdi, 4
add dword ptr [rax+4], 1
cmp rdi, r9
jz short loc_189E
mov edx, [rdi]
jmp short loc_184F
loc_1880:
lea rax, [rbp+rsi*8+0]
add r8d, 1
add rdi, 4
mov [rax], edx
mov dword ptr [rax+4], 1
mov [rbx], r8d
cmp rdi, r9
jnz short loc_1840
loc_189E:
mov rdi, r11; ptr
call _free
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz loc_1C0E
add rsp, 88h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_18CF:
lea rcx, [r13+rax+4]
xor eax, eax
mov edx, [rcx]
cmp edx, 0FFFFFFFEh
jz loc_1C02
nop dword ptr [rax+00000000h]
loc_18E8:
mov rbx, rax
lea rax, [rax+1]
cmp dword ptr [rsi+rbx*4+8], 0FFFFFFFEh
jnz short loc_18E8
mov rsi, r13
mov r9d, ebx
mov r13d, ebp
xor eax, eax
mov rdi, rbx
mov ebp, r15d
cmp edx, 0FFFFFFFFh
jz short loc_193D
loc_190C:
cmp edx, 0FFFFFFFEh
jz short loc_1922
movsxd r8, [rsp+0B8h+var_44]
lea ebx, [r8+1]
mov [r11+r8*4], edx
mov [rsp+0B8h+var_44], ebx
loc_1922:
mov r8d, eax
loc_1925:
lea eax, [r8+1]
cmp r8d, r9d
jge loc_1ADE
movsxd rdx, eax
mov edx, [rcx+rdx*4]
cmp edx, 0FFFFFFFFh
jnz short loc_190C
loc_193D:
lea r8d, [rax+1]
movsxd rbx, r8d
shl rbx, 2
lea r15, [rcx+rbx]
mov edx, [r15]
cmp edx, 0FFFFFFFEh
jz short loc_1925
lea r12, [rcx+rbx-4]
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1960:
mov rbx, r8
lea r8, [r8+1]
cmp dword ptr [r12+rbx*4+8], 0FFFFFFFEh
jnz short loc_1960
mov [rsp+0B8h+var_A8], rcx
mov r8, rsi
xor r12d, r12d
mov rcx, rbx
mov [rsp+0B8h+var_9C], r9d
mov esi, r13d
mov r9, rdi
mov edi, ebp
mov dword ptr [rsp+0B8h+ptr], eax
mov rbp, r14
mov r14d, ebx
cmp edx, 0FFFFFFFFh
jz short loc_19CC
loc_1999:
cmp edx, 0FFFFFFFEh
jz short loc_19B0
movsxd rax, [rsp+0B8h+var_44]
lea r10d, [rax+1]
mov [r11+rax*4], edx
mov [rsp+0B8h+var_44], r10d
loc_19B0:
mov r10d, r12d
loc_19B3:
lea r12d, [r10+1]
cmp r10d, r14d
jge loc_1AF0
movsxd rax, r12d
mov edx, [r15+rax*4]
cmp edx, 0FFFFFFFFh
jnz short loc_1999
loc_19CC:
lea r10d, [r12+1]
movsxd rbx, r10d
shl rbx, 2
lea rax, [r15+rbx]
mov edx, [rax]
cmp edx, 0FFFFFFFEh
jz short loc_19B3
lea r13, [r15+rbx-4]
xor r10d, r10d
nop dword ptr [rax+rax+00h]
loc_19F0:
mov rbx, r10
lea r10, [r10+1]
cmp dword ptr [r13+rbx*4+8], 0FFFFFFFEh
jnz short loc_19F0
mov [rsp+0B8h+var_90], esi
mov r10d, ebx
mov rsi, rbp
xor r13d, r13d
mov [rsp+0B8h+var_88], r9
mov ebp, r12d
mov r9d, edi
mov [rsp+0B8h+var_80], r8
mov r8, rbx
mov [rsp+0B8h+var_98], rcx
mov [rsp+0B8h+var_8C], r14d
cmp edx, 0FFFFFFFFh
jz short loc_1A5E
loc_1A2E:
cmp edx, 0FFFFFFFEh
jz short loc_1A43
movsxd rcx, [rsp+0B8h+var_44]
lea edi, [rcx+1]
mov [r11+rcx*4], edx
mov [rsp+0B8h+var_44], edi
loc_1A43:
mov ecx, r13d
loc_1A46:
lea r13d, [rcx+1]
cmp ecx, r10d
jge loc_1B3B
movsxd rdx, r13d
mov edx, [rax+rdx*4]
cmp edx, 0FFFFFFFFh
jnz short loc_1A2E
loc_1A5E:
lea ecx, [r13+1]
movsxd rdi, ecx
shl rdi, 2
lea r12, [rax+rdi]
mov edx, [r12]
cmp edx, 0FFFFFFFEh
jz short loc_1A46
lea rdi, [rax+rdi-4]
xor ecx, ecx
nop dword ptr [rax]
loc_1A80:
mov rbx, rcx
lea rcx, [rcx+1]
cmp dword ptr [rdi+rbx*4+8], 0FFFFFFFEh
jnz short loc_1A80
mov [rsp+0B8h+var_70], rsi
mov rdi, r15
mov r14d, ebx
mov r15, rax
mov [rsp+0B8h+var_78], r8
xor ecx, ecx
mov r8, rbx
mov rax, rdi
loc_1AA9:
cmp edx, 0FFFFFFFFh
jz loc_1B89
cmp edx, 0FFFFFFFEh
jz short loc_1AC7
movsxd rsi, [rsp+0B8h+var_44]
lea edi, [rsi+1]
mov [r11+rsi*4], edx
mov [rsp+0B8h+var_44], edi
loc_1AC7:
mov ebx, ecx
loc_1AC9:
lea ecx, [rbx+1]
cmp ebx, r14d
jge loc_1B69
movsxd rdx, ecx
mov edx, [r12+rdx*4]
jmp short loc_1AA9
loc_1ADE:
mov r15d, ebp
mov ebp, r13d
mov r13, rsi
lea ebp, [rbp+rdi+2]
jmp loc_17FD
loc_1AF0:
mov eax, dword ptr [rsp+0B8h+ptr]
mov rbx, rcx
mov r13d, esi
mov r14, rbp
mov rsi, r8
mov ebp, edi
mov rcx, [rsp+0B8h+var_A8]
mov rdi, r9
lea r8d, [rax+rbx+2]
mov r9d, [rsp+0B8h+var_9C]
jmp loc_1925
loc_1B19:
mov edi, 320h; size
mov [rsp+0B8h+ptr], rax
call _malloc
mov dword ptr [rbx], 0
mov r11, [rsp+0B8h+ptr]
mov rbp, rax
jmp loc_189E
loc_1B3B:
mov rbx, r8
mov r12d, ebp
mov edi, r9d
mov rbp, rsi
mov rcx, [rsp+0B8h+var_98]
mov r14d, [rsp+0B8h+var_8C]
lea r10d, [r12+rbx+2]
mov r8, [rsp+0B8h+var_80]
mov r9, [rsp+0B8h+var_88]
mov esi, [rsp+0B8h+var_90]
jmp loc_19B3
loc_1B69:
mov rdi, rax
mov rbx, r8
mov rax, r15
mov r8, [rsp+0B8h+var_78]
mov rsi, [rsp+0B8h+var_70]
mov r15, rdi
lea ecx, [r13+rbx+2]
jmp loc_1A46
loc_1B89:
add ecx, 1
movsxd rdx, ecx
mov ebx, ecx
shl rdx, 2
lea rdi, [r12+rdx]
cmp dword ptr [rdi], 0FFFFFFFEh
jz short loc_1C0A
lea rsi, [r12+rdx-4]
mov edx, 1
loc_1BA8:
mov rbx, rdx
add rdx, 1
cmp dword ptr [rsi+rdx*4], 0FFFFFFFEh
jnz short loc_1BA8
mov edx, ebx
add ebx, ecx
loc_1BB9:
lea rsi, [rsp+0B8h+var_44]
mov ecx, edx
mov [rsp+0B8h+var_4C], r9d
mov rdx, rsi
mov rsi, r11
mov [rsp+0B8h+var_58], r8
mov [rsp+0B8h+var_50], r10d
mov [rsp+0B8h+var_60], rax
mov [rsp+0B8h+var_68], r11
call flatten
mov r11, [rsp+0B8h+var_68]
mov rax, [rsp+0B8h+var_60]
mov r10d, [rsp+0B8h+var_50]
mov r8, [rsp+0B8h+var_58]
mov r9d, [rsp+0B8h+var_4C]
jmp loc_1AC9
loc_1C02:
add ebp, 1
jmp loc_17FD
loc_1C0A:
xor edx, edx
jmp short loc_1BB9
loc_1C0E:
call ___stack_chk_fail | _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
char *v18; // rdi
char *v19; // r9
int v20; // r8d
int v21; // edx
_DWORD *v22; // rax
_DWORD *v23; // rax
_DWORD *v25; // rcx
long long v26; // rax
int v27; // edx
long long v28; // rbx
long long v29; // rsi
int v30; // r9d
int v31; // r13d
int v32; // eax
long long v33; // rdi
int v34; // ebp
int v35; // ebx
int v36; // r8d
long long v37; // rbx
_DWORD *v38; // r15
int v39; // edx
long long v40; // r12
long long v41; // r8
long long v42; // rbx
long long v43; // r8
int v44; // r12d
long long v45; // rcx
int v46; // esi
long long v47; // r9
int v48; // edi
int *v49; // rbp
int v50; // r14d
int v51; // r10d
int v52; // r10d
long long v53; // rbx
_DWORD *v54; // rax
int v55; // edx
long long v56; // r13
long long v57; // r10
long long v58; // rbx
int v59; // r10d
int *v60; // rsi
int v61; // r13d
int v62; // ebp
int v63; // r9d
long long v64; // r8
int v65; // edi
int v66; // ecx
long long v67; // rdi
_DWORD *v68; // r12
int v69; // edx
long long v70; // rdi
long long v71; // rcx
long long v72; // rbx
_DWORD *v73; // rdi
int v74; // r14d
_DWORD *v75; // r15
int v76; // ecx
long long v77; // r8
_DWORD *v78; // rax
int v79; // edi
int v80; // ebx
int v81; // ebp
int v82; // ebx
_DWORD *v83; // rax
int v84; // r12d
_DWORD *v85; // rdi
int v86; // ebx
int v87; // ecx
long long v88; // rdx
_DWORD *v89; // rdi
long long v90; // rsi
long long v91; // rdx
unsigned int v92; // ebx
unsigned int v93; // edx
char *ptr; // [rsp+8h] [rbp-B0h]
int ptra; // [rsp+8h] [rbp-B0h]
void *ptrb; // [rsp+8h] [rbp-B0h]
_DWORD *v97; // [rsp+10h] [rbp-A8h]
int v98; // [rsp+1Ch] [rbp-9Ch]
long long v99; // [rsp+20h] [rbp-98h]
int v100; // [rsp+28h] [rbp-90h]
int v101; // [rsp+2Ch] [rbp-8Ch]
long long v102; // [rsp+30h] [rbp-88h]
long long v103; // [rsp+38h] [rbp-80h]
long long v104; // [rsp+40h] [rbp-78h]
int *v105; // [rsp+48h] [rbp-70h]
_DWORD *v106; // [rsp+50h] [rbp-68h]
_DWORD *v107; // [rsp+58h] [rbp-60h]
long long v108; // [rsp+60h] [rbp-58h]
int v109; // [rsp+68h] [rbp-50h]
int v110; // [rsp+6Ch] [rbp-4Ch]
int v111; // [rsp+74h] [rbp-44h] BYREF
unsigned long long v112; // [rsp+78h] [rbp-40h]
v3 = a2;
v5 = 0;
v7 = a3;
v112 = __readfsqword(0x28u);
v8 = malloc(0x190uLL);
v111 = 0;
v9 = v8;
if ( a2 <= 0 )
{
ptrb = v8;
v83 = malloc(0x320uLL);
*a3 = 0;
v16 = ptrb;
v17 = v83;
}
else
{
do
{
v10 = 4LL * v5;
v11 = a1 + v10;
v12 = *(_DWORD *)(a1 + v10);
if ( v12 == -1 )
{
v25 = (_DWORD *)(a1 + v10 + 4);
v26 = 0LL;
v27 = *v25;
if ( *v25 == -2 )
{
++v5;
}
else
{
do
v28 = v26++;
while ( *(_DWORD *)(v11 + 4 * v28 + 8) != -2 );
v29 = a1;
v30 = v28;
v31 = v5;
v32 = 0;
v33 = v28;
v34 = v3;
if ( v27 != -1 )
{
LABEL_19:
if ( v27 != -2 )
{
v35 = v111 + 1;
v9[v111] = v27;
v111 = v35;
}
v36 = v32;
goto LABEL_22;
}
while ( 1 )
{
v36 = v32 + 1;
v37 = v32 + 1;
v38 = &v25[v37];
v39 = v25[v37];
if ( v39 != -2 )
{
v40 = (long long)&v25[v37 - 1];
v41 = 0LL;
do
v42 = v41++;
while ( *(_DWORD *)(v40 + 4 * v42 + 8) != -2 );
v97 = v25;
v43 = v29;
v44 = 0;
v45 = v42;
v98 = v30;
v46 = v31;
v47 = v33;
v48 = v34;
ptra = v32;
v49 = v7;
v50 = v42;
if ( v39 != -1 )
{
LABEL_28:
if ( v39 != -2 )
{
v51 = v111 + 1;
v9[v111] = v39;
v111 = v51;
}
v52 = v44;
goto LABEL_31;
}
while ( 1 )
{
v52 = v44 + 1;
v53 = v44 + 1;
v54 = &v38[v53];
v55 = v38[v53];
if ( v55 != -2 )
{
v56 = (long long)&v38[v53 - 1];
v57 = 0LL;
do
v58 = v57++;
while ( *(_DWORD *)(v56 + 4 * v58 + 8) != -2 );
v100 = v46;
v59 = v58;
v60 = v49;
v61 = 0;
v102 = v47;
v62 = v44;
v63 = v48;
v103 = v43;
v64 = v58;
v99 = v45;
v101 = v50;
if ( v55 != -1 )
{
LABEL_37:
if ( v55 != -2 )
{
v65 = v111 + 1;
v9[v111] = v55;
v111 = v65;
}
v66 = v61;
goto LABEL_40;
}
while ( 1 )
{
v66 = v61 + 1;
v67 = v61 + 1;
v68 = &v54[v67];
v69 = v54[v67];
if ( v69 != -2 )
{
v70 = (long long)&v54[v67 - 1];
v71 = 0LL;
do
v72 = v71++;
while ( *(_DWORD *)(v70 + 4 * v72 + 8) != -2 );
v105 = v60;
v73 = v38;
v74 = v72;
v75 = v54;
v104 = v64;
v76 = 0;
v77 = v72;
v78 = v73;
while ( 1 )
{
if ( v69 == -1 )
{
v87 = v76 + 1;
v80 = v87;
v88 = v87;
v89 = &v68[v88];
if ( v68[v88] == -2 )
{
v93 = 0;
}
else
{
v90 = (long long)&v68[v88 - 1];
v91 = 1LL;
do
v92 = v91++;
while ( *(_DWORD *)(v90 + 4 * v91) != -2 );
v93 = v92;
v80 = v87 + v92;
}
v110 = v63;
v108 = v77;
v109 = v59;
v107 = v78;
v106 = v9;
flatten(v89, v9, &v111, v93);
v9 = v106;
v78 = v107;
v59 = v109;
v77 = v108;
v63 = v110;
}
else
{
if ( v69 != -2 )
{
v79 = v111 + 1;
v9[v111] = v69;
v111 = v79;
}
v80 = v76;
}
v76 = v80 + 1;
if ( v80 >= v74 )
break;
v69 = v68[v76];
}
v85 = v78;
v86 = v77;
v54 = v75;
v64 = v104;
v60 = v105;
v38 = v85;
v66 = v61 + v86 + 2;
}
LABEL_40:
v61 = v66 + 1;
if ( v66 >= v59 )
break;
v55 = v54[v61];
if ( v55 != -1 )
goto LABEL_37;
}
v84 = v62;
v48 = v63;
v49 = v60;
v45 = v99;
v50 = v101;
v52 = v84 + v64 + 2;
v43 = v103;
v47 = v102;
v46 = v100;
}
LABEL_31:
v44 = v52 + 1;
if ( v52 >= v50 )
break;
v39 = v38[v44];
if ( v39 != -1 )
goto LABEL_28;
}
v82 = v45;
v31 = v46;
v7 = v49;
v29 = v43;
v34 = v48;
v25 = v97;
v33 = v47;
v36 = ptra + v82 + 2;
v30 = v98;
}
LABEL_22:
v32 = v36 + 1;
if ( v36 >= v30 )
break;
v27 = v25[v32];
if ( v27 != -1 )
goto LABEL_19;
}
v3 = v34;
v81 = v31;
a1 = v29;
v5 = v81 + v33 + 2;
}
}
else if ( v12 != -2 )
{
v13 = v111 + 1;
v9[v111] = v12;
v111 = v13;
}
++v5;
}
while ( v3 > v5 );
v14 = v111;
ptr = (char *)v9;
v15 = malloc(0x320uLL);
*v7 = 0;
v16 = ptr;
v17 = v15;
if ( (int)v14 > 0 )
{
v18 = ptr;
v19 = &ptr[4 * v14];
v20 = 0;
while ( 1 )
{
v21 = *(_DWORD *)v18;
if ( v20 > 0 )
break;
LABEL_14:
v23 = &v17[2 * v20++];
v18 += 4;
*v23 = v21;
v23[1] = 1;
*v7 = v20;
if ( v18 == v19 )
goto LABEL_15;
}
while ( 1 )
{
v22 = v17;
while ( *v22 != v21 )
{
v22 += 2;
if ( v22 == &v17[2 * v20] )
goto LABEL_14;
}
v18 += 4;
++v22[1];
if ( v18 == v19 )
break;
v21 = *(_DWORD *)v18;
}
}
}
LABEL_15:
free(v16);
return v17;
} | 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_001017d1:
MOVSXD RAX,EBP
SHL RAX,0x2
LEA RSI,[R13 + RAX*0x1]
MOV EDX,dword ptr [RSI]
CMP EDX,-0x1
JZ 0x001018cf
CMP EDX,-0x2
JZ 0x001017fd
MOVSXD RAX,dword ptr [RSP + 0x74]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R11 + RAX*0x4],EDX
MOV dword ptr [RSP + 0x74],ECX
LAB_001017fd:
ADD EBP,0x1
CMP R15D,EBP
JG 0x001017d1
MOVSXD R12,dword ptr [RSP + 0x74]
MOV EDI,0x320
MOV qword ptr [RSP + 0x8],R11
MOV RBX,R14
CALL 0x001010b0
MOV dword ptr [R14],0x0
MOV R11,qword ptr [RSP + 0x8]
TEST R12D,R12D
MOV RBP,RAX
JLE 0x0010189e
MOV RDI,R11
LEA R9,[R11 + R12*0x4]
XOR R8D,R8D
NOP word ptr [RAX + RAX*0x1]
LAB_00101840:
MOVSXD RSI,R8D
MOV EDX,dword ptr [RDI]
LEA RCX,[RBP + RSI*0x8]
TEST R8D,R8D
JLE 0x00101880
LAB_0010184f:
MOV RAX,RBP
JMP 0x00101861
LAB_00101858:
ADD RAX,0x8
CMP RAX,RCX
JZ 0x00101880
LAB_00101861:
CMP dword ptr [RAX],EDX
JNZ 0x00101858
ADD RDI,0x4
ADD dword ptr [RAX + 0x4],0x1
CMP RDI,R9
JZ 0x0010189e
MOV EDX,dword ptr [RDI]
JMP 0x0010184f
LAB_00101880:
LEA RAX,[RBP + RSI*0x8]
ADD R8D,0x1
ADD RDI,0x4
MOV dword ptr [RAX],EDX
MOV dword ptr [RAX + 0x4],0x1
MOV dword ptr [RBX],R8D
CMP RDI,R9
JNZ 0x00101840
LAB_0010189e:
MOV RDI,R11
CALL 0x00101080
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101c0e
ADD RSP,0x88
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001018cf:
LEA RCX,[R13 + RAX*0x1 + 0x4]
XOR EAX,EAX
MOV EDX,dword ptr [RCX]
CMP EDX,-0x2
JZ 0x00101c02
NOP dword ptr [RAX]
LAB_001018e8:
MOV RBX,RAX
LEA RAX,[RAX + 0x1]
CMP dword ptr [RSI + RBX*0x4 + 0x8],-0x2
JNZ 0x001018e8
MOV RSI,R13
MOV R9D,EBX
MOV R13D,EBP
XOR EAX,EAX
MOV RDI,RBX
MOV EBP,R15D
CMP EDX,-0x1
JZ 0x0010193d
LAB_0010190c:
CMP EDX,-0x2
JZ 0x00101922
MOVSXD R8,dword ptr [RSP + 0x74]
LEA EBX,[R8 + 0x1]
MOV dword ptr [R11 + R8*0x4],EDX
MOV dword ptr [RSP + 0x74],EBX
LAB_00101922:
MOV R8D,EAX
LAB_00101925:
LEA EAX,[R8 + 0x1]
CMP R8D,R9D
JGE 0x00101ade
MOVSXD RDX,EAX
MOV EDX,dword ptr [RCX + RDX*0x4]
CMP EDX,-0x1
JNZ 0x0010190c
LAB_0010193d:
LEA R8D,[RAX + 0x1]
MOVSXD RBX,R8D
SHL RBX,0x2
LEA R15,[RCX + RBX*0x1]
MOV EDX,dword ptr [R15]
CMP EDX,-0x2
JZ 0x00101925
LEA R12,[RCX + RBX*0x1 + -0x4]
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101960:
MOV RBX,R8
LEA R8,[R8 + 0x1]
CMP dword ptr [R12 + RBX*0x4 + 0x8],-0x2
JNZ 0x00101960
MOV qword ptr [RSP + 0x10],RCX
MOV R8,RSI
XOR R12D,R12D
MOV RCX,RBX
MOV dword ptr [RSP + 0x1c],R9D
MOV ESI,R13D
MOV R9,RDI
MOV EDI,EBP
MOV dword ptr [RSP + 0x8],EAX
MOV RBP,R14
MOV R14D,EBX
CMP EDX,-0x1
JZ 0x001019cc
LAB_00101999:
CMP EDX,-0x2
JZ 0x001019b0
MOVSXD RAX,dword ptr [RSP + 0x74]
LEA R10D,[RAX + 0x1]
MOV dword ptr [R11 + RAX*0x4],EDX
MOV dword ptr [RSP + 0x74],R10D
LAB_001019b0:
MOV R10D,R12D
LAB_001019b3:
LEA R12D,[R10 + 0x1]
CMP R10D,R14D
JGE 0x00101af0
MOVSXD RAX,R12D
MOV EDX,dword ptr [R15 + RAX*0x4]
CMP EDX,-0x1
JNZ 0x00101999
LAB_001019cc:
LEA R10D,[R12 + 0x1]
MOVSXD RBX,R10D
SHL RBX,0x2
LEA RAX,[R15 + RBX*0x1]
MOV EDX,dword ptr [RAX]
CMP EDX,-0x2
JZ 0x001019b3
LEA R13,[R15 + RBX*0x1 + -0x4]
XOR R10D,R10D
NOP dword ptr [RAX + RAX*0x1]
LAB_001019f0:
MOV RBX,R10
LEA R10,[R10 + 0x1]
CMP dword ptr [R13 + RBX*0x4 + 0x8],-0x2
JNZ 0x001019f0
MOV dword ptr [RSP + 0x28],ESI
MOV R10D,EBX
MOV RSI,RBP
XOR R13D,R13D
MOV qword ptr [RSP + 0x30],R9
MOV EBP,R12D
MOV R9D,EDI
MOV qword ptr [RSP + 0x38],R8
MOV R8,RBX
MOV qword ptr [RSP + 0x20],RCX
MOV dword ptr [RSP + 0x2c],R14D
CMP EDX,-0x1
JZ 0x00101a5e
LAB_00101a2e:
CMP EDX,-0x2
JZ 0x00101a43
MOVSXD RCX,dword ptr [RSP + 0x74]
LEA EDI,[RCX + 0x1]
MOV dword ptr [R11 + RCX*0x4],EDX
MOV dword ptr [RSP + 0x74],EDI
LAB_00101a43:
MOV ECX,R13D
LAB_00101a46:
LEA R13D,[RCX + 0x1]
CMP ECX,R10D
JGE 0x00101b3b
MOVSXD RDX,R13D
MOV EDX,dword ptr [RAX + RDX*0x4]
CMP EDX,-0x1
JNZ 0x00101a2e
LAB_00101a5e:
LEA ECX,[R13 + 0x1]
MOVSXD RDI,ECX
SHL RDI,0x2
LEA R12,[RAX + RDI*0x1]
MOV EDX,dword ptr [R12]
CMP EDX,-0x2
JZ 0x00101a46
LEA RDI,[RAX + RDI*0x1 + -0x4]
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101a80:
MOV RBX,RCX
LEA RCX,[RCX + 0x1]
CMP dword ptr [RDI + RBX*0x4 + 0x8],-0x2
JNZ 0x00101a80
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,R15
MOV R14D,EBX
MOV R15,RAX
MOV qword ptr [RSP + 0x40],R8
XOR ECX,ECX
MOV R8,RBX
MOV RAX,RDI
LAB_00101aa9:
CMP EDX,-0x1
JZ 0x00101b89
CMP EDX,-0x2
JZ 0x00101ac7
MOVSXD RSI,dword ptr [RSP + 0x74]
LEA EDI,[RSI + 0x1]
MOV dword ptr [R11 + RSI*0x4],EDX
MOV dword ptr [RSP + 0x74],EDI
LAB_00101ac7:
MOV EBX,ECX
LAB_00101ac9:
LEA ECX,[RBX + 0x1]
CMP EBX,R14D
JGE 0x00101b69
MOVSXD RDX,ECX
MOV EDX,dword ptr [R12 + RDX*0x4]
JMP 0x00101aa9
LAB_00101ade:
MOV R15D,EBP
MOV EBP,R13D
MOV R13,RSI
LEA EBP,[RBP + RDI*0x1 + 0x2]
JMP 0x001017fd
LAB_00101af0:
MOV EAX,dword ptr [RSP + 0x8]
MOV RBX,RCX
MOV R13D,ESI
MOV R14,RBP
MOV RSI,R8
MOV EBP,EDI
MOV RCX,qword ptr [RSP + 0x10]
MOV RDI,R9
LEA R8D,[RAX + RBX*0x1 + 0x2]
MOV R9D,dword ptr [RSP + 0x1c]
JMP 0x00101925
LAB_00101b19:
MOV EDI,0x320
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001010b0
MOV dword ptr [RBX],0x0
MOV R11,qword ptr [RSP + 0x8]
MOV RBP,RAX
JMP 0x0010189e
LAB_00101b3b:
MOV RBX,R8
MOV R12D,EBP
MOV EDI,R9D
MOV RBP,RSI
MOV RCX,qword ptr [RSP + 0x20]
MOV R14D,dword ptr [RSP + 0x2c]
LEA R10D,[R12 + RBX*0x1 + 0x2]
MOV R8,qword ptr [RSP + 0x38]
MOV R9,qword ptr [RSP + 0x30]
MOV ESI,dword ptr [RSP + 0x28]
JMP 0x001019b3
LAB_00101b69:
MOV RDI,RAX
MOV RBX,R8
MOV RAX,R15
MOV R8,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
MOV R15,RDI
LEA ECX,[R13 + RBX*0x1 + 0x2]
JMP 0x00101a46
LAB_00101b89:
ADD ECX,0x1
MOVSXD RDX,ECX
MOV EBX,ECX
SHL RDX,0x2
LEA RDI,[R12 + RDX*0x1]
CMP dword ptr [RDI],-0x2
JZ 0x00101c0a
LEA RSI,[R12 + RDX*0x1 + -0x4]
MOV EDX,0x1
LAB_00101ba8:
MOV RBX,RDX
ADD RDX,0x1
CMP dword ptr [RSI + RDX*0x4],-0x2
JNZ 0x00101ba8
MOV EDX,EBX
ADD EBX,ECX
LAB_00101bb9:
LEA RSI,[RSP + 0x74]
MOV ECX,EDX
MOV dword ptr [RSP + 0x6c],R9D
MOV RDX,RSI
MOV RSI,R11
MOV qword ptr [RSP + 0x60],R8
MOV dword ptr [RSP + 0x68],R10D
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x50],R11
CALL 0x001013e0
MOV R11,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x58]
MOV R10D,dword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0x60]
MOV R9D,dword ptr [RSP + 0x6c]
JMP 0x00101ac9
LAB_00101c02:
ADD EBP,0x1
JMP 0x001017fd
LAB_00101c0a:
XOR EDX,EDX
JMP 0x00101bb9
LAB_00101c0e:
CALL 0x00101090 | 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 iVar18;
long in_FS_OFFSET;
int local_44;
long local_40;
iVar12 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)malloc(400);
local_44 = 0;
if (param_2 < 1) {
piVar4 = (int *)malloc(800);
*param_3 = 0;
}
else {
do {
piVar4 = (int *)(param_1 + (long)iVar12 * 4);
iVar9 = *piVar4;
if (iVar9 == -1) {
piVar14 = (int *)(param_1 + 4 + (long)iVar12 * 4);
iVar9 = *piVar14;
lVar3 = 0;
if (iVar9 != -2) {
do {
lVar13 = lVar3;
lVar3 = lVar13 + 1;
} while (piVar4[lVar13 + 2] != -2);
iVar2 = 0;
if (iVar9 == -1) goto LAB_0010193d;
do {
iVar17 = iVar2;
if (iVar9 != -2) {
lVar3 = (long)local_44;
local_44 = local_44 + 1;
__ptr[lVar3] = iVar9;
}
LAB_00101925:
iVar2 = iVar17 + 1;
if ((int)lVar13 <= iVar17) {
iVar12 = iVar12 + 2 + (int)lVar13;
goto LAB_001017fd;
}
iVar9 = piVar14[iVar2];
} while (iVar9 != -1);
LAB_0010193d:
iVar17 = iVar2 + 1;
piVar4 = piVar14 + iVar17;
iVar9 = *piVar4;
if (iVar9 != -2) {
lVar3 = 0;
do {
lVar15 = lVar3;
lVar3 = lVar15 + 1;
} while (piVar14[(long)iVar17 + lVar15 + 1] != -2);
iVar17 = 0;
if (iVar9 == -1) goto LAB_001019cc;
do {
iVar6 = iVar17;
if (iVar9 != -2) {
lVar3 = (long)local_44;
local_44 = local_44 + 1;
__ptr[lVar3] = iVar9;
}
LAB_001019b3:
iVar17 = iVar6 + 1;
if ((int)lVar15 <= iVar6) {
iVar17 = iVar2 + 2 + (int)lVar15;
goto LAB_00101925;
}
iVar9 = piVar4[iVar17];
} while (iVar9 != -1);
LAB_001019cc:
iVar6 = iVar17 + 1;
piVar5 = piVar4 + iVar6;
iVar9 = *piVar5;
if (iVar9 != -2) {
lVar3 = 0;
do {
lVar16 = lVar3;
lVar3 = lVar16 + 1;
} while (piVar4[(long)iVar6 + lVar16 + 1] != -2);
iVar18 = 0;
iVar6 = iVar18;
if (iVar9 == -1) goto LAB_00101a5e;
do {
if (iVar9 != -2) {
lVar3 = (long)local_44;
local_44 = local_44 + 1;
__ptr[lVar3] = iVar9;
}
while( true ) {
iVar18 = iVar6 + 1;
if ((int)lVar16 <= iVar6) {
iVar6 = iVar17 + 2 + (int)lVar16;
goto LAB_001019b3;
}
iVar9 = piVar5[iVar18];
iVar6 = iVar18;
if (iVar9 != -1) break;
LAB_00101a5e:
iVar6 = iVar18 + 1;
piVar1 = piVar5 + iVar6;
iVar9 = *piVar1;
if (iVar9 != -2) {
lVar3 = 0;
do {
lVar8 = lVar3;
lVar3 = lVar8 + 1;
} while (piVar5[(long)iVar6 + lVar8 + 1] != -2);
iVar6 = 0;
while( true ) {
if (iVar9 == -1) {
iVar7 = iVar6 + 1;
lVar3 = (long)iVar7;
if (piVar1[lVar3] == -2) {
uVar11 = 0;
}
else {
uVar11 = 1;
do {
uVar10 = uVar11;
uVar11 = uVar10 + 1;
} while (piVar1[(long)iVar7 + uVar10] != -2);
uVar11 = uVar10 & 0xffffffff;
iVar7 = (int)uVar10 + iVar7;
}
flatten(piVar1 + lVar3,__ptr,&local_44,uVar11);
}
else {
iVar7 = iVar6;
if (iVar9 != -2) {
lVar3 = (long)local_44;
local_44 = local_44 + 1;
__ptr[lVar3] = iVar9;
}
}
iVar6 = iVar7 + 1;
if ((int)lVar8 <= iVar7) break;
iVar9 = piVar1[iVar6];
}
iVar6 = iVar18 + 2 + (int)lVar8;
}
}
} while( true );
}
goto LAB_001019b3;
}
goto LAB_00101925;
}
iVar12 = iVar12 + 1;
}
else if (iVar9 != -2) {
lVar3 = (long)local_44;
local_44 = local_44 + 1;
__ptr[lVar3] = iVar9;
}
LAB_001017fd:
iVar9 = local_44;
iVar12 = iVar12 + 1;
} while (iVar12 < param_2);
lVar3 = (long)local_44;
piVar4 = (int *)malloc(800);
*param_3 = 0;
if (0 < iVar9) {
iVar12 = 0;
piVar14 = __ptr;
do {
lVar13 = (long)iVar12;
iVar9 = *piVar14;
piVar5 = piVar4;
if (0 < iVar12) {
do {
while (*piVar5 == iVar9) {
piVar14 = piVar14 + 1;
piVar5[1] = piVar5[1] + 1;
if (piVar14 == __ptr + lVar3) goto LAB_0010189e;
piVar5 = piVar4;
iVar9 = *piVar14;
}
piVar5 = piVar5 + 2;
} while (piVar5 != piVar4 + lVar13 * 2);
}
iVar12 = iVar12 + 1;
piVar14 = piVar14 + 1;
piVar4[lVar13 * 2] = iVar9;
(piVar4 + lVar13 * 2)[1] = 1;
*param_3 = iVar12;
} while (piVar14 != __ptr + lVar3);
}
}
LAB_0010189e:
free(__ptr);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return piVar4;
} |
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[] = {7, 8, 9, 10};
int test_tup2_size = sizeof(test_tup2) / sizeof(test_tup2[0]);
char** result2 = func0(test_tup2, test_tup2_size, "PF");
assert(strcmp(result2[0], "7") == 0 && strcmp(result2[1], "PF") == 0 && strcmp(result2[2], "8") == 0);
int test_tup3[] = {11, 14, 12, 1, 4};
int test_tup3_size = sizeof(test_tup3) / sizeof(test_tup3[0]);
char** result3 = func0(test_tup3, test_tup3_size, "JH");
assert(strcmp(result3[0], "11") == 0 && strcmp(result3[1], "JH") == 0 && strcmp(result3[2], "14") == 0);
printf("All tests passed!\n");
// freeing allocated memory
free(result1);
free(result2);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
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+0xa7>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%ecx
mov %ecx,-0x10(%rbp)
cltq
lea 0x0(,%rax,8),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
lea 0xd8a(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1110 <asprintf@plt>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x28(%rbp),%rax
mov %rax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1247 <func0+0x3e>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
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 short loc_12B3
loc_1247:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
lea ecx, [rax+1]
mov [rbp+var_10], ecx
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rcx
lea rcx, fmt; "%d"
mov rsi, rcx; fmt
mov rdi, rax; ptr
mov eax, 0
call _asprintf
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rdx, rax
mov rax, [rbp+var_28]
mov [rdx], rax
add [rbp+var_C], 1
loc_12B3:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_1247
mov rax, [rbp+var_8]
leave
retn | 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;
v6 += 2;
v8[v3] = a3;
}
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x1c]
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 + -0xc],0x0
JMP 0x001012b3
LAB_00101247:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],ECX
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101110
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RDX],RAX
ADD dword ptr [RBP + -0xc],0x1
LAB_001012b3:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101247
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | 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)local_18 * 8),"%d",
(ulong)*(uint *)(param_1 + (long)local_14 * 4));
local_18 = local_18 + 2;
*(int8 *)((long)iVar1 * 8 + (long)pvVar2) = param_3;
}
return pvVar2;
} |
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[] = {7, 8, 9, 10};
int test_tup2_size = sizeof(test_tup2) / sizeof(test_tup2[0]);
char** result2 = func0(test_tup2, test_tup2_size, "PF");
assert(strcmp(result2[0], "7") == 0 && strcmp(result2[1], "PF") == 0 && strcmp(result2[2], "8") == 0);
int test_tup3[] = {11, 14, 12, 1, 4};
int test_tup3_size = sizeof(test_tup3) / sizeof(test_tup3[0]);
char** result3 = func0(test_tup3, test_tup3_size, "JH");
assert(strcmp(result3[0], "11") == 0 && strcmp(result3[1], "JH") == 0 && strcmp(result3[2], "14") == 0);
printf("All tests passed!\n");
// freeing allocated memory
free(result1);
free(result2);
free(result3);
return 0;
}
| 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
lea -0x1(%r12),%r12d
add $0x1,%r12
shl $0x4,%r12
add %rax,%r12
lea 0xdcf(%rip),%r15
mov 0x0(%rbp),%edx
mov %r15,%rsi
mov %rbx,%rdi
mov $0x0,%eax
callq 10f0 <asprintf@plt>
mov %r13,0x8(%rbx)
add $0x4,%rbp
add $0x10,%rbx
cmp %r12,%rbx
jne 1235 <func0+0x4c>
mov %r14,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov 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
shl r12, 4
add r12, rax
lea r15, unk_2004
loc_124F:
mov edx, [rbp+0]
mov rsi, r15
mov rdi, rbx
mov eax, 0
call _asprintf
mov [rbx+8], r13
add rbp, 4
add rbx, 10h
cmp rbx, r12
jnz short loc_124F
loc_1273:
mov rax, r14
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | 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);
*(_QWORD *)(v7 + 8) = a3;
++a1;
v7 += 16LL;
}
while ( v7 != v8 );
}
return v6;
} | 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,dword ptr [RBP]
MOV RSI,R15
MOV RDI,RBX
MOV EAX,0x0
CALL 0x00101110
MOV qword ptr [RBX + 0x8],R13
ADD RBP,0x4
ADD RBX,0x10
CMP RBX,R12
JNZ 0x0010124f
LAB_00101273:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | 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;
__ptr = __ptr + 2;
} while (__ptr != ppcVar1 + (ulong)param_2 * 2);
}
return ppcVar1;
} |
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[] = {7, 8, 9, 10};
int test_tup2_size = sizeof(test_tup2) / sizeof(test_tup2[0]);
char** result2 = func0(test_tup2, test_tup2_size, "PF");
assert(strcmp(result2[0], "7") == 0 && strcmp(result2[1], "PF") == 0 && strcmp(result2[2], "8") == 0);
int test_tup3[] = {11, 14, 12, 1, 4};
int test_tup3_size = sizeof(test_tup3) / sizeof(test_tup3[0]);
char** result3 = func0(test_tup3, test_tup3_size, "JH");
assert(strcmp(result3[0], "11") == 0 && strcmp(result3[1], "JH") == 0 && strcmp(result3[2], "14") == 0);
printf("All tests passed!\n");
// freeing allocated memory
free(result1);
free(result2);
free(result3);
return 0;
}
| 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
mov %rax,%rbx
lea 0xbb4(%rip),%r15
add $0x1,%r12
shl $0x4,%r12
add %rax,%r12
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%edx
mov %rbx,%rdi
mov %r15,%rsi
xor %eax,%eax
add $0x10,%rbx
add $0x4,%rbp
callq 10f0 <asprintf@plt>
mov %r13,-0x8(%rbx)
cmp %r12,%rbx
jne 1460 <func0+0x50>
add $0x8,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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 r15, unk_2004
add r12, rax
nop dword ptr [rax+00h]
loc_1478:
mov edx, [rbp+0]
mov rdi, rbx
mov rsi, r15
xor eax, eax
add rbx, 10h
add rbp, 4
call _asprintf
mov [rbx-8], r13
cmp rbx, r12
jnz short loc_1478
loc_1499:
add rsp, 8
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | 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
{
v9 = *a1;
v10 = v7;
v7 += 16LL;
++a1;
asprintf(v10, &unk_2004, v9);
*(_QWORD *)(v7 - 8) = a3;
}
while ( v7 != v8 );
}
return v6;
} | 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 EDX,dword ptr [RBP]
MOV RDI,RBX
MOV RSI,R15
XOR EAX,EAX
ADD RBX,0x10
ADD RBP,0x4
CALL 0x00101110
MOV qword ptr [RBX + -0x8],R13
CMP RBX,R12
JNZ 0x00101478
LAB_00101499:
ADD RSP,0x8
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | 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 + 1;
asprintf(__ptr,"%d",(ulong)uVar1);
__ptr[1] = param_3;
__ptr = ppcVar3;
} while (ppcVar3 != ppcVar2 + (ulong)param_2 * 2);
}
return ppcVar2;
} |
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[] = {7, 8, 9, 10};
int test_tup2_size = sizeof(test_tup2) / sizeof(test_tup2[0]);
char** result2 = func0(test_tup2, test_tup2_size, "PF");
assert(strcmp(result2[0], "7") == 0 && strcmp(result2[1], "PF") == 0 && strcmp(result2[2], "8") == 0);
int test_tup3[] = {11, 14, 12, 1, 4};
int test_tup3_size = sizeof(test_tup3) / sizeof(test_tup3[0]);
char** result3 = func0(test_tup3, test_tup3_size, "JH");
assert(strcmp(result3[0], "11") == 0 && strcmp(result3[1], "JH") == 0 && strcmp(result3[2], "14") == 0);
printf("All tests passed!\n");
// freeing allocated memory
free(result1);
free(result2);
free(result3);
return 0;
}
| 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
mov %rax,%rbx
lea 0xbe4(%rip),%r15
add $0x1,%r12
shl $0x4,%r12
add %rax,%r12
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%edx
mov %rbx,%rdi
mov %r15,%rsi
xor %eax,%eax
add $0x10,%rbx
add $0x4,%rbp
callq 10f0 <asprintf@plt>
mov %r13,-0x8(%rbx)
cmp %rbx,%r12
jne 1430 <func0+0x50>
add $0x8,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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, rax
add r12, rax
lea r15, fmt; "%d"
nop dword ptr [rax+00000000h]
loc_1438:
mov edx, [rbp+0]
mov rdi, rbx; ptr
mov rsi, r15; fmt
xor eax, eax
add rbx, 10h
add rbp, 4
call _asprintf
mov [rbx-8], r13
cmp r12, rbx
jnz short loc_1438
loc_1459:
add rsp, 8
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | 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 += 2;
++a1;
asprintf(v10, "%d", v9);
*(v7 - 1) = a3;
}
while ( v8 != v7 );
}
return v6;
} | 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 EDX,dword ptr [RBP]
MOV RDI,RBX
MOV RSI,R15
XOR EAX,EAX
ADD RBX,0x10
ADD RBP,0x4
CALL 0x00101110
MOV qword ptr [RBX + -0x8],R13
CMP R12,RBX
JNZ 0x00101438
LAB_00101459:
ADD RSP,0x8
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | 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;
asprintf(__ptr,"%d",(ulong)uVar1);
__ptr[1] = param_3;
__ptr = ppcVar3;
} while (ppcVar2 + param_2 * 2 != ppcVar3);
}
return ppcVar2;
} |
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)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_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 [rbp+var_4], 1
loc_11A5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
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 dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
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,%rax
jne 1170 <func0+0x30>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 11e8 <func0+0xa8>
movslq %edx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
add $0x3,%edx
add (%rdi,%rcx,4),%eax
cmp %edx,%esi
jle 11e2 <func0+0xa2>
movslq %edx,%rdx
add (%rdi,%rdx,4),%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 11aa <func0+0x6a>
| 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 rax, rdx
jnz short loc_1170
movdqa xmm1, xmm0
mov edx, esi
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short locret_11E0
loc_11AA:
movsxd rdi, edx
lea r8, ds:0[rdi*4]
add eax, [rcx+rdi*4]
lea edi, [rdx+1]
cmp esi, edi
jle short locret_11DA
add edx, 2
add eax, [rcx+r8+4]
cmp esi, edx
jle short locret_11DA
add eax, [rcx+r8+8]
retn
loc_11D8:
xor eax, eax
locret_11DA:
retn
locret_11E0:
retn
loc_11E1:
xor edx, edx
xor eax, eax
jmp short loc_11AA | 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;
}
else
{
v2 = a1;
v3 = 0LL;
do
{
v4 = _mm_loadu_si128(v2++);
v3 = _mm_add_epi32(v3, v4);
}
while ( v2 != &a1[(unsigned int)a2 >> 2] );
v5 = a2 & 0x7FFFFFFC;
v6 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v6, _mm_srli_si128(v6, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v8 = v5;
result = (unsigned int)(a1->m128i_i32[v8] + result);
if ( a2 > v5 + 1 )
{
result = (unsigned int)(a1->m128i_i32[v8 + 1] + result);
if ( a2 > v5 + 2 )
return (unsigned int)(a1->m128i_i32[v8 + 2] + result);
}
return result;
} | 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 XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x001011e0
LAB_001011aa:
MOVSXD RDI,EDX
LEA R8,[RDI*0x4]
ADD EAX,dword ptr [RCX + RDI*0x4]
LEA EDI,[RDX + 0x1]
CMP ESI,EDI
JLE 0x001011da
ADD EDX,0x2
ADD EAX,dword ptr [RCX + R8*0x1 + 0x4]
CMP ESI,EDX
JLE 0x001011da
ADD EAX,dword ptr [RCX + R8*0x1 + 0x8]
RET
LAB_001011d8:
XOR EAX,EAX
LAB_001011da:
RET
LAB_001011e0:
RET
LAB_001011e1:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011aa | 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 {
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
piVar5 = param_1;
do {
iVar1 = *piVar5;
piVar2 = piVar5 + 1;
piVar3 = piVar5 + 2;
piVar4 = piVar5 + 3;
piVar5 = piVar5 + 4;
iVar7 = iVar7 + iVar1;
iVar8 = iVar8 + *piVar2;
iVar9 = iVar9 + *piVar3;
iVar10 = iVar10 + *piVar4;
} while (piVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar6 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) == 0) {
return iVar7;
}
}
iVar7 = iVar7 + param_1[(int)uVar6];
if ((int)(uVar6 + 1) < (int)param_2) {
iVar7 = iVar7 + param_1[(long)(int)uVar6 + 1];
if ((int)(uVar6 + 2) < (int)param_2) {
return iVar7 + param_1[(long)(int)uVar6 + 2];
}
}
}
return iVar7;
} |
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 < m; k++) {
temp[k] = false;
}
for (int j = 0; j < m; j++) {
if (DP[j]) {
if (!DP[(j + arr[i]) % m]) {
temp[(j + arr[i]) % m] = true;
}
}
}
for (int j = 0; j < m; j++) {
if (temp[j]) {
DP[j] = true;
}
}
DP[arr[i] % m] = true;
}
return DP[0];
}
| 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 11ab <func0+0x42>
mov $0x1,%eax
jmpq 1456 <func0+0x2ed>
mov -0x70(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x48(%rbp)
movslq %eax,%rdx
mov %rdx,%r12
mov $0x0,%r13d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
mov $0x10,%edx
sub $0x1,%rdx
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1219 <func0+0xb0>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1202 <func0+0x99>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1243 <func0+0xda>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x0,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x4c(%rbp)
jmp 1268 <func0+0xff>
mov -0x40(%rbp),%rdx
mov -0x4c(%rbp),%eax
cltq
movb $0x0,(%rdx,%rax,1)
addl $0x1,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
cmp -0x70(%rbp),%eax
jl 1257 <func0+0xee>
movl $0x0,-0x50(%rbp)
jmpq 1443 <func0+0x2da>
mov %rsp,%rax
mov %rax,%rcx
mov -0x40(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 129a <func0+0x131>
mov $0x1,%eax
mov %rcx,%rsp
jmpq 1456 <func0+0x2ed>
mov -0x70(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x38(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
cltq
mov $0x10,%edx
sub $0x1,%rdx
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 1309 <func0+0x1a0>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 12f2 <func0+0x189>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1333 <func0+0x1ca>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x0,%rax
mov %rax,-0x30(%rbp)
movl $0x0,-0x54(%rbp)
jmp 1358 <func0+0x1ef>
mov -0x30(%rbp),%rdx
mov -0x54(%rbp),%eax
cltq
movb $0x0,(%rdx,%rax,1)
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x70(%rbp),%eax
jl 1347 <func0+0x1de>
movl $0x0,-0x58(%rbp)
jmp 13db <func0+0x272>
mov -0x40(%rbp),%rdx
mov -0x58(%rbp),%eax
cltq
movzbl (%rdx,%rax,1),%eax
test %al,%al
je 13d7 <func0+0x26e>
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x58(%rbp),%eax
add %edx,%eax
cltd
idivl -0x70(%rbp)
mov %edx,%eax
mov -0x40(%rbp),%rdx
cltq
movzbl (%rdx,%rax,1),%eax
xor $0x1,%eax
test %al,%al
je 13d7 <func0+0x26e>
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x58(%rbp),%eax
add %edx,%eax
cltd
idivl -0x70(%rbp)
mov %edx,%eax
mov -0x30(%rbp),%rdx
cltq
movb $0x1,(%rdx,%rax,1)
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x70(%rbp),%eax
jl 1369 <func0+0x200>
movl $0x0,-0x5c(%rbp)
jmp 140e <func0+0x2a5>
mov -0x30(%rbp),%rdx
mov -0x5c(%rbp),%eax
cltq
movzbl (%rdx,%rax,1),%eax
test %al,%al
je 140a <func0+0x2a1>
mov -0x40(%rbp),%rdx
mov -0x5c(%rbp),%eax
cltq
movb $0x1,(%rdx,%rax,1)
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x70(%rbp),%eax
jl 13ec <func0+0x283>
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
idivl -0x70(%rbp)
mov %edx,%eax
mov -0x40(%rbp),%rdx
cltq
movb $0x1,(%rdx,%rax,1)
mov %rcx,%rsp
addl $0x1,-0x50(%rbp)
mov -0x50(%rbp),%eax
cmp -0x6c(%rbp),%eax
jl 127c <func0+0x113>
mov -0x40(%rbp),%rax
movzbl (%rax),%eax
mov %rsi,%rsp
mov -0x28(%rbp),%rsi
xor %fs:0x28,%rsi
je 146d <func0+0x304>
callq 1060 <__stack_chk_fail@plt>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
| 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 eax, 1
jmp loc_141C
loc_11A6:
mov eax, [rbp+var_50]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_28], rdx
cdqe
mov edx, 10h
sub rdx, 1
add rax, rdx
mov esi, 10h
mov edx, 0
div rsi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11E3:
cmp rsp, rdx
jz short loc_11FA
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_11E3
loc_11FA:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1224
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1224:
mov rax, rsp
add rax, 0
mov [rbp+var_20], rax
mov [rbp+var_3C], 0
jmp short loc_1249
loc_1238:
mov rdx, [rbp+var_20]
mov eax, [rbp+var_3C]
cdqe
mov byte ptr [rdx+rax], 0
add [rbp+var_3C], 1
loc_1249:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_50]
jl short loc_1238
mov [rbp+var_38], 0
jmp loc_1409
loc_125D:
mov rax, rsp
mov rsi, rax
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
test al, al
jz short loc_127B
mov eax, 1
mov rsp, rsi
jmp loc_141C
loc_127B:
mov eax, [rbp+var_50]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
mov edx, 10h
sub rdx, 1
add rax, rdx
mov ecx, 10h
mov edx, 0
div rcx
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_12B8:
cmp rsp, rdx
jz short loc_12CF
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_12B8
loc_12CF:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12F9
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12F9:
mov rax, rsp
add rax, 0
mov [rbp+var_10], rax
mov [rbp+var_34], 0
jmp short loc_131E
loc_130D:
mov rdx, [rbp+var_10]
mov eax, [rbp+var_34]
cdqe
mov byte ptr [rdx+rax], 0
add [rbp+var_34], 1
loc_131E:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_50]
jl short loc_130D
mov [rbp+var_30], 0
jmp short loc_13A1
loc_132F:
mov rdx, [rbp+var_20]
mov eax, [rbp+var_30]
cdqe
movzx eax, byte ptr [rdx+rax]
test al, al
jz short loc_139D
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_30]
add eax, edx
cdq
idiv [rbp+var_50]
mov eax, edx
mov rdx, [rbp+var_20]
cdqe
movzx eax, byte ptr [rdx+rax]
xor eax, 1
test al, al
jz short loc_139D
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_30]
add eax, edx
cdq
idiv [rbp+var_50]
mov eax, edx
mov rdx, [rbp+var_10]
cdqe
mov byte ptr [rdx+rax], 1
loc_139D:
add [rbp+var_30], 1
loc_13A1:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_50]
jl short loc_132F
mov [rbp+var_2C], 0
jmp short loc_13D4
loc_13B2:
mov rdx, [rbp+var_10]
mov eax, [rbp+var_2C]
cdqe
movzx eax, byte ptr [rdx+rax]
test al, al
jz short loc_13D0
mov rdx, [rbp+var_20]
mov eax, [rbp+var_2C]
cdqe
mov byte ptr [rdx+rax], 1
loc_13D0:
add [rbp+var_2C], 1
loc_13D4:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_50]
jl short loc_13B2
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
cdq
idiv [rbp+var_50]
mov eax, edx
mov rdx, [rbp+var_20]
cdqe
mov byte ptr [rdx+rax], 1
mov rsp, rsi
add [rbp+var_38], 1
loc_1409:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_4C]
jl loc_125D
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
loc_141C:
mov rsp, rdi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1433
call ___stack_chk_fail
locret_1433:
leave
retn | 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-38h]
int k; // [rsp+24h] [rbp-34h]
int m; // [rsp+28h] [rbp-30h]
int n; // [rsp+2Ch] [rbp-2Ch]
long long v16; // [rsp+30h] [rbp-28h]
unsigned __int8 *v17; // [rsp+38h] [rbp-20h]
long long v18; // [rsp+40h] [rbp-18h]
int *v19; // [rsp+48h] [rbp-10h]
unsigned long long v20; // [rsp+50h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
v20 = __readfsqword(0x28u);
if ( a2 > a3 )
return 1LL;
v16 = v8 - 1LL;
v4 = 16 * ((v8 + 15LL) / 0x10uLL);
while ( &v8 != (int *)((char *)&v8 - (v4 & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v8 + (v4 & 0xFFF) - 8) = *(_QWORD *)((char *)&v8 + (v4 & 0xFFF) - 8);
v17 = (unsigned __int8 *)&v8;
for ( i = 0; i < v8; ++i )
v17[i] = 0;
for ( j = 0; j < v9; ++j )
{
if ( *v17 )
return 1LL;
v18 = v8 - 1LL;
v6 = 16 * ((v8 + 15LL) / 0x10uLL);
while ( &v8 != (int *)((char *)&v8 - (v6 & 0xFFFFFFFFFFFFF000LL)) )
;
v7 = alloca(v6 & 0xFFF);
if ( (v6 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v8 + (v6 & 0xFFF) - 8) = *(_QWORD *)((char *)&v8 + (v6 & 0xFFF) - 8);
v19 = &v8;
for ( k = 0; k < v8; ++k )
*((_BYTE *)v19 + k) = 0;
for ( m = 0; m < v8; ++m )
{
if ( v17[m] && v17[(*(_DWORD *)(4LL * j + v10) + m) % v8] != 1 )
*((_BYTE *)v19 + (*(_DWORD *)(4LL * j + v10) + m) % v8) = 1;
}
for ( n = 0; n < v8; ++n )
{
if ( *((_BYTE *)v19 + n) )
v17[n] = 1;
}
v17[*(_DWORD *)(4LL * j + v10) % v8] = 1;
}
return *v17;
} | 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
MOV EAX,0x1
JMP 0x0010141c
LAB_001011a6:
MOV EAX,dword ptr [RBP + -0x50]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
CDQE
MOV EDX,0x10
SUB RDX,0x1
ADD RAX,RDX
MOV ESI,0x10
MOV EDX,0x0
DIV RSI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011e3:
CMP RSP,RDX
JZ 0x001011fa
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011e3
LAB_001011fa:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101224
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101224:
MOV RAX,RSP
ADD RAX,0x0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x00101249
LAB_00101238:
MOV RDX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x0
ADD dword ptr [RBP + -0x3c],0x1
LAB_00101249:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x50]
JL 0x00101238
MOV dword ptr [RBP + -0x38],0x0
JMP 0x00101409
LAB_0010125d:
MOV RAX,RSP
MOV RSI,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x0010127b
MOV EAX,0x1
MOV RSP,RSI
JMP 0x0010141c
LAB_0010127b:
MOV EAX,dword ptr [RBP + -0x50]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
MOV EDX,0x10
SUB RDX,0x1
ADD RAX,RDX
MOV ECX,0x10
MOV EDX,0x0
DIV RCX
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001012b8:
CMP RSP,RDX
JZ 0x001012cf
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001012b8
LAB_001012cf:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012f9
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012f9:
MOV RAX,RSP
ADD RAX,0x0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x34],0x0
JMP 0x0010131e
LAB_0010130d:
MOV RDX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x34]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x0
ADD dword ptr [RBP + -0x34],0x1
LAB_0010131e:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x50]
JL 0x0010130d
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001013a1
LAB_0010132f:
MOV RDX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x30]
CDQE
MOVZX EAX,byte ptr [RDX + RAX*0x1]
TEST AL,AL
JZ 0x0010139d
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EDX
CDQ
IDIV dword ptr [RBP + -0x50]
MOV EAX,EDX
MOV RDX,qword ptr [RBP + -0x20]
CDQE
MOVZX EAX,byte ptr [RDX + RAX*0x1]
XOR EAX,0x1
TEST AL,AL
JZ 0x0010139d
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EDX
CDQ
IDIV dword ptr [RBP + -0x50]
MOV EAX,EDX
MOV RDX,qword ptr [RBP + -0x10]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x1
LAB_0010139d:
ADD dword ptr [RBP + -0x30],0x1
LAB_001013a1:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x50]
JL 0x0010132f
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001013d4
LAB_001013b2:
MOV RDX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
MOVZX EAX,byte ptr [RDX + RAX*0x1]
TEST AL,AL
JZ 0x001013d0
MOV RDX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x1
LAB_001013d0:
ADD dword ptr [RBP + -0x2c],0x1
LAB_001013d4:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x50]
JL 0x001013b2
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQ
IDIV dword ptr [RBP + -0x50]
MOV EAX,EDX
MOV RDX,qword ptr [RBP + -0x20]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x1
MOV RSP,RSI
ADD dword ptr [RBP + -0x38],0x1
LAB_00101409:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x0010125d
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
LAB_0010141c:
MOV RSP,RDI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101433
CALL 0x00101060
LAB_00101433:
LEAVE
RET | 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_28;
long local_20;
int *local_18;
long local_10;
piVar5 = &local_58;
local_50 = param_1;
local_54 = param_2;
local_58 = param_3;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 < param_2) {
cVar3 = '\x01';
}
else {
local_30 = (long)param_3 + -1;
uVar4 = (((long)param_3 + 0xfU) / 0x10) * 0x10;
for (; piVar5 != (int *)((long)&local_58 - (uVar4 & 0xfffffffffffff000));
piVar5 = (int *)((long)piVar5 + -0x1000)) {
*(int8 *)((long)piVar5 + -8) = *(int8 *)((long)piVar5 + -8);
}
lVar1 = -(ulong)((uint)uVar4 & 0xfff);
if ((uVar4 & 0xfff) != 0) {
*(int8 *)((long)piVar5 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar1) =
*(int8 *)((long)piVar5 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar1);
}
local_28 = (char *)((long)piVar5 + lVar1);
for (local_44 = 0; local_44 < local_58; local_44 = local_44 + 1) {
*(int *)((long)piVar5 + local_44 + lVar1) = 0;
}
for (local_40 = 0; local_40 < local_54; local_40 = local_40 + 1) {
if (*local_28 != '\0') {
cVar3 = '\x01';
goto LAB_0010141c;
}
local_20 = (long)local_58 + -1;
uVar4 = (((long)local_58 + 0xfU) / 0x10) * 0x10;
for (puVar6 = (int *)((long)piVar5 + lVar1);
puVar6 != (int *)((long)piVar5 + (lVar1 - (uVar4 & 0xfffffffffffff000)));
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
lVar2 = -(ulong)((uint)uVar4 & 0xfff);
if ((uVar4 & 0xfff) != 0) {
*(int8 *)(puVar6 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar2) =
*(int8 *)(puVar6 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar2);
}
local_18 = puVar6 + lVar2;
for (local_3c = 0; local_3c < local_58; local_3c = local_3c + 1) {
puVar6[local_3c + lVar2] = 0;
}
for (local_38 = 0; local_38 < local_58; local_38 = local_38 + 1) {
if ((local_28[local_38] != '\0') &&
(local_28[(local_38 + *(int *)(local_50 + (long)local_40 * 4)) % local_58] != '\x01')) {
puVar6[(local_38 + *(int *)(local_50 + (long)local_40 * 4)) % local_58 + lVar2] = 1;
}
}
for (local_34 = 0; local_34 < local_58; local_34 = local_34 + 1) {
if (puVar6[local_34 + lVar2] != '\0') {
local_28[local_34] = '\x01';
}
}
local_28[*(int *)(local_50 + (long)local_40 * 4) % local_58] = '\x01';
}
cVar3 = *local_28;
}
LAB_0010141c:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return cVar3;
} |
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 < m; k++) {
temp[k] = false;
}
for (int j = 0; j < m; j++) {
if (DP[j]) {
if (!DP[(j + arr[i]) % m]) {
temp[(j + arr[i]) % m] = true;
}
}
}
for (int j = 0; j < m; j++) {
if (temp[j]) {
DP[j] = true;
}
}
DP[arr[i] % m] = true;
}
return DP[0];
}
| 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 $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11d1 <func0+0x68>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11ba <func0+0x51>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11e7 <func0+0x7e>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%rcx
test %r8d,%r8d
jle 1207 <func0+0x9e>
mov %rcx,%rax
lea -0x1(%r8),%edx
lea 0x1(%rcx,%rdx,1),%rdx
movb $0x0,(%rax)
add $0x1,%rax
cmp %rdx,%rax
jne 11fb <func0+0x92>
test %esi,%esi
jle 1323 <func0+0x1ba>
mov %rdi,%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r13
mov $0x10,%ebx
add $0xf,%r10
lea -0x1(%r8),%esi
lea 0x1(%rsi),%r14
mov $0x0,%r12d
jmpq 12d8 <func0+0x16f>
mov %r11,%rsp
jmpq 1326 <func0+0x1bd>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
je 1255 <func0+0xec>
orq $0x0,-0x8(%rsp,%rdx,1)
mov %rsp,%rdi
test %r8d,%r8d
jle 12be <func0+0x155>
mov %rdi,%rax
lea (%r14,%rdi,1),%rdx
movb $0x0,(%rax)
add $0x1,%rax
cmp %rdx,%rax
jne 1264 <func0+0xfb>
mov %r12,%r15
jmp 1281 <func0+0x118>
lea 0x1(%r15),%rax
cmp %rsi,%r15
je 12a1 <func0+0x138>
mov %rax,%r15
cmpb $0x0,(%rcx,%r15,1)
je 1275 <func0+0x10c>
mov %r15d,%eax
add (%r9),%eax
cltd
idiv %r8d
movslq %edx,%rax
cmpb $0x0,(%rcx,%rax,1)
jne 1275 <func0+0x10c>
movb $0x1,(%rdi,%rax,1)
jmp 1275 <func0+0x10c>
mov %r12,%rax
jmp 12b2 <func0+0x149>
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 12be <func0+0x155>
mov %rdx,%rax
cmpb $0x0,(%rdi,%rax,1)
je 12a6 <func0+0x13d>
movb $0x1,(%rcx,%rax,1)
jmp 12a6 <func0+0x13d>
mov (%r9),%eax
cltd
idiv %r8d
movslq %edx,%rdx
movb $0x1,(%rcx,%rdx,1)
mov %r11,%rsp
add $0x4,%r9
cmp %r13,%r9
je 1323 <func0+0x1ba>
mov %rsp,%r11
movzbl (%rcx),%eax
test %al,%al
jne 1236 <func0+0xcd>
mov %r10,%rax
mov $0x0,%edx
div %rbx
shl $0x4,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 123e <func0+0xd5>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1308 <func0+0x19f>
movzbl (%rcx),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 1344 <func0+0x1db>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| 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, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11B7:
cmp rsp, rdx
jz short loc_11CE
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11B7
loc_11CE:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11E4
or [rsp+rax+40h+var_48], 0
loc_11E4:
mov rcx, rsp
test r8d, r8d
jle short loc_1204
mov rax, rcx
lea edx, [r8-1]
lea rdx, [rcx+rdx+1]
loc_11F8:
mov byte ptr [rax], 0
add rax, 1
cmp rax, rdx
jnz short loc_11F8
loc_1204:
test esi, esi
jle loc_131D
mov r9, rdi
lea eax, [rsi-1]
lea r13, [rdi+rax*4+4]
mov ebx, 10h
add r10, 0Fh
lea esi, [r8-1]
lea r14, [rsi+1]
mov r12d, 0
jmp loc_12D5
loc_1233:
mov rsp, r11
jmp loc_1320
loc_123B:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jz short loc_1252
or [rsp+rdx+40h+var_48], 0
loc_1252:
mov rdi, rsp
test r8d, r8d
jle short loc_12BB
mov rax, rdi
lea rdx, [r14+rdi]
loc_1261:
mov byte ptr [rax], 0
add rax, 1
cmp rax, rdx
jnz short loc_1261
mov r15, r12
jmp short loc_127E
loc_1272:
lea rax, [r15+1]
cmp r15, rsi
jz short loc_129E
mov r15, rax
loc_127E:
cmp byte ptr [rcx+r15], 0
jz short loc_1272
mov eax, r15d
add eax, [r9]
cdq
idiv r8d
movsxd rax, edx
cmp byte ptr [rcx+rax], 0
jnz short loc_1272
mov byte ptr [rdi+rax], 1
jmp short loc_1272
loc_129E:
mov rax, r12
jmp short loc_12AF
loc_12A3:
lea rdx, [rax+1]
cmp rax, rsi
jz short loc_12BB
mov rax, rdx
loc_12AF:
cmp byte ptr [rdi+rax], 0
jz short loc_12A3
mov byte ptr [rcx+rax], 1
jmp short loc_12A3
loc_12BB:
mov eax, [r9]
cdq
idiv r8d
movsxd rdx, edx
mov byte ptr [rcx+rdx], 1
mov rsp, r11
add r9, 4
cmp r9, r13
jz short loc_131D
loc_12D5:
mov r11, rsp
movzx eax, byte ptr [rcx]
test al, al
jnz loc_1233
mov rax, r10
mov edx, 0
div rbx
shl rax, 4
mov rdi, rax
and rdi, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rdi
loc_1302:
cmp rsp, rdx
jz loc_123B
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_1302
loc_131D:
movzx eax, byte ptr [rcx]
loc_1320:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_133E
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_133E:
call ___stack_chk_fail | 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 long long v15; // rdx
void *v16; // rsp
_BYTE *v17; // rax
long long i; // r15
int v19; // edx
long long j; // rax
unsigned long long v21; // rax
_BYTE v23[8]; // [rsp+8h] [rbp-40h] BYREF
unsigned long long v24; // [rsp+10h] [rbp-38h]
v24 = __readfsqword(0x28u);
result = 1LL;
if ( a2 <= a3 )
{
v5 = a3;
v6 = (a3 + 15) & 0xFFF0;
v7 = &v23[-((a3 + 15LL) & 0xFFFFFFFFFFFFF000LL)];
while ( v23 != v7 )
;
v8 = v6 & 0xFFF;
v9 = alloca(v8);
if ( (v6 & 0xFFF) != 0 )
*(_QWORD *)&v23[v8 - 8] = *(_QWORD *)&v23[v8 - 8];
if ( a3 > 0 )
{
v10 = v23;
do
*v10++ = 0;
while ( v10 != &v23[a3 - 1 + 1] );
}
if ( a2 <= 0 )
{
return v23[0];
}
else
{
v11 = a1;
v12 = (long long)&a1[a2 - 1 + 1];
v13 = v5 + 15;
v14 = (unsigned int)(a3 - 1);
while ( 1 )
{
result = v23[0];
if ( v23[0] )
break;
v21 = 16 * (v13 / 0x10);
while ( v23 != &v23[-(v21 & 0xFFFFFFFFFFFFF000LL)] )
;
v15 = v21 & 0xFFF;
v16 = alloca(v15);
if ( (v21 & 0xFFF) != 0 )
*(_QWORD *)&v23[v15 - 8] = *(_QWORD *)&v23[v15 - 8];
if ( a3 > 0 )
{
v17 = v23;
do
*v17++ = 0;
while ( v17 != &v23[v14 + 1] );
for ( i = 0LL; ; ++i )
{
if ( v23[i] )
{
v19 = (*v11 + (int)i) % a3;
if ( !v23[v19] )
v23[v19] = 1;
}
if ( i == v14 )
break;
}
for ( j = 0LL; ; ++j )
{
if ( v23[j] )
v23[j] = 1;
if ( j == v14 )
break;
}
}
v23[*v11++ % a3] = 1;
if ( v11 == (_DWORD *)v12 )
return v23[0];
}
}
}
return result;
} | 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_001011b7:
CMP RSP,RDX
JZ 0x001011ce
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011b7
LAB_001011ce:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011e4
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011e4:
MOV RCX,RSP
TEST R8D,R8D
JLE 0x00101204
MOV RAX,RCX
LEA EDX,[R8 + -0x1]
LEA RDX,[RCX + RDX*0x1 + 0x1]
LAB_001011f8:
MOV byte ptr [RAX],0x0
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001011f8
LAB_00101204:
TEST ESI,ESI
JLE 0x0010131d
MOV R9,RDI
LEA EAX,[RSI + -0x1]
LEA R13,[RDI + RAX*0x4 + 0x4]
MOV EBX,0x10
ADD R10,0xf
LEA ESI,[R8 + -0x1]
LEA R14,[RSI + 0x1]
MOV R12D,0x0
JMP 0x001012d5
LAB_00101233:
MOV RSP,R11
JMP 0x00101320
LAB_0010123b:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JZ 0x00101252
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
LAB_00101252:
MOV RDI,RSP
TEST R8D,R8D
JLE 0x001012bb
MOV RAX,RDI
LEA RDX,[R14 + RDI*0x1]
LAB_00101261:
MOV byte ptr [RAX],0x0
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101261
MOV R15,R12
JMP 0x0010127e
LAB_00101272:
LEA RAX,[R15 + 0x1]
CMP R15,RSI
JZ 0x0010129e
MOV R15,RAX
LAB_0010127e:
CMP byte ptr [RCX + R15*0x1],0x0
JZ 0x00101272
MOV EAX,R15D
ADD EAX,dword ptr [R9]
CDQ
IDIV R8D
MOVSXD RAX,EDX
CMP byte ptr [RCX + RAX*0x1],0x0
JNZ 0x00101272
MOV byte ptr [RDI + RAX*0x1],0x1
JMP 0x00101272
LAB_0010129e:
MOV RAX,R12
JMP 0x001012af
LAB_001012a3:
LEA RDX,[RAX + 0x1]
CMP RAX,RSI
JZ 0x001012bb
MOV RAX,RDX
LAB_001012af:
CMP byte ptr [RDI + RAX*0x1],0x0
JZ 0x001012a3
MOV byte ptr [RCX + RAX*0x1],0x1
JMP 0x001012a3
LAB_001012bb:
MOV EAX,dword ptr [R9]
CDQ
IDIV R8D
MOVSXD RDX,EDX
MOV byte ptr [RCX + RDX*0x1],0x1
MOV RSP,R11
ADD R9,0x4
CMP R9,R13
JZ 0x0010131d
LAB_001012d5:
MOV R11,RSP
MOVZX EAX,byte ptr [RCX]
TEST AL,AL
JNZ 0x00101233
MOV RAX,R10
MOV EDX,0x0
DIV RBX
SHL RAX,0x4
MOV RDI,RAX
AND RDI,-0x1000
MOV RDX,RSP
SUB RDX,RDI
LAB_00101302:
CMP RSP,RDX
JZ 0x0010123b
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101302
LAB_0010131d:
MOVZX EAX,byte ptr [RCX]
LAB_00101320:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010133e
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010133e:
CALL 0x00101060 | 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;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
cVar4 = '\x01';
puVar11 = auStack_48;
if (param_2 <= param_3) {
uVar5 = (long)param_3 + 0xf;
for (; puVar10 != auStack_48 + -(uVar5 & 0xfffffffffffff000); puVar10 = puVar10 + -0x1000) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar2 = -uVar5;
puVar6 = puVar10 + lVar2;
puVar11 = puVar10 + lVar2;
if (uVar5 != 0) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
if (0 < param_3) {
do {
*puVar6 = 0;
puVar6 = puVar6 + 1;
} while (puVar6 != puVar10 + (ulong)(param_3 - 1) + lVar2 + 1);
}
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar5 = (ulong)(param_3 - 1);
do {
cVar4 = puVar10[lVar2];
if (cVar4 != '\0') goto LAB_00101320;
uVar9 = ((long)param_3 + 0xfU) / 0x10 << 4;
for (puVar6 = puVar10 + lVar2; puVar6 != puVar10 + (lVar2 - (uVar9 & 0xfffffffffffff000));
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar9 = (ulong)((uint)uVar9 & 0xfff);
lVar3 = -uVar9;
puVar7 = puVar6 + lVar3;
if (uVar9 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (0 < param_3) {
do {
*puVar7 = 0;
puVar7 = puVar7 + 1;
} while (puVar7 != puVar6 + uVar5 + 1 + lVar3);
uVar9 = 0;
do {
if ((puVar10[uVar9 + lVar2] != '\0') &&
(lVar8 = (long)(((int)uVar9 + *param_1) % param_3), puVar10[lVar8 + lVar2] == '\0'))
{
puVar6[lVar8 + lVar3] = 1;
}
bVar12 = uVar9 != uVar5;
uVar9 = uVar9 + 1;
} while (bVar12);
uVar9 = 0;
do {
if (puVar6[uVar9 + lVar3] != '\0') {
puVar10[uVar9 + lVar2] = 1;
}
bVar12 = uVar9 != uVar5;
uVar9 = uVar9 + 1;
} while (bVar12);
}
puVar10[*param_1 % param_3 + lVar2] = 1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
cVar4 = puVar10[lVar2];
puVar11 = puVar10 + lVar2;
}
LAB_00101320:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar11 + -8) = main;
__stack_chk_fail();
}
return cVar4;
} |
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 < m; k++) {
temp[k] = false;
}
for (int j = 0; j < m; j++) {
if (DP[j]) {
if (!DP[(j + arr[i]) % m]) {
temp[(j + arr[i]) % m] = true;
}
}
}
for (int j = 0; j < m; j++) {
if (temp[j]) {
DP[j] = true;
}
}
DP[arr[i] % m] = true;
}
return DP[0];
}
| 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 %rcx,%rdx
mov %rcx,%rax
and $0xfffffffffffff000,%rdx
and $0xfffffffffffffff0,%rax
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 12ff <func0+0x6f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 12ea <func0+0x5a>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1312 <func0+0x82>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r8
test %r9d,%r9d
jle 133c <func0+0xac>
lea -0x1(%r9),%edx
mov %rsp,%rax
lea 0x1(%rsp,%rdx,1),%rdx
nopw %cs:0x0(%rax,%rax,1)
movb $0x0,(%rax)
add $0x1,%rax
cmp %rdx,%rax
jne 1330 <func0+0xa0>
test %esi,%esi
jle 1465 <func0+0x1d5>
lea -0x1(%rsi),%eax
mov %rcx,%r14
and $0xff0,%ecx
mov %rdi,%r12
lea 0x4(%rdi,%rax,4),%r15
lea -0x8(%rcx),%rax
mov %rcx,-0x48(%rbp)
and $0xfffffffffffff000,%r14
lea -0x1(%r9),%edi
mov %rax,-0x58(%rbp)
lea 0x1(%rdi),%rax
lea (%r8,%rdi,1),%r10
mov %rax,-0x50(%rbp)
nopl 0x0(%rax,%rax,1)
movzbl (%r8),%eax
mov %rsp,%r13
test %al,%al
jne 1469 <func0+0x1d9>
mov %rsp,%rax
sub %r14,%rax
cmp %rax,%rsp
je 13af <func0+0x11f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 139a <func0+0x10a>
mov -0x48(%rbp),%rax
sub %rax,%rsp
test %rax,%rax
je 13c4 <func0+0x134>
mov -0x58(%rbp),%rax
orq $0x0,(%rsp,%rax,1)
mov -0x50(%rbp),%rcx
mov (%r12),%ebx
mov %rsp,%rsi
mov %rsp,%rax
lea (%rsp,%rcx,1),%rdx
test %r9d,%r9d
jle 1447 <func0+0x1b7>
nopl 0x0(%rax,%rax,1)
movb $0x0,(%rax)
add $0x1,%rax
cmp %rdx,%rax
jne 13e0 <func0+0x150>
mov %ebx,%r11d
mov %r8,%rcx
sub %r8d,%r11d
nopl (%rax)
cmp %rcx,%r10
je 1424 <func0+0x194>
movzbl 0x1(%rcx),%eax
add $0x1,%rcx
test %al,%al
je 13f8 <func0+0x168>
lea (%r11,%rcx,1),%eax
cltd
idiv %r9d
movslq %edx,%rdx
cmpb $0x0,(%r8,%rdx,1)
jne 13f8 <func0+0x168>
movb $0x1,(%rsi,%rdx,1)
cmp %rcx,%r10
jne 13fd <func0+0x16d>
xor %eax,%eax
jmp 1433 <func0+0x1a3>
nopl 0x0(%rax,%rax,1)
mov %rdx,%rax
cmpb $0x0,(%rsi,%rax,1)
je 143e <func0+0x1ae>
movb $0x1,(%r8,%rax,1)
lea 0x1(%rax),%rdx
cmp %rdi,%rax
jne 1430 <func0+0x1a0>
mov %ebx,%eax
add $0x4,%r12
cltd
idiv %r9d
movslq %edx,%rdx
movb $0x1,(%r8,%rdx,1)
mov %r13,%rsp
cmp %r15,%r12
jne 1380 <func0+0xf0>
movzbl (%r8),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 1487 <func0+0x1f7>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| 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+0Fh]
mov r14, rdi
mov rsi, r15
mov rax, r15
and rsi, 0FFFFFFFFFFFFF000h
and rax, 0FFFFFFFFFFFFFFF0h
sub rcx, rsi
cmp rsp, rcx
jz short loc_1311
loc_12FC:
sub rsp, 1000h
or [rsp+1070h+var_78], 0
cmp rsp, rcx
jnz short loc_12FC
loc_1311:
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1324
or [rsp+rax+1070h+var_1078], 0
loc_1324:
mov r12, rsp
test ebx, ebx
jle short loc_1335
xor esi, esi
mov rdi, rsp
call _memset
loc_1335:
test r13d, r13d
jle loc_1464
lea eax, [r13-1]
mov r13, r14
lea rax, [r14+rax*4+4]
mov [rbp+var_50], rax
mov rax, r15
and r15d, 0FF0h
and rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_60], r15
mov [rbp+var_58], rax
lea rax, [r15-8]
mov [rbp+var_68], rax
nop dword ptr [rax+00h]
loc_1370:
movzx eax, byte ptr [r12]
mov r15, rsp
test al, al
jnz loc_1469
mov rdx, [rbp+var_58]
mov rax, rsp
and rdx, 0FFFFFFFFFFFFF000h
sub rax, rdx
cmp rsp, rax
jz short loc_13AB
loc_1396:
sub rsp, 1000h
or [rsp+2070h+var_1078], 0
cmp rsp, rax
jnz short loc_1396
loc_13AB:
mov rax, [rbp+var_60]
sub rsp, rax
test rax, rax
jz short loc_13C0
mov rax, [rbp+var_68]
or [rsp+rax+2070h+var_2070], 0
loc_13C0:
mov r14, rsp
test ebx, ebx
jle loc_1487
mov r8d, ebx
xor esi, esi
mov rdi, rsp
mov rdx, r8
mov [rbp+var_48], r8
call _memset
mov r11d, [r13+0]
lea esi, [rbx-1]
mov r8, [rbp+var_48]
add rsi, r12
mov rcx, r12
mov edi, r11d
sub edi, r12d
nop word ptr [rax+rax+00000000h]
loc_1400:
cmp rcx, rsi
jz short loc_142B
loc_1405:
movzx eax, byte ptr [rcx+1]
add rcx, 1
test al, al
jz short loc_1400
lea eax, [rdi+rcx]
cdq
idiv ebx
movsxd rdx, edx
cmp byte ptr [r12+rdx], 0
jnz short loc_1400
mov byte ptr [r14+rdx], 1
cmp rcx, rsi
jnz short loc_1405
loc_142B:
xor eax, eax
nop dword ptr [rax]
loc_1430:
cmp byte ptr [r14+rax], 0
jz short loc_143C
mov byte ptr [r12+rax], 1
loc_143C:
add rax, 1
cmp r8, rax
jnz short loc_1430
loc_1445:
mov eax, r11d
add r13, 4
cdq
idiv ebx
movsxd rdx, edx
mov byte ptr [r12+rdx], 1
mov rsp, r15
cmp r13, [rbp+var_50]
jnz loc_1370
loc_1464:
movzx eax, byte ptr [r12]
loc_1469:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_148D
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1487:
mov r11d, [r13+0]
jmp short loc_1445
loc_148D:
call ___stack_chk_fail | 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
unsigned int v16; // edi
long long v18; // rdx
long long v19; // rax
_QWORD v20[512]; // [rsp+0h] [rbp-2070h] BYREF
_BYTE v21[4088]; // [rsp+1000h] [rbp-1070h] BYREF
long long v22; // [rsp+2000h] [rbp-70h] BYREF
long long v23; // [rsp+2008h] [rbp-68h]
signed long long v24; // [rsp+2010h] [rbp-60h]
unsigned long long v25; // [rsp+2018h] [rbp-58h]
long long v26; // [rsp+2020h] [rbp-50h]
long long v27; // [rsp+2028h] [rbp-48h]
unsigned long long v28; // [rsp+2038h] [rbp-38h]
v28 = __readfsqword(0x28u);
result = 1LL;
if ( a2 <= a3 )
{
v5 = a3 + 15LL;
v6 = (long long *)((char *)&v22 - (v5 & 0xFFFFFFFFFFFFF000LL));
if ( &v22 != v6 )
{
while ( v21 != (_BYTE *)v6 )
;
}
v7 = ((_WORD)a3 + 15) & 0xFF0;
v8 = alloca(v7);
if ( (((_WORD)a3 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v20[511] + v7) = *(_QWORD *)((char *)&v20[511] + v7);
if ( a3 > 0 )
memset(v21, 0LL);
if ( a2 <= 0 )
{
return v21[0];
}
else
{
v9 = a1;
v26 = (long long)&a1[a2 - 1 + 1];
v24 = v5 & 0xFF0;
v25 = v5 & 0xFFFFFFFFFFFFFFF0LL;
v23 = v24 - 8;
while ( 1 )
{
result = v21[0];
if ( v21[0] )
break;
v10 = &v21[-(v25 & 0xFFFFFFFFFFFFF000LL)];
if ( v21 != (_BYTE *)v10 )
{
while ( v20 != v10 )
;
}
v11 = alloca(v24);
if ( v24 )
*(_QWORD *)((char *)v20 + v23) = *(_QWORD *)((char *)v20 + v23);
if ( a3 <= 0 )
{
v12 = *v9;
}
else
{
v27 = (unsigned int)a3;
memset(v20, 0LL);
v12 = *v9;
v13 = v27;
v14 = &v21[a3 - 1];
v15 = v21;
v16 = *v9 - (unsigned int)v21;
while ( v15 != v14 )
{
while ( *++v15 )
{
v18 = (int)(v16 + (_DWORD)v15) % a3;
if ( v21[v18] )
break;
*((_BYTE *)v20 + v18) = 1;
if ( v15 == v14 )
goto LABEL_21;
}
}
LABEL_21:
v19 = 0LL;
do
{
if ( *((_BYTE *)v20 + v19) )
v21[v19] = 1;
++v19;
}
while ( v13 != v19 );
}
++v9;
v21[v12 % a3] = 1;
if ( v9 == (int *)v26 )
return v21[0];
}
}
}
return result;
} | 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,-0x1000
AND RAX,-0x10
SUB RCX,RSI
CMP RSP,RCX
JZ 0x00101311
LAB_001012fc:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012fc
LAB_00101311:
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101324
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101324:
MOV R12,RSP
TEST EBX,EBX
JLE 0x00101335
XOR ESI,ESI
MOV RDI,RSP
CALL 0x00101090
LAB_00101335:
TEST R13D,R13D
JLE 0x00101464
LEA EAX,[R13 + -0x1]
MOV R13,R14
LEA RAX,[R14 + RAX*0x4 + 0x4]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,R15
AND R15D,0xff0
AND RAX,-0x10
MOV qword ptr [RBP + -0x60],R15
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[R15 + -0x8]
MOV qword ptr [RBP + -0x68],RAX
NOP dword ptr [RAX]
LAB_00101370:
MOVZX EAX,byte ptr [R12]
MOV R15,RSP
TEST AL,AL
JNZ 0x00101469
MOV RDX,qword ptr [RBP + -0x58]
MOV RAX,RSP
AND RDX,-0x1000
SUB RAX,RDX
CMP RSP,RAX
JZ 0x001013ab
LAB_00101396:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RAX
JNZ 0x00101396
LAB_001013ab:
MOV RAX,qword ptr [RBP + -0x60]
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001013c0
MOV RAX,qword ptr [RBP + -0x68]
OR qword ptr [RSP + RAX*0x1],0x0
LAB_001013c0:
MOV R14,RSP
TEST EBX,EBX
JLE 0x00101487
MOV R8D,EBX
XOR ESI,ESI
MOV RDI,RSP
MOV RDX,R8
MOV qword ptr [RBP + -0x48],R8
CALL 0x00101090
MOV R11D,dword ptr [R13]
LEA ESI,[RBX + -0x1]
MOV R8,qword ptr [RBP + -0x48]
ADD RSI,R12
MOV RCX,R12
MOV EDI,R11D
SUB EDI,R12D
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101400:
CMP RCX,RSI
JZ 0x0010142b
LAB_00101405:
MOVZX EAX,byte ptr [RCX + 0x1]
ADD RCX,0x1
TEST AL,AL
JZ 0x00101400
LEA EAX,[RDI + RCX*0x1]
CDQ
IDIV EBX
MOVSXD RDX,EDX
CMP byte ptr [R12 + RDX*0x1],0x0
JNZ 0x00101400
MOV byte ptr [R14 + RDX*0x1],0x1
CMP RCX,RSI
JNZ 0x00101405
LAB_0010142b:
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101430:
CMP byte ptr [R14 + RAX*0x1],0x0
JZ 0x0010143c
MOV byte ptr [R12 + RAX*0x1],0x1
LAB_0010143c:
ADD RAX,0x1
CMP R8,RAX
JNZ 0x00101430
LAB_00101445:
MOV EAX,R11D
ADD R13,0x4
CDQ
IDIV EBX
MOVSXD RDX,EDX
MOV byte ptr [R12 + RDX*0x1],0x1
MOV RSP,R15
CMP R13,qword ptr [RBP + -0x50]
JNZ 0x00101370
LAB_00101464:
MOVZX EAX,byte ptr [R12]
LAB_00101469:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010148d
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101487:
MOV R11D,dword ptr [R13]
JMP 0x00101445
LAB_0010148d:
CALL 0x00101070 | 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 *local_58;
ulong local_50;
long local_40;
int1 *puVar10;
int1 *puVar12;
puVar9 = auStack_78;
puVar10 = auStack_78;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
cVar4 = '\x01';
puVar7 = auStack_78;
if (param_2 <= (int)param_3) {
uVar6 = (long)(int)param_3 + 0xf;
puVar7 = auStack_78;
while (puVar10 != auStack_78 + -(uVar6 & 0xfffffffffffff000)) {
puVar9 = puVar7 + -0x1000;
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
puVar10 = puVar7 + -0x1000;
puVar7 = puVar7 + -0x1000;
}
uVar5 = (ulong)((uint)uVar6 & 0xff0);
lVar2 = -uVar5;
if (uVar5 != 0) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
if (0 < (int)param_3) {
*(int8 *)(puVar9 + lVar2 + -8) = 0x101335;
memset(puVar9 + lVar2,0,(long)(int)param_3);
}
if (0 < param_2) {
local_58 = param_1 + (ulong)(param_2 - 1) + 1;
local_68 = (ulong)((uint)uVar6 & 0xff0);
local_60 = uVar6 & 0xfffffffffffffff0;
local_70 = local_68 - 8;
do {
cVar4 = puVar9[lVar2];
puVar7 = puVar9 + lVar2;
if (cVar4 != '\0') goto LAB_00101469;
puVar7 = puVar9 + lVar2;
puVar11 = puVar9 + lVar2;
puVar12 = puVar9 + lVar2;
while (puVar12 != puVar9 + (lVar2 - (local_60 & 0xfffffffffffff000))) {
puVar11 = puVar7 + -0x1000;
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
puVar12 = puVar7 + -0x1000;
puVar7 = puVar7 + -0x1000;
}
lVar3 = -local_68;
if (local_68 != 0) {
*(int8 *)(puVar11 + local_70 + lVar3) = *(int8 *)(puVar11 + local_70 + lVar3);
}
if ((int)param_3 < 1) {
iVar13 = *param_1;
}
else {
local_50 = (ulong)param_3;
*(int8 *)(puVar11 + lVar3 + -8) = 0x1013df;
memset(puVar11 + lVar3,0,local_50);
iVar13 = *param_1;
puVar7 = puVar9 + lVar2;
while (puVar7 != puVar9 + (ulong)(param_3 - 1) + lVar2) {
while ((pcVar1 = puVar7 + 1, puVar7 = puVar7 + 1, *pcVar1 != '\0' &&
(lVar8 = (long)(((iVar13 - ((int)puVar9 + (int)lVar2)) + (int)puVar7) %
(int)param_3), puVar9[lVar8 + lVar2] == '\0'))) {
puVar11[lVar8 + lVar3] = 1;
if (puVar7 == puVar9 + (ulong)(param_3 - 1) + lVar2) goto LAB_0010142b;
}
}
LAB_0010142b:
uVar6 = 0;
do {
if (puVar11[uVar6 + lVar3] != '\0') {
puVar9[uVar6 + lVar2] = 1;
}
uVar6 = uVar6 + 1;
} while (local_50 != uVar6);
}
param_1 = param_1 + 1;
puVar9[iVar13 % (int)param_3 + lVar2] = 1;
} while (param_1 != local_58);
}
cVar4 = puVar9[lVar2];
puVar7 = puVar9 + lVar2;
}
LAB_00101469:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + -8) = 0x101492;
__stack_chk_fail();
}
return cVar4;
} |
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 < m; k++) {
temp[k] = false;
}
for (int j = 0; j < m; j++) {
if (DP[j]) {
if (!DP[(j + arr[i]) % m]) {
temp[(j + arr[i]) % m] = true;
}
}
}
for (int j = 0; j < m; j++) {
if (temp[j]) {
DP[j] = true;
}
}
DP[arr[i] % m] = true;
}
return DP[0];
}
| 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 $0xf,%rcx
mov %rdi,%r13
mov %rcx,%rdx
mov %rcx,%rax
and $0xfffffffffffff000,%rdx
and $0xfffffffffffffff0,%rax
sub %rdx,%rsi
mov %rsi,%rdx
cmp %rdx,%rsp
je 1315 <func0+0x75>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 1300 <func0+0x60>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1328 <func0+0x88>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%rbx
test %r15d,%r15d
jle 134a <func0+0xaa>
lea -0x1(%r15),%edx
xor %esi,%esi
mov %rsp,%rdi
mov %rcx,-0x48(%rbp)
add $0x1,%rdx
callq 1090 <memset@plt>
mov -0x48(%rbp),%rcx
test %r12d,%r12d
jle 1476 <func0+0x1d6>
lea -0x1(%r12),%eax
lea 0x4(%r13,%rax,4),%rax
mov %rax,-0x60(%rbp)
mov %rcx,%rax
and $0xff0,%ecx
and $0xfffffffffffffff0,%rax
mov %rcx,-0x70(%rbp)
mov %rax,-0x68(%rbp)
lea -0x8(%rcx),%rax
mov %rax,-0x78(%rbp)
xchg %ax,%ax
movzbl (%rbx),%eax
mov %rsp,%r14
test %al,%al
jne 1479 <func0+0x1d9>
mov -0x68(%rbp),%rax
mov %rsp,%rdi
and $0xfffffffffffff000,%rax
sub %rax,%rdi
mov %rdi,%rax
cmp %rax,%rsp
je 13bb <func0+0x11b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 13a6 <func0+0x106>
mov -0x70(%rbp),%rax
sub %rax,%rsp
test %rax,%rax
je 13d0 <func0+0x130>
mov -0x78(%rbp),%rax
orq $0x0,(%rsp,%rax,1)
mov 0x0(%r13),%eax
mov %rsp,%r12
mov %eax,-0x48(%rbp)
test %r15d,%r15d
jle 1457 <func0+0x1b7>
lea -0x1(%r15),%r9d
xor %esi,%esi
mov %rsp,%rdi
lea 0x1(%r9),%rdx
mov %r9,-0x58(%rbp)
mov %rdx,-0x50(%rbp)
callq 1090 <memset@plt>
mov -0x50(%rbp),%rdx
mov -0x48(%rbp),%edi
mov %rbx,%rcx
mov -0x58(%rbp),%r9
lea (%rbx,%rdx,1),%rsi
sub %ebx,%edi
nopl (%rax)
cmpb $0x0,(%rcx)
je 142a <func0+0x18a>
lea (%rdi,%rcx,1),%eax
cltd
idiv %r15d
movslq %edx,%rdx
cmpb $0x0,(%rbx,%rdx,1)
jne 142a <func0+0x18a>
movb $0x1,(%r12,%rdx,1)
add $0x1,%rcx
cmp %rcx,%rsi
jne 1410 <func0+0x170>
xor %eax,%eax
jmp 1443 <func0+0x1a3>
nopw 0x0(%rax,%rax,1)
mov %rdx,%rax
cmpb $0x0,(%r12,%rax,1)
je 144e <func0+0x1ae>
movb $0x1,(%rbx,%rax,1)
lea 0x1(%rax),%rdx
cmp %r9,%rax
jne 1440 <func0+0x1a0>
mov -0x48(%rbp),%eax
add $0x4,%r13
cltd
idiv %r15d
movslq %edx,%rdx
movb $0x1,(%rbx,%rdx,1)
mov %r14,%rsp
cmp -0x60(%rbp),%r13
jne 1380 <func0+0xe0>
movzbl (%rbx),%eax
mov -0x38(%rbp),%rsi
xor %fs:0x28,%rsi
jne 1497 <func0+0x1f7>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| 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, [r12+0Fh]
mov rsi, rcx
mov rax, rcx
and rsi, 0FFFFFFFFFFFFF000h
and rax, 0FFFFFFFFFFFFFFF0h
sub rdx, rsi
cmp rsp, rdx
jz short loc_12FE
loc_12E9:
sub rsp, 1000h
or [rsp+1070h+var_78], 0
cmp rsp, rdx
jnz short loc_12E9
loc_12FE:
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1311
or [rsp+rax+1070h+var_1078], 0
loc_1311:
mov r14, rsp
test r15d, r15d
jle short loc_132E
mov edx, r15d; n
xor esi, esi; c
mov rdi, rsp; s
mov [rbp+var_48], rcx
call _memset
mov rcx, [rbp+var_48]
loc_132E:
test ebx, ebx
jle loc_1448
lea rax, [r13+rbx*4+0]
mov [rbp+var_50], rax
mov rax, rcx
and ecx, 0FF0h
and rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_60], rcx
mov [rbp+var_58], rax
lea rax, [rcx-8]
mov [rbp+var_68], rax
mov rax, r13
mov r13, r12
mov r12, rax
nop dword ptr [rax]
loc_1368:
cmp byte ptr [r14], 0
mov [rbp+var_48], rsp
jnz loc_1450
mov rdx, [rbp+var_58]
mov rax, rsp
and rdx, 0FFFFFFFFFFFFF000h
sub rax, rdx
cmp rsp, rax
jz short loc_13A1
loc_138C:
sub rsp, 1000h
or [rsp+2070h+var_1078], 0
cmp rsp, rax
jnz short loc_138C
loc_13A1:
mov rax, [rbp+var_60]
sub rsp, rax
test rax, rax
jz short loc_13B6
mov rax, [rbp+var_68]
or [rsp+rax+2070h+var_2070], 0
loc_13B6:
mov rbx, rsp
test r15d, r15d
jle loc_1473
xor esi, esi; c
mov rdi, rsp; s
mov edx, r15d; n
call _memset
mov r11d, [r12]
lea rsi, [r13+r14+0]
mov rcx, r14
mov edi, r11d
sub edi, r14d
nop dword ptr [rax+00000000h]
loc_13E8:
cmp byte ptr [rcx], 0
jz short loc_1402
lea eax, [rdi+rcx]
cdq
idiv r15d
movsxd rdx, edx
cmp byte ptr [r14+rdx], 0
jnz short loc_1402
mov byte ptr [rbx+rdx], 1
loc_1402:
add rcx, 1
cmp rcx, rsi
jnz short loc_13E8
xor eax, eax
nop dword ptr [rax]
loc_1410:
cmp byte ptr [rbx+rax], 0
jz short loc_141B
mov byte ptr [r14+rax], 1
loc_141B:
add rax, 1
cmp r13, rax
jnz short loc_1410
loc_1424:
mov eax, r11d
add r12, 4
cdq
idiv r15d
movsxd rdx, edx
mov byte ptr [r14+rdx], 1
mov rax, [rbp+var_50]
mov rsp, [rbp+var_48]
cmp r12, rax
jnz loc_1368
loc_1448:
movzx eax, byte ptr [r14]
jmp short loc_1455
loc_1450:
mov eax, 1
loc_1455:
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1479
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1473:
mov r11d, [r12]
jmp short loc_1424
loc_1479:
call ___stack_chk_fail | 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 int v16; // edi
long long v17; // rdx
long long v18; // rax
_QWORD v20[512]; // [rsp+0h] [rbp-2070h] BYREF
_BYTE v21[4088]; // [rsp+1000h] [rbp-1070h] BYREF
long long v22; // [rsp+2000h] [rbp-70h] BYREF
long long v23; // [rsp+2008h] [rbp-68h]
signed long long v24; // [rsp+2010h] [rbp-60h]
unsigned long long v25; // [rsp+2018h] [rbp-58h]
int *v26; // [rsp+2020h] [rbp-50h]
_BYTE *v27; // [rsp+2028h] [rbp-48h]
unsigned long long v28; // [rsp+2038h] [rbp-38h]
v28 = __readfsqword(0x28u);
if ( a2 <= a3 )
{
v3 = a3;
v5 = a3 + 15LL;
v6 = (a3 + 15) & 0xFFF0;
v7 = (long long *)((char *)&v22 - (v5 & 0xFFFFFFFFFFFFF000LL));
if ( &v22 != v7 )
{
while ( v21 != (_BYTE *)v7 )
;
}
v8 = v6 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)((char *)&v20[511] + v8) = *(_QWORD *)((char *)&v20[511] + v8);
if ( a3 > 0 )
{
v27 = (_BYTE *)v5;
memset(v21, 0, (unsigned int)a3);
v5 = (long long)v27;
}
if ( a2 <= 0 )
return v21[0];
v26 = &a1[a2];
v24 = v5 & 0xFF0;
v25 = v5 & 0xFFFFFFFFFFFFFFF0LL;
v23 = v24 - 8;
v10 = v3;
v11 = a1;
while ( 1 )
{
v27 = v21;
if ( v21[0] )
break;
v12 = &v21[-(v25 & 0xFFFFFFFFFFFFF000LL)];
if ( v21 != (_BYTE *)v12 )
{
while ( v20 != v12 )
;
}
v13 = alloca(v24);
if ( v24 )
*(_QWORD *)((char *)v20 + v23) = *(_QWORD *)((char *)v20 + v23);
if ( a3 <= 0 )
{
v14 = *v11;
}
else
{
memset(v20, 0, (unsigned int)a3);
v14 = *v11;
v15 = v21;
v16 = *v11 - (unsigned int)v21;
do
{
if ( *v15 )
{
v17 = (int)(v16 + (_DWORD)v15) % a3;
if ( !v21[v17] )
*((_BYTE *)v20 + v17) = 1;
}
++v15;
}
while ( v15 != &v21[v10] );
v18 = 0LL;
do
{
if ( *((_BYTE *)v20 + v18) )
v21[v18] = 1;
++v18;
}
while ( v10 != v18 );
}
++v11;
v21[v14 % a3] = 1;
if ( v11 == v26 )
return v21[0];
}
}
return 1LL;
} | 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
AND RAX,-0x10
SUB RDX,RSI
CMP RSP,RDX
JZ 0x001012fe
LAB_001012e9:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDX
JNZ 0x001012e9
LAB_001012fe:
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101311
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101311:
MOV R14,RSP
TEST R15D,R15D
JLE 0x0010132e
MOV EDX,R15D
XOR ESI,ESI
MOV RDI,RSP
MOV qword ptr [RBP + -0x48],RCX
CALL 0x00101090
MOV RCX,qword ptr [RBP + -0x48]
LAB_0010132e:
TEST EBX,EBX
JLE 0x00101448
LEA RAX,[R13 + RBX*0x4]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,RCX
AND ECX,0xff0
AND RAX,-0x10
MOV qword ptr [RBP + -0x60],RCX
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[RCX + -0x8]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,R13
MOV R13,R12
MOV R12,RAX
NOP dword ptr [RAX]
LAB_00101368:
CMP byte ptr [R14],0x0
MOV qword ptr [RBP + -0x48],RSP
JNZ 0x00101450
MOV RDX,qword ptr [RBP + -0x58]
MOV RAX,RSP
AND RDX,-0x1000
SUB RAX,RDX
CMP RSP,RAX
JZ 0x001013a1
LAB_0010138c:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RAX
JNZ 0x0010138c
LAB_001013a1:
MOV RAX,qword ptr [RBP + -0x60]
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001013b6
MOV RAX,qword ptr [RBP + -0x68]
OR qword ptr [RSP + RAX*0x1],0x0
LAB_001013b6:
MOV RBX,RSP
TEST R15D,R15D
JLE 0x00101473
XOR ESI,ESI
MOV RDI,RSP
MOV EDX,R15D
CALL 0x00101090
MOV R11D,dword ptr [R12]
LEA RSI,[R13 + R14*0x1]
MOV RCX,R14
MOV EDI,R11D
SUB EDI,R14D
NOP dword ptr [RAX]
LAB_001013e8:
CMP byte ptr [RCX],0x0
JZ 0x00101402
LEA EAX,[RDI + RCX*0x1]
CDQ
IDIV R15D
MOVSXD RDX,EDX
CMP byte ptr [R14 + RDX*0x1],0x0
JNZ 0x00101402
MOV byte ptr [RBX + RDX*0x1],0x1
LAB_00101402:
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001013e8
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101410:
CMP byte ptr [RBX + RAX*0x1],0x0
JZ 0x0010141b
MOV byte ptr [R14 + RAX*0x1],0x1
LAB_0010141b:
ADD RAX,0x1
CMP R13,RAX
JNZ 0x00101410
LAB_00101424:
MOV EAX,R11D
ADD R12,0x4
CDQ
IDIV R15D
MOVSXD RDX,EDX
MOV byte ptr [R14 + RDX*0x1],0x1
MOV RAX,qword ptr [RBP + -0x50]
MOV RSP,qword ptr [RBP + -0x48]
CMP R12,RAX
JNZ 0x00101368
LAB_00101448:
MOVZX EAX,byte ptr [R14]
JMP 0x00101455
LAB_00101450:
MOV EAX,0x1
LAB_00101455:
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101479
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101473:
MOV R11D,dword ptr [R12]
JMP 0x00101424
LAB_00101479:
CALL 0x00101070 | 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 *local_58;
int *local_50;
long local_40;
int *puVar9;
puVar8 = auStack_78;
puVar9 = auStack_78;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
puVar10 = auStack_78;
if ((int)param_3 < param_2) {
LAB_00101450:
uVar3 = 1;
}
else {
lVar12 = (long)(int)param_3;
puVar5 = (int *)(lVar12 + 0xf);
puVar10 = auStack_78;
while (puVar9 != auStack_78 + -((ulong)puVar5 & 0xfffffffffffff000)) {
puVar8 = puVar10 + -0x1000;
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
puVar9 = puVar10 + -0x1000;
puVar10 = puVar10 + -0x1000;
}
uVar4 = (ulong)((uint)puVar5 & 0xff0);
lVar1 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if (0 < (int)param_3) {
*(int8 *)(puVar8 + lVar1 + -8) = 0x10132a;
local_50 = puVar5;
memset(puVar8 + lVar1,0,(ulong)param_3);
puVar5 = local_50;
}
puVar10 = puVar8 + lVar1;
if (0 < param_2) {
local_58 = param_1 + param_2;
local_68 = (ulong)((uint)puVar5 & 0xff0);
local_60 = (ulong)puVar5 & 0xfffffffffffffff0;
local_70 = local_68 - 8;
local_50 = puVar8 + lVar1;
do {
puVar10 = local_50;
if (puVar8[lVar1] != '\0') goto LAB_00101450;
for (; puVar10 != local_50 + -(local_60 & 0xfffffffffffff000); puVar10 = puVar10 + -0x1000)
{
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
lVar2 = -local_68;
if (local_68 != 0) {
*(int8 *)(puVar10 + local_70 + lVar2) = *(int8 *)(puVar10 + local_70 + lVar2);
}
if ((int)param_3 < 1) {
iVar11 = *param_1;
}
else {
*(int8 *)(puVar10 + lVar2 + -8) = 0x1013cf;
memset(puVar10 + lVar2,0,(ulong)param_3);
iVar11 = *param_1;
pcVar6 = puVar8 + lVar1;
do {
if ((*pcVar6 != '\0') &&
(lVar7 = (long)(((iVar11 - ((int)puVar8 + (int)lVar1)) + (int)pcVar6) % (int)param_3)
, puVar8[lVar7 + lVar1] == '\0')) {
puVar10[lVar7 + lVar2] = 1;
}
pcVar6 = pcVar6 + 1;
} while (pcVar6 != puVar8 + lVar12 + lVar1);
lVar7 = 0;
do {
if (puVar10[lVar7 + lVar2] != '\0') {
puVar8[lVar7 + lVar1] = 1;
}
lVar7 = lVar7 + 1;
} while (lVar12 != lVar7);
}
param_1 = param_1 + 1;
puVar8[iVar11 % (int)param_3 + lVar1] = 1;
puVar10 = local_50;
} while (param_1 != local_58);
}
uVar3 = puVar8[lVar1];
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar10 + -8) = 0x10147e;
__stack_chk_fail();
}
return uVar3;
} |
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));
while (placement <= max_digit) {
for (int i = 0; i < RADIX; i++) {
count[i] = 0;
}
for (int i = 0; i < size; i++) {
int index = (nums[i] / placement) % RADIX;
count[index]++;
}
for (int i = 1; i < RADIX; i++) {
count[i] += count[i - 1];
}
for (int i = size - 1; i >= 0; i--) {
int index = (nums[i] / placement) % RADIX;
output[count[index] - 1] = nums[i];
count[index]--;
}
for (int i = 0; i < size; i++) {
nums[i] = output[i];
}
placement *= RADIX;
}
free(output);
free(count);
}
| 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 = sizeof(nums2) / sizeof(nums2[0]);
func0(nums2, size2);
int sorted2[] = {2, 3, 7, 8, 9, 11};
for (int i = 0; i < size2; i++) {
assert(nums2[i] == sorted2[i]);
}
int nums3[] = {36, 12, 24, 26, 29};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
func0(nums3, size3);
int sorted3[] = {12, 24, 26, 29, 36};
for (int i = 0; i < size3; i++) {
assert(nums3[i] == sorted3[i]);
}
return 0;
}
| 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(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x34(%rbp)
jge 1209 <func0+0x60>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x34(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 11d5 <func0+0x2c>
mov -0x4c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x10(%rbp)
mov $0x28,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
jmpq 1456 <func0+0x2ad>
movl $0x0,-0x2c(%rbp)
jmp 1264 <func0+0xbb>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movl $0x0,(%rax)
addl $0x1,-0x2c(%rbp)
cmpl $0x9,-0x2c(%rbp)
jle 1246 <func0+0x9d>
movl $0x0,-0x28(%rbp)
jmp 12e0 <func0+0x137>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
idivl -0x38(%rbp)
mov %eax,%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1273 <func0+0xca>
movl $0x1,-0x24(%rbp)
jmp 1339 <func0+0x190>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x8(%rbp),%rax
add %rsi,%rax
add %ecx,%edx
mov %edx,(%rax)
addl $0x1,-0x24(%rbp)
cmpl $0x9,-0x24(%rbp)
jle 12f1 <func0+0x148>
mov -0x4c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x20(%rbp)
jmpq 13fb <func0+0x252>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
idivl -0x38(%rbp)
mov %eax,%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
mov %eax,-0x18(%rbp)
mov -0x18(%rbp),%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x18(%rbp)
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea -0x4(%rdx),%rcx
mov -0x10(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
sub $0x1,%edx
mov %edx,(%rax)
subl $0x1,-0x20(%rbp)
cmpl $0x0,-0x20(%rbp)
jns 134d <func0+0x1a4>
movl $0x0,-0x1c(%rbp)
jmp 143f <func0+0x296>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 140e <func0+0x265>
mov -0x38(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x34(%rbp),%eax
jle 123d <func0+0x94>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
leaveq
retq
| 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]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_34], eax
jge short loc_1209
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
mov [rbp+var_34], eax
loc_1209:
add [rbp+var_30], 1
loc_120D:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_4C]
jl short loc_11D5
mov eax, [rbp+var_4C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov edi, 28h ; '('; size
call _malloc
mov [rbp+var_8], rax
jmp loc_144A
loc_123D:
mov [rbp+var_2C], 0
jmp short loc_1264
loc_1246:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov dword ptr [rax], 0
add [rbp+var_2C], 1
loc_1264:
cmp [rbp+var_2C], 9
jle short loc_1246
mov [rbp+var_28], 0
jmp short loc_12DA
loc_1273:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
cdq
idiv [rbp+var_38]
mov edx, eax
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
sar eax, 2
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_14], edx
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rax]
add edx, 1
mov [rax], edx
add [rbp+var_28], 1
loc_12DA:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_4C]
jl short loc_1273
mov [rbp+var_24], 1
jmp short loc_1333
loc_12EB:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov ecx, [rax]
mov eax, [rbp+var_24]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_24]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rsi
add edx, ecx
mov [rax], edx
add [rbp+var_24], 1
loc_1333:
cmp [rbp+var_24], 9
jle short loc_12EB
mov eax, [rbp+var_4C]
sub eax, 1
mov [rbp+var_20], eax
jmp loc_13EF
loc_1347:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
cdq
idiv [rbp+var_38]
mov edx, eax
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
sar eax, 2
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
mov [rbp+var_18], eax
mov ecx, [rbp+var_18]
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_18], edx
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rbp+var_18]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov edx, [rdx]
movsxd rdx, edx
shl rdx, 2
lea rcx, [rdx-4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rax]
sub edx, 1
mov [rax], edx
sub [rbp+var_20], 1
loc_13EF:
cmp [rbp+var_20], 0
jns loc_1347
mov [rbp+var_1C], 0
jmp short loc_1433
loc_1402:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_48]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_1C], 1
loc_1433:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_4C]
jl short loc_1402
mov edx, [rbp+var_38]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov [rbp+var_38], eax
loc_144A:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jle loc_123D
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
mov rdi, rax; ptr
call _free
nop
leave
retn | 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-18h]
int v11; // [rsp+3Ch] [rbp-14h]
_DWORD *ptr; // [rsp+40h] [rbp-10h]
_DWORD *v13; // [rsp+48h] [rbp-8h]
v2 = 1;
v3 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v3 < a1[i] )
v3 = a1[i];
}
ptr = malloc(4LL * a2);
v13 = malloc(0x28uLL);
while ( v2 <= v3 )
{
for ( j = 0; j <= 9; ++j )
v13[j] = 0;
for ( k = 0; k < a2; ++k )
{
v11 = a1[k] / v2 % 10;
++v13[v11];
}
for ( m = 1; m <= 9; ++m )
v13[m] += v13[m - 1];
for ( n = a2 - 1; n >= 0; --n )
{
v10 = a1[n] / v2 % 10;
ptr[--v13[v10]] = a1[n];
}
for ( ii = 0; ii < a2; ++ii )
a1[ii] = ptr[ii];
v2 *= 10;
}
free(ptr);
free(v13);
} | 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 + -0x30]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x34],EAX
JGE 0x00101209
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
LAB_00101209:
ADD dword ptr [RBP + -0x30],0x1
LAB_0010120d:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x001011d5
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV EDI,0x28
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0010144a
LAB_0010123d:
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101264
LAB_00101246:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV dword ptr [RAX],0x0
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101264:
CMP dword ptr [RBP + -0x2c],0x9
JLE 0x00101246
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001012da
LAB_00101273:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQ
IDIV dword ptr [RBP + -0x38]
MOV EDX,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
SAR EAX,0x2
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x14],EDX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
ADD EDX,0x1
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x28],0x1
LAB_001012da:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x00101273
MOV dword ptr [RBP + -0x24],0x1
JMP 0x00101333
LAB_001012eb:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RSI
ADD EDX,ECX
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x24],0x1
LAB_00101333:
CMP dword ptr [RBP + -0x24],0x9
JLE 0x001012eb
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001013ef
LAB_00101347:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQ
IDIV dword ptr [RBP + -0x38]
MOV EDX,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
SAR EAX,0x2
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
MOV dword ptr [RBP + -0x18],EAX
MOV ECX,dword ptr [RBP + -0x18]
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x18],EDX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EDX,dword ptr [RDX]
MOVSXD RDX,EDX
SHL RDX,0x2
LEA RCX,[RDX + -0x4]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
SUB EDX,0x1
MOV dword ptr [RAX],EDX
SUB dword ptr [RBP + -0x20],0x1
LAB_001013ef:
CMP dword ptr [RBP + -0x20],0x0
JNS 0x00101347
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101433
LAB_00101402:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101433:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x00101402
MOV EDX,dword ptr [RBP + -0x38]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV dword ptr [RBP + -0x38],EAX
LAB_0010144a:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x0010123d
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101080
NOP
LEAVE
RET | 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 = local_38 + 1) {
if (local_3c < param_1[local_38]) {
local_3c = param_1[local_38];
}
}
__ptr = malloc((long)param_2 << 2);
__ptr_00 = malloc(0x28);
for (; local_40 <= local_3c; local_40 = local_40 * 10) {
for (local_34 = 0; local_34 < 10; local_34 = local_34 + 1) {
*(int4 *)((long)__ptr_00 + (long)local_34 * 4) = 0;
}
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
piVar1 = (int *)((long)__ptr_00 + (long)((param_1[local_30] / local_40) % 10) * 4);
*piVar1 = *piVar1 + 1;
}
for (local_2c = 1; local_2c < 10; local_2c = local_2c + 1) {
*(int *)((long)__ptr_00 + (long)local_2c * 4) =
*(int *)((long)__ptr_00 + (long)local_2c * 4 + -4) +
*(int *)((long)__ptr_00 + (long)local_2c * 4);
}
for (local_28 = param_2 + -1; -1 < local_28; local_28 = local_28 + -1) {
iVar2 = (param_1[local_28] / local_40) % 10;
*(int *)((long)__ptr + (long)*(int *)((long)__ptr_00 + (long)iVar2 * 4) * 4 + -4) =
param_1[local_28];
piVar1 = (int *)((long)__ptr_00 + (long)iVar2 * 4);
*piVar1 = *piVar1 + -1;
}
for (local_24 = 0; local_24 < param_2; local_24 = local_24 + 1) {
param_1[local_24] = *(int *)((long)__ptr + (long)local_24 * 4);
}
}
free(__ptr);
free(__ptr_00);
return;
} |
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));
while (placement <= max_digit) {
for (int i = 0; i < RADIX; i++) {
count[i] = 0;
}
for (int i = 0; i < size; i++) {
int index = (nums[i] / placement) % RADIX;
count[index]++;
}
for (int i = 1; i < RADIX; i++) {
count[i] += count[i - 1];
}
for (int i = size - 1; i >= 0; i--) {
int index = (nums[i] / placement) % RADIX;
output[count[index] - 1] = nums[i];
count[index]--;
}
for (int i = 0; i < size; i++) {
nums[i] = output[i];
}
placement *= RADIX;
}
free(output);
free(count);
}
| 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 = sizeof(nums2) / sizeof(nums2[0]);
func0(nums2, size2);
int sorted2[] = {2, 3, 7, 8, 9, 11};
for (int i = 0; i < size2; i++) {
assert(nums2[i] == sorted2[i]);
}
int nums3[] = {36, 12, 24, 26, 29};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
func0(nums3, size3);
int sorted3[] = {12, 24, 26, 29, 36};
for (int i = 0; i < size3; i++) {
assert(nums3[i] == sorted3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %esi,%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 %edx,%r13d
add $0x4,%rax
cmp %rcx,%rax
jne 11d5 <func0+0x2c>
movslq %r14d,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r12
mov $0x28,%edi
callq 10b0 <malloc@plt>
mov %rax,%rbx
test %r13d,%r13d
jle 130b <func0+0x162>
lea -0x1(%r14),%r9d
mov %rbp,0x8(%rsp)
lea 0x4(%rbp,%r9,4),%r10
mov $0x1,%ecx
lea 0x28(%rax),%r8
lea -0x1(%r14),%r11d
jmp 124d <func0+0xa4>
mov (%r12,%rax,4),%edx
mov %edx,0x0(%rbp,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %r9,%rdx
jne 1229 <func0+0x80>
lea (%rcx,%rcx,4),%eax
add %eax,%eax
mov %eax,%ecx
cmp %r13d,%eax
jg 130b <func0+0x162>
mov %rbx,%rax
movl $0x0,(%rax)
add $0x4,%rax
cmp %r8,%rax
jne 1250 <func0+0xa7>
test %r14d,%r14d
jle 1299 <func0+0xf0>
mov 0x8(%rsp),%rsi
mov (%rsi),%eax
cltd
idiv %ecx
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %eax,%edi
sar $0x1f,%edi
sub %edi,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
cltq
addl $0x1,(%rbx,%rax,4)
add $0x4,%rsi
cmp %r10,%rsi
jne 1269 <func0+0xc0>
lea 0x4(%rbx),%rax
mov -0x4(%rax),%edx
add %edx,(%rax)
add $0x4,%rax
cmp %r8,%rax
jne 129d <func0+0xf4>
test %r11d,%r11d
js 12f8 <func0+0x14f>
movslq %r11d,%rsi
mov 0x0(%rbp,%rsi,4),%edi
mov %edi,%eax
cltd
idiv %ecx
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %eax,%r15d
sar $0x1f,%r15d
sub %r15d,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
cltq
lea (%rbx,%rax,4),%rdx
mov (%rdx),%eax
movslq %eax,%r15
mov %edi,-0x4(%r12,%r15,4)
sub $0x1,%eax
mov %eax,(%rdx)
sub $0x1,%rsi
test %esi,%esi
jns 12b3 <func0+0x10a>
test %r14d,%r14d
jle 123d <func0+0x94>
mov $0x0,%eax
jmpq 1229 <func0+0x80>
mov %r12,%rdi
callq 1080 <free@plt>
mov %rbx,%rdi
callq 1080 <free@plt>
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov 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 r13d, edx
add rax, 4
cmp rax, rcx
jnz short loc_11D5
loc_11E7:
movsxd rdi, r14d
shl rdi, 2
call _malloc
mov r12, rax
mov edi, 28h ; '('
call _malloc
mov rbx, rax
test r13d, r13d
jle loc_12FE
lea r8d, [r14-1]
lea r9, [rbp+r8*4+4]
mov ecx, 1
lea rdi, [rax+28h]
lea r10d, [r14-1]
loc_1222:
mov rax, rbx
loc_1225:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdi
jnz short loc_1225
test r14d, r14d
jle short loc_126F
mov rsi, rbp
loc_123C:
mov eax, [rsi]
cdq
idiv ecx
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
mov r11d, eax
sar r11d, 1Fh
sub edx, r11d
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
cdqe
add dword ptr [rbx+rax*4], 1
add rsi, 4
cmp rsi, r9
jnz short loc_123C
loc_126F:
lea rax, [rbx+4]
loc_1273:
mov edx, [rax-4]
add [rax], edx
add rax, 4
cmp rax, rdi
jnz short loc_1273
test r10d, r10d
js short loc_12D0
movsxd rsi, r10d
loc_1289:
mov r11d, [rbp+rsi*4+0]
mov eax, r11d
cdq
idiv ecx
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
mov r15d, eax
sar r15d, 1Fh
sub edx, r15d
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
cdqe
lea rdx, [rbx+rax*4]
mov eax, [rdx]
movsxd r15, eax
mov [r12+r15*4-4], r11d
sub eax, 1
mov [rdx], eax
sub rsi, 1
test esi, esi
jns short loc_1289
loc_12D0:
test r14d, r14d
jle short loc_12EE
mov eax, 0
loc_12DA:
mov edx, [r12+rax*4]
mov [rbp+rax*4+0], edx
mov rdx, rax
add rax, 1
cmp rdx, r8
jnz short loc_12DA
loc_12EE:
lea eax, [rcx+rcx*4]
add eax, eax
mov ecx, eax
cmp eax, r13d
jle loc_1222
loc_12FE:
mov rdi, r12
call _free
mov rdi, rbx
call _free
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | 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 *v15; // rax
int v16; // eax
unsigned long long v17; // rax
int v18; // eax
long long v19; // rdx
long long v20; // rcx
v3 = (int)a2;
v4 = *a1;
if ( (int)a2 > 1 )
{
v5 = a1 + 1;
do
{
if ( v4 < *v5 )
v4 = *v5;
++v5;
}
while ( v5 != &a1[(_DWORD)a2 - 2 + 2] );
}
v6 = malloc(4LL * (int)a2);
v7 = malloc(40LL);
v10 = (_DWORD *)v7;
if ( v4 > 0 )
{
v11 = (unsigned int)((_DWORD)a2 - 1);
LODWORD(v9) = 1;
v12 = (_DWORD *)(v7 + 40);
v13 = (_DWORD)a2 - 1;
do
{
v14 = v10;
do
*v14++ = 0;
while ( v14 != v12 );
if ( v3 > 0 )
{
a2 = a1;
do
++v10[*a2++ / (int)v9 % 10];
while ( a2 != &a1[v11 + 1] );
}
v15 = v10 + 1;
do
{
v8 = (unsigned int)*(v15 - 1);
*v15++ += v8;
}
while ( v15 != v12 );
if ( v13 >= 0 )
{
a2 = (int *)v13;
do
{
v8 = (unsigned long long)&v10[a1[(_QWORD)a2] / (int)v9 % 10];
v16 = *(_DWORD *)v8;
*(_DWORD *)(v6 + 4LL * *(int *)v8 - 4) = a1[(_QWORD)a2];
*(_DWORD *)v8 = v16 - 1;
a2 = (int *)((char *)a2 - 1);
}
while ( (int)a2 >= 0 );
}
if ( v3 > 0 )
{
v17 = 0LL;
do
{
a1[v17] = *(_DWORD *)(v6 + 4 * v17);
v8 = v17++;
}
while ( v8 != v11 );
}
v18 = 10 * v9;
v9 = (unsigned int)(10 * v9);
}
while ( v18 <= v4 );
}
free(v6, a2, v8, v9);
return free(v10, a2, v19, v20);
} | 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
JNZ 0x001011d5
LAB_001011e7:
MOVSXD RDI,R14D
SHL RDI,0x2
CALL 0x001010b0
MOV R12,RAX
MOV EDI,0x28
CALL 0x001010b0
MOV RBX,RAX
TEST R13D,R13D
JLE 0x001012fe
LEA R8D,[R14 + -0x1]
LEA R9,[RBP + R8*0x4 + 0x4]
MOV ECX,0x1
LEA RDI,[RAX + 0x28]
LEA R10D,[R14 + -0x1]
LAB_00101222:
MOV RAX,RBX
LAB_00101225:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101225
TEST R14D,R14D
JLE 0x0010126f
MOV RSI,RBP
LAB_0010123c:
MOV EAX,dword ptr [RSI]
CDQ
IDIV ECX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV R11D,EAX
SAR R11D,0x1f
SUB EDX,R11D
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
CDQE
ADD dword ptr [RBX + RAX*0x4],0x1
ADD RSI,0x4
CMP RSI,R9
JNZ 0x0010123c
LAB_0010126f:
LEA RAX,[RBX + 0x4]
LAB_00101273:
MOV EDX,dword ptr [RAX + -0x4]
ADD dword ptr [RAX],EDX
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101273
TEST R10D,R10D
JS 0x001012d0
MOVSXD RSI,R10D
LAB_00101289:
MOV R11D,dword ptr [RBP + RSI*0x4]
MOV EAX,R11D
CDQ
IDIV ECX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV R15D,EAX
SAR R15D,0x1f
SUB EDX,R15D
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
CDQE
LEA RDX,[RBX + RAX*0x4]
MOV EAX,dword ptr [RDX]
MOVSXD R15,EAX
MOV dword ptr [R12 + R15*0x4 + -0x4],R11D
SUB EAX,0x1
MOV dword ptr [RDX],EAX
SUB RSI,0x1
TEST ESI,ESI
JNS 0x00101289
LAB_001012d0:
TEST R14D,R14D
JLE 0x001012ee
MOV EAX,0x0
LAB_001012da:
MOV EDX,dword ptr [R12 + RAX*0x4]
MOV dword ptr [RBP + RAX*0x4],EDX
MOV RDX,RAX
ADD RAX,0x1
CMP RDX,R8
JNZ 0x001012da
LAB_001012ee:
LEA EAX,[RCX + RCX*0x4]
ADD EAX,EAX
MOV ECX,EAX
CMP EAX,R13D
JLE 0x00101222
LAB_001012fe:
MOV RDI,R12
CALL 0x00101080
MOV RDI,RBX
CALL 0x00101080
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | 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;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 2) + 2);
}
__ptr = malloc((long)param_2 << 2);
piVar3 = (int *)malloc(0x28);
if (0 < iVar8) {
iVar6 = 1;
piVar4 = piVar3;
do {
do {
*piVar4 = 0;
piVar4 = piVar4 + 1;
} while (piVar4 != piVar3 + 10);
piVar4 = param_1;
if (0 < param_2) {
do {
piVar3[(*piVar4 / iVar6) % 10] = piVar3[(*piVar4 / iVar6) % 10] + 1;
piVar4 = piVar4 + 1;
} while (piVar4 != param_1 + (ulong)(param_2 - 1) + 1);
}
piVar4 = piVar3 + 1;
do {
*piVar4 = *piVar4 + piVar4[-1];
piVar4 = piVar4 + 1;
} while (piVar4 != piVar3 + 10);
if (-1 < param_2 + -1) {
lVar7 = (long)(param_2 + -1);
do {
iVar1 = param_1[lVar7];
iVar2 = piVar3[(iVar1 / iVar6) % 10];
*(int *)((long)__ptr + (long)iVar2 * 4 + -4) = iVar1;
piVar3[(iVar1 / iVar6) % 10] = iVar2 + -1;
lVar7 = lVar7 + -1;
} while (-1 < (int)lVar7);
}
if (0 < param_2) {
uVar5 = 0;
do {
param_1[uVar5] = *(int *)((long)__ptr + uVar5 * 4);
bVar9 = uVar5 != param_2 - 1;
uVar5 = uVar5 + 1;
} while (bVar9);
}
iVar6 = iVar6 * 10;
piVar4 = piVar3;
} while (iVar6 <= iVar8);
}
free(__ptr);
free(piVar3);
return;
} |
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));
while (placement <= max_digit) {
for (int i = 0; i < RADIX; i++) {
count[i] = 0;
}
for (int i = 0; i < size; i++) {
int index = (nums[i] / placement) % RADIX;
count[index]++;
}
for (int i = 1; i < RADIX; i++) {
count[i] += count[i - 1];
}
for (int i = size - 1; i >= 0; i--) {
int index = (nums[i] / placement) % RADIX;
output[count[index] - 1] = nums[i];
count[index]--;
}
for (int i = 0; i < size; i++) {
nums[i] = output[i];
}
placement *= RADIX;
}
free(output);
free(count);
}
| 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 = sizeof(nums2) / sizeof(nums2[0]);
func0(nums2, size2);
int sorted2[] = {2, 3, 7, 8, 9, 11};
for (int i = 0; i < size2; i++) {
assert(nums2[i] == sorted2[i]);
}
int nums3[] = {36, 12, 24, 26, 29};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
func0(nums3, size3);
int sorted3[] = {12, 24, 26, 29, 36};
for (int i = 0; i < size3; i++) {
assert(nums3[i] == sorted3[i]);
}
return 0;
}
| 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 %edx,%r13d
cmovl %edx,%r13d
add $0x4,%rax
cmp %rax,%rcx
jne 1410 <func0+0x30>
movslq %r14d,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov $0x28,%edi
mov %rax,%r12
callq 10b0 <malloc@plt>
mov %rax,%rbp
test %r13d,%r13d
jle 1561 <func0+0x181>
lea 0x28(%rax),%r9
lea 0x4(%rax),%rax
mov $0x1,%ecx
mov %rax,0x8(%rsp)
lea -0x1(%r14),%r10d
mov %r10,%rsi
lea 0x4(%rbx,%r10,4),%r11
nopl (%rax)
mov %rbp,%rax
nopl 0x0(%rax,%rax,1)
movl $0x0,(%rax)
add $0x4,%rax
cmp %rax,%r9
jne 1470 <func0+0x90>
mov %rbx,%rdi
test %r14d,%r14d
jle 14c4 <func0+0xe4>
nopw 0x0(%rax,%rax,1)
mov (%rdi),%eax
add $0x4,%rdi
cltd
idiv %ecx
movslq %eax,%rdx
mov %eax,%r8d
imul $0x66666667,%rdx,%rdx
sar $0x1f,%r8d
sar $0x22,%rdx
sub %r8d,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
cltq
addl $0x1,0x0(%rbp,%rax,4)
cmp %rdi,%r11
jne 1490 <func0+0xb0>
mov 0x8(%rsp),%rax
nopl 0x0(%rax)
mov -0x4(%rax),%edx
add %edx,(%rax)
add $0x4,%rax
cmp %rax,%r9
jne 14d0 <func0+0xf0>
movslq %esi,%rdi
test %esi,%esi
js 1530 <func0+0x150>
nopl (%rax)
mov (%rbx,%rdi,4),%r8d
sub $0x1,%rdi
mov %r8d,%eax
cltd
idiv %ecx
movslq %eax,%rdx
mov %eax,%r15d
imul $0x66666667,%rdx,%rdx
sar $0x1f,%r15d
sar $0x22,%rdx
sub %r15d,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
cltq
lea 0x0(%rbp,%rax,4),%rdx
movslq (%rdx),%r15
mov %r15,%rax
mov %r8d,-0x4(%r12,%r15,4)
sub $0x1,%eax
mov %eax,(%rdx)
test %edi,%edi
jns 14e8 <func0+0x108>
xor %eax,%eax
test %r14d,%r14d
jle 1553 <func0+0x173>
nopw 0x0(%rax,%rax,1)
mov (%r12,%rax,4),%edx
mov %edx,(%rbx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%r10
jne 1540 <func0+0x160>
lea (%rcx,%rcx,4),%ecx
add %ecx,%ecx
cmp %r13d,%ecx
jle 1468 <func0+0x88>
mov %r12,%rdi
callq 1080 <free@plt>
add $0x18,%rsp
mov %rbp,%rdi
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
jmpq 1080 <free@plt>
| 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]
cmp r8d, edx
cmovl r8d, edx
add rax, 4
cmp rcx, rax
jnz short loc_1420
loc_1432:
movsxd rdi, r9d
mov dword ptr [rsp+58h+var_50], r8d
shl rdi, 2
mov [rsp+58h+var_48], r9d
call _malloc
mov edi, 28h ; '('
mov r13, rax
call _malloc
mov r8d, dword ptr [rsp+58h+var_50]
mov r9d, [rsp+58h+var_48]
mov rbp, rax
test r8d, r8d
jle loc_15A7
lea eax, [r9-1]
mov [rsp+58h+var_44], r8d
lea r14, [rbp+28h]
mov rdi, r12
lea r15, [r12+rax*4+4]
mov r10, rax
mov r12, r13
mov ebx, 1
lea rax, ds:4[rax*4]
mov r13, r15
mov r15, r14
mov r14d, r10d
mov [rsp+58h+var_40], rax
lea rax, [rbp+4]
mov [rsp+58h+var_50], rax
nop word ptr [rax+rax+00h]
loc_14B0:
pxor xmm0, xmm0
mov qword ptr [rbp+20h], 0
mov rcx, rdi
movups xmmword ptr [rbp+0], xmm0
movups xmmword ptr [rbp+10h], xmm0
test r9d, r9d
jle short loc_1501
nop dword ptr [rax+00h]
loc_14D0:
mov eax, [rcx]
add rcx, 4
cdq
idiv ebx
movsxd rdx, eax
mov esi, eax
imul rdx, 66666667h
sar esi, 1Fh
sar rdx, 22h
sub edx, esi
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
cdqe
add dword ptr [rbp+rax*4+0], 1
cmp rcx, r13
jnz short loc_14D0
loc_1501:
mov rax, [rsp+58h+var_50]
nop word ptr [rax+rax+00000000h]
loc_1510:
mov edx, [rax-4]
add [rax], edx
add rax, 4
cmp rax, r15
jnz short loc_1510
movsxd rcx, r14d
test r14d, r14d
js short loc_1576
nop word ptr [rax+rax+00000000h]
loc_1530:
mov esi, [rdi+rcx*4]
sub rcx, 1
mov eax, esi
cdq
idiv ebx
movsxd rdx, eax
mov r8d, eax
imul rdx, 66666667h
sar r8d, 1Fh
sar rdx, 22h
sub edx, r8d
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
cdqe
lea rdx, [rbp+rax*4+0]
movsxd r8, dword ptr [rdx]
mov rax, r8
mov [r12+r8*4-4], esi
sub eax, 1
mov [rdx], eax
test ecx, ecx
jns short loc_1530
loc_1576:
test r9d, r9d
jle short loc_1595
mov rdx, [rsp+58h+var_40]
mov rsi, r12
mov [rsp+58h+var_48], r9d
call _memcpy
mov r9d, [rsp+58h+var_48]
mov rdi, rax
loc_1595:
lea ebx, [rbx+rbx*4]
add ebx, ebx
cmp ebx, [rsp+58h+var_44]
jle loc_14B0
mov r13, r12
loc_15A7:
mov rdi, r13
call _free
add rsp, 28h
mov rdi, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
jmp _free | 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 v14; // r14d
int *v15; // rcx
int v16; // eax
int v17; // eax
_DWORD *v18; // rax
int v19; // eax
long long v20; // rax
long long v21; // rdx
long long v22; // rcx
long long v23; // r8
long long v24; // r9
int v26; // [rsp+8h] [rbp-50h]
unsigned int v27; // [rsp+10h] [rbp-48h]
long long v28; // [rsp+18h] [rbp-40h]
v2 = *a1;
if ( (int)a2 > 1 )
{
v3 = a1 + 1;
do
{
if ( v2 < *v3 )
v2 = *v3;
++v3;
}
while ( &a1[(unsigned int)(a2 - 2) + 2] != v3 );
}
v26 = v2;
v4 = malloc(4LL * (int)a2);
v5 = malloc(40LL);
v8 = (unsigned int)v26;
v9 = (unsigned int)a2;
v10 = v5;
if ( v26 > 0 )
{
v11 = (unsigned int)(a2 - 1);
v12 = (long long)&a1[v11 + 1];
v13 = 1;
v14 = a2 - 1;
v28 = 4 * v11 + 4;
do
{
*(_QWORD *)(v10 + 32) = 0LL;
v15 = a1;
*(_OWORD *)v10 = 0LL;
*(_OWORD *)(v10 + 16) = 0LL;
if ( (int)v9 > 0 )
{
do
{
v16 = *v15++;
v17 = v16 / v13;
a2 = (unsigned int)(v17 >> 31);
++*(_DWORD *)(v10 + 4LL * (v17 % 10));
}
while ( v15 != (int *)v12 );
}
v18 = (_DWORD *)(v10 + 4);
do
{
v6 = (unsigned int)*(v18 - 1);
*v18++ += v6;
}
while ( v18 != (_DWORD *)(v10 + 40) );
v7 = v14;
if ( v14 >= 0 )
{
do
{
a2 = (unsigned int)a1[v7--];
v6 = v10 + 4LL * ((int)a2 / v13 % 10);
v8 = *(int *)v6;
v19 = *(_DWORD *)v6;
*(_DWORD *)(v4 + 4 * v8 - 4) = a2;
*(_DWORD *)v6 = v19 - 1;
}
while ( (int)v7 >= 0 );
}
if ( (int)v9 > 0 )
{
a2 = v4;
v27 = v9;
v20 = memcpy(a1, v4, v28, v7);
v9 = v27;
a1 = (int *)v20;
}
v13 *= 10;
}
while ( v13 <= v26 );
}
free(v4, a2, v6, v7, v8, v9);
return free(v10, a2, v21, v22, v23, v24);
} | 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,0x4
CMP RCX,RAX
JNZ 0x00101420
LAB_00101432:
MOVSXD RDI,R9D
MOV dword ptr [RSP + 0x8],R8D
SHL RDI,0x2
MOV dword ptr [RSP + 0x10],R9D
CALL 0x001010d0
MOV EDI,0x28
MOV R13,RAX
CALL 0x001010d0
MOV R8D,dword ptr [RSP + 0x8]
MOV R9D,dword ptr [RSP + 0x10]
MOV RBP,RAX
TEST R8D,R8D
JLE 0x001015a7
LEA EAX,[R9 + -0x1]
MOV dword ptr [RSP + 0x14],R8D
LEA R14,[RBP + 0x28]
MOV RDI,R12
LEA R15,[R12 + RAX*0x4 + 0x4]
MOV R10,RAX
MOV R12,R13
MOV EBX,0x1
LEA RAX,[0x4 + RAX*0x4]
MOV R13,R15
MOV R15,R14
MOV R14D,R10D
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[RBP + 0x4]
MOV qword ptr [RSP + 0x8],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_001014b0:
PXOR XMM0,XMM0
MOV qword ptr [RBP + 0x20],0x0
MOV RCX,RDI
MOVUPS xmmword ptr [RBP],XMM0
MOVUPS xmmword ptr [RBP + 0x10],XMM0
TEST R9D,R9D
JLE 0x00101501
NOP dword ptr [RAX]
LAB_001014d0:
MOV EAX,dword ptr [RCX]
ADD RCX,0x4
CDQ
IDIV EBX
MOVSXD RDX,EAX
MOV ESI,EAX
IMUL RDX,RDX,0x66666667
SAR ESI,0x1f
SAR RDX,0x22
SUB EDX,ESI
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
CDQE
ADD dword ptr [RBP + RAX*0x4],0x1
CMP RCX,R13
JNZ 0x001014d0
LAB_00101501:
MOV RAX,qword ptr [RSP + 0x8]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101510:
MOV EDX,dword ptr [RAX + -0x4]
ADD dword ptr [RAX],EDX
ADD RAX,0x4
CMP RAX,R15
JNZ 0x00101510
MOVSXD RCX,R14D
TEST R14D,R14D
JS 0x00101576
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101530:
MOV ESI,dword ptr [RDI + RCX*0x4]
SUB RCX,0x1
MOV EAX,ESI
CDQ
IDIV EBX
MOVSXD RDX,EAX
MOV R8D,EAX
IMUL RDX,RDX,0x66666667
SAR R8D,0x1f
SAR RDX,0x22
SUB EDX,R8D
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
CDQE
LEA RDX,[RBP + RAX*0x4]
MOVSXD R8,dword ptr [RDX]
MOV RAX,R8
MOV dword ptr [R12 + R8*0x4 + -0x4],ESI
SUB EAX,0x1
MOV dword ptr [RDX],EAX
TEST ECX,ECX
JNS 0x00101530
LAB_00101576:
TEST R9D,R9D
JLE 0x00101595
MOV RDX,qword ptr [RSP + 0x18]
MOV RSI,R12
MOV dword ptr [RSP + 0x10],R9D
CALL 0x001010c0
MOV R9D,dword ptr [RSP + 0x10]
MOV RDI,RAX
LAB_00101595:
LEA EBX,[RBX + RBX*0x4]
ADD EBX,EBX
CMP EBX,dword ptr [RSP + 0x14]
JLE 0x001014b0
MOV R13,R12
LAB_001015a7:
MOV RDI,R13
CALL 0x00101090
ADD RSP,0x28
MOV RDI,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
JMP 0x00101090 | 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 < *piVar4) {
iVar10 = *piVar4;
}
piVar4 = piVar4 + 1;
} while (param_1 + (ulong)(param_2 - 2) + 2 != piVar4);
}
__src = malloc((long)param_2 << 2);
__ptr = (int1 (*) [16])malloc(0x28);
if (0 < iVar10) {
uVar1 = param_2 - 1;
piVar4 = param_1 + (ulong)uVar1 + 1;
iVar9 = 1;
do {
*(int8 *)__ptr[2] = 0;
*__ptr = (int1 [16])0x0;
__ptr[1] = (int1 [16])0x0;
piVar5 = (int *)(*__ptr + 4);
piVar7 = param_1;
if (0 < param_2) {
do {
iVar2 = *piVar7;
piVar7 = piVar7 + 1;
*(int *)(*__ptr + (long)((iVar2 / iVar9) % 10) * 4) =
*(int *)(*__ptr + (long)((iVar2 / iVar9) % 10) * 4) + 1;
} while (piVar7 != piVar4);
}
do {
*piVar5 = *piVar5 + piVar5[-1];
piVar5 = piVar5 + 1;
} while (piVar5 != (int *)(__ptr[2] + 8));
lVar8 = (long)(int)uVar1;
uVar6 = uVar1;
while (-1 < (int)uVar6) {
iVar2 = param_1[lVar8];
lVar8 = lVar8 + -1;
iVar3 = *(int *)(*__ptr + (long)((iVar2 / iVar9) % 10) * 4);
*(int *)((long)__src + (long)iVar3 * 4 + -4) = iVar2;
*(int *)(*__ptr + (long)((iVar2 / iVar9) % 10) * 4) = iVar3 + -1;
uVar6 = (uint)lVar8;
}
if (0 < param_2) {
param_1 = (int *)memcpy(param_1,__src,(ulong)uVar1 * 4 + 4);
}
iVar9 = iVar9 * 10;
} while (iVar9 <= iVar10);
}
free(__src);
free(__ptr);
return;
} |
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));
while (placement <= max_digit) {
for (int i = 0; i < RADIX; i++) {
count[i] = 0;
}
for (int i = 0; i < size; i++) {
int index = (nums[i] / placement) % RADIX;
count[index]++;
}
for (int i = 1; i < RADIX; i++) {
count[i] += count[i - 1];
}
for (int i = size - 1; i >= 0; i--) {
int index = (nums[i] / placement) % RADIX;
output[count[index] - 1] = nums[i];
count[index]--;
}
for (int i = 0; i < size; i++) {
nums[i] = output[i];
}
placement *= RADIX;
}
free(output);
free(count);
}
| 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 = sizeof(nums2) / sizeof(nums2[0]);
func0(nums2, size2);
int sorted2[] = {2, 3, 7, 8, 9, 11};
for (int i = 0; i < size2; i++) {
assert(nums2[i] == sorted2[i]);
}
int nums3[] = {36, 12, 24, 26, 29};
int size3 = sizeof(nums3) / sizeof(nums3[0]);
func0(nums3, size3);
int sorted3[] = {12, 24, 26, 29, 36};
for (int i = 0; i < size3; i++) {
assert(nums3[i] == sorted3[i]);
}
return 0;
}
| 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 %ecx,%edx
movd %ebx,%xmm7
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm7,%xmm0
shl $0x4,%rdx
add %rdi,%rdx
nopl (%rax)
movdqu 0x4(%rax),%xmm2
add $0x10,%rax
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
movdqa %xmm1,%xmm0
por %xmm2,%xmm0
cmp %rax,%rdx
jne 1440 <func0+0x50>
movdqa %xmm0,%xmm2
mov %ecx,%edx
psrldq $0x8,%xmm2
and $0xfffffffc,%edx
movdqa %xmm2,%xmm1
lea 0x1(%rdx),%eax
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
movdqa %xmm1,%xmm0
por %xmm2,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,(%rsp)
cmp %edx,%ecx
je 14f6 <func0+0x106>
movslq %eax,%rdx
mov (%rsp),%ecx
mov (%r12,%rdx,4),%edx
cmp %edx,%ecx
mov %edx,%ebx
lea 0x1(%rax),%edx
cmovge %ecx,%ebx
mov %ebx,(%rsp)
cmp %edx,%r15d
jle 14f6 <func0+0x106>
movslq %edx,%rdx
mov (%r12,%rdx,4),%edx
cmp %edx,%ebx
cmovge %ebx,%edx
add $0x2,%eax
mov %edx,(%rsp)
cmp %eax,%r15d
jle 14f6 <func0+0x106>
cltq
mov (%r12,%rax,4),%eax
cmp %eax,%edx
cmovge %edx,%eax
mov %eax,(%rsp)
movslq %r15d,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov $0x28,%edi
mov %rax,%r13
callq 10d0 <malloc@plt>
mov %rax,%rbp
mov (%rsp),%eax
test %eax,%eax
jle 168b <func0+0x29b>
lea -0x1(%r15),%eax
mov $0x1,%ebx
pxor %xmm1,%xmm1
mov %eax,0x4(%rsp)
lea 0x4(%r12,%rax,4),%r14
lea 0x4(,%rax,4),%rax
mov %rax,0x8(%rsp)
movq $0x0,0x20(%rbp)
mov %r12,%rcx
movups %xmm1,0x0(%rbp)
movups %xmm1,0x10(%rbp)
test %r15d,%r15d
jle 16a9 <func0+0x2b9>
nopl 0x0(%rax)
mov (%rcx),%eax
add $0x4,%rcx
cltd
idiv %ebx
movslq %eax,%rdx
mov %eax,%esi
imul $0x66666667,%rdx,%rdx
sar $0x1f,%esi
sar $0x22,%rdx
sub %esi,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
cltq
addl $0x1,0x0(%rbp,%rax,4)
cmp %r14,%rcx
jne 1560 <func0+0x170>
mov 0x8(%rbp),%esi
mov 0x0(%rbp),%eax
mov 0xc(%rbp),%edx
add 0x4(%rbp),%eax
mov 0x10(%rbp),%edi
add %eax,%esi
mov 0x14(%rbp),%r8d
add %esi,%edx
mov 0x18(%rbp),%r9d
mov 0x1c(%rbp),%ecx
add %edx,%edi
mov 0x20(%rbp),%r10d
mov 0x24(%rbp),%r11d
add %edi,%r8d
add %r8d,%r9d
add %r9d,%ecx
add %ecx,%r10d
add %r10d,%r11d
movd %edx,%xmm2
movd %edi,%xmm3
movd %eax,%xmm0
mov %r11d,0x24(%rbp)
movd %esi,%xmm4
punpckldq %xmm3,%xmm2
movd %r10d,%xmm5
punpckldq %xmm4,%xmm0
movd %r9d,%xmm6
punpcklqdq %xmm2,%xmm0
movd %ecx,%xmm2
movslq 0x4(%rsp),%rcx
movups %xmm0,0x4(%rbp)
movd %r8d,%xmm0
punpckldq %xmm5,%xmm2
punpckldq %xmm6,%xmm0
punpcklqdq %xmm2,%xmm0
movups %xmm0,0x14(%rbp)
test %ecx,%ecx
js 1664 <func0+0x274>
nopl 0x0(%rax,%rax,1)
mov (%r12,%rcx,4),%esi
sub $0x1,%rcx
mov %esi,%eax
cltd
idiv %ebx
movslq %eax,%rdx
mov %eax,%edi
imul $0x66666667,%rdx,%rdx
sar $0x1f,%edi
sar $0x22,%rdx
sub %edi,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
cltq
lea 0x0(%rbp,%rax,4),%rdx
movslq (%rdx),%rdi
mov %rdi,%rax
mov %esi,-0x4(%r13,%rdi,4)
sub $0x1,%eax
mov %eax,(%rdx)
test %ecx,%ecx
jns 1620 <func0+0x230>
test %r15d,%r15d
jle 167d <func0+0x28d>
mov 0x8(%rsp),%rdx
mov %r13,%rsi
mov %r12,%rdi
callq 10c0 <memcpy@plt>
pxor %xmm1,%xmm1
lea (%rbx,%rbx,4),%ebx
add %ebx,%ebx
cmp (%rsp),%ebx
jle 1540 <func0+0x150>
mov %r13,%rdi
callq 1090 <free@plt>
add $0x18,%rsp
mov %rbp,%rdi
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
jmpq 1090 <free@plt>
xor %r11d,%r11d
xor %r10d,%r10d
xor %ecx,%ecx
xor %r9d,%r9d
xor %r8d,%r8d
xor %edi,%edi
xor %edx,%edx
xor %esi,%esi
xor %eax,%eax
jmpq 15c8 <func0+0x1d8>
mov $0x1,%eax
jmpq 14b5 <func0+0xc5>
xchg %ax,%ax
| 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 edx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00h]
loc_13C0:
movdqu xmm0, xmmword ptr [rax+4]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rdx, rax
jnz short loc_13C0
movdqa xmm1, xmm2
mov eax, ecx
psrldq xmm1, 8
and eax, 0FFFFFFFCh
movdqa xmm0, xmm1
add eax, 1
and ecx, 3
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd r15d, xmm1
jz short loc_1470
loc_1432:
movsxd rdx, eax
lea rcx, ds:0[rdx*4]
mov edx, [r12+rdx*4]
cmp r15d, edx
cmovl r15d, edx
lea edx, [rax+1]
cmp r9d, edx
jle short loc_1470
mov edx, [r12+rcx+4]
cmp r15d, edx
cmovl r15d, edx
add eax, 2
cmp r9d, eax
jle short loc_1470
mov eax, [r12+rcx+8]
cmp r15d, eax
cmovl r15d, eax
loc_1470:
movsxd r14, r9d
mov [rsp+48h+var_48], r9d
shl r14, 2
mov rdi, r14; size
call _malloc
mov edi, 28h ; '('; size
mov r13, rax
call _malloc
mov rbx, rax
test r15d, r15d
jle loc_15D6
mov r9d, [rsp+48h+var_48]
add r14, r12
mov ebp, 1
pxor xmm0, xmm0
lea eax, [r9-1]
mov [rsp+48h+var_44], eax
lea rax, ds:4[rax*4]
mov [rsp+48h+n], rax
nop dword ptr [rax+00000000h]
loc_14C8:
mov eax, [rsp+48h+var_48]
mov qword ptr [rbx+20h], 0
mov rsi, r12
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
test eax, eax
jle loc_15F4
nop dword ptr [rax]
loc_14E8:
mov eax, [rsi]
add rsi, 4
cdq
idiv ebp
movsxd rdx, eax
mov ecx, eax
imul rdx, 66666667h
sar ecx, 1Fh
sar rdx, 22h
sub edx, ecx
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
cdqe
add dword ptr [rbx+rax*4], 1
cmp rsi, r14
jnz short loc_14E8
mov r11d, [rbx+8]
mov r10d, [rbx+0Ch]
mov eax, [rbx]
add eax, [rbx+4]
mov r9d, [rbx+10h]
add r11d, eax
mov r8d, [rbx+14h]
mov [rbx+4], eax
add r10d, r11d
mov edi, [rbx+18h]
mov esi, [rbx+1Ch]
mov [rbx+8], r11d
add r9d, r10d
mov edx, [rbx+20h]
mov [rbx+0Ch], r10d
add r8d, r9d
mov [rbx+10h], r9d
add edi, r8d
mov [rbx+14h], r8d
add esi, edi
mov [rbx+18h], edi
add edx, esi
add [rbx+24h], edx
mov [rbx+20h], edx
mov [rbx+1Ch], esi
movsxd rsi, [rsp+48h+var_44]
nop dword ptr [rax]
loc_1570:
mov ecx, [r12+rsi*4]
sub rsi, 1
mov eax, ecx
cdq
idiv ebp
movsxd rdx, eax
mov edi, eax
imul rdx, 66666667h
sar edi, 1Fh
sar rdx, 22h
sub edx, edi
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
cdqe
lea rdx, [rbx+rax*4]
movsxd rdi, dword ptr [rdx]
mov rax, rdi
mov [r13+rdi*4-4], ecx
sub eax, 1
mov [rdx], eax
test esi, esi
jns short loc_1570
mov rdx, [rsp+48h+n]; n
mov rsi, r13; src
mov rdi, r12; dest
call _memcpy
pxor xmm0, xmm0
loc_15C7:
lea ebp, [rbp+rbp*4+0]
add ebp, ebp
cmp ebp, r15d
jle loc_14C8
loc_15D6:
mov rdi, r13; ptr
call _free
add rsp, 18h
mov rdi, rbx; ptr
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
jmp _free
loc_15F4:
mov dword ptr [rbx+4], 0
mov qword ptr [rbx+8], 0
mov qword ptr [rbx+10h], 0
mov qword ptr [rbx+18h], 0
mov qword ptr [rbx+20h], 0
jmp short loc_15C7
loc_161D:
mov eax, 1
jmp loc_1432 | 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
long long v15; // rcx
_DWORD *v16; // r13
_QWORD *v17; // rbx
signed int *v18; // r14
int v19; // ebp
__int128 v20; // xmm0
signed int *v21; // rsi
int v22; // eax
int v23; // r10d
int v24; // eax
int v25; // r9d
int v26; // r11d
int v27; // r8d
int v28; // r10d
int v29; // edi
int v30; // esi
int v31; // r9d
int v32; // edx
int v33; // r8d
int v34; // edi
int v35; // esi
int v36; // edx
long long v37; // rsi
signed int v38; // ecx
int *v39; // rdx
int v40; // eax
v3 = *dest;
if ( a2 > 1 )
{
v4 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v10 = 1;
}
else
{
v5 = dest;
v6 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v3), 0);
do
{
v7 = _mm_loadu_si128((const __m128i *)(v5 + 1));
v5 += 4;
v8 = _mm_cmpgt_epi32(v7, v6);
v6 = _mm_or_si128(_mm_andnot_si128(v8, v6), _mm_and_si128(v7, v8));
}
while ( &dest[4 * (v4 >> 2)] != v5 );
v9 = _mm_srli_si128(v6, 8);
v10 = (v4 & 0xFFFFFFFC) + 1;
v11 = _mm_cmpgt_epi32(v9, v6);
v12 = _mm_or_si128(_mm_andnot_si128(v11, v6), _mm_and_si128(v9, v11));
v13 = _mm_srli_si128(v12, 4);
v14 = _mm_cmpgt_epi32(v13, v12);
v3 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v14, v12), _mm_and_si128(v13, v14)));
if ( (v4 & 3) == 0 )
goto LABEL_14;
}
v15 = v10;
if ( v3 < dest[v15] )
v3 = dest[v10];
if ( a2 > v10 + 1 )
{
if ( v3 < dest[v15 + 1] )
v3 = dest[v15 + 1];
if ( a2 > v10 + 2 && v3 < dest[v15 + 2] )
v3 = dest[v15 + 2];
}
}
LABEL_14:
v16 = malloc(4LL * a2);
v17 = malloc(0x28uLL);
if ( v3 > 0 )
{
v18 = &dest[a2];
v19 = 1;
v20 = 0LL;
do
{
v17[4] = 0LL;
v21 = dest;
*(_OWORD *)v17 = v20;
*((_OWORD *)v17 + 1) = v20;
if ( a2 <= 0 )
{
*((_DWORD *)v17 + 1) = 0;
v17[1] = 0LL;
v17[2] = 0LL;
v17[3] = 0LL;
v17[4] = 0LL;
}
else
{
do
{
v22 = *v21++;
++*((_DWORD *)v17 + v22 / v19 % 10);
}
while ( v21 != v18 );
v23 = *((_DWORD *)v17 + 3);
v24 = *((_DWORD *)v17 + 1) + *(_DWORD *)v17;
v25 = *((_DWORD *)v17 + 4);
v26 = v24 + *((_DWORD *)v17 + 2);
v27 = *((_DWORD *)v17 + 5);
*((_DWORD *)v17 + 1) = v24;
v28 = v26 + v23;
v29 = *((_DWORD *)v17 + 6);
v30 = *((_DWORD *)v17 + 7);
*((_DWORD *)v17 + 2) = v26;
v31 = v28 + v25;
v32 = *((_DWORD *)v17 + 8);
*((_DWORD *)v17 + 3) = v28;
v33 = v31 + v27;
*((_DWORD *)v17 + 4) = v31;
v34 = v33 + v29;
*((_DWORD *)v17 + 5) = v33;
v35 = v34 + v30;
*((_DWORD *)v17 + 6) = v34;
v36 = v35 + v32;
*((_DWORD *)v17 + 9) += v36;
*((_DWORD *)v17 + 8) = v36;
*((_DWORD *)v17 + 7) = v35;
v37 = a2 - 1;
do
{
v38 = dest[v37--];
v39 = (int *)v17 + v38 / v19 % 10;
v40 = *v39;
v16[*v39 - 1] = v38;
*v39 = v40 - 1;
}
while ( (int)v37 >= 0 );
memcpy(dest, v16, 4LL * (unsigned int)(a2 - 1) + 4);
v20 = 0LL;
}
v19 *= 10;
}
while ( v19 <= v3 );
}
free(v16);
free(v17);
} | 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,RDI
NOP dword ptr [RAX]
LAB_001013c0:
MOVDQU XMM0,xmmword ptr [RAX + 0x4]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RDX,RAX
JNZ 0x001013c0
MOVDQA XMM1,XMM2
MOV EAX,ECX
PSRLDQ XMM1,0x8
AND EAX,0xfffffffc
MOVDQA XMM0,XMM1
ADD EAX,0x1
AND ECX,0x3
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD R15D,XMM1
JZ 0x00101470
LAB_00101432:
MOVSXD RDX,EAX
LEA RCX,[RDX*0x4]
MOV EDX,dword ptr [R12 + RDX*0x4]
CMP R15D,EDX
CMOVL R15D,EDX
LEA EDX,[RAX + 0x1]
CMP R9D,EDX
JLE 0x00101470
MOV EDX,dword ptr [R12 + RCX*0x1 + 0x4]
CMP R15D,EDX
CMOVL R15D,EDX
ADD EAX,0x2
CMP R9D,EAX
JLE 0x00101470
MOV EAX,dword ptr [R12 + RCX*0x1 + 0x8]
CMP R15D,EAX
CMOVL R15D,EAX
LAB_00101470:
MOVSXD R14,R9D
MOV dword ptr [RSP],R9D
SHL R14,0x2
MOV RDI,R14
CALL 0x001010d0
MOV EDI,0x28
MOV R13,RAX
CALL 0x001010d0
MOV RBX,RAX
TEST R15D,R15D
JLE 0x001015d6
MOV R9D,dword ptr [RSP]
ADD R14,R12
MOV EBP,0x1
PXOR XMM0,XMM0
LEA EAX,[R9 + -0x1]
MOV dword ptr [RSP + 0x4],EAX
LEA RAX,[0x4 + RAX*0x4]
MOV qword ptr [RSP + 0x8],RAX
NOP dword ptr [RAX]
LAB_001014c8:
MOV EAX,dword ptr [RSP]
MOV qword ptr [RBX + 0x20],0x0
MOV RSI,R12
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
TEST EAX,EAX
JLE 0x001015f4
NOP dword ptr [RAX]
LAB_001014e8:
MOV EAX,dword ptr [RSI]
ADD RSI,0x4
CDQ
IDIV EBP
MOVSXD RDX,EAX
MOV ECX,EAX
IMUL RDX,RDX,0x66666667
SAR ECX,0x1f
SAR RDX,0x22
SUB EDX,ECX
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
CDQE
ADD dword ptr [RBX + RAX*0x4],0x1
CMP RSI,R14
JNZ 0x001014e8
MOV R11D,dword ptr [RBX + 0x8]
MOV R10D,dword ptr [RBX + 0xc]
MOV EAX,dword ptr [RBX]
ADD EAX,dword ptr [RBX + 0x4]
MOV R9D,dword ptr [RBX + 0x10]
ADD R11D,EAX
MOV R8D,dword ptr [RBX + 0x14]
MOV dword ptr [RBX + 0x4],EAX
ADD R10D,R11D
MOV EDI,dword ptr [RBX + 0x18]
MOV ESI,dword ptr [RBX + 0x1c]
MOV dword ptr [RBX + 0x8],R11D
ADD R9D,R10D
MOV EDX,dword ptr [RBX + 0x20]
MOV dword ptr [RBX + 0xc],R10D
ADD R8D,R9D
MOV dword ptr [RBX + 0x10],R9D
ADD EDI,R8D
MOV dword ptr [RBX + 0x14],R8D
ADD ESI,EDI
MOV dword ptr [RBX + 0x18],EDI
ADD EDX,ESI
ADD dword ptr [RBX + 0x24],EDX
MOV dword ptr [RBX + 0x20],EDX
MOV dword ptr [RBX + 0x1c],ESI
MOVSXD RSI,dword ptr [RSP + 0x4]
NOP dword ptr [RAX]
LAB_00101570:
MOV ECX,dword ptr [R12 + RSI*0x4]
SUB RSI,0x1
MOV EAX,ECX
CDQ
IDIV EBP
MOVSXD RDX,EAX
MOV EDI,EAX
IMUL RDX,RDX,0x66666667
SAR EDI,0x1f
SAR RDX,0x22
SUB EDX,EDI
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
CDQE
LEA RDX,[RBX + RAX*0x4]
MOVSXD RDI,dword ptr [RDX]
MOV RAX,RDI
MOV dword ptr [R13 + RDI*0x4 + -0x4],ECX
SUB EAX,0x1
MOV dword ptr [RDX],EAX
TEST ESI,ESI
JNS 0x00101570
MOV RDX,qword ptr [RSP + 0x8]
MOV RSI,R13
MOV RDI,R12
CALL 0x001010c0
PXOR XMM0,XMM0
LAB_001015c7:
LEA EBP,[RBP + RBP*0x4]
ADD EBP,EBP
CMP EBP,R15D
JLE 0x001014c8
LAB_001015d6:
MOV RDI,R13
CALL 0x00101090
ADD RSP,0x18
MOV RDI,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
JMP 0x00101090
LAB_001015f4:
MOV dword ptr [RBX + 0x4],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV qword ptr [RBX + 0x10],0x0
MOV qword ptr [RBX + 0x18],0x0
MOV qword ptr [RBX + 0x20],0x0
JMP 0x001015c7
LAB_0010161d:
MOV EAX,0x1
JMP 0x00101432 | 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 uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uVar15 = *param_1;
if (1 < param_2) {
uVar2 = param_2 - 1;
if (param_2 - 2U < 3) {
iVar6 = 1;
}
else {
puVar8 = param_1;
uVar21 = uVar15;
uVar17 = uVar15;
uVar22 = uVar15;
do {
puVar1 = puVar8 + 1;
puVar3 = puVar8 + 2;
puVar4 = puVar8 + 3;
puVar5 = puVar8 + 4;
puVar8 = puVar8 + 4;
uVar16 = -(uint)((int)uVar15 < (int)*puVar1);
uVar18 = -(uint)((int)uVar21 < (int)*puVar3);
uVar19 = -(uint)((int)uVar17 < (int)*puVar4);
uVar20 = -(uint)((int)uVar22 < (int)*puVar5);
uVar15 = ~uVar16 & uVar15 | *puVar1 & uVar16;
uVar21 = ~uVar18 & uVar21 | *puVar3 & uVar18;
uVar17 = ~uVar19 & uVar17 | *puVar4 & uVar19;
uVar22 = ~uVar20 & uVar22 | *puVar5 & uVar20;
} while (param_1 + (ulong)(uVar2 >> 2) * 4 != puVar8);
iVar6 = (uVar2 & 0xfffffffc) + 1;
uVar15 = ~-(uint)((int)uVar15 < (int)uVar17) & uVar15 |
uVar17 & -(uint)((int)uVar15 < (int)uVar17);
uVar21 = ~-(uint)((int)uVar21 < (int)uVar22) & uVar21 |
uVar22 & -(uint)((int)uVar21 < (int)uVar22);
uVar17 = -(uint)((int)uVar15 < (int)uVar21);
uVar15 = ~uVar17 & uVar15 | uVar21 & uVar17;
if ((uVar2 & 3) == 0) goto LAB_00101470;
}
if ((int)uVar15 < (int)param_1[iVar6]) {
uVar15 = param_1[iVar6];
}
if (iVar6 + 1 < param_2) {
if ((int)uVar15 < (int)param_1[(long)iVar6 + 1]) {
uVar15 = param_1[(long)iVar6 + 1];
}
if ((iVar6 + 2 < param_2) && ((int)uVar15 < (int)param_1[(long)iVar6 + 2])) {
uVar15 = param_1[(long)iVar6 + 2];
}
}
}
LAB_00101470:
__src = malloc((long)param_2 * 4);
__ptr = (int (*) [16])malloc(0x28);
if (0 < (int)uVar15) {
iVar6 = 1;
do {
*(int8 *)__ptr[2] = 0;
*__ptr = (int [16])0x0;
__ptr[1] = (int [16])0x0;
puVar8 = param_1;
if (param_2 < 1) {
*(int4 *)(*__ptr + 4) = 0;
*(int8 *)(*__ptr + 8) = 0;
*(int8 *)__ptr[1] = 0;
*(int8 *)(__ptr[1] + 8) = 0;
*(int8 *)__ptr[2] = 0;
}
else {
do {
uVar2 = *puVar8;
puVar8 = puVar8 + 1;
*(int *)(*__ptr + (long)(((int)uVar2 / iVar6) % 10) * 4) =
*(int *)(*__ptr + (long)(((int)uVar2 / iVar6) % 10) * 4) + 1;
} while (puVar8 != param_1 + param_2);
iVar7 = *(int *)*__ptr + *(int *)(*__ptr + 4);
iVar12 = *(int *)__ptr[1];
iVar14 = *(int *)(*__ptr + 8) + iVar7;
iVar11 = *(int *)(__ptr[1] + 4);
*(int *)(*__ptr + 4) = iVar7;
iVar13 = *(int *)(*__ptr + 0xc) + iVar14;
iVar7 = *(int *)(__ptr[1] + 8);
iVar9 = *(int *)(__ptr[1] + 0xc);
*(int *)(*__ptr + 8) = iVar14;
iVar12 = iVar12 + iVar13;
iVar14 = *(int *)__ptr[2];
*(int *)(*__ptr + 0xc) = iVar13;
iVar11 = iVar11 + iVar12;
*(int *)__ptr[1] = iVar12;
iVar7 = iVar7 + iVar11;
*(int *)(__ptr[1] + 4) = iVar11;
iVar9 = iVar9 + iVar7;
*(int *)(__ptr[1] + 8) = iVar7;
iVar14 = iVar14 + iVar9;
*(int *)(__ptr[2] + 4) = *(int *)(__ptr[2] + 4) + iVar14;
*(int *)__ptr[2] = iVar14;
*(int *)(__ptr[1] + 0xc) = iVar9;
lVar10 = (long)(int)(param_2 - 1U);
do {
uVar2 = param_1[lVar10];
lVar10 = lVar10 + -1;
iVar12 = *(int *)(*__ptr + (long)(((int)uVar2 / iVar6) % 10) * 4);
*(uint *)((long)__src + (long)iVar12 * 4 + -4) = uVar2;
*(int *)(*__ptr + (long)(((int)uVar2 / iVar6) % 10) * 4) = iVar12 + -1;
} while (-1 < (int)lVar10);
memcpy(param_1,__src,(ulong)(param_2 - 1U) * 4 + 4);
}
iVar6 = iVar6 * 10;
} while (iVar6 <= (int)uVar15);
}
free(__src);
free(__ptr);
return;
} |
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
cmp %eax,-0x8(%rbp)
jge 11de <func0+0x55>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11aa <func0+0x21>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov 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
mov eax, [rax]
cmp [rbp+var_8], eax
jge short loc_11DE
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
loc_11DE:
add [rbp+var_4], 1
loc_11E2:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11AA
mov eax, [rbp+var_8]
pop rbp
retn | 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 [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x8],EAX
JGE 0x001011de
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011de:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011e2:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011aa
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | 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 *)v4 );
}
return v2;
} | 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
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| 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:
retn | 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;
if ( v3 == v4 )
break;
}
}
return result;
} | 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) break;
iVar3 = *param_1;
param_1 = param_1 + 1;
}
}
return;
} |
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 $0x10,%rax
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand %xmm2,%xmm1
pandn %xmm0,%xmm2
movdqa %xmm2,%xmm0
por %xmm1,%xmm0
cmp %rdx,%rax
jne 11a8 <func0+0x38>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand %xmm2,%xmm1
pandn %xmm0,%xmm2
por %xmm2,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 1250 <func0+0xe0>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 1245 <func0+0xd5>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x2,%edx
cmp %edx,%esi
jle 1245 <func0+0xd5>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
cmp %edx,%eax
cmovl %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
retq
xor %edx,%edx
jmp 1216 <func0+0xa6>
nopw %cs:0x0(%rax,%rax,1)
| 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, xmmword ptr [rax]
add rax, 10h
movdqa xmm2, xmm1
pcmpgtd xmm2, xmm0
pand xmm1, xmm2
pandn xmm2, xmm0
movdqa xmm0, xmm2
por xmm0, xmm1
cmp rax, rdx
jnz short loc_11A8
movdqa xmm2, xmm0
mov edx, ecx
psrldq xmm2, 8
and edx, 0FFFFFFFCh
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
test cl, 3
jz short locret_1250
loc_1215:
movsxd rsi, edx
lea r8, ds:0[rsi*4]
mov esi, [rdi+rsi*4]
cmp eax, esi
cmovl eax, esi
lea esi, [rdx+1]
cmp ecx, esi
jle short locret_124A
mov esi, [rdi+r8+4]
cmp eax, esi
cmovl eax, esi
add edx, 2
cmp ecx, edx
jle short locret_124A
mov edx, [rdi+r8+8]
cmp eax, edx
cmovl eax, edx
locret_124A:
retn
locret_1250:
retn
loc_1251:
xor edx, edx
jmp short loc_1215 | 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; // xmm0
long long v15; // r8
int v16; // esi
int v17; // esi
int v18; // edx
result = a1->m128i_u32[0];
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v10 = 0;
}
else
{
v4 = _mm_cvtsi32_si128(result);
v5 = a1;
v6 = _mm_shuffle_epi32(v4, 0);
do
{
v7 = _mm_loadu_si128(v5++);
v8 = _mm_cmpgt_epi32(v7, v6);
v6 = _mm_or_si128(_mm_andnot_si128(v8, v6), _mm_and_si128(v7, v8));
}
while ( v5 != &a1[(unsigned int)a2 >> 2] );
v9 = _mm_srli_si128(v6, 8);
v10 = a2 & 0xFFFFFFFC;
v11 = _mm_cmpgt_epi32(v9, v6);
v12 = _mm_or_si128(_mm_andnot_si128(v11, v6), _mm_and_si128(v9, v11));
v13 = _mm_srli_si128(v12, 4);
v14 = _mm_cmpgt_epi32(v13, v12);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v14, v12), _mm_and_si128(v13, v14)));
if ( (a2 & 3) == 0 )
return result;
}
v15 = v10;
v16 = a1->m128i_i32[v15];
if ( (int)result < v16 )
result = (unsigned int)v16;
if ( a2 > v10 + 1 )
{
v17 = a1->m128i_i32[v15 + 1];
if ( (int)result < v17 )
result = (unsigned int)v17;
if ( a2 > v10 + 2 )
{
v18 = a1->m128i_i32[v15 + 2];
if ( (int)result < v18 )
return (unsigned int)v18;
}
}
}
return result;
} | 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
PCMPGTD XMM2,XMM0
PAND XMM1,XMM2
PANDN XMM2,XMM0
MOVDQA XMM0,XMM2
POR XMM0,XMM1
CMP RAX,RDX
JNZ 0x001011a8
MOVDQA XMM2,XMM0
MOV EDX,ECX
PSRLDQ XMM2,0x8
AND EDX,0xfffffffc
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x00101250
LAB_00101215:
MOVSXD RSI,EDX
LEA R8,[RSI*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
CMP EAX,ESI
CMOVL EAX,ESI
LEA ESI,[RDX + 0x1]
CMP ECX,ESI
JLE 0x0010124a
MOV ESI,dword ptr [RDI + R8*0x1 + 0x4]
CMP EAX,ESI
CMOVL EAX,ESI
ADD EDX,0x2
CMP ECX,EDX
JLE 0x0010124a
MOV EDX,dword ptr [RDI + R8*0x1 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_0010124a:
RET
LAB_00101250:
RET
LAB_00101251:
XOR EDX,EDX
JMP 0x00101215 | 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) {
uVar5 = 0;
}
else {
puVar4 = param_1;
uVar7 = uVar6;
uVar8 = uVar6;
uVar9 = uVar6;
do {
uVar5 = *puVar4;
puVar1 = puVar4 + 1;
puVar2 = puVar4 + 2;
puVar3 = puVar4 + 3;
puVar4 = puVar4 + 4;
uVar10 = -(uint)((int)uVar6 < (int)uVar5);
uVar11 = -(uint)((int)uVar7 < (int)*puVar1);
uVar12 = -(uint)((int)uVar8 < (int)*puVar2);
uVar13 = -(uint)((int)uVar9 < (int)*puVar3);
uVar6 = ~uVar10 & uVar6 | uVar5 & uVar10;
uVar7 = ~uVar11 & uVar7 | *puVar1 & uVar11;
uVar8 = ~uVar12 & uVar8 | *puVar2 & uVar12;
uVar9 = ~uVar13 & uVar9 | *puVar3 & uVar13;
} while (puVar4 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar5 = param_2 & 0xfffffffc;
uVar8 = ~-(uint)((int)uVar6 < (int)uVar8) & uVar6 | uVar8 & -(uint)((int)uVar6 < (int)uVar8);
uVar7 = ~-(uint)((int)uVar7 < (int)uVar9) & uVar7 | uVar9 & -(uint)((int)uVar7 < (int)uVar9);
uVar6 = -(uint)((int)uVar8 < (int)uVar7);
uVar6 = ~uVar6 & uVar8 | uVar7 & uVar6;
if ((param_2 & 3) == 0) {
return uVar6;
}
}
if ((int)uVar6 < (int)param_1[(int)uVar5]) {
uVar6 = param_1[(int)uVar5];
}
if ((int)(uVar5 + 1) < (int)param_2) {
if ((int)uVar6 < (int)param_1[(long)(int)uVar5 + 1]) {
uVar6 = param_1[(long)(int)uVar5 + 1];
}
if (((int)(uVar5 + 2) < (int)param_2) && ((int)uVar6 < (int)param_1[(long)(int)uVar5 + 2])) {
uVar6 = param_1[(long)(int)uVar5 + 2];
}
}
}
return uVar6;
} |
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>
movsd 0xebf(%rip),%xmm1
divsd %xmm1,%xmm0
leaveq
retq
| 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 [rbp+var_8], xmm0
movsd xmm1, [rbp+var_8]
movsd xmm0, cs:qword_2078
mulsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _round
movq rax, xmm0
movsd xmm0, cs:qword_2078
movq xmm1, rax
divsd xmm1, xmm0
movapd xmm0, xmm1
leave
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
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 ptr [RBP + -0x8],XMM0
MOVSD XMM1,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x00102078]
MULSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MOVSD XMM0,qword ptr [0x00102078]
MOVQ XMM1,RAX
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM1
LEAVE
RET | 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;
den = rem;
rem = num % den;
}
gcd = den;
lcm = (num1 * num2) / gcd;
return lcm;
}
| 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,%edi
callq 1169 <find_lcm>
mov %eax,-0x10(%rbp)
movl $0x2,-0xc(%rbp)
jmp 1244 <func0+0x6a>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1169 <find_lcm>
mov %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 121b <func0+0x41>
mov -0x10(%rbp),%eax
leaveq
retq
| 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, edx
mov edi, eax
call find_lcm
mov [rbp+var_10], eax
mov [rbp+var_C], 2
jmp short loc_1244
loc_121B:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
mov esi, edx
mov edi, eax
call find_lcm
mov [rbp+var_10], eax
add [rbp+var_C], 1
loc_1244:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_121B
mov eax, [rbp+var_10]
leave
retn | 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 + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0xc],0x2
JMP 0x00101244
LAB_0010121b:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
MOV dword ptr [RBP + -0x10],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_00101244:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010121b
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET | 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;
den = rem;
rem = num % den;
}
gcd = den;
lcm = (num1 * num2) / gcd;
return lcm;
}
| 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_lcm>
mov %eax,%edi
add $0x4,%rbx
cmp %rbp,%rbx
jne 11d5 <func0+0x2e>
mov %edi,%eax
pop %rbx
pop %rbp
pop %r12
retq
| 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 edi, eax
add rbx, 4
cmp rbx, rbp
jnz short loc_11D5
loc_11E7:
mov eax, edi
pop rbx
pop rbp
pop r12
retn | 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 *)v5 );
}
return (unsigned int)lcm;
} | 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 RBX,0x4
CMP RBX,RBP
JNZ 0x001011d5
LAB_001011e7:
MOV EAX,EDI
POP RBX
POP RBP
POP R12
RET | 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;
den = rem;
rem = num % den;
}
gcd = den;
lcm = (num1 * num2) / gcd;
return lcm;
}
| 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>
imul %r10d,%r8d
mov %r8d,%eax
cltd
idiv %r9d
mov %eax,%r8d
cmp $0x2,%esi
jle 139b <func0+0x9b>
lea -0x3(%rsi),%eax
lea 0x8(%rdi),%r9
lea 0xc(%rdi,%rax,4),%r10
nopw %cs:0x0(%rax,%rax,1)
mov (%r9),%edi
cmp %r8d,%edi
jl 13a0 <func0+0xa0>
mov %edi,%eax
mov %r8d,%ecx
cltd
idiv %ecx
test %edx,%edx
je 13ac <func0+0xac>
nopl 0x0(%rax)
mov %ecx,%eax
mov %edx,%esi
mov %edx,%ecx
cltd
idiv %esi
test %edx,%edx
jne 1378 <func0+0x78>
imul %edi,%r8d
add $0x4,%r9
mov %r8d,%eax
cltd
idiv %esi
mov %eax,%r8d
cmp %r10,%r9
jne 1360 <func0+0x60>
mov %r8d,%eax
retq
mov %r8d,%eax
mov %edi,%ecx
cltd
idiv %ecx
test %edx,%edx
jne 1378 <func0+0x78>
mov %ecx,%esi
jmp 1385 <func0+0x85>
mov %r8d,%eax
mov %r10d,%ecx
cltd
idiv %ecx
test %edx,%edx
jne 1328 <func0+0x28>
mov %ecx,%r9d
jmpq 1337 <func0+0x37>
nopl 0x0(%rax)
| 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, edx
jnz short loc_1330
loc_133D:
imul r8d, r10d
mov eax, r8d
cdq
idiv esi
mov r8d, eax
cmp r9d, 2
jle short loc_139B
lea eax, [r9-3]
lea r10, [rdi+8]
lea r9, [rdi+rax*4+0Ch]
nop dword ptr [rax]
loc_1360:
mov edi, [r10]
cmp edi, r8d
jl short loc_13A0
mov eax, edi
mov ecx, r8d
cdq
idiv ecx
test edx, edx
jz short loc_13AC
nop dword ptr [rax+00h]
loc_1378:
mov eax, ecx
mov esi, edx
mov ecx, edx
cdq
idiv esi
test edx, edx
jnz short loc_1378
loc_1385:
imul r8d, edi
add r10, 4
mov eax, r8d
cdq
idiv esi
mov r8d, eax
cmp r10, r9
jnz short loc_1360
loc_139B:
mov eax, r8d
retn
loc_13A0:
mov eax, r8d
mov ecx, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1378
loc_13AC:
mov esi, ecx
jmp short loc_1385
loc_13B0:
mov eax, r8d
mov ecx, r10d
cdq
idiv ecx
test edx, edx
jnz loc_1330
loc_13C1:
mov esi, ecx
jmp loc_133D | 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 ( *a1 <= v3 )
{
v5 = *a1;
v6 = v3 % v2;
if ( v3 % v2 )
goto LABEL_3;
LABEL_14:
v8 = v5;
goto LABEL_4;
}
v5 = a1[1];
v6 = v2 % v3;
if ( !(v2 % v3) )
goto LABEL_14;
do
{
LABEL_3:
v7 = v5;
v8 = v6;
v5 = v6;
v6 = v7 % v6;
}
while ( v6 );
LABEL_4:
v9 = v3 * v2 / v8;
if ( a2 > 2 )
{
v10 = a1 + 2;
v11 = (long long)&a1[a2 - 3 + 3];
do
{
v12 = *v10;
if ( *v10 < v9 )
{
v13 = *v10;
v14 = v9 % v12;
if ( v9 % v12 )
{
do
{
LABEL_8:
v15 = v13;
v16 = v14;
v13 = v14;
v14 = v15 % v14;
}
while ( v14 );
goto LABEL_9;
}
}
else
{
v13 = v9;
v14 = v12 % v9;
if ( v12 % v9 )
goto LABEL_8;
}
v16 = v13;
LABEL_9:
++v10;
v9 = v12 * v9 / v16;
}
while ( v10 != (int *)v11 );
}
return (unsigned int)v9;
} | 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,R10D
MOV EAX,R8D
CDQ
IDIV ESI
MOV R8D,EAX
CMP R9D,0x2
JLE 0x0010139b
LEA EAX,[R9 + -0x3]
LEA R10,[RDI + 0x8]
LEA R9,[RDI + RAX*0x4 + 0xc]
NOP dword ptr [RAX]
LAB_00101360:
MOV EDI,dword ptr [R10]
CMP EDI,R8D
JL 0x001013a0
MOV EAX,EDI
MOV ECX,R8D
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013ac
NOP dword ptr [RAX]
LAB_00101378:
MOV EAX,ECX
MOV ESI,EDX
MOV ECX,EDX
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x00101378
LAB_00101385:
IMUL R8D,EDI
ADD R10,0x4
MOV EAX,R8D
CDQ
IDIV ESI
MOV R8D,EAX
CMP R10,R9
JNZ 0x00101360
LAB_0010139b:
MOV EAX,R8D
RET
LAB_001013a0:
MOV EAX,R8D
MOV ECX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101378
LAB_001013ac:
MOV ESI,ECX
JMP 0x00101385
LAB_001013b0:
MOV EAX,R8D
MOV ECX,R10D
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101330
LAB_001013c1:
MOV ESI,ECX
JMP 0x0010133d | 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;
iVar7 = iVar8;
}
else {
lVar2 = (long)iVar8 % (long)iVar1;
iVar4 = (int)lVar2;
iVar7 = iVar1;
}
while (iVar4 != 0) {
iVar5 = (int)lVar2;
lVar2 = (long)iVar7 % (long)iVar5;
iVar7 = iVar5;
iVar4 = (int)lVar2;
}
uVar3 = (long)(iVar1 * iVar8) % (long)iVar7;
uVar6 = (long)(iVar1 * iVar8) / (long)iVar7 & 0xffffffff;
if (2 < param_2) {
piVar9 = param_1 + 2;
do {
iVar1 = *piVar9;
iVar8 = (int)uVar6;
if (iVar1 < iVar8) {
uVar3 = (long)iVar8 % (long)iVar1;
iVar5 = (int)uVar3;
iVar7 = iVar1;
iVar4 = iVar1;
goto joined_r0x001013aa;
}
uVar3 = (long)iVar1 % (long)iVar8;
iVar5 = (int)uVar3;
iVar7 = iVar8;
while( true ) {
iVar4 = (int)uVar6;
joined_r0x001013aa:
if (iVar5 == 0) break;
uVar6 = uVar3 & 0xffffffff;
iVar7 = (int)uVar3;
uVar3 = (long)iVar4 % (long)iVar7;
iVar5 = (int)uVar3;
}
piVar9 = piVar9 + 1;
uVar3 = (long)(iVar8 * iVar1) % (long)iVar7;
uVar6 = (long)(iVar8 * iVar1) / (long)iVar7 & 0xffffffff;
} while (piVar9 != param_1 + (ulong)(param_2 - 3) + 3);
}
auVar10._8_8_ = uVar3 & 0xffffffff;
auVar10._0_8_ = uVar6;
return auVar10;
} |
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;
den = rem;
rem = num % den;
}
gcd = den;
lcm = (num1 * num2) / gcd;
return lcm;
}
| 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,%ecx
idiv %r8d
test %edx,%edx
jne 1300 <func0+0x30>
mov %r9d,%eax
cltd
idiv %r8d
mov %eax,%edi
cmp $0x2,%esi
jle 136b <func0+0x9b>
lea -0x3(%rsi),%eax
lea 0x8(%r10),%r8
lea 0xc(%r10,%rax,4),%r10
nopw 0x0(%rax,%rax,1)
mov (%r8),%esi
cmp %edi,%esi
jl 1370 <func0+0xa0>
mov %esi,%r9d
mov %edi,%ecx
mov %r9d,%eax
imul %esi,%edi
cltd
idiv %ecx
test %edx,%edx
je 1382 <func0+0xb2>
nopl 0x0(%rax)
mov %ecx,%eax
mov %edx,%ecx
cltd
idiv %ecx
test %edx,%edx
jne 1350 <func0+0x80>
mov %edi,%eax
cltd
idiv %ecx
mov %eax,%edi
add $0x4,%r8
cmp %r8,%r10
jne 1330 <func0+0x60>
mov %edi,%eax
retq
xchg %ax,%ax
mov %edi,%r9d
imul %esi,%edi
mov %esi,%ecx
mov %r9d,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1350 <func0+0x80>
mov %r9d,%edi
jmp 1362 <func0+0x92>
mov %r9d,%ecx
mov %r8d,%edi
jmpq 12ed <func0+0x1d>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| 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
cdq
idiv ecx
test edx, edx
jnz short loc_1300
mov eax, r8d
cdq
idiv ecx
mov edi, eax
loc_1313:
cmp esi, 2
jle short loc_1363
lea eax, [rsi-3]
lea r8, [r9+8]
lea r10, [r9+rax*4+0Ch]
nop dword ptr [rax+00h]
loc_1328:
mov esi, [r8]
cmp esi, edi
jge short loc_1370
mov r9d, edi
imul edi, esi
mov ecx, esi
mov eax, r9d
cdq
idiv ecx
test edx, edx
jz short loc_1382
nop dword ptr [rax+00000000h]
loc_1348:
mov eax, ecx
mov ecx, edx
cdq
idiv ecx
test edx, edx
jnz short loc_1348
mov eax, edi
cdq
idiv ecx
mov edi, eax
loc_135A:
add r8, 4
cmp r10, r8
jnz short loc_1328
loc_1363:
mov eax, edi
retn
loc_1370:
mov r9d, esi
mov ecx, edi
mov eax, r9d
imul edi, esi
cdq
idiv ecx
test edx, edx
jnz short loc_1348
loc_1382:
mov edi, r9d
jmp short loc_135A
loc_1387:
mov ecx, r8d
mov edi, r10d
jmp loc_12ED | 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;
v3 = a1[1];
if ( *a1 <= v3 )
{
v5 = *a1;
v6 = a1[1];
}
else
{
v5 = a1[1];
v6 = *a1;
}
v7 = v3 * v2;
v8 = v6 % v5;
if ( v6 % v5 )
{
do
{
v9 = v5;
v5 = v8;
v8 = v9 % v8;
}
while ( v8 );
v6 = v7 / v5;
}
if ( a2 > 2 )
{
v10 = a1 + 2;
v11 = (long long)&a1[a2 - 3 + 3];
do
{
v12 = *v10;
if ( *v10 >= v6 )
{
v13 = *v10;
v15 = v6;
v14 = v12 * v6;
v16 = v12 % v15;
if ( v12 % v15 )
{
do
{
LABEL_10:
v17 = v15;
v15 = v16;
v16 = v17 % v16;
}
while ( v16 );
v6 = v14 / v15;
goto LABEL_12;
}
}
else
{
v13 = v6;
v14 = v12 * v6;
v15 = *v10;
v16 = v13 % v12;
if ( v13 % v12 )
goto LABEL_10;
}
v6 = v13;
LABEL_12:
++v10;
}
while ( (int *)v11 != v10 );
}
return (unsigned int)v6;
} | 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 0x00101300
MOV EAX,R8D
CDQ
IDIV ECX
MOV EDI,EAX
LAB_00101313:
CMP ESI,0x2
JLE 0x00101363
LEA EAX,[RSI + -0x3]
LEA R8,[R9 + 0x8]
LEA R10,[R9 + RAX*0x4 + 0xc]
NOP dword ptr [RAX]
LAB_00101328:
MOV ESI,dword ptr [R8]
CMP ESI,EDI
JGE 0x00101370
MOV R9D,EDI
IMUL EDI,ESI
MOV ECX,ESI
MOV EAX,R9D
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101382
NOP dword ptr [RAX]
LAB_00101348:
MOV EAX,ECX
MOV ECX,EDX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101348
MOV EAX,EDI
CDQ
IDIV ECX
MOV EDI,EAX
LAB_0010135a:
ADD R8,0x4
CMP R10,R8
JNZ 0x00101328
LAB_00101363:
MOV EAX,EDI
RET
LAB_00101370:
MOV R9D,ESI
MOV ECX,EDI
MOV EAX,R9D
IMUL EDI,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101348
LAB_00101382:
MOV EDI,R9D
JMP 0x0010135a
LAB_00101387:
MOV ECX,R8D
MOV EDI,R10D
JMP 0x001012ed | 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 ((int)lVar3 != 0) {
do {
iVar4 = (int)lVar3;
lVar3 = (long)iVar5 % (long)iVar4;
iVar5 = iVar4;
} while ((int)lVar3 != 0);
iVar4 = (iVar1 * iVar2) / iVar4;
}
if (2 < param_2) {
piVar7 = param_1 + 2;
do {
iVar1 = *piVar7;
if (iVar1 < iVar4) {
lVar3 = (long)iVar4 % (long)iVar1;
iVar6 = (int)lVar3;
iVar2 = iVar4;
iVar5 = iVar1;
}
else {
lVar3 = (long)iVar1 % (long)iVar4;
iVar6 = (int)lVar3;
iVar2 = iVar1;
iVar5 = iVar4;
}
if (iVar6 != 0) {
do {
iVar2 = (int)lVar3;
lVar3 = (long)iVar5 % (long)iVar2;
iVar5 = iVar2;
} while ((int)lVar3 != 0);
iVar2 = (iVar4 * iVar1) / iVar2;
}
iVar4 = iVar2;
piVar7 = piVar7 + 1;
} while (param_1 + (ulong)(param_2 - 3) + 3 != piVar7);
}
return iVar4;
} |
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+0x30>
mov $0x1,%eax
jmp 117e <func0+0x35>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
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 short loc_1179
mov eax, 1
jmp short loc_117E
loc_1179:
mov eax, 0
loc_117E:
pop rbp
retn | _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,dword ptr [RBP + -0x4]
JZ 0x00101179
MOV EAX,0x1
JMP 0x0010117e
LAB_00101179:
MOV EAX,0x0
LAB_0010117e:
POP RBP
RET | 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] + 1;
}
}
}
for (i = 0; i <= n; i++) {
lds[i] = 1;
}
for (i = n-2; i >= 0; i--) {
for (j = n-1; j > i; j--) {
if (arr[i] > arr[j] && lds[i] < lds[j] + 1) {
lds[i] = lds[j] + 1;
}
}
}
maximum = lis[0] + lds[0] - 1;
for (i = 1; i < n; i++) {
if ((lis[i] + lds[i] - 1) > maximum) {
maximum = lis[i] + lds[i] - 1;
}
}
return maximum;
}
| 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(arr3, sizeof(arr3)/sizeof(arr3[0])) == 5);
printf("All tests passed.\n");
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 %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 %rdx,-0x48(%rbp)
movslq %eax,%rdx
mov %rdx,%r12
mov $0x0,%r13d
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 1230 <func0+0xa7>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1219 <func0+0x90>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 125a <func0+0xd1>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
mov -0x6c(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x38(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 12e6 <func0+0x15d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 12cf <func0+0x146>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1310 <func0+0x187>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x30(%rbp)
movl $0x0,-0x4c(%rbp)
jmp 1341 <func0+0x1b8>
mov -0x40(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
movl $0x1,(%rax,%rdx,4)
addl $0x1,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
cmp -0x6c(%rbp),%eax
jle 132c <func0+0x1a3>
movl $0x1,-0x4c(%rbp)
jmpq 13d9 <func0+0x250>
movl $0x0,-0x50(%rbp)
jmp 13cd <func0+0x244>
mov -0x4c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x68(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 13c9 <func0+0x240>
mov -0x40(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x40(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jl 13c9 <func0+0x240>
mov -0x40(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
lea 0x1(%rax),%ecx
mov -0x40(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x50(%rbp)
mov -0x50(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 135e <func0+0x1d5>
addl $0x1,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
cmp -0x6c(%rbp),%eax
jl 1355 <func0+0x1cc>
movl $0x0,-0x4c(%rbp)
jmp 1403 <func0+0x27a>
mov -0x30(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
movl $0x1,(%rax,%rdx,4)
addl $0x1,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
cmp -0x6c(%rbp),%eax
jle 13ee <func0+0x265>
mov -0x6c(%rbp),%eax
sub $0x2,%eax
mov %eax,-0x4c(%rbp)
jmpq 149f <func0+0x316>
mov -0x6c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x50(%rbp)
jmp 1493 <func0+0x30a>
mov -0x4c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x68(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x68(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 148f <func0+0x306>
mov -0x30(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x30(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jl 148f <func0+0x306>
mov -0x30(%rbp),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
lea 0x1(%rax),%ecx
mov -0x30(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
subl $0x1,-0x50(%rbp)
mov -0x50(%rbp),%eax
cmp -0x4c(%rbp),%eax
jg 1424 <func0+0x29b>
subl $0x1,-0x4c(%rbp)
cmpl $0x0,-0x4c(%rbp)
jns 1419 <func0+0x290>
mov -0x40(%rbp),%rax
mov (%rax),%edx
mov -0x30(%rbp),%rax
mov (%rax),%eax
add %edx,%eax
sub $0x1,%eax
mov %eax,-0x54(%rbp)
movl $0x1,-0x4c(%rbp)
jmp 1510 <func0+0x387>
mov -0x40(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x30(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %ecx,%eax
sub $0x1,%eax
cmp %eax,-0x54(%rbp)
jge 150c <func0+0x383>
mov -0x40(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x30(%rbp),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %ecx,%eax
sub $0x1,%eax
mov %eax,-0x54(%rbp)
addl $0x1,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
cmp -0x6c(%rbp),%eax
jl 14c6 <func0+0x33d>
mov -0x54(%rbp),%eax
mov %rsi,%rsp
mov -0x28(%rbp),%rsi
xor %fs:0x28,%rsi
je 1532 <func0+0x3a9>
callq 1080 <__stack_chk_fail@plt>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
| 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 rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11F9:
cmp rsp, rdx
jz short loc_1210
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_11F9
loc_1210:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_123A
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_123A:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov eax, [rbp+var_4C]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_1295:
cmp rsp, rdx
jz short loc_12AC
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_1295
loc_12AC:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12D6
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12D6:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_34], 0
jmp short loc_1307
loc_12F2:
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 1
add [rbp+var_34], 1
loc_1307:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_4C]
jle short loc_12F2
mov [rbp+var_34], 1
jmp loc_139F
loc_131B:
mov [rbp+var_30], 0
jmp short loc_1393
loc_1324:
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_30]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_138F
mov rax, [rbp+var_20]
mov edx, [rbp+var_30]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jl short loc_138F
mov rax, [rbp+var_20]
mov edx, [rbp+var_30]
movsxd rdx, edx
mov eax, [rax+rdx*4]
lea ecx, [rax+1]
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov [rax+rdx*4], ecx
loc_138F:
add [rbp+var_30], 1
loc_1393:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_34]
jl short loc_1324
add [rbp+var_34], 1
loc_139F:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_4C]
jl loc_131B
mov [rbp+var_34], 0
jmp short loc_13C9
loc_13B4:
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 1
add [rbp+var_34], 1
loc_13C9:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_4C]
jle short loc_13B4
mov eax, [rbp+var_4C]
sub eax, 2
mov [rbp+var_34], eax
jmp loc_1465
loc_13DF:
mov eax, [rbp+var_4C]
sub eax, 1
mov [rbp+var_30], eax
jmp short loc_1459
loc_13EA:
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_30]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_1455
mov rax, [rbp+var_10]
mov edx, [rbp+var_30]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jl short loc_1455
mov rax, [rbp+var_10]
mov edx, [rbp+var_30]
movsxd rdx, edx
mov eax, [rax+rdx*4]
lea ecx, [rax+1]
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov [rax+rdx*4], ecx
loc_1455:
sub [rbp+var_30], 1
loc_1459:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_34]
jg short loc_13EA
sub [rbp+var_34], 1
loc_1465:
cmp [rbp+var_34], 0
jns loc_13DF
mov rax, [rbp+var_20]
mov edx, [rax]
mov rax, [rbp+var_10]
mov eax, [rax]
add eax, edx
sub eax, 1
mov [rbp+var_2C], eax
mov [rbp+var_34], 1
jmp short loc_14D6
loc_148C:
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, ecx
sub eax, 1
cmp [rbp+var_2C], eax
jge short loc_14D2
mov rax, [rbp+var_20]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_34]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, ecx
sub eax, 1
mov [rbp+var_2C], eax
loc_14D2:
add [rbp+var_34], 1
loc_14D6:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_4C]
jl short loc_148C
mov eax, [rbp+var_2C]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_14F8
call ___stack_chk_fail
locret_14F8:
leave
retn | 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]
int v12; // [rsp+2Ch] [rbp-2Ch]
long long v13; // [rsp+30h] [rbp-28h]
_DWORD *v14; // [rsp+38h] [rbp-20h]
long long v15; // [rsp+40h] [rbp-18h]
_DWORD *v16; // [rsp+48h] [rbp-10h]
unsigned long long v17; // [rsp+50h] [rbp-8h]
v9 = a1;
v8 = a2;
v17 = __readfsqword(0x28u);
v13 = a2 + 1 - 1LL;
v2 = 16 * ((4LL * (a2 + 1) + 15) / 0x10uLL);
while ( v7 != &v7[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v2 & 0xFFF) - 8] = *(_QWORD *)&v7[(v2 & 0xFFF) - 8];
v14 = v7;
v15 = v8 + 1 - 1LL;
v4 = 16 * ((4LL * (v8 + 1) + 15) / 0x10uLL);
while ( v7 != &v7[-(v4 & 0xFFFFFFFFFFFFF000LL)] )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v4 & 0xFFF) - 8] = *(_QWORD *)&v7[(v4 & 0xFFF) - 8];
v16 = v7;
for ( i = 0; i <= v8; ++i )
v14[i] = 1;
for ( i = 1; i < v8; ++i )
{
for ( j = 0; j < i; ++j )
{
if ( *(_DWORD *)(4LL * i + v9) > *(_DWORD *)(4LL * j + v9) && v14[j] >= v14[i] )
v14[i] = v14[j] + 1;
}
}
for ( i = 0; i <= v8; ++i )
v16[i] = 1;
for ( i = v8 - 2; i >= 0; --i )
{
for ( j = v8 - 1; j > i; --j )
{
if ( *(_DWORD *)(4LL * i + v9) > *(_DWORD *)(4LL * j + v9) && v16[j] >= v16[i] )
v16[i] = v16[j] + 1;
}
}
v12 = *v14 + *v16 - 1;
for ( i = 1; i < v8; ++i )
{
if ( v12 < v14[i] + v16[i] - 1 )
v12 = v14[i] + v16[i] - 1;
}
return (unsigned int)v12;
} | 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 RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011f9:
CMP RSP,RDX
JZ 0x00101210
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011f9
LAB_00101210:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010123a
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010123a:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_00101295:
CMP RSP,RDX
JZ 0x001012ac
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101295
LAB_001012ac:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012d6
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012d6:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x34],0x0
JMP 0x00101307
LAB_001012f2:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x1
ADD dword ptr [RBP + -0x34],0x1
LAB_00101307:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x4c]
JLE 0x001012f2
MOV dword ptr [RBP + -0x34],0x1
JMP 0x0010139f
LAB_0010131b:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00101393
LAB_00101324:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010138f
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JL 0x0010138f
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LEA ECX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_0010138f:
ADD dword ptr [RBP + -0x30],0x1
LAB_00101393:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x00101324
ADD dword ptr [RBP + -0x34],0x1
LAB_0010139f:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x0010131b
MOV dword ptr [RBP + -0x34],0x0
JMP 0x001013c9
LAB_001013b4:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x1
ADD dword ptr [RBP + -0x34],0x1
LAB_001013c9:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x4c]
JLE 0x001013b4
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x2
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00101465
LAB_001013df:
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00101459
LAB_001013ea:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x00101455
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JL 0x00101455
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LEA ECX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_00101455:
SUB dword ptr [RBP + -0x30],0x1
LAB_00101459:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x34]
JG 0x001013ea
SUB dword ptr [RBP + -0x34],0x1
LAB_00101465:
CMP dword ptr [RBP + -0x34],0x0
JNS 0x001013df
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
SUB EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
MOV dword ptr [RBP + -0x34],0x1
JMP 0x001014d6
LAB_0010148c:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD EAX,ECX
SUB EAX,0x1
CMP dword ptr [RBP + -0x2c],EAX
JGE 0x001014d2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD EAX,ECX
SUB EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
LAB_001014d2:
ADD dword ptr [RBP + -0x34],0x1
LAB_001014d6:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x0010148c
MOV EAX,dword ptr [RBP + -0x2c]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014f8
CALL 0x00101080
LAB_001014f8:
LEAVE
RET | 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;
local_50 = param_1;
local_54 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = (long)(param_2 + 1) + -1;
uVar3 = (((long)(param_2 + 1) * 4 + 0xfU) / 0x10) * 0x10;
for (puVar4 = auStack_58; puVar4 != auStack_58 + -(uVar3 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
puVar5 = puVar4 + lVar1;
if ((uVar3 & 0xfff) != 0) {
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
local_28 = (int *)(puVar4 + lVar1);
local_20 = (long)(local_54 + 1) + -1;
uVar3 = (((long)(local_54 + 1) * 4 + 0xfU) / 0x10) * 0x10;
for (; puVar5 != puVar4 + (lVar1 - (uVar3 & 0xfffffffffffff000)); puVar5 = puVar5 + -0x1000) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)(puVar5 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar5 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
for (local_3c = 0; local_3c <= local_54; local_3c = local_3c + 1) {
local_28[local_3c] = 1;
}
for (local_3c = 1; local_3c < local_54; local_3c = local_3c + 1) {
for (local_38 = 0; local_38 < local_3c; local_38 = local_38 + 1) {
if ((*(int *)(local_50 + (long)local_38 * 4) < *(int *)(local_50 + (long)local_3c * 4)) &&
(local_28[local_3c] <= local_28[local_38])) {
local_28[local_3c] = local_28[local_38] + 1;
}
}
}
for (local_3c = 0; local_3c <= local_54; local_3c = local_3c + 1) {
*(int4 *)(puVar5 + (long)local_3c * 4 + lVar1) = 1;
}
for (local_3c = local_54 + -2; iVar2 = local_54, -1 < local_3c; local_3c = local_3c + -1) {
while (local_38 = iVar2 + -1, local_3c < local_38) {
iVar2 = local_38;
if ((*(int *)(local_50 + (long)local_38 * 4) < *(int *)(local_50 + (long)local_3c * 4)) &&
(*(int *)(puVar5 + (long)local_3c * 4 + lVar1) <=
*(int *)(puVar5 + (long)local_38 * 4 + lVar1))) {
*(int *)(puVar5 + (long)local_3c * 4 + lVar1) =
*(int *)(puVar5 + (long)local_38 * 4 + lVar1) + 1;
}
}
}
local_34 = *(int *)(puVar5 + lVar1) + *local_28 + -1;
for (local_3c = 1; local_3c < local_54; local_3c = local_3c + 1) {
if (local_34 < *(int *)(puVar5 + (long)local_3c * 4 + lVar1) + local_28[local_3c] + -1) {
local_34 = *(int *)(puVar5 + (long)local_3c * 4 + lVar1) + local_28[local_3c] + -1;
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_34;
}
local_18 = puVar5 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
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] + 1;
}
}
}
for (i = 0; i <= n; i++) {
lds[i] = 1;
}
for (i = n-2; i >= 0; i--) {
for (j = n-1; j > i; j--) {
if (arr[i] > arr[j] && lds[i] < lds[j] + 1) {
lds[i] = lds[j] + 1;
}
}
}
maximum = lis[0] + lds[0] - 1;
for (i = 1; i < n; i++) {
if ((lis[i] + lds[i] - 1) > maximum) {
maximum = lis[i] + lds[i] - 1;
}
}
return maximum;
}
| 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(arr3, sizeof(arr3)/sizeof(arr3[0])) == 5);
printf("All tests passed.\n");
return 0;
}
| 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,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 11e4 <func0+0x5b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11cd <func0+0x44>
mov %rcx,%rdx
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
je 11fb <func0+0x72>
orq $0x0,-0x8(%rsp,%rdx,1)
lea 0x3(%rsp),%rdx
mov %rdx,%r10
shr $0x2,%r10
and $0xfffffffffffffffc,%rdx
mov %rdx,%r9
add $0xf,%rax
mov %rax,%rcx
and $0xfffffffffffffff0,%rcx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 123f <func0+0xb6>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1228 <func0+0x9f>
mov %rcx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1255 <func0+0xcc>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r8
mov %r8,%r11
shr $0x2,%r11
and $0xfffffffffffffffc,%r8
test %esi,%esi
js 12a1 <func0+0x118>
mov %rdx,%rax
mov %esi,%ecx
lea 0x4(%rdx,%rcx,4),%rdx
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1273 <func0+0xea>
mov $0x1,%edx
cmp $0x1,%esi
jg 12da <func0+0x151>
mov $0x0,%eax
movl $0x1,(%r8,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jge 1291 <func0+0x108>
mov %esi,%ecx
sub $0x2,%ecx
js 1321 <func0+0x198>
movslq %ecx,%rcx
lea -0x1(%rsi),%r13d
jmp 1311 <func0+0x188>
add $0x1,%rax
cmp %rdx,%rax
je 12d2 <func0+0x149>
cmp (%rdi,%rax,4),%ebx
jle 12b1 <func0+0x128>
mov (%r9,%rax,4),%ecx
cmp (%r9,%rdx,4),%ecx
jl 12b1 <func0+0x128>
add $0x1,%ecx
mov %ecx,(%r9,%rdx,4)
jmp 12b1 <func0+0x128>
add $0x1,%rdx
cmp %edx,%esi
jle 128c <func0+0x103>
test %edx,%edx
jle 12d2 <func0+0x149>
mov (%rdi,%rdx,4),%ebx
mov $0x0,%eax
jmp 12ba <func0+0x131>
sub $0x1,%rax
cmp %eax,%ebx
jge 1309 <func0+0x180>
cmp (%rdi,%rax,4),%r12d
jle 12e8 <func0+0x15f>
mov (%r8,%rax,4),%edx
cmp (%r8,%rcx,4),%edx
jl 12e8 <func0+0x15f>
add $0x1,%edx
mov %edx,(%r8,%rcx,4)
jmp 12e8 <func0+0x15f>
sub $0x1,%rcx
test %ecx,%ecx
js 1321 <func0+0x198>
mov %ecx,%ebx
cmp %r13d,%ecx
jge 1309 <func0+0x180>
mov (%rdi,%rcx,4),%r12d
movslq %r13d,%rax
jmp 12f0 <func0+0x167>
mov 0x0(,%r11,4),%ecx
add 0x0(,%r10,4),%ecx
sub $0x1,%ecx
cmp $0x1,%esi
jle 135e <func0+0x1d5>
lea -0x2(%rsi),%esi
add $0x2,%rsi
mov $0x1,%edx
mov (%r8,%rdx,4),%eax
add (%r9,%rdx,4),%eax
sub $0x1,%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0x1,%rdx
cmp %rdx,%rsi
jne 1345 <func0+0x1bc>
mov -0x28(%rbp),%rax
xor %fs:0x28,%rax
jne 137a <func0+0x1f1>
mov %ecx,%eax
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
callq 1080 <__stack_chk_fail@plt>
| 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, 0FFFFFFFFFFFFF000h
mov rsi, rsp
sub rsi, rdx
loc_11D0:
cmp rsp, rsi
jz short loc_11E7
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11D0
loc_11E7:
mov rdx, rdi
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jz short loc_11FE
or [rsp+rdx+30h+var_38], 0
loc_11FE:
lea r8, [rsp+30h+var_2D]
mov r10, r8
shr r10, 2
and r8, 0FFFFFFFFFFFFFFFCh
add rax, 0Fh
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rsi, rsp
sub rsi, rax
loc_1225:
cmp rsp, rsi
jz short loc_123C
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_1225
loc_123C:
mov rax, rdx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1252
or [rsp+rax+30h+var_38], 0
loc_1252:
lea rdi, [rsp+30h+var_2D]
mov r11, rdi
shr r11, 2
and rdi, 0FFFFFFFFFFFFFFFCh
test r9d, r9d
js short loc_12A1
mov rax, r8
lea edx, [r9+1]
lea rdx, [r8+rdx*4]
loc_1272:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_1272
mov edx, 1
cmp r9d, 1
jg short loc_12DC
loc_128C:
mov eax, 0
loc_1291:
mov dword ptr [rdi+rax*4], 1
add rax, 1
cmp r9d, eax
jge short loc_1291
loc_12A1:
mov esi, r9d
sub esi, 2
js short loc_1320
movsxd rsi, esi
lea r13d, [r9-1]
jmp short loc_1310
loc_12B2:
add rax, 1
cmp rax, rdx
jz short loc_12D3
loc_12BB:
cmp ebx, [rcx+rax*4]
jle short loc_12B2
mov esi, [r8+rax*4]
cmp esi, [r8+rdx*4]
jl short loc_12B2
add esi, 1
mov [r8+rdx*4], esi
jmp short loc_12B2
loc_12D3:
add rdx, 1
cmp r9d, edx
jle short loc_128C
loc_12DC:
test edx, edx
jle short loc_12D3
mov ebx, [rcx+rdx*4]
mov eax, 0
jmp short loc_12BB
loc_12EA:
sub rax, 1
cmp ebx, eax
jge short loc_1308
loc_12F2:
cmp r12d, [rcx+rax*4]
jle short loc_12EA
mov edx, [rdi+rax*4]
cmp edx, [rdi+rsi*4]
jl short loc_12EA
add edx, 1
mov [rdi+rsi*4], edx
jmp short loc_12EA
loc_1308:
sub rsi, 1
test esi, esi
js short loc_1320
loc_1310:
mov ebx, esi
cmp esi, r13d
jge short loc_1308
mov r12d, [rcx+rsi*4]
movsxd rax, r13d
jmp short loc_12F2
loc_1320:
mov ecx, ds:dword_0[r11*4]
add ecx, ds:dword_0[r10*4]
sub ecx, 1
cmp r9d, 1
jle short loc_1359
mov r9d, r9d
mov edx, 1
loc_1341:
mov eax, [rdi+rdx*4]
add eax, [r8+rdx*4]
sub eax, 1
cmp ecx, eax
cmovl ecx, eax
add rdx, 1
cmp r9, rdx
jnz short loc_1341
loc_1359:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_1375
mov eax, ecx
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_1375:
call ___stack_chk_fail | 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
long long v15; // rax
int v16; // esi
int v17; // ebx
long long v18; // rax
int v19; // edx
int v20; // r12d
int v21; // ecx
long long v22; // rdx
_DWORD v25[2]; // [rsp+8h] [rbp-30h] BYREF
unsigned long long v26; // [rsp+10h] [rbp-28h]
v26 = __readfsqword(0x28u);
v3 = 4LL * (a2 + 1);
while ( v25 != (_DWORD *)((char *)v25 - ((v3 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v4 = ((_WORD)v3 + 15) & 0xFF0;
v5 = alloca(v4);
if ( (((_WORD)v3 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v25[-2] + v4) = *(_QWORD *)((char *)&v25[-2] + v4);
v6 = v3 + 15;
v7 = v6 & 0xFFF0;
while ( v25 != (_DWORD *)((char *)v25 - (v6 & 0xFFFFFFFFFFFFF000LL)) )
;
v8 = v6 & 0xFF0;
v9 = alloca(v8);
if ( (v7 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v25[-2] + v8) = *(_QWORD *)((char *)&v25[-2] + v8);
if ( a2 >= 0 )
{
v10 = v25;
do
*v10++ = 1;
while ( v10 != &v25[a2 + 1] );
v11 = 1LL;
if ( a2 > 1 )
{
do
{
if ( (int)v11 > 0 )
{
v17 = *(_DWORD *)(a1 + 4 * v11);
v15 = 0LL;
do
{
if ( v17 > *(_DWORD *)(a1 + 4 * v15) )
{
v16 = v25[v15];
if ( v16 >= v25[v11] )
v25[v11] = v16 + 1;
}
++v15;
}
while ( v15 != v11 );
}
++v11;
}
while ( a2 > (int)v11 );
}
v12 = 0LL;
do
v25[v12++] = 1;
while ( a2 >= (int)v12 );
}
LODWORD(v13) = a2 - 2;
if ( a2 - 2 >= 0 )
{
v13 = (int)v13;
v14 = a2 - 1;
do
{
if ( (int)v13 < v14 )
{
v20 = *(_DWORD *)(a1 + 4 * v13);
v18 = v14;
do
{
if ( v20 > *(_DWORD *)(a1 + 4 * v18) )
{
v19 = v25[v18];
if ( v19 >= v25[v13] )
v25[v13] = v19 + 1;
}
--v18;
}
while ( (int)v13 < (int)v18 );
}
--v13;
}
while ( (int)v13 >= 0 );
}
v21 = 2 * v25[0] - 1;
if ( a2 > 1 )
{
v22 = 1LL;
do
{
if ( v21 < 2 * v25[v22] - 1 )
v21 = 2 * v25[v22] - 1;
++v22;
}
while ( a2 != v22 );
}
return (unsigned int)v21;
} | 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
JZ 0x001011e7
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d0
LAB_001011e7:
MOV RDX,RDI
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JZ 0x001011fe
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
LAB_001011fe:
LEA R8,[RSP + 0x3]
MOV R10,R8
SHR R10,0x2
AND R8,-0x4
ADD RAX,0xf
MOV RDX,RAX
AND RDX,-0x10
AND RAX,-0x1000
MOV RSI,RSP
SUB RSI,RAX
LAB_00101225:
CMP RSP,RSI
JZ 0x0010123c
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101225
LAB_0010123c:
MOV RAX,RDX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101252
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101252:
LEA RDI,[RSP + 0x3]
MOV R11,RDI
SHR R11,0x2
AND RDI,-0x4
TEST R9D,R9D
JS 0x001012a1
MOV RAX,R8
LEA EDX,[R9 + 0x1]
LEA RDX,[R8 + RDX*0x4]
LAB_00101272:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101272
MOV EDX,0x1
CMP R9D,0x1
JG 0x001012dc
LAB_0010128c:
MOV EAX,0x0
LAB_00101291:
MOV dword ptr [RDI + RAX*0x4],0x1
ADD RAX,0x1
CMP R9D,EAX
JGE 0x00101291
LAB_001012a1:
MOV ESI,R9D
SUB ESI,0x2
JS 0x00101320
MOVSXD RSI,ESI
LEA R13D,[R9 + -0x1]
JMP 0x00101310
LAB_001012b2:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x001012d3
LAB_001012bb:
CMP EBX,dword ptr [RCX + RAX*0x4]
JLE 0x001012b2
MOV ESI,dword ptr [R8 + RAX*0x4]
CMP ESI,dword ptr [R8 + RDX*0x4]
JL 0x001012b2
ADD ESI,0x1
MOV dword ptr [R8 + RDX*0x4],ESI
JMP 0x001012b2
LAB_001012d3:
ADD RDX,0x1
CMP R9D,EDX
JLE 0x0010128c
LAB_001012dc:
TEST EDX,EDX
JLE 0x001012d3
MOV EBX,dword ptr [RCX + RDX*0x4]
MOV EAX,0x0
JMP 0x001012bb
LAB_001012ea:
SUB RAX,0x1
CMP EBX,EAX
JGE 0x00101308
LAB_001012f2:
CMP R12D,dword ptr [RCX + RAX*0x4]
JLE 0x001012ea
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,dword ptr [RDI + RSI*0x4]
JL 0x001012ea
ADD EDX,0x1
MOV dword ptr [RDI + RSI*0x4],EDX
JMP 0x001012ea
LAB_00101308:
SUB RSI,0x1
TEST ESI,ESI
JS 0x00101320
LAB_00101310:
MOV EBX,ESI
CMP ESI,R13D
JGE 0x00101308
MOV R12D,dword ptr [RCX + RSI*0x4]
MOVSXD RAX,R13D
JMP 0x001012f2
LAB_00101320:
MOV ECX,dword ptr [R11*0x4]
ADD ECX,dword ptr [R10*0x4]
SUB ECX,0x1
CMP R9D,0x1
JLE 0x00101359
MOV R9D,R9D
MOV EDX,0x1
LAB_00101341:
MOV EAX,dword ptr [RDI + RDX*0x4]
ADD EAX,dword ptr [R8 + RDX*0x4]
SUB EAX,0x1
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0x1
CMP R9,RDX
JNZ 0x00101341
LAB_00101359:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101375
MOV EAX,ECX
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_00101375:
CALL 0x00101080 | 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;
uVar3 = lVar2 + 0xf;
for (puVar8 = auStack_38; puVar8 != auStack_38 + -(uVar3 & 0xfffffffffffff000);
puVar8 = puVar8 + -0x1000) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
puVar4 = (int4 *)(puVar8 + lVar1);
puVar9 = puVar8 + lVar1;
if (uVar3 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
uVar3 = lVar2 + 0xf;
for (; puVar9 != puVar8 + (lVar1 - (uVar3 & 0xfffffffffffff000)); puVar9 = puVar9 + -0x1000) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar2 = -uVar3;
if (uVar3 != 0) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
if (-1 < (int)param_2) {
do {
*puVar4 = 1;
puVar4 = puVar4 + 1;
} while (puVar4 != (int4 *)(puVar8 + (ulong)(param_2 + 1) * 4 + lVar1));
lVar7 = 1;
if (1 < (int)param_2) {
do {
if (0 < (int)lVar7) {
iVar6 = *(int *)(param_1 + lVar7 * 4);
lVar5 = 0;
do {
if ((*(int *)(param_1 + lVar5 * 4) < iVar6) &&
(*(int *)(puVar8 + lVar7 * 4 + lVar1) <= *(int *)(puVar8 + lVar5 * 4 + lVar1))) {
*(int *)(puVar8 + lVar7 * 4 + lVar1) = *(int *)(puVar8 + lVar5 * 4 + lVar1) + 1;
}
lVar5 = lVar5 + 1;
} while (lVar5 != lVar7);
}
lVar7 = lVar7 + 1;
} while ((int)lVar7 < (int)param_2);
}
lVar7 = 0;
do {
*(int4 *)(puVar9 + lVar7 * 4 + lVar2) = 1;
lVar7 = lVar7 + 1;
} while ((int)lVar7 <= (int)param_2);
}
if (-1 < (int)(param_2 - 2)) {
lVar7 = (long)(int)(param_2 - 2);
do {
if ((int)lVar7 < (int)(param_2 - 1)) {
iVar6 = *(int *)(param_1 + lVar7 * 4);
lVar5 = (long)(int)(param_2 - 1);
do {
if (*(int *)(param_1 + lVar5 * 4) < iVar6) {
if (*(int *)(puVar9 + lVar7 * 4 + lVar2) <= *(int *)(puVar9 + lVar5 * 4 + lVar2)) {
*(int *)(puVar9 + lVar7 * 4 + lVar2) = *(int *)(puVar9 + lVar5 * 4 + lVar2) + 1;
}
}
lVar5 = lVar5 + -1;
} while ((int)lVar7 < (int)lVar5);
}
lVar7 = lVar7 + -1;
} while (-1 < (int)lVar7);
}
iVar6 = *(int *)(puVar9 + lVar2) + *(int *)(puVar8 + lVar1) + -1;
if (1 < (int)param_2) {
uVar3 = 1;
do {
if (iVar6 < *(int *)(puVar9 + uVar3 * 4 + lVar2) + *(int *)(puVar8 + uVar3 * 4 + lVar1) + -1)
{
iVar6 = *(int *)(puVar9 + uVar3 * 4 + lVar2) + *(int *)(puVar8 + uVar3 * 4 + lVar1) + -1;
}
uVar3 = uVar3 + 1;
} while (param_2 != uVar3);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar6;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar9 + lVar2 + -8) = main;
__stack_chk_fail();
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.