index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
4,082 | func0 |
#include <assert.h>
| int func0(int A, int B) {
int variable = 1;
if (A == B) {
return 1;
} else if ((B - A) >= 5) {
return 0;
} else {
for (int i = A + 1; i <= B; i++) {
variable = (variable * (i % 10)) % 10;
}
return variable % 10;
}
}
| int main() {
assert(func0(2, 4) == 2);
assert(func0(6, 8) == 6);
assert(func0(1, 2) == 2);
assert(func0(3, 7) == 0);
assert(func0(20, 23) == 6);
assert(func0(1021, 1024) == 4);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
je 1330 <func0+0x20>
mov %esi,%eax
sub %edi,%eax
cmp $0x4,%eax
jle 1328 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax)
jmpq 12a0 <func0.part.0>
nopl (%rax)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
lea ecx, [rdi+1]
cmp ecx, esi
jg short loc_1300
lea edi, [rsi+1]
mov eax, 1
nop
loc_12B0:
movsxd rdx, ecx
mov esi, ecx
imul rdx, 66666667h
sar esi, 1Fh
sar rdx, 22h
sub edx, esi
lea esi, [rdx+rdx*4]
mov edx, ecx
add ecx, 1
add esi, esi
sub edx, esi
imul edx, eax
movsxd rax, edx
mov esi, edx
imul rax, 66666667h
sar esi, 1Fh
sar rax, 22h
sub eax, esi
lea esi, [rax+rax*4]
mov eax, edx
add esi, esi
sub eax, esi
cmp ecx, edi
jnz short loc_12B0
retn
loc_1300:
mov eax, 1
retn | long long func0_part_0(int a1, int a2)
{
int v2; // ecx
int v3; // edi
long long result; // rax
int v5; // esi
int v6; // edx
v2 = a1 + 1;
if ( a1 + 1 > a2 )
return 1LL;
v3 = a2 + 1;
LODWORD(result) = 1;
do
{
v5 = 5 * (v2 / 10);
v6 = v2++;
result = (unsigned int)((int)result * (v6 - 2 * v5) % 10);
}
while ( v2 != v3 );
return result;
} | func0.part.0:
LEA ECX,[RDI + 0x1]
CMP ECX,ESI
JG 0x00101300
LEA EDI,[RSI + 0x1]
MOV EAX,0x1
NOP
LAB_001012b0:
MOVSXD RDX,ECX
MOV ESI,ECX
IMUL RDX,RDX,0x66666667
SAR ESI,0x1f
SAR RDX,0x22
SUB EDX,ESI
LEA ESI,[RDX + RDX*0x4]
MOV EDX,ECX
ADD ECX,0x1
ADD ESI,ESI
SUB EDX,ESI
IMUL EDX,EAX
MOVSXD RAX,EDX
MOV ESI,EDX
IMUL RAX,RAX,0x66666667
SAR ESI,0x1f
SAR RAX,0x22
SUB EAX,ESI
LEA ESI,[RAX + RAX*0x4]
MOV EAX,EDX
ADD ESI,ESI
SUB EAX,ESI
CMP ECX,EDI
JNZ 0x001012b0
RET
LAB_00101300:
MOV EAX,0x1
RET | int func0_part_0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_1 + 1 <= param_2) {
iVar1 = 1;
iVar2 = param_1 + 1;
do {
iVar3 = iVar2 + 1;
iVar1 = ((iVar2 % 10) * iVar1) % 10;
iVar2 = iVar3;
} while (iVar3 != param_2 + 1);
return iVar1;
}
return 1;
} |
4,083 | func0 |
#include <assert.h>
| int func0(int A, int B) {
int variable = 1;
if (A == B) {
return 1;
} else if ((B - A) >= 5) {
return 0;
} else {
for (int i = A + 1; i <= B; i++) {
variable = (variable * (i % 10)) % 10;
}
return variable % 10;
}
}
| int main() {
assert(func0(2, 4) == 2);
assert(func0(6, 8) == 6);
assert(func0(1, 2) == 2);
assert(func0(3, 7) == 0);
assert(func0(20, 23) == 6);
assert(func0(1021, 1024) == 4);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
cmp %esi,%edi
je 1395 <func0+0x85>
mov %esi,%edx
xor %eax,%eax
sub %edi,%edx
cmp $0x4,%edx
jg 1395 <func0+0x85>
add $0x1,%edi
cmp %edi,%esi
jl 1390 <func0+0x80>
add $0x1,%esi
mov $0x1,%eax
nopw 0x0(%rax,%rax,1)
movslq %edi,%rdx
mov %edi,%ecx
imul $0x66666667,%rdx,%rdx
sar $0x1f,%ecx
sar $0x22,%rdx
sub %ecx,%edx
mov %edi,%ecx
add $0x1,%edi
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%ecx
mov %ecx,%edx
imul %eax,%edx
movslq %edx,%rax
mov %edx,%ecx
imul $0x66666667,%rax,%rax
sar $0x1f,%ecx
sar $0x22,%rax
sub %ecx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
cmp %esi,%edi
jne 1340 <func0+0x30>
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
lea ecx, [rdi+1]
cmp ecx, esi
jg short loc_1300
lea edi, [rsi+1]
mov eax, 1
nop
loc_12B0:
movsxd rdx, ecx
mov esi, ecx
imul rdx, 66666667h
sar esi, 1Fh
sar rdx, 22h
sub edx, esi
lea esi, [rdx+rdx*4]
mov edx, ecx
add ecx, 1
add esi, esi
sub edx, esi
imul edx, eax
movsxd rax, edx
mov esi, edx
imul rax, 66666667h
sar esi, 1Fh
sar rax, 22h
sub eax, esi
lea esi, [rax+rax*4]
mov eax, edx
add esi, esi
sub eax, esi
cmp ecx, edi
jnz short loc_12B0
retn
loc_1300:
mov eax, 1
retn | long long func0_part_0(int a1, int a2)
{
int v2; // ecx
int v3; // edi
long long result; // rax
int v5; // esi
int v6; // edx
v2 = a1 + 1;
if ( a1 + 1 > a2 )
return 1LL;
v3 = a2 + 1;
LODWORD(result) = 1;
do
{
v5 = 5 * (v2 / 10);
v6 = v2++;
result = (unsigned int)((int)result * (v6 - 2 * v5) % 10);
}
while ( v2 != v3 );
return result;
} | func0.part.0:
LEA ECX,[RDI + 0x1]
CMP ECX,ESI
JG 0x00101300
LEA EDI,[RSI + 0x1]
MOV EAX,0x1
NOP
LAB_001012b0:
MOVSXD RDX,ECX
MOV ESI,ECX
IMUL RDX,RDX,0x66666667
SAR ESI,0x1f
SAR RDX,0x22
SUB EDX,ESI
LEA ESI,[RDX + RDX*0x4]
MOV EDX,ECX
ADD ECX,0x1
ADD ESI,ESI
SUB EDX,ESI
IMUL EDX,EAX
MOVSXD RAX,EDX
MOV ESI,EDX
IMUL RAX,RAX,0x66666667
SAR ESI,0x1f
SAR RAX,0x22
SUB EAX,ESI
LEA ESI,[RAX + RAX*0x4]
MOV EAX,EDX
ADD ESI,ESI
SUB EAX,ESI
CMP ECX,EDI
JNZ 0x001012b0
RET
LAB_00101300:
MOV EAX,0x1
RET | int func0_part_0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_1 + 1 <= param_2) {
iVar1 = 1;
iVar2 = param_1 + 1;
do {
iVar3 = iVar2 + 1;
iVar1 = ((iVar2 % 10) * iVar1) % 10;
iVar2 = iVar3;
} while (iVar3 != param_2 + 1);
return iVar1;
}
return 1;
} |
4,084 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 0) {
res |= (1 << count);
}
count += 1;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 15);
assert(func0(20) == 21);
assert(func0(30) == 31);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 11ac <func0+0x43>
mov -0xc(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 11a5 <func0+0x3c>
mov -0xc(%rbp),%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
or %eax,-0x8(%rbp)
addl $0x1,-0xc(%rbp)
sarl -0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jg 118a <func0+0x21>
mov -0x14(%rbp),%eax
or -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
jmp short loc_11AC
loc_118A:
mov eax, [rbp+var_C]
and eax, 1
test eax, eax
jnz short loc_11A5
mov eax, [rbp+var_C]
mov edx, 1
mov ecx, eax
shl edx, cl
mov eax, edx
or [rbp+var_8], eax
loc_11A5:
add [rbp+var_C], 1
sar [rbp+var_4], 1
loc_11AC:
cmp [rbp+var_4], 0
jg short loc_118A
mov eax, [rbp+var_14]
or eax, [rbp+var_8]
pop rbp
retn | long long func0(int a1)
{
char v2; // [rsp+8h] [rbp-Ch]
int v3; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
v3 = 0;
for ( i = a1; i > 0; i >>= 1 )
{
if ( (v2 & 1) == 0 )
v3 |= 1 << v2;
++v2;
}
return v3 | (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011ac
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011a5
MOV EAX,dword ptr [RBP + -0xc]
MOV EDX,0x1
MOV ECX,EAX
SHL EDX,CL
MOV EAX,EDX
OR dword ptr [RBP + -0x8],EAX
LAB_001011a5:
ADD dword ptr [RBP + -0xc],0x1
SAR dword ptr [RBP + -0x4],0x1
LAB_001011ac:
CMP dword ptr [RBP + -0x4],0x0
JG 0x0010118a
MOV EAX,dword ptr [RBP + -0x14]
OR EAX,dword ptr [RBP + -0x8]
POP RBP
RET | uint func0(uint param_1)
{
byte bVar1;
int4 local_10;
int4 local_c;
bVar1 = 0;
local_10 = 0;
for (local_c = param_1; 0 < (int)local_c; local_c = (int)local_c >> 1) {
if (!(bool)(bVar1 & 1)) {
local_10 = local_10 | 1 << (bVar1 & 0x1f);
}
bVar1 = bVar1 + 1;
}
return param_1 | local_10;
} |
4,085 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 0) {
res |= (1 << count);
}
count += 1;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 15);
assert(func0(20) == 21);
assert(func0(30) == 31);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 119c <func0+0x33>
mov %edi,%edx
mov $0x0,%eax
mov $0x0,%ecx
mov $0x1,%r8d
jmp 118e <func0+0x25>
add $0x1,%ecx
sar %edx
test %edx,%edx
jle 11a1 <func0+0x38>
test $0x1,%cl
jne 1185 <func0+0x1c>
mov %r8d,%esi
shl %cl,%esi
or %esi,%eax
jmp 1185 <func0+0x1c>
mov $0x0,%eax
or %edi,%eax
retq
| func0:
endbr64
mov eax, edi
test edi, edi
jle short loc_119F
mov edx, edi
mov esi, 0
mov ecx, 0
mov edi, 1
jmp short loc_118F
loc_1186:
add ecx, 1
sar edx, 1
test edx, edx
jle short loc_11A4
loc_118F:
test cl, 1
jnz short loc_1186
mov r8d, edi
shl r8d, cl
or esi, r8d
jmp short loc_1186
loc_119F:
mov esi, 0
loc_11A4:
or eax, esi
retn | long long func0(int a1)
{
int v1; // edx
int v2; // esi
char v3; // cl
if ( a1 <= 0 )
{
v2 = 0;
}
else
{
v1 = a1;
v2 = 0;
v3 = 0;
do
{
if ( (v3 & 1) == 0 )
v2 |= 1 << v3;
++v3;
v1 >>= 1;
}
while ( v1 > 0 );
}
return v2 | (unsigned int)a1;
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JLE 0x0010119f
MOV EDX,EDI
MOV ESI,0x0
MOV ECX,0x0
MOV EDI,0x1
JMP 0x0010118f
LAB_00101186:
ADD ECX,0x1
SAR EDX,0x1
TEST EDX,EDX
JLE 0x001011a4
LAB_0010118f:
TEST CL,0x1
JNZ 0x00101186
MOV R8D,EDI
SHL R8D,CL
OR ESI,R8D
JMP 0x00101186
LAB_0010119f:
MOV ESI,0x0
LAB_001011a4:
OR EAX,ESI
RET | uint func0(uint param_1)
{
bool bVar1;
uint uVar2;
uint uVar3;
if ((int)param_1 < 1) {
uVar3 = 0;
}
else {
uVar3 = 0;
bVar1 = false;
uVar2 = param_1;
do {
if (!bVar1) {
uVar3 = uVar3 | 1 << bVar1;
}
bVar1 = (bool)(bVar1 ^ 1);
uVar2 = (int)uVar2 >> 1;
} while (0 < (int)uVar2);
}
return param_1 | uVar3;
} |
4,086 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 0) {
res |= (1 << count);
}
count += 1;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 15);
assert(func0(20) == 21);
assert(func0(30) == 31);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 11a0 <func0+0x30>
mov %edi,%edx
xor %eax,%eax
xor %ecx,%ecx
mov $0x1,%r8d
nopl 0x0(%rax)
test $0x1,%cl
jne 1194 <func0+0x24>
mov %r8d,%esi
shl %cl,%esi
or %esi,%eax
add $0x1,%ecx
sar %edx
jne 1188 <func0+0x18>
or %edi,%eax
retq
xchg %ax,%ax
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test edi, edi
jle short loc_1250
mov edx, edi
xor eax, eax
xor ecx, ecx
mov r8d, 1
nop dword ptr [rax+00h]
loc_1238:
test cl, 1
jnz short loc_1244
mov esi, r8d
shl esi, cl
or eax, esi
loc_1244:
add ecx, 1
sar edx, 1
jnz short loc_1238
or eax, edi
retn
loc_1250:
mov eax, edi
retn | long long func0(int a1)
{
int v1; // edx
unsigned int v2; // eax
char v3; // cl
if ( a1 <= 0 )
return (unsigned int)a1;
v1 = a1;
v2 = 0;
v3 = 0;
do
{
if ( (v3 & 1) == 0 )
v2 |= 1 << v3;
++v3;
v1 >>= 1;
}
while ( v1 );
return a1 | v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101250
MOV EDX,EDI
XOR EAX,EAX
XOR ECX,ECX
MOV R8D,0x1
NOP dword ptr [RAX]
LAB_00101238:
TEST CL,0x1
JNZ 0x00101244
MOV ESI,R8D
SHL ESI,CL
OR EAX,ESI
LAB_00101244:
ADD ECX,0x1
SAR EDX,0x1
JNZ 0x00101238
OR EAX,EDI
RET
LAB_00101250:
MOV EAX,EDI
RET | uint func0(uint param_1)
{
byte bVar1;
uint uVar2;
uint uVar3;
if (0 < (int)param_1) {
uVar2 = 0;
bVar1 = 0;
uVar3 = param_1;
do {
if (!(bool)(bVar1 & 1)) {
uVar2 = uVar2 | 1 << (bVar1 & 0x1f);
}
bVar1 = bVar1 + 1;
uVar3 = (int)uVar3 >> 1;
} while (uVar3 != 0);
return uVar2 | param_1;
}
return param_1;
} |
4,087 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int count = 0;
int res = 0;
int temp = n;
while (temp > 0) {
if (count % 2 == 0) {
res |= (1 << count);
}
count += 1;
temp >>= 1;
}
return (n | res);
}
| int main() {
assert(func0(10) == 15);
assert(func0(20) == 21);
assert(func0(30) == 31);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 11a0 <func0+0x30>
mov %edi,%edx
xor %eax,%eax
xor %ecx,%ecx
mov $0x1,%r8d
nopl 0x0(%rax)
test $0x1,%cl
jne 1194 <func0+0x24>
mov %r8d,%esi
shl %cl,%esi
or %esi,%eax
add $0x1,%ecx
sar %edx
jne 1188 <func0+0x18>
or %edi,%eax
retq
xchg %ax,%ax
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test edi, edi
jle short loc_11A8
mov edx, edi
xor esi, esi
xor ecx, ecx
mov eax, 1
nop dword ptr [rax+rax+00h]
loc_1188:
test cl, 1
jnz short loc_1196
mov r8d, eax
shl r8d, cl
or esi, r8d
loc_1196:
add ecx, 1
sar edx, 1
jnz short loc_1188
mov eax, edi
or eax, esi
retn
loc_11A8:
mov eax, edi
retn | long long func0(int a1)
{
int v1; // edx
int v2; // esi
char v3; // cl
if ( a1 <= 0 )
return (unsigned int)a1;
v1 = a1;
v2 = 0;
v3 = 0;
do
{
if ( (v3 & 1) == 0 )
v2 |= 1 << v3;
++v3;
v1 >>= 1;
}
while ( v1 );
return v2 | (unsigned int)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011a8
MOV EDX,EDI
XOR ESI,ESI
XOR ECX,ECX
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101188:
TEST CL,0x1
JNZ 0x00101196
MOV R8D,EAX
SHL R8D,CL
OR ESI,R8D
LAB_00101196:
ADD ECX,0x1
SAR EDX,0x1
JNZ 0x00101188
MOV EAX,EDI
OR EAX,ESI
RET
LAB_001011a8:
MOV EAX,EDI
RET | uint func0(uint param_1)
{
byte bVar1;
uint uVar2;
uint uVar3;
if (0 < (int)param_1) {
uVar3 = 0;
bVar1 = 0;
uVar2 = param_1;
do {
if (!(bool)(bVar1 & 1)) {
uVar3 = uVar3 | 1 << (bVar1 & 0x1f);
}
bVar1 = bVar1 + 1;
uVar2 = (int)uVar2 >> 1;
} while (uVar2 != 0);
return param_1 | uVar3;
}
return param_1;
} |
4,088 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int nums[][4], int rowCount, int N, int* result) {
for (int i = 0; i < rowCount; i++) {
result[i] = nums[i][N];
}
return result;
}
| int main() {
int nums1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums2[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums3[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int result1[3], result2[3], result3[3];
int expected1[3] = {1, 4, 7};
int expected2[3] = {3, 6, 9};
int expected3[3] = {2, 5, 1};
func0(nums1, 3, 0, result1);
func0(nums2, 3, 2, result2);
func0(nums3, 3, 1, result3);
for (int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
assert(result2[i] == expected2[i]);
assert(result3[i] == expected3[i]);
}
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11de <func0+0x55>
mov -0x4(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
cltq
mov (%rcx,%rax,4),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11a8 <func0+0x1f>
mov -0x28(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_4], 0
jmp short loc_11DE
loc_11A8:
mov eax, [rbp+var_4]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_20]
cdqe
mov eax, [rcx+rax*4]
mov [rdx], eax
add [rbp+var_4], 1
loc_11DE:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11A8
mov rax, [rbp+var_28]
pop rbp
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
int i; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2; ++i )
*(_DWORD *)(a4 + 4LL * i) = *(_DWORD *)(16LL * i + a1 + 4LL * a3);
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011de
LAB_001011a8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011de:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011a8
MOV RAX,qword ptr [RBP + -0x28]
POP RBP
RET | long func0(long param_1,int param_2,int param_3,long param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(int4 *)((long)local_c * 4 + param_4) =
*(int4 *)((long)local_c * 0x10 + param_1 + (long)param_3 * 4);
}
return param_4;
} |
4,089 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int nums[][4], int rowCount, int N, int* result) {
for (int i = 0; i < rowCount; i++) {
result[i] = nums[i][N];
}
return result;
}
| int main() {
int nums1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums2[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums3[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int result1[3], result2[3], result3[3];
int expected1[3] = {1, 4, 7};
int expected2[3] = {3, 6, 9};
int expected3[3] = {2, 5, 1};
func0(nums1, 3, 0, result1);
func0(nums2, 3, 2, result2);
func0(nums3, 3, 1, result3);
for (int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
assert(result2[i] == expected2[i]);
assert(result3[i] == expected3[i]);
}
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
mov %rcx,%rax
test %esi,%esi
jle 11b7 <func0+0x2e>
movslq %edx,%rdx
lea (%rdi,%rdx,4),%rdi
mov %rcx,%rdx
lea -0x1(%rsi),%ecx
lea 0x4(%rax,%rcx,4),%r8
mov (%rdi),%esi
mov %esi,(%rdx)
add $0x10,%rdi
add $0x4,%rdx
cmp %r8,%rdx
jne 11a6 <func0+0x1d>
retq
| func0:
endbr64
mov rax, rcx
test esi, esi
jle short locret_11B7
movsxd rdx, edx
lea rdi, [rdi+rdx*4]
mov rdx, rcx
lea ecx, [rsi-1]
lea r8, [rax+rcx*4+4]
loc_11A6:
mov esi, [rdi]
mov [rdx], esi
add rdi, 10h
add rdx, 4
cmp rdx, r8
jnz short loc_11A6
locret_11B7:
retn | _DWORD * func0(long long a1, int a2, int a3, _DWORD *a4)
{
_DWORD *result; // rax
_DWORD *v5; // rdi
_DWORD *v6; // rdx
result = a4;
if ( a2 > 0 )
{
v5 = (_DWORD *)(a1 + 4LL * a3);
v6 = a4;
do
{
*v6 = *v5;
v5 += 4;
++v6;
}
while ( v6 != &a4[a2 - 1 + 1] );
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST ESI,ESI
JLE 0x001011b7
MOVSXD RDX,EDX
LEA RDI,[RDI + RDX*0x4]
MOV RDX,RCX
LEA ECX,[RSI + -0x1]
LEA R8,[RAX + RCX*0x4 + 0x4]
LAB_001011a6:
MOV ESI,dword ptr [RDI]
MOV dword ptr [RDX],ESI
ADD RDI,0x10
ADD RDX,0x4
CMP RDX,R8
JNZ 0x001011a6
LAB_001011b7:
RET | void func0(long param_1,int param_2,int param_3,int4 *param_4)
{
int4 *puVar1;
int4 *puVar2;
if (0 < param_2) {
puVar2 = (int4 *)(param_1 + (long)param_3 * 4);
puVar1 = param_4 + (ulong)(param_2 - 1) + 1;
do {
*param_4 = *puVar2;
puVar2 = puVar2 + 4;
param_4 = param_4 + 1;
} while (param_4 != puVar1);
}
return;
} |
4,090 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int nums[][4], int rowCount, int N, int* result) {
for (int i = 0; i < rowCount; i++) {
result[i] = nums[i][N];
}
return result;
}
| int main() {
int nums1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums2[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums3[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int result1[3], result2[3], result3[3];
int expected1[3] = {1, 4, 7};
int expected2[3] = {3, 6, 9};
int expected3[3] = {2, 5, 1};
func0(nums1, 3, 0, result1);
func0(nums2, 3, 2, result2);
func0(nums3, 3, 1, result3);
for (int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
assert(result2[i] == expected2[i]);
assert(result3[i] == expected3[i]);
}
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
mov %rcx,%rax
test %esi,%esi
jle 1302 <func0+0x32>
movslq %edx,%rdx
lea (%rdi,%rdx,4),%rdi
mov %rcx,%rdx
lea -0x1(%rsi),%ecx
lea 0x4(%rax,%rcx,4),%r8
nopl (%rax)
mov (%rdi),%esi
add $0x4,%rdx
add $0x10,%rdi
mov %esi,-0x4(%rdx)
cmp %r8,%rdx
jne 12f0 <func0+0x20>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov rax, rcx
test esi, esi
jle short locret_1302
movsxd rdx, edx
lea rdi, [rdi+rdx*4]
mov rdx, rcx
lea ecx, [rsi-1]
lea r8, [rax+rcx*4+4]
nop dword ptr [rax]
loc_12F0:
mov esi, [rdi]
add rdx, 4
add rdi, 10h
mov [rdx-4], esi
cmp rdx, r8
jnz short loc_12F0
locret_1302:
retn | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
int *v5; // rdi
long long v6; // rdx
long long v7; // r8
int v8; // esi
result = a4;
if ( a2 > 0 )
{
v5 = (int *)(a1 + 4LL * a3);
v6 = a4;
v7 = a4 + 4LL * (unsigned int)(a2 - 1) + 4;
do
{
v8 = *v5;
v6 += 4LL;
v5 += 4;
*(_DWORD *)(v6 - 4) = v8;
}
while ( v6 != v7 );
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST ESI,ESI
JLE 0x00101302
MOVSXD RDX,EDX
LEA RDI,[RDI + RDX*0x4]
MOV RDX,RCX
LEA ECX,[RSI + -0x1]
LEA R8,[RAX + RCX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_001012f0:
MOV ESI,dword ptr [RDI]
ADD RDX,0x4
ADD RDI,0x10
MOV dword ptr [RDX + -0x4],ESI
CMP RDX,R8
JNZ 0x001012f0
LAB_00101302:
RET | void func0(long param_1,int param_2,int param_3,int4 *param_4)
{
int4 uVar1;
int4 *puVar2;
int4 *puVar3;
int4 *puVar4;
if (0 < param_2) {
puVar4 = (int4 *)(param_1 + (long)param_3 * 4);
puVar2 = param_4;
do {
uVar1 = *puVar4;
puVar3 = puVar2 + 1;
puVar4 = puVar4 + 4;
*puVar2 = uVar1;
puVar2 = puVar3;
} while (puVar3 != param_4 + (ulong)(param_2 - 1) + 1);
}
return;
} |
4,091 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int nums[][4], int rowCount, int N, int* result) {
for (int i = 0; i < rowCount; i++) {
result[i] = nums[i][N];
}
return result;
}
| int main() {
int nums1[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums2[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int nums3[][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}};
int result1[3], result2[3], result3[3];
int expected1[3] = {1, 4, 7};
int expected2[3] = {3, 6, 9};
int expected3[3] = {2, 5, 1};
func0(nums1, 3, 0, result1);
func0(nums2, 3, 2, result2);
func0(nums3, 3, 1, result3);
for (int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
assert(result2[i] == expected2[i]);
assert(result3[i] == expected3[i]);
}
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
mov %rcx,%rax
test %esi,%esi
jle 1292 <func0+0x122>
movslq %esi,%r8
movslq %edx,%rcx
lea -0x1(%rsi),%r10d
lea -0x3(%rcx,%r8,4),%r9
lea (%rdi,%rcx,4),%rdx
lea (%rdi,%r9,4),%r9
lea (%rax,%r8,4),%r8
cmp %r9,%rax
setae %r9b
cmp %r8,%rdx
setae %r8b
or %r8b,%r9b
je 1278 <func0+0x108>
cmp $0x5,%r10d
jbe 1278 <func0+0x108>
mov %r10d,%r9d
mov %rax,%r8
shr $0x2,%r9d
shl $0x6,%r9
add %rdx,%r9
nopl 0x0(%rax)
movdqu (%rdx),%xmm0
movdqu 0x10(%rdx),%xmm2
add $0x40,%rdx
add $0x10,%r8
movdqu -0x20(%rdx),%xmm1
movdqu -0x10(%rdx),%xmm3
shufps $0x88,%xmm2,%xmm0
shufps $0x88,%xmm3,%xmm1
shufps $0x88,%xmm1,%xmm0
movups %xmm0,-0x10(%r8)
cmp %r9,%rdx
jne 11d0 <func0+0x60>
mov %r10d,%edx
and $0xfffffffc,%edx
mov %edx,%r9d
mov %r9,%r8
shl $0x4,%r8
add %rdi,%r8
mov (%r8,%rcx,4),%r8d
mov %r8d,(%rax,%r9,4)
lea 0x1(%rdx),%r8d
cmp %r8d,%esi
jle 1292 <func0+0x122>
movslq %r8d,%r8
mov %r8,%r9
shl $0x4,%r9
add %rdi,%r9
mov (%r9,%rcx,4),%r9d
mov %r9d,(%rax,%r8,4)
lea 0x2(%rdx),%r8d
cmp %r8d,%esi
jle 1292 <func0+0x122>
movslq %r8d,%r8
add $0x3,%edx
mov %r8,%r9
shl $0x4,%r9
add %rdi,%r9
mov (%r9,%rcx,4),%r9d
mov %r9d,(%rax,%r8,4)
cmp %edx,%esi
jle 1292 <func0+0x122>
movslq %edx,%rdx
mov %rdx,%rsi
shl $0x4,%rsi
add %rsi,%rdi
mov (%rdi,%rcx,4),%ecx
mov %ecx,(%rax,%rdx,4)
retq
nopl 0x0(%rax,%rax,1)
mov %rax,%rsi
lea 0x4(%rax,%r10,4),%rdi
mov (%rdx),%ecx
add $0x4,%rsi
add $0x10,%rdx
mov %ecx,-0x4(%rsi)
cmp %rdi,%rsi
jne 1280 <func0+0x110>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov r8, rdi
mov edi, esi
mov rsi, rcx
test edi, edi
jle loc_12A0
lea r9d, [rdi-1]
push rbx
movsxd r11, edi
cmp r9d, 3
jbe loc_1290
movsxd rdx, edx
lea rcx, ds:0[r11*4]
lea rbx, [rcx+rdx]
lea r10, ds:0[rdx*4]
lea rbx, [r8+rbx*4-0Ch]
lea rax, [r8+r10]
cmp rsi, rbx
jnb short loc_11F0
add rcx, rsi
cmp rax, rcx
jnb short loc_11F0
loc_11C3:
lea rdx, [r8+rdx*4]
mov rax, rsi
lea rdi, [rsi+r11*4]
xchg ax, ax
loc_11D0:
mov ecx, [rdx]
add rax, 4
add rdx, 10h
mov [rax-4], ecx
cmp rdi, rax
jnz short loc_11D0
loc_11E2:
mov rax, rsi
pop rbx
retn
loc_11F0:
mov ecx, r9d
mov rdx, rsi
shr ecx, 2
shl rcx, 6
add rcx, rax
loc_1200:
movdqu xmm0, xmmword ptr [rax]
movdqu xmm2, xmmword ptr [rax+10h]
add rax, 40h ; '@'
add rdx, 10h
movdqu xmm1, xmmword ptr [rax-20h]
movdqu xmm3, xmmword ptr [rax-10h]
shufps xmm0, xmm2, 88h
shufps xmm1, xmm3, 88h
shufps xmm0, xmm1, 88h
movups xmmword ptr [rdx-10h], xmm0
cmp rax, rcx
jnz short loc_1200
and r9d, 0FFFFFFFCh
movsxd rdx, r9d
mov rax, rdx
lea rcx, ds:0[rdx*4]
shl rax, 4
add rax, r8
add rax, r10
mov r8d, [rax]
mov [rsi+rdx*4], r8d
lea edx, [r9+1]
cmp edi, edx
jle short loc_11E2
mov edx, [rax+10h]
mov [rsi+rcx+4], edx
lea edx, [r9+2]
cmp edx, edi
jge loc_11E2
mov edx, [rax+20h]
add r9d, 3
mov [rsi+rcx+8], edx
cmp edi, r9d
jle loc_11E2
mov eax, [rax+30h]
mov [rsi+rcx+0Ch], eax
mov rax, rsi
pop rbx
retn
loc_1290:
movsxd rdx, edx
jmp loc_11C3
loc_12A0:
mov rax, rcx
retn | unsigned long long func0(long long a1, int a2, long long a3, unsigned long long a4)
{
unsigned int v7; // r9d
long long v8; // r10
const __m128i *v9; // rax
int *v10; // rdx
unsigned long long v11; // rax
unsigned long long v12; // rdi
int v13; // ecx
unsigned long long v15; // rdx
const __m128i *v16; // rcx
__m128 v17; // xmm0
__m128 v18; // xmm2
signed int v19; // r9d
long long v20; // rcx
_DWORD *v21; // rax
if ( a2 <= 0 )
return a4;
v7 = a2 - 1;
if ( (unsigned int)(a2 - 1) <= 3 )
{
a3 = (int)a3;
LABEL_5:
v10 = (int *)(a1 + 4 * a3);
v11 = a4;
v12 = a4 + 4LL * a2;
do
{
v13 = *v10;
v11 += 4LL;
v10 += 4;
*(_DWORD *)(v11 - 4) = v13;
}
while ( v12 != v11 );
return a4;
}
a3 = (int)a3;
v8 = 4LL * (int)a3;
v9 = (const __m128i *)(a1 + v8);
if ( a4 < a1 + 4 * (4LL * a2 + (int)a3) - 12 && (unsigned long long)v9 < a4 + 4LL * a2 )
goto LABEL_5;
v15 = a4;
v16 = &v9[4 * (unsigned long long)(v7 >> 2)];
do
{
v17 = (__m128)_mm_loadu_si128(v9);
v18 = (__m128)_mm_loadu_si128(v9 + 1);
v9 += 4;
v15 += 16LL;
*(__m128 *)(v15 - 16) = _mm_shuffle_ps(
_mm_shuffle_ps(v17, v18, 136),
_mm_shuffle_ps((__m128)_mm_loadu_si128(v9 - 2), (__m128)_mm_loadu_si128(v9 - 1), 136),
136);
}
while ( v9 != v16 );
v19 = v7 & 0xFFFFFFFC;
v20 = 4LL * v19;
v21 = (_DWORD *)(v8 + a1 + 16LL * v19);
*(_DWORD *)(a4 + v20) = *v21;
if ( a2 <= v19 + 1 )
return a4;
*(_DWORD *)(a4 + v20 + 4) = v21[4];
if ( v19 + 2 >= a2 )
return a4;
*(_DWORD *)(a4 + v20 + 8) = v21[8];
if ( a2 <= v19 + 3 )
return a4;
*(_DWORD *)(a4 + v20 + 12) = v21[12];
return a4;
} | func0:
ENDBR64
MOV R8,RDI
MOV EDI,ESI
MOV RSI,RCX
TEST EDI,EDI
JLE 0x001012a0
LEA R9D,[RDI + -0x1]
PUSH RBX
MOVSXD R11,EDI
CMP R9D,0x3
JBE 0x00101290
MOVSXD RDX,EDX
LEA RCX,[R11*0x4]
LEA RBX,[RCX + RDX*0x1]
LEA R10,[RDX*0x4]
LEA RBX,[R8 + RBX*0x4 + -0xc]
LEA RAX,[R8 + R10*0x1]
CMP RSI,RBX
JNC 0x001011f0
ADD RCX,RSI
CMP RAX,RCX
JNC 0x001011f0
LAB_001011c3:
LEA RDX,[R8 + RDX*0x4]
MOV RAX,RSI
LEA RDI,[RSI + R11*0x4]
NOP
LAB_001011d0:
MOV ECX,dword ptr [RDX]
ADD RAX,0x4
ADD RDX,0x10
MOV dword ptr [RAX + -0x4],ECX
CMP RDI,RAX
JNZ 0x001011d0
LAB_001011e2:
MOV RAX,RSI
POP RBX
RET
LAB_001011f0:
MOV ECX,R9D
MOV RDX,RSI
SHR ECX,0x2
SHL RCX,0x6
ADD RCX,RAX
LAB_00101200:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM2,xmmword ptr [RAX + 0x10]
ADD RAX,0x40
ADD RDX,0x10
MOVDQU XMM1,xmmword ptr [RAX + -0x20]
MOVDQU XMM3,xmmword ptr [RAX + -0x10]
SHUFPS XMM0,XMM2,0x88
SHUFPS XMM1,XMM3,0x88
SHUFPS XMM0,XMM1,0x88
MOVUPS xmmword ptr [RDX + -0x10],XMM0
CMP RAX,RCX
JNZ 0x00101200
AND R9D,0xfffffffc
MOVSXD RDX,R9D
MOV RAX,RDX
LEA RCX,[RDX*0x4]
SHL RAX,0x4
ADD RAX,R8
ADD RAX,R10
MOV R8D,dword ptr [RAX]
MOV dword ptr [RSI + RDX*0x4],R8D
LEA EDX,[R9 + 0x1]
CMP EDI,EDX
JLE 0x001011e2
MOV EDX,dword ptr [RAX + 0x10]
MOV dword ptr [RSI + RCX*0x1 + 0x4],EDX
LEA EDX,[R9 + 0x2]
CMP EDX,EDI
JGE 0x001011e2
MOV EDX,dword ptr [RAX + 0x20]
ADD R9D,0x3
MOV dword ptr [RSI + RCX*0x1 + 0x8],EDX
CMP EDI,R9D
JLE 0x001011e2
MOV EAX,dword ptr [RAX + 0x30]
MOV dword ptr [RSI + RCX*0x1 + 0xc],EAX
MOV RAX,RSI
POP RBX
RET
LAB_00101290:
MOVSXD RDX,EDX
JMP 0x001011c3
LAB_001012a0:
MOV RAX,RCX
RET | int4 * func0(long param_1,int param_2,int param_3,int4 *param_4)
{
long lVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 *puVar5;
int4 *puVar6;
int4 *puVar7;
int4 *puVar8;
uint uVar9;
long lVar10;
if (param_2 < 1) {
return param_4;
}
uVar9 = param_2 - 1;
lVar10 = (long)param_2;
if (3 < uVar9) {
lVar1 = (long)param_3 * 4;
puVar7 = (int4 *)(param_1 + lVar1);
if (((int4 *)(param_1 + -0xc + (lVar10 * 4 + (long)param_3) * 4) <= param_4) ||
(param_4 + lVar10 <= puVar7)) {
puVar5 = puVar7;
puVar8 = param_4;
do {
uVar2 = puVar5[4];
puVar6 = puVar5 + 0x10;
uVar3 = puVar5[8];
uVar4 = puVar5[0xc];
*puVar8 = *puVar5;
puVar8[1] = uVar2;
puVar8[2] = uVar3;
puVar8[3] = uVar4;
puVar5 = puVar6;
puVar8 = puVar8 + 4;
} while (puVar6 != puVar7 + (ulong)(uVar9 >> 2) * 0x10);
uVar9 = uVar9 & 0xfffffffc;
lVar10 = (long)(int)uVar9;
puVar7 = (int4 *)(lVar10 * 0x10 + param_1 + lVar1);
param_4[lVar10] = *puVar7;
if (param_2 <= (int)(uVar9 + 1)) {
return param_4;
}
param_4[lVar10 + 1] = puVar7[4];
if (param_2 <= (int)(uVar9 + 2)) {
return param_4;
}
param_4[lVar10 + 2] = puVar7[8];
if (param_2 <= (int)(uVar9 + 3)) {
return param_4;
}
param_4[lVar10 + 3] = puVar7[0xc];
return param_4;
}
}
puVar7 = (int4 *)(param_1 + (long)param_3 * 4);
puVar5 = param_4;
do {
uVar2 = *puVar7;
puVar8 = puVar5 + 1;
puVar7 = puVar7 + 4;
*puVar5 = uVar2;
puVar5 = puVar8;
} while (param_4 + lVar10 != puVar8);
return param_4;
} |
4,092 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
// Function to find the minimum length and corresponding list
| void func0(int input_list[][10], int size_list[], int list_count, int *min_length, int **min_list) {
int i, j;
*min_length = INT_MAX;
*min_list = NULL;
for (i = 0; i < list_count; i++) {
if (size_list[i] < *min_length) {
*min_length = size_list[i];
*min_list = input_list[i];
}
}
}
| int main() {
int list1[][10] = {{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}};
int sizes1[] = {1, 2, 2, 2, 3};
int *result_list1;
int result_length1;
func0(list1, sizes1, 5, &result_length1, &result_list1);
assert(result_length1 == 1 && result_list1[0] == 0);
int list2[][10] = {{1,2,3,4,5},{1,2,3,4},{1,2,3},{1,2},{1}};
int sizes2[] = {5, 4, 3, 2, 1};
int *result_list2;
int result_length2;
func0(list2, sizes2, 5, &result_length2, &result_list2);
assert(result_length2 == 1 && result_list2[0] == 1);
int list3[][10] = {{3,4,5},{6,7,8,9},{10,11,12},{1,2}};
int sizes3[] = {3, 4, 3, 2};
int *result_list3;
int result_length3;
func0(list3, sizes3, 4, &result_length3, &result_list3);
assert(result_length3 == 2 && (result_list3[0] == 1 && result_list3[1] == 2));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8,-0x38(%rbp)
mov -0x30(%rbp),%rax
movl $0x7fffffff,(%rax)
mov -0x38(%rbp),%rax
movq $0x0,(%rax)
movl $0x0,-0x4(%rbp)
jmp 1207 <func0+0x9e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x30(%rbp),%rax
mov (%rax),%eax
cmp %eax,%edx
jge 1203 <func0+0x9a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x30(%rbp),%rax
mov %edx,(%rax)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x38(%rbp),%rax
mov %rdx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11a2 <func0+0x39>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
mov [rbp+var_38], r8
mov rax, [rbp+var_30]
mov dword ptr [rax], 7FFFFFFFh
mov rax, [rbp+var_38]
mov qword ptr [rax], 0
mov [rbp+var_4], 0
jmp short loc_1207
loc_11A2:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_30]
mov eax, [rax]
cmp edx, eax
jge short loc_1203
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_30]
mov [rax], edx
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
shl rax, 3
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov rax, [rbp+var_38]
mov [rax], rdx
loc_1203:
add [rbp+var_4], 1
loc_1207:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_11A2
nop
nop
pop rbp
retn | long long func0(long long a1, long long a2, int a3, _DWORD *a4, _QWORD *a5)
{
long long result; // rax
unsigned int i; // [rsp+34h] [rbp-4h]
*a4 = 0x7FFFFFFF;
*a5 = 0LL;
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
if ( *(_DWORD *)(4LL * (int)i + a2) < *a4 )
{
*a4 = *(_DWORD *)(4LL * (int)i + a2);
*a5 = a1 + 40LL * (int)i;
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x38],R8
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x7fffffff
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101207
LAB_001011a2:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x00101203
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x3
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RDX
LAB_00101203:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101207:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011a2
NOP
NOP
POP RBP
RET | void func0(long param_1,long param_2,int param_3,int *param_4,long *param_5)
{
int4 local_c;
*param_4 = 0x7fffffff;
*param_5 = 0;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
if (*(int *)(param_2 + (long)local_c * 4) < *param_4) {
*param_4 = *(int *)(param_2 + (long)local_c * 4);
*param_5 = (long)local_c * 0x28 + param_1;
}
}
return;
} |
4,093 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
// Function to find the minimum length and corresponding list
| void func0(int input_list[][10], int size_list[], int list_count, int *min_length, int **min_list) {
int i, j;
*min_length = INT_MAX;
*min_list = NULL;
for (i = 0; i < list_count; i++) {
if (size_list[i] < *min_length) {
*min_length = size_list[i];
*min_list = input_list[i];
}
}
}
| int main() {
int list1[][10] = {{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}};
int sizes1[] = {1, 2, 2, 2, 3};
int *result_list1;
int result_length1;
func0(list1, sizes1, 5, &result_length1, &result_list1);
assert(result_length1 == 1 && result_list1[0] == 0);
int list2[][10] = {{1,2,3,4,5},{1,2,3,4},{1,2,3},{1,2},{1}};
int sizes2[] = {5, 4, 3, 2, 1};
int *result_list2;
int result_length2;
func0(list2, sizes2, 5, &result_length2, &result_list2);
assert(result_length2 == 1 && result_list2[0] == 1);
int list3[][10] = {{3,4,5},{6,7,8,9},{10,11,12},{1,2}};
int sizes3[] = {3, 4, 3, 2};
int *result_list3;
int result_length3;
func0(list3, sizes3, 4, &result_length3, &result_list3);
assert(result_length3 == 2 && (result_list3[0] == 1 && result_list3[1] == 2));
return 0;
}
| O1 | c | func0:
endbr64
movl $0x7fffffff,(%rcx)
movq $0x0,(%r8)
test %edx,%edx
jle 11a5 <func0+0x3c>
mov %rsi,%rax
lea -0x1(%rdx),%edx
lea 0x4(%rsi,%rdx,4),%rsi
jmp 1198 <func0+0x2f>
add $0x4,%rax
add $0x28,%rdi
cmp %rsi,%rax
je 11a5 <func0+0x3c>
mov (%rax),%edx
cmp (%rcx),%edx
jge 118b <func0+0x22>
mov %edx,(%rcx)
mov %rdi,(%r8)
jmp 118b <func0+0x22>
retq
| func0:
endbr64
mov dword ptr [rcx], 7FFFFFFFh
mov qword ptr [r8], 0
test edx, edx
jle short locret_11A5
mov rax, rsi
lea edx, [rdx-1]
lea rsi, [rsi+rdx*4+4]
jmp short loc_1198
loc_118B:
add rax, 4
add rdi, 28h ; '('
cmp rax, rsi
jz short locret_11A5
loc_1198:
mov edx, [rax]
cmp edx, [rcx]
jge short loc_118B
mov [rcx], edx
mov [r8], rdi
jmp short loc_118B
locret_11A5:
retn | void func0(long long a1, _DWORD *a2, int a3, _DWORD *a4, _QWORD *a5)
{
_DWORD *v5; // rax
long long v6; // rsi
*a4 = 0x7FFFFFFF;
*a5 = 0LL;
if ( a3 > 0 )
{
v5 = a2;
v6 = (long long)&a2[a3 - 1 + 1];
do
{
if ( *v5 < *a4 )
{
*a4 = *v5;
*a5 = a1;
}
++v5;
a1 += 40LL;
}
while ( v5 != (_DWORD *)v6 );
}
} | func0:
ENDBR64
MOV dword ptr [RCX],0x7fffffff
MOV qword ptr [R8],0x0
TEST EDX,EDX
JLE 0x001011a5
MOV RAX,RSI
LEA EDX,[RDX + -0x1]
LEA RSI,[RSI + RDX*0x4 + 0x4]
JMP 0x00101198
LAB_0010118b:
ADD RAX,0x4
ADD RDI,0x28
CMP RAX,RSI
JZ 0x001011a5
LAB_00101198:
MOV EDX,dword ptr [RAX]
CMP EDX,dword ptr [RCX]
JGE 0x0010118b
MOV dword ptr [RCX],EDX
MOV qword ptr [R8],RDI
JMP 0x0010118b
LAB_001011a5:
RET | void func0(long param_1,int *param_2,int param_3,int *param_4,long *param_5)
{
int *piVar1;
*param_4 = 0x7fffffff;
*param_5 = 0;
if (0 < param_3) {
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
do {
if (*param_2 < *param_4) {
*param_4 = *param_2;
*param_5 = param_1;
}
param_2 = param_2 + 1;
param_1 = param_1 + 0x28;
} while (param_2 != piVar1);
}
return;
} |
4,094 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
// Function to find the minimum length and corresponding list
| void func0(int input_list[][10], int size_list[], int list_count, int *min_length, int **min_list) {
int i, j;
*min_length = INT_MAX;
*min_list = NULL;
for (i = 0; i < list_count; i++) {
if (size_list[i] < *min_length) {
*min_length = size_list[i];
*min_list = input_list[i];
}
}
}
| int main() {
int list1[][10] = {{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}};
int sizes1[] = {1, 2, 2, 2, 3};
int *result_list1;
int result_length1;
func0(list1, sizes1, 5, &result_length1, &result_list1);
assert(result_length1 == 1 && result_list1[0] == 0);
int list2[][10] = {{1,2,3,4,5},{1,2,3,4},{1,2,3},{1,2},{1}};
int sizes2[] = {5, 4, 3, 2, 1};
int *result_list2;
int result_length2;
func0(list2, sizes2, 5, &result_length2, &result_list2);
assert(result_length2 == 1 && result_list2[0] == 1);
int list3[][10] = {{3,4,5},{6,7,8,9},{10,11,12},{1,2}};
int sizes3[] = {3, 4, 3, 2};
int *result_list3;
int result_length3;
func0(list3, sizes3, 4, &result_length3, &result_list3);
assert(result_length3 == 2 && (result_list3[0] == 1 && result_list3[1] == 2));
return 0;
}
| O2 | c | func0:
endbr64
movl $0x7fffffff,(%rcx)
movq $0x0,(%r8)
test %edx,%edx
jle 1182 <func0+0x42>
lea -0x1(%rdx),%eax
mov $0x7fffffff,%edx
lea 0x4(%rsi,%rax,4),%r9
jmp 116a <func0+0x2a>
nopl 0x0(%rax)
mov (%rcx),%edx
mov (%rsi),%eax
cmp %edx,%eax
jge 1175 <func0+0x35>
mov %eax,(%rcx)
mov %rdi,(%r8)
add $0x4,%rsi
add $0x28,%rdi
cmp %r9,%rsi
jne 1168 <func0+0x28>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov dword ptr [rcx], 7FFFFFFFh
mov qword ptr [r8], 0
test edx, edx
jle short locret_1512
lea eax, [rdx-1]
mov edx, 7FFFFFFFh
lea r9, [rsi+rax*4]
jmp short loc_14FE
loc_14F8:
mov edx, [rcx]
add rsi, 4
loc_14FE:
mov eax, [rsi]
cmp eax, edx
jge short loc_1509
mov [rcx], eax
mov [r8], rdi
loc_1509:
add rdi, 28h ; '('
cmp rsi, r9
jnz short loc_14F8
locret_1512:
retn | void func0(long long a1, int *a2, int a3, int *a4, _QWORD *a5)
{
long long v5; // rax
int v6; // edx
int *v7; // r9
*a4 = 0x7FFFFFFF;
*a5 = 0LL;
if ( a3 > 0 )
{
v5 = (unsigned int)(a3 - 1);
v6 = 0x7FFFFFFF;
v7 = &a2[v5];
while ( 1 )
{
if ( *a2 < v6 )
{
*a4 = *a2;
*a5 = a1;
}
a1 += 40LL;
if ( a2 == v7 )
break;
v6 = *a4;
++a2;
}
}
} | func0:
ENDBR64
MOV dword ptr [RCX],0x7fffffff
MOV qword ptr [R8],0x0
TEST EDX,EDX
JLE 0x00101512
LEA EAX,[RDX + -0x1]
MOV EDX,0x7fffffff
LEA R9,[RSI + RAX*0x4]
JMP 0x001014fe
LAB_001014f8:
MOV EDX,dword ptr [RCX]
ADD RSI,0x4
LAB_001014fe:
MOV EAX,dword ptr [RSI]
CMP EAX,EDX
JGE 0x00101509
MOV dword ptr [RCX],EAX
MOV qword ptr [R8],RDI
LAB_00101509:
ADD RDI,0x28
CMP RSI,R9
JNZ 0x001014f8
LAB_00101512:
RET | void func0(long param_1,int *param_2,int param_3,int *param_4,long *param_5)
{
int *piVar1;
int iVar2;
*param_4 = 0x7fffffff;
*param_5 = 0;
if (0 < param_3) {
iVar2 = 0x7fffffff;
piVar1 = param_2 + (param_3 - 1);
while( true ) {
if (*param_2 < iVar2) {
*param_4 = *param_2;
*param_5 = param_1;
}
param_1 = param_1 + 0x28;
if (param_2 == piVar1) break;
iVar2 = *param_4;
param_2 = param_2 + 1;
}
}
return;
} |
4,095 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
// Function to find the minimum length and corresponding list
| void func0(int input_list[][10], int size_list[], int list_count, int *min_length, int **min_list) {
int i, j;
*min_length = INT_MAX;
*min_list = NULL;
for (i = 0; i < list_count; i++) {
if (size_list[i] < *min_length) {
*min_length = size_list[i];
*min_list = input_list[i];
}
}
}
| int main() {
int list1[][10] = {{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}};
int sizes1[] = {1, 2, 2, 2, 3};
int *result_list1;
int result_length1;
func0(list1, sizes1, 5, &result_length1, &result_list1);
assert(result_length1 == 1 && result_list1[0] == 0);
int list2[][10] = {{1,2,3,4,5},{1,2,3,4},{1,2,3},{1,2},{1}};
int sizes2[] = {5, 4, 3, 2, 1};
int *result_list2;
int result_length2;
func0(list2, sizes2, 5, &result_length2, &result_list2);
assert(result_length2 == 1 && result_list2[0] == 1);
int list3[][10] = {{3,4,5},{6,7,8,9},{10,11,12},{1,2}};
int sizes3[] = {3, 4, 3, 2};
int *result_list3;
int result_length3;
func0(list3, sizes3, 4, &result_length3, &result_list3);
assert(result_length3 == 2 && (result_list3[0] == 1 && result_list3[1] == 2));
return 0;
}
| O3 | c | func0:
endbr64
movl $0x7fffffff,(%rcx)
movq $0x0,(%r8)
test %edx,%edx
jle 1182 <func0+0x42>
lea -0x1(%rdx),%eax
mov $0x7fffffff,%edx
lea 0x4(%rsi,%rax,4),%r9
nopw 0x0(%rax,%rax,1)
mov (%rsi),%eax
cmp %edx,%eax
jge 1175 <func0+0x35>
mov %eax,(%rcx)
mov %eax,%edx
mov %rdi,(%r8)
add $0x4,%rsi
add $0x28,%rdi
cmp %r9,%rsi
jne 1168 <func0+0x28>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov dword ptr [rcx], 7FFFFFFFh
mov qword ptr [r8], 0
test edx, edx
jle short locret_1182
movsxd rdx, edx
lea r9, [rsi+rdx*4]
mov edx, 7FFFFFFFh
nop dword ptr [rax+00000000h]
loc_1168:
mov eax, [rsi]
cmp eax, edx
jge short loc_1175
mov [rcx], eax
mov edx, eax
mov [r8], rdi
loc_1175:
add rsi, 4
add rdi, 28h ; '('
cmp rsi, r9
jnz short loc_1168
locret_1182:
retn | void func0(long long a1, int *a2, int a3, int *a4, _QWORD *a5)
{
int *v5; // r9
int v6; // edx
int v7; // eax
*a4 = 0x7FFFFFFF;
*a5 = 0LL;
if ( a3 > 0 )
{
v5 = &a2[a3];
v6 = 0x7FFFFFFF;
do
{
v7 = *a2;
if ( *a2 < v6 )
{
*a4 = v7;
v6 = v7;
*a5 = a1;
}
++a2;
a1 += 40LL;
}
while ( a2 != v5 );
}
} | func0:
ENDBR64
MOV dword ptr [RCX],0x7fffffff
MOV qword ptr [R8],0x0
TEST EDX,EDX
JLE 0x00101182
MOVSXD RDX,EDX
LEA R9,[RSI + RDX*0x4]
MOV EDX,0x7fffffff
NOP dword ptr [RAX]
LAB_00101168:
MOV EAX,dword ptr [RSI]
CMP EAX,EDX
JGE 0x00101175
MOV dword ptr [RCX],EAX
MOV EDX,EAX
MOV qword ptr [R8],RDI
LAB_00101175:
ADD RSI,0x4
ADD RDI,0x28
CMP RSI,R9
JNZ 0x00101168
LAB_00101182:
RET | void func0(long param_1,int *param_2,int param_3,int *param_4,long *param_5)
{
int *piVar1;
int iVar2;
int iVar3;
*param_4 = 0x7fffffff;
*param_5 = 0;
if (0 < param_3) {
piVar1 = param_2 + param_3;
iVar3 = 0x7fffffff;
do {
iVar2 = *param_2;
if (iVar2 < iVar3) {
*param_4 = iVar2;
*param_5 = param_1;
iVar3 = iVar2;
}
param_2 = param_2 + 1;
param_1 = param_1 + 0x28;
} while (param_2 != piVar1);
}
return;
} |
4,096 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x == y && y == z) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == false);
assert(func0(6, 6, 12) == false);
assert(func0(6, 6, 6) == 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
jne 1171 <func0+0x28>
mov -0x8(%rbp),%eax
cmp -0xc(%rbp),%eax
jne 1171 <func0+0x28>
mov $0x1,%eax
jmp 1176 <func0+0x2d>
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]
jnz short loc_1171
mov eax, [rbp+var_8]
cmp eax, [rbp+var_C]
jnz short loc_1171
mov eax, 1
jmp short loc_1176
loc_1171:
mov eax, 0
loc_1176:
pop rbp
retn | _BOOL8 func0(int a1, int a2, int a3)
{
return a1 == a2 && a2 == a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x00101171
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x00101171
MOV EAX,0x1
JMP 0x00101176
LAB_00101171:
MOV EAX,0x0
LAB_00101176:
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)) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
4,097 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x == y && y == z) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == false);
assert(func0(6, 6, 12) == false);
assert(func0(6, 6, 6) == true);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
sete %al
cmp %edx,%esi
sete %dl
and %edx,%eax
retq
| func0:
endbr64
cmp edi, esi
setz al
cmp esi, edx
setz dl
and eax, edx
retn | long long func0(int a1, int a2, int a3)
{
unsigned int v3; // eax
LOBYTE(v3) = a1 == a2;
LOBYTE(a3) = a2 == a3;
return a3 & v3;
} | func0:
ENDBR64
CMP EDI,ESI
SETZ AL
CMP ESI,EDX
SETZ DL
AND EAX,EDX
RET | uint func0(int param_1,int param_2,int param_3)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_1 == param_2) &
CONCAT31((int3)((uint)param_3 >> 8),param_2 == param_3);
} |
4,098 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x == y && y == z) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == false);
assert(func0(6, 6, 12) == false);
assert(func0(6, 6, 6) == true);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
sete %al
cmp %edx,%esi
sete %dl
and %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
setz al
cmp esi, edx
setz dl
and eax, edx
retn | long long func0(int a1, int a2, int a3)
{
unsigned int v3; // eax
LOBYTE(v3) = a1 == a2;
LOBYTE(a3) = a2 == a3;
return a3 & v3;
} | func0:
ENDBR64
CMP EDI,ESI
SETZ AL
CMP ESI,EDX
SETZ DL
AND EAX,EDX
RET | uint func0(int param_1,int param_2,int param_3)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_1 == param_2) &
CONCAT31((int3)((uint)param_3 >> 8),param_2 == param_3);
} |
4,099 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y, int z) {
if (x == y && y == z) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(6, 8, 12) == false);
assert(func0(6, 6, 12) == false);
assert(func0(6, 6, 6) == true);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
sete %al
cmp %edx,%esi
sete %dl
and %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
setz al
cmp esi, edx
setz dl
and eax, edx
retn | long long func0(int a1, int a2, int a3)
{
unsigned int v3; // eax
LOBYTE(v3) = a1 == a2;
LOBYTE(a3) = a2 == a3;
return a3 & v3;
} | func0:
ENDBR64
CMP EDI,ESI
SETZ AL
CMP ESI,EDX
SETZ DL
AND EAX,EDX
RET | uint func0(int param_1,int param_2,int param_3)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_1 == param_2) &
CONCAT31((int3)((uint)param_3 >> 8),param_2 == param_3);
} |
4,100 | func0 |
#include <assert.h>
| int func0(int b, int h) {
int area = b * h;
return area;
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(15, 20) == 300);
assert(func0(8, 9) == 72);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
imul -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
imul eax, [rbp+var_18]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a2 * a1);
} | 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]
IMUL EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2)
{
return param_1 * param_2;
} |
4,101 | func0 |
#include <assert.h>
| int func0(int b, int h) {
int area = b * h;
return area;
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(15, 20) == 300);
assert(func0(8, 9) == 72);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
imul %esi,%eax
retq
| func0:
endbr64
mov eax, edi
imul eax, esi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a2 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
IMUL EAX,ESI
RET | int func0(int param_1,int param_2)
{
return param_1 * param_2;
} |
4,102 | func0 |
#include <assert.h>
| int func0(int b, int h) {
int area = b * h;
return area;
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(15, 20) == 300);
assert(func0(8, 9) == 72);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
imul %esi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
imul eax, esi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a2 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
IMUL EAX,ESI
RET | int func0(int param_1,int param_2)
{
return param_1 * param_2;
} |
4,103 | func0 |
#include <assert.h>
| int func0(int b, int h) {
int area = b * h;
return area;
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(15, 20) == 300);
assert(func0(8, 9) == 72);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
imul %esi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
imul eax, esi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a2 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
IMUL EAX,ESI
RET | int func0(int param_1,int param_2)
{
return param_1 * param_2;
} |
4,104 | func0 | #include <assert.h>
#include <string.h>
| char* func0(const char* str) {
int len = strlen(str);
if (str[0] == str[len - 1]) {
return "Equal";
} else {
return "Not Equal";
}
}
| int main() {
assert(strcmp(func0("abcda"), "Equal") == 0);
assert(strcmp(func0("ab"), "Not Equal") == 0);
assert(strcmp(func0("mad"), "Not Equal") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x4(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea -0x1(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 11cf <func0+0x46>
lea 0xe3b(%rip),%rax
jmp 11d6 <func0+0x4d>
lea 0xe38(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov rax, [rbp+s]
movzx edx, byte ptr [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, [rax-1]
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_11CF
lea rax, s2; "Equal"
jmp short locret_11D6
loc_11CF:
lea rax, aNotEqual; "Not Equal"
locret_11D6:
leave
retn | const char * func0(const char *a1)
{
if ( *a1 == a1[(int)strlen(a1) - 1] )
return "Equal";
else
return "Not Equal";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x4],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001011cf
LEA RAX,[0x102008]
JMP 0x001011d6
LAB_001011cf:
LEA RAX,[0x10200e]
LAB_001011d6:
LEAVE
RET | char * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
if (*param_1 == param_1[(long)(int)sVar1 + -1]) {
pcVar2 = "Equal";
}
else {
pcVar2 = "Not Equal";
}
return pcVar2;
} |
4,105 | func0 | #include <assert.h>
#include <string.h>
| char* func0(const char* str) {
int len = strlen(str);
if (str[0] == str[len - 1]) {
return "Equal";
} else {
return "Not Equal";
}
}
| int main() {
assert(strcmp(func0("abcda"), "Equal") == 0);
assert(strcmp(func0("ab"), "Not Equal") == 0);
assert(strcmp(func0("mad"), "Not Equal") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
cltq
movzbl -0x1(%rdx,%rax,1),%eax
cmp %al,(%rdx)
lea 0xe90(%rip),%rax
lea 0xe85(%rip),%rdx
cmovne %rdx,%rax
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
cdqe
movzx eax, byte ptr [rbx+rax-1]
cmp [rbx], al
lea rax, aNotEqual+4; "Equal"
lea rdx, aNotEqual; "Not Equal"
cmovnz rax, rdx
pop rbx
retn | char * func0(_BYTE *a1)
{
bool v1; // zf
char *result; // rax
v1 = *a1 == a1[(int)strlen() - 1];
result = "Equal";
if ( !v1 )
return "Not Equal";
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101070
CDQE
MOVZX EAX,byte ptr [RBX + RAX*0x1 + -0x1]
CMP byte ptr [RBX],AL
LEA RAX,[0x102008]
LEA RDX,[0x102004]
CMOVNZ RAX,RDX
POP RBX
RET | char * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
pcVar2 = "Equal";
if (*param_1 != param_1[(long)(int)sVar1 + -1]) {
pcVar2 = "Not Equal";
}
return pcVar2;
} |
4,106 | func0 | #include <assert.h>
#include <string.h>
| char* func0(const char* str) {
int len = strlen(str);
if (str[0] == str[len - 1]) {
return "Equal";
} else {
return "Not Equal";
}
}
| int main() {
assert(strcmp(func0("abcda"), "Equal") == 0);
assert(strcmp(func0("ab"), "Not Equal") == 0);
assert(strcmp(func0("mad"), "Not Equal") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1050 <strlen@plt>
lea 0xe90(%rip),%rdx
cltq
movzbl -0x1(%rbx,%rax,1),%eax
cmp %al,(%rbx)
lea 0xe84(%rip),%rax
cmovne %rdx,%rax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
lea rdx, aNotEqual; "Not Equal"
cdqe
movzx eax, byte ptr [rbx+rax-1]
cmp [rbx], al
lea rax, aNotEqual+4; "Equal"
cmovnz rax, rdx
pop rbx
retn | char * func0(_BYTE *a1)
{
bool v1; // zf
char *result; // rax
v1 = *a1 == a1[(int)strlen() - 1];
result = "Equal";
if ( !v1 )
return "Not Equal";
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101070
LEA RDX,[0x102004]
CDQE
MOVZX EAX,byte ptr [RBX + RAX*0x1 + -0x1]
CMP byte ptr [RBX],AL
LEA RAX,[0x102008]
CMOVNZ RAX,RDX
POP RBX
RET | char * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
pcVar2 = "Equal";
if (*param_1 != param_1[(long)(int)sVar1 + -1]) {
pcVar2 = "Not Equal";
}
return pcVar2;
} |
4,107 | func0 | #include <assert.h>
#include <string.h>
| char* func0(const char* str) {
int len = strlen(str);
if (str[0] == str[len - 1]) {
return "Equal";
} else {
return "Not Equal";
}
}
| int main() {
assert(strcmp(func0("abcda"), "Equal") == 0);
assert(strcmp(func0("ab"), "Not Equal") == 0);
assert(strcmp(func0("mad"), "Not Equal") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1050 <strlen@plt>
lea 0xe90(%rip),%rdx
cltq
movzbl -0x1(%rbx,%rax,1),%eax
cmp %al,(%rbx)
lea 0xe84(%rip),%rax
cmovne %rdx,%rax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
lea rdx, aNotEqual+4; "Equal"
cdqe
movzx eax, byte ptr [rbx+rax-1]
cmp [rbx], al
lea rax, aNotEqual; "Not Equal"
cmovz rax, rdx
pop rbx
retn | char * func0(const char *a1)
{
bool v1; // zf
char *result; // rax
v1 = *a1 == a1[(int)strlen(a1) - 1];
result = "Not Equal";
if ( v1 )
return "Equal";
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101050
LEA RDX,[0x102008]
CDQE
MOVZX EAX,byte ptr [RBX + RAX*0x1 + -0x1]
CMP byte ptr [RBX],AL
LEA RAX,[0x102004]
CMOVZ RAX,RDX
POP RBX
RET | char * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
pcVar2 = "Not Equal";
if (*param_1 == param_1[(long)(int)sVar1 + -1]) {
pcVar2 = "Equal";
}
return pcVar2;
} |
4,108 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int *my_list, int n) {
int max_value = 0;
for (int i = 0; i < n; i++) {
if (my_list[i] > max_value) {
max_value = my_list[i];
}
}
int *buckets = malloc((max_value + 1) * sizeof(int));
for (int j = 0; j <= max_value; j++) {
buckets[j] = 0;
}
for (int i = 0; i < n; i++) {
buckets[my_list[i]]++;
}
int pos = 0;
for (int j = 0; j <= max_value; j++) {
for (int a = 0; a < buckets[j]; a++) {
my_list[pos] = j;
pos++;
}
}
free(buckets);
}
| int main() {
int list1[] = {1, 23, 4, 5, 6, 7, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
func0(list1, size1);
assert(list1[0] == 1 && list1[1] == 4 && list1[2] == 5 && list1[3] == 6 && list1[4] == 7 && list1[5] == 8 && list1[6] == 23);
int list2[] = {12, 9, 28, 33, 69, 45};
int size2 = sizeof(list2) / sizeof(list2[0]);
func0(list2, size2);
assert(list2[0] == 9 && list2[1] == 12 && list2[2] == 28 && list2[3] == 33 && list2[4] == 45 && list2[5] == 69);
int list3[] = {8, 4, 14, 3, 2, 1};
int size3 = sizeof(list3) / sizeof(list3[0]);
func0(list3, size3);
assert(list3[0] == 1 && list3[1] == 2 && list3[2] == 3 && list3[3] == 4 && list3[4] == 8 && list3[5] == 14);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmp 1204 <func0+0x5b>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x24(%rbp)
jge 1200 <func0+0x57>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x24(%rbp)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 11cc <func0+0x23>
mov -0x24(%rbp),%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 124b <func0+0xa2>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movl $0x0,(%rax)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 122d <func0+0x84>
movl $0x0,-0x18(%rbp)
jmp 128e <func0+0xe5>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%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,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 125c <func0+0xb3>
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 12ef <func0+0x146>
movl $0x0,-0xc(%rbp)
jmp 12d0 <func0+0x127>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
addl $0x1,-0xc(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jl 12af <func0+0x106>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 12a6 <func0+0xfd>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp short loc_1204
loc_11CC:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_24], eax
jge short loc_1200
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov [rbp+var_24], eax
loc_1200:
add [rbp+var_20], 1
loc_1204:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_3C]
jl short loc_11CC
mov eax, [rbp+var_24]
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_1C], 0
jmp short loc_124B
loc_122D:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov dword ptr [rax], 0
add [rbp+var_1C], 1
loc_124B:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jle short loc_122D
mov [rbp+var_18], 0
jmp short loc_128E
loc_125C:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
add edx, 1
mov [rax], edx
add [rbp+var_18], 1
loc_128E:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_3C]
jl short loc_125C
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_12EF
loc_12A6:
mov [rbp+var_C], 0
jmp short loc_12D0
loc_12AF:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rdx, rax
mov eax, [rbp+var_10]
mov [rdx], eax
add [rbp+var_14], 1
add [rbp+var_C], 1
loc_12D0:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jl short loc_12AF
add [rbp+var_10], 1
loc_12EF:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_24]
jle short loc_12A6
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
nop
leave
retn | void func0(long long a1, int a2)
{
_DWORD *v2; // rax
int v3; // [rsp+1Ch] [rbp-24h]
int i; // [rsp+20h] [rbp-20h]
int j; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+28h] [rbp-18h]
int v7; // [rsp+2Ch] [rbp-14h]
int m; // [rsp+30h] [rbp-10h]
int n; // [rsp+34h] [rbp-Ch]
_DWORD *ptr; // [rsp+38h] [rbp-8h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( v3 < *(_DWORD *)(4LL * i + a1) )
v3 = *(_DWORD *)(4LL * i + a1);
}
ptr = malloc(4LL * (v3 + 1));
for ( j = 0; j <= v3; ++j )
ptr[j] = 0;
for ( k = 0; k < a2; ++k )
{
v2 = &ptr[*(int *)(4LL * k + a1)];
++*v2;
}
v7 = 0;
for ( m = 0; m <= v3; ++m )
{
for ( n = 0; n < ptr[m]; ++n )
*(_DWORD *)(a1 + 4LL * v7++) = m;
}
free(ptr);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101204
LAB_001011cc:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x24],EAX
JGE 0x00101200
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
LAB_00101200:
ADD dword ptr [RBP + -0x20],0x1
LAB_00101204:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001011cc
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010124b
LAB_0010122d:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV dword ptr [RAX],0x0
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010124b:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x0010122d
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010128e
LAB_0010125c:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
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 + -0x18],0x1
LAB_0010128e:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x0010125c
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012ef
LAB_001012a6:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012d0
LAB_001012af:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x14],0x1
ADD dword ptr [RBP + -0xc],0x1
LAB_001012d0:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JL 0x001012af
ADD dword ptr [RBP + -0x10],0x1
LAB_001012ef:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x001012a6
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101080
NOP
LEAVE
RET | void func0(long param_1,int param_2)
{
void *__ptr;
int *piVar1;
int4 local_2c;
int4 local_28;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
local_2c = 0;
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
if (local_2c < *(int *)(param_1 + (long)local_28 * 4)) {
local_2c = *(int *)(param_1 + (long)local_28 * 4);
}
}
__ptr = malloc((long)(local_2c + 1) << 2);
for (local_24 = 0; local_24 <= local_2c; local_24 = local_24 + 1) {
*(int4 *)((long)__ptr + (long)local_24 * 4) = 0;
}
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
piVar1 = (int *)((long)__ptr + (long)*(int *)(param_1 + (long)local_20 * 4) * 4);
*piVar1 = *piVar1 + 1;
}
local_1c = 0;
for (local_18 = 0; local_18 <= local_2c; local_18 = local_18 + 1) {
for (local_14 = 0; local_14 < *(int *)((long)__ptr + (long)local_18 * 4);
local_14 = local_14 + 1) {
*(int *)((long)local_1c * 4 + param_1) = local_18;
local_1c = local_1c + 1;
}
}
free(__ptr);
return;
} |
4,109 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int *my_list, int n) {
int max_value = 0;
for (int i = 0; i < n; i++) {
if (my_list[i] > max_value) {
max_value = my_list[i];
}
}
int *buckets = malloc((max_value + 1) * sizeof(int));
for (int j = 0; j <= max_value; j++) {
buckets[j] = 0;
}
for (int i = 0; i < n; i++) {
buckets[my_list[i]]++;
}
int pos = 0;
for (int j = 0; j <= max_value; j++) {
for (int a = 0; a < buckets[j]; a++) {
my_list[pos] = j;
pos++;
}
}
free(buckets);
}
| int main() {
int list1[] = {1, 23, 4, 5, 6, 7, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
func0(list1, size1);
assert(list1[0] == 1 && list1[1] == 4 && list1[2] == 5 && list1[3] == 6 && list1[4] == 7 && list1[5] == 8 && list1[6] == 23);
int list2[] = {12, 9, 28, 33, 69, 45};
int size2 = sizeof(list2) / sizeof(list2[0]);
func0(list2, size2);
assert(list2[0] == 9 && list2[1] == 12 && list2[2] == 28 && list2[3] == 33 && list2[4] == 45 && list2[5] == 69);
int list3[] = {8, 4, 14, 3, 2, 1};
int size3 = sizeof(list3) / sizeof(list3[0]);
func0(list3, size3);
assert(list3[0] == 1 && list3[1] == 2 && list3[2] == 3 && list3[3] == 4 && list3[4] == 8 && list3[5] == 14);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
test %esi,%esi
jle 127a <func0+0xd1>
mov %esi,%r12d
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%ebx
mov (%rax),%edx
cmp %edx,%ebx
cmovl %edx,%ebx
add $0x4,%rax
cmp %rcx,%rax
jne 11cf <func0+0x26>
lea 0x1(%rbx),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
js 120b <func0+0x62>
mov $0x0,%edx
movl $0x0,(%rax,%rdx,4)
add $0x1,%rdx
cmp %edx,%ebx
jge 11f7 <func0+0x4e>
test %r12d,%r12d
jle 1226 <func0+0x7d>
mov $0x0,%edx
movslq 0x0(%rbp,%rdx,4),%rcx
addl $0x1,(%rax,%rcx,4)
add $0x1,%rdx
cmp %edx,%r12d
jg 1210 <func0+0x67>
test %ebx,%ebx
js 126d <func0+0xc4>
mov $0x0,%edi
mov $0x0,%r9d
lea 0x4(%rbp),%r11
jmp 1260 <func0+0xb7>
movslq %r9d,%r10
lea 0x0(%rbp,%r10,4),%rdx
lea -0x1(%r8),%esi
add %r10,%rsi
lea (%r11,%rsi,4),%rsi
mov %ecx,(%rdx)
add $0x4,%rdx
cmp %rsi,%rdx
jne 124a <func0+0xa1>
add %r8d,%r9d
add $0x1,%rdi
cmp %edi,%ebx
jl 126d <func0+0xc4>
mov %edi,%ecx
mov (%rax,%rdi,4),%r8d
test %r8d,%r8d
jg 1237 <func0+0x8e>
jmp 1258 <func0+0xaf>
mov %rax,%rdi
callq 1080 <free@plt>
pop %rbx
pop %rbp
pop %r12
retq
mov $0x4,%edi
callq 10b0 <malloc@plt>
movl $0x0,(%rax)
mov $0x0,%ebx
jmp 1226 <func0+0x7d>
| func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
test esi, esi
jle loc_127A
mov r12d, esi
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov ebx, 0
loc_11CF:
mov edx, [rax]
cmp ebx, edx
cmovl ebx, edx
add rax, 4
cmp rax, rcx
jnz short loc_11CF
lea edi, [rbx+1]
movsxd rdi, edi
shl rdi, 2
call _malloc
mov rdi, rax
test ebx, ebx
js short loc_120E
mov eax, 0
loc_11FA:
mov dword ptr [rdi+rax*4], 0
add rax, 1
cmp ebx, eax
jge short loc_11FA
test r12d, r12d
jle short loc_1229
loc_120E:
mov eax, 0
loc_1213:
movsxd rdx, dword ptr [rbp+rax*4+0]
add dword ptr [rdi+rdx*4], 1
add rax, 1
cmp r12d, eax
jg short loc_1213
test ebx, ebx
js short loc_1270
loc_1229:
mov esi, 0
mov r9d, 0
lea r11, [rbp+4]
jmp short loc_1263
loc_123A:
movsxd r10, r9d
lea rax, [rbp+r10*4+0]
lea ecx, [r8-1]
add rcx, r10
lea rcx, [r11+rcx*4]
loc_124D:
mov [rax], edx
add rax, 4
cmp rax, rcx
jnz short loc_124D
add r9d, r8d
loc_125B:
add rsi, 1
cmp ebx, esi
jl short loc_1270
loc_1263:
mov edx, esi
mov r8d, [rdi+rsi*4]
test r8d, r8d
jg short loc_123A
jmp short loc_125B
loc_1270:
call _free
pop rbx
pop rbp
pop r12
retn
loc_127A:
mov edi, 4
call _malloc
mov rdi, rax
mov dword ptr [rax], 0
mov ebx, 0
jmp short loc_1229 | long long func0(int *a1, int a2)
{
int *v3; // rax
int v4; // ebx
_DWORD *v5; // rdi
long long v6; // rax
long long v7; // rax
long long v8; // rsi
int v9; // r9d
int *v10; // rax
int v11; // r8d
if ( a2 <= 0 )
{
v5 = (_DWORD *)malloc(4LL);
*v5 = 0;
v4 = 0;
LABEL_12:
v8 = 0LL;
v9 = 0;
do
{
v11 = v5[v8];
if ( v11 > 0 )
{
v10 = &a1[v9];
do
*v10++ = v8;
while ( v10 != &a1[v9 + 1 + (unsigned long long)(unsigned int)(v11 - 1)] );
v9 += v11;
}
++v8;
}
while ( v4 >= (int)v8 );
return free();
}
v3 = a1;
v4 = 0;
do
{
if ( v4 < *v3 )
v4 = *v3;
++v3;
}
while ( v3 != &a1[a2 - 1 + 1] );
v5 = (_DWORD *)malloc(4LL * (v4 + 1));
if ( v4 >= 0 )
{
v6 = 0LL;
do
v5[v6++] = 0;
while ( v4 >= (int)v6 );
}
v7 = 0LL;
do
++v5[a1[v7++]];
while ( a2 > (int)v7 );
if ( v4 >= 0 )
goto LABEL_12;
return free();
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
TEST ESI,ESI
JLE 0x0010127a
MOV R12D,ESI
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EBX,0x0
LAB_001011cf:
MOV EDX,dword ptr [RAX]
CMP EBX,EDX
CMOVL EBX,EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011cf
LEA EDI,[RBX + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
TEST EBX,EBX
JS 0x0010120e
MOV EAX,0x0
LAB_001011fa:
MOV dword ptr [RDI + RAX*0x4],0x0
ADD RAX,0x1
CMP EBX,EAX
JGE 0x001011fa
TEST R12D,R12D
JLE 0x00101229
LAB_0010120e:
MOV EAX,0x0
LAB_00101213:
MOVSXD RDX,dword ptr [RBP + RAX*0x4]
ADD dword ptr [RDI + RDX*0x4],0x1
ADD RAX,0x1
CMP R12D,EAX
JG 0x00101213
TEST EBX,EBX
JS 0x00101270
LAB_00101229:
MOV ESI,0x0
MOV R9D,0x0
LEA R11,[RBP + 0x4]
JMP 0x00101263
LAB_0010123a:
MOVSXD R10,R9D
LEA RAX,[RBP + R10*0x4]
LEA ECX,[R8 + -0x1]
ADD RCX,R10
LEA RCX,[R11 + RCX*0x4]
LAB_0010124d:
MOV dword ptr [RAX],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010124d
ADD R9D,R8D
LAB_0010125b:
ADD RSI,0x1
CMP EBX,ESI
JL 0x00101270
LAB_00101263:
MOV EDX,ESI
MOV R8D,dword ptr [RDI + RSI*0x4]
TEST R8D,R8D
JG 0x0010123a
JMP 0x0010125b
LAB_00101270:
CALL 0x00101080
POP RBX
POP RBP
POP R12
RET
LAB_0010127a:
MOV EDI,0x4
CALL 0x001010b0
MOV RDI,RAX
MOV dword ptr [RAX],0x0
MOV EBX,0x0
JMP 0x00101229 | void func0(int *param_1,int param_2)
{
int iVar1;
int4 *__ptr;
long lVar2;
int *piVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
__ptr = (int4 *)malloc(4);
*__ptr = 0;
iVar4 = 0;
}
else {
iVar4 = 0;
piVar3 = param_1;
do {
if (iVar4 < *piVar3) {
iVar4 = *piVar3;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 1) + 1);
__ptr = (int4 *)malloc((long)(iVar4 + 1) << 2);
if (-1 < iVar4) {
lVar2 = 0;
do {
__ptr[lVar2] = 0;
lVar2 = lVar2 + 1;
} while ((int)lVar2 <= iVar4);
if (param_2 < 1) goto LAB_00101229;
}
lVar2 = 0;
do {
__ptr[param_1[lVar2]] = __ptr[param_1[lVar2]] + 1;
lVar2 = lVar2 + 1;
} while ((int)lVar2 < param_2);
if (iVar4 < 0) goto LAB_00101270;
}
LAB_00101229:
lVar2 = 0;
iVar5 = 0;
do {
iVar1 = __ptr[lVar2];
if (0 < iVar1) {
piVar3 = param_1 + iVar5;
do {
*piVar3 = (int)lVar2;
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(iVar1 - 1) + (long)iVar5 + 1);
iVar5 = iVar5 + iVar1;
}
lVar2 = lVar2 + 1;
} while ((int)lVar2 <= iVar4);
LAB_00101270:
free(__ptr);
return;
} |
4,110 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int *my_list, int n) {
int max_value = 0;
for (int i = 0; i < n; i++) {
if (my_list[i] > max_value) {
max_value = my_list[i];
}
}
int *buckets = malloc((max_value + 1) * sizeof(int));
for (int j = 0; j <= max_value; j++) {
buckets[j] = 0;
}
for (int i = 0; i < n; i++) {
buckets[my_list[i]]++;
}
int pos = 0;
for (int j = 0; j <= max_value; j++) {
for (int a = 0; a < buckets[j]; a++) {
my_list[pos] = j;
pos++;
}
}
free(buckets);
}
| int main() {
int list1[] = {1, 23, 4, 5, 6, 7, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
func0(list1, size1);
assert(list1[0] == 1 && list1[1] == 4 && list1[2] == 5 && list1[3] == 6 && list1[4] == 7 && list1[5] == 8 && list1[6] == 23);
int list2[] = {12, 9, 28, 33, 69, 45};
int size2 = sizeof(list2) / sizeof(list2[0]);
func0(list2, size2);
assert(list2[0] == 9 && list2[1] == 12 && list2[2] == 28 && list2[3] == 33 && list2[4] == 45 && list2[5] == 69);
int list3[] = {8, 4, 14, 3, 2, 1};
int size3 = sizeof(list3) / sizeof(list3[0]);
func0(list3, size3);
assert(list3[0] == 1 && list3[1] == 2 && list3[2] == 3 && list3[3] == 4 && list3[4] == 8 && list3[5] == 14);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
push %rbx
test %esi,%esi
jle 14ac <func0+0xec>
lea -0x1(%rsi),%edx
mov %rdi,%rax
xor %ebx,%ebx
lea 0x4(%rdi,%rdx,4),%rcx
nopl 0x0(%rax,%rax,1)
movslq (%rax),%rdx
cmp %edx,%ebx
cmovl %rdx,%rbx
add $0x4,%rax
cmp %rcx,%rax
jne 13e8 <func0+0x28>
lea 0x1(%rbx),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r9
mov %rax,%rdx
lea 0x4(%rax,%rbx,4),%rax
nopl 0x0(%rax)
movl $0x0,(%rdx)
add $0x4,%rdx
cmp %rdx,%rax
jne 1418 <func0+0x58>
test %r12d,%r12d
jle 1451 <func0+0x91>
lea -0x1(%r12),%eax
mov %rbp,%rdx
lea 0x4(%rbp,%rax,4),%rcx
nopl 0x0(%rax)
movslq (%rdx),%rax
add $0x4,%rdx
addl $0x1,(%r9,%rax,4)
cmp %rcx,%rdx
jne 1440 <func0+0x80>
xor %edi,%edi
xor %eax,%eax
lea 0x4(%rbp),%r11
nopl 0x0(%rax)
mov (%r9,%rdi,4),%r8d
mov %edi,%ecx
test %r8d,%r8d
jle 148e <func0+0xce>
movslq %eax,%r10
lea -0x1(%r8),%esi
add %r10,%rsi
lea 0x0(%rbp,%r10,4),%rdx
lea (%r11,%rsi,4),%rsi
xchg %ax,%ax
mov %ecx,(%rdx)
add $0x4,%rdx
cmp %rdx,%rsi
jne 1480 <func0+0xc0>
add %r8d,%eax
lea 0x1(%rdi),%rdx
cmp %rbx,%rdi
je 14a0 <func0+0xe0>
mov %rdx,%rdi
jmp 1460 <func0+0xa0>
nopl 0x0(%rax)
pop %rbx
mov %r9,%rdi
pop %rbp
pop %r12
jmpq 1080 <free@plt>
mov $0x4,%edi
xor %ebx,%ebx
jmpq 1404 <func0+0x44>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
test esi, esi
jle loc_14B1
lea edx, [rsi-1]
lea r13, [rdi+4]
mov rax, rdi
xor ebx, ebx
mov r12, rdx
lea rcx, [r13+rdx*4+0]
nop dword ptr [rax]
loc_1400:
movsxd rdx, dword ptr [rax]
cmp ebx, edx
cmovl rbx, rdx
add rax, 4
cmp rax, rcx
jnz short loc_1400
lea edi, [rbx+1]
add rbx, 1
movsxd rdi, edi
shl rdi, 2
call _malloc
lea rdx, ds:0[rbx*4]
xor esi, esi
mov rdi, rax
call _memset
lea rcx, [r13+r12*4+0]
mov r8, rax
mov rax, rbp
nop word ptr [rax+rax+00h]
loc_1448:
movsxd rdx, dword ptr [rax]
add rax, 4
add dword ptr [r8+rdx*4], 1
cmp rcx, rax
jnz short loc_1448
loc_1459:
xor esi, esi
xor r9d, r9d
lea r11, [rbp+4]
nop word ptr [rax+rax+00h]
loc_1468:
mov edi, [r8+rsi*4]
mov edx, esi
test edi, edi
jle short loc_1496
movsxd r10, r9d
lea ecx, [rdi-1]
add rcx, r10
lea rax, [rbp+r10*4+0]
lea rcx, [r11+rcx*4]
nop dword ptr [rax+00h]
loc_1488:
mov [rax], edx
add rax, 4
cmp rcx, rax
jnz short loc_1488
add r9d, edi
loc_1496:
add rsi, 1
cmp rbx, rsi
jnz short loc_1468
add rsp, 8
mov rdi, r8
pop rbx
pop rbp
pop r12
pop r13
jmp _free
loc_14B1:
mov edi, 4
mov ebx, 1
call _malloc
mov dword ptr [rax], 0
mov r8, rax
jmp short loc_1459 | long long func0(int *a1, int a2)
{
int *v3; // rax
long long v4; // rbx
long long v5; // r12
long long v6; // rbx
long long v7; // rax
long long v8; // r8
int *v9; // rax
long long v10; // rdx
long long v11; // rsi
int v12; // r9d
int v13; // edi
long long v14; // rdx
int *v15; // rax
_DWORD *v17; // rax
if ( a2 <= 0 )
{
v6 = 1LL;
v17 = (_DWORD *)malloc(4LL);
*v17 = 0;
v8 = (long long)v17;
}
else
{
v3 = a1;
v4 = 0LL;
v5 = (unsigned int)(a2 - 1);
do
{
if ( (int)v4 < *v3 )
v4 = *v3;
++v3;
}
while ( v3 != &a1[v5 + 1] );
v6 = v4 + 1;
v7 = malloc(4LL * (int)v6);
v8 = memset(v7, 0LL, 4 * v6);
v9 = a1;
do
{
v10 = *v9++;
++*(_DWORD *)(v8 + 4 * v10);
}
while ( &a1[v5 + 1] != v9 );
}
v11 = 0LL;
v12 = 0;
do
{
v13 = *(_DWORD *)(v8 + 4 * v11);
v14 = (unsigned int)v11;
if ( v13 > 0 )
{
v15 = &a1[v12];
do
*v15++ = v11;
while ( &a1[v12 + 1 + (unsigned long long)(unsigned int)(v13 - 1)] != v15 );
v12 += v13;
}
++v11;
}
while ( v6 != v11 );
return free(v8, v11, v14);
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001014b1
LEA EDX,[RSI + -0x1]
LEA R13,[RDI + 0x4]
MOV RAX,RDI
XOR EBX,EBX
MOV R12,RDX
LEA RCX,[R13 + RDX*0x4]
NOP dword ptr [RAX]
LAB_00101400:
MOVSXD RDX,dword ptr [RAX]
CMP EBX,EDX
CMOVL RBX,RDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101400
LEA EDI,[RBX + 0x1]
ADD RBX,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
LEA RDX,[RBX*0x4]
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010c0
LEA RCX,[R13 + R12*0x4]
MOV R8,RAX
MOV RAX,RBP
NOP word ptr [RAX + RAX*0x1]
LAB_00101448:
MOVSXD RDX,dword ptr [RAX]
ADD RAX,0x4
ADD dword ptr [R8 + RDX*0x4],0x1
CMP RCX,RAX
JNZ 0x00101448
LAB_00101459:
XOR ESI,ESI
XOR R9D,R9D
LEA R11,[RBP + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101468:
MOV EDI,dword ptr [R8 + RSI*0x4]
MOV EDX,ESI
TEST EDI,EDI
JLE 0x00101496
MOVSXD R10,R9D
LEA ECX,[RDI + -0x1]
ADD RCX,R10
LEA RAX,[RBP + R10*0x4]
LEA RCX,[R11 + RCX*0x4]
NOP dword ptr [RAX]
LAB_00101488:
MOV dword ptr [RAX],EDX
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x00101488
ADD R9D,EDI
LAB_00101496:
ADD RSI,0x1
CMP RBX,RSI
JNZ 0x00101468
ADD RSP,0x8
MOV RDI,R8
POP RBX
POP RBP
POP R12
POP R13
JMP 0x00101090
LAB_001014b1:
MOV EDI,0x4
MOV EBX,0x1
CALL 0x001010d0
MOV dword ptr [RAX],0x0
MOV R8,RAX
JMP 0x00101459 | void func0(int *param_1,int param_2)
{
int iVar1;
void *__s;
int4 *__ptr;
int *piVar2;
long lVar3;
long lVar4;
int iVar5;
if (param_2 < 1) {
lVar3 = 1;
__ptr = (int4 *)malloc(4);
*__ptr = 0;
}
else {
lVar4 = 0;
piVar2 = param_1;
do {
if ((int)lVar4 < *piVar2) {
lVar4 = (long)*piVar2;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
lVar3 = lVar4 + 1;
__s = malloc((long)((int)lVar4 + 1) << 2);
__ptr = (int4 *)memset(__s,0,lVar3 * 4);
piVar2 = param_1;
do {
iVar5 = *piVar2;
piVar2 = piVar2 + 1;
__ptr[iVar5] = __ptr[iVar5] + 1;
} while (param_1 + (ulong)(param_2 - 1) + 1 != piVar2);
}
lVar4 = 0;
iVar5 = 0;
do {
iVar1 = __ptr[lVar4];
if (0 < iVar1) {
piVar2 = param_1 + iVar5;
do {
*piVar2 = (int)lVar4;
piVar2 = piVar2 + 1;
} while (param_1 + (ulong)(iVar1 - 1) + (long)iVar5 + 1 != piVar2);
iVar5 = iVar5 + iVar1;
}
lVar4 = lVar4 + 1;
} while (lVar3 != lVar4);
free(__ptr);
return;
} |
4,111 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int *my_list, int n) {
int max_value = 0;
for (int i = 0; i < n; i++) {
if (my_list[i] > max_value) {
max_value = my_list[i];
}
}
int *buckets = malloc((max_value + 1) * sizeof(int));
for (int j = 0; j <= max_value; j++) {
buckets[j] = 0;
}
for (int i = 0; i < n; i++) {
buckets[my_list[i]]++;
}
int pos = 0;
for (int j = 0; j <= max_value; j++) {
for (int a = 0; a < buckets[j]; a++) {
my_list[pos] = j;
pos++;
}
}
free(buckets);
}
| int main() {
int list1[] = {1, 23, 4, 5, 6, 7, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
func0(list1, size1);
assert(list1[0] == 1 && list1[1] == 4 && list1[2] == 5 && list1[3] == 6 && list1[4] == 7 && list1[5] == 8 && list1[6] == 23);
int list2[] = {12, 9, 28, 33, 69, 45};
int size2 = sizeof(list2) / sizeof(list2[0]);
func0(list2, size2);
assert(list2[0] == 9 && list2[1] == 12 && list2[2] == 28 && list2[3] == 33 && list2[4] == 45 && list2[5] == 69);
int list3[] = {8, 4, 14, 3, 2, 1};
int size3 = sizeof(list3) / sizeof(list3[0]);
func0(list3, size3);
assert(list3[0] == 1 && list3[1] == 2 && list3[2] == 3 && list3[3] == 4 && list3[4] == 8 && list3[5] == 14);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
test %esi,%esi
jle 155c <func0+0x1bc>
lea -0x1(%rsi),%r12d
cmp $0x2,%r12d
jbe 1579 <func0+0x1d9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm2,%xmm2
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 13d8 <func0+0x38>
movdqa %xmm2,%xmm0
mov %esi,%eax
psrldq $0x8,%xmm0
and $0xfffffffc,%eax
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm3
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm3
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm0
por %xmm3,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%ebp
test $0x3,%sil
je 147f <func0+0xdf>
movslq %eax,%rdx
mov (%rbx,%rdx,4),%edx
cmp %edx,%ebp
cmovl %rdx,%rbp
lea 0x1(%rax),%edx
cmp %esi,%edx
jge 147f <func0+0xdf>
movslq %edx,%rdx
mov (%rbx,%rdx,4),%edx
cmp %edx,%ebp
cmovl %rdx,%rbp
add $0x2,%eax
cmp %eax,%esi
jle 147f <func0+0xdf>
cltq
mov (%rbx,%rax,4),%eax
cmp %eax,%ebp
cmovl %rax,%rbp
lea 0x1(%rbp),%edi
add $0x1,%rbp
mov %r12d,%r12d
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
lea 0x0(,%rbp,4),%rdx
xor %esi,%esi
mov %rax,%rdi
callq 10c0 <memset@plt>
lea 0x4(%rbx,%r12,4),%rcx
mov %rax,%rdi
mov %rbx,%rax
nopw 0x0(%rax,%rax,1)
movslq (%rax),%rdx
add $0x4,%rax
addl $0x1,(%rdi,%rdx,4)
cmp %rcx,%rax
jne 14b8 <func0+0x118>
xor %esi,%esi
xor %r9d,%r9d
nopl (%rax)
mov (%rdi,%rsi,4),%ecx
mov %esi,%r8d
test %ecx,%ecx
jle 1543 <func0+0x1a3>
lea -0x1(%rcx),%eax
cmp $0x2,%eax
jbe 1555 <func0+0x1b5>
mov %ecx,%edx
movslq %r9d,%rax
movd %r8d,%xmm4
shr $0x2,%edx
lea (%rbx,%rax,4),%rax
pshufd $0x0,%xmm4,%xmm0
shl $0x4,%rdx
add %rax,%rdx
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 1500 <func0+0x160>
mov %ecx,%eax
and $0xfffffffc,%eax
lea (%r9,%rax,1),%edx
cmp %eax,%ecx
je 1540 <func0+0x1a0>
movslq %edx,%rdx
mov %r8d,(%rbx,%rdx,4)
lea 0x0(,%rdx,4),%r10
lea 0x1(%rax),%edx
cmp %ecx,%edx
jge 1540 <func0+0x1a0>
add $0x2,%eax
mov %r8d,0x4(%rbx,%r10,1)
cmp %ecx,%eax
jge 1540 <func0+0x1a0>
mov %r8d,0x8(%rbx,%r10,1)
add %ecx,%r9d
add $0x1,%rsi
cmp %rbp,%rsi
jne 14d0 <func0+0x130>
pop %rbx
pop %rbp
pop %r12
jmpq 1090 <free@plt>
mov %r9d,%edx
xor %eax,%eax
jmp 1519 <func0+0x179>
mov $0x4,%edi
mov $0x1,%ebp
callq 10d0 <malloc@plt>
movl $0x0,(%rax)
mov %rax,%rdi
jmpq 14c8 <func0+0x128>
xor %eax,%eax
xor %ebp,%ebp
jmpq 144e <func0+0xae>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
test esi, esi
jle loc_15A3
lea eax, [rsi-1]
mov ebp, esi
cmp eax, 2
jbe loc_15BE
mov edx, esi
mov rax, rdi
pxor xmm2, xmm2
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00h]
loc_13D8:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_13D8
movdqa xmm1, xmm2
mov eax, ebp
psrldq xmm1, 8
and eax, 0FFFFFFFCh
movdqa xmm0, xmm1
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 r12d, xmm1
test bpl, 3
jz short loc_1480
loc_1447:
movsxd rdx, eax
lea rcx, ds:0[rdx*4]
mov edx, [rbx+rdx*4]
cmp r12d, edx
cmovl r12d, edx
lea edx, [rax+1]
cmp ebp, edx
jle short loc_1480
mov edx, [rbx+rcx+4]
cmp r12d, edx
cmovl r12d, edx
add eax, 2
cmp ebp, eax
jle short loc_1480
mov eax, [rbx+rcx+8]
cmp r12d, eax
cmovl r12d, eax
loc_1480:
lea edi, [r12+1]
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov r8, rax
test r12d, r12d
js short loc_14B1
movsxd rax, r12d
mov rdi, r8; s
xor esi, esi; c
lea rdx, ds:4[rax*4]; n
call _memset
mov r8, rax
loc_14B1:
xor eax, eax
nop dword ptr [rax+rax+00h]
loc_14B8:
movsxd rdx, dword ptr [rbx+rax*4]
add rax, 1
add dword ptr [r8+rdx*4], 1
cmp ebp, eax
jg short loc_14B8
test r12d, r12d
js loc_1590
loc_14D2:
movsxd r10, r12d
xor esi, esi
xor r9d, r9d
nop word ptr [rax+rax+00h]
loc_14E0:
mov edx, [r8+rsi*4]
mov edi, esi
test edx, edx
jle loc_1577
lea eax, [rdx-1]
cmp eax, 2
jbe loc_159C
mov ecx, edx
movsxd rax, r9d
movd xmm3, edi
shr ecx, 2
lea rax, [rbx+rax*4]
pshufd xmm0, xmm3, 0
shl rcx, 4
lea r11, [rcx+rax]
and ecx, 10h
jz short loc_1530
movups xmmword ptr [rax], xmm0
add rax, 10h
cmp r11, rax
jz short loc_1540
nop dword ptr [rax+rax+00000000h]
loc_1530:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp r11, rax
jnz short loc_1530
loc_1540:
mov eax, edx
and eax, 0FFFFFFFCh
lea ecx, [r9+rax]
test dl, 3
jz short loc_1574
loc_154E:
movsxd rcx, ecx
mov [rbx+rcx*4], edi
lea r11, ds:0[rcx*4]
lea ecx, [rax+1]
cmp ecx, edx
jge short loc_1574
add eax, 2
mov [rbx+r11+4], edi
cmp edx, eax
jle short loc_1574
mov [rbx+r11+8], edi
loc_1574:
add r9d, edx
loc_1577:
lea rax, [rsi+1]
cmp r10, rsi
jz short loc_1590
mov rsi, rax
jmp loc_14E0
loc_1590:
pop rbx
mov rdi, r8; ptr
pop rbp
pop r12
jmp _free
loc_159C:
mov ecx, r9d
xor eax, eax
jmp short loc_154E
loc_15A3:
mov edi, 4; size
xor r12d, r12d
call _malloc
mov dword ptr [rax], 0
mov r8, rax
jmp loc_14D2
loc_15BE:
xor eax, eax
xor r12d, r12d
jmp loc_1447 | void func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm2
__m128i v4; // xmm0
__m128i v5; // xmm1
__m128i v6; // xmm1
signed int v7; // eax
__m128i v8; // xmm0
__m128i v9; // xmm0
__m128i v10; // xmm2
__m128i v11; // xmm1
int v12; // r12d
long long v13; // rcx
_DWORD *v14; // r8
long long v15; // rax
long long v16; // rdx
long long v17; // rsi
int v18; // r9d
int v19; // edx
__m128i *v20; // rax
__m128i v21; // xmm0
long long v22; // rcx
__m128i *v23; // r11
int v24; // eax
int v25; // ecx
long long v26; // r11
_DWORD *v27; // rax
if ( a2 <= 0 )
{
v12 = 0;
v27 = malloc(4uLL);
*v27 = 0;
v14 = v27;
LABEL_19:
v17 = 0LL;
v18 = 0;
while ( 1 )
{
v19 = v14[v17];
if ( v19 <= 0 )
goto LABEL_30;
if ( (unsigned int)(v19 - 1) <= 2 )
{
v25 = v18;
v24 = 0;
}
else
{
v20 = (__m128i *)((char *)a1 + 4 * v18);
v21 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v17), 0);
v22 = (unsigned int)v19 >> 2;
v23 = &v20[v22];
if ( ((v22 * 16) & 0x10) == 0 || (*v20 = v21, ++v20, v23 != v20) )
{
do
{
*v20 = v21;
v20 += 2;
v20[-1] = v21;
}
while ( v23 != v20 );
}
v24 = v19 & 0x7FFFFFFC;
v25 = v18 + (v19 & 0xFFFFFFFC);
if ( (v19 & 3) == 0 )
goto LABEL_29;
}
a1->m128i_i32[v25] = v17;
v26 = v25;
if ( v24 + 1 < v19 )
{
a1->m128i_i32[v26 + 1] = v17;
if ( v19 > v24 + 2 )
a1->m128i_i32[v26 + 2] = v17;
}
LABEL_29:
v18 += v19;
LABEL_30:
if ( v12 == v17 )
goto LABEL_32;
++v17;
}
}
if ( (unsigned int)(a2 - 1) <= 2 )
{
v7 = 0;
v12 = 0;
}
else
{
v2 = a1;
v3 = 0LL;
do
{
v4 = _mm_loadu_si128(v2++);
v5 = _mm_cmpgt_epi32(v4, v3);
v3 = _mm_or_si128(_mm_andnot_si128(v5, v3), _mm_and_si128(v4, v5));
}
while ( v2 != &a1[(unsigned int)a2 >> 2] );
v6 = _mm_srli_si128(v3, 8);
v7 = a2 & 0xFFFFFFFC;
v8 = _mm_cmpgt_epi32(v6, v3);
v9 = _mm_or_si128(_mm_andnot_si128(v8, v3), _mm_and_si128(v6, v8));
v10 = _mm_srli_si128(v9, 4);
v11 = _mm_cmpgt_epi32(v10, v9);
v12 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v11, v9), _mm_and_si128(v10, v11)));
if ( (a2 & 3) == 0 )
goto LABEL_14;
}
v13 = v7;
if ( v12 < a1->m128i_i32[v13] )
v12 = a1->m128i_i32[v7];
if ( a2 > v7 + 1 )
{
if ( v12 < a1->m128i_i32[v13 + 1] )
v12 = a1->m128i_i32[v13 + 1];
if ( a2 > v7 + 2 && v12 < a1->m128i_i32[v13 + 2] )
v12 = a1->m128i_i32[v13 + 2];
}
LABEL_14:
v14 = malloc(4LL * (v12 + 1));
if ( v12 >= 0 )
v14 = memset(v14, 0, 4LL * v12 + 4);
v15 = 0LL;
do
{
v16 = a1->m128i_i32[v15++];
++v14[v16];
}
while ( a2 > (int)v15 );
if ( v12 >= 0 )
goto LABEL_19;
LABEL_32:
free(v14);
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
TEST ESI,ESI
JLE 0x001015a3
LEA EAX,[RSI + -0x1]
MOV EBP,ESI
CMP EAX,0x2
JBE 0x001015be
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM2,XMM2
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_001013d8:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x001013d8
MOVDQA XMM1,XMM2
MOV EAX,EBP
PSRLDQ XMM1,0x8
AND EAX,0xfffffffc
MOVDQA XMM0,XMM1
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 R12D,XMM1
TEST BPL,0x3
JZ 0x00101480
LAB_00101447:
MOVSXD RDX,EAX
LEA RCX,[RDX*0x4]
MOV EDX,dword ptr [RBX + RDX*0x4]
CMP R12D,EDX
CMOVL R12D,EDX
LEA EDX,[RAX + 0x1]
CMP EBP,EDX
JLE 0x00101480
MOV EDX,dword ptr [RBX + RCX*0x1 + 0x4]
CMP R12D,EDX
CMOVL R12D,EDX
ADD EAX,0x2
CMP EBP,EAX
JLE 0x00101480
MOV EAX,dword ptr [RBX + RCX*0x1 + 0x8]
CMP R12D,EAX
CMOVL R12D,EAX
LAB_00101480:
LEA EDI,[R12 + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R8,RAX
TEST R12D,R12D
JS 0x001014b1
MOVSXD RAX,R12D
MOV RDI,R8
XOR ESI,ESI
LEA RDX,[0x4 + RAX*0x4]
CALL 0x001010c0
MOV R8,RAX
LAB_001014b1:
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001014b8:
MOVSXD RDX,dword ptr [RBX + RAX*0x4]
ADD RAX,0x1
ADD dword ptr [R8 + RDX*0x4],0x1
CMP EBP,EAX
JG 0x001014b8
TEST R12D,R12D
JS 0x00101590
LAB_001014d2:
MOVSXD R10,R12D
XOR ESI,ESI
XOR R9D,R9D
NOP word ptr [RAX + RAX*0x1]
LAB_001014e0:
MOV EDX,dword ptr [R8 + RSI*0x4]
MOV EDI,ESI
TEST EDX,EDX
JLE 0x00101577
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x0010159c
MOV ECX,EDX
MOVSXD RAX,R9D
MOVD XMM3,EDI
SHR ECX,0x2
LEA RAX,[RBX + RAX*0x4]
PSHUFD XMM0,XMM3,0x0
SHL RCX,0x4
LEA R11,[RCX + RAX*0x1]
AND ECX,0x10
JZ 0x00101530
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x10
CMP R11,RAX
JZ 0x00101540
NOP dword ptr [RAX + RAX*0x1]
LAB_00101530:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP R11,RAX
JNZ 0x00101530
LAB_00101540:
MOV EAX,EDX
AND EAX,0xfffffffc
LEA ECX,[R9 + RAX*0x1]
TEST DL,0x3
JZ 0x00101574
LAB_0010154e:
MOVSXD RCX,ECX
MOV dword ptr [RBX + RCX*0x4],EDI
LEA R11,[RCX*0x4]
LEA ECX,[RAX + 0x1]
CMP ECX,EDX
JGE 0x00101574
ADD EAX,0x2
MOV dword ptr [RBX + R11*0x1 + 0x4],EDI
CMP EDX,EAX
JLE 0x00101574
MOV dword ptr [RBX + R11*0x1 + 0x8],EDI
LAB_00101574:
ADD R9D,EDX
LAB_00101577:
LEA RAX,[RSI + 0x1]
CMP R10,RSI
JZ 0x00101590
MOV RSI,RAX
JMP 0x001014e0
LAB_00101590:
POP RBX
MOV RDI,R8
POP RBP
POP R12
JMP 0x00101090
LAB_0010159c:
MOV ECX,R9D
XOR EAX,EAX
JMP 0x0010154e
LAB_001015a3:
MOV EDI,0x4
XOR R12D,R12D
CALL 0x001010d0
MOV dword ptr [RAX],0x0
MOV R8,RAX
JMP 0x001014d2
LAB_001015be:
XOR EAX,EAX
XOR R12D,R12D
JMP 0x00101447 | void func0(uint *param_1,ulong param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint uVar5;
int4 *__s;
long lVar6;
uint *puVar7;
int iVar8;
uint uVar10;
int iVar11;
uint uVar12;
bool bVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
long lVar9;
uVar10 = (uint)param_2;
if ((int)uVar10 < 1) {
uVar12 = 0;
__s = (int4 *)malloc(4);
*__s = 0;
}
else {
if (uVar10 - 1 < 3) {
uVar4 = 0;
uVar12 = 0;
LAB_00101447:
if ((int)uVar12 < (int)param_1[(int)uVar4]) {
uVar12 = param_1[(int)uVar4];
}
if ((int)(uVar4 + 1) < (int)uVar10) {
if ((int)uVar12 < (int)param_1[(long)(int)uVar4 + 1]) {
uVar12 = param_1[(long)(int)uVar4 + 1];
}
if (((int)(uVar4 + 2) < (int)uVar10) && ((int)uVar12 < (int)param_1[(long)(int)uVar4 + 2]))
{
uVar12 = param_1[(long)(int)uVar4 + 2];
}
}
}
else {
uVar12 = 0;
uVar5 = 0;
uVar15 = 0;
uVar19 = 0;
puVar7 = param_1;
do {
uVar4 = *puVar7;
puVar1 = puVar7 + 1;
puVar2 = puVar7 + 2;
puVar3 = puVar7 + 3;
puVar7 = puVar7 + 4;
uVar14 = -(uint)((int)uVar12 < (int)uVar4);
uVar16 = -(uint)((int)uVar5 < (int)*puVar1);
uVar17 = -(uint)((int)uVar15 < (int)*puVar2);
uVar18 = -(uint)((int)uVar19 < (int)*puVar3);
uVar12 = ~uVar14 & uVar12 | uVar4 & uVar14;
uVar5 = ~uVar16 & uVar5 | *puVar1 & uVar16;
uVar15 = ~uVar17 & uVar15 | *puVar2 & uVar17;
uVar19 = ~uVar18 & uVar19 | *puVar3 & uVar18;
} while (puVar7 != param_1 + (param_2 >> 2 & 0x3fffffff) * 4);
uVar4 = uVar10 & 0xfffffffc;
uVar12 = ~-(uint)((int)uVar12 < (int)uVar15) & uVar12 |
uVar15 & -(uint)((int)uVar12 < (int)uVar15);
uVar5 = ~-(uint)((int)uVar5 < (int)uVar19) & uVar5 |
uVar19 & -(uint)((int)uVar5 < (int)uVar19);
uVar15 = -(uint)((int)uVar12 < (int)uVar5);
uVar12 = ~uVar15 & uVar12 | uVar5 & uVar15;
if ((param_2 & 3) != 0) goto LAB_00101447;
}
__s = (int4 *)malloc((long)(int)(uVar12 + 1) << 2);
if (-1 < (int)uVar12) {
__s = (int4 *)memset(__s,0,(long)(int)uVar12 * 4 + 4);
}
lVar6 = 0;
do {
puVar7 = param_1 + lVar6;
lVar6 = lVar6 + 1;
__s[(int)*puVar7] = __s[(int)*puVar7] + 1;
} while ((int)lVar6 < (int)uVar10);
if ((int)uVar12 < 0) goto LAB_00101590;
}
iVar11 = 0;
lVar6 = 0;
do {
uVar10 = __s[lVar6];
if (0 < (int)uVar10) {
uVar4 = (uint)lVar6;
if (uVar10 - 1 < 3) {
uVar5 = 0;
iVar8 = iVar11;
LAB_0010154e:
lVar9 = (long)iVar8;
param_1[lVar9] = uVar4;
if (((int)(uVar5 + 1) < (int)uVar10) &&
(param_1[lVar9 + 1] = uVar4, (int)(uVar5 + 2) < (int)uVar10)) {
param_1[lVar9 + 2] = uVar4;
}
}
else {
puVar7 = param_1 + iVar11;
puVar1 = puVar7 + (ulong)(uVar10 >> 2) * 4;
if (((ulong)(uVar10 >> 2) * 0x10 & 0x10) == 0) goto LAB_00101530;
*puVar7 = uVar4;
puVar7[1] = uVar4;
puVar7[2] = uVar4;
puVar7[3] = uVar4;
for (puVar7 = puVar7 + 4; puVar1 != puVar7; puVar7 = puVar7 + 8) {
LAB_00101530:
*puVar7 = uVar4;
puVar7[1] = uVar4;
puVar7[2] = uVar4;
puVar7[3] = uVar4;
puVar7[4] = uVar4;
puVar7[5] = uVar4;
puVar7[6] = uVar4;
puVar7[7] = uVar4;
}
uVar5 = uVar10 & 0xfffffffc;
iVar8 = iVar11 + uVar5;
if ((uVar10 & 3) != 0) goto LAB_0010154e;
}
iVar11 = iVar11 + uVar10;
}
bVar13 = (int)uVar12 != lVar6;
lVar6 = lVar6 + 1;
} while (bVar13);
LAB_00101590:
free(__s);
return;
} |
4,112 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int n, int r) {
double tn = a * pow(r, n - 1);
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 16);
assert(func0(1, 5, 4) == 256);
assert(func0(2, 6, 3) == 486);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm2
movsd %xmm2,-0x28(%rbp)
mov -0x18(%rbp),%eax
sub $0x1,%eax
cvtsi2sd %eax,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm0
callq 1060 <pow@plt>
mulsd -0x28(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movsd [rbp+var_28], xmm2
mov eax, [rbp+var_18]
sub eax, 1
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_1C]
movq rax, xmm3
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
mulsd xmm0, [rbp+var_28]
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
leave
retn | double func0(int a1, int a2, int a3)
{
return pow((double)a3, (double)(a2 - 1)) * (double)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVSD qword ptr [RBP + -0x28],XMM2
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x1c]
MOVQ RAX,XMM3
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MULSD XMM0,qword ptr [RBP + -0x28]
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LEAVE
RET | double func0(int param_1,int param_2,int param_3)
{
double dVar1;
dVar1 = pow((double)param_3,(double)(param_2 + -1));
return dVar1 * (double)param_1;
} |
4,113 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int n, int r) {
double tn = a * pow(r, n - 1);
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 16);
assert(func0(1, 5, 4) == 256);
assert(func0(2, 6, 3) == 486);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
sub $0x1,%esi
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
callq 1050 <pow@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mulsd %xmm1,%xmm0
pop %rbx
retq
| func0:
endbr64
push rbx
mov ebx, edi
sub esi, 1
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
call _pow
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
mulsd xmm0, xmm1
pop rbx
retn | double func0(int a1, int a2, int a3)
{
return (double)a1 * pow((double)a3, (double)(a2 - 1));
} | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
SUB ESI,0x1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
CALL 0x00101050
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
MULSD XMM0,XMM1
POP RBX
RET | double func0(int param_1,int param_2,int param_3)
{
double dVar1;
dVar1 = pow((double)param_3,(double)(param_2 + -1));
return (double)param_1 * dVar1;
} |
4,114 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int n, int r) {
double tn = a * pow(r, n - 1);
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 16);
assert(func0(1, 5, 4) == 256);
assert(func0(2, 6, 3) == 486);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%esi
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
push %rbx
cvtsi2sd %esi,%xmm1
mov %edi,%ebx
cvtsi2sd %edx,%xmm0
callq 1050 <pow@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
pop %rbx
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub esi, 1
pxor xmm0, xmm0
pxor xmm1, xmm1
push rbx
cvtsi2sd xmm1, esi
mov ebx, edi
cvtsi2sd xmm0, edx
call _pow
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
pop rbx
mulsd xmm0, xmm1
retn | double func0(int a1, int a2, int a3)
{
return (double)a1 * pow((double)a3, (double)(a2 - 1));
} | func0:
ENDBR64
SUB ESI,0x1
PXOR XMM0,XMM0
PXOR XMM1,XMM1
PUSH RBX
CVTSI2SD XMM1,ESI
MOV EBX,EDI
CVTSI2SD XMM0,EDX
CALL 0x00101050
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
POP RBX
MULSD XMM0,XMM1
RET | double func0(int param_1,int param_2,int param_3)
{
double dVar1;
dVar1 = pow((double)param_3,(double)(param_2 + -1));
return (double)param_1 * dVar1;
} |
4,115 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int n, int r) {
double tn = a * pow(r, n - 1);
return tn;
}
| int main() {
assert(func0(1, 5, 2) == 16);
assert(func0(1, 5, 4) == 256);
assert(func0(2, 6, 3) == 486);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1,%esi
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
push %rbx
cvtsi2sd %esi,%xmm1
mov %edi,%ebx
cvtsi2sd %edx,%xmm0
callq 1050 <pow@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
pop %rbx
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub esi, 1
pxor xmm0, xmm0
pxor xmm1, xmm1
push rbx
cvtsi2sd xmm1, esi; y
mov ebx, edi
cvtsi2sd xmm0, edx; x
call _pow
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
pop rbx
mulsd xmm0, xmm1
retn | double func0(int a1, int a2, int a3)
{
return (double)a1 * pow((double)a3, (double)(a2 - 1));
} | func0:
ENDBR64
SUB ESI,0x1
PXOR XMM0,XMM0
PXOR XMM1,XMM1
PUSH RBX
CVTSI2SD XMM1,ESI
MOV EBX,EDI
CVTSI2SD XMM0,EDX
CALL 0x00101050
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
POP RBX
MULSD XMM0,XMM1
RET | double func0(int param_1,int param_2,int param_3)
{
double dVar1;
dVar1 = pow((double)param_3,(double)(param_2 + -1));
return (double)param_1 * dVar1;
} |
4,116 | func0 |
#include <assert.h>
int rev(int num) {
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
| int func0(int n) {
return (2 * rev(n) == n + 1);
}
| int main() {
assert(func0(70) == 0);
assert(func0(23) == 0);
assert(func0(73) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x8,%rsp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
mov %eax,%edi
callq 1149 <rev>
lea (%rax,%rax,1),%edx
mov -0x4(%rbp),%eax
add $0x1,%eax
cmp %eax,%edx
sete %al
movzbl %al,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 8
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
mov edi, eax
call rev
lea edx, [rax+rax]
mov eax, [rbp+var_4]
add eax, 1
cmp edx, eax
setz al
movzx eax, al
leave
retn | _BOOL8 func0(unsigned int a1)
{
return 2 * (unsigned int)rev(a1) == a1 + 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x8
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
MOV EDI,EAX
CALL 0x00101149
LEA EDX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP EDX,EAX
SETZ AL
MOVZX EAX,AL
LEAVE
RET | bool func0(int param_1)
{
int iVar1;
iVar1 = rev(param_1);
return iVar1 * 2 == param_1 + 1;
} |
4,117 | func0 |
#include <assert.h>
int rev(int num) {
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
| int func0(int n) {
return (2 * rev(n) == n + 1);
}
| int main() {
assert(func0(70) == 0);
assert(func0(23) == 0);
assert(func0(73) == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
callq 1149 <rev>
add %eax,%eax
add $0x1,%ebx
cmp %ebx,%eax
sete %al
movzbl %al,%eax
pop %rbx
retq
| func0:
endbr64
push rbx
mov ebx, edi
call rev
add eax, eax
add ebx, 1
cmp eax, ebx
setz al
movzx eax, al
pop rbx
retn | _BOOL8 func0(int a1)
{
return 2 * (unsigned int)rev() == a1 + 1;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
CALL 0x00101149
ADD EAX,EAX
ADD EBX,0x1
CMP EAX,EBX
SETZ AL
MOVZX EAX,AL
POP RBX
RET | bool func0(int param_1)
{
int iVar1;
iVar1 = rev();
return iVar1 * 2 == param_1 + 1;
} |
4,118 | func0 |
#include <assert.h>
int rev(int num) {
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
| int func0(int n) {
return (2 * rev(n) == n + 1);
}
| int main() {
assert(func0(70) == 0);
assert(func0(23) == 0);
assert(func0(73) == 1);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 11d0 <func0+0x50>
mov %edi,%edx
xor %ecx,%ecx
mov $0xcccccccd,%r8d
nopw 0x0(%rax,%rax,1)
mov %edx,%eax
lea (%rcx,%rcx,4),%esi
mov %edx,%r9d
imul %r8,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%r9d
lea (%r9,%rsi,2),%ecx
mov %edx,%esi
mov %eax,%edx
cmp $0x9,%esi
jg 1198 <func0+0x18>
add %ecx,%ecx
add $0x1,%edi
xor %eax,%eax
cmp %ecx,%edi
sete %al
retq
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
add $0x1,%edi
xor %eax,%eax
cmp %ecx,%edi
sete %al
retq
nopl (%rax)
| func0:
endbr64
test edi, edi
jle short loc_11D0
mov edx, edi
xor ecx, ecx
mov r9d, 0CCCCCCCDh
nop word ptr [rax+rax+00h]
loc_1198:
mov eax, edx
lea r8d, [rcx+rcx*4]
mov esi, edx
imul rax, r9
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub esi, ecx
lea ecx, [rsi+r8*2]
mov esi, edx
mov edx, eax
cmp esi, 9
jg short loc_1198
add ecx, ecx
add edi, 1
xor eax, eax
cmp edi, ecx
setz al
retn
loc_11D0:
xor ecx, ecx
add edi, 1
xor eax, eax
cmp edi, ecx
setz al
retn | _BOOL8 func0(int a1)
{
unsigned int v1; // edx
unsigned int v2; // ecx
int v3; // esi
if ( a1 <= 0 )
return a1 == -1;
v1 = a1;
v2 = 0;
do
{
v2 = v1 % 0xA + 10 * v2;
v3 = v1;
v1 /= 0xAu;
}
while ( v3 > 9 );
return a1 + 1 == 2 * v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011d0
MOV EDX,EDI
XOR ECX,ECX
MOV R9D,0xcccccccd
NOP word ptr [RAX + RAX*0x1]
LAB_00101198:
MOV EAX,EDX
LEA R8D,[RCX + RCX*0x4]
MOV ESI,EDX
IMUL RAX,R9
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB ESI,ECX
LEA ECX,[RSI + R8*0x2]
MOV ESI,EDX
MOV EDX,EAX
CMP ESI,0x9
JG 0x00101198
ADD ECX,ECX
ADD EDI,0x1
XOR EAX,EAX
CMP EDI,ECX
SETZ AL
RET
LAB_001011d0:
XOR ECX,ECX
ADD EDI,0x1
XOR EAX,EAX
CMP EDI,ECX
SETZ AL
RET | bool func0(uint param_1)
{
int iVar1;
ulong uVar2;
int iVar3;
if (0 < (int)param_1) {
uVar2 = (ulong)param_1;
iVar1 = 0;
do {
iVar3 = (int)uVar2;
iVar1 = iVar3 + (int)(uVar2 / 10) * -10 + iVar1 * 10;
uVar2 = uVar2 / 10;
} while (9 < iVar3);
return param_1 + 1 == iVar1 * 2;
}
return param_1 == 0xffffffff;
} |
4,119 | func0 |
#include <assert.h>
int rev(int num) {
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
| int func0(int n) {
return (2 * rev(n) == n + 1);
}
| int main() {
assert(func0(70) == 0);
assert(func0(23) == 0);
assert(func0(73) == 1);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 11d0 <func0+0x50>
mov %edi,%edx
xor %ecx,%ecx
mov $0xcccccccd,%r8d
nopw 0x0(%rax,%rax,1)
mov %edx,%eax
lea (%rcx,%rcx,4),%esi
mov %edx,%r9d
imul %r8,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%r9d
lea (%r9,%rsi,2),%ecx
mov %edx,%esi
mov %eax,%edx
cmp $0x9,%esi
jg 1198 <func0+0x18>
add %ecx,%ecx
add $0x1,%edi
xor %eax,%eax
cmp %ecx,%edi
sete %al
retq
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
add $0x1,%edi
xor %eax,%eax
cmp %ecx,%edi
sete %al
retq
nopl (%rax)
| func0:
endbr64
test edi, edi
jle short loc_11D0
mov edx, edi
xor ecx, ecx
mov r9d, 0CCCCCCCDh
nop word ptr [rax+rax+00h]
loc_1198:
mov eax, edx
lea r8d, [rcx+rcx*4]
mov esi, edx
imul rax, r9
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub esi, ecx
lea ecx, [rsi+r8*2]
mov esi, edx
mov edx, eax
cmp esi, 9
jg short loc_1198
add ecx, ecx
add edi, 1
xor eax, eax
cmp edi, ecx
setz al
retn
loc_11D0:
xor ecx, ecx
add edi, 1
xor eax, eax
cmp edi, ecx
setz al
retn | _BOOL8 func0(int a1)
{
unsigned int v1; // edx
unsigned int v2; // ecx
int v3; // esi
if ( a1 <= 0 )
return a1 == -1;
v1 = a1;
v2 = 0;
do
{
v2 = v1 % 0xA + 10 * v2;
v3 = v1;
v1 /= 0xAu;
}
while ( v3 > 9 );
return a1 + 1 == 2 * v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011d0
MOV EDX,EDI
XOR ECX,ECX
MOV R9D,0xcccccccd
NOP word ptr [RAX + RAX*0x1]
LAB_00101198:
MOV EAX,EDX
LEA R8D,[RCX + RCX*0x4]
MOV ESI,EDX
IMUL RAX,R9
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB ESI,ECX
LEA ECX,[RSI + R8*0x2]
MOV ESI,EDX
MOV EDX,EAX
CMP ESI,0x9
JG 0x00101198
ADD ECX,ECX
ADD EDI,0x1
XOR EAX,EAX
CMP EDI,ECX
SETZ AL
RET
LAB_001011d0:
XOR ECX,ECX
ADD EDI,0x1
XOR EAX,EAX
CMP EDI,ECX
SETZ AL
RET | bool func0(uint param_1)
{
int iVar1;
ulong uVar2;
int iVar3;
if (0 < (int)param_1) {
uVar2 = (ulong)param_1;
iVar1 = 0;
do {
iVar3 = (int)uVar2;
iVar1 = iVar3 + (int)(uVar2 / 10) * -10 + iVar1 * 10;
uVar2 = uVar2 / 10;
} while (9 < iVar3);
return param_1 + 1 == iVar1 * 2;
}
return param_1 == 0xffffffff;
} |
4,120 | func0 |
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n; j++) {
if (arr[i] < arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
int num = arr[0];
for (int i = 1; i < n; i++) {
num = num * 10 + arr[i];
}
return num;
}
| int main() {
int arr1[3] = {1, 2, 3};
int arr2[4] = {4, 5, 6, 1};
int arr3[4] = {1, 2, 3, 9};
assert(func0(arr1, 3) == 321);
assert(func0(arr2, 4) == 6541);
assert(func0(arr3, 4) == 9321);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 1235 <func0+0xcc>
mov -0x14(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
jmpq 1225 <func0+0xbc>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 1221 <func0+0xb8>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1192 <func0+0x29>
addl $0x1,-0x14(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x14(%rbp)
jl 1184 <func0+0x1b>
mov -0x28(%rbp),%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 1283 <func0+0x11a>
mov -0xc(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,%ecx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %ecx,%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1256 <func0+0xed>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
jmp loc_1235
loc_1184:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_10], eax
jmp loc_1225
loc_1192:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_1221
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_14]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_1221:
add [rbp+var_10], 1
loc_1225:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl loc_1192
add [rbp+var_14], 1
loc_1235:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_14], eax
jl loc_1184
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_C], eax
mov [rbp+var_8], 1
jmp short loc_1283
loc_1256:
mov edx, [rbp+var_C]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov ecx, eax
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
add eax, ecx
mov [rbp+var_C], eax
add [rbp+var_8], 1
loc_1283:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_2C]
jl short loc_1256
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(unsigned int *a1, int a2)
{
int i; // [rsp+18h] [rbp-14h]
int j; // [rsp+1Ch] [rbp-10h]
unsigned int v5; // [rsp+20h] [rbp-Ch]
int k; // [rsp+24h] [rbp-8h]
unsigned int v7; // [rsp+28h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( (int)a1[i] < (int)a1[j] )
{
v7 = a1[i];
a1[i] = a1[j];
a1[j] = v7;
}
}
}
v5 = *a1;
for ( k = 1; k < a2; ++k )
v5 = 10 * v5 + a1[k];
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101235
LAB_00101184:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00101225
LAB_00101192:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x00101221
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_00101221:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101225:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101192
ADD dword ptr [RBP + -0x14],0x1
LAB_00101235:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JL 0x00101184
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101283
LAB_00101256:
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD EAX,ECX
MOV dword ptr [RBP + -0xc],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_00101283:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101256
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int local_1c;
int local_18;
int local_14;
int local_10;
for (local_1c = 0; local_18 = local_1c, local_1c < param_2 + -1; local_1c = local_1c + 1) {
while (local_18 = local_18 + 1, local_18 < param_2) {
if (param_1[local_1c] < param_1[local_18]) {
iVar1 = param_1[local_1c];
param_1[local_1c] = param_1[local_18];
param_1[local_18] = iVar1;
}
}
}
local_14 = *param_1;
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
local_14 = param_1[local_10] + local_14 * 10;
}
return local_14;
} |
4,121 | func0 |
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n; j++) {
if (arr[i] < arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
int num = arr[0];
for (int i = 1; i < n; i++) {
num = num * 10 + arr[i];
}
return num;
}
| int main() {
int arr1[3] = {1, 2, 3};
int arr2[4] = {4, 5, 6, 1};
int arr3[4] = {1, 2, 3, 9};
assert(func0(arr1, 3) == 321);
assert(func0(arr2, 4) == 6541);
assert(func0(arr3, 4) == 9321);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11b6 <func0+0x4d>
mov %rdi,%r8
lea -0x2(%rsi),%r10d
add $0x2,%r10
mov $0x1,%r9d
jmp 11ac <func0+0x43>
add $0x1,%rax
cmp %eax,%esi
jle 119f <func0+0x36>
mov (%r8),%edx
mov (%rdi,%rax,4),%ecx
cmp %ecx,%edx
jge 1185 <func0+0x1c>
mov %ecx,(%r8)
mov %edx,(%rdi,%rax,4)
jmp 1185 <func0+0x1c>
add $0x1,%r9
add $0x4,%r8
cmp %r10,%r9
je 11b6 <func0+0x4d>
cmp %r9d,%esi
jle 119f <func0+0x36>
mov %r9,%rax
jmp 118d <func0+0x24>
mov (%rdi),%edx
cmp $0x1,%esi
jle 11da <func0+0x71>
lea 0x4(%rdi),%rax
lea -0x2(%rsi),%ecx
lea 0x8(%rdi,%rcx,4),%rsi
lea (%rdx,%rdx,4),%ecx
mov (%rax),%edx
lea (%rdx,%rcx,2),%edx
add $0x4,%rax
cmp %rsi,%rax
jne 11c9 <func0+0x60>
mov %edx,%eax
retq
| func0:
endbr64
push rbp
push rbx
mov r11, rdi
mov r9d, esi
cmp esi, 1
jle short loc_11D4
lea rsi, [rdi+4]
lea r10d, [r9-2]
add r10, 2
mov r8d, 1
lea ebp, [r9-1]
lea rbx, [rdi+8]
jmp short loc_11BC
loc_1196:
add rax, 4
cmp rax, rdi
jz short loc_11AF
loc_119F:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jge short loc_1196
mov [rsi-4], ecx
mov [rax], edx
jmp short loc_1196
loc_11AF:
add r8, 1
add rsi, 4
cmp r8, r10
jz short loc_11D4
loc_11BC:
cmp r9d, r8d
jle short loc_11AF
mov eax, ebp
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [rbx+rax*4]
mov rax, rsi
jmp short loc_119F
loc_11D4:
mov edx, [r11]
cmp r9d, 1
jle short loc_11FB
lea rax, [r11+4]
lea ecx, [r9-2]
lea rsi, [r11+rcx*4+8]
loc_11EA:
lea ecx, [rdx+rdx*4]
mov edx, [rax]
lea edx, [rdx+rcx*2]
add rax, 4
cmp rax, rsi
jnz short loc_11EA
loc_11FB:
mov eax, edx
pop rbx
pop rbp
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int *v3; // rsi
long long v4; // r8
unsigned int *v5; // rax
signed int v6; // edx
unsigned int v7; // edx
unsigned int *v8; // rax
if ( a2 > 1 )
{
v3 = a1 + 1;
v4 = 1LL;
do
{
if ( a2 > (int)v4 )
{
v5 = v3;
do
{
v6 = *(v3 - 1);
if ( v6 < (int)*v5 )
{
*(v3 - 1) = *v5;
*v5 = v6;
}
++v5;
}
while ( v5 != &a1[v4 + 1 + (unsigned int)(a2 - 1 - v4)] );
}
++v4;
++v3;
}
while ( v4 != (unsigned int)(a2 - 2) + 2LL );
}
v7 = *a1;
if ( a2 > 1 )
{
v8 = a1 + 1;
do
v7 = *v8++ + 10 * v7;
while ( v8 != &a1[a2 - 2 + 2] );
}
return v7;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV R11,RDI
MOV R9D,ESI
CMP ESI,0x1
JLE 0x001011d4
LEA RSI,[RDI + 0x4]
LEA R10D,[R9 + -0x2]
ADD R10,0x2
MOV R8D,0x1
LEA EBP,[R9 + -0x1]
LEA RBX,[RDI + 0x8]
JMP 0x001011bc
LAB_00101196:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011af
LAB_0010119f:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x00101196
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
JMP 0x00101196
LAB_001011af:
ADD R8,0x1
ADD RSI,0x4
CMP R8,R10
JZ 0x001011d4
LAB_001011bc:
CMP R9D,R8D
JLE 0x001011af
MOV EAX,EBP
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[RBX + RAX*0x4]
MOV RAX,RSI
JMP 0x0010119f
LAB_001011d4:
MOV EDX,dword ptr [R11]
CMP R9D,0x1
JLE 0x001011fb
LEA RAX,[R11 + 0x4]
LEA ECX,[R9 + -0x2]
LEA RSI,[R11 + RCX*0x4 + 0x8]
LAB_001011ea:
LEA ECX,[RDX + RDX*0x4]
MOV EDX,dword ptr [RAX]
LEA EDX,[RDX + RCX*0x2]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001011ea
LAB_001011fb:
MOV EAX,EDX
POP RBX
POP RBP
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
long lVar4;
if (1 < param_2) {
piVar2 = param_1 + 1;
lVar4 = 1;
do {
if ((int)lVar4 < param_2) {
piVar1 = piVar2;
do {
iVar3 = piVar2[-1];
if (iVar3 < *piVar1) {
piVar2[-1] = *piVar1;
*piVar1 = iVar3;
}
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + lVar4 + (ulong)(uint)((param_2 + -1) - (int)lVar4) + 1);
}
lVar4 = lVar4 + 1;
piVar2 = piVar2 + 1;
} while (lVar4 != (ulong)(param_2 - 2) + 2);
}
iVar3 = *param_1;
if (1 < param_2) {
piVar2 = param_1 + 1;
do {
iVar3 = *piVar2 + iVar3 * 10;
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 2);
}
return iVar3;
} |
4,122 | func0 |
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n; j++) {
if (arr[i] < arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
int num = arr[0];
for (int i = 1; i < n; i++) {
num = num * 10 + arr[i];
}
return num;
}
| int main() {
int arr1[3] = {1, 2, 3};
int arr2[4] = {4, 5, 6, 1};
int arr3[4] = {1, 2, 3, 9};
assert(func0(arr1, 3) == 321);
assert(func0(arr2, 4) == 6541);
assert(func0(arr3, 4) == 9321);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 12e5 <func0+0x55>
lea -0x2(%rsi),%r10d
mov %rdi,%r8
mov $0x1,%r9d
add $0x2,%r10
nopw 0x0(%rax,%rax,1)
cmp %r9d,%esi
jle 12d8 <func0+0x48>
mov %r9,%rax
nopl 0x0(%rax,%rax,1)
mov (%r8),%edx
mov (%rdi,%rax,4),%ecx
cmp %ecx,%edx
jge 12d0 <func0+0x40>
mov %ecx,(%r8)
mov %edx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 12c0 <func0+0x30>
add $0x1,%r9
add $0x4,%r8
cmp %r10,%r9
jne 12b0 <func0+0x20>
mov (%rdi),%r8d
cmp $0x1,%esi
jle 1313 <func0+0x83>
lea -0x2(%rsi),%edx
lea 0x4(%rdi),%rax
lea 0x8(%rdi,%rdx,4),%rsi
nopl 0x0(%rax)
mov (%rax),%edx
lea (%r8,%r8,4),%ecx
add $0x4,%rax
lea (%rdx,%rcx,2),%r8d
cmp %rax,%rsi
jne 1300 <func0+0x70>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov r11, rdi
mov r9d, esi
push rbx
cmp esi, 1
jle short loc_1304
lea r10d, [r9-2]
lea rsi, [rdi+4]
mov r8d, 1
add r10, 2
lea ebp, [r9-1]
lea rbx, [rdi+8]
nop dword ptr [rax+rax+00h]
loc_12C0:
cmp r9d, r8d
jle short loc_12F7
mov eax, ebp
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [rbx+rax*4]
mov rax, rsi
nop word ptr [rax+rax+00000000h]
loc_12E0:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jge short loc_12EE
mov [rsi-4], ecx
mov [rax], edx
loc_12EE:
add rax, 4
cmp rax, rdi
jnz short loc_12E0
loc_12F7:
add r8, 1
add rsi, 4
cmp r8, r10
jnz short loc_12C0
loc_1304:
mov r8d, [r11]
cmp r9d, 1
jle short loc_1333
lea edx, [r9-2]
lea rax, [r11+4]
lea rsi, [r11+rdx*4+8]
nop word ptr [rax+rax+00h]
loc_1320:
mov edx, [rax]
lea ecx, [r8+r8*4]
add rax, 4
lea r8d, [rdx+rcx*2]
cmp rsi, rax
jnz short loc_1320
loc_1333:
mov eax, r8d
pop rbx
pop rbp
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int *v3; // rsi
long long v4; // r8
unsigned int *v5; // rax
int v6; // edx
unsigned int v7; // r8d
int *v8; // rax
int v9; // edx
if ( a2 > 1 )
{
v3 = a1 + 1;
v4 = 1LL;
do
{
if ( a2 > (int)v4 )
{
v5 = v3;
do
{
v6 = *(v3 - 1);
if ( v6 < (int)*v5 )
{
*(v3 - 1) = *v5;
*v5 = v6;
}
++v5;
}
while ( v5 != &a1[v4 + 1 + (unsigned int)(a2 - 1 - v4)] );
}
++v4;
++v3;
}
while ( v4 != (unsigned int)(a2 - 2) + 2LL );
}
v7 = *a1;
if ( a2 > 1 )
{
v8 = (int *)(a1 + 1);
do
{
v9 = *v8++;
v7 = v9 + 10 * v7;
}
while ( &a1[a2 - 2 + 2] != (unsigned int *)v8 );
}
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV R11,RDI
MOV R9D,ESI
PUSH RBX
CMP ESI,0x1
JLE 0x00101304
LEA R10D,[R9 + -0x2]
LEA RSI,[RDI + 0x4]
MOV R8D,0x1
ADD R10,0x2
LEA EBP,[R9 + -0x1]
LEA RBX,[RDI + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
CMP R9D,R8D
JLE 0x001012f7
MOV EAX,EBP
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[RBX + RAX*0x4]
MOV RAX,RSI
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001012e0:
MOV EDX,dword ptr [RSI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x001012ee
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_001012ee:
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x001012e0
LAB_001012f7:
ADD R8,0x1
ADD RSI,0x4
CMP R8,R10
JNZ 0x001012c0
LAB_00101304:
MOV R8D,dword ptr [R11]
CMP R9D,0x1
JLE 0x00101333
LEA EDX,[R9 + -0x2]
LEA RAX,[R11 + 0x4]
LEA RSI,[R11 + RDX*0x4 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101320:
MOV EDX,dword ptr [RAX]
LEA ECX,[R8 + R8*0x4]
ADD RAX,0x4
LEA R8D,[RDX + RCX*0x2]
CMP RSI,RAX
JNZ 0x00101320
LAB_00101333:
MOV EAX,R8D
POP RBX
POP RBP
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
long lVar5;
if (1 < param_2) {
piVar3 = param_1 + 1;
lVar5 = 1;
do {
if ((int)lVar5 < param_2) {
piVar2 = piVar3;
do {
iVar4 = piVar3[-1];
if (iVar4 < *piVar2) {
piVar3[-1] = *piVar2;
*piVar2 = iVar4;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + lVar5 + (ulong)(uint)((param_2 + -1) - (int)lVar5) + 1);
}
lVar5 = lVar5 + 1;
piVar3 = piVar3 + 1;
} while (lVar5 != (ulong)(param_2 - 2) + 2);
}
iVar4 = *param_1;
if (1 < param_2) {
piVar3 = param_1 + 1;
do {
iVar1 = *piVar3;
piVar3 = piVar3 + 1;
iVar4 = iVar1 + iVar4 * 10;
} while (param_1 + (ulong)(param_2 - 2) + 2 != piVar3);
}
return iVar4;
} |
4,123 | func0 |
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n; j++) {
if (arr[i] < arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
int num = arr[0];
for (int i = 1; i < n; i++) {
num = num * 10 + arr[i];
}
return num;
}
| int main() {
int arr1[3] = {1, 2, 3};
int arr2[4] = {4, 5, 6, 1};
int arr3[4] = {1, 2, 3, 9};
assert(func0(arr1, 3) == 321);
assert(func0(arr2, 4) == 6541);
assert(func0(arr3, 4) == 9321);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 12d5 <func0+0x55>
lea -0x2(%rsi),%r10d
mov %rdi,%r8
mov $0x1,%r9d
add $0x2,%r10
nopw 0x0(%rax,%rax,1)
cmp %r9d,%esi
jle 12c8 <func0+0x48>
mov %r9,%rax
nopl 0x0(%rax,%rax,1)
mov (%r8),%edx
mov (%rdi,%rax,4),%ecx
cmp %ecx,%edx
jge 12c0 <func0+0x40>
mov %ecx,(%r8)
mov %edx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 12b0 <func0+0x30>
add $0x1,%r9
add $0x4,%r8
cmp %r10,%r9
jne 12a0 <func0+0x20>
mov (%rdi),%r8d
cmp $0x1,%esi
jle 1303 <func0+0x83>
lea -0x2(%rsi),%edx
lea 0x4(%rdi),%rax
lea 0x8(%rdi,%rdx,4),%rsi
nopl 0x0(%rax)
mov (%rax),%edx
lea (%r8,%r8,4),%ecx
add $0x4,%rax
lea (%rdx,%rcx,2),%r8d
cmp %rax,%rsi
jne 12f0 <func0+0x70>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
cmp esi, 1
jle loc_1309
lea r10, [rdi+4]
lea r12d, [rsi-2]
mov r11d, esi
mov r9d, 1
mov rdi, r10
lea rbx, [rbp+8]
lea r13d, [rsi-1]
nop word ptr [rax+rax+00h]
loc_12A8:
cmp esi, r9d
jle short loc_12D7
mov eax, r13d
sub eax, r9d
lea rax, [r9+rax-1]
lea r8, [rbx+rax*4]
mov rax, rdi
nop
loc_12C0:
mov edx, [rdi-4]
mov ecx, [rax]
cmp edx, ecx
jge short loc_12CE
mov [rdi-4], ecx
mov [rax], edx
loc_12CE:
add rax, 4
cmp r8, rax
jnz short loc_12C0
loc_12D7:
add r9, 1
add rdi, 4
cmp r9, r11
jnz short loc_12A8
mov eax, [rbp+0]
lea rcx, [rbx+r12*4]
nop dword ptr [rax+rax+00h]
loc_12F0:
lea edx, [rax+rax*4]
mov eax, [r10]
add r10, 4
lea eax, [rax+rdx*2]
cmp rcx, r10
jnz short loc_12F0
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1309:
pop rbx
mov eax, [rdi]
pop rbp
pop r12
pop r13
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int *v3; // r10
long long v4; // r9
unsigned int *v5; // rdi
unsigned int *v6; // rbx
unsigned int *v7; // rax
signed int v8; // edx
long long result; // rax
int v10; // edx
int v11; // eax
if ( a2 <= 1 )
return *a1;
v3 = a1 + 1;
v4 = 1LL;
v5 = a1 + 1;
v6 = a1 + 2;
do
{
if ( a2 > (int)v4 )
{
v7 = v5;
do
{
v8 = *(v5 - 1);
if ( v8 < (int)*v7 )
{
*(v5 - 1) = *v7;
*v7 = v8;
}
++v7;
}
while ( &v6[v4 - 1 + (unsigned int)(a2 - 1 - v4)] != v7 );
}
++v4;
++v5;
}
while ( v4 != a2 );
LODWORD(result) = *a1;
do
{
v10 = 5 * result;
v11 = *v3++;
result = (unsigned int)(v11 + 2 * v10);
}
while ( &v6[a2 - 2] != v3 );
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
CMP ESI,0x1
JLE 0x00101309
LEA R10,[RDI + 0x4]
LEA R12D,[RSI + -0x2]
MOV R11D,ESI
MOV R9D,0x1
MOV RDI,R10
LEA RBX,[RBP + 0x8]
LEA R13D,[RSI + -0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_001012a8:
CMP ESI,R9D
JLE 0x001012d7
MOV EAX,R13D
SUB EAX,R9D
LEA RAX,[R9 + RAX*0x1 + -0x1]
LEA R8,[RBX + RAX*0x4]
MOV RAX,RDI
NOP
LAB_001012c0:
MOV EDX,dword ptr [RDI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x001012ce
MOV dword ptr [RDI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_001012ce:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x001012c0
LAB_001012d7:
ADD R9,0x1
ADD RDI,0x4
CMP R9,R11
JNZ 0x001012a8
MOV EAX,dword ptr [RBP]
LEA RCX,[RBX + R12*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012f0:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [R10]
ADD R10,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RCX,R10
JNZ 0x001012f0
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101309:
POP RBX
MOV EAX,dword ptr [RDI]
POP RBP
POP R12
POP R13
RET | int func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
int *piVar6;
if (1 < (int)param_2) {
piVar6 = param_1 + 1;
uVar5 = 1;
piVar4 = piVar6;
do {
if ((int)uVar5 < (int)param_2) {
piVar3 = piVar4;
do {
iVar2 = piVar4[-1];
if (iVar2 < *piVar3) {
piVar4[-1] = *piVar3;
*piVar3 = iVar2;
}
piVar3 = piVar3 + 1;
} while (param_1 + uVar5 + ((param_2 - 1) - (int)uVar5) + 1 != piVar3);
}
uVar5 = uVar5 + 1;
piVar4 = piVar4 + 1;
} while (uVar5 != param_2);
iVar2 = *param_1;
do {
iVar1 = *piVar6;
piVar6 = piVar6 + 1;
iVar2 = iVar1 + iVar2 * 10;
} while (param_1 + (ulong)(param_2 - 2) + 2 != piVar6);
return iVar2;
}
return *param_1;
} |
4,124 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y) {
return ((x ^ y) < 0);
}
| int main() {
assert(func0(1, -2) == true);
assert(func0(3, 2) == false);
assert(func0(-10, -10) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
xor -0x8(%rbp),%eax
shr $0x1f,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
xor eax, [rbp+var_8]
shr eax, 1Fh
pop rbp
retn | long long func0(unsigned int a1, int a2)
{
return (a2 ^ a1) >> 31;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,dword ptr [RBP + -0x8]
SHR EAX,0x1f
POP RBP
RET | uint func0(uint param_1,uint param_2)
{
return (param_1 ^ param_2) >> 0x1f;
} |
4,125 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y) {
return ((x ^ y) < 0);
}
| int main() {
assert(func0(1, -2) == true);
assert(func0(3, 2) == false);
assert(func0(-10, -10) == false);
return 0;
}
| O1 | c | func0:
endbr64
xor %esi,%edi
mov %edi,%eax
shr $0x1f,%eax
retq
| func0:
endbr64
xor edi, esi
shr edi, 1Fh
mov eax, edi
retn | long long func0(unsigned int a1, int a2)
{
return (a2 ^ a1) >> 31;
} | func0:
ENDBR64
XOR EDI,ESI
SHR EDI,0x1f
MOV EAX,EDI
RET | uint func0(uint param_1,uint param_2)
{
return (param_1 ^ param_2) >> 0x1f;
} |
4,126 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y) {
return ((x ^ y) < 0);
}
| int main() {
assert(func0(1, -2) == true);
assert(func0(3, 2) == false);
assert(func0(-10, -10) == false);
return 0;
}
| O2 | c | func0:
endbr64
xor %esi,%edi
mov %edi,%eax
shr $0x1f,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
xor edi, esi
shr edi, 1Fh
mov eax, edi
retn | long long func0(unsigned int a1, int a2)
{
return (a2 ^ a1) >> 31;
} | func0:
ENDBR64
XOR EDI,ESI
SHR EDI,0x1f
MOV EAX,EDI
RET | uint func0(uint param_1,uint param_2)
{
return (param_1 ^ param_2) >> 0x1f;
} |
4,127 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x, int y) {
return ((x ^ y) < 0);
}
| int main() {
assert(func0(1, -2) == true);
assert(func0(3, 2) == false);
assert(func0(-10, -10) == false);
return 0;
}
| O3 | c | func0:
endbr64
xor %esi,%edi
mov %edi,%eax
shr $0x1f,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
xor edi, esi
shr edi, 1Fh
mov eax, edi
retn | long long func0(unsigned int a1, int a2)
{
return (a2 ^ a1) >> 31;
} | func0:
ENDBR64
XOR EDI,ESI
SHR EDI,0x1f
MOV EAX,EDI
RET | uint func0(uint param_1,uint param_2)
{
return (param_1 ^ param_2) >> 0x1f;
} |
4,128 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * n - 2 * n;
}
| int main() {
assert(func0(5) == 65);
assert(func0(10) == 280);
assert(func0(15) == 645);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov %edx,%eax
add %eax,%eax
add %eax,%edx
mov -0x4(%rbp),%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
imul eax, eax
mov edx, eax
mov eax, edx
add eax, eax
add edx, eax
mov eax, [rbp+var_4]
add eax, eax
sub edx, eax
mov eax, edx
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * a1 - 2 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
MOV EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
SUB EDX,EAX
MOV EAX,EDX
POP RBP
RET | int func0(int param_1)
{
return param_1 * param_1 * 3 + param_1 * -2;
} |
4,129 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * n - 2 * n;
}
| int main() {
assert(func0(5) == 65);
assert(func0(10) == 280);
assert(func0(15) == 645);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
imul %edi,%eax
lea (%rax,%rax,2),%eax
add %edi,%edi
sub %edi,%eax
retq
| func0:
endbr64
mov eax, edi
imul eax, edi
lea eax, [rax+rax*2]
add edi, edi
sub eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * a1 - 2 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
IMUL EAX,EDI
LEA EAX,[RAX + RAX*0x2]
ADD EDI,EDI
SUB EAX,EDI
RET | int func0(int param_1)
{
return param_1 * param_1 * 3 + param_1 * -2;
} |
4,130 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * n - 2 * n;
}
| int main() {
assert(func0(5) == 65);
assert(func0(10) == 280);
assert(func0(15) == 645);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
imul %edi,%eax
add %edi,%edi
lea (%rax,%rax,2),%eax
sub %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
imul eax, edi
add edi, edi
lea eax, [rax+rax*2]
sub eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * a1 - 2 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
IMUL EAX,EDI
ADD EDI,EDI
LEA EAX,[RAX + RAX*0x2]
SUB EAX,EDI
RET | int func0(int param_1)
{
return param_1 * param_1 * 3 + param_1 * -2;
} |
4,131 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * n - 2 * n;
}
| int main() {
assert(func0(5) == 65);
assert(func0(10) == 280);
assert(func0(15) == 645);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
imul %edi,%eax
add %edi,%edi
lea (%rax,%rax,2),%eax
sub %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
imul eax, edi
add edi, edi
lea eax, [rax+rax*2]
sub eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * a1 - 2 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
IMUL EAX,EDI
ADD EDI,EDI
LEA EAX,[RAX + RAX*0x2]
SUB EAX,EDI
RET | int func0(int param_1)
{
return param_1 * param_1 * 3 + param_1 * -2;
} |
4,132 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int *mls = (int *)malloc(n * sizeof(int));
int max = 0;
for (int i = 0; i < n; i++) {
mls[i] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (abs(arr[i] - arr[j]) <= 1 && mls[i] < mls[j] + 1) {
mls[i] = mls[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mls[i]) {
max = mls[i];
}
}
free(mls);
return max;
}
| int main() {
int arr1[] = {2, 5, 6, 3, 7, 6, 5, 8};
assert(func0(arr1, 8) == 5);
int arr2[] = {-2, -1, 5, -1, 4, 0, 3};
assert(func0(arr2, 7) == 4);
int arr3[] = {9, 11, 13, 15, 18};
assert(func0(arr3, 5) == 1);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmp 121f <func0+0x56>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movl $0x1,(%rax)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1201 <func0+0x38>
movl $0x0,-0x14(%rbp)
jmpq 1320 <func0+0x157>
movl $0x0,-0x10(%rbp)
jmpq 1310 <func0+0x147>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
cmp $0xffffffff,%eax
jl 130c <func0+0x143>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
cmp $0x1,%eax
jg 130c <func0+0x143>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jl 130c <func0+0x143>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 123f <func0+0x76>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1233 <func0+0x6a>
movl $0x0,-0xc(%rbp)
jmp 136d <func0+0x1a4>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x1c(%rbp)
jge 1369 <func0+0x1a0>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x1c(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1335 <func0+0x16c>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x1c(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp short loc_121F
loc_1201:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov dword ptr [rax], 1
add [rbp+var_18], 1
loc_121F:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_1201
mov [rbp+var_14], 0
jmp loc_131C
loc_1233:
mov [rbp+var_10], 0
jmp loc_130C
loc_123F:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
sub edx, eax
cmp edx, 0FFFFFFFFh
jl loc_1308
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
sub edx, eax
cmp edx, 1
jg short loc_1308
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jl short loc_1308
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
add edx, 1
mov [rax], edx
loc_1308:
add [rbp+var_10], 1
loc_130C:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jl loc_123F
add [rbp+var_14], 1
loc_131C:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl loc_1233
mov [rbp+var_C], 0
jmp short loc_1369
loc_1331:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_1C], eax
jge short loc_1365
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_1C], eax
loc_1365:
add [rbp+var_C], 1
loc_1369:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl short loc_1331
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_1C]
leave
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int k; // [rsp+20h] [rbp-10h]
int m; // [rsp+24h] [rbp-Ch]
_DWORD *ptr; // [rsp+28h] [rbp-8h]
ptr = malloc(4LL * a2);
v3 = 0;
for ( i = 0; i < a2; ++i )
ptr[i] = 1;
for ( j = 0; j < a2; ++j )
{
for ( k = 0; k < j; ++k )
{
if ( *(_DWORD *)(4LL * j + a1) - *(_DWORD *)(4LL * k + a1) >= -1
&& *(_DWORD *)(4LL * j + a1) - *(_DWORD *)(4LL * k + a1) <= 1
&& ptr[k] >= ptr[j] )
{
ptr[j] = ptr[k] + 1;
}
}
}
for ( m = 0; m < a2; ++m )
{
if ( (signed int)v3 < ptr[m] )
v3 = ptr[m];
}
free(ptr);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010121f
LAB_00101201:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV dword ptr [RAX],0x1
ADD dword ptr [RBP + -0x18],0x1
LAB_0010121f:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101201
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010131c
LAB_00101233:
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010130c
LAB_0010123f:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
SUB EDX,EAX
CMP EDX,-0x1
JL 0x00101308
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
SUB EDX,EAX
CMP EDX,0x1
JG 0x00101308
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JL 0x00101308
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
ADD EDX,0x1
MOV dword ptr [RAX],EDX
LAB_00101308:
ADD dword ptr [RBP + -0x10],0x1
LAB_0010130c:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x0010123f
ADD dword ptr [RBP + -0x14],0x1
LAB_0010131c:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101233
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101369
LAB_00101331:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1c],EAX
JGE 0x00101365
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00101365:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101369:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101331
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101090
MOV EAX,dword ptr [RBP + -0x1c]
LEAVE
RET | int func0(long param_1,int param_2)
{
void *__ptr;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
__ptr = malloc((long)param_2 << 2);
local_24 = 0;
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
*(int4 *)((long)__ptr + (long)local_20 * 4) = 1;
}
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
for (local_18 = 0; local_18 < local_1c; local_18 = local_18 + 1) {
if (((-2 < *(int *)(param_1 + (long)local_1c * 4) - *(int *)(param_1 + (long)local_18 * 4)) &&
(*(int *)(param_1 + (long)local_1c * 4) - *(int *)(param_1 + (long)local_18 * 4) < 2)) &&
(*(int *)((long)__ptr + (long)local_1c * 4) <= *(int *)((long)__ptr + (long)local_18 * 4)))
{
*(int *)((long)__ptr + (long)local_1c * 4) = *(int *)((long)__ptr + (long)local_18 * 4) + 1;
}
}
}
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (local_24 < *(int *)((long)__ptr + (long)local_14 * 4)) {
local_24 = *(int *)((long)__ptr + (long)local_14 * 4);
}
}
free(__ptr);
return local_24;
} |
4,133 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int *mls = (int *)malloc(n * sizeof(int));
int max = 0;
for (int i = 0; i < n; i++) {
mls[i] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (abs(arr[i] - arr[j]) <= 1 && mls[i] < mls[j] + 1) {
mls[i] = mls[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mls[i]) {
max = mls[i];
}
}
free(mls);
return max;
}
| int main() {
int arr1[] = {2, 5, 6, 3, 7, 6, 5, 8};
assert(func0(arr1, 8) == 5);
int arr2[] = {-2, -1, 5, -1, 4, 0, 3};
assert(func0(arr2, 7) == 4);
int arr3[] = {9, 11, 13, 15, 18};
assert(func0(arr3, 5) == 1);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rdi
test %ebp,%ebp
jle 1280 <func0+0xb7>
mov %rax,%r9
lea -0x1(%rbp),%r11d
lea 0x4(%rax,%r11,4),%r10
movl $0x1,(%rax)
add $0x4,%rax
cmp %r10,%rax
jne 11fb <func0+0x32>
mov $0x0,%esi
mov $0x0,%ebp
jmp 124c <func0+0x83>
lea 0x1(%rdx),%rcx
cmp %rdx,%rax
je 1240 <func0+0x77>
mov %rcx,%rdx
mov %r8d,%ecx
sub (%rbx,%rdx,4),%ecx
add $0x1,%ecx
cmp $0x2,%ecx
ja 1216 <func0+0x4d>
mov (%rdi,%rdx,4),%ecx
cmp (%rdi,%rsi,4),%ecx
jl 1216 <func0+0x4d>
add $0x1,%ecx
mov %ecx,(%rdi,%rsi,4)
jmp 1216 <func0+0x4d>
lea 0x1(%rsi),%rax
cmp %r11,%rsi
je 125c <func0+0x93>
mov %rax,%rsi
test %esi,%esi
jle 1240 <func0+0x77>
mov (%rbx,%rsi,4),%r8d
lea -0x1(%rsi),%eax
mov %rbp,%rdx
jmp 1222 <func0+0x59>
mov $0x0,%ebx
mov (%r9),%eax
cmp %eax,%ebx
cmovl %eax,%ebx
add $0x4,%r9
cmp %r10,%r9
jne 1261 <func0+0x98>
callq 1090 <free@plt>
mov %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
mov $0x0,%ebx
jmp 1272 <func0+0xa9>
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
movsxd rdi, esi
shl rdi, 2
call _malloc
mov rdi, rax
test ebp, ebp
jle loc_1280
mov r9, rax
mov eax, ebp
lea r10, [rdi+rax*4]
mov rax, rdi
loc_11FB:
mov dword ptr [rax], 1
add rax, 4
cmp rax, r10
jnz short loc_11FB
mov r11d, ebp
mov ecx, 0
mov ebp, 0
jmp short loc_124C
loc_1219:
lea rdx, [rax+1]
cmp rsi, rax
jz short loc_1243
mov rax, rdx
loc_1225:
mov edx, r8d
sub edx, [rbx+rax*4]
add edx, 1
cmp edx, 2
ja short loc_1219
mov edx, [rdi+rax*4]
cmp edx, [rdi+rcx*4]
jl short loc_1219
add edx, 1
mov [rdi+rcx*4], edx
jmp short loc_1219
loc_1243:
add rcx, 1
cmp rcx, r11
jz short loc_125C
loc_124C:
test ecx, ecx
jle short loc_1243
mov r8d, [rbx+rcx*4]
lea esi, [rcx-1]
mov rax, rbp
jmp short loc_1225
loc_125C:
mov ebx, 0
loc_1261:
mov eax, [r9]
cmp ebx, eax
cmovl ebx, eax
add r9, 4
cmp r9, r10
jnz short loc_1261
loc_1272:
call _free
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
loc_1280:
mov ebx, 0
jmp short loc_1272 | long long func0(long long a1, long long a2)
{
int v3; // ebp
unsigned int *v4; // rax
long long v5; // rdx
unsigned int *v6; // rdi
unsigned int *v7; // r9
unsigned int *v8; // r10
long long v9; // rcx
long long i; // rax
int v11; // edx
int v12; // r8d
unsigned int v13; // ebx
v3 = a2;
v4 = (unsigned int *)malloc(4LL * (int)a2);
v6 = v4;
if ( (int)a2 <= 0 )
{
v13 = 0;
}
else
{
v7 = v4;
v8 = &v4[(unsigned int)a2];
do
*v4++ = 1;
while ( v4 != v8 );
v9 = 0LL;
do
{
if ( (int)v9 > 0 )
{
v12 = *(_DWORD *)(a1 + 4 * v9);
a2 = (unsigned int)(v9 - 1);
for ( i = 0LL; ; ++i )
{
if ( (unsigned int)(v12 - *(_DWORD *)(a1 + 4 * i) + 1) <= 2 )
{
v11 = v6[i];
if ( v11 >= (int)v6[v9] )
v6[v9] = v11 + 1;
}
v5 = i + 1;
if ( a2 == i )
break;
}
}
++v9;
}
while ( v9 != v3 );
v13 = 0;
do
{
if ( (int)v13 < (int)*v7 )
v13 = *v7;
++v7;
}
while ( v7 != v8 );
}
free(v6, a2, v5);
return v13;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010d0
MOV RDI,RAX
TEST EBP,EBP
JLE 0x00101280
MOV R9,RAX
MOV EAX,EBP
LEA R10,[RDI + RAX*0x4]
MOV RAX,RDI
LAB_001011fb:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,R10
JNZ 0x001011fb
MOV R11D,EBP
MOV ECX,0x0
MOV EBP,0x0
JMP 0x0010124c
LAB_00101219:
LEA RDX,[RAX + 0x1]
CMP RSI,RAX
JZ 0x00101243
MOV RAX,RDX
LAB_00101225:
MOV EDX,R8D
SUB EDX,dword ptr [RBX + RAX*0x4]
ADD EDX,0x1
CMP EDX,0x2
JA 0x00101219
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,dword ptr [RDI + RCX*0x4]
JL 0x00101219
ADD EDX,0x1
MOV dword ptr [RDI + RCX*0x4],EDX
JMP 0x00101219
LAB_00101243:
ADD RCX,0x1
CMP RCX,R11
JZ 0x0010125c
LAB_0010124c:
TEST ECX,ECX
JLE 0x00101243
MOV R8D,dword ptr [RBX + RCX*0x4]
LEA ESI,[RCX + -0x1]
MOV RAX,RBP
JMP 0x00101225
LAB_0010125c:
MOV EBX,0x0
LAB_00101261:
MOV EAX,dword ptr [R9]
CMP EBX,EAX
CMOVL EBX,EAX
ADD R9,0x4
CMP R9,R10
JNZ 0x00101261
LAB_00101272:
CALL 0x00101090
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101280:
MOV EBX,0x0
JMP 0x00101272 | int func0(long param_1,uint param_2)
{
int *__ptr;
int *piVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
bool bVar5;
__ptr = (int *)malloc((long)(int)param_2 << 2);
if ((int)param_2 < 1) {
iVar4 = 0;
}
else {
piVar1 = __ptr;
do {
*piVar1 = 1;
piVar1 = piVar1 + 1;
} while (piVar1 != __ptr + param_2);
uVar3 = 0;
do {
if (0 < (int)uVar3) {
iVar4 = *(int *)(param_1 + uVar3 * 4);
uVar2 = 0;
do {
if (((iVar4 - *(int *)(param_1 + uVar2 * 4)) + 1U < 3) && (__ptr[uVar3] <= __ptr[uVar2]))
{
__ptr[uVar3] = __ptr[uVar2] + 1;
}
bVar5 = (int)uVar3 - 1 != uVar2;
uVar2 = uVar2 + 1;
} while (bVar5);
}
uVar3 = uVar3 + 1;
} while (uVar3 != param_2);
iVar4 = 0;
piVar1 = __ptr;
do {
if (iVar4 < *piVar1) {
iVar4 = *piVar1;
}
piVar1 = piVar1 + 1;
} while (piVar1 != __ptr + param_2);
}
free(__ptr);
return iVar4;
} |
4,134 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int *mls = (int *)malloc(n * sizeof(int));
int max = 0;
for (int i = 0; i < n; i++) {
mls[i] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (abs(arr[i] - arr[j]) <= 1 && mls[i] < mls[j] + 1) {
mls[i] = mls[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mls[i]) {
max = mls[i];
}
}
free(mls);
return max;
}
| int main() {
int arr1[] = {2, 5, 6, 3, 7, 6, 5, 8};
assert(func0(arr1, 8) == 5);
int arr2[] = {-2, -1, 5, -1, 4, 0, 3};
assert(func0(arr2, 7) == 4);
int arr3[] = {9, 11, 13, 15, 18};
assert(func0(arr3, 5) == 1);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %rax,%rdi
test %r12d,%r12d
jle 141b <func0+0xdb>
lea -0x1(%r12),%r11d
mov %rax,%r9
lea 0x4(%rax,%r11,4),%r10
nopw %cs:0x0(%rax,%rax,1)
movl $0x1,(%rax)
add $0x4,%rax
cmp %r10,%rax
jne 1380 <func0+0x40>
xor %esi,%esi
nopl 0x0(%rax)
test %rsi,%rsi
je 13d8 <func0+0x98>
mov (%rbx,%rsi,4),%r8d
lea -0x1(%rsi),%eax
xor %edx,%edx
jmp 13b3 <func0+0x73>
nopl 0x0(%rax,%rax,1)
mov %rcx,%rdx
mov %r8d,%ecx
sub (%rbx,%rdx,4),%ecx
add $0x1,%ecx
cmp $0x2,%ecx
ja 13cf <func0+0x8f>
mov (%rdi,%rdx,4),%ecx
cmp (%rdi,%rsi,4),%ecx
jl 13cf <func0+0x8f>
add $0x1,%ecx
mov %ecx,(%rdi,%rsi,4)
lea 0x1(%rdx),%rcx
cmp %rdx,%rax
jne 13b0 <func0+0x70>
lea 0x1(%rsi),%rax
cmp %r11,%rsi
je 13f0 <func0+0xb0>
mov %rax,%rsi
jmp 1398 <func0+0x58>
nopw %cs:0x0(%rax,%rax,1)
xor %r12d,%r12d
nopl 0x0(%rax,%rax,1)
mov (%r9),%eax
cmp %eax,%r12d
cmovl %eax,%r12d
add $0x4,%r9
cmp %r10,%r9
jne 13f8 <func0+0xb8>
callq 1090 <free@plt>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
callq 1090 <free@plt>
xor %r12d,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
xchg %ax,%ax
| func0:
endbr64
push r12
push rbx
mov rbx, rdi
movsxd rdi, esi
mov r12, rdi
shl rdi, 2
sub rsp, 8
call _malloc
mov rdi, rax
test r12d, r12d
jle loc_13FB
mov r11d, r12d
mov r9, rax
lea r10, [rax+r11*4]
nop dword ptr [rax+rax+00h]
loc_1378:
mov dword ptr [rax], 1
add rax, 4
cmp rax, r10
jnz short loc_1378
xor ecx, ecx
nop dword ptr [rax+00000000h]
loc_1390:
test rcx, rcx
jz short loc_13C8
mov r8d, [rbx+rcx*4]
lea esi, [rcx-1]
xor eax, eax
jmp short loc_13A3
loc_13A0:
mov rax, rdx
loc_13A3:
mov edx, r8d
sub edx, [rbx+rax*4]
add edx, 1
cmp edx, 2
ja short loc_13BF
mov edx, [rdi+rax*4]
cmp edx, [rdi+rcx*4]
jl short loc_13BF
add edx, 1
mov [rdi+rcx*4], edx
loc_13BF:
lea rdx, [rax+1]
cmp rsi, rax
jnz short loc_13A0
loc_13C8:
add rcx, 1
cmp rcx, r11
jnz short loc_1390
xor r12d, r12d
nop dword ptr [rax+00h]
loc_13D8:
mov eax, [r9]
cmp r12d, eax
cmovl r12d, eax
add r9, 4
cmp r9, r10
jnz short loc_13D8
call _free
add rsp, 8
mov eax, r12d
pop rbx
pop r12
retn
loc_13FB:
call _free
xor r12d, r12d
add rsp, 8
mov eax, r12d
pop rbx
pop r12
retn | long long func0(long long a1, int a2)
{
unsigned int *v3; // rax
unsigned int *v4; // rdi
unsigned int *v5; // r9
unsigned int *v6; // r10
long long i; // rcx
int v8; // r8d
long long j; // rax
int v10; // edx
unsigned int v11; // r12d
v3 = (unsigned int *)malloc(4LL * a2);
v4 = v3;
if ( a2 <= 0 )
{
free(v3);
return 0LL;
}
else
{
v5 = v3;
v6 = &v3[a2];
do
*v3++ = 1;
while ( v3 != v6 );
for ( i = 0LL; i != a2; ++i )
{
if ( i )
{
v8 = *(_DWORD *)(a1 + 4 * i);
for ( j = 0LL; ; ++j )
{
if ( (unsigned int)(v8 - *(_DWORD *)(a1 + 4 * j) + 1) <= 2 )
{
v10 = v4[j];
if ( v10 >= (int)v4[i] )
v4[i] = v10 + 1;
}
if ( (_DWORD)i - 1 == j )
break;
}
}
}
v11 = 0;
do
{
if ( (int)v11 < (int)*v5 )
v11 = *v5;
++v5;
}
while ( v5 != v6 );
free(v4);
return v11;
}
} | func0:
ENDBR64
PUSH R12
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV R12,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010d0
MOV RDI,RAX
TEST R12D,R12D
JLE 0x001013fb
MOV R11D,R12D
MOV R9,RAX
LEA R10,[RAX + R11*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101378:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,R10
JNZ 0x00101378
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101390:
TEST RCX,RCX
JZ 0x001013c8
MOV R8D,dword ptr [RBX + RCX*0x4]
LEA ESI,[RCX + -0x1]
XOR EAX,EAX
JMP 0x001013a3
LAB_001013a0:
MOV RAX,RDX
LAB_001013a3:
MOV EDX,R8D
SUB EDX,dword ptr [RBX + RAX*0x4]
ADD EDX,0x1
CMP EDX,0x2
JA 0x001013bf
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,dword ptr [RDI + RCX*0x4]
JL 0x001013bf
ADD EDX,0x1
MOV dword ptr [RDI + RCX*0x4],EDX
LAB_001013bf:
LEA RDX,[RAX + 0x1]
CMP RSI,RAX
JNZ 0x001013a0
LAB_001013c8:
ADD RCX,0x1
CMP RCX,R11
JNZ 0x00101390
XOR R12D,R12D
NOP dword ptr [RAX]
LAB_001013d8:
MOV EAX,dword ptr [R9]
CMP R12D,EAX
CMOVL R12D,EAX
ADD R9,0x4
CMP R9,R10
JNZ 0x001013d8
CALL 0x00101090
ADD RSP,0x8
MOV EAX,R12D
POP RBX
POP R12
RET
LAB_001013fb:
CALL 0x00101090
XOR R12D,R12D
ADD RSP,0x8
MOV EAX,R12D
POP RBX
POP R12
RET | int func0(long param_1,uint param_2)
{
int *__ptr;
int *piVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
bool bVar5;
__ptr = (int *)malloc((long)(int)param_2 << 2);
if ((int)param_2 < 1) {
free(__ptr);
return 0;
}
piVar1 = __ptr;
do {
*piVar1 = 1;
piVar1 = piVar1 + 1;
} while (piVar1 != __ptr + param_2);
uVar3 = 0;
do {
if (uVar3 != 0) {
iVar4 = *(int *)(param_1 + uVar3 * 4);
uVar2 = 0;
do {
if (((iVar4 - *(int *)(param_1 + uVar2 * 4)) + 1U < 3) && (__ptr[uVar3] <= __ptr[uVar2])) {
__ptr[uVar3] = __ptr[uVar2] + 1;
}
bVar5 = (int)uVar3 - 1 != uVar2;
uVar2 = uVar2 + 1;
} while (bVar5);
}
uVar3 = uVar3 + 1;
} while (uVar3 != param_2);
iVar4 = 0;
piVar1 = __ptr;
do {
if (iVar4 < *piVar1) {
iVar4 = *piVar1;
}
piVar1 = piVar1 + 1;
} while (piVar1 != __ptr + param_2);
free(__ptr);
return iVar4;
} |
4,135 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int func0(int arr[], int n) {
int *mls = (int *)malloc(n * sizeof(int));
int max = 0;
for (int i = 0; i < n; i++) {
mls[i] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (abs(arr[i] - arr[j]) <= 1 && mls[i] < mls[j] + 1) {
mls[i] = mls[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mls[i]) {
max = mls[i];
}
}
free(mls);
return max;
}
| int main() {
int arr1[] = {2, 5, 6, 3, 7, 6, 5, 8};
assert(func0(arr1, 8) == 5);
int arr2[] = {-2, -1, 5, -1, 4, 0, 3};
assert(func0(arr2, 7) == 4);
int arr3[] = {9, 11, 13, 15, 18};
assert(func0(arr3, 5) == 1);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r8
test %ebp,%ebp
jle 14ae <func0+0x1ae>
lea -0x1(%rbp),%esi
cmp $0x2,%esi
jbe 14c1 <func0+0x1c1>
mov %ebp,%edx
movdqa 0xd65(%rip),%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rax,%rdx
nopl (%rax)
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 1348 <func0+0x48>
mov %ebp,%eax
and $0xfffffffc,%eax
test $0x3,%bpl
je 138d <func0+0x8d>
movslq %eax,%rdx
movl $0x1,(%r8,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%ebp
jle 138d <func0+0x8d>
movslq %edx,%rdx
add $0x2,%eax
movl $0x1,(%r8,%rdx,4)
cmp %eax,%ebp
jle 138d <func0+0x8d>
cltq
movl $0x1,(%r8,%rax,4)
mov $0x1,%edi
cmp $0x1,%ebp
je 13d6 <func0+0xd6>
nopw 0x0(%rax,%rax,1)
mov (%rbx,%rdi,4),%eax
xor %edx,%edx
nopl (%rax)
mov %eax,%ecx
sub (%rbx,%rdx,4),%ecx
add $0x1,%ecx
cmp $0x2,%ecx
ja 13c6 <func0+0xc6>
mov (%r8,%rdx,4),%ecx
cmp %ecx,(%r8,%rdi,4)
jg 13c6 <func0+0xc6>
add $0x1,%ecx
mov %ecx,(%r8,%rdi,4)
add $0x1,%rdx
cmp %edi,%edx
jl 13a8 <func0+0xa8>
add $0x1,%rdi
cmp %edi,%ebp
jg 13a0 <func0+0xa0>
cmp $0x2,%esi
jbe 14c8 <func0+0x1c8>
mov %ebp,%edx
mov %r8,%rax
pxor %xmm2,%xmm2
shr $0x2,%edx
shl $0x4,%rdx
add %r8,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 13f8 <func0+0xf8>
movdqa %xmm2,%xmm1
mov %ebp,%eax
psrldq $0x8,%xmm1
and $0xfffffffc,%eax
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm0,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%r12d
test $0x3,%bpl
je 149e <func0+0x19e>
movslq %eax,%rdx
mov (%r8,%rdx,4),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
lea 0x1(%rax),%edx
cmp %edx,%ebp
jle 149e <func0+0x19e>
movslq %edx,%rdx
mov (%r8,%rdx,4),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
add $0x2,%eax
cmp %ebp,%eax
jge 149e <func0+0x19e>
cltq
mov (%r8,%rax,4),%eax
cmp %eax,%r12d
cmovl %eax,%r12d
mov %r8,%rdi
callq 1090 <free@plt>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
xor %r12d,%r12d
mov %r8,%rdi
callq 1090 <free@plt>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
xor %eax,%eax
jmpq 135f <func0+0x5f>
xor %eax,%eax
xor %r12d,%r12d
jmp 1467 <func0+0x167>
| func0:
endbr64
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov rbx, rdi
shl rdi, 2; size
sub rsp, 8
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jle loc_14BE
lea r8d, [rbx-1]
cmp r8d, 2
jbe loc_14CE
mov edx, ebx
movdqa xmm0, cs:xmmword_2080
shr edx, 2
shl rdx, 4
lea rcx, [rdx+rax]
and edx, 10h
jz short loc_1360
movups xmmword ptr [rax], xmm0
lea rax, [rax+10h]
cmp rax, rcx
jz short loc_1370
nop dword ptr [rax+rax+00h]
loc_1360:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp rax, rcx
jnz short loc_1360
loc_1370:
mov eax, ebx
and eax, 0FFFFFFFCh
test bl, 3
jz short loc_13A9
mov ecx, eax
mov dword ptr [rdi+rcx*4], 1
lea rdx, ds:0[rcx*4]
lea ecx, [rax+1]
cmp ebx, ecx
jle short loc_13A9
loc_1392:
add eax, 2
mov dword ptr [rdi+rdx+4], 1
cmp ebx, eax
jle short loc_13A9
mov dword ptr [rdi+rdx+8], 1
loc_13A9:
mov r9d, ebx
mov ecx, 1
nop dword ptr [rax+00000000h]
loc_13B8:
mov esi, [rbp+rcx*4+0]
xor eax, eax
xchg ax, ax
loc_13C0:
mov edx, esi
sub edx, [rbp+rax*4+0]
add edx, 1
cmp edx, 2
ja short loc_13DC
mov edx, [rdi+rax*4]
cmp [rdi+rcx*4], edx
jg short loc_13DC
add edx, 1
mov [rdi+rcx*4], edx
loc_13DC:
add rax, 1
cmp eax, ecx
jl short loc_13C0
add rcx, 1
cmp rcx, r9
jnz short loc_13B8
cmp r8d, 2
jbe loc_14E8
mov edx, ebx
mov rax, rdi
pxor xmm2, xmm2
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_1410:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_1410
movdqa xmm0, xmm2
mov eax, ebx
psrldq xmm0, 8
and eax, 0FFFFFFFCh
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm1, xmm0
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd ebp, xmm0
test bl, 3
jz short loc_14B0
movsxd rdx, eax
lea rcx, ds:0[rdx*4]
mov edx, [rdi+rdx*4]
cmp ebp, edx
cmovl ebp, edx
lea edx, [rax+1]
cmp ebx, edx
jle short loc_14B0
loc_1497:
mov edx, [rdi+rcx+4]
cmp ebp, edx
cmovl ebp, edx
add eax, 2
cmp eax, ebx
jge short loc_14B0
mov eax, [rdi+rcx+8]
cmp ebp, eax
cmovl ebp, eax
loc_14B0:
call _free
add rsp, 8
mov eax, ebp
pop rbx
pop rbp
retn
loc_14BE:
call _free
xor ebp, ebp
add rsp, 8
mov eax, ebp
pop rbx
pop rbp
retn
loc_14CE:
mov dword ptr [rax], 1
xor edx, edx
xor eax, eax
cmp ebx, 1
jnz loc_1392
mov ebp, 1
jmp short loc_14B0
loc_14E8:
mov ebp, [rdi]
xor eax, eax
test ebp, ebp
cmovs ebp, eax
xor ecx, ecx
jmp short loc_1497 | long long func0(long long a1, int a2)
{
__m128i *v4; // rax
__m128i *v5; // rdi
unsigned int v6; // r8d
__m128i si128; // xmm0
long long v8; // rdx
__m128i *v9; // rcx
unsigned int v10; // eax
long long v11; // rdx
long long v12; // rcx
int v13; // esi
long long v14; // rax
__int32 v15; // edx
const __m128i *v16; // rax
__m128i v17; // xmm2
__m128i v18; // xmm0
__m128i v19; // xmm1
__m128i v20; // xmm0
signed int v21; // eax
__m128i v22; // xmm1
__m128i v23; // xmm1
__m128i v24; // xmm2
__m128i v25; // xmm0
int v26; // ebp
long long v27; // rcx
v4 = (__m128i *)malloc(4LL * a2);
v5 = v4;
if ( a2 > 0 )
{
v6 = a2 - 1;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v4->m128i_i32[0] = 1;
v11 = 0LL;
v10 = 0;
if ( a2 == 1 )
{
v26 = 1;
goto LABEL_29;
}
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2080);
v8 = (unsigned int)a2 >> 2;
v9 = &v4[v8];
if ( ((v8 * 16) & 0x10) == 0 || (*v4 = si128, ++v4, v4 != v9) )
{
do
{
*v4 = si128;
v4 += 2;
v4[-1] = si128;
}
while ( v4 != v9 );
}
v10 = a2 & 0x7FFFFFFC;
if ( (a2 & 3) == 0 )
goto LABEL_10;
v5->m128i_i32[v10] = 1;
v11 = v10;
if ( a2 <= (int)(v10 + 1) )
goto LABEL_10;
}
v5->m128i_i32[v11 + 1] = 1;
if ( a2 > (int)(v10 + 2) )
v5->m128i_i32[v11 + 2] = 1;
LABEL_10:
v12 = 1LL;
do
{
v13 = *(_DWORD *)(a1 + 4 * v12);
v14 = 0LL;
do
{
if ( (unsigned int)(v13 - *(_DWORD *)(a1 + 4 * v14) + 1) <= 2 )
{
v15 = v5->m128i_i32[v14];
if ( v5->m128i_i32[v12] <= v15 )
v5->m128i_i32[v12] = v15 + 1;
}
++v14;
}
while ( (int)v14 < (int)v12 );
++v12;
}
while ( v12 != a2 );
if ( v6 <= 2 )
{
v26 = v5->m128i_i32[0];
v21 = 0;
if ( v5->m128i_i32[0] < 0 )
v26 = 0;
v27 = 0LL;
}
else
{
v16 = v5;
v17 = 0LL;
do
{
v18 = _mm_loadu_si128(v16++);
v19 = _mm_cmpgt_epi32(v18, v17);
v17 = _mm_or_si128(_mm_andnot_si128(v19, v17), _mm_and_si128(v18, v19));
}
while ( v16 != &v5[(unsigned int)a2 >> 2] );
v20 = _mm_srli_si128(v17, 8);
v21 = a2 & 0xFFFFFFFC;
v22 = _mm_cmpgt_epi32(v20, v17);
v23 = _mm_or_si128(_mm_andnot_si128(v22, v17), _mm_and_si128(v20, v22));
v24 = _mm_srli_si128(v23, 4);
v25 = _mm_cmpgt_epi32(v24, v23);
v26 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v25, v23), _mm_and_si128(v24, v25)));
if ( (a2 & 3) == 0 )
goto LABEL_29;
v27 = v21;
if ( v26 < v5->m128i_i32[v27] )
v26 = v5->m128i_i32[v21];
if ( a2 <= v21 + 1 )
goto LABEL_29;
}
if ( v26 < v5->m128i_i32[v27 + 1] )
v26 = v5->m128i_i32[v27 + 1];
if ( v21 + 2 < a2 && v26 < v5->m128i_i32[v27 + 2] )
v26 = v5->m128i_i32[v27 + 2];
LABEL_29:
free(v5);
return (unsigned int)v26;
}
free(v4);
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010d0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x001014be
LEA R8D,[RBX + -0x1]
CMP R8D,0x2
JBE 0x001014ce
MOV EDX,EBX
MOVDQA XMM0,xmmword ptr [0x00102080]
SHR EDX,0x2
SHL RDX,0x4
LEA RCX,[RDX + RAX*0x1]
AND EDX,0x10
JZ 0x00101360
MOVUPS xmmword ptr [RAX],XMM0
LEA RAX,[RAX + 0x10]
CMP RAX,RCX
JZ 0x00101370
NOP dword ptr [RAX + RAX*0x1]
LAB_00101360:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RCX
JNZ 0x00101360
LAB_00101370:
MOV EAX,EBX
AND EAX,0xfffffffc
TEST BL,0x3
JZ 0x001013a9
MOV ECX,EAX
MOV dword ptr [RDI + RCX*0x4],0x1
LEA RDX,[RCX*0x4]
LEA ECX,[RAX + 0x1]
CMP EBX,ECX
JLE 0x001013a9
LAB_00101392:
ADD EAX,0x2
MOV dword ptr [RDI + RDX*0x1 + 0x4],0x1
CMP EBX,EAX
JLE 0x001013a9
MOV dword ptr [RDI + RDX*0x1 + 0x8],0x1
LAB_001013a9:
MOV R9D,EBX
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_001013b8:
MOV ESI,dword ptr [RBP + RCX*0x4]
XOR EAX,EAX
NOP
LAB_001013c0:
MOV EDX,ESI
SUB EDX,dword ptr [RBP + RAX*0x4]
ADD EDX,0x1
CMP EDX,0x2
JA 0x001013dc
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP dword ptr [RDI + RCX*0x4],EDX
JG 0x001013dc
ADD EDX,0x1
MOV dword ptr [RDI + RCX*0x4],EDX
LAB_001013dc:
ADD RAX,0x1
CMP EAX,ECX
JL 0x001013c0
ADD RCX,0x1
CMP RCX,R9
JNZ 0x001013b8
CMP R8D,0x2
JBE 0x001014e8
MOV EDX,EBX
MOV RAX,RDI
PXOR XMM2,XMM2
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101410:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x00101410
MOVDQA XMM0,XMM2
MOV EAX,EBX
PSRLDQ XMM0,0x8
AND EAX,0xfffffffc
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM1,XMM0
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EBP,XMM0
TEST BL,0x3
JZ 0x001014b0
MOVSXD RDX,EAX
LEA RCX,[RDX*0x4]
MOV EDX,dword ptr [RDI + RDX*0x4]
CMP EBP,EDX
CMOVL EBP,EDX
LEA EDX,[RAX + 0x1]
CMP EBX,EDX
JLE 0x001014b0
LAB_00101497:
MOV EDX,dword ptr [RDI + RCX*0x1 + 0x4]
CMP EBP,EDX
CMOVL EBP,EDX
ADD EAX,0x2
CMP EAX,EBX
JGE 0x001014b0
MOV EAX,dword ptr [RDI + RCX*0x1 + 0x8]
CMP EBP,EAX
CMOVL EBP,EAX
LAB_001014b0:
CALL 0x00101090
ADD RSP,0x8
MOV EAX,EBP
POP RBX
POP RBP
RET
LAB_001014be:
CALL 0x00101090
XOR EBP,EBP
ADD RSP,0x8
MOV EAX,EBP
POP RBX
POP RBP
RET
LAB_001014ce:
MOV dword ptr [RAX],0x1
XOR EDX,EDX
XOR EAX,EAX
CMP EBX,0x1
JNZ 0x00101392
MOV EBP,0x1
JMP 0x001014b0
LAB_001014e8:
MOV EBP,dword ptr [RDI]
XOR EAX,EAX
TEST EBP,EBP
CMOVS EBP,EAX
XOR ECX,ECX
JMP 0x00101497 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(long param_1,uint param_2)
{
int iVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
int8 uVar5;
int8 uVar6;
uint uVar7;
uint uVar8;
uint *__ptr;
long lVar9;
uint *puVar10;
ulong uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
__ptr = (uint *)malloc((long)(int)param_2 << 2);
uVar6 = _UNK_00102088;
uVar5 = _DAT_00102080;
if ((int)param_2 < 1) {
free(__ptr);
return 0;
}
if (param_2 - 1 < 3) {
*__ptr = 1;
lVar9 = 0;
uVar7 = 0;
if (param_2 == 1) {
uVar7 = 1;
goto LAB_001014b0;
}
LAB_00101392:
*(int4 *)((long)__ptr + lVar9 + 4) = 1;
if ((int)(uVar7 + 2) < (int)param_2) {
*(int4 *)((long)__ptr + lVar9 + 8) = 1;
}
}
else {
puVar10 = __ptr;
if (((ulong)(param_2 >> 2) * 0x10 & 0x10) == 0) goto LAB_00101360;
*(int8 *)__ptr = _DAT_00102080;
*(int8 *)(__ptr + 2) = uVar6;
for (puVar10 = __ptr + 4; puVar10 != __ptr + (ulong)(param_2 >> 2) * 4; puVar10 = puVar10 + 8) {
LAB_00101360:
*(int8 *)puVar10 = uVar5;
*(int8 *)(puVar10 + 2) = uVar6;
*(int8 *)(puVar10 + 4) = uVar5;
*(int8 *)(puVar10 + 6) = uVar6;
}
uVar7 = param_2 & 0xfffffffc;
if ((param_2 & 3) != 0) {
__ptr[uVar7] = 1;
lVar9 = (ulong)uVar7 * 4;
if ((int)(uVar7 + 1) < (int)param_2) goto LAB_00101392;
}
}
uVar11 = 1;
do {
iVar1 = *(int *)(param_1 + uVar11 * 4);
lVar9 = 0;
do {
if (((iVar1 - *(int *)(param_1 + lVar9 * 4)) + 1U < 3) &&
((int)__ptr[uVar11] <= (int)__ptr[lVar9])) {
__ptr[uVar11] = __ptr[lVar9] + 1;
}
lVar9 = lVar9 + 1;
} while ((int)lVar9 < (int)uVar11);
uVar11 = uVar11 + 1;
} while (uVar11 != param_2);
if (param_2 - 1 < 3) {
uVar7 = *__ptr;
uVar8 = 0;
if ((int)uVar7 < 0) {
uVar7 = 0;
}
lVar9 = 0;
}
else {
uVar7 = 0;
uVar16 = 0;
uVar17 = 0;
uVar18 = 0;
puVar10 = __ptr;
do {
uVar8 = *puVar10;
puVar2 = puVar10 + 1;
puVar3 = puVar10 + 2;
puVar4 = puVar10 + 3;
puVar10 = puVar10 + 4;
uVar12 = -(uint)((int)uVar7 < (int)uVar8);
uVar13 = -(uint)((int)uVar16 < (int)*puVar2);
uVar14 = -(uint)((int)uVar17 < (int)*puVar3);
uVar15 = -(uint)((int)uVar18 < (int)*puVar4);
uVar7 = ~uVar12 & uVar7 | uVar8 & uVar12;
uVar16 = ~uVar13 & uVar16 | *puVar2 & uVar13;
uVar17 = ~uVar14 & uVar17 | *puVar3 & uVar14;
uVar18 = ~uVar15 & uVar18 | *puVar4 & uVar15;
} while (puVar10 != __ptr + (ulong)(param_2 >> 2) * 4);
uVar8 = param_2 & 0xfffffffc;
uVar17 = ~-(uint)((int)uVar7 < (int)uVar17) & uVar7 | uVar17 & -(uint)((int)uVar7 < (int)uVar17)
;
uVar16 = ~-(uint)((int)uVar16 < (int)uVar18) & uVar16 |
uVar18 & -(uint)((int)uVar16 < (int)uVar18);
uVar7 = -(uint)((int)uVar17 < (int)uVar16);
uVar7 = ~uVar7 & uVar17 | uVar16 & uVar7;
if ((param_2 & 3) == 0) goto LAB_001014b0;
lVar9 = (long)(int)uVar8 * 4;
if ((int)uVar7 < (int)__ptr[(int)uVar8]) {
uVar7 = __ptr[(int)uVar8];
}
if ((int)param_2 <= (int)(uVar8 + 1)) goto LAB_001014b0;
}
uVar16 = *(uint *)((long)__ptr + lVar9 + 4);
if ((int)uVar7 < (int)uVar16) {
uVar7 = uVar16;
}
if (((int)(uVar8 + 2) < (int)param_2) &&
(uVar8 = *(uint *)((long)__ptr + lVar9 + 8), (int)uVar7 < (int)uVar8)) {
uVar7 = uVar8;
}
LAB_001014b0:
free(__ptr);
return uVar7;
} |
4,136 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| int func0(const char *s, int n) {
int count = 0, sum = 0;
// Maximum possible sum is n*9
// Minimum possible sum -n
int max_sum = n * 9;
int min_sum = -n;
int size = max_sum - min_sum + 1;
int *mp = calloc(size, sizeof(int));
if (!mp) {
perror("Memory allocation failed");
exit(EXIT_FAILURE);
}
mp[-min_sum] += 1;
for (int i = 0; i < n; i++) {
sum += s[i] - '0';
int key = sum - (i + 1);
if (key >= min_sum && key <= max_sum) {
count += mp[key - min_sum];
mp[key - min_sum] += 1;
}
}
free(mp);
return count;
}
| int main() {
assert(func0("112112", 6) == 6);
assert(func0("111", 3) == 6);
assert(func0("1101112", 7) == 12);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
mov -0x3c(%rbp),%edx
mov %edx,%eax
shl $0x3,%eax
add %edx,%eax
mov %eax,-0x18(%rbp)
mov -0x3c(%rbp),%eax
neg %eax
mov %eax,-0x14(%rbp)
mov -0x18(%rbp),%eax
sub -0x14(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
mov -0x10(%rbp),%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 10b0 <calloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 123e <func0+0x75>
lea 0xdd9(%rip),%rdi
callq 10c0 <perror@plt>
mov $0x1,%edi
callq 10d0 <exit@plt>
mov -0x14(%rbp),%eax
neg %eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
neg %eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
add $0x1,%edx
mov %edx,(%rax)
movl $0x0,-0x1c(%rbp)
jmpq 1309 <func0+0x140>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
sub $0x30,%eax
add %eax,-0x20(%rbp)
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x20(%rbp),%eax
sub %edx,%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 1305 <func0+0x13c>
mov -0xc(%rbp),%eax
cmp -0x18(%rbp),%eax
jg 1305 <func0+0x13c>
mov -0xc(%rbp),%eax
sub -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x24(%rbp)
mov -0xc(%rbp),%eax
sub -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
sub -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 127d <func0+0xb4>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x24(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_24], 0
mov [rbp+var_20], 0
mov edx, [rbp+var_3C]
mov eax, edx
shl eax, 3
add eax, edx
mov [rbp+var_18], eax
mov eax, [rbp+var_3C]
neg eax
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
sub eax, [rbp+var_14]
add eax, 1
mov [rbp+var_10], eax
mov eax, [rbp+var_10]
cdqe
mov esi, 4; size
mov rdi, rax; nmemb
call _calloc
mov [rbp+ptr], rax
cmp [rbp+ptr], 0
jnz short loc_1241
lea rax, s; "Memory allocation failed"
mov rdi, rax; s
call _perror
mov edi, 1; status
call _exit
loc_1241:
mov eax, [rbp+var_14]
neg eax
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
neg eax
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
add edx, 1
mov [rax], edx
mov [rbp+var_1C], 0
jmp loc_130C
loc_1280:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_38]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
sub eax, 30h ; '0'
add [rbp+var_20], eax
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov eax, [rbp+var_20]
sub eax, edx
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jl short loc_1308
mov eax, [rbp+var_C]
cmp eax, [rbp+var_18]
jg short loc_1308
mov eax, [rbp+var_C]
sub eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
add [rbp+var_24], eax
mov eax, [rbp+var_C]
sub eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
sub eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
add edx, 1
mov [rax], edx
loc_1308:
add [rbp+var_1C], 1
loc_130C:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_3C]
jl loc_1280
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_24]
leave
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+1Ch] [rbp-24h]
int v4; // [rsp+20h] [rbp-20h]
int i; // [rsp+24h] [rbp-1Ch]
int v6; // [rsp+34h] [rbp-Ch]
_DWORD *ptr; // [rsp+38h] [rbp-8h]
v3 = 0;
v4 = 0;
ptr = calloc(10 * a2 + 1, 4uLL);
if ( !ptr )
{
perror("Memory allocation failed");
exit(1);
}
++ptr[a2];
for ( i = 0; i < a2; ++i )
{
v4 += *(char *)(i + a1) - 48;
v6 = v4 - (i + 1);
if ( v6 >= -a2 && v6 <= 9 * a2 )
v3 += ptr[v6 + a2]++;
}
free(ptr);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,EDX
SHL EAX,0x3
ADD EAX,EDX
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x3c]
NEG EAX
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x00101241
LEA RAX,[0x102004]
MOV RDI,RAX
CALL 0x001010c0
MOV EDI,0x1
CALL 0x001010d0
LAB_00101241:
MOV EAX,dword ptr [RBP + -0x14]
NEG EAX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
NEG EAX
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
ADD EDX,0x1
MOV dword ptr [RAX],EDX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010130c
LAB_00101280:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
SUB EAX,0x30
ADD dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101308
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x18]
JG 0x00101308
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
ADD EDX,0x1
MOV dword ptr [RAX],EDX
LAB_00101308:
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010130c:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101280
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101090
MOV EAX,dword ptr [RBP + -0x24]
LEAVE
RET | int func0(long param_1,int param_2)
{
int iVar1;
void *__ptr;
int local_2c;
int local_28;
int local_24;
local_2c = 0;
local_28 = 0;
__ptr = calloc((long)(param_2 * 10 + 1),4);
if (__ptr == (void *)0x0) {
perror("Memory allocation failed");
/* WARNING: Subroutine does not return */
exit(1);
}
*(int *)((long)__ptr + (long)param_2 * 4) = *(int *)((long)__ptr + (long)param_2 * 4) + 1;
for (local_24 = 0; local_24 < param_2; local_24 = local_24 + 1) {
local_28 = local_28 + *(char *)(param_1 + local_24) + -0x30;
iVar1 = local_28 - (local_24 + 1);
if ((-param_2 <= iVar1) && (iVar1 <= param_2 * 9)) {
local_2c = local_2c + *(int *)((long)__ptr + (long)(iVar1 + param_2) * 4);
*(int *)((long)__ptr + (long)(iVar1 + param_2) * 4) =
*(int *)((long)__ptr + (long)(iVar1 + param_2) * 4) + 1;
}
}
free(__ptr);
return local_2c;
} |
4,137 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| int func0(const char *s, int n) {
int count = 0, sum = 0;
// Maximum possible sum is n*9
// Minimum possible sum -n
int max_sum = n * 9;
int min_sum = -n;
int size = max_sum - min_sum + 1;
int *mp = calloc(size, sizeof(int));
if (!mp) {
perror("Memory allocation failed");
exit(EXIT_FAILURE);
}
mp[-min_sum] += 1;
for (int i = 0; i < n; i++) {
sum += s[i] - '0';
int key = sum - (i + 1);
if (key >= min_sum && key <= max_sum) {
count += mp[key - min_sum];
mp[key - min_sum] += 1;
}
}
free(mp);
return count;
}
| int main() {
assert(func0("112112", 6) == 6);
assert(func0("111", 3) == 6);
assert(func0("1101112", 7) == 12);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
lea (%rsi,%rsi,8),%eax
mov %eax,%r14d
mov %esi,%r13d
neg %r13d
lea 0x1(%rsi,%rax,1),%edi
movslq %edi,%rdi
mov $0x4,%esi
callq 10b0 <calloc@plt>
test %rax,%rax
je 1223 <func0+0x5a>
mov %rax,%rdi
movslq %ebx,%rax
addl $0x1,(%rdi,%rax,4)
test %ebx,%ebx
jle 1270 <func0+0xa7>
lea -0x1(%rbx),%eax
add $0x2,%rax
mov $0x1,%ecx
mov $0x0,%esi
mov $0x0,%r12d
jmp 1257 <func0+0x8e>
lea 0xdda(%rip),%rdi
callq 10c0 <perror@plt>
mov $0x1,%edi
callq 10d0 <exit@plt>
add %ebx,%edx
movslq %edx,%rdx
lea (%rdi,%rdx,4),%r8
mov (%r8),%edx
add %edx,%r12d
add $0x1,%edx
mov %edx,(%r8)
add $0x1,%rcx
cmp %rax,%rcx
je 1276 <func0+0xad>
movsbl -0x1(%rbp,%rcx,1),%edx
lea -0x30(%rsi,%rdx,1),%esi
mov %esi,%edx
sub %ecx,%edx
cmp %edx,%r13d
jg 124e <func0+0x85>
cmp %edx,%r14d
jge 1239 <func0+0x70>
jmp 124e <func0+0x85>
mov $0x0,%r12d
callq 1090 <free@plt>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
lea r14d, [rsi+rsi*8]
mov r13d, esi
neg r13d
lea edi, [rsi+r14+1]
movsxd rdi, edi
mov esi, 4
call _calloc
test rax, rax
jz short loc_121E
mov rdi, rax
movsxd rax, ebx
add dword ptr [rdi+rax*4], 1
test ebx, ebx
jle short loc_126A
lea esi, [rbx+1]
mov edx, 1
mov ecx, 0
mov r12d, 0
jmp short loc_1251
loc_121E:
lea rdi, aMemoryAllocati; "Memory allocation failed"
call _perror
mov edi, 1
call _exit
loc_1234:
add eax, ebx
cdqe
lea r8, [rdi+rax*4]
mov eax, [r8]
add r12d, eax
add eax, 1
mov [r8], eax
loc_1248:
add rdx, 1
cmp rdx, rsi
jz short loc_1270
loc_1251:
movsx eax, byte ptr [rbp+rdx-1]
lea ecx, [rcx+rax-30h]
mov eax, ecx
sub eax, edx
cmp r13d, eax
jg short loc_1248
cmp r14d, eax
jge short loc_1234
jmp short loc_1248
loc_126A:
mov r12d, 0
loc_1270:
call _free
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, int a2)
{
long long v3; // rax
long long v4; // rdi
long long v5; // rdx
int v6; // ecx
unsigned int v7; // r12d
_DWORD *v8; // r8
int v9; // eax
v3 = calloc(10 * a2 + 1, 4LL);
if ( !v3 )
{
perror("Memory allocation failed");
exit(1LL);
}
v4 = v3;
++*(_DWORD *)(v3 + 4LL * a2);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v5 = 1LL;
v6 = 0;
v7 = 0;
do
{
v6 = v6 + *(char *)(a1 + v5 - 1) - 48;
v9 = v6 - v5;
if ( -a2 <= v6 - (int)v5 && 9 * a2 >= v9 )
{
v8 = (_DWORD *)(v4 + 4LL * (a2 + v9));
v7 += (*v8)++;
}
++v5;
}
while ( v5 != a2 + 1 );
}
free();
return v7;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
LEA R14D,[RSI + RSI*0x8]
MOV R13D,ESI
NEG R13D
LEA EDI,[RSI + R14*0x1 + 0x1]
MOVSXD RDI,EDI
MOV ESI,0x4
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010121e
MOV RDI,RAX
MOVSXD RAX,EBX
ADD dword ptr [RDI + RAX*0x4],0x1
TEST EBX,EBX
JLE 0x0010126a
LEA ESI,[RBX + 0x1]
MOV EDX,0x1
MOV ECX,0x0
MOV R12D,0x0
JMP 0x00101251
LAB_0010121e:
LEA RDI,[0x102004]
CALL 0x001010c0
MOV EDI,0x1
CALL 0x001010d0
LAB_00101234:
ADD EAX,EBX
CDQE
LEA R8,[RDI + RAX*0x4]
MOV EAX,dword ptr [R8]
ADD R12D,EAX
ADD EAX,0x1
MOV dword ptr [R8],EAX
LAB_00101248:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x00101270
LAB_00101251:
MOVSX EAX,byte ptr [RBP + RDX*0x1 + -0x1]
LEA ECX,[RCX + RAX*0x1 + -0x30]
MOV EAX,ECX
SUB EAX,EDX
CMP R13D,EAX
JG 0x00101248
CMP R14D,EAX
JGE 0x00101234
JMP 0x00101248
LAB_0010126a:
MOV R12D,0x0
LAB_00101270:
CALL 0x00101090
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int func0(long param_1,int param_2)
{
int *piVar1;
int iVar2;
void *__ptr;
int iVar3;
ulong uVar4;
int iVar5;
__ptr = calloc((long)(param_2 * 10 + 1),4);
if (__ptr == (void *)0x0) {
perror("Memory allocation failed");
/* WARNING: Subroutine does not return */
exit(1);
}
piVar1 = (int *)((long)__ptr + (long)param_2 * 4);
*piVar1 = *piVar1 + 1;
if (param_2 < 1) {
iVar5 = 0;
}
else {
uVar4 = 1;
iVar3 = 0;
iVar5 = 0;
do {
iVar3 = iVar3 + -0x30 + (int)*(char *)(param_1 + -1 + uVar4);
iVar2 = iVar3 - (int)uVar4;
if ((-param_2 <= iVar2) && (iVar2 <= param_2 * 9)) {
piVar1 = (int *)((long)__ptr + (long)(iVar2 + param_2) * 4);
iVar2 = *piVar1;
iVar5 = iVar5 + iVar2;
*piVar1 = iVar2 + 1;
}
uVar4 = uVar4 + 1;
} while (uVar4 != param_2 + 1);
}
free(__ptr);
return iVar5;
} |
4,138 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| int func0(const char *s, int n) {
int count = 0, sum = 0;
// Maximum possible sum is n*9
// Minimum possible sum -n
int max_sum = n * 9;
int min_sum = -n;
int size = max_sum - min_sum + 1;
int *mp = calloc(size, sizeof(int));
if (!mp) {
perror("Memory allocation failed");
exit(EXIT_FAILURE);
}
mp[-min_sum] += 1;
for (int i = 0; i < n; i++) {
sum += s[i] - '0';
int key = sum - (i + 1);
if (key >= min_sum && key <= max_sum) {
count += mp[key - min_sum];
mp[key - min_sum] += 1;
}
}
free(mp);
return count;
}
| int main() {
assert(func0("112112", 6) == 6);
assert(func0("111", 3) == 6);
assert(func0("1101112", 7) == 12);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
lea (%rsi,%rsi,8),%r13d
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
lea 0x1(%rsi,%r13,1),%edi
neg %r12d
push %rbx
movslq %edi,%rdi
mov %esi,%ebx
mov $0x4,%esi
callq 10b0 <calloc@plt>
test %rax,%rax
je 1325 <func0+0xa5>
mov %rax,%rdi
movslq %ebx,%rax
addl $0x1,(%rdi,%rax,4)
test %ebx,%ebx
jle 1320 <func0+0xa0>
lea -0x1(%rbx),%eax
mov $0x1,%ecx
xor %esi,%esi
xor %r14d,%r14d
add $0x2,%rax
nopl 0x0(%rax)
movsbl -0x1(%rbp,%rcx,1),%edx
lea -0x30(%rsi,%rdx,1),%esi
mov %esi,%edx
sub %ecx,%edx
cmp %edx,%r12d
jg 1304 <func0+0x84>
cmp %edx,%r13d
jl 1304 <func0+0x84>
add %ebx,%edx
movslq %edx,%rdx
lea (%rdi,%rdx,4),%r8
mov (%r8),%edx
add %edx,%r14d
add $0x1,%edx
mov %edx,(%r8)
add $0x1,%rcx
cmp %rcx,%rax
jne 12d8 <func0+0x58>
callq 1090 <free@plt>
pop %rbx
mov %r14d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xchg %ax,%ax
xor %r14d,%r14d
jmp 130d <func0+0x8d>
lea 0xcd8(%rip),%rdi
callq 10c0 <perror@plt>
mov $0x1,%edi
callq 10d0 <exit@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
lea r13d, [rsi+rsi*8]
push r12
mov r12d, esi
push rbp
mov rbp, rdi
lea edi, [rsi+r13+1]
neg r12d
push rbx
movsxd rdi, edi
mov ebx, esi
mov esi, 4
call _calloc
test rax, rax
jz short loc_131D
mov rdi, rax
movsxd rax, ebx
add dword ptr [rdi+rax*4], 1
test ebx, ebx
jle short loc_1318
lea esi, [rbx+1]
mov edx, 1
xor ecx, ecx
xor r14d, r14d
nop dword ptr [rax]
loc_12D0:
movsx eax, byte ptr [rbp+rdx-1]
lea ecx, [rcx+rax-30h]
mov eax, ecx
sub eax, edx
cmp r12d, eax
jg short loc_12FB
cmp r13d, eax
jl short loc_12FB
add eax, ebx
cdqe
lea r8, [rdi+rax*4]
mov eax, [r8]
add r14d, eax
add eax, 1
mov [r8], eax
loc_12FB:
add rdx, 1
cmp rsi, rdx
jnz short loc_12D0
loc_1304:
call _free
pop rbx
mov eax, r14d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1318:
xor r14d, r14d
jmp short loc_1304
loc_131D:
lea rdi, aMemoryAllocati; "Memory allocation failed"
call _perror
mov edi, 1
call _exit | long long func0(long long a1, int a2)
{
long long v3; // rax
long long v4; // rdi
long long v5; // rdx
int v6; // ecx
unsigned int v7; // r14d
int v8; // eax
_DWORD *v9; // r8
v3 = calloc(10 * a2 + 1, 4LL);
if ( !v3 )
{
perror("Memory allocation failed");
exit(1LL);
}
v4 = v3;
++*(_DWORD *)(v3 + 4LL * a2);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v5 = 1LL;
v6 = 0;
v7 = 0;
do
{
v6 = v6 + *(char *)(a1 + v5 - 1) - 48;
v8 = v6 - v5;
if ( -a2 <= v6 - (int)v5 && 9 * a2 >= v8 )
{
v9 = (_DWORD *)(v4 + 4LL * (a2 + v8));
v7 += (*v9)++;
}
++v5;
}
while ( a2 + 1 != v5 );
}
free();
return v7;
} | func0:
ENDBR64
PUSH R14
PUSH R13
LEA R13D,[RSI + RSI*0x8]
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDI
LEA EDI,[RSI + R13*0x1 + 0x1]
NEG R12D
PUSH RBX
MOVSXD RDI,EDI
MOV EBX,ESI
MOV ESI,0x4
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010131d
MOV RDI,RAX
MOVSXD RAX,EBX
ADD dword ptr [RDI + RAX*0x4],0x1
TEST EBX,EBX
JLE 0x00101318
LEA ESI,[RBX + 0x1]
MOV EDX,0x1
XOR ECX,ECX
XOR R14D,R14D
NOP dword ptr [RAX]
LAB_001012d0:
MOVSX EAX,byte ptr [RBP + RDX*0x1 + -0x1]
LEA ECX,[RCX + RAX*0x1 + -0x30]
MOV EAX,ECX
SUB EAX,EDX
CMP R12D,EAX
JG 0x001012fb
CMP R13D,EAX
JL 0x001012fb
ADD EAX,EBX
CDQE
LEA R8,[RDI + RAX*0x4]
MOV EAX,dword ptr [R8]
ADD R14D,EAX
ADD EAX,0x1
MOV dword ptr [R8],EAX
LAB_001012fb:
ADD RDX,0x1
CMP RSI,RDX
JNZ 0x001012d0
LAB_00101304:
CALL 0x00101090
POP RBX
MOV EAX,R14D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101318:
XOR R14D,R14D
JMP 0x00101304
LAB_0010131d:
LEA RDI,[0x102004]
CALL 0x001010c0
MOV EDI,0x1
CALL 0x001010d0 | int func0(long param_1,int param_2)
{
int *piVar1;
int iVar2;
void *__ptr;
int iVar3;
ulong uVar4;
int iVar5;
__ptr = calloc((long)(param_2 * 10 + 1),4);
if (__ptr != (void *)0x0) {
piVar1 = (int *)((long)__ptr + (long)param_2 * 4);
*piVar1 = *piVar1 + 1;
if (param_2 < 1) {
iVar5 = 0;
}
else {
uVar4 = 1;
iVar3 = 0;
iVar5 = 0;
do {
iVar3 = iVar3 + -0x30 + (int)*(char *)(param_1 + -1 + uVar4);
iVar2 = iVar3 - (int)uVar4;
if ((-param_2 <= iVar2) && (iVar2 <= param_2 * 9)) {
piVar1 = (int *)((long)__ptr + (long)(iVar2 + param_2) * 4);
iVar2 = *piVar1;
iVar5 = iVar5 + iVar2;
*piVar1 = iVar2 + 1;
}
uVar4 = uVar4 + 1;
} while (param_2 + 1 != uVar4);
}
free(__ptr);
return iVar5;
}
perror("Memory allocation failed");
/* WARNING: Subroutine does not return */
exit(1);
} |
4,139 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| int func0(const char *s, int n) {
int count = 0, sum = 0;
// Maximum possible sum is n*9
// Minimum possible sum -n
int max_sum = n * 9;
int min_sum = -n;
int size = max_sum - min_sum + 1;
int *mp = calloc(size, sizeof(int));
if (!mp) {
perror("Memory allocation failed");
exit(EXIT_FAILURE);
}
mp[-min_sum] += 1;
for (int i = 0; i < n; i++) {
sum += s[i] - '0';
int key = sum - (i + 1);
if (key >= min_sum && key <= max_sum) {
count += mp[key - min_sum];
mp[key - min_sum] += 1;
}
}
free(mp);
return count;
}
| int main() {
assert(func0("112112", 6) == 6);
assert(func0("111", 3) == 6);
assert(func0("1101112", 7) == 12);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
lea (%rsi,%rsi,8),%r13d
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
lea 0x1(%rsi,%r13,1),%edi
neg %r12d
push %rbx
movslq %edi,%rdi
mov %esi,%ebx
mov $0x4,%esi
callq 10b0 <calloc@plt>
test %rax,%rax
je 1325 <func0+0xa5>
mov %rax,%rdi
movslq %ebx,%rax
addl $0x1,(%rdi,%rax,4)
test %ebx,%ebx
jle 1320 <func0+0xa0>
lea -0x1(%rbx),%eax
mov $0x1,%ecx
xor %esi,%esi
xor %r14d,%r14d
add $0x2,%rax
nopl 0x0(%rax)
movsbl -0x1(%rbp,%rcx,1),%edx
lea -0x30(%rsi,%rdx,1),%esi
mov %esi,%edx
sub %ecx,%edx
cmp %edx,%r12d
jg 1304 <func0+0x84>
cmp %edx,%r13d
jl 1304 <func0+0x84>
add %ebx,%edx
movslq %edx,%rdx
lea (%rdi,%rdx,4),%r8
mov (%r8),%edx
add %edx,%r14d
add $0x1,%edx
mov %edx,(%r8)
add $0x1,%rcx
cmp %rcx,%rax
jne 12d8 <func0+0x58>
callq 1090 <free@plt>
pop %rbx
mov %r14d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xchg %ax,%ax
xor %r14d,%r14d
jmp 130d <func0+0x8d>
lea 0xcd8(%rip),%rdi
callq 10c0 <perror@plt>
mov $0x1,%edi
callq 10d0 <exit@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
lea r13d, [rsi+rsi*8]
push r12
mov r12d, esi
push rbp
mov rbp, rdi
lea edi, [rsi+r13+1]
neg r12d
push rbx
movsxd rdi, edi; nmemb
mov ebx, esi
mov esi, 4; size
call _calloc
test rax, rax
jz func0_cold
movsxd rsi, ebx
mov rdi, rax; ptr
add dword ptr [rax+rsi*4], 1
test ebx, ebx
jle short loc_1340
mov edx, 1
xor ecx, ecx
xor r14d, r14d
jmp short loc_12F3
loc_12F0:
mov rdx, rax
loc_12F3:
movsx eax, byte ptr [rbp+rdx-1]
lea ecx, [rcx+rax-30h]
mov eax, ecx
sub eax, edx
cmp r12d, eax
jg short loc_131E
cmp r13d, eax
jl short loc_131E
add eax, ebx
cdqe
lea r8, [rdi+rax*4]
mov eax, [r8]
add r14d, eax
add eax, 1
mov [r8], eax
loc_131E:
lea rax, [rdx+1]
cmp rsi, rdx
jnz short loc_12F0
loc_1327:
call _free
pop rbx
mov eax, r14d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1340:
xor r14d, r14d
jmp short loc_1327 | long long func0(long long a1, int a2)
{
char *v3; // rax
char *v4; // rdi
long long v5; // rdx
int v6; // ecx
unsigned int v7; // r14d
int v8; // eax
char *v9; // r8
v3 = (char *)calloc(10 * a2 + 1, 4uLL);
if ( !v3 )
func0_cold();
v4 = v3;
++*(_DWORD *)&v3[4 * a2];
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v5 = 1LL;
v6 = 0;
v7 = 0;
while ( 1 )
{
v6 = v6 + *(char *)(a1 + v5 - 1) - 48;
v8 = v6 - v5;
if ( -a2 <= v6 - (int)v5 && 9 * a2 >= v8 )
{
v9 = &v4[4 * a2 + 4 * v8];
v7 += (*(_DWORD *)v9)++;
}
if ( a2 == v5 )
break;
++v5;
}
}
free(v4);
return v7;
} | func0:
ENDBR64
PUSH R14
PUSH R13
LEA R13D,[RSI + RSI*0x8]
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDI
LEA EDI,[RSI + R13*0x1 + 0x1]
NEG R12D
PUSH RBX
MOVSXD RDI,EDI
MOV EBX,ESI
MOV ESI,0x4
CALL 0x001010b0
TEST RAX,RAX
JZ 0x001010e0
MOVSXD RSI,EBX
MOV RDI,RAX
ADD dword ptr [RAX + RSI*0x4],0x1
TEST EBX,EBX
JLE 0x00101340
MOV EDX,0x1
XOR ECX,ECX
XOR R14D,R14D
JMP 0x001012f3
LAB_001012f0:
MOV RDX,RAX
LAB_001012f3:
MOVSX EAX,byte ptr [RBP + RDX*0x1 + -0x1]
LEA ECX,[RCX + RAX*0x1 + -0x30]
MOV EAX,ECX
SUB EAX,EDX
CMP R12D,EAX
JG 0x0010131e
CMP R13D,EAX
JL 0x0010131e
ADD EAX,EBX
CDQE
LEA R8,[RDI + RAX*0x4]
MOV EAX,dword ptr [R8]
ADD R14D,EAX
ADD EAX,0x1
MOV dword ptr [R8],EAX
LAB_0010131e:
LEA RAX,[RDX + 0x1]
CMP RSI,RDX
JNZ 0x001012f0
LAB_00101327:
CALL 0x00101090
POP RBX
MOV EAX,R14D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101340:
XOR R14D,R14D
JMP 0x00101327 | int func0(long param_1,int param_2)
{
int *piVar1;
int iVar2;
void *__ptr;
int iVar3;
long lVar4;
int iVar5;
bool bVar6;
__ptr = calloc((long)(param_2 * 10 + 1),4);
if (__ptr == (void *)0x0) {
perror("Memory allocation failed");
/* WARNING: Subroutine does not return */
exit(1);
}
piVar1 = (int *)((long)__ptr + (long)param_2 * 4);
*piVar1 = *piVar1 + 1;
if (param_2 < 1) {
iVar5 = 0;
}
else {
iVar3 = 0;
iVar5 = 0;
lVar4 = 1;
do {
iVar3 = iVar3 + -0x30 + (int)*(char *)(param_1 + -1 + lVar4);
iVar2 = iVar3 - (int)lVar4;
if ((-param_2 <= iVar2) && (iVar2 <= param_2 * 9)) {
piVar1 = (int *)((long)__ptr + (long)(iVar2 + param_2) * 4);
iVar2 = *piVar1;
iVar5 = iVar5 + iVar2;
*piVar1 = iVar2 + 1;
}
bVar6 = param_2 != lVar4;
lVar4 = lVar4 + 1;
} while (bVar6);
}
free(__ptr);
return iVar5;
} |
4,140 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int xs[], int size) {
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (xs[i] < min_val) {
min_val = xs[i];
}
}
return min_val;
}
| int main() {
int arr1[5] = {10, 20, 1, 45, 99};
int arr2[3] = {1, 2, 3};
int arr3[4] = {45, 46, 50, 60};
assert(func0(arr1, 5) == 1);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 45);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x7fffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c0 <func0+0x57>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jle 11bc <func0+0x53>
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 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], 7FFFFFFFh
mov [rbp+var_4], 0
jmp short loc_11C0
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]
cmp [rbp+var_8], eax
jle short loc_11BC
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_11BC:
add [rbp+var_4], 1
loc_11C0:
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)
{
int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( v3 > *(_DWORD *)(4LL * i + a1) )
v3 = *(_DWORD *)(4LL * i + a1);
}
return (unsigned int)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],0x7fffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c0
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]
CMP dword ptr [RBP + -0x8],EAX
JLE 0x001011bc
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_001011bc:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c0:
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 = 0x7fffffff;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < local_10) {
local_10 = *(int *)(param_1 + (long)local_c * 4);
}
}
return local_10;
} |
4,141 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int xs[], int size) {
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (xs[i] < min_val) {
min_val = xs[i];
}
}
return min_val;
}
| int main() {
int arr1[5] = {10, 20, 1, 45, 99};
int arr2[3] = {1, 2, 3};
int arr3[4] = {45, 46, 50, 60};
assert(func0(arr1, 5) == 1);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 45);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1194 <func0+0x2b>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x7fffffff,%edx
mov (%rax),%ecx
cmp %ecx,%edx
cmovg %ecx,%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x7fffffff,%edx
jmp 1191 <func0+0x28>
| func0:
endbr64
test esi, esi
jle short loc_1194
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov edx, 7FFFFFFFh
loc_1181:
mov ecx, [rax]
cmp edx, ecx
cmovg edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1191:
mov eax, edx
retn
loc_1194:
mov edx, 7FFFFFFFh
jmp short loc_1191 | long long func0(int *a1, int a2)
{
int *v2; // rax
long long v3; // rsi
int v4; // edx
if ( a2 <= 0 )
{
return 0x7FFFFFFF;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x7FFFFFFF;
do
{
if ( v4 > *v2 )
v4 = *v2;
++v2;
}
while ( v2 != (int *)v3 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101194
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x7fffffff
LAB_00101181:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVG EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101191:
MOV EAX,EDX
RET
LAB_00101194:
MOV EDX,0x7fffffff
JMP 0x00101191 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0x7fffffff;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0x7fffffff;
do {
if (*param_1 < iVar2) {
iVar2 = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
4,142 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int xs[], int size) {
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (xs[i] < min_val) {
min_val = xs[i];
}
}
return min_val;
}
| int main() {
int arr1[5] = {10, 20, 1, 45, 99};
int arr2[3] = {1, 2, 3};
int arr3[4] = {45, 46, 50, 60};
assert(func0(arr1, 5) == 1);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 45);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
mov $0x7fffffff,%eax
nopl (%rax)
mov (%rdi),%edx
cmp %edx,%eax
cmovg %edx,%eax
add $0x4,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax)
mov $0x7fffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
mov eax, 7FFFFFFFh
nop dword ptr [rax]
loc_1158:
mov edx, [rdi]
cmp eax, edx
cmovg eax, edx
add rdi, 4
cmp rdi, rcx
jnz short loc_1158
retn
loc_1170:
mov eax, 7FFFFFFFh
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rcx
long long result; // rax
if ( a2 <= 0 )
return 0x7FFFFFFFLL;
v2 = (long long)&a1[a2 - 1 + 1];
result = 0x7FFFFFFFLL;
do
{
if ( (int)result > *a1 )
result = (unsigned int)*a1;
++a1;
}
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x7fffffff
NOP dword ptr [RAX]
LAB_00101158:
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVG EAX,EDX
ADD RDI,0x4
CMP RDI,RCX
JNZ 0x00101158
RET
LAB_00101170:
MOV EAX,0x7fffffff
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 = 0x7fffffff;
do {
if (*param_1 < iVar2) {
iVar2 = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0x7fffffff;
} |
4,143 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int xs[], int size) {
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (xs[i] < min_val) {
min_val = xs[i];
}
}
return min_val;
}
| int main() {
int arr1[5] = {10, 20, 1, 45, 99};
int arr2[3] = {1, 2, 3};
int arr3[4] = {45, 46, 50, 60};
assert(func0(arr1, 5) == 1);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 4) == 45);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1210 <func0+0xd0>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1221 <func0+0xe1>
mov %esi,%edx
movdqa 0xeae(%rip),%xmm0
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm1
movdqu (%rax),%xmm3
add $0x10,%rax
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
por %xmm1,%xmm0
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm0,%xmm2
mov %esi,%edx
psrldq $0x8,%xmm2
and $0xfffffffc,%edx
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm0,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 1220 <func0+0xe0>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%eax
cmovg %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 1215 <func0+0xd5>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,%eax
cmovg %ecx,%eax
add $0x2,%edx
cmp %edx,%esi
jle 1215 <func0+0xd5>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
cmp %edx,%eax
cmovg %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x7fffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
retq
xor %edx,%edx
mov $0x7fffffff,%eax
jmp 11da <func0+0x9a>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1220
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1231
mov edx, esi
movdqa xmm0, cs:xmmword_2010
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1178:
movdqu xmm1, xmmword ptr [rax]
movdqu xmm3, xmmword ptr [rax]
add rax, 10h
pcmpgtd xmm1, xmm0
pand xmm0, xmm1
pandn xmm1, xmm3
por xmm0, xmm1
cmp rax, rdx
jnz short loc_1178
movdqa xmm2, xmm0
mov edx, ecx
psrldq xmm2, 8
and edx, 0FFFFFFFCh
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm1, xmm0
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movd eax, xmm0
test cl, 3
jz short locret_1230
loc_11E1:
movsxd rsi, edx
lea r8, ds:0[rsi*4]
mov esi, [rdi+rsi*4]
cmp eax, esi
cmovg eax, esi
lea esi, [rdx+1]
cmp ecx, esi
jle short locret_1225
mov esi, [rdi+r8+4]
cmp eax, esi
cmovg eax, esi
add edx, 2
cmp ecx, edx
jle short locret_1225
mov edx, [rdi+r8+8]
cmp eax, edx
cmovg eax, edx
retn
loc_1220:
mov eax, 7FFFFFFFh
locret_1225:
retn
locret_1230:
retn
loc_1231:
xor edx, edx
mov eax, 7FFFFFFFh
jmp short loc_11E1 | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm0
const __m128i *v4; // rax
__m128i v5; // xmm1
__m128i v6; // xmm3
__m128i v7; // xmm1
__m128i v8; // xmm2
signed int v9; // edx
__m128i v10; // xmm1
__m128i v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm0
long long result; // rax
long long v15; // r8
int v16; // esi
int v17; // esi
int v18; // edx
if ( a2 <= 0 )
return 0x7FFFFFFFLL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v9 = 0;
result = 0x7FFFFFFFLL;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v4 = a1;
do
{
v5 = _mm_loadu_si128(v4);
v6 = v5;
++v4;
v7 = _mm_cmpgt_epi32(v5, si128);
si128 = _mm_or_si128(_mm_and_si128(si128, v7), _mm_andnot_si128(v7, v6));
}
while ( v4 != &a1[(unsigned int)a2 >> 2] );
v8 = _mm_srli_si128(si128, 8);
v9 = a2 & 0xFFFFFFFC;
v10 = _mm_cmpgt_epi32(v8, si128);
v11 = _mm_or_si128(_mm_andnot_si128(v10, v8), _mm_and_si128(si128, v10));
v12 = _mm_srli_si128(v11, 4);
v13 = _mm_cmpgt_epi32(v12, v11);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v13, v12), _mm_and_si128(v11, v13)));
if ( (a2 & 3) == 0 )
return result;
}
v15 = v9;
v16 = a1->m128i_i32[v15];
if ( (int)result > v16 )
result = (unsigned int)v16;
if ( a2 > v9 + 1 )
{
v17 = a1->m128i_i32[v15 + 1];
if ( (int)result > v17 )
result = (unsigned int)v17;
if ( a2 > v9 + 2 )
{
v18 = a1->m128i_i32[v15 + 2];
if ( (int)result > v18 )
return (unsigned int)v18;
}
}
return result;
} | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101220
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101231
MOV EDX,ESI
MOVDQA XMM0,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM1,xmmword ptr [RAX]
MOVDQU XMM3,xmmword ptr [RAX]
ADD RAX,0x10
PCMPGTD XMM1,XMM0
PAND XMM0,XMM1
PANDN XMM1,XMM3
POR XMM0,XMM1
CMP RAX,RDX
JNZ 0x00101178
MOVDQA XMM2,XMM0
MOV EDX,ECX
PSRLDQ XMM2,0x8
AND EDX,0xfffffffc
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM1,XMM0
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x00101230
LAB_001011e1:
MOVSXD RSI,EDX
LEA R8,[RSI*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
CMP EAX,ESI
CMOVG EAX,ESI
LEA ESI,[RDX + 0x1]
CMP ECX,ESI
JLE 0x00101225
MOV ESI,dword ptr [RDI + R8*0x1 + 0x4]
CMP EAX,ESI
CMOVG EAX,ESI
ADD EDX,0x2
CMP ECX,EDX
JLE 0x00101225
MOV EDX,dword ptr [RDI + R8*0x1 + 0x8]
CMP EAX,EDX
CMOVG EAX,EDX
RET
LAB_00101220:
MOV EAX,0x7fffffff
LAB_00101225:
RET
LAB_00101230:
RET
LAB_00101231:
XOR EDX,EDX
MOV EAX,0x7fffffff
JMP 0x001011e1 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
if ((int)param_2 < 1) {
uVar10 = 0x7fffffff;
}
else {
if (param_2 - 1 < 3) {
uVar9 = 0;
uVar10 = 0x7fffffff;
}
else {
puVar8 = param_1;
uVar10 = _DAT_00102010;
uVar11 = _UNK_00102014;
uVar12 = _UNK_00102018;
uVar13 = _UNK_0010201c;
do {
uVar9 = *puVar8;
puVar1 = puVar8 + 1;
puVar2 = puVar8 + 2;
puVar3 = puVar8 + 3;
uVar4 = *puVar8;
puVar5 = puVar8 + 1;
puVar6 = puVar8 + 2;
puVar7 = puVar8 + 3;
puVar8 = puVar8 + 4;
uVar10 = uVar10 & -(uint)((int)uVar10 < (int)uVar9) |
~-(uint)((int)uVar10 < (int)uVar9) & uVar4;
uVar11 = uVar11 & -(uint)((int)uVar11 < (int)*puVar1) |
~-(uint)((int)uVar11 < (int)*puVar1) & *puVar5;
uVar12 = uVar12 & -(uint)((int)uVar12 < (int)*puVar2) |
~-(uint)((int)uVar12 < (int)*puVar2) & *puVar6;
uVar13 = uVar13 & -(uint)((int)uVar13 < (int)*puVar3) |
~-(uint)((int)uVar13 < (int)*puVar3) & *puVar7;
} while (puVar8 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar9 = param_2 & 0xfffffffc;
uVar12 = ~-(uint)((int)uVar10 < (int)uVar12) & uVar12 |
uVar10 & -(uint)((int)uVar10 < (int)uVar12);
uVar11 = ~-(uint)((int)uVar11 < (int)uVar13) & uVar13 |
uVar11 & -(uint)((int)uVar11 < (int)uVar13);
uVar10 = -(uint)((int)uVar12 < (int)uVar11);
uVar10 = ~uVar10 & uVar11 | uVar12 & uVar10;
if ((param_2 & 3) == 0) {
return uVar10;
}
}
if ((int)param_1[(int)uVar9] < (int)uVar10) {
uVar10 = param_1[(int)uVar9];
}
if ((int)(uVar9 + 1) < (int)param_2) {
if ((int)param_1[(long)(int)uVar9 + 1] < (int)uVar10) {
uVar10 = param_1[(long)(int)uVar9 + 1];
}
if ((int)(uVar9 + 2) < (int)param_2) {
if ((int)param_1[(long)(int)uVar9 + 2] < (int)uVar10) {
uVar10 = param_1[(long)(int)uVar9 + 2];
}
return uVar10;
}
}
}
return uVar10;
} |
4,144 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][2], int list_size) {
int max_diff = 0;
for (int i = 0; i < list_size; i++) {
int diff = abs(test_list[i][1] - test_list[i][0]);
if (diff > max_diff) {
max_diff = diff;
}
}
return max_diff;
}
| int main() {
int arr1[][2] = {{3, 5}, {1, 7}, {10, 3}, {1, 2}};
int arr2[][2] = {{4, 6}, {2, 17}, {9, 13}, {11, 12}};
int arr3[][2] = {{12, 35}, {21, 27}, {13, 23}, {41, 22}};
assert(func0(arr1, 4) == 7);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 4) == 23);
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 11d6 <func0+0x6d>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
mov %edx,-0x4(%rbp)
sub %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 11d2 <func0+0x69>
mov -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D4
loc_1188:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax+4]
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov edx, [rdx]
sub eax, edx
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_C]
jle short loc_11D0
mov eax, [rbp+var_4]
mov [rbp+var_C], eax
loc_11D0:
add [rbp+var_8], 1
loc_11D4:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
long long v2; // rcx
int v3; // eax
int v5; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
v2 = 8LL * i;
v3 = *(_DWORD *)(v2 + a1 + 4) - *(_DWORD *)(v2 + a1);
if ( *(_DWORD *)(v2 + a1) - *(_DWORD *)(v2 + a1 + 4) >= 0 )
v3 = *(_DWORD *)(v2 + a1) - *(_DWORD *)(8LL * i + a1 + 4);
if ( v3 > v5 )
v5 = v3;
}
return (unsigned int)v5;
} | 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 0x001011d4
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x4]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EDX,dword ptr [RDX]
SUB EAX,EDX
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x001011d0
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011d0:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d4:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int iVar1;
int4 local_14;
int4 local_10;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
iVar1 = *(int *)(param_1 + (long)local_10 * 8 + 4) - *(int *)(param_1 + (long)local_10 * 8);
if (iVar1 < 1) {
iVar1 = -iVar1;
}
if (local_14 < iVar1) {
local_14 = iVar1;
}
}
return local_14;
} |
4,145 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][2], int list_size) {
int max_diff = 0;
for (int i = 0; i < list_size; i++) {
int diff = abs(test_list[i][1] - test_list[i][0]);
if (diff > max_diff) {
max_diff = diff;
}
}
return max_diff;
}
| int main() {
int arr1[][2] = {{3, 5}, {1, 7}, {10, 3}, {1, 2}};
int arr2[][2] = {{4, 6}, {2, 17}, {9, 13}, {11, 12}};
int arr3[][2] = {{12, 35}, {21, 27}, {13, 23}, {41, 22}};
assert(func0(arr1, 4) == 7);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 4) == 23);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a0 <func0+0x37>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdi
mov $0x0,%ecx
mov 0x4(%rdx),%eax
sub (%rdx),%eax
mov %eax,%esi
sar $0x1f,%esi
xor %esi,%eax
sub %esi,%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0x8,%rdx
cmp %rdi,%rdx
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 119d <func0+0x34>
| func0:
endbr64
test esi, esi
jle short loc_119E
mov rdx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*8+8]
mov esi, 0
loc_1181:
mov eax, [rdx+4]
sub eax, [rdx]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp esi, eax
cmovl esi, eax
add rdx, 8
cmp rdx, rdi
jnz short loc_1181
loc_119B:
mov eax, esi
retn
loc_119E:
mov esi, 0
jmp short loc_119B | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rdx
long long v3; // rdi
int v4; // esi
int v5; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[2 * (a2 - 1) + 2];
v4 = 0;
do
{
v5 = v2[1] - *v2;
if ( *v2 - v2[1] >= 0 )
v5 = *v2 - v2[1];
if ( v4 < v5 )
v4 = v5;
v2 += 2;
}
while ( v2 != (_DWORD *)v3 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119e
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x8 + 0x8]
MOV ESI,0x0
LAB_00101181:
MOV EAX,dword ptr [RDX + 0x4]
SUB EAX,dword ptr [RDX]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP ESI,EAX
CMOVL ESI,EAX
ADD RDX,0x8
CMP RDX,RDI
JNZ 0x00101181
LAB_0010119b:
MOV EAX,ESI
RET
LAB_0010119e:
MOV ESI,0x0
JMP 0x0010119b | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
iVar3 = 0;
do {
iVar2 = param_1[1] - *param_1;
if (iVar2 < 1) {
iVar2 = -iVar2;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
}
return iVar3;
} |
4,146 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][2], int list_size) {
int max_diff = 0;
for (int i = 0; i < list_size; i++) {
int diff = abs(test_list[i][1] - test_list[i][0]);
if (diff > max_diff) {
max_diff = diff;
}
}
return max_diff;
}
| int main() {
int arr1[][2] = {{3, 5}, {1, 7}, {10, 3}, {1, 2}};
int arr2[][2] = {{4, 6}, {2, 17}, {9, 13}, {11, 12}};
int arr3[][2] = {{12, 35}, {21, 27}, {13, 23}, {41, 22}};
assert(func0(arr1, 4) == 7);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 4) == 23);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x8(%rdi,%rax,8),%rcx
nopl 0x0(%rax,%rax,1)
mov 0x4(%rdi),%eax
sub (%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x8,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1390
lea eax, [rsi-1]
xor r8d, r8d
lea rcx, [rdi+rax*8+8]
nop dword ptr [rax+rax+00h]
loc_1368:
mov eax, [rdi+4]
sub eax, [rdi]
mov edx, eax
neg edx
cmovns eax, edx
cmp r8d, eax
cmovl r8d, eax
add rdi, 8
cmp rdi, rcx
jnz short loc_1368
mov eax, r8d
retn
loc_1390:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // r8d
long long v3; // rcx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[2 * (a2 - 1) + 2];
do
{
v4 = a1[1] - *a1;
if ( *a1 - a1[1] >= 0 )
v4 = *a1 - a1[1];
if ( v2 < v4 )
v2 = v4;
a1 += 2;
}
while ( a1 != (_DWORD *)v3 );
return (unsigned int)v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101390
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RCX,[RDI + RAX*0x8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101368:
MOV EAX,dword ptr [RDI + 0x4]
SUB EAX,dword ptr [RDI]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0x8
CMP RDI,RCX
JNZ 0x00101368
MOV EAX,R8D
RET
LAB_00101390:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
iVar2 = param_1[1] - *param_1;
if (iVar2 < 1) {
iVar2 = -iVar2;
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
return iVar3;
}
return 0;
} |
4,147 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][2], int list_size) {
int max_diff = 0;
for (int i = 0; i < list_size; i++) {
int diff = abs(test_list[i][1] - test_list[i][0]);
if (diff > max_diff) {
max_diff = diff;
}
}
return max_diff;
}
| int main() {
int arr1[][2] = {{3, 5}, {1, 7}, {10, 3}, {1, 2}};
int arr2[][2] = {{4, 6}, {2, 17}, {9, 13}, {11, 12}};
int arr3[][2] = {{12, 35}, {21, 27}, {13, 23}, {41, 22}};
assert(func0(arr1, 4) == 7);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 4) == 23);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 14d0 <func0+0x130>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 14d9 <func0+0x139>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm3,%xmm3
shr $0x2,%edx
shl $0x5,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
movdqu 0x10(%rax),%xmm4
add $0x20,%rax
movdqa %xmm2,%xmm0
shufps $0x88,%xmm4,%xmm2
shufps $0xdd,%xmm4,%xmm0
psubd %xmm2,%xmm0
movdqa %xmm0,%xmm1
psrad $0x1f,%xmm1
pxor %xmm1,%xmm0
psubd %xmm1,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
movdqa %xmm1,%xmm3
por %xmm0,%xmm3
cmp %rdx,%rax
jne 13d0 <func0+0x30>
movdqa %xmm3,%xmm0
mov %esi,%ecx
psrldq $0x8,%xmm0
and $0xfffffffc,%ecx
movdqa %xmm0,%xmm1
pcmpgtd %xmm3,%xmm1
pand %xmm1,%xmm0
pandn %xmm3,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 14d8 <func0+0x138>
movslq %ecx,%r8
mov 0x4(%rdi,%r8,8),%edx
sub (%rdi,%r8,8),%edx
mov %edx,%r8d
sar $0x1f,%r8d
xor %r8d,%edx
sub %r8d,%edx
cmp %edx,%eax
cmovl %edx,%eax
lea 0x1(%rcx),%edx
cmp %edx,%esi
jle 14d2 <func0+0x132>
movslq %edx,%r8
mov 0x4(%rdi,%r8,8),%edx
sub (%rdi,%r8,8),%edx
mov %edx,%r8d
sar $0x1f,%r8d
xor %r8d,%edx
sub %r8d,%edx
cmp %edx,%eax
cmovl %edx,%eax
add $0x2,%ecx
cmp %ecx,%esi
jle 14d2 <func0+0x132>
movslq %ecx,%rcx
mov 0x4(%rdi,%rcx,8),%edx
sub (%rdi,%rcx,8),%edx
mov %edx,%ecx
sar $0x1f,%ecx
xor %ecx,%edx
sub %ecx,%edx
cmp %edx,%eax
cmovl %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %ecx,%ecx
xor %eax,%eax
jmp 1464 <func0+0xc4>
| func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1408
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1411
mov edx, esi
mov rax, rdi
pxor xmm2, xmm2
shr edx, 2
shl rdx, 5
add rdx, rdi
nop dword ptr [rax]
loc_1310:
movdqu xmm1, xmmword ptr [rax]
movdqu xmm3, xmmword ptr [rax+10h]
add rax, 20h ; ' '
movdqa xmm0, xmm1
shufps xmm1, xmm3, 88h
shufps xmm0, xmm3, 0DDh
psubd xmm0, xmm1
movdqa xmm1, xmm0
psrad xmm1, 1Fh
pxor xmm0, xmm1
psubd xmm0, xmm1
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_1310
movdqa xmm1, xmm2
mov esi, ecx
psrldq xmm1, 8
and esi, 0FFFFFFFCh
movdqa xmm0, xmm1
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 eax, xmm1
test cl, 3
jz short locret_1410
loc_13A3:
movsxd r8, esi
shl r8, 3
lea r9, [rdi+r8]
mov edx, [r9+4]
sub edx, [r9]
mov r9d, edx
neg r9d
cmovns edx, r9d
cmp eax, edx
cmovl eax, edx
lea edx, [rsi+1]
cmp ecx, edx
jle short locret_140A
lea r9, [rdi+r8+8]
mov edx, [r9+4]
sub edx, [r9]
mov r9d, edx
neg r9d
cmovns edx, r9d
cmp eax, edx
cmovl eax, edx
add esi, 2
cmp ecx, esi
jle short locret_140A
lea rcx, [rdi+r8+10h]
mov edx, [rcx+4]
sub edx, [rcx]
mov ecx, edx
neg ecx
cmovns edx, ecx
cmp eax, edx
cmovl eax, edx
retn
loc_1408:
xor eax, eax
locret_140A:
retn
locret_1410:
retn
loc_1411:
xor esi, esi
xor eax, eax
jmp short loc_13A3 | long long func0(const __m128i *a1, int a2)
{
const __m128i *v3; // rax
__m128i v4; // xmm2
__m128 v5; // xmm1
__m128 v6; // xmm3
__m128i v7; // xmm0
__m128i v8; // xmm1
__m128i v9; // xmm0
__m128i v10; // xmm1
__m128i v11; // xmm1
signed int v12; // esi
__m128i v13; // xmm0
__m128i v14; // xmm0
__m128i v15; // xmm2
__m128i v16; // xmm1
long long result; // rax
long long v18; // r8
int v19; // edx
int v20; // edx
int v21; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v12 = 0;
result = 0LL;
}
else
{
v3 = a1;
v4 = 0LL;
do
{
v5 = (__m128)_mm_loadu_si128(v3);
v6 = (__m128)_mm_loadu_si128(v3 + 1);
v3 += 2;
v7 = _mm_sub_epi32((__m128i)_mm_shuffle_ps(v5, v6, 221), (__m128i)_mm_shuffle_ps(v5, v6, 136));
v8 = _mm_srai_epi32(v7, 0x1Fu);
v9 = _mm_sub_epi32(_mm_xor_si128(v7, v8), v8);
v10 = _mm_cmpgt_epi32(v9, v4);
v4 = _mm_or_si128(_mm_andnot_si128(v10, v4), _mm_and_si128(v9, v10));
}
while ( v3 != &a1[2 * ((unsigned int)a2 >> 2)] );
v11 = _mm_srli_si128(v4, 8);
v12 = a2 & 0xFFFFFFFC;
v13 = _mm_cmpgt_epi32(v11, v4);
v14 = _mm_or_si128(_mm_andnot_si128(v13, v4), _mm_and_si128(v11, v13));
v15 = _mm_srli_si128(v14, 4);
v16 = _mm_cmpgt_epi32(v15, v14);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v16, v14), _mm_and_si128(v15, v16)));
if ( (a2 & 3) == 0 )
return result;
}
v18 = 2LL * v12;
v19 = a1->m128i_i32[v18 + 1] - a1->m128i_i32[v18];
if ( a1->m128i_i32[v18] - a1->m128i_i32[v18 + 1] >= 0 )
v19 = a1->m128i_i32[2 * v12] - a1->m128i_i32[2 * v12 + 1];
if ( (int)result < v19 )
result = (unsigned int)v19;
if ( a2 > v12 + 1 )
{
v20 = a1->m128i_i32[v18 + 3] - a1->m128i_i32[v18 + 2];
if ( a1->m128i_i32[v18 + 2] - a1->m128i_i32[v18 + 3] >= 0 )
v20 = a1->m128i_i32[v18 + 2] - a1->m128i_i32[v18 + 3];
if ( (int)result < v20 )
result = (unsigned int)v20;
if ( a2 > v12 + 2 )
{
v21 = a1[1].m128i_i32[v18 + 1] - a1[1].m128i_i32[v18];
if ( a1[1].m128i_i32[v18] - a1[1].m128i_i32[v18 + 1] >= 0 )
v21 = a1[1].m128i_i32[v18] - a1[1].m128i_i32[v18 + 1];
if ( (int)result < v21 )
return (unsigned int)v21;
}
}
return result;
} | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101408
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101411
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM2,XMM2
SHR EDX,0x2
SHL RDX,0x5
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101310:
MOVDQU XMM1,xmmword ptr [RAX]
MOVDQU XMM3,xmmword ptr [RAX + 0x10]
ADD RAX,0x20
MOVDQA XMM0,XMM1
SHUFPS XMM1,XMM3,0x88
SHUFPS XMM0,XMM3,0xdd
PSUBD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRAD XMM1,0x1f
PXOR XMM0,XMM1
PSUBD XMM0,XMM1
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x00101310
MOVDQA XMM1,XMM2
MOV ESI,ECX
PSRLDQ XMM1,0x8
AND ESI,0xfffffffc
MOVDQA XMM0,XMM1
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 EAX,XMM1
TEST CL,0x3
JZ 0x00101410
LAB_001013a3:
MOVSXD R8,ESI
SHL R8,0x3
LEA R9,[RDI + R8*0x1]
MOV EDX,dword ptr [R9 + 0x4]
SUB EDX,dword ptr [R9]
MOV R9D,EDX
NEG R9D
CMOVNS EDX,R9D
CMP EAX,EDX
CMOVL EAX,EDX
LEA EDX,[RSI + 0x1]
CMP ECX,EDX
JLE 0x0010140a
LEA R9,[RDI + R8*0x1 + 0x8]
MOV EDX,dword ptr [R9 + 0x4]
SUB EDX,dword ptr [R9]
MOV R9D,EDX
NEG R9D
CMOVNS EDX,R9D
CMP EAX,EDX
CMOVL EAX,EDX
ADD ESI,0x2
CMP ECX,ESI
JLE 0x0010140a
LEA RCX,[RDI + R8*0x1 + 0x10]
MOV EDX,dword ptr [RCX + 0x4]
SUB EDX,dword ptr [RCX]
MOV ECX,EDX
NEG ECX
CMOVNS EDX,ECX
CMP EAX,EDX
CMOVL EAX,EDX
RET
LAB_00101408:
XOR EAX,EAX
LAB_0010140a:
RET
LAB_00101410:
RET
LAB_00101411:
XOR ESI,ESI
XOR EAX,EAX
JMP 0x001013a3 | uint func0(int *param_1,uint param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
uint uVar9;
int *piVar10;
uint uVar11;
long lVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
if ((int)param_2 < 1) {
uVar9 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar13 = 0;
uVar9 = 0;
}
else {
uVar9 = 0;
uVar11 = 0;
uVar15 = 0;
uVar22 = 0;
piVar10 = param_1;
do {
iVar2 = *piVar10;
piVar3 = piVar10 + 1;
piVar4 = piVar10 + 2;
piVar5 = piVar10 + 3;
piVar1 = piVar10 + 4;
piVar6 = piVar10 + 5;
piVar7 = piVar10 + 6;
piVar8 = piVar10 + 7;
piVar10 = piVar10 + 8;
uVar13 = *piVar3 - iVar2 >> 0x1f;
uVar16 = *piVar5 - *piVar4 >> 0x1f;
uVar18 = *piVar6 - *piVar1 >> 0x1f;
uVar20 = *piVar8 - *piVar7 >> 0x1f;
uVar13 = (*piVar3 - iVar2 ^ uVar13) - uVar13;
uVar16 = (*piVar5 - *piVar4 ^ uVar16) - uVar16;
uVar18 = (*piVar6 - *piVar1 ^ uVar18) - uVar18;
uVar20 = (*piVar8 - *piVar7 ^ uVar20) - uVar20;
uVar14 = -(uint)((int)uVar9 < (int)uVar13);
uVar17 = -(uint)((int)uVar11 < (int)uVar16);
uVar19 = -(uint)((int)uVar15 < (int)uVar18);
uVar21 = -(uint)((int)uVar22 < (int)uVar20);
uVar9 = ~uVar14 & uVar9 | uVar13 & uVar14;
uVar11 = ~uVar17 & uVar11 | uVar16 & uVar17;
uVar15 = ~uVar19 & uVar15 | uVar18 & uVar19;
uVar22 = ~uVar21 & uVar22 | uVar20 & uVar21;
} while (piVar10 != param_1 + (ulong)(param_2 >> 2) * 8);
uVar13 = param_2 & 0xfffffffc;
uVar9 = ~-(uint)((int)uVar9 < (int)uVar15) & uVar9 |
uVar15 & -(uint)((int)uVar9 < (int)uVar15);
uVar11 = ~-(uint)((int)uVar11 < (int)uVar22) & uVar11 |
uVar22 & -(uint)((int)uVar11 < (int)uVar22);
uVar15 = -(uint)((int)uVar9 < (int)uVar11);
uVar9 = ~uVar15 & uVar9 | uVar11 & uVar15;
if ((param_2 & 3) == 0) {
return uVar9;
}
}
lVar12 = (long)(int)uVar13;
uVar11 = (param_1 + lVar12 * 2)[1] - param_1[lVar12 * 2];
if ((int)uVar11 < 1) {
uVar11 = -uVar11;
}
if ((int)uVar9 < (int)uVar11) {
uVar9 = uVar11;
}
if ((int)(uVar13 + 1) < (int)param_2) {
uVar11 = (param_1 + lVar12 * 2 + 2)[1] - param_1[lVar12 * 2 + 2];
if ((int)uVar11 < 1) {
uVar11 = -uVar11;
}
if ((int)uVar9 < (int)uVar11) {
uVar9 = uVar11;
}
if ((int)(uVar13 + 2) < (int)param_2) {
uVar13 = (param_1 + lVar12 * 2 + 4)[1] - param_1[lVar12 * 2 + 4];
if ((int)uVar13 < 1) {
uVar13 = -uVar13;
}
if ((int)uVar9 < (int)uVar13) {
uVar9 = uVar13;
}
return uVar9;
}
}
}
return uVar9;
} |
4,148 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char subject[30];
int marks;
} SubjectMarks;
int cmp(const void *a, const void *b) {
SubjectMarks *sm1 = (SubjectMarks *)a;
SubjectMarks *sm2 = (SubjectMarks *)b;
return sm1->marks - sm2->marks;
}
| void func0(SubjectMarks sm[], int len) {
qsort(sm, len, sizeof(SubjectMarks), cmp);
}
| int main() {
SubjectMarks sm1[] = {{"English", 88}, {"Science", 90}, {"Maths", 97}, {"Social sciences", 82}};
func0(sm1, 4);
assert(sm1[0].marks == 82 && !strcmp(sm1[0].subject, "Social sciences"));
assert(sm1[1].marks == 88 && !strcmp(sm1[1].subject, "English"));
assert(sm1[2].marks == 90 && !strcmp(sm1[2].subject, "Science"));
assert(sm1[3].marks == 97 && !strcmp(sm1[3].subject, "Maths"));
SubjectMarks sm2[] = {{"Telugu", 49}, {"Hindhi", 54}, {"Social", 33}};
func0(sm2, 3);
assert(sm2[0].marks == 33 && !strcmp(sm2[0].subject, "Social"));
assert(sm2[1].marks == 49 && !strcmp(sm2[1].subject, "Telugu"));
assert(sm2[2].marks == 54 && !strcmp(sm2[2].subject, "Hindhi"));
SubjectMarks sm3[] = {{"Physics", 96}, {"Chemistry", 97}, {"Biology", 45}};
func0(sm3, 3);
assert(sm3[0].marks == 45 && !strcmp(sm3[0].subject, "Biology"));
assert(sm3[1].marks == 96 && !strcmp(sm3[1].subject, "Physics"));
assert(sm3[2].marks == 97 && !strcmp(sm3[2].subject, "Chemistry"));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%esi
mov -0x8(%rbp),%rax
lea -0x55(%rip),%rcx
mov $0x24,%edx
mov %rax,%rdi
mov $0x0,%eax
callq 1080 <qsort@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+nmemb+4], rdi
mov dword ptr [rbp+nmemb], esi
mov esi, dword ptr [rbp+nmemb]; nmemb
mov rax, [rbp+nmemb+4]
lea rdx, cmp
mov rcx, rdx; compar
mov edx, 24h ; '$'; size
mov rdi, rax; base
mov eax, 0
call _qsort
nop
leave
retn | void func0(void *a1, unsigned int a2)
{
qsort(a1, a2, 0x24uLL, cmp);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV ESI,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x1011a9]
MOV RCX,RDX
MOV EDX,0x24
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101080
NOP
LEAVE
RET | void func0(void *param_1,uint param_2)
{
qsort(param_1,(ulong)param_2,0x24,cmp);
return;
} |
4,149 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char subject[30];
int marks;
} SubjectMarks;
int cmp(const void *a, const void *b) {
SubjectMarks *sm1 = (SubjectMarks *)a;
SubjectMarks *sm2 = (SubjectMarks *)b;
return sm1->marks - sm2->marks;
}
| void func0(SubjectMarks sm[], int len) {
qsort(sm, len, sizeof(SubjectMarks), cmp);
}
| int main() {
SubjectMarks sm1[] = {{"English", 88}, {"Science", 90}, {"Maths", 97}, {"Social sciences", 82}};
func0(sm1, 4);
assert(sm1[0].marks == 82 && !strcmp(sm1[0].subject, "Social sciences"));
assert(sm1[1].marks == 88 && !strcmp(sm1[1].subject, "English"));
assert(sm1[2].marks == 90 && !strcmp(sm1[2].subject, "Science"));
assert(sm1[3].marks == 97 && !strcmp(sm1[3].subject, "Maths"));
SubjectMarks sm2[] = {{"Telugu", 49}, {"Hindhi", 54}, {"Social", 33}};
func0(sm2, 3);
assert(sm2[0].marks == 33 && !strcmp(sm2[0].subject, "Social"));
assert(sm2[1].marks == 49 && !strcmp(sm2[1].subject, "Telugu"));
assert(sm2[2].marks == 54 && !strcmp(sm2[2].subject, "Hindhi"));
SubjectMarks sm3[] = {{"Physics", 96}, {"Chemistry", 97}, {"Biology", 45}};
func0(sm3, 3);
assert(sm3[0].marks == 45 && !strcmp(sm3[0].subject, "Biology"));
assert(sm3[1].marks == 96 && !strcmp(sm3[1].subject, "Physics"));
assert(sm3[2].marks == 97 && !strcmp(sm3[2].subject, "Chemistry"));
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
lea -0x1a(%rip),%rcx
mov $0x24,%edx
mov $0x0,%eax
callq 1070 <qsort@plt>
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
lea rcx, cmp
mov edx, 24h ; '$'
mov eax, 0
call _qsort
add rsp, 8
retn | long long func0(long long a1, long long a2)
{
return qsort(a1, a2, 36LL, cmp);
} | func0:
ENDBR64
SUB RSP,0x8
LEA RCX,[0x1011a9]
MOV EDX,0x24
MOV EAX,0x0
CALL 0x00101080
ADD RSP,0x8
RET | void func0(void *param_1,size_t param_2)
{
qsort(param_1,param_2,0x24,cmp);
return;
} |
4,150 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char subject[30];
int marks;
} SubjectMarks;
int cmp(const void *a, const void *b) {
SubjectMarks *sm1 = (SubjectMarks *)a;
SubjectMarks *sm2 = (SubjectMarks *)b;
return sm1->marks - sm2->marks;
}
| void func0(SubjectMarks sm[], int len) {
qsort(sm, len, sizeof(SubjectMarks), cmp);
}
| int main() {
SubjectMarks sm1[] = {{"English", 88}, {"Science", 90}, {"Maths", 97}, {"Social sciences", 82}};
func0(sm1, 4);
assert(sm1[0].marks == 82 && !strcmp(sm1[0].subject, "Social sciences"));
assert(sm1[1].marks == 88 && !strcmp(sm1[1].subject, "English"));
assert(sm1[2].marks == 90 && !strcmp(sm1[2].subject, "Science"));
assert(sm1[3].marks == 97 && !strcmp(sm1[3].subject, "Maths"));
SubjectMarks sm2[] = {{"Telugu", 49}, {"Hindhi", 54}, {"Social", 33}};
func0(sm2, 3);
assert(sm2[0].marks == 33 && !strcmp(sm2[0].subject, "Social"));
assert(sm2[1].marks == 49 && !strcmp(sm2[1].subject, "Telugu"));
assert(sm2[2].marks == 54 && !strcmp(sm2[2].subject, "Hindhi"));
SubjectMarks sm3[] = {{"Physics", 96}, {"Chemistry", 97}, {"Biology", 45}};
func0(sm3, 3);
assert(sm3[0].marks == 45 && !strcmp(sm3[0].subject, "Biology"));
assert(sm3[1].marks == 96 && !strcmp(sm3[1].subject, "Physics"));
assert(sm3[2].marks == 97 && !strcmp(sm3[2].subject, "Chemistry"));
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1b(%rip),%rcx
mov $0x24,%edx
xor %eax,%eax
jmpq 1070 <qsort@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea rcx, cmp
mov edx, 24h ; '$'
xor eax, eax
jmp _qsort | long long func0(long long a1, long long a2)
{
return qsort(a1, a2, 36LL, cmp);
} | func0:
ENDBR64
LEA RCX,[0x101790]
MOV EDX,0x24
XOR EAX,EAX
JMP 0x00101080 | void func0(void *param_1,size_t param_2)
{
qsort(param_1,param_2,0x24,cmp);
return;
} |
4,151 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char subject[30];
int marks;
} SubjectMarks;
int cmp(const void *a, const void *b) {
SubjectMarks *sm1 = (SubjectMarks *)a;
SubjectMarks *sm2 = (SubjectMarks *)b;
return sm1->marks - sm2->marks;
}
| void func0(SubjectMarks sm[], int len) {
qsort(sm, len, sizeof(SubjectMarks), cmp);
}
| int main() {
SubjectMarks sm1[] = {{"English", 88}, {"Science", 90}, {"Maths", 97}, {"Social sciences", 82}};
func0(sm1, 4);
assert(sm1[0].marks == 82 && !strcmp(sm1[0].subject, "Social sciences"));
assert(sm1[1].marks == 88 && !strcmp(sm1[1].subject, "English"));
assert(sm1[2].marks == 90 && !strcmp(sm1[2].subject, "Science"));
assert(sm1[3].marks == 97 && !strcmp(sm1[3].subject, "Maths"));
SubjectMarks sm2[] = {{"Telugu", 49}, {"Hindhi", 54}, {"Social", 33}};
func0(sm2, 3);
assert(sm2[0].marks == 33 && !strcmp(sm2[0].subject, "Social"));
assert(sm2[1].marks == 49 && !strcmp(sm2[1].subject, "Telugu"));
assert(sm2[2].marks == 54 && !strcmp(sm2[2].subject, "Hindhi"));
SubjectMarks sm3[] = {{"Physics", 96}, {"Chemistry", 97}, {"Biology", 45}};
func0(sm3, 3);
assert(sm3[0].marks == 45 && !strcmp(sm3[0].subject, "Biology"));
assert(sm3[1].marks == 96 && !strcmp(sm3[1].subject, "Physics"));
assert(sm3[2].marks == 97 && !strcmp(sm3[2].subject, "Chemistry"));
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1b(%rip),%rcx
mov $0x24,%edx
xor %eax,%eax
jmpq 1070 <qsort@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea rcx, cmp; compar
mov edx, 24h ; '$'; size
xor eax, eax
jmp _qsort | void func0(void *a1, size_t a2)
{
qsort(a1, a2, 0x24uLL, cmp);
} | func0:
ENDBR64
LEA RCX,[0x1016c0]
MOV EDX,0x24
XOR EAX,EAX
JMP 0x00101080 | void func0(void *param_1,size_t param_2)
{
qsort(param_1,param_2,0x24,cmp);
return;
} |
4,152 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *data_list, int n) {
int total = 0;
for (int i = 0; i < n; i++) {
if (data_list[i] < 0) { // Negative value used as a sentinel for sublists
int sub_length = -data_list[i]; // Length of the sublist
i++;
total += func0(&data_list[i], sub_length);
i += sub_length - 1; // Adjust the index to the end of the sublist
} else {
total += data_list[i];
}
}
return total;
}
| int main() {
int list1[] = {1, 2, -2, 3, 4, -2, 5, 6};
int list2[] = {7, 10, -2, 15, 14, -2, 19, 41};
int list3[] = {10, 20, -2, 30, 40, -2, 50, 60};
assert(func0(list1, 8) == 21);
assert(func0(list2, 8) == 106);
assert(func0(list3, 8) == 210);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1234 <func0+0xab>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jns 1217 <func0+0x8e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
neg %eax
mov %eax,-0x4(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,%esi
mov %rdx,%rdi
callq 1189 <func0>
add %eax,-0xc(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
add %eax,-0x8(%rbp)
jmp 1230 <func0+0xa7>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11af <func0+0x26>
mov -0xc(%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 [rbp+var_C], 0
mov [rbp+var_8], 0
jmp loc_1234
loc_11AF:
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
jns short loc_1217
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
neg eax
mov [rbp+var_4], eax
add [rbp+var_8], 1
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
mov esi, eax
mov rdi, rdx
call func0
add [rbp+var_C], eax
mov eax, [rbp+var_4]
sub eax, 1
add [rbp+var_8], eax
jmp short loc_1230
loc_1217:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_C], eax
loc_1230:
add [rbp+var_8], 1
loc_1234:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_11AF
mov eax, [rbp+var_C]
leave
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+18h] [rbp-8h]
unsigned int v6; // [rsp+1Ch] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) >= 0 )
{
v3 += *(_DWORD *)(4LL * i + a1);
}
else
{
v6 = -*(_DWORD *)(4LL * i + a1);
v5 = i + 1;
v3 += func0(a1 + 4LL * v5, v6);
i = v6 - 1 + v5;
}
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
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 0x00101234
LAB_001011af:
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
JNS 0x00101217
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]
NEG EAX
MOV dword ptr [RBP + -0x4],EAX
ADD dword ptr [RBP + -0x8],0x1
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV ESI,EAX
MOV RDI,RDX
CALL 0x00101189
ADD dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
ADD dword ptr [RBP + -0x8],EAX
JMP 0x00101230
LAB_00101217:
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]
ADD dword ptr [RBP + -0xc],EAX
LAB_00101230:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101234:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011af
MOV EAX,dword ptr [RBP + -0xc]
LEAVE
RET | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
int4 local_14;
int4 local_10;
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) {
iVar1 = -*(int *)(param_1 + (long)local_10 * 4);
iVar2 = func0((long)(local_10 + 1) * 4 + param_1,iVar1);
local_10 = local_10 + 1 + iVar1 + -1;
}
else {
iVar2 = *(int *)(param_1 + (long)local_10 * 4);
}
local_14 = local_14 + iVar2;
}
return local_14;
} |
4,153 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *data_list, int n) {
int total = 0;
for (int i = 0; i < n; i++) {
if (data_list[i] < 0) { // Negative value used as a sentinel for sublists
int sub_length = -data_list[i]; // Length of the sublist
i++;
total += func0(&data_list[i], sub_length);
i += sub_length - 1; // Adjust the index to the end of the sublist
} else {
total += data_list[i];
}
}
return total;
}
| int main() {
int list1[] = {1, 2, -2, 3, 4, -2, 5, 6};
int list2[] = {7, 10, -2, 15, 14, -2, 19, 41};
int list3[] = {10, 20, -2, 30, 40, -2, 50, 60};
assert(func0(list1, 8) == 21);
assert(func0(list2, 8) == 106);
assert(func0(list3, 8) == 210);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov $0x0,%r12d
test %esi,%esi
jle 11e6 <func0+0x5d>
mov %rdi,%r14
mov %esi,%r13d
mov $0x0,%eax
jmp 11b7 <func0+0x2e>
add %ebp,%r12d
add $0x1,%eax
cmp %eax,%r13d
jle 11e6 <func0+0x5d>
movslq %eax,%rdx
lea 0x0(,%rdx,4),%rcx
mov (%r14,%rdx,4),%ebp
test %ebp,%ebp
jns 11ac <func0+0x23>
lea 0x1(%rax),%ebx
mov %ebp,%esi
neg %esi
lea 0x4(%r14,%rcx,1),%rdi
callq 1189 <func0>
add %eax,%r12d
not %ebp
lea 0x0(%rbp,%rbx,1),%eax
jmp 11af <func0+0x26>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12d, 0
test esi, esi
jle short loc_11E6
mov r14, rdi
mov r13d, esi
mov eax, 0
jmp short loc_11CE
loc_11AC:
lea ebx, [rax+1]
mov esi, ebp
neg esi
lea rdi, [r14+rcx+4]
call func0
add r12d, eax
not ebp
lea eax, [rbp+rbx+0]
loc_11C6:
add eax, 1
cmp r13d, eax
jle short loc_11E6
loc_11CE:
movsxd rdx, eax
lea rcx, ds:0[rdx*4]
mov ebp, [r14+rdx*4]
test ebp, ebp
js short loc_11AC
add r12d, ebp
jmp short loc_11C6
loc_11E6:
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, int a2)
{
unsigned int v2; // r12d
int i; // eax
int v4; // ebx
int v5; // ebp
v2 = 0;
if ( a2 > 0 )
{
for ( i = 0; i < a2; ++i )
{
v5 = *(_DWORD *)(a1 + 4LL * i);
if ( v5 < 0 )
{
v4 = i + 1;
v2 += func0(a1 + 4LL * i + 4, (unsigned int)-v5);
i = ~v5 + v4;
}
else
{
v2 += v5;
}
}
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12D,0x0
TEST ESI,ESI
JLE 0x001011e6
MOV R14,RDI
MOV R13D,ESI
MOV EAX,0x0
JMP 0x001011ce
LAB_001011ac:
LEA EBX,[RAX + 0x1]
MOV ESI,EBP
NEG ESI
LEA RDI,[R14 + RCX*0x1 + 0x4]
CALL 0x00101189
ADD R12D,EAX
NOT EBP
LEA EAX,[RBP + RBX*0x1]
LAB_001011c6:
ADD EAX,0x1
CMP R13D,EAX
JLE 0x001011e6
LAB_001011ce:
MOVSXD RDX,EAX
LEA RCX,[RDX*0x4]
MOV EBP,dword ptr [R14 + RDX*0x4]
TEST EBP,EBP
JS 0x001011ac
ADD R12D,EBP
JMP 0x001011c6
LAB_001011e6:
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int func0(long param_1,int param_2)
{
uint uVar1;
uint uVar2;
int iVar3;
int iVar4;
iVar4 = 0;
if (0 < param_2) {
iVar3 = 0;
do {
uVar1 = *(uint *)(param_1 + (long)iVar3 * 4);
if ((int)uVar1 < 0) {
uVar2 = func0(param_1 + 4 + (long)iVar3 * 4,-uVar1);
iVar3 = ~uVar1 + iVar3 + 1;
uVar1 = uVar2;
}
iVar4 = iVar4 + uVar1;
iVar3 = iVar3 + 1;
} while (iVar3 < param_2);
}
return iVar4;
} |
4,154 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *data_list, int n) {
int total = 0;
for (int i = 0; i < n; i++) {
if (data_list[i] < 0) { // Negative value used as a sentinel for sublists
int sub_length = -data_list[i]; // Length of the sublist
i++;
total += func0(&data_list[i], sub_length);
i += sub_length - 1; // Adjust the index to the end of the sublist
} else {
total += data_list[i];
}
}
return total;
}
| int main() {
int list1[] = {1, 2, -2, 3, 4, -2, 5, 6};
int list2[] = {7, 10, -2, 15, 14, -2, 19, 41};
int list3[] = {10, 20, -2, 30, 40, -2, 50, 60};
assert(func0(list1, 8) == 21);
assert(func0(list2, 8) == 106);
assert(func0(list3, 8) == 210);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
test %esi,%esi
jle 1359 <func0+0x39>
mov %rdi,%r14
mov %esi,%r13d
xor %ebx,%ebx
movslq %ebx,%rax
add $0x1,%ebx
mov (%r14,%rax,4),%ebp
lea 0x0(,%rax,4),%rdx
test %ebp,%ebp
js 1368 <func0+0x48>
add %ebp,%r12d
cmp %ebx,%r13d
jg 133b <func0+0x1b>
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl (%rax)
mov %ebp,%esi
lea 0x4(%r14,%rdx,1),%rdi
sub %ebp,%ebx
neg %esi
callq 1320 <func0>
add %eax,%r12d
jmp 1354 <func0+0x34>
nopl (%rax)
| func0:
endbr64
push r14
push r13
push r12
xor r12d, r12d
push rbp
push rbx
test esi, esi
jle short loc_1359
mov r14, rdi
mov r13d, esi
xor eax, eax
loc_133B:
movsxd rdx, eax
mov ebp, [r14+rdx*4]
lea rcx, ds:0[rdx*4]
test ebp, ebp
js short loc_1368
add r12d, ebp
loc_1351:
add eax, 1
cmp r13d, eax
jg short loc_133B
loc_1359:
pop rbx
mov eax, r12d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1368:
mov esi, ebp
lea rdi, [r14+rcx+4]
lea ebx, [rax+1]
not ebp
neg esi
call func0
add r12d, eax
lea eax, [rbp+rbx+0]
jmp short loc_1351 | long long func0(long long a1, int a2)
{
unsigned int v2; // r12d
int i; // eax
int v4; // ebp
int v6; // ebx
v2 = 0;
if ( a2 > 0 )
{
for ( i = 0; i < a2; ++i )
{
v4 = *(_DWORD *)(a1 + 4LL * i);
if ( v4 < 0 )
{
v6 = i + 1;
v2 += func0(a1 + 4LL * i + 4, (unsigned int)-v4);
i = ~v4 + v6;
}
else
{
v2 += v4;
}
}
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x00101359
MOV R14,RDI
MOV R13D,ESI
XOR EAX,EAX
LAB_0010133b:
MOVSXD RDX,EAX
MOV EBP,dword ptr [R14 + RDX*0x4]
LEA RCX,[RDX*0x4]
TEST EBP,EBP
JS 0x00101368
ADD R12D,EBP
LAB_00101351:
ADD EAX,0x1
CMP R13D,EAX
JG 0x0010133b
LAB_00101359:
POP RBX
MOV EAX,R12D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101368:
MOV ESI,EBP
LEA RDI,[R14 + RCX*0x1 + 0x4]
LEA EBX,[RAX + 0x1]
NOT EBP
NEG ESI
CALL 0x00101320
ADD R12D,EAX
LEA EAX,[RBP + RBX*0x1]
JMP 0x00101351 | int func0(long param_1,int param_2)
{
int iVar1;
uint uVar2;
uint uVar3;
int iVar4;
iVar4 = 0;
if (0 < param_2) {
iVar1 = 0;
do {
uVar2 = *(uint *)(param_1 + (long)iVar1 * 4);
if ((int)uVar2 < 0) {
uVar3 = ~uVar2;
uVar2 = func0(param_1 + 4 + (long)iVar1 * 4,-uVar2);
iVar1 = uVar3 + iVar1 + 1;
}
iVar4 = iVar4 + uVar2;
iVar1 = iVar1 + 1;
} while (iVar1 < param_2);
}
return iVar4;
} |
4,155 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int *data_list, int n) {
int total = 0;
for (int i = 0; i < n; i++) {
if (data_list[i] < 0) { // Negative value used as a sentinel for sublists
int sub_length = -data_list[i]; // Length of the sublist
i++;
total += func0(&data_list[i], sub_length);
i += sub_length - 1; // Adjust the index to the end of the sublist
} else {
total += data_list[i];
}
}
return total;
}
| int main() {
int list1[] = {1, 2, -2, 3, 4, -2, 5, 6};
int list2[] = {7, 10, -2, 15, 14, -2, 19, 41};
int list3[] = {10, 20, -2, 30, 40, -2, 50, 60};
assert(func0(list1, 8) == 21);
assert(func0(list2, 8) == 106);
assert(func0(list3, 8) == 210);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
test %esi,%esi
jle 12f9 <func0+0x39>
mov %rdi,%r14
mov %esi,%r13d
xor %ebx,%ebx
movslq %ebx,%rax
add $0x1,%ebx
mov (%r14,%rax,4),%ebp
lea 0x0(,%rax,4),%rdx
test %ebp,%ebp
js 1308 <func0+0x48>
add %ebp,%r12d
cmp %ebx,%r13d
jg 12db <func0+0x1b>
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl (%rax)
mov %ebp,%esi
lea 0x4(%r14,%rdx,1),%rdi
sub %ebp,%ebx
neg %esi
callq 12c0 <func0>
add %eax,%r12d
cmp %ebx,%r13d
jg 12db <func0+0x1b>
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
xor ebx, ebx
sub rsp, 0C8h
test esi, esi
jle short loc_1305
xor r15d, r15d
mov r13, rdi
mov r12d, esi
loc_12E4:
movsxd rax, r15d
mov r14d, [r13+rax*4+0]
lea rdx, ds:0[rax*4]
test r14d, r14d
js short loc_1320
add ebx, r14d
loc_12FC:
add r15d, 1
cmp r12d, r15d
jg short loc_12E4
loc_1305:
add rsp, 0C8h
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1320:
mov r8d, r14d
mov [rsp+0F8h+var_E8], r13
add r15d, 1
xor ebp, ebp
neg r8d
lea rcx, [r13+rdx+4]
mov [rsp+0F8h+var_F0], r14d
xor eax, eax
mov [rsp+0F8h+var_EC], r15d
mov r14, rcx
mov r15d, r8d
mov [rsp+0F8h+var_E0], ebx
mov ebx, r12d
loc_134F:
movsxd rcx, eax
mov r13d, [r14+rcx*4]
lea rsi, ds:0[rcx*4]
test r13d, r13d
js short loc_1398
add ebp, r13d
loc_1366:
add eax, 1
cmp r15d, eax
jg short loc_134F
mov r14d, [rsp+0F8h+var_F0]
mov r15d, [rsp+0F8h+var_EC]
mov r12d, ebx
mov ebx, [rsp+0F8h+var_E0]
mov r13, [rsp+0F8h+var_E8]
mov eax, r14d
not eax
add ebx, ebp
add r15d, eax
jmp loc_12FC
loc_1398:
add eax, 1
mov r8d, r13d
mov [rsp+0F8h+var_D4], r13d
lea rcx, [r14+rsi+4]
mov [rsp+0F8h+var_DC], eax
neg r8d
xor r12d, r12d
xor esi, esi
mov [rsp+0F8h+var_C8], ebp
mov [rsp+0F8h+var_D8], r15d
mov r15d, r8d
mov [rsp+0F8h+var_D0], r14
mov r14, rcx
loc_13C8:
movsxd rcx, esi
mov r13d, [r14+rcx*4]
lea rax, ds:0[rcx*4]
test r13d, r13d
js short loc_1410
add r12d, r13d
loc_13DF:
add esi, 1
cmp esi, r15d
jl short loc_13C8
mov r13d, [rsp+0F8h+var_D4]
mov ebp, [rsp+0F8h+var_C8]
mov edi, [rsp+0F8h+var_DC]
mov r15d, [rsp+0F8h+var_D8]
mov eax, r13d
mov r14, [rsp+0F8h+var_D0]
add ebp, r12d
not eax
add eax, edi
jmp loc_1366
loc_1410:
lea edi, [rsi+1]
mov r8d, r13d
mov [rsp+0F8h+var_C0], r13d
lea rcx, [r14+rax+4]
mov [rsp+0F8h+var_C4], edi
neg r8d
xor ebp, ebp
xor esi, esi
mov [rsp+0F8h+var_BC], r12d
mov [rsp+0F8h+var_B0], r15d
mov r15d, r8d
mov [rsp+0F8h+var_B8], r14
mov r14, rcx
loc_1440:
movsxd rcx, esi
mov r13d, [r14+rcx*4]
lea rax, ds:0[rcx*4]
test r13d, r13d
js short loc_1490
add ebp, r13d
loc_1457:
add esi, 1
cmp esi, r15d
jl short loc_1440
mov r13d, [rsp+0F8h+var_C0]
mov r12d, [rsp+0F8h+var_BC]
mov eax, [rsp+0F8h+var_C4]
mov r15d, [rsp+0F8h+var_B0]
mov esi, r13d
mov r14, [rsp+0F8h+var_B8]
add r12d, ebp
not esi
add esi, eax
jmp loc_13DF
loc_1490:
lea edi, [rsi+1]
mov r8d, r13d
mov [rsp+0F8h+var_A0], r13d
lea rcx, [r14+rax+4]
mov [rsp+0F8h+var_AC], edi
neg r8d
xor r12d, r12d
xor esi, esi
mov [rsp+0F8h+var_9C], ebp
mov [rsp+0F8h+var_A8], r14
mov r14, rcx
mov [rsp+0F8h+var_98], r15d
mov r15d, r8d
loc_14C0:
movsxd rdx, esi
mov r13d, [r14+rdx*4]
lea rax, ds:0[rdx*4]
test r13d, r13d
js short loc_1508
add r12d, r13d
loc_14D7:
add esi, 1
cmp esi, r15d
jl short loc_14C0
mov r13d, [rsp+0F8h+var_A0]
mov ebp, [rsp+0F8h+var_9C]
mov eax, [rsp+0F8h+var_AC]
mov r14, [rsp+0F8h+var_A8]
mov esi, r13d
mov r15d, [rsp+0F8h+var_98]
add ebp, r12d
not esi
add esi, eax
jmp loc_1457
loc_1508:
lea edi, [rsi+1]
mov r8d, r13d
mov [rsp+0F8h+var_88], r13d
lea rdx, [r14+rax+4]
mov [rsp+0F8h+var_94], edi
neg r8d
xor ebp, ebp
xor esi, esi
mov [rsp+0F8h+var_80], r15d
mov [rsp+0F8h+var_90], r14
mov r14d, r8d
mov [rsp+0F8h+var_84], r12d
mov r12, rdx
loc_1538:
movsxd rdx, esi
mov r13d, [r12+rdx*4]
lea rax, ds:0[rdx*4]
test r13d, r13d
js short loc_1580
add ebp, r13d
loc_154F:
add esi, 1
cmp esi, r14d
jl short loc_1538
mov r13d, [rsp+0F8h+var_88]
mov r12d, [rsp+0F8h+var_84]
mov eax, [rsp+0F8h+var_94]
mov r14, [rsp+0F8h+var_90]
mov esi, r13d
mov r15d, [rsp+0F8h+var_80]
add r12d, ebp
not esi
add esi, eax
jmp loc_14D7
loc_1580:
lea edi, [rsi+1]
mov ecx, r13d
mov [rsp+0F8h+var_78], r12
xor esi, esi
mov [rsp+0F8h+var_7C], edi
neg ecx
lea rdx, [r12+rax+4]
xor r15d, r15d
mov [rsp+0F8h+var_68], r14d
mov [rsp+0F8h+var_70], r13d
mov r13, rdx
mov [rsp+0F8h+var_6C], ebp
mov ebp, ecx
loc_15BA:
movsxd rcx, esi
mov r12d, [r13+rcx*4+0]
lea rax, ds:0[rcx*4]
test r12d, r12d
js short loc_1610
add r15d, r12d
loc_15D2:
add esi, 1
cmp esi, ebp
jl short loc_15BA
mov r13d, [rsp+0F8h+var_70]
mov ebp, [rsp+0F8h+var_6C]
mov eax, [rsp+0F8h+var_7C]
mov r12, [rsp+0F8h+var_78]
mov esi, r13d
mov r14d, [rsp+0F8h+var_68]
add ebp, r15d
not esi
add esi, eax
jmp loc_154F
loc_1610:
lea edi, [rsi+1]
lea r8, [r13+rax+4]
mov ecx, r12d
xor r14d, r14d
mov [rsp+0F8h+var_64], edi
neg ecx
xor esi, esi
mov edx, r12d
mov [rsp+0F8h+var_60], r13
mov r9d, ebp
mov r13, r8
mov r11d, r14d
mov r8d, r15d
mov r10d, ebx
loc_1643:
movsxd rdi, esi
mov ebx, [r13+rdi*4+0]
lea rax, ds:0[rdi*4]
test ebx, ebx
js short loc_1690
add r11d, ebx
loc_165A:
add esi, 1
cmp ecx, esi
jg short loc_1643
mov eax, [rsp+0F8h+var_64]
mov esi, edx
mov r15d, r8d
mov ebp, r9d
not esi
mov r13, [rsp+0F8h+var_60]
mov ebx, r10d
add r15d, r11d
add esi, eax
jmp loc_15D2
loc_1690:
lea edi, [rsi+1]
mov r15d, ebx
lea r14, [r13+rax+4]
xor r12d, r12d
mov [rsp+0F8h+var_58], edi
neg r15d
xor esi, esi
loc_16AA:
movsxd rax, esi
mov ebp, [r14+rax*4]
lea rdi, ds:0[rax*4]
test ebp, ebp
js short loc_16E0
add esi, 1
add r12d, ebp
cmp r15d, esi
jg short loc_16AA
loc_16C8:
mov eax, [rsp+0F8h+var_58]
not ebx
add r11d, r12d
mov esi, ebx
add esi, eax
jmp short loc_165A
loc_16E0:
mov [rsp+0F8h+var_4C], edx
mov edx, ebp
lea eax, [rsi+1]
lea rdi, [r14+rdi+4]
neg edx
mov [rsp+0F8h+var_3C], r10d
mov esi, edx
mov [rsp+0F8h+var_40], r11d
mov [rsp+0F8h+var_44], r9d
mov [rsp+0F8h+var_48], r8d
mov [rsp+0F8h+var_50], ecx
mov [rsp+0F8h+var_54], eax
call func0
mov esi, [rsp+0F8h+var_54]
mov ecx, [rsp+0F8h+var_50]
add r12d, eax
mov edx, [rsp+0F8h+var_4C]
mov r8d, [rsp+0F8h+var_48]
sub esi, ebp
mov r9d, [rsp+0F8h+var_44]
mov r11d, [rsp+0F8h+var_40]
cmp r15d, esi
mov r10d, [rsp+0F8h+var_3C]
jg loc_16AA
jmp loc_16C8 | long long func0(long long a1, int a2)
{
unsigned int v2; // ebx
int v3; // r15d
int v5; // r12d
int v6; // r14d
int v8; // ebp
int v9; // r8d
int v10; // eax
long long v11; // r14
int v12; // r15d
int v13; // ebx
int v14; // r13d
int v15; // r12d
int v16; // esi
int v17; // r15d
long long v18; // r14
int v19; // r13d
long long v20; // rax
int v21; // ebp
int v22; // esi
int v23; // r15d
long long v24; // r14
int v25; // r13d
long long v26; // rax
int v27; // r12d
int v28; // esi
long long v29; // r14
int v30; // r15d
int v31; // r13d
long long v32; // rdx
int v33; // ebp
int v34; // esi
int v35; // r14d
long long v36; // r12
int v37; // r13d
long long v38; // rax
int v39; // edi
int v40; // esi
int v41; // ecx
int v42; // r15d
long long v43; // r13
int v44; // ebp
int v45; // r12d
long long v46; // rax
int v47; // ecx
int v48; // esi
int v49; // edx
int v50; // r9d
long long v51; // r13
int v52; // r11d
int v53; // r8d
int v54; // r10d
int v55; // ebx
long long v56; // r14
int v57; // r12d
int v58; // r15d
int v59; // esi
int v60; // ebp
int v61; // eax
int v62; // [rsp+8h] [rbp-F0h]
int v63; // [rsp+Ch] [rbp-ECh]
long long v64; // [rsp+10h] [rbp-E8h]
unsigned int v65; // [rsp+18h] [rbp-E0h]
int v66; // [rsp+1Ch] [rbp-DCh]
int v67; // [rsp+20h] [rbp-D8h]
int v68; // [rsp+24h] [rbp-D4h]
long long v69; // [rsp+28h] [rbp-D0h]
int v70; // [rsp+30h] [rbp-C8h]
int v71; // [rsp+34h] [rbp-C4h]
int v72; // [rsp+38h] [rbp-C0h]
int v73; // [rsp+3Ch] [rbp-BCh]
long long v74; // [rsp+40h] [rbp-B8h]
int v75; // [rsp+48h] [rbp-B0h]
int v76; // [rsp+4Ch] [rbp-ACh]
long long v77; // [rsp+50h] [rbp-A8h]
int v78; // [rsp+58h] [rbp-A0h]
int v79; // [rsp+5Ch] [rbp-9Ch]
int v80; // [rsp+60h] [rbp-98h]
int v81; // [rsp+64h] [rbp-94h]
long long v82; // [rsp+68h] [rbp-90h]
int v83; // [rsp+70h] [rbp-88h]
int v84; // [rsp+74h] [rbp-84h]
int v85; // [rsp+78h] [rbp-80h]
long long v86; // [rsp+80h] [rbp-78h]
int v87; // [rsp+88h] [rbp-70h]
int v88; // [rsp+8Ch] [rbp-6Ch]
int v89; // [rsp+90h] [rbp-68h]
int v90; // [rsp+94h] [rbp-64h]
long long v91; // [rsp+98h] [rbp-60h]
int v92; // [rsp+A0h] [rbp-58h]
int v93; // [rsp+A8h] [rbp-50h]
int v94; // [rsp+ACh] [rbp-4Ch]
int v95; // [rsp+B0h] [rbp-48h]
int v96; // [rsp+B4h] [rbp-44h]
int v97; // [rsp+B8h] [rbp-40h]
int v98; // [rsp+BCh] [rbp-3Ch]
v2 = 0;
if ( a2 > 0 )
{
v3 = 0;
v5 = a2;
do
{
v6 = *(_DWORD *)(a1 + 4LL * v3);
if ( v6 < 0 )
{
v64 = a1;
v8 = 0;
v9 = -v6;
v62 = *(_DWORD *)(a1 + 4LL * v3);
v10 = 0;
v63 = v3 + 1;
v11 = a1 + 4LL * v3 + 4;
v12 = v9;
v65 = v2;
v13 = v5;
do
{
v14 = *(_DWORD *)(v11 + 4LL * v10);
if ( v14 < 0 )
{
v68 = *(_DWORD *)(v11 + 4LL * v10);
v66 = v10 + 1;
v15 = 0;
v16 = 0;
v70 = v8;
v67 = v12;
v17 = -v14;
v69 = v11;
v18 = v11 + 4LL * v10 + 4;
do
{
v19 = *(_DWORD *)(v18 + 4LL * v16);
v20 = 4LL * v16;
if ( v19 < 0 )
{
v72 = *(_DWORD *)(v18 + 4LL * v16);
v71 = v16 + 1;
v21 = 0;
v22 = 0;
v73 = v15;
v75 = v17;
v23 = -v19;
v74 = v18;
v24 = v18 + v20 + 4;
do
{
v25 = *(_DWORD *)(v24 + 4LL * v22);
v26 = 4LL * v22;
if ( v25 < 0 )
{
v78 = *(_DWORD *)(v24 + 4LL * v22);
v76 = v22 + 1;
v27 = 0;
v28 = 0;
v79 = v21;
v77 = v24;
v29 = v24 + v26 + 4;
v80 = v23;
v30 = -v25;
do
{
v31 = *(_DWORD *)(v29 + 4LL * v28);
if ( v31 < 0 )
{
v83 = *(_DWORD *)(v29 + 4LL * v28);
v32 = v29 + 4LL * v28 + 4;
v81 = v28 + 1;
v33 = 0;
v34 = 0;
v85 = v30;
v82 = v29;
v35 = -v31;
v84 = v27;
v36 = v32;
do
{
v37 = *(_DWORD *)(v36 + 4LL * v34);
v38 = 4LL * v34;
if ( v37 < 0 )
{
v39 = v34 + 1;
v86 = v36;
v40 = 0;
v41 = -v37;
v42 = 0;
v89 = v35;
v87 = v37;
v43 = v36 + v38 + 4;
v88 = v33;
v44 = v41;
do
{
v45 = *(_DWORD *)(v43 + 4LL * v40);
v46 = 4LL * v40;
if ( v45 < 0 )
{
v90 = v40 + 1;
v47 = -v45;
v48 = 0;
v49 = v45;
v91 = v43;
v50 = v44;
v51 = v43 + v46 + 4;
v52 = 0;
v53 = v42;
v54 = v13;
do
{
v55 = *(_DWORD *)(v51 + 4LL * v48);
if ( v55 < 0 )
{
v56 = v51 + 4LL * v48 + 4;
v57 = 0;
v92 = v48 + 1;
v58 = -v55;
v59 = 0;
do
{
while ( 1 )
{
v60 = *(_DWORD *)(v56 + 4LL * v59);
if ( v60 < 0 )
break;
++v59;
v57 += v60;
if ( v58 <= v59 )
goto LABEL_45;
}
v94 = v49;
v98 = v54;
v97 = v52;
v96 = v50;
v95 = v53;
v93 = v47;
v61 = func0(v56 + 4LL * v59 + 4, (unsigned int)-v60);
v47 = v93;
v57 += v61;
v49 = v94;
v53 = v95;
v59 = v59 + 1 - v60;
v50 = v96;
v52 = v97;
v54 = v98;
}
while ( v58 > v59 );
LABEL_45:
v52 += v57;
v48 = v92 + ~v55;
}
else
{
v52 += v55;
}
++v48;
}
while ( v47 > v48 );
v44 = v50;
v43 = v91;
v13 = v54;
v42 = v52 + v53;
v40 = v90 + ~v49;
}
else
{
v42 += v45;
}
++v40;
}
while ( v40 < v44 );
v36 = v86;
v35 = v89;
v33 = v42 + v88;
v34 = v39 + ~v87;
}
else
{
v33 += v37;
}
++v34;
}
while ( v34 < v35 );
v29 = v82;
v30 = v85;
v27 = v33 + v84;
v28 = v81 + ~v83;
}
else
{
v27 += v31;
}
++v28;
}
while ( v28 < v30 );
v24 = v77;
v23 = v80;
v21 = v27 + v79;
v22 = v76 + ~v78;
}
else
{
v21 += v25;
}
++v22;
}
while ( v22 < v23 );
v17 = v75;
v18 = v74;
v15 = v21 + v73;
v16 = v71 + ~v72;
}
else
{
v15 += v19;
}
++v16;
}
while ( v16 < v17 );
v12 = v67;
v11 = v69;
v8 = v15 + v70;
v10 = v66 + ~v68;
}
else
{
v8 += v14;
}
++v10;
}
while ( v12 > v10 );
v5 = v13;
a1 = v64;
v2 = v8 + v65;
v3 = ~v62 + v63;
}
else
{
v2 += v6;
}
++v3;
}
while ( v5 > v3 );
}
return v2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
XOR EBX,EBX
SUB RSP,0xc8
TEST ESI,ESI
JLE 0x00101305
XOR R15D,R15D
MOV R13,RDI
MOV R12D,ESI
LAB_001012e4:
MOVSXD RAX,R15D
MOV R14D,dword ptr [R13 + RAX*0x4]
LEA RDX,[RAX*0x4]
TEST R14D,R14D
JS 0x00101320
ADD EBX,R14D
LAB_001012fc:
ADD R15D,0x1
CMP R12D,R15D
JG 0x001012e4
LAB_00101305:
ADD RSP,0xc8
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101320:
MOV R8D,R14D
MOV qword ptr [RSP + 0x10],R13
ADD R15D,0x1
XOR EBP,EBP
NEG R8D
LEA RCX,[R13 + RDX*0x1 + 0x4]
MOV dword ptr [RSP + 0x8],R14D
XOR EAX,EAX
MOV dword ptr [RSP + 0xc],R15D
MOV R14,RCX
MOV R15D,R8D
MOV dword ptr [RSP + 0x18],EBX
MOV EBX,R12D
LAB_0010134f:
MOVSXD RCX,EAX
MOV R13D,dword ptr [R14 + RCX*0x4]
LEA RSI,[RCX*0x4]
TEST R13D,R13D
JS 0x00101398
ADD EBP,R13D
LAB_00101366:
ADD EAX,0x1
CMP R15D,EAX
JG 0x0010134f
MOV R14D,dword ptr [RSP + 0x8]
MOV R15D,dword ptr [RSP + 0xc]
MOV R12D,EBX
MOV EBX,dword ptr [RSP + 0x18]
MOV R13,qword ptr [RSP + 0x10]
MOV EAX,R14D
NOT EAX
ADD EBX,EBP
ADD R15D,EAX
JMP 0x001012fc
LAB_00101398:
ADD EAX,0x1
MOV R8D,R13D
MOV dword ptr [RSP + 0x24],R13D
LEA RCX,[R14 + RSI*0x1 + 0x4]
MOV dword ptr [RSP + 0x1c],EAX
NEG R8D
XOR R12D,R12D
XOR ESI,ESI
MOV dword ptr [RSP + 0x30],EBP
MOV dword ptr [RSP + 0x20],R15D
MOV R15D,R8D
MOV qword ptr [RSP + 0x28],R14
MOV R14,RCX
LAB_001013c8:
MOVSXD RCX,ESI
MOV R13D,dword ptr [R14 + RCX*0x4]
LEA RAX,[RCX*0x4]
TEST R13D,R13D
JS 0x00101410
ADD R12D,R13D
LAB_001013df:
ADD ESI,0x1
CMP ESI,R15D
JL 0x001013c8
MOV R13D,dword ptr [RSP + 0x24]
MOV EBP,dword ptr [RSP + 0x30]
MOV EDI,dword ptr [RSP + 0x1c]
MOV R15D,dword ptr [RSP + 0x20]
MOV EAX,R13D
MOV R14,qword ptr [RSP + 0x28]
ADD EBP,R12D
NOT EAX
ADD EAX,EDI
JMP 0x00101366
LAB_00101410:
LEA EDI,[RSI + 0x1]
MOV R8D,R13D
MOV dword ptr [RSP + 0x38],R13D
LEA RCX,[R14 + RAX*0x1 + 0x4]
MOV dword ptr [RSP + 0x34],EDI
NEG R8D
XOR EBP,EBP
XOR ESI,ESI
MOV dword ptr [RSP + 0x3c],R12D
MOV dword ptr [RSP + 0x48],R15D
MOV R15D,R8D
MOV qword ptr [RSP + 0x40],R14
MOV R14,RCX
LAB_00101440:
MOVSXD RCX,ESI
MOV R13D,dword ptr [R14 + RCX*0x4]
LEA RAX,[RCX*0x4]
TEST R13D,R13D
JS 0x00101490
ADD EBP,R13D
LAB_00101457:
ADD ESI,0x1
CMP ESI,R15D
JL 0x00101440
MOV R13D,dword ptr [RSP + 0x38]
MOV R12D,dword ptr [RSP + 0x3c]
MOV EAX,dword ptr [RSP + 0x34]
MOV R15D,dword ptr [RSP + 0x48]
MOV ESI,R13D
MOV R14,qword ptr [RSP + 0x40]
ADD R12D,EBP
NOT ESI
ADD ESI,EAX
JMP 0x001013df
LAB_00101490:
LEA EDI,[RSI + 0x1]
MOV R8D,R13D
MOV dword ptr [RSP + 0x58],R13D
LEA RCX,[R14 + RAX*0x1 + 0x4]
MOV dword ptr [RSP + 0x4c],EDI
NEG R8D
XOR R12D,R12D
XOR ESI,ESI
MOV dword ptr [RSP + 0x5c],EBP
MOV qword ptr [RSP + 0x50],R14
MOV R14,RCX
MOV dword ptr [RSP + 0x60],R15D
MOV R15D,R8D
LAB_001014c0:
MOVSXD RDX,ESI
MOV R13D,dword ptr [R14 + RDX*0x4]
LEA RAX,[RDX*0x4]
TEST R13D,R13D
JS 0x00101508
ADD R12D,R13D
LAB_001014d7:
ADD ESI,0x1
CMP ESI,R15D
JL 0x001014c0
MOV R13D,dword ptr [RSP + 0x58]
MOV EBP,dword ptr [RSP + 0x5c]
MOV EAX,dword ptr [RSP + 0x4c]
MOV R14,qword ptr [RSP + 0x50]
MOV ESI,R13D
MOV R15D,dword ptr [RSP + 0x60]
ADD EBP,R12D
NOT ESI
ADD ESI,EAX
JMP 0x00101457
LAB_00101508:
LEA EDI,[RSI + 0x1]
MOV R8D,R13D
MOV dword ptr [RSP + 0x70],R13D
LEA RDX,[R14 + RAX*0x1 + 0x4]
MOV dword ptr [RSP + 0x64],EDI
NEG R8D
XOR EBP,EBP
XOR ESI,ESI
MOV dword ptr [RSP + 0x78],R15D
MOV qword ptr [RSP + 0x68],R14
MOV R14D,R8D
MOV dword ptr [RSP + 0x74],R12D
MOV R12,RDX
LAB_00101538:
MOVSXD RDX,ESI
MOV R13D,dword ptr [R12 + RDX*0x4]
LEA RAX,[RDX*0x4]
TEST R13D,R13D
JS 0x00101580
ADD EBP,R13D
LAB_0010154f:
ADD ESI,0x1
CMP ESI,R14D
JL 0x00101538
MOV R13D,dword ptr [RSP + 0x70]
MOV R12D,dword ptr [RSP + 0x74]
MOV EAX,dword ptr [RSP + 0x64]
MOV R14,qword ptr [RSP + 0x68]
MOV ESI,R13D
MOV R15D,dword ptr [RSP + 0x78]
ADD R12D,EBP
NOT ESI
ADD ESI,EAX
JMP 0x001014d7
LAB_00101580:
LEA EDI,[RSI + 0x1]
MOV ECX,R13D
MOV qword ptr [RSP + 0x80],R12
XOR ESI,ESI
MOV dword ptr [RSP + 0x7c],EDI
NEG ECX
LEA RDX,[R12 + RAX*0x1 + 0x4]
XOR R15D,R15D
MOV dword ptr [RSP + 0x90],R14D
MOV dword ptr [RSP + 0x88],R13D
MOV R13,RDX
MOV dword ptr [RSP + 0x8c],EBP
MOV EBP,ECX
LAB_001015ba:
MOVSXD RCX,ESI
MOV R12D,dword ptr [R13 + RCX*0x4]
LEA RAX,[RCX*0x4]
TEST R12D,R12D
JS 0x00101610
ADD R15D,R12D
LAB_001015d2:
ADD ESI,0x1
CMP ESI,EBP
JL 0x001015ba
MOV R13D,dword ptr [RSP + 0x88]
MOV EBP,dword ptr [RSP + 0x8c]
MOV EAX,dword ptr [RSP + 0x7c]
MOV R12,qword ptr [RSP + 0x80]
MOV ESI,R13D
MOV R14D,dword ptr [RSP + 0x90]
ADD EBP,R15D
NOT ESI
ADD ESI,EAX
JMP 0x0010154f
LAB_00101610:
LEA EDI,[RSI + 0x1]
LEA R8,[R13 + RAX*0x1 + 0x4]
MOV ECX,R12D
XOR R14D,R14D
MOV dword ptr [RSP + 0x94],EDI
NEG ECX
XOR ESI,ESI
MOV EDX,R12D
MOV qword ptr [RSP + 0x98],R13
MOV R9D,EBP
MOV R13,R8
MOV R11D,R14D
MOV R8D,R15D
MOV R10D,EBX
LAB_00101643:
MOVSXD RDI,ESI
MOV EBX,dword ptr [R13 + RDI*0x4]
LEA RAX,[RDI*0x4]
TEST EBX,EBX
JS 0x00101690
ADD R11D,EBX
LAB_0010165a:
ADD ESI,0x1
CMP ECX,ESI
JG 0x00101643
MOV EAX,dword ptr [RSP + 0x94]
MOV ESI,EDX
MOV R15D,R8D
MOV EBP,R9D
NOT ESI
MOV R13,qword ptr [RSP + 0x98]
MOV EBX,R10D
ADD R15D,R11D
ADD ESI,EAX
JMP 0x001015d2
LAB_00101690:
LEA EDI,[RSI + 0x1]
MOV R15D,EBX
LEA R14,[R13 + RAX*0x1 + 0x4]
XOR R12D,R12D
MOV dword ptr [RSP + 0xa0],EDI
NEG R15D
XOR ESI,ESI
LAB_001016aa:
MOVSXD RAX,ESI
MOV EBP,dword ptr [R14 + RAX*0x4]
LEA RDI,[RAX*0x4]
TEST EBP,EBP
JS 0x001016e0
ADD ESI,0x1
ADD R12D,EBP
CMP R15D,ESI
JG 0x001016aa
LAB_001016c8:
MOV EAX,dword ptr [RSP + 0xa0]
NOT EBX
ADD R11D,R12D
MOV ESI,EBX
ADD ESI,EAX
JMP 0x0010165a
LAB_001016e0:
MOV dword ptr [RSP + 0xac],EDX
MOV EDX,EBP
LEA EAX,[RSI + 0x1]
LEA RDI,[R14 + RDI*0x1 + 0x4]
NEG EDX
MOV dword ptr [RSP + 0xbc],R10D
MOV ESI,EDX
MOV dword ptr [RSP + 0xb8],R11D
MOV dword ptr [RSP + 0xb4],R9D
MOV dword ptr [RSP + 0xb0],R8D
MOV dword ptr [RSP + 0xa8],ECX
MOV dword ptr [RSP + 0xa4],EAX
CALL 0x001012c0
MOV ESI,dword ptr [RSP + 0xa4]
MOV ECX,dword ptr [RSP + 0xa8]
ADD R12D,EAX
MOV EDX,dword ptr [RSP + 0xac]
MOV R8D,dword ptr [RSP + 0xb0]
SUB ESI,EBP
MOV R9D,dword ptr [RSP + 0xb4]
MOV R11D,dword ptr [RSP + 0xb8]
CMP R15D,ESI
MOV R10D,dword ptr [RSP + 0xbc]
JG 0x001016aa
JMP 0x001016c8 | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
uint uVar21;
uint uVar22;
uint uVar23;
int iVar24;
int iVar25;
int iVar26;
int iVar27;
int iVar28;
int iVar29;
int iVar30;
uint uVar31;
uint uVar32;
uint uVar33;
uint uVar34;
int iVar35;
uint uVar36;
iVar20 = 0;
if (0 < param_2) {
iVar35 = 0;
do {
uVar9 = *(uint *)(param_1 + (long)iVar35 * 4);
if ((int)uVar9 < 0) {
uVar21 = 0;
lVar1 = param_1 + 4 + (long)iVar35 * 4;
iVar18 = 0;
do {
uVar10 = *(uint *)(lVar1 + (long)iVar18 * 4);
if ((int)uVar10 < 0) {
lVar2 = lVar1 + 4 + (long)iVar18 * 4;
uVar32 = 0;
iVar24 = 0;
do {
uVar11 = *(uint *)(lVar2 + (long)iVar24 * 4);
if ((int)uVar11 < 0) {
lVar3 = lVar2 + 4 + (long)iVar24 * 4;
uVar22 = 0;
iVar25 = 0;
do {
uVar12 = *(uint *)(lVar3 + (long)iVar25 * 4);
if ((int)uVar12 < 0) {
lVar4 = lVar3 + 4 + (long)iVar25 * 4;
uVar33 = 0;
iVar26 = 0;
do {
uVar13 = *(uint *)(lVar4 + (long)iVar26 * 4);
if ((int)uVar13 < 0) {
lVar5 = lVar4 + 4 + (long)iVar26 * 4;
uVar23 = 0;
iVar27 = 0;
do {
uVar14 = *(uint *)(lVar5 + (long)iVar27 * 4);
if ((int)uVar14 < 0) {
iVar28 = 0;
lVar6 = lVar5 + 4 + (long)iVar27 * 4;
uVar36 = 0;
do {
uVar15 = *(uint *)(lVar6 + (long)iVar28 * 4);
if ((int)uVar15 < 0) {
lVar7 = lVar6 + 4 + (long)iVar28 * 4;
uVar31 = 0;
iVar29 = 0;
do {
uVar16 = *(uint *)(lVar7 + (long)iVar29 * 4);
if ((int)uVar16 < 0) {
lVar8 = lVar7 + 4 + (long)iVar29 * 4;
uVar34 = 0;
iVar30 = 0;
do {
while( true ) {
iVar17 = *(int *)(lVar8 + (long)iVar30 * 4);
if (iVar17 < 0) break;
iVar30 = iVar30 + 1;
uVar34 = uVar34 + iVar17;
if ((int)-uVar16 <= iVar30) goto LAB_001016c8;
}
iVar19 = func0(lVar8 + 4 + (long)iVar30 * 4,-iVar17);
uVar34 = uVar34 + iVar19;
iVar30 = (iVar30 + 1) - iVar17;
} while (iVar30 < (int)-uVar16);
LAB_001016c8:
iVar29 = ~uVar16 + iVar29 + 1;
uVar16 = uVar34;
}
uVar31 = uVar31 + uVar16;
iVar29 = iVar29 + 1;
} while (iVar29 < (int)-uVar15);
iVar28 = ~uVar15 + iVar28 + 1;
uVar15 = uVar31;
}
uVar36 = uVar36 + uVar15;
iVar28 = iVar28 + 1;
} while (iVar28 < (int)-uVar14);
iVar27 = ~uVar14 + iVar27 + 1;
uVar14 = uVar36;
}
uVar23 = uVar23 + uVar14;
iVar27 = iVar27 + 1;
} while (iVar27 < (int)-uVar13);
iVar26 = ~uVar13 + iVar26 + 1;
uVar13 = uVar23;
}
uVar33 = uVar33 + uVar13;
iVar26 = iVar26 + 1;
} while (iVar26 < (int)-uVar12);
iVar25 = ~uVar12 + iVar25 + 1;
uVar12 = uVar33;
}
uVar22 = uVar22 + uVar12;
iVar25 = iVar25 + 1;
} while (iVar25 < (int)-uVar11);
iVar24 = ~uVar11 + iVar24 + 1;
uVar11 = uVar22;
}
uVar32 = uVar32 + uVar11;
iVar24 = iVar24 + 1;
} while (iVar24 < (int)-uVar10);
iVar18 = ~uVar10 + iVar18 + 1;
uVar10 = uVar32;
}
uVar21 = uVar21 + uVar10;
iVar18 = iVar18 + 1;
} while (iVar18 < (int)-uVar9);
iVar35 = iVar35 + 1 + ~uVar9;
uVar9 = uVar21;
}
iVar20 = iVar20 + uVar9;
iVar35 = iVar35 + 1;
} while (iVar35 < param_2);
}
return iVar20;
} |
4,156 | func0 |
#include <assert.h>
| int func0(int* list, int list_size) {
int pos_count = 0;
for (int i = 0; i < list_size; i++) {
if (list[i] >= 0) {
pos_count++;
}
}
return pos_count;
}
| int main() {
int list1[] = {1, -2, 3, -4};
int list2[] = {3, 4, 5, -1};
int list3[] = {1, 2, 3, 4};
assert(func0(list1, 4) == 2);
assert(func0(list2, 4) == 3);
assert(func0(list3, 4) == 4);
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 11aa <func0+0x41>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
js 11a6 <func0+0x3d>
addl $0x1,-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_11AA
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
js short loc_11A6
add [rbp+var_8], 1
loc_11A6:
add [rbp+var_4], 1
loc_11AA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) >= 0 )
++v3;
}
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 0x001011aa
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JS 0x001011a6
ADD dword ptr [RBP + -0x8],0x1
LAB_001011a6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011aa:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (-1 < *(int *)(param_1 + (long)local_c * 4)) {
local_10 = local_10 + 1;
}
}
return local_10;
} |
4,157 | func0 |
#include <assert.h>
| int func0(int* list, int list_size) {
int pos_count = 0;
for (int i = 0; i < list_size; i++) {
if (list[i] >= 0) {
pos_count++;
}
}
return pos_count;
}
| int main() {
int list1[] = {1, -2, 3, -4};
int list2[] = {3, 4, 5, -1};
int list3[] = {1, 2, 3, 4};
assert(func0(list1, 4) == 2);
assert(func0(list2, 4) == 3);
assert(func0(list3, 4) == 4);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1196 <func0+0x2d>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
cmpl $0x80000000,(%rax)
adc $0x0,%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1193 <func0+0x2a>
| func0:
endbr64
test esi, esi
jle short loc_1196
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
cmp dword ptr [rax], 80000000h
adc edx, 0
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_1193:
mov eax, edx
retn
loc_1196:
mov edx, 0
jmp short loc_1193 | 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++ < 0x80000000;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101196
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
CMP dword ptr [RAX],0x80000000
ADC EDX,0x0
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_00101193:
MOV EAX,EDX
RET
LAB_00101196:
MOV EDX,0x0
JMP 0x00101193 | int func0(uint *param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 < 0x80000000);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar2;
} |
4,158 | func0 |
#include <assert.h>
| int func0(int* list, int list_size) {
int pos_count = 0;
for (int i = 0; i < list_size; i++) {
if (list[i] >= 0) {
pos_count++;
}
}
return pos_count;
}
| int main() {
int list1[] = {1, -2, 3, -4};
int list2[] = {3, 4, 5, -1};
int list3[] = {1, 2, 3, 4};
assert(func0(list1, 4) == 2);
assert(func0(list2, 4) == 3);
assert(func0(list3, 4) == 4);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
cmpl $0x80000000,(%rdi)
adc $0x0,%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1320
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1308:
cmp dword ptr [rdi], 80000000h
adc eax, 0
add rdi, 4
cmp rdi, rdx
jnz short loc_1308
retn
loc_1320:
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 = (*a1++ < 0x80000000) + (unsigned int)result;
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101320
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101308:
CMP dword ptr [RDI],0x80000000
ADC EAX,0x0
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101308
RET
LAB_00101320:
XOR EAX,EAX
RET | int func0(uint *param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 < 0x80000000);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return iVar2;
}
return 0;
} |
4,159 | func0 |
#include <assert.h>
| int func0(int* list, int list_size) {
int pos_count = 0;
for (int i = 0; i < list_size; i++) {
if (list[i] >= 0) {
pos_count++;
}
}
return pos_count;
}
| int main() {
int list1[] = {1, -2, 3, -4};
int list2[] = {3, 4, 5, -1};
int list3[] = {1, 2, 3, 4};
assert(func0(list1, 4) == 2);
assert(func0(list2, 4) == 3);
assert(func0(list3, 4) == 4);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1210 <func0+0xd0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1219 <func0+0xd9>
mov %esi,%edx
pxor %xmm0,%xmm0
pcmpeqd %xmm2,%xmm2
mov %rdi,%rax
shr $0x2,%edx
movdqa %xmm0,%xmm3
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm4
movdqa %xmm3,%xmm1
add $0x10,%rax
pcmpgtd %xmm4,%xmm1
pandn %xmm2,%xmm1
psubd %xmm1,%xmm0
cmp %rdx,%rax
jne 1178 <func0+0x38>
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 1218 <func0+0xd8>
movslq %edx,%rcx
cmpl $0x80000000,(%rdi,%rcx,4)
lea 0x1(%rdx),%ecx
adc $0x0,%eax
cmp %esi,%ecx
jge 1212 <func0+0xd2>
movslq %ecx,%rcx
cmpl $0x80000000,(%rdi,%rcx,4)
lea 0x2(%rdx),%ecx
adc $0x0,%eax
cmp %ecx,%esi
jle 1212 <func0+0xd2>
movslq %ecx,%rcx
cmpl $0x80000000,(%rdi,%rcx,4)
adc $0x0,%eax
add $0x3,%edx
cmp %edx,%esi
jle 1212 <func0+0xd2>
movslq %edx,%rdx
cmpl $0x80000000,(%rdi,%rdx,4)
adc $0x0,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 11be <func0+0x7e>
| func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11F8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1201
mov edx, esi
pxor xmm0, xmm0
pcmpeqd xmm2, xmm2
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_1178:
movdqu xmm1, xmmword ptr [rax]
add rax, 10h
pcmpgtd xmm1, xmm2
psubd xmm0, xmm1
cmp rdx, rax
jnz short loc_1178
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_1200
loc_11B6:
movsxd rdi, edx
cmp dword ptr [rcx+rdi*4], 80000000h
lea r8, ds:0[rdi*4]
lea edi, [rdx+1]
adc eax, 0
cmp esi, edi
jle short locret_11FA
cmp dword ptr [rcx+r8+4], 80000000h
adc eax, 0
add edx, 2
cmp esi, edx
jle short locret_11FA
cmp dword ptr [rcx+r8+8], 80000000h
adc eax, 0
retn
loc_11F8:
xor eax, eax
locret_11FA:
retn
locret_1200:
retn
loc_1201:
xor edx, edx
xor eax, eax
jmp short loc_11B6 | long long func0(const __m128i *a1, int a2)
{
__m128i v2; // xmm0
const __m128i *v3; // rax
__m128i v4; // xmm1
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 = 0LL;
v3 = a1;
do
{
v4 = _mm_loadu_si128(v3++);
v2 = _mm_sub_epi32(v2, _mm_cmpgt_epi32(v4, (__m128i)-1LL));
}
while ( &a1[(unsigned int)a2 >> 2] != v3 );
v5 = a2 & 0x7FFFFFFC;
v6 = _mm_add_epi32(v2, _mm_srli_si128(v2, 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 = (a1->m128i_i32[v8] < 0x80000000) + (unsigned int)result;
if ( a2 > v5 + 1 )
{
result = (a1->m128i_i32[v8 + 1] < 0x80000000) + (unsigned int)result;
if ( a2 > v5 + 2 )
return (a1->m128i_i32[v8 + 2] < 0x80000000) + (unsigned int)result;
}
return result;
} | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011f8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101201
MOV EDX,ESI
PXOR XMM0,XMM0
PCMPEQD XMM2,XMM2
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101178:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPGTD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RDX,RAX
JNZ 0x00101178
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 0x00101200
LAB_001011b6:
MOVSXD RDI,EDX
CMP dword ptr [RCX + RDI*0x4],0x80000000
LEA R8,[RDI*0x4]
LEA EDI,[RDX + 0x1]
ADC EAX,0x0
CMP ESI,EDI
JLE 0x001011fa
CMP dword ptr [RCX + R8*0x1 + 0x4],0x80000000
ADC EAX,0x0
ADD EDX,0x2
CMP ESI,EDX
JLE 0x001011fa
CMP dword ptr [RCX + R8*0x1 + 0x8],0x80000000
ADC EAX,0x0
RET
LAB_001011f8:
XOR EAX,EAX
LAB_001011fa:
RET
LAB_00101200:
RET
LAB_00101201:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011b6 | 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 + (uint)(-1 < iVar1);
iVar8 = iVar8 + (uint)(-1 < *piVar2);
iVar9 = iVar9 + (uint)(-1 < *piVar3);
iVar10 = iVar10 + (uint)(-1 < *piVar4);
} while (param_1 + (ulong)(param_2 >> 2) * 4 != piVar5);
uVar6 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) == 0) {
return iVar7;
}
}
iVar7 = iVar7 + (uint)((uint)param_1[(int)uVar6] < 0x80000000);
if ((int)(uVar6 + 1) < (int)param_2) {
iVar7 = iVar7 + (uint)((uint)param_1[(long)(int)uVar6 + 1] < 0x80000000);
if ((int)(uVar6 + 2) < (int)param_2) {
return iVar7 + (uint)((uint)param_1[(long)(int)uVar6 + 2] < 0x80000000);
}
}
}
return iVar7;
} |
4,160 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| unsigned long long func0(int n) {
unsigned long long** bell = malloc((n + 1) * sizeof(unsigned long long*));
for(int i = 0; i <= n; i++) {
bell[i] = malloc((n + 1) * sizeof(unsigned long long));
for(int j = 0; j <= n; j++) {
bell[i][j] = 0;
}
}
bell[0][0] = 1;
for(int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for(int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
unsigned long long result = bell[n][0];
for(int i = 0; i <= n; i++) {
free(bell[i]);
}
free(bell);
return result;
}
| int main() {
assert(func0(2) == 2);
assert(func0(10) == 115975);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov -0x44(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1090 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x34(%rbp)
jmp 122b <func0+0xa2>
mov -0x44(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x20(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1090 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,-0x30(%rbp)
jmp 121f <func0+0x96>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
add %rdx,%rax
movq $0x0,(%rax)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 11f0 <func0+0x67>
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 11ba <func0+0x31>
mov -0x20(%rbp),%rax
mov (%rax),%rax
movq $0x1,(%rax)
movl $0x1,-0x2c(%rbp)
jmpq 1332 <func0+0x1a9>
mov -0x2c(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
sub $0x8,%rdx
add %rax,%rdx
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov (%rdx),%rdx
mov %rdx,(%rax)
movl $0x1,-0x28(%rbp)
jmpq 1322 <func0+0x199>
mov -0x2c(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
sub $0x8,%rdx
add %rdx,%rax
mov (%rax),%rcx
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
sub $0x8,%rdx
add %rdx,%rax
mov (%rax),%rdx
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rsi
mov -0x20(%rbp),%rax
add %rsi,%rax
mov (%rax),%rax
mov -0x28(%rbp),%esi
movslq %esi,%rsi
shl $0x3,%rsi
add %rsi,%rax
add %rcx,%rdx
mov %rdx,(%rax)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x2c(%rbp),%eax
jle 129e <func0+0x115>
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 124d <func0+0xc4>
mov -0x44(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov (%rax),%rax
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
jmp 1388 <func0+0x1ff>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1070 <free@plt>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 1365 <func0+0x1dc>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1070 <free@plt>
mov -0x18(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov eax, [rbp+var_44]
add eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_34], 0
jmp short loc_122B
loc_11BA:
mov eax, [rbp+var_44]
add eax, 1
cdqe
shl rax, 3
mov edx, [rbp+var_34]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+ptr]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov [rbp+var_30], 0
jmp short loc_121F
loc_11F0:
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_30]
movsxd rdx, edx
shl rdx, 3
add rax, rdx
mov qword ptr [rax], 0
add [rbp+var_30], 1
loc_121F:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_44]
jle short loc_11F0
add [rbp+var_34], 1
loc_122B:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_44]
jle short loc_11BA
mov rax, [rbp+ptr]
mov rax, [rax]
mov qword ptr [rax], 1
mov [rbp+var_2C], 1
jmp loc_1332
loc_124D:
mov eax, [rbp+var_2C]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_2C]
movsxd rdx, edx
shl rdx, 3
sub rdx, 8
add rdx, rax
mov eax, [rbp+var_2C]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rcx
mov rax, [rax]
mov rdx, [rdx]
mov [rax], rdx
mov [rbp+var_28], 1
jmp loc_1322
loc_129E:
mov eax, [rbp+var_2C]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_28]
movsxd rdx, edx
shl rdx, 3
sub rdx, 8
add rax, rdx
mov rcx, [rax]
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_28]
movsxd rdx, edx
shl rdx, 3
sub rdx, 8
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_2C]
cdqe
lea rsi, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rsi
mov rax, [rax]
mov esi, [rbp+var_28]
movsxd rsi, esi
shl rsi, 3
add rax, rsi
add rdx, rcx
mov [rax], rdx
add [rbp+var_28], 1
loc_1322:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_2C]
jle loc_129E
add [rbp+var_2C], 1
loc_1332:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_44]
jle loc_124D
mov eax, [rbp+var_44]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_18], rax
mov [rbp+var_24], 0
jmp short loc_1388
loc_1365:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov rdi, rax; ptr
call _free
add [rbp+var_24], 1
loc_1388:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_44]
jle short loc_1365
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-34h]
int j; // [rsp+20h] [rbp-30h]
int k; // [rsp+24h] [rbp-2Ch]
int m; // [rsp+28h] [rbp-28h]
int n; // [rsp+2Ch] [rbp-24h]
_QWORD **ptr; // [rsp+30h] [rbp-20h]
long long v8; // [rsp+38h] [rbp-18h]
ptr = (_QWORD **)malloc(8LL * (a1 + 1));
for ( i = 0; i <= a1; ++i )
{
ptr[i] = malloc(8LL * (a1 + 1));
for ( j = 0; j <= a1; ++j )
ptr[i][j] = 0LL;
}
**ptr = 1LL;
for ( k = 1; k <= a1; ++k )
{
*ptr[k] = ptr[k - 1][k - 1];
for ( m = 1; m <= k; ++m )
ptr[k][m] = ptr[k - 1][m - 1] + ptr[k][m - 1];
}
v8 = *ptr[a1];
for ( n = 0; n <= a1; ++n )
free(ptr[n]);
free(ptr);
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101090
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x34],0x0
JMP 0x0010122b
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x20]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101090
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP + -0x30],0x0
JMP 0x0010121f
LAB_001011f0:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
SHL RDX,0x3
ADD RAX,RDX
MOV qword ptr [RAX],0x0
ADD dword ptr [RBP + -0x30],0x1
LAB_0010121f:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x001011f0
ADD dword ptr [RBP + -0x34],0x1
LAB_0010122b:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x001011ba
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x1
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x00101332
LAB_0010124d:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
SHL RDX,0x3
SUB RDX,0x8
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RDX]
MOV qword ptr [RAX],RDX
MOV dword ptr [RBP + -0x28],0x1
JMP 0x00101322
LAB_0010129e:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
SHL RDX,0x3
SUB RDX,0x8
ADD RAX,RDX
MOV RCX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
SHL RDX,0x3
SUB RDX,0x8
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RSI,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RSI
MOV RAX,qword ptr [RAX]
MOV ESI,dword ptr [RBP + -0x28]
MOVSXD RSI,ESI
SHL RSI,0x3
ADD RAX,RSI
ADD RDX,RCX
MOV qword ptr [RAX],RDX
ADD dword ptr [RBP + -0x28],0x1
LAB_00101322:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x2c]
JLE 0x0010129e
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101332:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x0010124d
MOV EAX,dword ptr [RBP + -0x44]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101388
LAB_00101365:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101070
ADD dword ptr [RBP + -0x24],0x1
LAB_00101388:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x00101365
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101070
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int8 func0(int param_1)
{
int8 uVar1;
int8 *__ptr;
void *pvVar2;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
__ptr = (int8 *)malloc((long)(param_1 + 1) << 3);
for (local_3c = 0; local_3c <= param_1; local_3c = local_3c + 1) {
pvVar2 = malloc((long)(param_1 + 1) << 3);
__ptr[local_3c] = pvVar2;
for (local_38 = 0; local_38 <= param_1; local_38 = local_38 + 1) {
*(int8 *)(__ptr[local_3c] + (long)local_38 * 8) = 0;
}
}
*(int8 *)*__ptr = 1;
for (local_34 = 1; local_34 <= param_1; local_34 = local_34 + 1) {
*(int8 *)__ptr[local_34] =
*(int8 *)((long)local_34 * 8 + -8 + __ptr[(long)local_34 + -1]);
for (local_30 = 1; local_30 <= local_34; local_30 = local_30 + 1) {
*(long *)(__ptr[local_34] + (long)local_30 * 8) =
*(long *)(__ptr[local_34] + (long)local_30 * 8 + -8) +
*(long *)(__ptr[(long)local_34 + -1] + (long)local_30 * 8 + -8);
}
}
uVar1 = *(int8 *)__ptr[param_1];
for (local_2c = 0; local_2c <= param_1; local_2c = local_2c + 1) {
free((void *)__ptr[local_2c]);
}
free(__ptr);
return uVar1;
} |
4,161 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| unsigned long long func0(int n) {
unsigned long long** bell = malloc((n + 1) * sizeof(unsigned long long*));
for(int i = 0; i <= n; i++) {
bell[i] = malloc((n + 1) * sizeof(unsigned long long));
for(int j = 0; j <= n; j++) {
bell[i][j] = 0;
}
}
bell[0][0] = 1;
for(int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for(int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
unsigned long long result = bell[n][0];
for(int i = 0; i <= n; i++) {
free(bell[i]);
}
free(bell);
return result;
}
| int main() {
assert(func0(2) == 2);
assert(func0(10) == 115975);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%r12d
lea 0x1(%rdi),%r13d
movslq %r13d,%r13
shl $0x3,%r13
mov %r13,%rdi
callq 1090 <malloc@plt>
mov %rax,%rbp
test %r12d,%r12d
js 12b1 <func0+0x128>
mov %rax,%rbx
mov %r12d,%eax
lea 0x8(,%rax,8),%r14
lea (%r14,%rbp,1),%r15
jmp 11da <func0+0x51>
add $0x8,%rbx
cmp %r15,%rbx
je 11fd <func0+0x74>
mov %r13,%rdi
callq 1090 <malloc@plt>
mov %rax,(%rbx)
mov %rax,%rdx
add %r14,%rax
movq $0x0,(%rdx)
add $0x8,%rdx
cmp %rax,%rdx
jne 11eb <func0+0x62>
jmp 11d1 <func0+0x48>
mov 0x0(%rbp),%rax
movq $0x1,(%rax)
test %r12d,%r12d
jle 1262 <func0+0xd9>
lea -0x1(%r12),%r9d
add $0x2,%r9
mov $0x0,%r8d
mov $0x1,%esi
jmp 1230 <func0+0xa7>
add $0x1,%rsi
add $0x8,%r8
cmp %r9,%rsi
je 1277 <func0+0xee>
mov 0x0(%rbp,%r8,1),%rdi
mov 0x0(%rbp,%rsi,8),%rcx
mov (%rdi,%r8,1),%rax
mov %rax,(%rcx)
test %esi,%esi
jle 1223 <func0+0x9a>
mov $0x0,%eax
mov (%rcx,%rax,8),%rdx
add (%rdi,%rax,8),%rdx
mov %rdx,0x8(%rcx,%rax,8)
add $0x1,%rax
cmp %rsi,%rax
jne 124a <func0+0xc1>
jmp 1223 <func0+0x9a>
mov -0x8(%rbp,%r13,1),%rax
mov (%rax),%r13
jne 1297 <func0+0x10e>
mov 0x0(%rbp),%rdi
callq 1070 <free@plt>
jmp 1297 <func0+0x10e>
mov -0x8(%rbp,%r13,1),%rax
mov (%rax),%r13
mov $0x0,%ebx
mov 0x0(%rbp,%rbx,8),%rdi
callq 1070 <free@plt>
add $0x1,%rbx
cmp %ebx,%r12d
jge 1284 <func0+0xfb>
mov %rbp,%rdi
callq 1070 <free@plt>
mov %r13,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov (%rax),%rax
movq $0x1,(%rax)
jg 120d <func0+0x84>
mov -0x8(%rbp,%r13,1),%rax
mov (%rax),%r13
jmp 1297 <func0+0x10e>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12d, edi
lea r13d, [rdi+1]
movsxd r13, r13d
shl r13, 3
mov rdi, r13
call _malloc
mov rbp, rax
test r12d, r12d
js loc_12A7
mov rbx, rax
lea r14d, [r12+1]
shl r14, 3
lea r15, [r14+rax]
loc_11CD:
mov rdi, r13
call _malloc
mov [rbx], rax
mov rdx, rax
add rax, r14
loc_11DE:
mov qword ptr [rdx], 0
add rdx, 8
cmp rdx, rax
jnz short loc_11DE
add rbx, 8
cmp rbx, r15
jnz short loc_11CD
mov rax, [rbp+0]
mov qword ptr [rax], 1
test r12d, r12d
jle loc_1292
loc_120B:
lea r9d, [r12+1]
mov r8d, 0
mov esi, 1
loc_121B:
mov rdi, [rbp+r8+0]
mov rcx, [rbp+rsi*8+0]
mov rax, [rdi+r8]
mov [rcx], rax
test esi, esi
jle short loc_124B
mov eax, 0
loc_1235:
mov rdx, [rcx+rax*8]
add rdx, [rdi+rax*8]
mov [rcx+rax*8+8], rdx
add rax, 1
cmp rax, rsi
jnz short loc_1235
loc_124B:
add rsi, 1
add r8, 8
cmp rsi, r9
jnz short loc_121B
mov rax, [rbp+r13-8]
mov r13, [rax]
mov ebx, 0
loc_1265:
mov rdi, [rbp+rbx*8+0]
call _free
add rbx, 1
cmp r12d, ebx
jge short loc_1265
loc_1278:
mov rdi, rbp
call _free
mov rax, r13
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1292:
mov rax, [rbp+r13-8]
mov r13, [rax]
jnz short loc_1278
mov rdi, [rbp+0]
call _free
jmp short loc_1278
loc_12A7:
mov rax, [rax]
mov qword ptr [rax], 1
jg loc_120B
mov rax, [rbp+r13-8]
mov r13, [rax]
jmp short loc_1278 | long long func0(int a1)
{
long long v2; // r13
_QWORD **v3; // rax
_QWORD *v4; // rbp
long long *v5; // rbx
long long v6; // r14
long long *v7; // r15
long long v8; // rax
_QWORD *v9; // rdx
_QWORD *v10; // rax
long long v11; // r8
long long v12; // rsi
long long v13; // rdi
_QWORD *v14; // rcx
long long v15; // rax
long long v16; // r13
long long v17; // rbx
v2 = a1 + 1;
v3 = (_QWORD **)malloc(v2 * 8);
v4 = v3;
if ( a1 < 0 )
{
**v3 = 1LL;
v16 = *v3[v2 - 1];
}
else
{
v5 = (long long *)v3;
v6 = (unsigned int)(a1 + 1);
v7 = (long long *)&v3[v6];
do
{
v8 = malloc(v2 * 8);
*v5 = v8;
v9 = (_QWORD *)v8;
v10 = (_QWORD *)(v6 * 8 + v8);
do
*v9++ = 0LL;
while ( v9 != v10 );
++v5;
}
while ( v5 != v7 );
*(_QWORD *)*v4 = 1LL;
if ( a1 <= 0 )
{
v16 = *(_QWORD *)v4[v2 - 1];
free(*v4);
}
else
{
v11 = 0LL;
v12 = 1LL;
do
{
v13 = v4[v11];
v14 = (_QWORD *)v4[v12];
*v14 = *(_QWORD *)(v13 + v11 * 8);
if ( (int)v12 > 0 )
{
v15 = 0LL;
do
{
v14[v15 + 1] = *(_QWORD *)(v13 + 8 * v15) + v14[v15];
++v15;
}
while ( v15 != v12 );
}
++v12;
++v11;
}
while ( v12 != a1 + 1 );
v16 = *(_QWORD *)v4[v2 - 1];
v17 = 0LL;
do
free(v4[v17++]);
while ( a1 >= (int)v17 );
}
}
free(v4);
return v16;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12D,EDI
LEA R13D,[RDI + 0x1]
MOVSXD R13,R13D
SHL R13,0x3
MOV RDI,R13
CALL 0x00101090
MOV RBP,RAX
TEST R12D,R12D
JS 0x001012a7
MOV RBX,RAX
LEA R14D,[R12 + 0x1]
SHL R14,0x3
LEA R15,[R14 + RAX*0x1]
LAB_001011cd:
MOV RDI,R13
CALL 0x00101090
MOV qword ptr [RBX],RAX
MOV RDX,RAX
ADD RAX,R14
LAB_001011de:
MOV qword ptr [RDX],0x0
ADD RDX,0x8
CMP RDX,RAX
JNZ 0x001011de
ADD RBX,0x8
CMP RBX,R15
JNZ 0x001011cd
MOV RAX,qword ptr [RBP]
MOV qword ptr [RAX],0x1
TEST R12D,R12D
JLE 0x00101292
LAB_0010120b:
LEA R9D,[R12 + 0x1]
MOV R8D,0x0
MOV ESI,0x1
LAB_0010121b:
MOV RDI,qword ptr [RBP + R8*0x1]
MOV RCX,qword ptr [RBP + RSI*0x8]
MOV RAX,qword ptr [RDI + R8*0x1]
MOV qword ptr [RCX],RAX
TEST ESI,ESI
JLE 0x0010124b
MOV EAX,0x0
LAB_00101235:
MOV RDX,qword ptr [RCX + RAX*0x8]
ADD RDX,qword ptr [RDI + RAX*0x8]
MOV qword ptr [RCX + RAX*0x8 + 0x8],RDX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101235
LAB_0010124b:
ADD RSI,0x1
ADD R8,0x8
CMP RSI,R9
JNZ 0x0010121b
MOV RAX,qword ptr [RBP + R13*0x1 + -0x8]
MOV R13,qword ptr [RAX]
MOV EBX,0x0
LAB_00101265:
MOV RDI,qword ptr [RBP + RBX*0x8]
CALL 0x00101070
ADD RBX,0x1
CMP R12D,EBX
JGE 0x00101265
LAB_00101278:
MOV RDI,RBP
CALL 0x00101070
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101292:
MOV RAX,qword ptr [RBP + R13*0x1 + -0x8]
MOV R13,qword ptr [RAX]
JNZ 0x00101278
MOV RDI,qword ptr [RBP]
CALL 0x00101070
JMP 0x00101278
LAB_001012a7:
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x1
JG 0x0010120b
MOV RAX,qword ptr [RBP + R13*0x1 + -0x8]
MOV R13,qword ptr [RAX]
JMP 0x00101278 | int8 func0(int param_1)
{
long lVar1;
int8 *__ptr;
int8 *puVar2;
int8 *puVar3;
ulong uVar4;
int8 *puVar5;
ulong uVar6;
long lVar7;
long lVar8;
int8 uVar9;
lVar8 = (long)(param_1 + 1);
__ptr = (int8 *)malloc(lVar8 * 8);
if (param_1 < 0) {
*(int8 *)*__ptr = 1;
if (param_1 < 1) {
uVar9 = *(int8 *)__ptr[lVar8 + -1];
goto LAB_00101278;
}
}
else {
puVar5 = __ptr;
do {
puVar2 = (int8 *)malloc(lVar8 * 8);
*puVar5 = puVar2;
puVar3 = puVar2 + (param_1 + 1U);
do {
*puVar2 = 0;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar3);
puVar5 = puVar5 + 1;
} while (puVar5 != __ptr + (param_1 + 1U));
*(int8 *)*__ptr = 1;
if (param_1 < 1) {
uVar9 = *(int8 *)__ptr[lVar8 + -1];
if (param_1 == 0) {
free((void *)*__ptr);
}
goto LAB_00101278;
}
}
lVar7 = 0;
uVar6 = 1;
do {
lVar1 = *(long *)((long)__ptr + lVar7);
puVar5 = (int8 *)__ptr[uVar6];
*puVar5 = *(int8 *)(lVar1 + lVar7);
if (0 < (int)uVar6) {
uVar4 = 0;
do {
puVar5[uVar4 + 1] = puVar5[uVar4] + *(long *)(lVar1 + uVar4 * 8);
uVar4 = uVar4 + 1;
} while (uVar4 != uVar6);
}
uVar6 = uVar6 + 1;
lVar7 = lVar7 + 8;
} while (uVar6 != param_1 + 1);
uVar9 = *(int8 *)__ptr[lVar8 + -1];
lVar8 = 0;
do {
free((void *)__ptr[lVar8]);
lVar8 = lVar8 + 1;
} while ((int)lVar8 <= param_1);
LAB_00101278:
free(__ptr);
return uVar9;
} |
4,162 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| unsigned long long func0(int n) {
unsigned long long** bell = malloc((n + 1) * sizeof(unsigned long long*));
for(int i = 0; i <= n; i++) {
bell[i] = malloc((n + 1) * sizeof(unsigned long long));
for(int j = 0; j <= n; j++) {
bell[i][j] = 0;
}
}
bell[0][0] = 1;
for(int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for(int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
unsigned long long result = bell[n][0];
for(int i = 0; i <= n; i++) {
free(bell[i]);
}
free(bell);
return result;
}
| int main() {
assert(func0(2) == 2);
assert(func0(10) == 115975);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
lea 0x1(%rdi),%r12d
push %rbp
movslq %r12d,%r12
push %rbx
shl $0x3,%r12
mov %edi,%ebx
mov %r12,%rdi
sub $0x8,%rsp
callq 1090 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
js 1330 <func0+0x130>
mov %rax,%r15
movslq %ebx,%rax
lea 0x8(,%rax,8),%r13
lea 0x0(%r13,%rbp,1),%r14
nopl (%rax)
mov %r12,%rdi
callq 1090 <malloc@plt>
mov %rax,(%r15)
lea (%rax,%r13,1),%rdx
nopw 0x0(%rax,%rax,1)
movq $0x0,(%rax)
add $0x8,%rax
cmp %rax,%rdx
jne 1260 <func0+0x60>
add $0x8,%r15
cmp %r14,%r15
jne 1248 <func0+0x48>
mov 0x0(%rbp),%r8
mov -0x8(%rbp,%r12,1),%r10
movq $0x1,(%r8)
test %ebx,%ebx
je 1344 <func0+0x144>
lea -0x1(%rbx),%eax
mov %r8,%rdi
xor %ecx,%ecx
mov $0x1,%edx
lea 0x8(,%rax,8),%r9
nopw %cs:0x0(%rax,%rax,1)
mov 0x8(%rbp,%rcx,1),%rsi
xor %eax,%eax
mov %rdx,(%rsi)
jmp 12c4 <func0+0xc4>
nopl 0x0(%rax)
add $0x8,%rax
add (%rdi,%rax,1),%rdx
mov %rdx,0x8(%rsi,%rax,1)
cmp %rcx,%rax
jne 12c0 <func0+0xc0>
add $0x8,%rcx
cmp %rcx,%r9
je 12f0 <func0+0xf0>
mov 0x0(%rbp,%rcx,1),%rdi
mov (%rdi,%rcx,1),%rdx
jmp 12b0 <func0+0xb0>
nopw %cs:0x0(%rax,%rax,1)
mov (%r10),%r13
xor %r12d,%r12d
jmp 1305 <func0+0x105>
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp,%r12,8),%r8
mov %r8,%rdi
add $0x1,%r12
callq 1070 <free@plt>
cmp %r12d,%ebx
jge 1300 <func0+0x100>
mov %rbp,%rdi
callq 1070 <free@plt>
add $0x8,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov (%rax),%rax
movq $0x1,(%rax)
mov -0x8(%rbp,%r12,1),%rax
mov (%rax),%r13
jmp 1316 <func0+0x116>
mov %r8,%rdi
mov (%r10),%r13
callq 1070 <free@plt>
jmp 1316 <func0+0x116>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, edi
push rbp
push rbx
lea ebx, [rdi+1]
movsxd rbx, ebx
shl rbx, 3
sub rsp, 18h
mov rdi, rbx
call _malloc
mov rbp, rax
test r12d, r12d
js loc_1320
mov r13, rax
movsxd rax, r12d
mov [rsp+48h+var_40], rax
lea r14, ds:8[rax*8]
lea r15, [r14+rbp]
nop word ptr [rax+rax+00h]
loc_1250:
mov rdi, rbx
call _malloc
mov [r13+0], rax
lea rdx, [rax+r14]
loc_1260:
mov qword ptr [rax], 0
add rax, 8
cmp rdx, rax
jnz short loc_1260
add r13, 8
cmp r15, r13
jnz short loc_1250
mov r8, [rbp+0]
mov r9, [rbp+rbx-8]
mov qword ptr [r8], 1
test r12d, r12d
jz loc_1334
mov r13, [rsp+48h+var_40]
mov rdi, r8
xor ecx, ecx
mov edx, 1
shl r13, 3
nop dword ptr [rax]
loc_12A8:
mov rsi, [rbp+rcx+8]
xor eax, eax
mov [rsi], rdx
jmp short loc_12BC
loc_12B8:
add rax, 8
loc_12BC:
add rdx, [rdi+rax]
mov [rsi+rax+8], rdx
cmp rax, rcx
jnz short loc_12B8
add rcx, 8
cmp r13, rcx
jz short loc_12E0
mov rdi, [rbp+rcx+0]
mov rdx, [rdi+rcx]
jmp short loc_12A8
loc_12E0:
mov r13, [r9]
xor ebx, ebx
jmp short loc_12F5
loc_12F0:
mov r8, [rbp+rbx*8+0]
loc_12F5:
mov rdi, r8
add rbx, 1
call _free
cmp r12d, ebx
jge short loc_12F0
loc_1306:
mov rdi, rbp
call _free
add rsp, 18h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1320:
mov rax, [rax]
mov qword ptr [rax], 1
mov rax, [rbp+rbx-8]
mov r13, [rax]
jmp short loc_1306
loc_1334:
mov rdi, r8
mov r13, [r9]
call _free
jmp short loc_1306 | long long func0(int a1)
{
long long v2; // rbx
_QWORD **v3; // rax
_QWORD *v4; // rbp
_QWORD *v5; // r13
long long v6; // r14
_QWORD *v7; // rax
_QWORD *v8; // rdx
_QWORD *v9; // r8
long long *v10; // r9
_QWORD *v11; // rdi
unsigned long long v12; // rcx
long long i; // rdx
long long *v14; // rsi
unsigned long long v15; // rax
long long v16; // r13
long long j; // rbx
v2 = a1 + 1;
v3 = (_QWORD **)malloc(v2 * 8);
v4 = v3;
if ( a1 < 0 )
{
**v3 = 1LL;
v16 = *v3[v2 - 1];
}
else
{
v5 = v3;
v6 = 8LL * a1 + 8;
do
{
v7 = (_QWORD *)malloc(v2 * 8);
*v5 = v7;
v8 = (_QWORD *)((char *)v7 + v6);
do
*v7++ = 0LL;
while ( v8 != v7 );
++v5;
}
while ( (_QWORD *)((char *)v4 + v6) != v5 );
v9 = (_QWORD *)*v4;
v10 = (long long *)v4[v2 - 1];
*(_QWORD *)*v4 = 1LL;
if ( a1 )
{
v11 = v9;
v12 = 0LL;
for ( i = 1LL; ; i = v11[v12 / 8] )
{
v14 = (long long *)v4[v12 / 8 + 1];
v15 = 0LL;
*v14 = i;
while ( 1 )
{
i += v11[v15 / 8];
v14[v15 / 8 + 1] = i;
if ( v15 == v12 )
break;
v15 += 8LL;
}
v12 += 8LL;
if ( 8LL * a1 == v12 )
break;
v11 = (_QWORD *)v4[v12 / 8];
}
v16 = *v10;
for ( j = 0LL; ; v9 = (_QWORD *)v4[j] )
{
++j;
free(v9);
if ( a1 < (int)j )
break;
}
}
else
{
v16 = *v10;
free(v9);
}
}
free(v4);
return v16;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBP
PUSH RBX
LEA EBX,[RDI + 0x1]
MOVSXD RBX,EBX
SHL RBX,0x3
SUB RSP,0x18
MOV RDI,RBX
CALL 0x00101090
MOV RBP,RAX
TEST R12D,R12D
JS 0x00101320
MOV R13,RAX
MOVSXD RAX,R12D
MOV qword ptr [RSP + 0x8],RAX
LEA R14,[0x8 + RAX*0x8]
LEA R15,[R14 + RBP*0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_00101250:
MOV RDI,RBX
CALL 0x00101090
MOV qword ptr [R13],RAX
LEA RDX,[RAX + R14*0x1]
LAB_00101260:
MOV qword ptr [RAX],0x0
ADD RAX,0x8
CMP RDX,RAX
JNZ 0x00101260
ADD R13,0x8
CMP R15,R13
JNZ 0x00101250
MOV R8,qword ptr [RBP]
MOV R9,qword ptr [RBP + RBX*0x1 + -0x8]
MOV qword ptr [R8],0x1
TEST R12D,R12D
JZ 0x00101334
MOV R13,qword ptr [RSP + 0x8]
MOV RDI,R8
XOR ECX,ECX
MOV EDX,0x1
SHL R13,0x3
NOP dword ptr [RAX]
LAB_001012a8:
MOV RSI,qword ptr [RBP + RCX*0x1 + 0x8]
XOR EAX,EAX
MOV qword ptr [RSI],RDX
JMP 0x001012bc
LAB_001012b8:
ADD RAX,0x8
LAB_001012bc:
ADD RDX,qword ptr [RDI + RAX*0x1]
MOV qword ptr [RSI + RAX*0x1 + 0x8],RDX
CMP RAX,RCX
JNZ 0x001012b8
ADD RCX,0x8
CMP R13,RCX
JZ 0x001012e0
MOV RDI,qword ptr [RBP + RCX*0x1]
MOV RDX,qword ptr [RDI + RCX*0x1]
JMP 0x001012a8
LAB_001012e0:
MOV R13,qword ptr [R9]
XOR EBX,EBX
JMP 0x001012f5
LAB_001012f0:
MOV R8,qword ptr [RBP + RBX*0x8]
LAB_001012f5:
MOV RDI,R8
ADD RBX,0x1
CALL 0x00101070
CMP R12D,EBX
JGE 0x001012f0
LAB_00101306:
MOV RDI,RBP
CALL 0x00101070
ADD RSP,0x18
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101320:
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x1
MOV RAX,qword ptr [RBP + RBX*0x1 + -0x8]
MOV R13,qword ptr [RAX]
JMP 0x00101306
LAB_00101334:
MOV RDI,R8
MOV R13,qword ptr [R9]
CALL 0x00101070
JMP 0x00101306 | int8 func0(int param_1)
{
int8 *puVar1;
long *plVar2;
int8 *__ptr;
long lVar3;
int8 *puVar4;
long lVar5;
long lVar6;
long lVar7;
int8 *puVar8;
int8 uVar9;
lVar7 = (long)(param_1 + 1);
__ptr = (int8 *)malloc(lVar7 * 8);
if (param_1 < 0) {
*(int8 *)*__ptr = 1;
uVar9 = *(int8 *)__ptr[lVar7 + -1];
}
else {
lVar3 = (long)param_1;
puVar8 = __ptr;
do {
puVar4 = (int8 *)malloc(lVar7 * 8);
*puVar8 = puVar4;
puVar1 = puVar4 + lVar3 + 1;
do {
*puVar4 = 0;
puVar4 = puVar4 + 1;
} while (puVar1 != puVar4);
puVar8 = puVar8 + 1;
} while (__ptr + lVar3 + 1 != puVar8);
puVar8 = (int8 *)*__ptr;
puVar1 = (int8 *)__ptr[lVar7 + -1];
*puVar8 = 1;
if (param_1 == 0) {
uVar9 = *puVar1;
free(puVar8);
}
else {
lVar6 = 0;
lVar7 = 1;
puVar4 = puVar8;
while( true ) {
plVar2 = *(long **)((long)__ptr + lVar6 + 8);
lVar5 = 0;
*plVar2 = lVar7;
while( true ) {
lVar7 = lVar7 + *(long *)((long)puVar4 + lVar5);
*(long *)((long)plVar2 + lVar5 + 8) = lVar7;
if (lVar5 == lVar6) break;
lVar5 = lVar5 + 8;
}
lVar6 = lVar6 + 8;
if (lVar3 << 3 == lVar6) break;
puVar4 = *(int8 **)((long)__ptr + lVar6);
lVar7 = *(long *)((long)puVar4 + lVar6);
}
uVar9 = *puVar1;
lVar7 = 0;
while( true ) {
lVar7 = lVar7 + 1;
free(puVar8);
if (param_1 < (int)lVar7) break;
puVar8 = (int8 *)__ptr[lVar7];
}
}
}
free(__ptr);
return uVar9;
} |
4,163 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| unsigned long long func0(int n) {
unsigned long long** bell = malloc((n + 1) * sizeof(unsigned long long*));
for(int i = 0; i <= n; i++) {
bell[i] = malloc((n + 1) * sizeof(unsigned long long));
for(int j = 0; j <= n; j++) {
bell[i][j] = 0;
}
}
bell[0][0] = 1;
for(int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for(int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
unsigned long long result = bell[n][0];
for(int i = 0; i <= n; i++) {
free(bell[i]);
}
free(bell);
return result;
}
| int main() {
assert(func0(2) == 2);
assert(func0(10) == 115975);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
lea 0x1(%rdi),%eax
push %r14
push %r13
push %r12
movslq %eax,%r12
push %rbp
shl $0x3,%r12
push %rbx
mov %edi,%ebx
mov %r12,%rdi
sub $0x18,%rsp
mov %eax,0x4(%rsp)
callq 1090 <malloc@plt>
mov %rax,%r15
test %ebx,%ebx
js 1357 <func0+0x157>
mov %rax,%r14
movslq %ebx,%rax
lea 0x8(%r15,%rax,8),%rax
mov %rax,0x8(%rsp)
mov 0x4(%rsp),%eax
mov %eax,%r13d
and $0xfffffffe,%eax
shr %r13d
mov %eax,%ebp
shl $0x4,%r13
nopl 0x0(%rax,%rax,1)
mov %r12,%rdi
callq 1090 <malloc@plt>
mov %rax,(%r14)
test %ebx,%ebx
je 1350 <func0+0x150>
mov %rax,%rdx
lea 0x0(%r13,%rax,1),%rsi
pxor %xmm0,%xmm0
movups %xmm0,(%rdx)
add $0x10,%rdx
cmp %rsi,%rdx
jne 1280 <func0+0x80>
movslq %ebp,%rdx
cmp 0x4(%rsp),%ebp
je 129d <func0+0x9d>
movq $0x0,(%rax,%rdx,8)
add $0x8,%r14
cmp %r14,0x8(%rsp)
jne 1260 <func0+0x60>
mov (%r15),%rdi
mov -0x8(%r15,%r12,1),%r10
movq $0x1,(%rdi)
test %ebx,%ebx
je 136b <func0+0x16b>
lea -0x1(%rbx),%r9d
mov $0x1,%ecx
mov $0x1,%edx
add $0x1,%r9
nopl 0x0(%rax)
mov (%r15,%rcx,8),%rsi
mov -0x8(%r15,%rcx,8),%rdi
xor %eax,%eax
mov %rdx,(%rsi)
nopw %cs:0x0(%rax,%rax,1)
add (%rdi,%rax,8),%rdx
mov %rdx,0x8(%rsi,%rax,8)
add $0x1,%rax
cmp %rax,%rcx
jne 12f0 <func0+0xf0>
cmp %rcx,%r9
je 1318 <func0+0x118>
mov (%rsi,%rcx,8),%rdx
add $0x1,%rcx
jmp 12d8 <func0+0xd8>
nopl 0x0(%rax)
mov (%r10),%r12
xor %ebp,%ebp
nopl (%rax)
mov (%r15,%rbp,8),%rdi
add $0x1,%rbp
callq 1070 <free@plt>
cmp %ebp,%ebx
jge 1320 <func0+0x120>
mov %r15,%rdi
callq 1070 <free@plt>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
xor %edx,%edx
jmpq 1295 <func0+0x95>
mov (%rax),%rax
movq $0x1,(%rax)
mov -0x8(%r15,%r12,1),%rax
mov (%rax),%r12
jmp 1331 <func0+0x131>
mov (%r10),%r12
callq 1070 <free@plt>
jmp 1331 <func0+0x131>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14d, edi
push r13
push r12
lea r12d, [rdi+1]
push rbp
movsxd r12, r12d
push rbx
shl r12, 3
sub rsp, 18h
mov [rsp+48h+var_3C], edi
mov rdi, r12; size
call _malloc
mov rbx, rax
test r14d, r14d
js loc_132B
mov r15, rax
movsxd rax, r14d
mov r13, rbx
lea r14, ds:8[rax*8]
lea rbp, [r14+rbx]
nop dword ptr [rax]
loc_1270:
mov rdi, r12; size
add r13, 8
call _malloc
mov rdx, r14; n
xor esi, esi; c
mov [r13-8], rax
mov rdi, rax; s
call _memset
cmp rbp, r13
jnz short loc_1270
mov rax, [rbx]
mov qword ptr [rax], 1
mov eax, [rsp+48h+var_3C]
test eax, eax
jz short loc_12F8
mov r14d, eax
mov ecx, 1
mov edx, 1
nop dword ptr [rax+00000000h]
loc_12B8:
mov rsi, [rbx+rcx*8]
mov rdi, [rbx+rcx*8-8]
xor eax, eax
mov [rsi], rdx
nop word ptr [rax+rax+00000000h]
loc_12D0:
add rdx, [rdi+rax*8]
mov [rsi+rax*8+8], rdx
add rax, 1
cmp rax, rcx
jnz short loc_12D0
cmp r14, rcx
jz short loc_12F8
mov rdx, [rsi+rcx*8]
add rcx, 1
jmp short loc_12B8
loc_12F8:
mov rax, [rbx+r12-8]
mov r12, [rax]
loc_1300:
mov rdi, [r15]; ptr
add r15, 8
call _free
cmp rbp, r15
jnz short loc_1300
loc_1311:
mov rdi, rbx; ptr
call _free
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_132B:
mov rax, [rax]
mov qword ptr [rax], 1
mov rax, [rbx+r12-8]
mov r12, [rax]
jmp short loc_1311 | long long func0(int a1)
{
size_t v1; // r12
_QWORD **v2; // rax
_QWORD **v3; // rbx
void **v4; // r15
void **v5; // r13
size_t v6; // r14
void **v7; // rbp
_QWORD *v8; // rax
long long v9; // rcx
long long i; // rdx
long long *v11; // rsi
_QWORD *v12; // rdi
long long v13; // rax
long long v14; // r12
void *v15; // rdi
v1 = a1 + 1;
v2 = (_QWORD **)malloc(v1 * 8);
v3 = v2;
if ( a1 < 0 )
{
**v2 = 1LL;
v14 = *v2[v1 - 1];
}
else
{
v4 = (void **)v2;
v5 = (void **)v2;
v6 = 8LL * a1 + 8;
v7 = (void **)((char *)v2 + v6);
do
{
++v5;
v8 = malloc(v1 * 8);
*(v5 - 1) = v8;
memset(v8, 0, v6);
}
while ( v7 != v5 );
**v3 = 1LL;
if ( a1 )
{
v9 = 1LL;
for ( i = 1LL; ; i = v11[v9++] )
{
v11 = v3[v9];
v12 = v3[v9 - 1];
v13 = 0LL;
*v11 = i;
do
{
i += v12[v13];
v11[++v13] = i;
}
while ( v13 != v9 );
if ( a1 == v9 )
break;
}
}
v14 = *v3[v1 - 1];
do
{
v15 = *v4++;
free(v15);
}
while ( v7 != v4 );
}
free(v3);
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,EDI
PUSH R13
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
MOVSXD R12,R12D
PUSH RBX
SHL R12,0x3
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EDI
MOV RDI,R12
CALL 0x001010b0
MOV RBX,RAX
TEST R14D,R14D
JS 0x0010132b
MOV R15,RAX
MOVSXD RAX,R14D
MOV R13,RBX
LEA R14,[0x8 + RAX*0x8]
LEA RBP,[R14 + RBX*0x1]
NOP dword ptr [RAX]
LAB_00101270:
MOV RDI,R12
ADD R13,0x8
CALL 0x001010b0
MOV RDX,R14
XOR ESI,ESI
MOV qword ptr [R13 + -0x8],RAX
MOV RDI,RAX
CALL 0x001010a0
CMP RBP,R13
JNZ 0x00101270
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX],0x1
MOV EAX,dword ptr [RSP + 0xc]
TEST EAX,EAX
JZ 0x001012f8
MOV R14D,EAX
MOV ECX,0x1
MOV EDX,0x1
NOP dword ptr [RAX]
LAB_001012b8:
MOV RSI,qword ptr [RBX + RCX*0x8]
MOV RDI,qword ptr [RBX + RCX*0x8 + -0x8]
XOR EAX,EAX
MOV qword ptr [RSI],RDX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001012d0:
ADD RDX,qword ptr [RDI + RAX*0x8]
MOV qword ptr [RSI + RAX*0x8 + 0x8],RDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x001012d0
CMP R14,RCX
JZ 0x001012f8
MOV RDX,qword ptr [RSI + RCX*0x8]
ADD RCX,0x1
JMP 0x001012b8
LAB_001012f8:
MOV RAX,qword ptr [RBX + R12*0x1 + -0x8]
MOV R12,qword ptr [RAX]
LAB_00101300:
MOV RDI,qword ptr [R15]
ADD R15,0x8
CALL 0x00101080
CMP RBP,R15
JNZ 0x00101300
LAB_00101311:
MOV RDI,RBX
CALL 0x00101080
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010132b:
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x1
MOV RAX,qword ptr [RBX + R12*0x1 + -0x8]
MOV R12,qword ptr [RAX]
JMP 0x00101311 | int8 func0(uint param_1)
{
long *plVar1;
long lVar2;
int8 *__ptr;
void *pvVar3;
ulong uVar4;
ulong uVar5;
long lVar6;
long lVar7;
int8 uVar8;
int8 *puVar9;
int8 *puVar10;
lVar7 = (long)(int)(param_1 + 1);
__ptr = (int8 *)malloc(lVar7 * 8);
if ((int)param_1 < 0) {
*(int8 *)*__ptr = 1;
uVar8 = *(int8 *)__ptr[lVar7 + -1];
}
else {
puVar9 = __ptr;
do {
puVar10 = puVar9 + 1;
pvVar3 = malloc(lVar7 * 8);
*puVar9 = pvVar3;
memset(pvVar3,0,(long)(int)param_1 * 8 + 8);
puVar9 = puVar10;
} while (__ptr + (long)(int)param_1 + 1 != puVar10);
*(int8 *)*__ptr = 1;
if (param_1 != 0) {
uVar5 = 1;
lVar6 = 1;
while( true ) {
plVar1 = (long *)__ptr[uVar5];
lVar2 = __ptr[uVar5 - 1];
uVar4 = 0;
*plVar1 = lVar6;
do {
lVar6 = lVar6 + *(long *)(lVar2 + uVar4 * 8);
plVar1[uVar4 + 1] = lVar6;
uVar4 = uVar4 + 1;
} while (uVar4 != uVar5);
if (param_1 == uVar5) break;
lVar6 = plVar1[uVar5];
uVar5 = uVar5 + 1;
}
}
uVar8 = *(int8 *)__ptr[lVar7 + -1];
puVar9 = __ptr;
do {
pvVar3 = (void *)*puVar9;
puVar9 = puVar9 + 1;
free(pvVar3);
} while (__ptr + (long)(int)param_1 + 1 != puVar9);
}
free(__ptr);
return uVar8;
} |
4,164 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n) {
bool increasing = true;
bool decreasing = true;
for (int i = 0; i < n - 1; i++) {
if (A[i] > A[i + 1]) {
increasing = false;
}
if (A[i] < A[i + 1]) {
decreasing = false;
}
}
return increasing || decreasing;
}
| int main() {
int array1[] = {6, 5, 4, 4};
int array2[] = {1, 2, 2, 3};
int array3[] = {1, 3, 2};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == true);
assert(func0(array3, 3) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movb $0x1,-0x6(%rbp)
movb $0x1,-0x5(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11fd <func0+0x94>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 11c1 <func0+0x58>
movb $0x0,-0x6(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 11f9 <func0+0x90>
movb $0x0,-0x5(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 1189 <func0+0x20>
cmpb $0x0,-0x6(%rbp)
jne 1214 <func0+0xab>
cmpb $0x0,-0x5(%rbp)
je 121b <func0+0xb2>
mov $0x1,%eax
jmp 1220 <func0+0xb7>
mov $0x0,%eax
and $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_6], 1
mov [rbp+var_5], 1
mov [rbp+var_4], 0
jmp short loc_11FD
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_11C1
mov [rbp+var_6], 0
loc_11C1:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_11F9
mov [rbp+var_5], 0
loc_11F9:
add [rbp+var_4], 1
loc_11FD:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_4], eax
jl short loc_1189
cmp [rbp+var_6], 0
jnz short loc_1214
cmp [rbp+var_5], 0
jz short loc_121B
loc_1214:
mov eax, 1
jmp short loc_1220
loc_121B:
mov eax, 0
loc_1220:
and eax, 1
pop rbp
retn | _BOOL8 func0(long long a1, int a2)
{
char v4; // [rsp+16h] [rbp-6h]
char v5; // [rsp+17h] [rbp-5h]
int i; // [rsp+18h] [rbp-4h]
v4 = 1;
v5 = 1;
for ( i = 0; i < a2 - 1; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4 * (i + 1LL) + a1) )
v4 = 0;
if ( *(_DWORD *)(4LL * i + a1) < *(_DWORD *)(4 * (i + 1LL) + a1) )
v5 = 0;
}
return v4 || v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV byte ptr [RBP + -0x6],0x1
MOV byte ptr [RBP + -0x5],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011fd
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001011c1
MOV byte ptr [RBP + -0x6],0x0
LAB_001011c1:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001011f9
MOV byte ptr [RBP + -0x5],0x0
LAB_001011f9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011fd:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x00101189
CMP byte ptr [RBP + -0x6],0x0
JNZ 0x00101214
CMP byte ptr [RBP + -0x5],0x0
JZ 0x0010121b
LAB_00101214:
MOV EAX,0x1
JMP 0x00101220
LAB_0010121b:
MOV EAX,0x0
LAB_00101220:
AND EAX,0x1
POP RBP
RET | int4 func0(long param_1,int param_2)
{
bool bVar1;
bool bVar2;
int4 uVar3;
int4 local_c;
bVar1 = true;
bVar2 = true;
for (local_c = 0; local_c < param_2 + -1; local_c = local_c + 1) {
if (*(int *)(param_1 + ((long)local_c + 1) * 4) < *(int *)(param_1 + (long)local_c * 4)) {
bVar1 = false;
}
if (*(int *)(param_1 + (long)local_c * 4) < *(int *)(param_1 + ((long)local_c + 1) * 4)) {
bVar2 = false;
}
}
if ((bVar1) || (bVar2)) {
uVar3 = 1;
}
else {
uVar3 = 0;
}
return uVar3;
} |
4,165 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n) {
bool increasing = true;
bool decreasing = true;
for (int i = 0; i < n - 1; i++) {
if (A[i] > A[i + 1]) {
increasing = false;
}
if (A[i] < A[i + 1]) {
decreasing = false;
}
}
return increasing || decreasing;
}
| int main() {
int array1[] = {6, 5, 4, 4};
int array2[] = {1, 2, 2, 3};
int array3[] = {1, 3, 2};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == true);
assert(func0(array3, 3) == false);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11a9 <func0+0x40>
mov %rdi,%rdx
lea -0x2(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r8
mov $0x1,%eax
mov $0x1,%r9d
mov $0x0,%edi
jmp 119b <func0+0x32>
mov %edi,%r9d
add $0x4,%rdx
cmp %r8,%rdx
je 11b4 <func0+0x4b>
mov (%rdx),%esi
mov 0x4(%rdx),%ecx
cmp %ecx,%esi
jg 118f <func0+0x26>
cmovl %edi,%eax
jmp 1192 <func0+0x29>
mov $0x1,%eax
mov $0x1,%r9d
or %r9d,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_11AA
mov rdx, rdi
lea eax, [rsi-2]
lea r9, [rdi+rax*4+4]
mov edi, 1
mov eax, 1
mov r8d, 0
jmp short loc_119B
loc_118F:
mov eax, r8d
loc_1192:
add rdx, 4
cmp rdx, r9
jz short loc_11B4
loc_119B:
mov esi, [rdx]
mov ecx, [rdx+4]
cmp esi, ecx
jg short loc_118F
cmovl edi, r8d
jmp short loc_1192
loc_11AA:
mov edi, 1
mov eax, 1
loc_11B4:
or eax, edi
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rdx
long long v3; // r9
int v4; // edi
int v5; // eax
int v6; // ecx
if ( a2 <= 1 )
{
v4 = 1;
v5 = 1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 2 + 1];
v4 = 1;
v5 = 1;
do
{
v6 = v2[1];
if ( *v2 > v6 )
{
v5 = 0;
}
else if ( *v2 < v6 )
{
v4 = 0;
}
++v2;
}
while ( v2 != (_DWORD *)v3 );
}
return v4 | (unsigned int)v5;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011aa
MOV RDX,RDI
LEA EAX,[RSI + -0x2]
LEA R9,[RDI + RAX*0x4 + 0x4]
MOV EDI,0x1
MOV EAX,0x1
MOV R8D,0x0
JMP 0x0010119b
LAB_0010118f:
MOV EAX,R8D
LAB_00101192:
ADD RDX,0x4
CMP RDX,R9
JZ 0x001011b4
LAB_0010119b:
MOV ESI,dword ptr [RDX]
MOV ECX,dword ptr [RDX + 0x4]
CMP ESI,ECX
JG 0x0010118f
CMOVL EDI,R8D
JMP 0x00101192
LAB_001011aa:
MOV EDI,0x1
MOV EAX,0x1
LAB_001011b4:
OR EAX,EDI
RET | uint func0(int *param_1,int param_2)
{
int *piVar1;
uint uVar2;
uint uVar3;
if (param_2 < 2) {
uVar3 = 1;
uVar2 = 1;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
uVar3 = 1;
uVar2 = 1;
do {
if (param_1[1] < *param_1) {
uVar2 = 0;
}
else if (*param_1 < param_1[1]) {
uVar3 = 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return uVar2 | uVar3;
} |
4,166 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n) {
bool increasing = true;
bool decreasing = true;
for (int i = 0; i < n - 1; i++) {
if (A[i] > A[i + 1]) {
increasing = false;
}
if (A[i] < A[i + 1]) {
decreasing = false;
}
}
return increasing || decreasing;
}
| int main() {
int array1[] = {6, 5, 4, 4};
int array2[] = {1, 2, 2, 3};
int array3[] = {1, 3, 2};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == true);
assert(func0(array3, 3) == false);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1188 <func0+0x48>
lea -0x2(%rsi),%eax
mov $0x1,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%rdx
mov $0x1,%eax
jmp 116c <func0+0x2c>
cmovl %esi,%eax
add $0x4,%rdi
cmp %rdx,%rdi
je 1180 <func0+0x40>
mov 0x4(%rdi),%r8d
cmp %r8d,(%rdi)
jle 1160 <func0+0x20>
add $0x4,%rdi
xor %ecx,%ecx
cmp %rdx,%rdi
jne 116c <func0+0x2c>
or %ecx,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, 1
jle short loc_12D8
lea eax, [rsi-2]
mov ecx, 1
xor esi, esi
lea rdx, [rdi+rax*4+4]
mov eax, 1
jmp short loc_12BC
loc_12B0:
cmovl eax, esi
add rdi, 4
cmp rdi, rdx
jz short loc_12D0
loc_12BC:
mov r8d, [rdi+4]
cmp [rdi], r8d
jle short loc_12B0
add rdi, 4
xor ecx, ecx
cmp rdi, rdx
jnz short loc_12BC
loc_12D0:
or eax, ecx
retn
loc_12D8:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // ecx
long long v3; // rdx
int v4; // eax
int v5; // r8d
if ( a2 <= 1 )
return 1LL;
v2 = 1;
v3 = (long long)&a1[a2 - 2 + 1];
v4 = 1;
do
{
while ( 1 )
{
v5 = a1[1];
if ( *a1 <= v5 )
break;
++a1;
v2 = 0;
if ( a1 == (_DWORD *)v3 )
return v2 | (unsigned int)v4;
}
if ( *a1 < v5 )
v4 = 0;
++a1;
}
while ( a1 != (_DWORD *)v3 );
return v2 | (unsigned int)v4;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012d8
LEA EAX,[RSI + -0x2]
MOV ECX,0x1
XOR ESI,ESI
LEA RDX,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x1
JMP 0x001012bc
LAB_001012b0:
CMOVL EAX,ESI
ADD RDI,0x4
CMP RDI,RDX
JZ 0x001012d0
LAB_001012bc:
MOV R8D,dword ptr [RDI + 0x4]
CMP dword ptr [RDI],R8D
JLE 0x001012b0
ADD RDI,0x4
XOR ECX,ECX
CMP RDI,RDX
JNZ 0x001012bc
LAB_001012d0:
OR EAX,ECX
RET
LAB_001012d8:
MOV EAX,0x1
RET | uint func0(int *param_1,int param_2)
{
int *piVar1;
uint uVar2;
uint uVar3;
if (param_2 < 2) {
return 1;
}
uVar3 = 1;
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
uVar2 = 1;
do {
while( true ) {
if (*param_1 <= param_1[1]) break;
param_1 = param_1 + 1;
uVar3 = 0;
if (param_1 == piVar1) goto LAB_001012d0;
}
if (*param_1 < param_1[1]) {
uVar2 = 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
LAB_001012d0:
return uVar2 | uVar3;
} |
4,167 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n) {
bool increasing = true;
bool decreasing = true;
for (int i = 0; i < n - 1; i++) {
if (A[i] > A[i + 1]) {
increasing = false;
}
if (A[i] < A[i + 1]) {
decreasing = false;
}
}
return increasing || decreasing;
}
| int main() {
int array1[] = {6, 5, 4, 4};
int array2[] = {1, 2, 2, 3};
int array3[] = {1, 3, 2};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == true);
assert(func0(array3, 3) == false);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1198 <func0+0x58>
lea -0x2(%rsi),%eax
mov (%rdi),%ecx
lea 0x4(%rdi),%rdx
mov $0x1,%r8d
lea 0x8(%rdi,%rax,4),%rdi
xor %r9d,%r9d
mov $0x1,%eax
jmp 117d <func0+0x3d>
nopw 0x0(%rax,%rax,1)
cmovl %r9d,%eax
add $0x4,%rdx
cmp %rdi,%rdx
je 1191 <func0+0x51>
mov %ecx,%esi
mov (%rdx),%ecx
cmp %ecx,%esi
jle 1170 <func0+0x30>
add $0x4,%rdx
xor %r8d,%r8d
cmp %rdi,%rdx
jne 117d <func0+0x3d>
or %r8d,%eax
retq
nopl (%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, 1
jle short loc_1198
lea eax, [rsi-2]
mov ecx, [rdi]
lea rdx, [rdi+4]
mov r8d, 1
lea rdi, [rdi+rax*4+8]
xor r9d, r9d
mov eax, 1
jmp short loc_117D
loc_1170:
cmovl eax, r9d
add rdx, 4
cmp rdi, rdx
jz short loc_1191
loc_117D:
mov esi, ecx
mov ecx, [rdx]
cmp esi, ecx
jle short loc_1170
add rdx, 4
xor r8d, r8d
cmp rdi, rdx
jnz short loc_117D
loc_1191:
or eax, r8d
retn
loc_1198:
mov eax, 1
retn | long long func0(int *a1, int a2)
{
int v2; // ecx
int *v3; // rdx
int v4; // r8d
long long v5; // rdi
int v6; // eax
int v7; // esi
if ( a2 <= 1 )
return 1LL;
v2 = *a1;
v3 = a1 + 1;
v4 = 1;
v5 = (long long)&a1[a2 - 2 + 2];
v6 = 1;
do
{
while ( 1 )
{
v7 = v2;
v2 = *v3;
if ( v7 <= *v3 )
break;
++v3;
v4 = 0;
if ( (int *)v5 == v3 )
return v4 | (unsigned int)v6;
}
if ( v7 < v2 )
v6 = 0;
++v3;
}
while ( (int *)v5 != v3 );
return v4 | (unsigned int)v6;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101198
LEA EAX,[RSI + -0x2]
MOV ECX,dword ptr [RDI]
LEA RDX,[RDI + 0x4]
MOV R8D,0x1
LEA RDI,[RDI + RAX*0x4 + 0x8]
XOR R9D,R9D
MOV EAX,0x1
JMP 0x0010117d
LAB_00101170:
CMOVL EAX,R9D
ADD RDX,0x4
CMP RDI,RDX
JZ 0x00101191
LAB_0010117d:
MOV ESI,ECX
MOV ECX,dword ptr [RDX]
CMP ESI,ECX
JLE 0x00101170
ADD RDX,0x4
XOR R8D,R8D
CMP RDI,RDX
JNZ 0x0010117d
LAB_00101191:
OR EAX,R8D
RET
LAB_00101198:
MOV EAX,0x1
RET | uint func0(int *param_1,int param_2)
{
int iVar1;
uint uVar2;
int iVar3;
int *piVar4;
uint uVar5;
if (param_2 < 2) {
return 1;
}
piVar4 = param_1 + 1;
uVar5 = 1;
uVar2 = 1;
iVar3 = *param_1;
do {
while (iVar1 = *piVar4, iVar1 < iVar3) {
piVar4 = piVar4 + 1;
uVar5 = 0;
iVar3 = iVar1;
if (param_1 + (ulong)(param_2 - 2) + 2 == piVar4) goto LAB_00101191;
}
if (iVar3 < iVar1) {
uVar2 = 0;
}
piVar4 = piVar4 + 1;
iVar3 = iVar1;
} while (param_1 + (ulong)(param_2 - 2) + 2 != piVar4);
LAB_00101191:
return uVar2 | uVar5;
} |
4,168 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int l[], int s[], int len_l, int len_s) {
bool sub_set = false;
if (len_s == 0) {
sub_set = true;
} else if (len_s == len_l) {
bool same = true;
for (int i = 0; i < len_l; i++) {
if (l[i] != s[i]) {
same = false;
break;
}
}
sub_set = same;
} else if (len_s > len_l) {
sub_set = false;
} else {
for (int i = 0; i <= len_l - len_s; i++) {
if (l[i] == s[0]) {
int n = 1;
while (n < len_s && l[i+n] == s[n]) {
n++;
}
if (n == len_s) {
sub_set = true;
break;
}
}
}
}
return sub_set;
}
| int main() {
int l[] = {2, 4, 3, 5, 7};
int s1[] = {3, 7};
int s2[] = {4, 3};
int s3[] = {1, 6};
assert(func0(l, s1, 5, 2) == false);
assert(func0(l, s2, 5, 2) == true);
assert(func0(l, s3, 5, 2) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %ecx,-0x28(%rbp)
movb $0x0,-0xe(%rbp)
cmpl $0x0,-0x28(%rbp)
jne 1192 <func0+0x29>
movb $0x1,-0xe(%rbp)
jmpq 129a <func0+0x131>
mov -0x28(%rbp),%eax
cmp -0x24(%rbp),%eax
jne 11f5 <func0+0x8c>
movb $0x1,-0xd(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11e1 <func0+0x78>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 11dd <func0+0x74>
movb $0x0,-0xd(%rbp)
jmp 11e9 <func0+0x80>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 11a7 <func0+0x3e>
movzbl -0xd(%rbp),%eax
mov %al,-0xe(%rbp)
jmpq 129a <func0+0x131>
mov -0x28(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 1206 <func0+0x9d>
movb $0x0,-0xe(%rbp)
jmpq 129a <func0+0x131>
movl $0x0,-0x8(%rbp)
jmp 128b <func0+0x122>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%rax
mov (%rax),%eax
cmp %eax,%edx
jne 1287 <func0+0x11e>
movl $0x1,-0x4(%rbp)
jmp 123c <func0+0xd3>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x28(%rbp),%eax
jge 1279 <func0+0x110>
mov -0x8(%rbp),%edx
mov -0x4(%rbp),%eax
add %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 1238 <func0+0xcf>
mov -0x4(%rbp),%eax
cmp -0x28(%rbp),%eax
jne 1287 <func0+0x11e>
movb $0x1,-0xe(%rbp)
jmp 129a <func0+0x131>
addl $0x1,-0x8(%rbp)
mov -0x24(%rbp),%eax
sub -0x28(%rbp),%eax
cmp %eax,-0x8(%rbp)
jle 120f <func0+0xa6>
movzbl -0xe(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_28], ecx
mov [rbp+var_E], 0
cmp [rbp+var_28], 0
jnz short loc_1192
mov [rbp+var_E], 1
jmp loc_129A
loc_1192:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_24]
jnz short loc_11F5
mov [rbp+var_D], 1
mov [rbp+var_C], 0
jmp short loc_11E1
loc_11A7:
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_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_11DD
mov [rbp+var_D], 0
jmp short loc_11E9
loc_11DD:
add [rbp+var_C], 1
loc_11E1:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_24]
jl short loc_11A7
loc_11E9:
movzx eax, [rbp+var_D]
mov [rbp+var_E], al
jmp loc_129A
loc_11F5:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_24]
jle short loc_1206
mov [rbp+var_E], 0
jmp loc_129A
loc_1206:
mov [rbp+var_8], 0
jmp short loc_128B
loc_120F:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_20]
mov eax, [rax]
cmp edx, eax
jnz short loc_1287
mov [rbp+var_4], 1
jmp short loc_123C
loc_1238:
add [rbp+var_4], 1
loc_123C:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_28]
jge short loc_1279
mov edx, [rbp+var_8]
mov eax, [rbp+var_4]
add eax, edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_1238
loc_1279:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_28]
jnz short loc_1287
mov [rbp+var_E], 1
jmp short loc_129A
loc_1287:
add [rbp+var_8], 1
loc_128B:
mov eax, [rbp+var_24]
sub eax, [rbp+var_28]
cmp [rbp+var_8], eax
jle loc_120F
loc_129A:
movzx eax, [rbp+var_E]
pop rbp
retn | long long func0(long long a1, _DWORD *a2, int a3, int a4)
{
unsigned __int8 v5; // [rsp+1Ah] [rbp-Eh]
unsigned __int8 v6; // [rsp+1Bh] [rbp-Dh]
int i; // [rsp+1Ch] [rbp-Ch]
int j; // [rsp+20h] [rbp-8h]
int k; // [rsp+24h] [rbp-4h]
v5 = 0;
if ( a4 )
{
if ( a4 == a3 )
{
v6 = 1;
for ( i = 0; i < a3; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) != a2[i] )
return 0;
}
return v6;
}
else if ( a4 <= a3 )
{
for ( j = 0; j <= a3 - a4; ++j )
{
if ( *(_DWORD *)(4LL * j + a1) == *a2 )
{
for ( k = 1; k < a4 && *(_DWORD *)(4LL * (j + k) + a1) == a2[k]; ++k )
;
if ( k == a4 )
return 1;
}
}
}
else
{
return 0;
}
}
else
{
return 1;
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x28],ECX
MOV byte ptr [RBP + -0xe],0x0
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x00101192
MOV byte ptr [RBP + -0xe],0x1
JMP 0x0010129a
LAB_00101192:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x24]
JNZ 0x001011f5
MOV byte ptr [RBP + -0xd],0x1
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011e1
LAB_001011a7:
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 + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001011dd
MOV byte ptr [RBP + -0xd],0x0
JMP 0x001011e9
LAB_001011dd:
ADD dword ptr [RBP + -0xc],0x1
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001011a7
LAB_001011e9:
MOVZX EAX,byte ptr [RBP + -0xd]
MOV byte ptr [RBP + -0xe],AL
JMP 0x0010129a
LAB_001011f5:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x00101206
MOV byte ptr [RBP + -0xe],0x0
JMP 0x0010129a
LAB_00101206:
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010128b
LAB_0010120f:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x00101287
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010123c
LAB_00101238:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010123c:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x28]
JGE 0x00101279
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x00101238
LAB_00101279:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x28]
JNZ 0x00101287
MOV byte ptr [RBP + -0xe],0x1
JMP 0x0010129a
LAB_00101287:
ADD dword ptr [RBP + -0x8],0x1
LAB_0010128b:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,dword ptr [RBP + -0x28]
CMP dword ptr [RBP + -0x8],EAX
JLE 0x0010120f
LAB_0010129a:
MOVZX EAX,byte ptr [RBP + -0xe]
POP RBP
RET | int func0(long param_1,int *param_2,int param_3,int param_4)
{
int local_16;
int local_15;
int local_14;
int local_10;
int local_c;
local_16 = 0;
if (param_4 == 0) {
local_16 = 1;
}
else if (param_4 == param_3) {
local_15 = 1;
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) != param_2[local_14]) {
local_15 = 0;
break;
}
}
local_16 = local_15;
}
else if (param_3 < param_4) {
local_16 = 0;
}
else {
for (local_10 = 0; local_10 <= param_3 - param_4; local_10 = local_10 + 1) {
if (*(int *)(param_1 + (long)local_10 * 4) == *param_2) {
for (local_c = 1;
(local_c < param_4 &&
(*(int *)(param_1 + (long)(local_c + local_10) * 4) == param_2[local_c]));
local_c = local_c + 1) {
}
if (local_c == param_4) {
return 1;
}
}
}
}
return local_16;
} |
4,169 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int l[], int s[], int len_l, int len_s) {
bool sub_set = false;
if (len_s == 0) {
sub_set = true;
} else if (len_s == len_l) {
bool same = true;
for (int i = 0; i < len_l; i++) {
if (l[i] != s[i]) {
same = false;
break;
}
}
sub_set = same;
} else if (len_s > len_l) {
sub_set = false;
} else {
for (int i = 0; i <= len_l - len_s; i++) {
if (l[i] == s[0]) {
int n = 1;
while (n < len_s && l[i+n] == s[n]) {
n++;
}
if (n == len_s) {
sub_set = true;
break;
}
}
}
}
return sub_set;
}
| int main() {
int l[] = {2, 4, 3, 5, 7};
int s1[] = {3, 7};
int s2[] = {4, 3};
int s3[] = {1, 6};
assert(func0(l, s1, 5, 2) == false);
assert(func0(l, s2, 5, 2) == true);
assert(func0(l, s3, 5, 2) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
test %ecx,%ecx
je 123d <func0+0xd4>
push %r14
push %rbp
push %rbx
cmp %edx,%ecx
je 11ac <func0+0x43>
mov $0x0,%eax
jg 121c <func0+0xb3>
sub %ecx,%edx
js 122f <func0+0xc6>
mov (%rsi),%ebx
mov $0x0,%r8d
mov $0x1,%ebp
lea -0x2(%rcx),%r11d
add $0x2,%r11
jmp 11ea <func0+0x81>
test %edx,%edx
jle 1221 <func0+0xb8>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
jmp 11bd <func0+0x54>
mov %rdx,%rax
mov (%rsi,%rax,4),%ebx
cmp %ebx,(%rdi,%rax,4)
jne 1228 <func0+0xbf>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 11ba <func0+0x51>
mov $0x1,%eax
jmp 121c <func0+0xb3>
mov %ebp,%r9d
cmp %r9d,%ecx
je 1236 <func0+0xcd>
add $0x1,%r8d
add $0x4,%rdi
cmp %edx,%r8d
jg 1217 <func0+0xae>
mov %rdi,%r10
cmp %ebx,(%rdi)
jne 11dd <func0+0x74>
cmp $0x1,%ecx
jle 11d5 <func0+0x6c>
mov $0x1,%eax
mov %eax,%r9d
mov (%rsi,%rax,4),%r14d
cmp %r14d,(%r10,%rax,4)
jne 11d8 <func0+0x6f>
lea 0x1(%rax),%r9d
add $0x1,%rax
cmp %r11,%rax
jne 11fb <func0+0x92>
jmp 11d8 <func0+0x6f>
mov $0x0,%eax
pop %rbx
pop %rbp
pop %r14
retq
mov $0x1,%eax
jmp 121c <func0+0xb3>
mov $0x0,%eax
jmp 121c <func0+0xb3>
mov $0x0,%eax
jmp 121c <func0+0xb3>
mov $0x1,%eax
jmp 121c <func0+0xb3>
retq
| func0:
endbr64
mov eax, 1
test ecx, ecx
jz locret_1232
push r14
push rbp
push rbx
cmp ecx, edx
jz short loc_11A7
mov eax, 0
jg loc_1211
sub edx, ecx
js loc_1224
mov ebx, [rsi]
mov r8d, 0
mov ebp, 1
mov r11d, ecx
jmp short loc_11DF
loc_11A7:
test edx, edx
jle short loc_1216
mov edx, edx
mov eax, 0
loc_11B2:
mov ebx, [rsi+rax*4]
cmp [rdi+rax*4], ebx
jnz short loc_121D
add rax, 1
cmp rax, rdx
jnz short loc_11B2
mov eax, 1
jmp short loc_1211
loc_11CA:
mov r9d, ebp
loc_11CD:
cmp ecx, r9d
jz short loc_122B
loc_11D2:
add r8d, 1
add rdi, 4
cmp r8d, edx
jg short loc_120C
loc_11DF:
mov r10, rdi
cmp [rdi], ebx
jnz short loc_11D2
cmp ecx, 1
jle short loc_11CA
mov eax, 1
loc_11F0:
mov r9d, eax
mov r14d, [rsi+rax*4]
cmp [r10+rax*4], r14d
jnz short loc_11CD
lea r9d, [rax+1]
add rax, 1
cmp rax, r11
jnz short loc_11F0
jmp short loc_11CD
loc_120C:
mov eax, 0
loc_1211:
pop rbx
pop rbp
pop r14
retn
loc_1216:
mov eax, 1
jmp short loc_1211
loc_121D:
mov eax, 0
jmp short loc_1211
loc_1224:
mov eax, 0
jmp short loc_1211
loc_122B:
mov eax, 1
jmp short loc_1211
locret_1232:
retn | long long func0(_DWORD *a1, _DWORD *a2, int a3, int a4)
{
long long result; // rax
int v5; // edx
int v6; // r8d
long long v7; // rax
int v8; // r9d
long long i; // rax
result = 1LL;
if ( a4 )
{
if ( a4 == a3 )
{
if ( a3 <= 0 )
{
return 1LL;
}
else
{
v7 = 0LL;
while ( a1[v7] == a2[v7] )
{
if ( ++v7 == a3 )
return 1LL;
}
return 0LL;
}
}
else
{
result = 0LL;
if ( a4 <= a3 )
{
v5 = a3 - a4;
if ( v5 < 0 )
{
return 0LL;
}
else
{
v6 = 0;
while ( 1 )
{
if ( *a1 == *a2 )
{
if ( a4 <= 1 )
{
v8 = 1;
}
else
{
for ( i = 1LL; i != a4; v8 = ++i )
{
v8 = i;
if ( a1[i] != a2[i] )
break;
}
}
if ( a4 == v8 )
break;
}
++v6;
++a1;
if ( v6 > v5 )
return 0LL;
}
return 1LL;
}
}
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST ECX,ECX
JZ 0x00101232
PUSH R14
PUSH RBP
PUSH RBX
CMP ECX,EDX
JZ 0x001011a7
MOV EAX,0x0
JG 0x00101211
SUB EDX,ECX
JS 0x00101224
MOV EBX,dword ptr [RSI]
MOV R8D,0x0
MOV EBP,0x1
MOV R11D,ECX
JMP 0x001011df
LAB_001011a7:
TEST EDX,EDX
JLE 0x00101216
MOV EDX,EDX
MOV EAX,0x0
LAB_001011b2:
MOV EBX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],EBX
JNZ 0x0010121d
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001011b2
MOV EAX,0x1
JMP 0x00101211
LAB_001011ca:
MOV R9D,EBP
LAB_001011cd:
CMP ECX,R9D
JZ 0x0010122b
LAB_001011d2:
ADD R8D,0x1
ADD RDI,0x4
CMP R8D,EDX
JG 0x0010120c
LAB_001011df:
MOV R10,RDI
CMP dword ptr [RDI],EBX
JNZ 0x001011d2
CMP ECX,0x1
JLE 0x001011ca
MOV EAX,0x1
LAB_001011f0:
MOV R9D,EAX
MOV R14D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [R10 + RAX*0x4],R14D
JNZ 0x001011cd
LEA R9D,[RAX + 0x1]
ADD RAX,0x1
CMP RAX,R11
JNZ 0x001011f0
JMP 0x001011cd
LAB_0010120c:
MOV EAX,0x0
LAB_00101211:
POP RBX
POP RBP
POP R14
RET
LAB_00101216:
MOV EAX,0x1
JMP 0x00101211
LAB_0010121d:
MOV EAX,0x0
JMP 0x00101211
LAB_00101224:
MOV EAX,0x0
JMP 0x00101211
LAB_0010122b:
MOV EAX,0x1
JMP 0x00101211
LAB_00101232:
RET | int8 func0(int *param_1,int *param_2,uint param_3,uint param_4)
{
int8 uVar1;
ulong uVar2;
int iVar3;
uint uVar4;
if (param_4 == 0) {
return 1;
}
if (param_4 == param_3) {
if ((int)param_3 < 1) {
uVar1 = 1;
}
else {
uVar2 = 0;
do {
if (param_1[uVar2] != param_2[uVar2]) {
return 0;
}
uVar2 = uVar2 + 1;
} while (uVar2 != param_3);
uVar1 = 1;
}
}
else {
uVar1 = 0;
if ((int)param_4 <= (int)param_3) {
if ((int)(param_3 - param_4) < 0) {
uVar1 = 0;
}
else {
iVar3 = 0;
do {
if (*param_1 == *param_2) {
if ((int)param_4 < 2) {
uVar4 = 1;
}
else {
uVar2 = 1;
do {
uVar4 = (uint)uVar2;
if (param_1[uVar2] != param_2[uVar2]) break;
uVar4 = uVar4 + 1;
uVar2 = uVar2 + 1;
} while (uVar2 != param_4);
}
if (param_4 == uVar4) {
return 1;
}
}
iVar3 = iVar3 + 1;
param_1 = param_1 + 1;
} while (iVar3 <= (int)(param_3 - param_4));
uVar1 = 0;
}
}
}
return uVar1;
} |
4,170 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int l[], int s[], int len_l, int len_s) {
bool sub_set = false;
if (len_s == 0) {
sub_set = true;
} else if (len_s == len_l) {
bool same = true;
for (int i = 0; i < len_l; i++) {
if (l[i] != s[i]) {
same = false;
break;
}
}
sub_set = same;
} else if (len_s > len_l) {
sub_set = false;
} else {
for (int i = 0; i <= len_l - len_s; i++) {
if (l[i] == s[0]) {
int n = 1;
while (n < len_s && l[i+n] == s[n]) {
n++;
}
if (n == len_s) {
sub_set = true;
break;
}
}
}
}
return sub_set;
}
| int main() {
int l[] = {2, 4, 3, 5, 7};
int s1[] = {3, 7};
int s2[] = {4, 3};
int s3[] = {1, 6};
assert(func0(l, s1, 5, 2) == false);
assert(func0(l, s2, 5, 2) == true);
assert(func0(l, s3, 5, 2) == false);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
test %ecx,%ecx
je 1328 <func0+0x78>
push %rbx
cmp %edx,%ecx
je 1330 <func0+0x80>
mov $0x0,%eax
jg 1322 <func0+0x72>
lea -0x2(%rcx),%r10d
mov (%rsi),%r11d
sub %ecx,%edx
xor %r8d,%r8d
add $0x2,%r10
jmp 12ed <func0+0x3d>
nopl 0x0(%rax,%rax,1)
add $0x1,%r8d
add $0x4,%rdi
cmp %r8d,%edx
jl 1354 <func0+0xa4>
cmp %r11d,(%rdi)
jne 12e0 <func0+0x30>
cmp $0x1,%ecx
jle 1358 <func0+0xa8>
mov $0x1,%eax
jmp 130d <func0+0x5d>
xchg %ax,%ax
lea 0x1(%rax),%r9d
add $0x1,%rax
cmp %r10,%rax
je 1318 <func0+0x68>
mov (%rsi,%rax,4),%ebx
mov %eax,%r9d
cmp %ebx,(%rdi,%rax,4)
je 1300 <func0+0x50>
cmp %r9d,%ecx
jne 12e0 <func0+0x30>
mov $0x1,%eax
pop %rbx
retq
nopl 0x0(%rax)
retq
nopl 0x0(%rax)
test %ecx,%ecx
jle 1322 <func0+0x72>
sub $0x1,%ecx
xor %eax,%eax
jmp 134c <func0+0x9c>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rax),%rdx
cmp %rax,%rcx
je 131d <func0+0x6d>
mov %rdx,%rax
mov (%rsi,%rax,4),%ebx
cmp %ebx,(%rdi,%rax,4)
je 1340 <func0+0x90>
xor %eax,%eax
pop %rbx
retq
mov $0x1,%r9d
jmp 1318 <func0+0x68>
| func0:
endbr64
mov eax, 1
test ecx, ecx
jz short locret_1328
push rbx
cmp ecx, edx
jz short loc_1330
mov eax, 0
jg short loc_1322
mov r11d, [rsi]
sub edx, ecx
xor r8d, r8d
movsxd r10, ecx
jmp short loc_12ED
loc_12E0:
add r8d, 1
add rdi, 4
cmp edx, r8d
jl short loc_1351
loc_12ED:
cmp [rdi], r11d
jnz short loc_12E0
cmp ecx, 1
jle short loc_1355
mov eax, 1
jmp short loc_130D
loc_1300:
lea r9d, [rax+1]
add rax, 1
cmp rax, r10
jz short loc_1318
loc_130D:
mov ebx, [rsi+rax*4]
mov r9d, eax
cmp [rdi+rax*4], ebx
jz short loc_1300
loc_1318:
cmp ecx, r9d
jnz short loc_12E0
loc_131D:
mov eax, 1
loc_1322:
pop rbx
retn
locret_1328:
retn
loc_1330:
test ecx, ecx
jle short loc_1322
movsxd rcx, ecx
xor eax, eax
jmp short loc_1349
loc_1340:
add rax, 1
cmp rcx, rax
jz short loc_131D
loc_1349:
mov ebx, [rsi+rax*4]
cmp [rdi+rax*4], ebx
jz short loc_1340
loc_1351:
xor eax, eax
pop rbx
retn
loc_1355:
mov r9d, 1
jmp short loc_1318 | long long func0(_DWORD *a1, _DWORD *a2, int a3, int a4)
{
long long result; // rax
int v5; // edx
int v6; // r8d
long long i; // rax
int v8; // r9d
long long v9; // rax
result = 1LL;
if ( a4 )
{
if ( a4 == a3 )
{
if ( a4 > 0 )
{
v9 = 0LL;
while ( a1[v9] == a2[v9] )
{
if ( a4 == ++v9 )
return 1LL;
}
return 0LL;
}
}
else
{
result = 0LL;
if ( a4 <= a3 )
{
v5 = a3 - a4;
v6 = 0;
while ( 1 )
{
if ( *a1 == *a2 )
{
if ( a4 <= 1 )
{
v8 = 1;
}
else
{
for ( i = 1LL; i != a4; v8 = ++i )
{
v8 = i;
if ( a1[i] != a2[i] )
break;
}
}
if ( a4 == v8 )
break;
}
++v6;
++a1;
if ( v5 < v6 )
return 0LL;
}
return 1LL;
}
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST ECX,ECX
JZ 0x00101328
PUSH RBX
CMP ECX,EDX
JZ 0x00101330
MOV EAX,0x0
JG 0x00101322
MOV R11D,dword ptr [RSI]
SUB EDX,ECX
XOR R8D,R8D
MOVSXD R10,ECX
JMP 0x001012ed
LAB_001012e0:
ADD R8D,0x1
ADD RDI,0x4
CMP EDX,R8D
JL 0x00101351
LAB_001012ed:
CMP dword ptr [RDI],R11D
JNZ 0x001012e0
CMP ECX,0x1
JLE 0x00101355
MOV EAX,0x1
JMP 0x0010130d
LAB_00101300:
LEA R9D,[RAX + 0x1]
ADD RAX,0x1
CMP RAX,R10
JZ 0x00101318
LAB_0010130d:
MOV EBX,dword ptr [RSI + RAX*0x4]
MOV R9D,EAX
CMP dword ptr [RDI + RAX*0x4],EBX
JZ 0x00101300
LAB_00101318:
CMP ECX,R9D
JNZ 0x001012e0
LAB_0010131d:
MOV EAX,0x1
LAB_00101322:
POP RBX
RET
LAB_00101328:
RET
LAB_00101330:
TEST ECX,ECX
JLE 0x00101322
MOVSXD RCX,ECX
XOR EAX,EAX
JMP 0x00101349
LAB_00101340:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x0010131d
LAB_00101349:
MOV EBX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],EBX
JZ 0x00101340
LAB_00101351:
XOR EAX,EAX
POP RBX
RET
LAB_00101355:
MOV R9D,0x1
JMP 0x00101318 | int8 func0(int *param_1,int *param_2,int param_3,int param_4)
{
int8 uVar1;
long lVar2;
int iVar3;
int iVar4;
uVar1 = 1;
if (param_4 == 0) {
return uVar1;
}
if (param_4 == param_3) {
if (0 < param_4) {
lVar2 = 0;
do {
if (param_1[lVar2] != param_2[lVar2]) {
return 0;
}
lVar2 = lVar2 + 1;
} while (param_4 != lVar2);
LAB_0010131d:
uVar1 = 1;
}
}
else {
uVar1 = 0;
if (param_4 <= param_3) {
iVar3 = 0;
do {
if (*param_1 == *param_2) {
if (param_4 < 2) {
iVar4 = 1;
}
else {
lVar2 = 1;
do {
iVar4 = (int)lVar2;
if (param_1[lVar2] != param_2[lVar2]) break;
iVar4 = iVar4 + 1;
lVar2 = lVar2 + 1;
} while (lVar2 != param_4);
}
if (param_4 == iVar4) goto LAB_0010131d;
}
iVar3 = iVar3 + 1;
param_1 = param_1 + 1;
if (param_3 - param_4 < iVar3) {
return 0;
}
} while( true );
}
}
return uVar1;
} |
4,171 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int l[], int s[], int len_l, int len_s) {
bool sub_set = false;
if (len_s == 0) {
sub_set = true;
} else if (len_s == len_l) {
bool same = true;
for (int i = 0; i < len_l; i++) {
if (l[i] != s[i]) {
same = false;
break;
}
}
sub_set = same;
} else if (len_s > len_l) {
sub_set = false;
} else {
for (int i = 0; i <= len_l - len_s; i++) {
if (l[i] == s[0]) {
int n = 1;
while (n < len_s && l[i+n] == s[n]) {
n++;
}
if (n == len_s) {
sub_set = true;
break;
}
}
}
}
return sub_set;
}
| int main() {
int l[] = {2, 4, 3, 5, 7};
int s1[] = {3, 7};
int s2[] = {4, 3};
int s3[] = {1, 6};
assert(func0(l, s1, 5, 2) == false);
assert(func0(l, s2, 5, 2) == true);
assert(func0(l, s3, 5, 2) == false);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
test %ecx,%ecx
je 1318 <func0+0x78>
push %rbx
cmp %edx,%ecx
je 1320 <func0+0x80>
mov $0x0,%eax
jg 1312 <func0+0x72>
lea -0x2(%rcx),%r10d
mov (%rsi),%r11d
sub %ecx,%edx
xor %r8d,%r8d
add $0x2,%r10
jmp 12dd <func0+0x3d>
nopl 0x0(%rax,%rax,1)
add $0x1,%r8d
add $0x4,%rdi
cmp %r8d,%edx
jl 1344 <func0+0xa4>
cmp %r11d,(%rdi)
jne 12d0 <func0+0x30>
cmp $0x1,%ecx
jle 1348 <func0+0xa8>
mov $0x1,%eax
jmp 12fd <func0+0x5d>
xchg %ax,%ax
lea 0x1(%rax),%r9d
add $0x1,%rax
cmp %rax,%r10
je 1308 <func0+0x68>
mov (%rsi,%rax,4),%ebx
mov %eax,%r9d
cmp %ebx,(%rdi,%rax,4)
je 12f0 <func0+0x50>
cmp %r9d,%ecx
jne 12d0 <func0+0x30>
mov $0x1,%eax
pop %rbx
retq
nopl 0x0(%rax)
retq
nopl 0x0(%rax)
test %ecx,%ecx
jle 1312 <func0+0x72>
sub $0x1,%ecx
xor %eax,%eax
jmp 133c <func0+0x9c>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rax),%rdx
cmp %rax,%rcx
je 130d <func0+0x6d>
mov %rdx,%rax
mov (%rsi,%rax,4),%ebx
cmp %ebx,(%rdi,%rax,4)
je 1330 <func0+0x90>
xor %eax,%eax
pop %rbx
retq
mov $0x1,%r9d
jmp 1308 <func0+0x68>
| func0:
endbr64
mov rax, rdi
mov rdi, rsi
mov esi, 1
test ecx, ecx
jz short loc_1320
push rbx
cmp ecx, edx
jz short loc_1328
mov esi, 0
jg short loc_1315
mov r11d, [rdi]
sub edx, ecx
mov rsi, rax
xor r8d, r8d
mov r10d, ecx
jmp short loc_12DD
loc_12D0:
add r8d, 1
add rsi, 4
cmp edx, r8d
jl short loc_1351
loc_12DD:
cmp [rsi], r11d
jnz short loc_12D0
cmp ecx, 1
jle loc_136E
mov eax, 1
jmp short loc_1301
loc_12F8:
add rax, 1
cmp r10, rax
jz short loc_1360
loc_1301:
mov ebx, [rdi+rax*4]
mov r9d, eax
cmp [rsi+rax*4], ebx
jz short loc_12F8
loc_130C:
cmp ecx, eax
jnz short loc_12D0
loc_1310:
mov esi, 1
loc_1315:
mov eax, esi
pop rbx
retn
loc_1320:
mov eax, esi
retn
loc_1328:
test ecx, ecx
jle short loc_1315
movsxd rcx, ecx
xor edx, edx
shl rcx, 2
jmp short loc_1349
loc_1340:
add rdx, 4
cmp rcx, rdx
jz short loc_1310
loc_1349:
mov ebx, [rdi+rdx]
cmp [rax+rdx], ebx
jz short loc_1340
loc_1351:
xor esi, esi
pop rbx
mov eax, esi
retn
loc_1360:
lea eax, [r9+1]
cmp ecx, eax
jnz loc_12D0
jmp short loc_1310
loc_136E:
mov eax, 1
jmp short loc_130C | long long func0(_DWORD *a1, _DWORD *a2, int a3, int a4)
{
unsigned int v6; // esi
int v7; // edx
_DWORD *v8; // rsi
int v9; // r8d
long long v10; // rax
int v11; // r9d
unsigned long long v13; // rdx
long long v14; // rcx
v6 = 1;
if ( !a4 )
return 1LL;
if ( a4 != a3 )
{
v6 = 0;
if ( a4 <= a3 )
{
v7 = a3 - a4;
v8 = a1;
v9 = 0;
while ( 1 )
{
if ( *v8 == *a2 )
{
if ( a4 <= 1 )
{
LODWORD(v10) = 1;
}
else
{
v10 = 1LL;
while ( 1 )
{
v11 = v10;
if ( v8[v10] != a2[v10] )
break;
if ( a4 == ++v10 )
{
if ( a4 != v11 + 1 )
goto LABEL_5;
return 1;
}
}
}
if ( a4 == (_DWORD)v10 )
return 1;
}
LABEL_5:
++v9;
++v8;
if ( v7 < v9 )
return 0LL;
}
}
return v6;
}
if ( a4 <= 0 )
return v6;
v13 = 0LL;
v14 = 4LL * a4;
while ( a1[v13 / 4] == a2[v13 / 4] )
{
v13 += 4LL;
if ( v14 == v13 )
return 1;
}
return 0LL;
} | func0:
ENDBR64
MOV RAX,RDI
MOV RDI,RSI
MOV ESI,0x1
TEST ECX,ECX
JZ 0x00101320
PUSH RBX
CMP ECX,EDX
JZ 0x00101328
MOV ESI,0x0
JG 0x00101315
MOV R11D,dword ptr [RDI]
SUB EDX,ECX
MOV RSI,RAX
XOR R8D,R8D
MOV R10D,ECX
JMP 0x001012dd
LAB_001012d0:
ADD R8D,0x1
ADD RSI,0x4
CMP EDX,R8D
JL 0x00101351
LAB_001012dd:
CMP dword ptr [RSI],R11D
JNZ 0x001012d0
CMP ECX,0x1
JLE 0x0010136e
MOV EAX,0x1
JMP 0x00101301
LAB_001012f8:
ADD RAX,0x1
CMP R10,RAX
JZ 0x00101360
LAB_00101301:
MOV EBX,dword ptr [RDI + RAX*0x4]
MOV R9D,EAX
CMP dword ptr [RSI + RAX*0x4],EBX
JZ 0x001012f8
LAB_0010130c:
CMP ECX,EAX
JNZ 0x001012d0
LAB_00101310:
MOV ESI,0x1
LAB_00101315:
MOV EAX,ESI
POP RBX
RET
LAB_00101320:
MOV EAX,ESI
RET
LAB_00101328:
TEST ECX,ECX
JLE 0x00101315
MOVSXD RCX,ECX
XOR EDX,EDX
SHL RCX,0x2
JMP 0x00101349
LAB_00101340:
ADD RDX,0x4
CMP RCX,RDX
JZ 0x00101310
LAB_00101349:
MOV EBX,dword ptr [RDI + RDX*0x1]
CMP dword ptr [RAX + RDX*0x1],EBX
JZ 0x00101340
LAB_00101351:
XOR ESI,ESI
POP RBX
MOV EAX,ESI
RET
LAB_00101360:
LEA EAX,[R9 + 0x1]
CMP ECX,EAX
JNZ 0x001012d0
JMP 0x00101310
LAB_0010136e:
MOV EAX,0x1
JMP 0x0010130c | int8 func0(int *param_1,int *param_2,uint param_3,uint param_4)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
long lVar4;
int8 uVar5;
int iVar6;
uVar5 = 1;
if (param_4 == 0) {
return 1;
}
if (param_4 == param_3) {
if (0 < (int)param_4) {
lVar4 = 0;
do {
if (*(int *)((long)param_1 + lVar4) != *(int *)((long)param_2 + lVar4)) {
return 0;
}
lVar4 = lVar4 + 4;
} while ((long)(int)param_4 * 4 != lVar4);
LAB_00101310:
uVar5 = 1;
}
}
else {
uVar5 = 0;
if ((int)param_4 <= (int)param_3) {
iVar6 = 0;
do {
if (*param_1 == *param_2) {
if ((int)param_4 < 2) {
uVar3 = 1;
LAB_0010130c:
uVar2 = (uint)uVar3;
}
else {
uVar1 = 1;
do {
uVar3 = uVar1;
if (param_1[uVar3] != param_2[uVar3]) goto LAB_0010130c;
uVar1 = uVar3 + 1;
} while ((ulong)param_4 != uVar3 + 1);
uVar2 = (int)uVar3 + 1;
}
if (param_4 == uVar2) goto LAB_00101310;
}
iVar6 = iVar6 + 1;
param_1 = param_1 + 1;
if ((int)(param_3 - param_4) < iVar6) {
return 0;
}
} while( true );
}
}
return uVar5;
} |
4,172 | func0 | #include <stdio.h>
#include <assert.h>
int find_equal_tuple(int Input[][10], int array_size, int k) {
int flag = 1;
for (int i = 0; i < array_size; ++i) {
int count = 0;
for (int j = 0; j < 10 && (Input[i][j] != 0 || j == 0); ++j) {
count++;
}
if (count != k) {
flag = 0;
break;
}
}
return flag;
}
| char* func0(int Input[][10], int array_size, int k) {
if (find_equal_tuple(Input, array_size, k) == 1) {
return "All tuples have same length";
} else {
return "All tuples do not have same length";
}
}
| int main() {
int Input1[][10] = {{11, 22, 33}, {44, 55, 66}};
int Input2[][10] = {{1, 2, 3}, {4, 5, 6, 7}};
int Input3[][10] = {{1, 2}, {3, 4}};
assert(func0(Input1, 2, 3) == "All tuples have same length");
assert(func0(Input2, 2, 3) == "All tuples do not have same length");
assert(func0(Input3, 2, 2) == "All tuples have same length");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
mov -0x10(%rbp),%edx
mov -0xc(%rbp),%ecx
mov -0x8(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <find_equal_tuple>
cmp $0x1,%eax
jne 1233 <func0+0x38>
lea 0xdd7(%rip),%rax
jmp 123a <func0+0x3f>
lea 0xdee(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov edx, [rbp+var_10]
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov esi, ecx
mov rdi, rax
call find_equal_tuple
cmp eax, 1
jnz short loc_1233
lea rax, aAllTuplesHaveS; "All tuples have same length"
jmp short locret_123A
loc_1233:
lea rax, aAllTuplesDoNot; "All tuples do not have same length"
locret_123A:
leave
retn | const char * func0(long long a1, unsigned int a2, unsigned int a3)
{
if ( (unsigned int)find_equal_tuple(a1, a2, a3) == 1 )
return "All tuples have same length";
else
return "All tuples do not have same length";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV EDX,dword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
CMP EAX,0x1
JNZ 0x00101233
LEA RAX,[0x102008]
JMP 0x0010123a
LAB_00101233:
LEA RAX,[0x102028]
LAB_0010123a:
LEAVE
RET | char * func0(int8 param_1,int4 param_2,int4 param_3)
{
int iVar1;
char *pcVar2;
iVar1 = find_equal_tuple(param_1,param_2,param_3);
if (iVar1 == 1) {
pcVar2 = "All tuples have same length";
}
else {
pcVar2 = "All tuples do not have same length";
}
return pcVar2;
} |
4,173 | func0 | #include <stdio.h>
#include <assert.h>
int find_equal_tuple(int Input[][10], int array_size, int k) {
int flag = 1;
for (int i = 0; i < array_size; ++i) {
int count = 0;
for (int j = 0; j < 10 && (Input[i][j] != 0 || j == 0); ++j) {
count++;
}
if (count != k) {
flag = 0;
break;
}
}
return flag;
}
| char* func0(int Input[][10], int array_size, int k) {
if (find_equal_tuple(Input, array_size, k) == 1) {
return "All tuples have same length";
} else {
return "All tuples do not have same length";
}
}
| int main() {
int Input1[][10] = {{11, 22, 33}, {44, 55, 66}};
int Input2[][10] = {{1, 2, 3}, {4, 5, 6, 7}};
int Input3[][10] = {{1, 2}, {3, 4}};
assert(func0(Input1, 2, 3) == "All tuples have same length");
assert(func0(Input2, 2, 3) == "All tuples do not have same length");
assert(func0(Input3, 2, 2) == "All tuples have same length");
return 0;
}
| O1 | c | func0:
endbr64
callq 1169 <find_equal_tuple>
cmp $0x1,%eax
lea 0xe2b(%rip),%rax
lea 0xe40(%rip),%rdx
cmovne %rdx,%rax
retq
| func0:
endbr64
call find_equal_tuple
cmp eax, 1
lea rax, aAllTuplesHaveS; "All tuples have same length"
lea rdx, aAllTuplesDoNot; "All tuples do not have same length"
cmovnz rax, rdx
retn | const char *func0()
{
bool v0; // zf
const char *result; // rax
v0 = (unsigned int)find_equal_tuple() == 1;
result = "All tuples have same length";
if ( !v0 )
return "All tuples do not have same length";
return result;
} | func0:
ENDBR64
CALL 0x00101169
CMP EAX,0x1
LEA RAX,[0x102004]
LEA RDX,[0x102040]
CMOVNZ RAX,RDX
RET | char * func0(void)
{
int iVar1;
char *pcVar2;
iVar1 = find_equal_tuple();
pcVar2 = "All tuples have same length";
if (iVar1 != 1) {
pcVar2 = "All tuples do not have same length";
}
return pcVar2;
} |
4,174 | func0 | #include <stdio.h>
#include <assert.h>
int find_equal_tuple(int Input[][10], int array_size, int k) {
int flag = 1;
for (int i = 0; i < array_size; ++i) {
int count = 0;
for (int j = 0; j < 10 && (Input[i][j] != 0 || j == 0); ++j) {
count++;
}
if (count != k) {
flag = 0;
break;
}
}
return flag;
}
| char* func0(int Input[][10], int array_size, int k) {
if (find_equal_tuple(Input, array_size, k) == 1) {
return "All tuples have same length";
} else {
return "All tuples do not have same length";
}
}
| int main() {
int Input1[][10] = {{11, 22, 33}, {44, 55, 66}};
int Input2[][10] = {{1, 2, 3}, {4, 5, 6, 7}};
int Input3[][10] = {{1, 2}, {3, 4}};
assert(func0(Input1, 2, 3) == "All tuples have same length");
assert(func0(Input2, 2, 3) == "All tuples do not have same length");
assert(func0(Input3, 2, 2) == "All tuples have same length");
return 0;
}
| O2 | c | func0:
endbr64
lea 0xb79(%rip),%rax
test %esi,%esi
jle 14cf <func0+0x4f>
lea -0x1(%rsi),%eax
lea (%rax,%rax,4),%rax
lea 0x28(%rdi,%rax,8),%rsi
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
mov %eax,%ecx
cmp $0xa,%rax
je 14d0 <func0+0x50>
add $0x1,%rax
mov -0x4(%rdi,%rax,4),%r8d
test %r8d,%r8d
jne 14a5 <func0+0x25>
cmp %ecx,%edx
jne 14d9 <func0+0x59>
add $0x28,%rdi
cmp %rsi,%rdi
jne 14a0 <func0+0x20>
lea 0xb35(%rip),%rax
retq
mov $0xa,%ecx
cmp %ecx,%edx
je 14bf <func0+0x3f>
lea 0xb40(%rip),%rax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea rax, aAllTuplesHaveS; "All tuples have same length"
test esi, esi
jle short locret_141F
lea eax, [rsi-1]
lea rax, [rax+rax*4]
lea rsi, [rdi+rax*8+28h]
nop dword ptr [rax+rax+00h]
loc_13F0:
mov eax, 1
loc_13F5:
mov ecx, eax
cmp rax, 0Ah
jz short loc_1420
add rax, 1
mov r8d, [rdi+rax*4-4]
test r8d, r8d
jnz short loc_13F5
cmp edx, ecx
jnz short loc_1429
loc_140F:
add rdi, 28h ; '('
cmp rdi, rsi
jnz short loc_13F0
lea rax, aAllTuplesHaveS; "All tuples have same length"
locret_141F:
retn
loc_1420:
mov ecx, 0Ah
cmp edx, ecx
jz short loc_140F
loc_1429:
lea rax, aAllTuplesDoNot; "All tuples do not have same length"
retn | const char * func0(long long a1, int a2, int a3)
{
const char *result; // rax
long long v4; // rsi
long long v5; // rax
int v6; // ecx
result = "All tuples have same length";
if ( a2 > 0 )
{
v4 = a1 + 40LL * (unsigned int)(a2 - 1) + 40;
while ( 2 )
{
v5 = 1LL;
while ( 1 )
{
v6 = v5;
if ( v5 == 10 )
break;
++v5;
if ( !*(_DWORD *)(a1 + 4 * v5 - 4) )
{
if ( a3 == v6 )
goto LABEL_7;
return "All tuples do not have same length";
}
}
if ( a3 != 10 )
return "All tuples do not have same length";
LABEL_7:
a1 += 40LL;
if ( a1 != v4 )
continue;
return "All tuples have same length";
}
}
return result;
} | func0:
ENDBR64
LEA RAX,[0x102004]
TEST ESI,ESI
JLE 0x0010141f
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RSI,[RDI + RAX*0x8 + 0x28]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV EAX,0x1
LAB_001013f5:
MOV ECX,EAX
CMP RAX,0xa
JZ 0x00101420
ADD RAX,0x1
MOV R8D,dword ptr [RDI + RAX*0x4 + -0x4]
TEST R8D,R8D
JNZ 0x001013f5
CMP EDX,ECX
JNZ 0x00101429
LAB_0010140f:
ADD RDI,0x28
CMP RDI,RSI
JNZ 0x001013f0
LEA RAX,[0x102004]
LAB_0010141f:
RET
LAB_00101420:
MOV ECX,0xa
CMP EDX,ECX
JZ 0x0010140f
LAB_00101429:
LEA RAX,[0x102040]
RET | char * func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
long lVar3;
if (0 < param_2) {
lVar1 = param_1 + 0x28;
do {
lVar2 = 1;
do {
lVar3 = lVar2;
if (lVar3 == 10) {
if (param_3 == 10) goto LAB_0010140f;
goto LAB_00101429;
}
lVar2 = lVar3 + 1;
} while (*(int *)(param_1 + -4 + (lVar3 + 1) * 4) != 0);
if (param_3 != (int)lVar3) {
LAB_00101429:
return "All tuples do not have same length";
}
LAB_0010140f:
param_1 = param_1 + 0x28;
} while (param_1 != lVar1 + (ulong)(param_2 - 1) * 0x28);
}
return "All tuples have same length";
} |
4,175 | func0 | #include <stdio.h>
#include <assert.h>
int find_equal_tuple(int Input[][10], int array_size, int k) {
int flag = 1;
for (int i = 0; i < array_size; ++i) {
int count = 0;
for (int j = 0; j < 10 && (Input[i][j] != 0 || j == 0); ++j) {
count++;
}
if (count != k) {
flag = 0;
break;
}
}
return flag;
}
| char* func0(int Input[][10], int array_size, int k) {
if (find_equal_tuple(Input, array_size, k) == 1) {
return "All tuples have same length";
} else {
return "All tuples do not have same length";
}
}
| int main() {
int Input1[][10] = {{11, 22, 33}, {44, 55, 66}};
int Input2[][10] = {{1, 2, 3}, {4, 5, 6, 7}};
int Input3[][10] = {{1, 2}, {3, 4}};
assert(func0(Input1, 2, 3) == "All tuples have same length");
assert(func0(Input2, 2, 3) == "All tuples do not have same length");
assert(func0(Input3, 2, 2) == "All tuples have same length");
return 0;
}
| O3 | c | func0:
endbr64
lea 0xba9(%rip),%rax
test %esi,%esi
jle 1517 <func0+0xc7>
lea -0x1(%rsi),%ecx
lea 0x4(%rdi),%rax
lea (%rcx,%rcx,4),%rcx
lea 0x2c(%rdi,%rcx,8),%rsi
jmp 1485 <func0+0x35>
nopl (%rax)
add $0x28,%rax
cmp %rsi,%rax
je 1510 <func0+0xc0>
mov (%rax),%r10d
mov $0x1,%ecx
test %r10d,%r10d
je 1500 <func0+0xb0>
mov 0x4(%rax),%r9d
mov $0x2,%ecx
test %r9d,%r9d
je 1500 <func0+0xb0>
mov 0x8(%rax),%r8d
mov $0x3,%ecx
test %r8d,%r8d
je 1500 <func0+0xb0>
mov 0xc(%rax),%edi
mov $0x4,%ecx
test %edi,%edi
je 1500 <func0+0xb0>
mov 0x10(%rax),%r11d
mov $0x5,%ecx
test %r11d,%r11d
je 1500 <func0+0xb0>
mov 0x14(%rax),%r10d
mov $0x6,%ecx
test %r10d,%r10d
je 1500 <func0+0xb0>
mov 0x18(%rax),%r9d
mov $0x7,%ecx
test %r9d,%r9d
je 1500 <func0+0xb0>
mov 0x1c(%rax),%r8d
mov $0x8,%ecx
test %r8d,%r8d
je 1500 <func0+0xb0>
mov 0x20(%rax),%edi
xor %ecx,%ecx
test %edi,%edi
setne %cl
add $0x9,%ecx
cmp %ecx,%edx
je 1478 <func0+0x28>
lea 0xb11(%rip),%rax
retq
lea 0xaed(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea rax, aAllTuplesHaveS; "All tuples have same length"
test esi, esi
jle locret_12C7
movsxd rsi, esi
lea rax, [rdi+4]
lea rcx, [rsi+rsi*4]
lea rsi, [rdi+rcx*8+4]
jmp short loc_1235
loc_1228:
add rax, 28h ; '('
cmp rax, rsi
jz loc_12C0
loc_1235:
mov r9d, [rax]
mov ecx, 1
test r9d, r9d
jz short loc_12B0
mov r8d, [rax+4]
mov ecx, 2
test r8d, r8d
jz short loc_12B0
mov edi, [rax+8]
mov ecx, 3
test edi, edi
jz short loc_12B0
mov r11d, [rax+0Ch]
mov ecx, 4
test r11d, r11d
jz short loc_12B0
mov r10d, [rax+10h]
mov ecx, 5
test r10d, r10d
jz short loc_12B0
mov r9d, [rax+14h]
mov ecx, 6
test r9d, r9d
jz short loc_12B0
mov r8d, [rax+18h]
mov ecx, 7
test r8d, r8d
jz short loc_12B0
mov edi, [rax+1Ch]
mov ecx, 8
test edi, edi
jz short loc_12B0
cmp dword ptr [rax+20h], 1
sbb ecx, ecx
add ecx, 0Ah
nop dword ptr [rax+00000000h]
loc_12B0:
cmp edx, ecx
jz loc_1228
lea rax, aAllTuplesDoNot; "All tuples do not have same length"
retn
loc_12C0:
lea rax, aAllTuplesHaveS; "All tuples have same length"
locret_12C7:
retn | const char * func0(long long a1, int a2, int a3)
{
const char *result; // rax
_DWORD *v4; // rax
long long v5; // rsi
int v6; // ecx
result = "All tuples have same length";
if ( a2 > 0 )
{
v4 = (_DWORD *)(a1 + 4);
v5 = a1 + 40LL * a2 + 4;
do
{
v6 = 1;
if ( *v4 )
{
v6 = 2;
if ( v4[1] )
{
v6 = 3;
if ( v4[2] )
{
v6 = 4;
if ( v4[3] )
{
v6 = 5;
if ( v4[4] )
{
v6 = 6;
if ( v4[5] )
{
v6 = 7;
if ( v4[6] )
{
v6 = 8;
if ( v4[7] )
v6 = 10 - (v4[8] == 0);
}
}
}
}
}
}
}
if ( a3 != v6 )
return "All tuples do not have same length";
v4 += 10;
}
while ( v4 != (_DWORD *)v5 );
return "All tuples have same length";
}
return result;
} | func0:
ENDBR64
LEA RAX,[0x10202b]
TEST ESI,ESI
JLE 0x001012c7
MOVSXD RSI,ESI
LEA RAX,[RDI + 0x4]
LEA RCX,[RSI + RSI*0x4]
LEA RSI,[RDI + RCX*0x8 + 0x4]
JMP 0x00101235
LAB_00101228:
ADD RAX,0x28
CMP RAX,RSI
JZ 0x001012c0
LAB_00101235:
MOV R9D,dword ptr [RAX]
MOV ECX,0x1
TEST R9D,R9D
JZ 0x001012b0
MOV R8D,dword ptr [RAX + 0x4]
MOV ECX,0x2
TEST R8D,R8D
JZ 0x001012b0
MOV EDI,dword ptr [RAX + 0x8]
MOV ECX,0x3
TEST EDI,EDI
JZ 0x001012b0
MOV R11D,dword ptr [RAX + 0xc]
MOV ECX,0x4
TEST R11D,R11D
JZ 0x001012b0
MOV R10D,dword ptr [RAX + 0x10]
MOV ECX,0x5
TEST R10D,R10D
JZ 0x001012b0
MOV R9D,dword ptr [RAX + 0x14]
MOV ECX,0x6
TEST R9D,R9D
JZ 0x001012b0
MOV R8D,dword ptr [RAX + 0x18]
MOV ECX,0x7
TEST R8D,R8D
JZ 0x001012b0
MOV EDI,dword ptr [RAX + 0x1c]
MOV ECX,0x8
TEST EDI,EDI
JZ 0x001012b0
CMP dword ptr [RAX + 0x20],0x1
SBB ECX,ECX
ADD ECX,0xa
NOP dword ptr [RAX]
LAB_001012b0:
CMP EDX,ECX
JZ 0x00101228
LEA RAX,[0x102008]
RET
LAB_001012c0:
LEA RAX,[0x10202b]
LAB_001012c7:
RET | char * func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = (int *)(param_1 + 4);
do {
iVar2 = 1;
if (((((*piVar1 != 0) && (iVar2 = 2, piVar1[1] != 0)) && (iVar2 = 3, piVar1[2] != 0)) &&
((iVar2 = 4, piVar1[3] != 0 && (iVar2 = 5, piVar1[4] != 0)))) &&
((iVar2 = 6, piVar1[5] != 0 && ((iVar2 = 7, piVar1[6] != 0 && (iVar2 = 8, piVar1[7] != 0)))
))) {
iVar2 = 10 - (uint)(piVar1[8] == 0);
}
if (param_3 != iVar2) {
return "All tuples do not have same length";
}
piVar1 = piVar1 + 10;
} while (piVar1 != (int *)(param_1 + 4 + (long)param_2 * 0x28));
}
return "All tuples have same length";
} |
4,176 | func0 |
#include <stdlib.h>
#include <assert.h>
| void func0(int *nums, int size) {
float shrink_fact = 1.3;
int gaps = size;
int swapped = 1;
int i = 0;
while (gaps > 1 || swapped) {
gaps = (int)((float)gaps / shrink_fact);
swapped = 0;
i = 0;
while (gaps + i < size) {
if (nums[i] > nums[i + gaps]) {
int temp = nums[i];
nums[i] = nums[i + gaps];
nums[i + gaps] = temp;
swapped = 1;
}
i++;
}
}
}
| int main() {
int arr1[] = {5, 15, 37, 25, 79};
int arr2[] = {41, 32, 15, 19, 22};
int arr3[] = {99, 15, 13, 47};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 4);
assert(arr1[0] == 5 && arr1[1] == 15 && arr1[2] == 25 && arr1[3] == 37 && arr1[4] == 79);
assert(arr2[0] == 15 && arr2[1] == 19 && arr2[2] == 22 && arr2[3] == 32 && arr2[4] == 41);
assert(arr3[0] == 13 && arr3[1] == 15 && arr3[2] == 47 && arr3[3] == 99);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movss 0xfc0(%rip),%xmm0
movss %xmm0,-0x8(%rbp)
mov -0x2c(%rbp),%eax
mov %eax,-0x14(%rbp)
movl $0x1,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 127c <func0+0x113>
cvtsi2ssl -0x14(%rbp),%xmm0
divss -0x8(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov %eax,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 126b <func0+0x102>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%ecx
mov -0x14(%rbp),%eax
add %ecx,%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1267 <func0+0xfe>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0xc(%rbp),%edx
mov -0x14(%rbp),%eax
add %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0xc(%rbp),%edx
mov -0x14(%rbp),%eax
add %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
movl $0x1,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0x14(%rbp),%edx
mov -0xc(%rbp),%eax
add %edx,%eax
cmp %eax,-0x2c(%rbp)
jg 11c2 <func0+0x59>
cmpl $0x1,-0x14(%rbp)
jg 119e <func0+0x35>
cmpl $0x0,-0x10(%rbp)
jne 119e <func0+0x35>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
movss xmm0, cs:dword_2120
movss [rbp+var_8], xmm0
mov eax, [rbp+var_2C]
mov [rbp+var_14], eax
mov [rbp+var_10], 1
mov [rbp+var_C], 0
jmp loc_1280
loc_119E:
pxor xmm0, xmm0
cvtsi2ss xmm0, [rbp+var_14]
divss xmm0, [rbp+var_8]
cvttss2si eax, xmm0
mov [rbp+var_14], eax
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_126F
loc_11C6:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov ecx, [rbp+var_C]
mov eax, [rbp+var_14]
add eax, ecx
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_126B
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov edx, [rbp+var_C]
mov eax, [rbp+var_14]
add eax, edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov edx, [rbp+var_C]
mov eax, [rbp+var_14]
add eax, edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
mov [rbp+var_10], 1
loc_126B:
add [rbp+var_C], 1
loc_126F:
mov edx, [rbp+var_14]
mov eax, [rbp+var_C]
add eax, edx
cmp [rbp+var_2C], eax
jg loc_11C6
loc_1280:
cmp [rbp+var_14], 1
jg loc_119E
cmp [rbp+var_10], 0
jnz loc_119E
nop
nop
pop rbp
retn | long long func0(long long a1, int a2)
{
long long result; // rax
int v3; // [rsp+18h] [rbp-14h]
int v4; // [rsp+1Ch] [rbp-10h]
int i; // [rsp+20h] [rbp-Ch]
int v6; // [rsp+28h] [rbp-4h]
result = (unsigned int)a2;
v3 = a2;
v4 = 1;
while ( v3 > 1 || v4 )
{
v3 = (int)(float)((float)v3 / 1.3);
v4 = 0;
for ( i = 0; ; ++i )
{
result = (unsigned int)(v3 + i);
if ( a2 <= (int)result )
break;
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4LL * (i + v3) + a1) )
{
v6 = *(_DWORD *)(4LL * i + a1);
*(_DWORD *)(4LL * i + a1) = *(_DWORD *)(4LL * (i + v3) + a1);
*(_DWORD *)(a1 + 4LL * (i + v3)) = v6;
v4 = 1;
}
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOVSS XMM0,dword ptr [0x00102120]
MOVSS dword ptr [RBP + -0x8],XMM0
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101280
LAB_0010119e:
PXOR XMM0,XMM0
CVTSI2SS XMM0,dword ptr [RBP + -0x14]
DIVSS XMM0,dword ptr [RBP + -0x8]
CVTTSS2SI EAX,XMM0
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010126f
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,ECX
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010126b
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
MOV dword ptr [RBP + -0x10],0x1
LAB_0010126b:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010126f:
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EDX
CMP dword ptr [RBP + -0x2c],EAX
JG 0x001011c6
LAB_00101280:
CMP dword ptr [RBP + -0x14],0x1
JG 0x0010119e
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x0010119e
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2)
{
int4 uVar1;
bool bVar2;
float fVar3;
int4 local_1c;
int4 local_14;
fVar3 = DAT_00102120;
bVar2 = true;
local_1c = param_2;
while ((1 < local_1c || (bVar2))) {
local_1c = (int)((float)local_1c / fVar3);
bVar2 = false;
for (local_14 = 0; local_14 + local_1c < param_2; local_14 = local_14 + 1) {
if (*(int *)(param_1 + (long)(local_1c + local_14) * 4) <
*(int *)(param_1 + (long)local_14 * 4)) {
uVar1 = *(int4 *)(param_1 + (long)local_14 * 4);
*(int4 *)(param_1 + (long)local_14 * 4) =
*(int4 *)(param_1 + (long)(local_1c + local_14) * 4);
*(int4 *)((long)(local_1c + local_14) * 4 + param_1) = uVar1;
bVar2 = true;
}
}
}
return;
} |
4,177 | func0 |
#include <stdlib.h>
#include <assert.h>
| void func0(int *nums, int size) {
float shrink_fact = 1.3;
int gaps = size;
int swapped = 1;
int i = 0;
while (gaps > 1 || swapped) {
gaps = (int)((float)gaps / shrink_fact);
swapped = 0;
i = 0;
while (gaps + i < size) {
if (nums[i] > nums[i + gaps]) {
int temp = nums[i];
nums[i] = nums[i + gaps];
nums[i + gaps] = temp;
swapped = 1;
}
i++;
}
}
}
| int main() {
int arr1[] = {5, 15, 37, 25, 79};
int arr2[] = {41, 32, 15, 19, 22};
int arr3[] = {99, 15, 13, 47};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 4);
assert(arr1[0] == 5 && arr1[1] == 15 && arr1[2] == 25 && arr1[3] == 37 && arr1[4] == 79);
assert(arr2[0] == 15 && arr2[1] == 19 && arr2[2] == 22 && arr2[3] == 32 && arr2[4] == 41);
assert(arr3[0] == 13 && arr3[1] == 15 && arr3[2] == 47 && arr3[3] == 99);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %esi,%edi
mov %esi,%r9d
movss 0xfbd(%rip),%xmm1
lea -0x1(%rsi),%r13d
lea 0x4(%rbx),%r12
mov $0x0,%ebp
mov $0x1,%esi
jmp 11c3 <func0+0x5a>
add $0x4,%rax
cmp %r10,%rax
je 11b8 <func0+0x4f>
mov (%rax),%edx
mov (%rax,%r8,4),%ecx
cmp %ecx,%edx
jle 1197 <func0+0x2e>
mov %ecx,(%rax)
mov %edx,(%rax,%r8,4)
mov %esi,%r11d
jmp 1197 <func0+0x2e>
mov %ebp,%r11d
cmp $0x1,%r9d
jg 11c3 <func0+0x5a>
test %r11d,%r11d
je 11ef <func0+0x86>
pxor %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
divss %xmm1,%xmm0
cvttss2si %xmm0,%r9d
cmp %r9d,%edi
jle 11b5 <func0+0x4c>
mov %rbx,%rax
mov %r13d,%edx
sub %r9d,%edx
lea (%r12,%rdx,4),%r10
mov %ebp,%r11d
movslq %r9d,%r8
jmp 11a0 <func0+0x37>
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
mov rbx, rdi
mov r9d, esi
movss xmm1, cs:dword_2120
lea r13d, [rsi-1]
lea r12, [rdi+4]
mov ebp, 0
mov r11d, 1
jmp short loc_11C0
loc_1196:
add rax, 4
cmp rax, r8
jz short loc_11B5
loc_119F:
mov edx, [rax]
mov ecx, [rax+rdi*4]
cmp edx, ecx
jle short loc_1196
mov [rax], ecx
mov [rax+rdi*4], edx
mov r10d, r11d
jmp short loc_1196
loc_11B2:
mov r10d, ebp
loc_11B5:
cmp r9d, 1
jg short loc_11C0
test r10d, r10d
jz short loc_11EC
loc_11C0:
pxor xmm0, xmm0
cvtsi2ss xmm0, r9d
divss xmm0, xmm1
cvttss2si r9d, xmm0
cmp esi, r9d
jle short loc_11B2
mov rax, rbx
mov edx, r13d
sub edx, r9d
lea r8, [r12+rdx*4]
mov r10d, ebp
movsxd rdi, r9d
jmp short loc_119F
loc_11EC:
pop rbx
pop rbp
pop r12
pop r13
retn | void func0(int *a1, int a2)
{
int v2; // r9d
int *v3; // rax
int v4; // edx
int v5; // ecx
int v6; // r10d
v2 = a2;
do
{
v2 = (int)(float)((float)v2 / 1.3);
if ( a2 <= v2 )
{
v6 = 0;
}
else
{
v3 = a1;
v6 = 0;
do
{
v4 = *v3;
v5 = v3[v2];
if ( *v3 > v5 )
{
*v3 = v5;
v3[v2] = v4;
v6 = 1;
}
++v3;
}
while ( v3 != &a1[a2 - 1 - v2 + 1] );
}
}
while ( v2 > 1 || v6 );
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV R9D,ESI
MOVSS XMM1,dword ptr [0x00102120]
LEA R13D,[RSI + -0x1]
LEA R12,[RDI + 0x4]
MOV EBP,0x0
MOV R11D,0x1
JMP 0x001011c0
LAB_00101196:
ADD RAX,0x4
CMP RAX,R8
JZ 0x001011b5
LAB_0010119f:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + RDI*0x4]
CMP EDX,ECX
JLE 0x00101196
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + RDI*0x4],EDX
MOV R10D,R11D
JMP 0x00101196
LAB_001011b2:
MOV R10D,EBP
LAB_001011b5:
CMP R9D,0x1
JG 0x001011c0
TEST R10D,R10D
JZ 0x001011ec
LAB_001011c0:
PXOR XMM0,XMM0
CVTSI2SS XMM0,R9D
DIVSS XMM0,XMM1
CVTTSS2SI R9D,XMM0
CMP ESI,R9D
JLE 0x001011b2
MOV RAX,RBX
MOV EDX,R13D
SUB EDX,R9D
LEA R8,[R12 + RDX*0x4]
MOV R10D,EBP
MOVSXD RDI,R9D
JMP 0x0010119f
LAB_001011ec:
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(int *param_1,int param_2)
{
int iVar1;
bool bVar2;
float fVar3;
int *piVar4;
int iVar5;
fVar3 = DAT_00102120;
iVar5 = param_2;
do {
iVar5 = (int)((float)iVar5 / fVar3);
if (iVar5 < param_2) {
bVar2 = false;
piVar4 = param_1;
do {
iVar1 = *piVar4;
if (piVar4[iVar5] < iVar1) {
*piVar4 = piVar4[iVar5];
piVar4[iVar5] = iVar1;
bVar2 = true;
}
piVar4 = piVar4 + 1;
} while (piVar4 != param_1 + (ulong)(uint)((param_2 + -1) - iVar5) + 1);
}
else {
bVar2 = false;
}
} while ((1 < iVar5) || (bVar2));
return;
} |
4,178 | func0 |
#include <stdlib.h>
#include <assert.h>
| void func0(int *nums, int size) {
float shrink_fact = 1.3;
int gaps = size;
int swapped = 1;
int i = 0;
while (gaps > 1 || swapped) {
gaps = (int)((float)gaps / shrink_fact);
swapped = 0;
i = 0;
while (gaps + i < size) {
if (nums[i] > nums[i + gaps]) {
int temp = nums[i];
nums[i] = nums[i + gaps];
nums[i + gaps] = temp;
swapped = 1;
}
i++;
}
}
}
| int main() {
int arr1[] = {5, 15, 37, 25, 79};
int arr2[] = {41, 32, 15, 19, 22};
int arr3[] = {99, 15, 13, 47};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 4);
assert(arr1[0] == 5 && arr1[1] == 15 && arr1[2] == 25 && arr1[3] == 37 && arr1[4] == 79);
assert(arr2[0] == 15 && arr2[1] == 19 && arr2[2] == 22 && arr2[3] == 32 && arr2[4] == 41);
assert(arr3[0] == 13 && arr3[1] == 15 && arr3[2] == 47 && arr3[3] == 99);
return 0;
}
| O2 | c | func0:
endbr64
movss 0xe34(%rip),%xmm1
push %rbp
mov %esi,%r9d
lea -0x1(%rsi),%ebp
push %rbx
lea 0x4(%rdi),%rbx
nopl 0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
divss %xmm1,%xmm0
cvttss2si %xmm0,%r9d
cmp %r9d,%esi
jle 1388 <func0+0x88>
mov %ebp,%edx
mov %rdi,%rax
xor %r11d,%r11d
movslq %r9d,%r8
sub %r9d,%edx
lea (%rbx,%rdx,4),%r10
nopl 0x0(%rax)
mov (%rax),%edx
mov (%rax,%r8,4),%ecx
cmp %ecx,%edx
jle 1366 <func0+0x66>
mov %ecx,(%rax)
mov $0x1,%r11d
mov %edx,(%rax,%r8,4)
add $0x4,%rax
cmp %rax,%r10
jne 1350 <func0+0x50>
and $0x1,%r11d
cmp $0x1,%r9d
jg 1320 <func0+0x20>
test %r11b,%r11b
jne 1320 <func0+0x20>
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
xor %r11d,%r11d
jmp 1373 <func0+0x73>
nopl (%rax)
| func0:
endbr64
movss xmm1, cs:dword_2120
push rbp
mov r11, rdi
mov r10d, esi
push rbx
lea ebp, [rsi-1]
lea rbx, [rdi+4]
nop dword ptr [rax+rax+00h]
loc_1310:
pxor xmm0, xmm0
cvtsi2ss xmm0, r10d
divss xmm0, xmm1
cvttss2si r10d, xmm0
cmp esi, r10d
jle short loc_1370
mov edx, ebp
mov rax, r11
xor r9d, r9d
movsxd rdi, r10d
sub edx, r10d
lea r8, [rbx+rdx*4]
nop dword ptr [rax+00000000h]
loc_1340:
mov edx, [rax]
mov ecx, [rax+rdi*4]
cmp edx, ecx
jle short loc_1354
mov [rax], ecx
mov r9d, 1
mov [rax+rdi*4], edx
loc_1354:
add rax, 4
cmp r8, rax
jnz short loc_1340
and r9d, 1
loc_1361:
cmp r10d, 1
jg short loc_1310
test r9b, r9b
jnz short loc_1310
pop rbx
pop rbp
retn
loc_1370:
xor r9d, r9d
jmp short loc_1361 | void func0(int *a1, int a2)
{
int v2; // r10d
int *v3; // rax
char v4; // r9
int v5; // edx
int v6; // ecx
v2 = a2;
do
{
v2 = (int)(float)((float)v2 / 1.3);
if ( a2 <= v2 )
{
v4 = 0;
}
else
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = v3[v2];
if ( *v3 > v6 )
{
*v3 = v6;
v4 = 1;
v3[v2] = v5;
}
++v3;
}
while ( &a1[a2 - 1 - v2 + 1] != v3 );
}
}
while ( v2 > 1 || v4 );
} | func0:
ENDBR64
MOVSS XMM1,dword ptr [0x00102120]
PUSH RBP
MOV R11,RDI
MOV R10D,ESI
PUSH RBX
LEA EBP,[RSI + -0x1]
LEA RBX,[RDI + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101310:
PXOR XMM0,XMM0
CVTSI2SS XMM0,R10D
DIVSS XMM0,XMM1
CVTTSS2SI R10D,XMM0
CMP ESI,R10D
JLE 0x00101370
MOV EDX,EBP
MOV RAX,R11
XOR R9D,R9D
MOVSXD RDI,R10D
SUB EDX,R10D
LEA R8,[RBX + RDX*0x4]
NOP dword ptr [RAX]
LAB_00101340:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + RDI*0x4]
CMP EDX,ECX
JLE 0x00101354
MOV dword ptr [RAX],ECX
MOV R9D,0x1
MOV dword ptr [RAX + RDI*0x4],EDX
LAB_00101354:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101340
AND R9D,0x1
LAB_00101361:
CMP R10D,0x1
JG 0x00101310
TEST R9B,R9B
JNZ 0x00101310
POP RBX
POP RBP
RET
LAB_00101370:
XOR R9D,R9D
JMP 0x00101361 | void func0(int *param_1,int param_2)
{
int iVar1;
bool bVar2;
float fVar3;
int *piVar4;
int iVar5;
fVar3 = DAT_00102120;
iVar5 = param_2;
do {
iVar5 = (int)((float)iVar5 / fVar3);
if (iVar5 < param_2) {
bVar2 = false;
piVar4 = param_1;
do {
iVar1 = *piVar4;
if (piVar4[iVar5] < iVar1) {
*piVar4 = piVar4[iVar5];
bVar2 = true;
piVar4[iVar5] = iVar1;
}
piVar4 = piVar4 + 1;
} while (param_1 + (ulong)(uint)((param_2 + -1) - iVar5) + 1 != piVar4);
}
else {
bVar2 = false;
}
} while ((1 < iVar5) || (bVar2));
return;
} |
4,179 | func0 |
#include <stdlib.h>
#include <assert.h>
| void func0(int *nums, int size) {
float shrink_fact = 1.3;
int gaps = size;
int swapped = 1;
int i = 0;
while (gaps > 1 || swapped) {
gaps = (int)((float)gaps / shrink_fact);
swapped = 0;
i = 0;
while (gaps + i < size) {
if (nums[i] > nums[i + gaps]) {
int temp = nums[i];
nums[i] = nums[i + gaps];
nums[i + gaps] = temp;
swapped = 1;
}
i++;
}
}
}
| int main() {
int arr1[] = {5, 15, 37, 25, 79};
int arr2[] = {41, 32, 15, 19, 22};
int arr3[] = {99, 15, 13, 47};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 4);
assert(arr1[0] == 5 && arr1[1] == 15 && arr1[2] == 25 && arr1[3] == 37 && arr1[4] == 79);
assert(arr2[0] == 15 && arr2[1] == 19 && arr2[2] == 22 && arr2[3] == 32 && arr2[4] == 41);
assert(arr3[0] == 13 && arr3[1] == 15 && arr3[2] == 47 && arr3[3] == 99);
return 0;
}
| O3 | c | func0:
endbr64
movss 0xe64(%rip),%xmm1
push %rbp
mov %esi,%r9d
lea -0x1(%rsi),%ebp
push %rbx
lea 0x4(%rdi),%rbx
nopl 0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
divss %xmm1,%xmm0
cvttss2si %xmm0,%r9d
cmp %r9d,%esi
jle 1358 <func0+0x88>
mov %ebp,%edx
mov %rdi,%rax
xor %r11d,%r11d
movslq %r9d,%r8
sub %r9d,%edx
lea (%rbx,%rdx,4),%r10
nopl 0x0(%rax)
mov (%rax),%edx
mov (%rax,%r8,4),%ecx
cmp %ecx,%edx
jle 1336 <func0+0x66>
mov %ecx,(%rax)
mov $0x1,%r11d
mov %edx,(%rax,%r8,4)
add $0x4,%rax
cmp %rax,%r10
jne 1320 <func0+0x50>
and $0x1,%r11d
cmp $0x1,%r9d
jg 12f0 <func0+0x20>
test %r11b,%r11b
jne 12f0 <func0+0x20>
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
xor %r11d,%r11d
jmp 1343 <func0+0x73>
nopl (%rax)
| func0:
endbr64
movss xmm1, cs:dword_2004
mov r11d, esi
nop
loc_12D0:
pxor xmm0, xmm0
cvtsi2ss xmm0, r11d
divss xmm0, xmm1
cvttss2si r11d, xmm0
cmp esi, r11d
jle short loc_1330
mov edx, esi
mov rax, rdi
xor r10d, r10d
movsxd r8, r11d
sub edx, r11d
lea r9, [rdi+rdx*4]
nop dword ptr [rax+00000000h]
loc_1300:
mov edx, [rax]
mov ecx, [rax+r8*4]
cmp edx, ecx
jle short loc_1316
mov [rax], ecx
mov r10d, 1
mov [rax+r8*4], edx
loc_1316:
add rax, 4
cmp r9, rax
jnz short loc_1300
and r10d, 1
loc_1323:
cmp r11d, 1
jg short loc_12D0
test r10b, r10b
jnz short loc_12D0
retn
loc_1330:
xor r10d, r10d
jmp short loc_1323 | void func0(int *a1, int a2)
{
int v2; // r11d
int *v3; // rax
char v4; // r10
int v5; // edx
int v6; // ecx
v2 = a2;
do
{
v2 = (int)(float)((float)v2 / 1.3);
if ( a2 <= v2 )
{
v4 = 0;
}
else
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = v3[v2];
if ( *v3 > v6 )
{
*v3 = v6;
v4 = 1;
v3[v2] = v5;
}
++v3;
}
while ( &a1[a2 - v2] != v3 );
}
}
while ( v2 > 1 || v4 );
} | func0:
ENDBR64
MOVSS XMM1,dword ptr [0x00102004]
MOV R11D,ESI
NOP
LAB_001012d0:
PXOR XMM0,XMM0
CVTSI2SS XMM0,R11D
DIVSS XMM0,XMM1
CVTTSS2SI R11D,XMM0
CMP ESI,R11D
JLE 0x00101330
MOV EDX,ESI
MOV RAX,RDI
XOR R10D,R10D
MOVSXD R8,R11D
SUB EDX,R11D
LEA R9,[RDI + RDX*0x4]
NOP dword ptr [RAX]
LAB_00101300:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + R8*0x4]
CMP EDX,ECX
JLE 0x00101316
MOV dword ptr [RAX],ECX
MOV R10D,0x1
MOV dword ptr [RAX + R8*0x4],EDX
LAB_00101316:
ADD RAX,0x4
CMP R9,RAX
JNZ 0x00101300
AND R10D,0x1
LAB_00101323:
CMP R11D,0x1
JG 0x001012d0
TEST R10B,R10B
JNZ 0x001012d0
RET
LAB_00101330:
XOR R10D,R10D
JMP 0x00101323 | void func0(int *param_1,int param_2)
{
int iVar1;
bool bVar2;
float fVar3;
int *piVar4;
int iVar5;
fVar3 = DAT_00102004;
iVar5 = param_2;
do {
iVar5 = (int)((float)iVar5 / fVar3);
if (iVar5 < param_2) {
bVar2 = false;
piVar4 = param_1;
do {
iVar1 = *piVar4;
if (piVar4[iVar5] < iVar1) {
*piVar4 = piVar4[iVar5];
bVar2 = true;
piVar4[iVar5] = iVar1;
}
piVar4 = piVar4 + 1;
} while (param_1 + (uint)(param_2 - iVar5) != piVar4);
}
else {
bVar2 = false;
}
} while ((1 < iVar5) || (bVar2));
return;
} |
4,180 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 4 != 2) {
return true;
}
return false;
}
| int main() {
assert(func0(5) == true);
assert(func0(10) == false);
assert(func0(15) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltd
shr $0x1e,%edx
add %edx,%eax
and $0x3,%eax
sub %edx,%eax
cmp $0x2,%eax
je 116e <func0+0x25>
mov $0x1,%eax
jmp 1173 <func0+0x2a>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov edx, [rbp+var_4]
mov eax, edx
sar eax, 1Fh
shr eax, 1Eh
add edx, eax
and edx, 3
sub edx, eax
mov eax, edx
cmp eax, 2
jz short loc_1174
mov eax, 1
jmp short loc_1179
loc_1174:
mov eax, 0
loc_1179:
pop rbp
retn | _BOOL8 func0(int a1)
{
return a1 % 4 != 2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1e
ADD EDX,EAX
AND EDX,0x3
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x2
JZ 0x00101174
MOV EAX,0x1
JMP 0x00101179
LAB_00101174:
MOV EAX,0x0
LAB_00101179:
POP RBP
RET | bool func0(int param_1)
{
return param_1 % 4 != 2;
} |
4,181 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 4 != 2) {
return true;
}
return false;
}
| int main() {
assert(func0(5) == true);
assert(func0(10) == false);
assert(func0(15) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
sar $0x1f,%eax
shr $0x1e,%eax
add %eax,%edi
and $0x3,%edi
sub %eax,%edi
cmp $0x2,%edi
setne %al
retq
| func0:
endbr64
mov eax, edi
sar eax, 1Fh
shr eax, 1Eh
add edi, eax
and edi, 3
sub edi, eax
cmp edi, 2
setnz al
retn | bool func0(int a1)
{
return a1 % 4 != 2;
} | func0:
ENDBR64
MOV EAX,EDI
SAR EAX,0x1f
SHR EAX,0x1e
ADD EDI,EAX
AND EDI,0x3
SUB EDI,EAX
CMP EDI,0x2
SETNZ AL
RET | bool func0(int param_1)
{
return param_1 % 4 != 2;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.