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, ... | 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 * (v... | 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,... | 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;
}
ret... |
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
im... | 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, ... | 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 * (v... | 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,... | 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;
}
ret... |
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,... | 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
... | 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 + -0... | 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_1... |
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 1... | 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 ... | 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... | 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;
... |
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,... | 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... | 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 !... |
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,... | 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 ... | 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 !... |
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... | 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),%e... | 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 ... | 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 ... | 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... | 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] );
}
ret... | 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;
} ... |
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... | 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>
ret... | 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... | 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
{
v... | 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;
*p... |
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... | 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:
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]... | 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... | 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... | 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 (... |
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 ... | 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... | 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... | 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 sh... | 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 )
{
... | 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 dw... | 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);
... |
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 ... | 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... | 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 118... | 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,... | 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;... | 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... | 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;
}
... |
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 ... | 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... | 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... | 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_15... | 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;
... | 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 qw... | 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;
... |
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 ... | 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... | 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 ... | 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, ea... | 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... | 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,... | 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 =... |
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 ... | 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 ... | _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_001011... | 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 (%r... | 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 ... | 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]
AD... | 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;
... | 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 s... | 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)... | 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 ... | 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]
... | 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 p... | 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)... |
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;
... | 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 s... | 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+... | 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
le... | 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;
... | 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
... | 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... |
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;
... | 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 s... | 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,... | 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 ... | 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
_DWOR... | 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 0... | 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) {
... |
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;
... | 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 s... | 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
... | 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 xm... | 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
_DWO... | 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 X... | 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 uVar... |
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),%xm... | 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 ... | 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,... | 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
mo... | 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, [r... | _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 0x001011... | 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 *... |
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
mo... | 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, [r... | _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 0x001011... | 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 *... |
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 = ... | 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... | 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_2... | 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[... | 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]... | 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]) ... |
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 = ... | 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)
m... | 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... | 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;
... | 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 [... | 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) {
piV... |
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 = ... | 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+0x4... | 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, e... | 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;
... | 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 RD... | 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) {
... |
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 = ... | 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+0x4... | 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 ... | 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 = 1L... | 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 + ... | 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 =... |
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) {
m... | 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
cl... | 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+... | 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... | 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 EA... | 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;
}... |
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) {
m... | 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 ... | 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 ... | 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 =... | 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... | 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 ... |
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) {
m... | 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,(... | 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
ad... | 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 <=... | 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,EC... | 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 (pi... |
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) {
m... | 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 $0... | 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 ... | 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
... | 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 0x00101... | /* 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;... |
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")... | 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... | 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]... | 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... | 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... | 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 re... |
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")... | 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 ... | 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 ... | 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;
++*(_D... | 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
... | 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);
}... |
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")... | 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... | 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 ... | 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;
++*(_D... | 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
... | 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 =... |
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")... | 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... | 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, ra... | 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 )
{
v... | 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
... | 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 */
... |
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 <f... | 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],... | 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]
... | 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:
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, 7FFF... | 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 *... | 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 (para... |
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... | 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 r... | 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;
}... |
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 %xm... | 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, ... | 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 resul... | 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,... | /* 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 ... |
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(,%... | 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]
m... | 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)... | 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]
M... | 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;
}
... |
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... | 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
... | 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 ... | 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_... | 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 < i... |
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+0x1... | 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 ... | 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;
}
whi... | 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
... | 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 = iVar... |
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... | 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]... | 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... | 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... | 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 uVar... |
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 && !... | 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
... | 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 && !... | 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 && !... | 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 && !... | 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);
... | 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");
... | 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 12... | 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
... | 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);
}
... | 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 ... | 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... |
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);
... | 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");
... | 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(,%... | 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... | 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 ... | 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,... | 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 + ... |
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);
... | 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");
... | 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 ... | 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... | 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 ... | 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_001... | 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);
... |
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);
... | 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");
... | 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 ... | 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 ... | 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... | 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 R12... | 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 iV... |
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>
ad... | 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 sho... | 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 EA... | 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... | 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);
}
retur... |
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(%r... | 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 %xmm... | 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 r... | 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;
... | 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 ... | 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 {
... |
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;... | 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
clt... | 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
... | 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 =... | 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... | 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... |
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;... | 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
l... | 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 ... | 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; // r... | 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 0x001010... | 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) {
... |
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;... | 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 ... | 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]... | 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; //... | 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... | 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[... |
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;... | 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
m... | 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
movs... | 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 ... | 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 ... | 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;... |
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 || decre... | 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),%ea... | 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 ... | _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) < *(_DW... | 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
MO... | 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;
... |
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 || decre... | 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... | 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, [r... | 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 )... | 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 0x001... | 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 (*para... |
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 || decre... | 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... | 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... | 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;
... | 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... | 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... |
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 || decre... | 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+... | 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
... | 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 = *v... | 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 ... | 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;
... |
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;
... | 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:
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]
... | 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 (... | 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 [R... | 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 ... |
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;
... | 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 ... | 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... | 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
{
... | 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 E... | 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_... |
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;
... | 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 ... | 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 ... | 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] ... | 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,... | 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]) {
retu... |
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;
... | 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 ... | 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 ... | 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 ... | 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 ... | 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)p... |
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 != ... | 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... | 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 0xdd... | 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 ra... | 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,[0x10200... | 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 != ... | 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... | 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 != ... | 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... | 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,%... | 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... | 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 )
{
... | 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 0x00... | 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;
... |
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 != ... | 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... | 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
te... | 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]... | 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 )
{
... | 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 +... | 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, piVar... |
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 + ga... | 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[... | 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
cvttss... | 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_1... | 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);
... | 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_001011... | 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 + ... |
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 + ga... | 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[... | 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),%ed... | 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 ... | 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[... | 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 ED... | 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;
... |
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 + ga... | 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[... | 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,%r... | 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, e... | 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[... | 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 RD... | 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;
... |
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 + ga... | 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[... | 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,%r... | 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... | 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... | 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 [... | 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;
... |
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... | _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
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.