index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
5,482 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
... | int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 1150 <func0+0x10>
cmp %edx,%edi
jge 1160 <func0+0x20>
retq
cmp %edx,%edi
jg 114e <func0+0xe>
cmp %edx,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
nopl 0x0(%rax)
cmp %edx,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_1158
cmp esi, edx
cmovl esi, edx
cmp edi, edx
cmovge eax, esi
retn
loc_1158:
cmp esi, edx
cmovg esi, edx
cmp edi, edx
cmovle eax, esi
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 <= a2 )
{
if ( a2 > a3 )
a2 = a3;
if ( a1 <= a3 )
return (unsigned int)a2;
}
else
{
if ( a2 < a3 )
a2 = a3;
if ( a1 >= a3 )
return (unsigned ... | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x00101158
CMP ESI,EDX
CMOVL ESI,EDX
CMP EDI,EDX
CMOVGE EAX,ESI
RET
LAB_00101158:
CMP ESI,EDX
CMOVG ESI,EDX
CMP EDI,EDX
CMOVLE EAX,ESI
RET | int func0(int param_1,int param_2,int param_3)
{
if (param_2 < param_1) {
if (param_2 < param_3) {
param_2 = param_3;
}
if (param_3 <= param_1) {
param_1 = param_2;
}
return param_1;
}
if (param_3 < param_2) {
param_2 = param_3;
}
if (param_1 <= param_3) {
param_1 = pa... |
5,483 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
... | int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 1150 <func0+0x10>
cmp %edx,%edi
jge 1160 <func0+0x20>
retq
cmp %edx,%edi
jg 114e <func0+0xe>
cmp %edx,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
nopl 0x0(%rax)
cmp %edx,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_1158
cmp esi, edx
cmovl esi, edx
cmp edi, edx
cmovge eax, esi
retn
loc_1158:
cmp esi, edx
cmovg esi, edx
cmp edi, edx
cmovle eax, esi
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 <= a2 )
{
if ( a2 > a3 )
a2 = a3;
if ( a1 <= a3 )
return (unsigned int)a2;
}
else
{
if ( a2 < a3 )
a2 = a3;
if ( a1 >= a3 )
return (unsigned ... | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x00101158
CMP ESI,EDX
CMOVL ESI,EDX
CMP EDI,EDX
CMOVGE EAX,ESI
RET
LAB_00101158:
CMP ESI,EDX
CMOVG ESI,EDX
CMP EDI,EDX
CMOVLE EAX,ESI
RET | int func0(int param_1,int param_2,int param_3)
{
if (param_2 < param_1) {
if (param_2 < param_3) {
param_2 = param_3;
}
if (param_3 <= param_1) {
param_1 = param_2;
}
return param_1;
}
if (param_3 < param_2) {
param_2 = param_3;
}
if (param_1 <= param_3) {
param_1 = pa... |
5,484 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
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 1201 <func0+0x98>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp... | 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_1201
loc_1188:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
cmp... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int v5; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v5 = *(_DWORD *)(4LL * i + a1);
if ( v5 < 0 )
v5 = -v5;
while ( v5 > 0 )
{
v3 += v5 % 10;
v5 /= 1... | 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 0x00101201
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dwo... | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
local_c = *(int *)(param_1 + (long)local_10 * 4);
if (local_c < 0) {
local_c = -local_c;
}
for (; 0 < local_c; local_c = l... |
5,485 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ca <func0+0x61>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%esi
jmp 118c <func0+0x23>
add $0x4,%r8
cmp %rdi,%r8
je 11cf <func0+0x66>
mov (%r8),%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
sub %eax,%edx
test %e... | func0:
endbr64
test esi, esi
jle short loc_11C4
mov r8, rdi
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
mov esi, 0
loc_1181:
mov eax, [r8]
mov edx, eax
neg edx
cmovs edx, eax
test edx, edx
jle short loc_11B8
loc_118F:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ... | long long func0(int *a1, int a2)
{
int *v2; // r8
long long v3; // r9
unsigned int v4; // esi
int v5; // edx
int v6; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
v5 = -*v2;
if ( *v2 > 0 )
v5 = *v2;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c4
MOV R8,RDI
LEA EAX,[RSI + -0x1]
LEA R9,[RDI + RAX*0x4 + 0x4]
MOV ESI,0x0
LAB_00101181:
MOV EAX,dword ptr [R8]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
TEST EDX,EDX
JLE 0x001011b8
LAB_0010118f:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LE... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
iVar5 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar5 = 0;
do {
iVar2 = *param_1;
iVar4 = -iVar2;
if (0 < iVar2) {
iVar4 = iVa... |
5,486 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13ef <func0+0x5f>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r9
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
mov %eax,%ecx
sar $0x1f,%ecx
mov %ecx,%edx
xor %eax,%edx
sub %ecx,%edx
test %eax,%eax
je 13e2 <func0+0x52>
... | func0:
endbr64
test esi, esi
jle short loc_12F7
lea eax, [rsi-1]
xor r8d, r8d
mov esi, 0CCCCCCCDh
lea r9, [rdi+rax*4+4]
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov eax, [rdi]
mov edx, eax
neg edx
cmovs edx, eax
test eax, eax
jz short loc_12EA
nop dword ptr [rax]
... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r8d
long long v3; // r9
unsigned int v4; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[a2 - 1 + 1];
do
{
v4 = -*a1;
if ( (int)*a1 > 0 )
v4 = *a1;
if ( *a1 )
{
do
{
v2 += v4 % 0... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012f7
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
MOV ESI,0xcccccccd
LEA R9,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EAX,dword ptr [RDI]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
TEST EAX,EAX
JZ 0x001012ea
NOP dword ptr [RAX]
LAB_001012d0:
MOV EAX,EDX
IMUL RAX,RSI
SHR RAX,... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
int iVar4;
if (0 < param_2) {
iVar4 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
uVar3 = *param_1;
uVar2 = -uVar3;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
while (uVar3 !=... |
5,487 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
| int func0(int nums[], int length) {
int sum = 0;
for (int i = 0; i < length; i++) {
int n = nums[i];
if(n < 0) n = -n;
while(n > 0) {
sum += n % 10;
n /= 10;
}
}
return sum;
}
| int main() {
int nums1[] = {10, 2, 56};
assert(func0(nums1, 3) == 14);
int nums2[] = {10, 20, 4, 5,70};
assert(func0(nums2, 5) == 19);
int nums3[] = {10, 20, -4, 5,-70};
assert(func0(nums3, 5) == 19);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 139f <func0+0x5f>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r9
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
mov %eax,%ecx
sar $0x1f,%ecx
mov %ecx,%edx
xor %eax,%edx
sub %ecx,%edx
test %eax,%eax
je 1392 <func0+0x52>
... | func0:
endbr64
test esi, esi
jle short loc_1395
movsxd rsi, esi
mov r8d, 0CCCCCCCDh
lea r9, [rdi+rsi*4]
xor esi, esi
nop word ptr [rax+rax+00000000h]
loc_1360:
mov eax, [rdi]
mov edx, eax
neg edx
cmovs edx, eax
test eax, eax
jz short loc_1389
nop dword ptr [rax]
loc_137... | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // r9
unsigned int v3; // esi
unsigned int v4; // edx
if ( a2 <= 0 )
return 0LL;
v2 = &a1[a2];
v3 = 0;
do
{
v4 = -*a1;
if ( (int)*a1 > 0 )
v4 = *a1;
if ( *a1 )
{
do
{
v3 += v4 % 0xA;
v4 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101395
MOVSXD RSI,ESI
MOV R8D,0xcccccccd
LEA R9,[RDI + RSI*0x4]
XOR ESI,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101360:
MOV EAX,dword ptr [RDI]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
TEST EAX,EAX
JZ 0x00101389
NOP dword ptr [RAX]
LAB_00101370:
MOV EAX,EDX
IMUL RAX,R8
SHR RAX,0x23
LEA ECX,[... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
int iVar4;
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar4 = 0;
do {
uVar3 = *param_1;
uVar2 = -uVar3;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
while (uVar3 != 0) {
iVa... |
5,488 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int t... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11D1
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]... | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
*(_DWORD *)(4LL * (int)i + a3) = *(_DWORD *)(4LL * (int)i + a1) ^ *(_DWORD *)(4LL * (int)i + a2);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d1
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(uint *)(param_3 + (long)local_c * 4) =
*(uint *)(param_2 + (long)local_c * 4) ^ *(uint *)(param_1 + (long)local_c * 4);
}
return;
} |
5,489 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int t... | O1 | c | func0:
endbr64
test %ecx,%ecx
jle 118f <func0+0x26>
lea -0x1(%rcx),%r8d
mov $0x0,%eax
mov (%rdi,%rax,4),%ecx
xor (%rsi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 117a <func0+0x11>
retq
| func0:
endbr64
test ecx, ecx
jle short locret_118D
mov ecx, ecx
mov eax, 0
loc_1178:
mov r8d, [rdi+rax*4]
xor r8d, [rsi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rax, rcx
jnz short loc_1178
locret_118D:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a2 + 4 * i) ^ *(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x0010118d
MOV ECX,ECX
MOV EAX,0x0
LAB_00101178:
MOV R8D,dword ptr [RDI + RAX*0x4]
XOR R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101178
LAB_0010118d:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(uint *)(param_3 + uVar1 * 4) =
*(uint *)(param_1 + uVar1 * 4) ^ *(uint *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
return;... |
5,490 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int t... | O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1165 <func0+0x25>
lea -0x1(%rcx),%r8d
xor %eax,%eax
xchg %ax,%ax
mov (%rdi,%rax,4),%ecx
xor (%rsi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 1150 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test ecx, ecx
jle short locret_1425
movsxd rcx, ecx
xor eax, eax
nop dword ptr [rax]
loc_1410:
mov r8d, [rdi+rax*4]
xor r8d, [rsi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rcx, rax
jnz short loc_1410
locret_1425:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a2 + 4 * i) ^ *(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101425
MOVSXD RCX,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101410:
MOV R8D,dword ptr [RDI + RAX*0x4]
XOR R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101410
LAB_00101425:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(uint *)(param_3 + lVar1 * 4) =
*(uint *)(param_1 + lVar1 * 4) ^ *(uint *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
return;
} |
5,491 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[], const int test_tup2[], int res[], int size) {
for(int i = 0; i < size; i++) {
res[i] = test_tup1[i] ^ test_tup2[i];
}
}
| int main() {
int size = 4;
int result[4];
int test_tup1[4] = {10, 4, 6, 9};
int test_tup2[4] = {5, 2, 3, 3};
int expected1[4] = {15, 6, 5, 10};
func0(test_tup1, test_tup2, result, size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected1[i]);
}
int t... | O3 | c | func0:
endbr64
test %ecx,%ecx
jle 120d <func0+0xcd>
lea 0xf(%rdi),%r8
lea -0x1(%rcx),%eax
sub %rdx,%r8
cmp $0x1e,%r8
seta %r9b
cmp $0x2,%eax
seta %r8b
test %r8b,%r9b
je 11f0 <func0+0xb0>
lea 0xf(%rsi),%r8
sub %rdx,%r8
cmp $0x1e,%r8
jbe 11f0 <func0+0xb0>
mov %ecx,%r8d
xor ... | func0:
endbr64
movsxd rax, ecx
mov r8, rsi
mov rsi, rdx
test eax, eax
jle locret_122B
cmp eax, 1
jz loc_1208
lea rcx, [rdi+4]
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea rcx, [r8+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea edx, [rax-1]
mov r... | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
int v7; // r9d
long long v8; // rdx
int v9; // edx
unsigned int v10; // ecx
long long v11; // rcx
result = a4;
if ( a4 > 0 )
{
if ( a4 == 1 || (unsigned long long)(a3 - (a1 + 4)) <= 8 || (unsigned long l... | func0:
ENDBR64
MOVSXD RAX,ECX
MOV R8,RSI
MOV RSI,RDX
TEST EAX,EAX
JLE 0x0010122b
CMP EAX,0x1
JZ 0x00101208
LEA RCX,[RDI + 0x4]
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA RCX,[R8 + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP EDX,0x2
JBE 0x0010122c
MOV ECX,EAX
XOR EDX,EDX
... | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
ulong uVar2;
uint uVar3;
long lVar4;
if (0 < (int)param_4) {
if (((param_4 == 1) || ((ulong)(param_3 - (param_1 + 4)) < 9)) ||
((ulong)(param_3 - (param_2 + 4)) < 9)) {
lVar4 = 0;
do {
*(uint *)(p... |
5,492 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of ... | int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 129a <func0+0xb5>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
jmp loc_1298
loc_1202:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx... | long long func0(_DWORD *a1, int a2)
{
int i; // [rsp+10h] [rbp-10h]
unsigned int v4; // [rsp+14h] [rbp-Ch]
int j; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( a1[2 * i] > a1[2 * i + 1] )
{
v6 = a1[2 * i];
a1[2 * i] = a1[2 * i + 1];
a1[2 * ... | 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 + -0x10],0x0
JMP 0x00101298
LAB_00101202:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP ... | int func0(void *param_1,int param_2)
{
int4 uVar1;
int local_18;
int local_14;
int local_10;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
if (*(int *)((long)param_1 + (long)local_18 * 8 + 4) <
*(int *)((long)param_1 + (long)local_18 * 8)) {
uVar1 = *(int4 *)((long)pa... |
5,493 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of ... | int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%ebx
test %esi,%esi
jle 11d8 <func0+0x39>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x8(%rdi,%rdx,8),%rsi
jmp 11c8 <func0+0x29>
add $0x8,%rax
cmp %rsi,%rax
je 121a <func0+0x7b>
mov (%rax),%edx
mov 0x4(%rax)... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
test esi, esi
jle short loc_11D8
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*8+8]
jmp short loc_11C8
loc_11BF:
add rax, 8
cmp rax, rsi
jz short loc_121A
loc_11C8:
mov edx, [rax]
mov ec... | long long func0(int *a1, int a2)
{
int *v3; // rax
long long v4; // rsi
int v5; // edx
int v6; // ecx
unsigned int v7; // edx
int *v9; // rax
if ( a2 <= 0 )
{
qsort(a1, a2, 8LL, cmp);
return a2 != 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[2 * (a2 - 1) + 2];
do
{
v5 =... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
TEST ESI,ESI
JLE 0x001011d8
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x8 + 0x8]
JMP 0x001011c8
LAB_001011bf:
ADD RAX,0x8
CMP RAX,RSI
JZ 0x0010121a
LAB_001011c8:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x001011b... | uint func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
uint uVar3;
if (param_2 < 1) {
qsort(param_1,(long)param_2,8,cmp);
uVar3 = (uint)(param_2 != 0);
}
else {
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar... |
5,494 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of ... | int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O2 | c | func0:
endbr64
movslq %esi,%r8
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %r8,%rbx
test %r8d,%r8d
jle 13d8 <func0+0xa8>
lea -0x1(%r8),%edx
lea 0x8(%rdi),%r12
mov %rdi,%rax
lea (%r12,%rdx,8),%rsi
nopl 0x0(%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 136e <fun... | func0:
endbr64
movsxd r8, esi
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, r8
test r8d, r8d
jle loc_13D8
lea edx, [r8-1]
lea r12, [rdi+8]
mov rax, rdi
lea rsi, [r12+rdx*8]
nop dword ptr [rax+00000000h]
loc_1360:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jl... | long long func0(int *a1, int a2)
{
int *v2; // rax
int v3; // edx
int v4; // ecx
int *v5; // rax
unsigned int v6; // r8d
long long v7; // rdx
if ( a2 <= 0 )
{
qsort(a1, a2, 8LL, cmp);
return a2 != 0;
}
else
{
v2 = a1;
do
{
v3 = *v2;
v4 = v2[1];
if ( *v2 > v4... | func0:
ENDBR64
MOVSXD R8,ESI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,R8
TEST R8D,R8D
JLE 0x001013d8
LEA EDX,[R8 + -0x1]
LEA R12,[RDI + 0x8]
MOV RAX,RDI
LEA RSI,[R12 + RDX*0x8]
NOP dword ptr [RAX]
LAB_00101360:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x0010136e
MOV dword ptr [RAX],EC... | uint func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
uint uVar3;
if (param_2 < 1) {
qsort(param_1,(long)param_2,8,cmp);
return (uint)(param_2 != 0);
}
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
... |
5,495 | func0 |
#include <assert.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
int *pair_a = (int *)a;
int *pair_b = (int *)b;
if(pair_a[0] != pair_b[0])
return pair_a[0] - pair_b[0];
return pair_a[1] - pair_b[1];
}
| int func0(int test_list[][2], int n) {
// Sort each pair
for(int i = 0; i < n; i++) {
if(test_list[i][0] > test_list[i][1]) {
int temp = test_list[i][0];
test_list[i][0] = test_list[i][1];
test_list[i][1] = temp;
}
}
// Sort the list of ... | int main() {
int test1[][2] = {{3,4}, {1,2}, {4,3}, {5,6}};
assert(func0(test1, 4) == 3);
int test2[][2] = {{4,15}, {2,3}, {5,4}, {6,7}};
assert(func0(test2, 4) == 4);
int test3[][2] = {{5,16}, {2,3}, {6,5}, {6,9}};
assert(func0(test3, 4) == 4);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
movslq %esi,%r8
mov %rdi,%rbp
push %rbx
mov %r8,%rbx
sub $0x8,%rsp
test %r8d,%r8d
jle 13a8 <func0+0xd8>
lea -0x1(%r8),%edx
mov %rdi,%rax
lea 0x8(%rdi,%rdx,8),%rsi
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 130e <func0+0x3e... | func0:
endbr64
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
sub rsp, 8
test edi, edi
jle loc_13E0
mov rax, rbx
lea rsi, [rbx+rdi*8]
nop word ptr [rax+rax+00h]
loc_12F8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ... | long long func0(__m128i *base, int a2)
{
size_t v3; // rdi
__m128i *v5; // rax
__m128i *v6; // rsi
__m128i v7; // xmm0
__int32 v8; // edi
__int32 *v9; // rcx
unsigned int v10; // edx
int v11; // esi
long long v12; // rax
__int32 v13; // r8d
v3 = a2;
if ( a2 <= 0 )
{
qsort(base, a2, 8uLL,... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SUB RSP,0x8
TEST EDI,EDI
JLE 0x001013e0
MOV RAX,RBX
LEA RSI,[RBX + RDI*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001012f8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x00101316
PSHUFD XMM0,XMM0,0xe1
MOVQ... | uint func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
long lVar3;
uint uVar4;
int iVar5;
size_t __nmemb;
int iVar6;
__nmemb = (size_t)param_2;
if (param_2 < 1) {
qsort(param_1,__nmemb,8,cmp);
return (uint)(param_2 != 0);
}
piVar2 = param_1;
do {
iVar1 = (int)*(int8 *)piV... |
5,496 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f7 <func0+0x8e>
movl $0x0,-0x4(%rbp)
jmp 11ed <func0+0x84>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_8], 0
jmp short loc_11F7
loc_1189:
mov [rbp+var_4], 0
jmp short loc_11ED
loc_1192:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov ... | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+24h] [rbp-8h]
int j; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
for ( j = 0; j <= 1; ++j )
*(_DWORD *)(8LL * (int)i + a3 + 4LL... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f7
LAB_00101189:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ed
LAB_00101192:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
... | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_10;
int4 local_c;
for (local_10 = 0; local_10 < param_4; local_10 = local_10 + 1) {
for (local_c = 0; local_c < 2; local_c = local_c + 1) {
*(int *)(param_3 + (long)local_10 * 8 + (long)local_c * 4) =
*(int *)((lo... |
5,497 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
... | O1 | c | func0:
endbr64
test %ecx,%ecx
jle 119b <func0+0x32>
lea -0x1(%rcx),%r8d
mov $0x0,%eax
mov (%rsi,%rax,8),%ecx
add (%rdi,%rax,8),%ecx
mov %ecx,(%rdx,%rax,8)
mov 0x4(%rsi,%rax,8),%ecx
add 0x4(%rdi,%rax,8),%ecx
mov %ecx,0x4(%rdx,%rax,8)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 1... | func0:
endbr64
test ecx, ecx
jle short locret_1197
mov r8d, ecx
mov eax, 0
loc_1179:
mov ecx, [rsi+rax*8]
add ecx, [rdi+rax*8]
mov [rdx+rax*8], ecx
mov ecx, [rsi+rax*8+4]
add ecx, [rdi+rax*8+4]
mov [rdx+rax*8+4], ecx
add rax, 1
cmp rax, r8
jnz short loc_1179
locret_119... | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
*(_DWORD *)(a3 + 8 * i) = *(_DWORD *)(a1 + 8 * i) + *(_DWORD *)(a2 + 8 * i);
*(_DWORD *)(a3 + 8 * i + 4) = *(_DWORD *)(a1 + 8 * i + 4) + *(_DWORD *)(a2 + 8 * i +... | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101197
MOV R8D,ECX
MOV EAX,0x0
LAB_00101179:
MOV ECX,dword ptr [RSI + RAX*0x8]
ADD ECX,dword ptr [RDI + RAX*0x8]
MOV dword ptr [RDX + RAX*0x8],ECX
MOV ECX,dword ptr [RSI + RAX*0x8 + 0x4]
ADD ECX,dword ptr [RDI + RAX*0x8 + 0x4]
MOV dword ptr [RDX + RAX*0x8 + 0x4],ECX
ADD RAX,0x1
CMP R... | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 8) = *(int *)(param_2 + uVar1 * 8) + *(int *)(param_1 + uVar1 * 8);
*(int *)(param_3 + 4 + uVar1 * 8) =
*(int *)(param_2 + 4 + uVar1 * ... |
5,498 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
... | O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1591 <func0+0x31>
lea -0x1(%rcx),%r8d
xor %eax,%eax
xchg %ax,%ax
mov (%rsi,%rax,8),%ecx
add (%rdi,%rax,8),%ecx
mov %ecx,(%rdx,%rax,8)
mov 0x4(%rsi,%rax,8),%ecx
add 0x4(%rdi,%rax,8),%ecx
mov %ecx,0x4(%rdx,%rax,8)
mov %rax,%rcx
add $0x1,%rax
cmp %r... | func0:
endbr64
test ecx, ecx
jle short locret_157E
movsxd r8, ecx
xor eax, eax
nop dword ptr [rax]
loc_1560:
mov ecx, [rsi+rax*8]
add ecx, [rdi+rax*8]
mov [rdx+rax*8], ecx
mov ecx, [rsi+rax*8+4]
add ecx, [rdi+rax*8+4]
mov [rdx+rax*8+4], ecx
add rax, 1
cmp r8, rax
jnz ... | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
*(_DWORD *)(a3 + 8 * i) = *(_DWORD *)(a1 + 8 * i) + *(_DWORD *)(a2 + 8 * i);
*(_DWORD *)(a3 + 8 * i + 4) = *(_DWORD *)(a1 + 8 * i + 4) + *(_DWORD *)(a2 + 8 * i +... | func0:
ENDBR64
TEST ECX,ECX
JLE 0x0010157e
MOVSXD R8,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101560:
MOV ECX,dword ptr [RSI + RAX*0x8]
ADD ECX,dword ptr [RDI + RAX*0x8]
MOV dword ptr [RDX + RAX*0x8],ECX
MOV ECX,dword ptr [RSI + RAX*0x8 + 0x4]
ADD ECX,dword ptr [RDI + RAX*0x8 + 0x4]
MOV dword ptr [RDX + RAX*0x8 + 0x4]... | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1 * 8) = *(int *)(param_2 + lVar1 * 8) + *(int *)(param_1 + lVar1 * 8);
*(int *)(param_3 + 4 + lVar1 * 8) =
*(int *)(param_2 + 4 + lVar1 * 8) + *(... |
5,499 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup1[][2], const int test_tup2[][2], int result[][2], int size) {
for (int i = 0; i < size; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = test_tup1[i][j] + test_tup2[i][j];
}
}
}
| int main() {
int size = 4;
int res[4][2];
int test_tup1[][2] = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
int test_tup2[][2] = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
int expected[][2] = {{7, 10}, {7, 14}, {3, 10}, {8, 13}};
func0(test_tup1, test_tup2, res, size);
for (int i = 0; i < size; i++)
... | O3 | c | func0:
endbr64
test %ecx,%ecx
jle 1521 <func0+0xb1>
lea 0xf(%rsi),%rax
sub %rdx,%rax
cmp $0x1e,%rax
seta %r8b
cmp $0x1,%ecx
setne %al
test %al,%r8b
je 14f5 <func0+0x85>
lea 0xf(%rdi),%rax
sub %rdx,%rax
cmp $0x1e,%rax
jbe 14f5 <func0+0x85>
mov %ecx,%eax
xor %r8d,%r8d
shr %e... | func0:
endbr64
test ecx, ecx
jle locret_11EC
lea rax, [rdi+0Fh]
sub rax, rdx
cmp rax, 1Eh
jbe short loc_11B9
lea rax, [rsi+0Fh]
sub rax, rdx
cmp rax, 1Eh
jbe short loc_11B9
cmp ecx, 1
jz loc_11EE
mov r8d, ecx
xor eax, eax
shr r8d, 1
shl r8, 4
nop dword... | void func0(long long a1, long long a2, long long a3, int a4)
{
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rcx
if ( a4 > 0 )
{
if ( (unsigned long long)(a1 + 15 - a3) <= 0x1E || (unsigned long long)(a2 + 15 - a3) <= 0x1E )
{
v6 = 0LL;
v7 = 8LL * a4;
... | func0:
ENDBR64
TEST ECX,ECX
JLE 0x001011ec
LEA RAX,[RDI + 0xf]
SUB RAX,RDX
CMP RAX,0x1e
JBE 0x001011b9
LEA RAX,[RSI + 0xf]
SUB RAX,RDX
CMP RAX,0x1e
JBE 0x001011b9
CMP ECX,0x1
JZ 0x001011ee
MOV R8D,ECX
XOR EAX,EAX
SHR R8D,0x1
SHL R8,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RDI + RAX*0x1]
... | void func0(long param_1,long param_2,long param_3,uint param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
long lVar12;
ulong uVar13;
if (0 < (int)param_4) {
if ((0x1e < (ulong)((param_1 + 0xf) ... |
5,500 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %edx,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x48(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov [rbp+var_3C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_38]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp... | long long func0(int a1, int a2, int a3)
{
unsigned long long v3; // rax
void *v4; // rsp
int v5; // eax
_BYTE v7[4]; // [rsp+8h] [rbp-40h] BYREF
int v8; // [rsp+Ch] [rbp-3Ch]
int v9; // [rsp+10h] [rbp-38h]
int v10; // [rsp+14h] [rbp-34h]
int i; // [rsp+24h] [rbp-24h]
int j; // [rsp+28h] [rbp-20h]
i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV dword ptr [RBP + -0x3c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword... | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
int local_40;
int local_3c;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_3c = param_1;
local_40... |
5,501 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edx,%r8d
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov r10d, edi
mov r9d, esi
mov esi, edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea eax, [r9+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h... | long long func0(int a1, int a2, int a3)
{
signed long long v3; // rax
void *v4; // rsp
_DWORD *v5; // rax
int v6; // r10d
int v7; // r8d
int v8; // eax
long long v9; // rdi
int *v10; // rcx
int *v11; // rdi
_DWORD v14[2]; // [rsp+8h] [rbp-20h] BYREF
unsigned long long v15; // [rsp+10h] [rbp-18h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV R10D,EDI
MOV R9D,ESI
MOV ESI,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA EAX,[R9 + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011ae:
CMP RSP,RDX
JZ 0x001011c5... | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
int4 *puVar4;
int *piVar5;
int1 *puVar6;
int iVar7;
long in_FS_OFFSET;
int1 auStack_28 [8];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_2 + 1) * 4 + 0xf;
for (puVar6 = a... |
5,502 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %edx,%r8d
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xffffffffff... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15d, edi
push r14
push r13
push r12
mov r12d, esi
push rbx
mov ebx, edx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rsi+1]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, ... | long long func0(int a1, int a2, int a3)
{
long long v6; // rdx
_DWORD *v7; // rcx
__int16 v8; // dx
signed long long v9; // rdx
void *v10; // rsp
_DWORD *v11; // r9
int v12; // edi
int v13; // eax
long long v14; // rsi
_DWORD *v15; // rcx
long long v16; // rsi
int v17; // eax
_DWORD v20[1022]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15D,EDI
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RSI + 0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
C... | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
int1 *puVar3;
int *piVar4;
int *piVar5;
ulong uVar6;
int1 *puVar7;
int iVar9;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int1 *puVar8;
puVar7 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uV... |
5,503 | func0 | #include <assert.h>
| int func0(int n, int r, int p) {
int C[r+1];
for (int i = 0; i <= r; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
mov %edi,%r15d
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbx
mov %edx,%ebx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi),%eax
mov %rsp,%rdi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%r... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15d, edi
push r14
push r13
push r12
mov r12d, esi
push rbx
mov ebx, edx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rsi+1]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, ... | long long func0(int a1, int a2, int a3)
{
long long v5; // rdx
_DWORD *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
_DWORD *v10; // r10
int v11; // r9d
int v12; // r8d
int v13; // eax
long long v14; // rdi
_DWORD *v15; // rcx
int v16; // esi
long long v17; // rdi
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15D,EDI
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RSI + 0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
C... | int4 func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long lVar2;
int iVar3;
int *puVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
int *puVar8;
int iVar10;
int iVar11;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int *puVar9;
puVar8 = auStack_48;
local_40 = *(long *)(... |
5,504 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcom... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe19(%rip),%rax
mov %rax,-0x58(%rbp)
cmpq $0x0,-0x68(%rbp)
jne 1201 <func0+0x38>
mov $0x0,%eax
jmp 1266 <func0+0x9d>
mov -0x58(%rbp),%rcx
lea -0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aHttpHttpsWwwAZ; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
mov [rbp+pattern], rax
cmp [rbp+string], 0
jnz short loc_1201
mov eax, 0
jmp ... | _BOOL8 func0(const char *a1)
{
bool v2; // [rsp+13h] [rbp-5Dh]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( !a1 )
return 0LL;
if ( regcomp(
&preg,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
CMP qword ptr [RBP + -0x68],0x0
JNZ 0x00101201
MOV EAX,0x0
JMP 0x00101266
LAB_00101201:
MOV RCX,qword ptr [RBP + -0x5... | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 == (char *)0x0) {
bVar2 = false;
}
else {
iVar1 = regcomp(&local_58,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+... |
5,505 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcom... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov $0x0,%ebp
test %rdi,%rdi
je 120a <func0+0x41>
mov %rdi,%rbx
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe07(%rip),%rsi
callq 10c0 <regcomp@plt>
test %eax,%eax
je 1225 <... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov ebp, 0
test rdi, rdi
jz short loc_120A
mov rbx, rdi
mov rdi, rsp
mov edx, 1
lea rsi, aHttpHttpsWwwAZ; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
call ... | long long func0(long long a1)
{
unsigned int v1; // ebp
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
v1 = 0;
if ( a1
&& !(unsigned int)regcomp(
v3,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-z... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV EBP,0x0
TEST RDI,RDI
JZ 0x0010120a
MOV RBX,RDI
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102008]
CALL 0x001010c0
TEST EAX,EAX
JZ 0x00101225
LAB_0010120a:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qwor... | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
bVar2 = false;
if (param_1 != (char *)0x0) {
iVar1 = regcomp(&rStack_68,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,25... |
5,506 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcom... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
return 0;
}
| O2 | c | func0:
endbr64
test %rdi,%rdi
je 1300 <func0+0x10>
jmpq 1270 <func0.part.0>
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
push r13
mov edx, 1
lea rsi, aHttpHttpsWwwAZ; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
xor r13d, r13d
push r12
push rbp
mov rbp, rdi
sub rsp, 50h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
test e... | long long func0_part_0(long long a1)
{
unsigned int v1; // r13d
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v1 = 0;
v3[9] = __readfsqword(0x28u);
if ( !(unsigned int)regcomp(
v3,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-... | func0.part.0:
PUSH R13
MOV EDX,0x1
LEA RSI,[0x102008]
XOR R13D,R13D
PUSH R12
PUSH RBP
MOV RBP,RDI
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x001012ca
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RDI,R12
MOV RSI,RBP
CALL 0x001... | bool func0_part_0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t rStack_68;
long local_20;
bVar2 = false;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-... |
5,507 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char *str) {
regex_t regex;
const char *pattern = "((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)";
int result;
bool match;
if (str == NULL) {
return false;
}
result = regcom... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
xor %r12d,%r12d
push %rbp
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
test %rdi,%rdi
je 1333 <func0+0x43>
mov %rsp,%r13
mov %rdi,%rbp
mov $0x1,%edx
lea 0xce1(%rip),%rsi
mov %r13,%rdi
callq 10c0 <regcomp@plt>
test %eax... | func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
test rdi, rdi
jz short loc_12AD
mov rbp, rsp
mov rbx, rdi
mov edx, 1; cflags
lea rsi, pattern; "((http|https)://)(www.)?[a-zA-Z0-9@:%._"...
mov rdi, rbp; preg
call _r... | long long func0(char *string)
{
unsigned int v1; // ebx
regex_t v3; // [rsp+0h] [rbp-68h] BYREF
unsigned long long v4; // [rsp+48h] [rbp-20h]
v4 = __readfsqword(0x28u);
if ( string
&& (v1 = (unsigned int)string,
!regcomp(
&v3,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x001012ad
MOV RBP,RSP
MOV RBX,RDI
MOV EDX,0x1
LEA RSI,[0x102008]
MOV RDI,RBP
CALL 0x001010c0
TEST EAX,EAX
JZ 0x001012d0
LAB_001012ad:
XOR EBX,EBX
LAB_001012af:
MOV RAX,qword ptr [RSP + 0... | ulong func0(char *param_1)
{
int iVar1;
ulong uVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 != (char *)0x0) {
iVar1 = regcomp(&rStack_68,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}... |
5,508 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jg 1164 <func0+0x1b>
mov -0x4(%rbp),%eax
jmp 1167 <func0+0x1e>
mov -0x8(%rbp),%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]
cmp eax, [rbp+var_8]
jg short loc_1164
mov eax, [rbp+var_4]
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
if ( (int)a1 > (int)a2 )
return a2;
else
return a1;
} | 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]
CMP EAX,dword ptr [RBP + -0x8]
JG 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,509 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,510 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,511 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
5,512 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,%eax
mov %al,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a3 <func0+0x3a>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x1c(%rbp)
jne 119f <func0+0x36>
mov $0x1,%eax... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov eax, esi
mov [rbp+var_1C], al
mov [rbp+var_4], 0
jmp short loc_11A3
loc_1183:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_1C], al
jnz short ... | long long func0(long long a1, char a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i <= 9; ++i )
{
if ( a2 == *(_BYTE *)(i + a1) )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x1c],AL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a3
LAB_00101183:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x1c],AL
JNZ 0... | int8 func0(long param_1,char param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (9 < local_c) {
return 0;
}
if (param_2 == *(char *)(param_1 + local_c)) break;
local_c = local_c + 1;
}
return 1;
} |
5,513 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
add $0xa,%rdi
cmp %sil,(%rax)
je 1188 <func0+0x1f>
add $0x1,%rax
cmp %rdi,%rax
jne 1174 <func0+0xb>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
mov rax, rdi
add rdi, 0Ah
loc_1174:
cmp [rax], sil
jz short loc_1188
add rax, 1
cmp rax, rdi
jnz short loc_1174
mov eax, 0
retn
loc_1188:
mov eax, 1
retn | long long func0(_BYTE *a1, char a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rdi
v2 = a1;
v3 = a1 + 10;
while ( *v2 != a2 )
{
if ( ++v2 == v3 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,RDI
ADD RDI,0xa
LAB_00101174:
CMP byte ptr [RAX],SIL
JZ 0x00101188
ADD RAX,0x1
CMP RAX,RDI
JNZ 0x00101174
MOV EAX,0x0
RET
LAB_00101188:
MOV EAX,0x1
RET | int8 func0(char *param_1,char param_2)
{
char *pcVar1;
pcVar1 = param_1 + 10;
do {
if (*param_1 == param_2) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
return 0;
} |
5,514 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O2 | c | func0:
endbr64
lea 0xa(%rdi),%rax
nopl 0x0(%rax,%rax,1)
cmp %sil,(%rdi)
je 1298 <func0+0x28>
add $0x1,%rdi
cmp %rax,%rdi
jne 1280 <func0+0x10>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
lea rax, [rdi+0Ah]
nop dword ptr [rax+rax+00000000h]
loc_1280:
cmp [rdi], sil
jz short loc_1298
add rdi, 1
cmp rdi, rax
jnz short loc_1280
xor eax, eax
retn
loc_1298:
mov eax, 1
retn | long long func0(_BYTE *a1, char a2)
{
_BYTE *v2; // rax
v2 = a1 + 10;
while ( *a1 != a2 )
{
if ( ++a1 == v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
LEA RAX,[RDI + 0xa]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101280:
CMP byte ptr [RDI],SIL
JZ 0x00101298
ADD RDI,0x1
CMP RDI,RAX
JNZ 0x00101280
XOR EAX,EAX
RET
LAB_00101298:
MOV EAX,0x1
RET | int8 func0(char *param_1,char param_2)
{
char *pcVar1;
pcVar1 = param_1 + 10;
do {
if (*param_1 == param_2) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
return 0;
} |
5,515 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(char tuplex[], char tuple1) {
int i;
for(i = 0; i < 10; i++) {
if(tuplex[i] == tuple1) {
return true;
}
}
return false;
}
| int main() {
char tuplex[] = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O3 | c | func0:
endbr64
cmp (%rdi),%sil
je 1378 <func0+0x48>
cmp 0x1(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x2(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x3(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x4(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x5(%rdi),%sil
je 1378 <func0+0x48>
cmp 0x6(%rdi),%sil
je ... | func0:
endbr64
cmp sil, [rdi]
jz short loc_1188
cmp sil, [rdi+1]
jz short loc_1188
cmp sil, [rdi+2]
jz short loc_1188
cmp sil, [rdi+3]
jz short loc_1188
cmp sil, [rdi+4]
jz short loc_1188
cmp sil, [rdi+5]
jz short loc_1188
cmp sil, [rdi+6]
jz short loc_1188... | bool func0(_BYTE *a1, unsigned __int8 a2)
{
return a2 == *a1
|| a2 == a1[1]
|| a2 == a1[2]
|| a2 == a1[3]
|| a2 == a1[4]
|| a2 == a1[5]
|| a2 == a1[6]
|| a2 == a1[7]
|| a2 == a1[8]
|| a1[9] == a2;
} | func0:
ENDBR64
CMP SIL,byte ptr [RDI]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x1]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x2]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x3]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x4]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x5]
JZ 0x00101188
CMP SIL,byte ptr [RDI + 0x6]
JZ 0x00101188
CMP SIL,by... | bool func0(char *param_1,char param_2)
{
if ((((((param_2 != *param_1) && (param_2 != param_1[1])) && (param_2 != param_1[2])) &&
((param_2 != param_1[3] && (param_2 != param_1[4])))) &&
((param_2 != param_1[5] && ((param_2 != param_1[6] && (param_2 != param_1[7])))))) &&
(param_2 != param_1[8])) {... |
5,516 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
shr %eax
xor -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
shr $0x2,%eax
xor %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
shr $0x4,%eax
xor %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
shr $0x8,%eax
xor... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
shr eax, 1
xor eax, [rbp+var_14]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 2
xor [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 4
xor [rbp+var_4], eax
mov eax, [rbp+var_4]
shr... | const char * func0(unsigned int a1)
{
unsigned int v2; // [rsp+10h] [rbp-4h]
unsigned int v3; // [rsp+10h] [rbp-4h]
v2 = ((a1 ^ (a1 >> 1)) >> 2) ^ a1 ^ (a1 >> 1);
v3 = (((v2 >> 4) ^ v2) >> 8) ^ (v2 >> 4) ^ v2;
if ( ((BYTE2(v3) ^ (unsigned __int8)v3) & 1) != 0 )
return "Odd Parity";
else
return "Eve... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
SHR EAX,0x1
XOR EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x2
XOR dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x4
XOR dword ptr [RBP + -0x4],E... | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 ^ param_1 >> 2;
param_1 = param_1 ^ param_1 >> 4;
param_1 = param_1 ^ param_1 >> 8;
if (((param_1 ^ param_1 >> 0x10) & 1) == 0) {
pcVar1 = "Even Parity";
}
else {
pcVar1 = "Odd Parity";
}
retur... |
5,517 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
shr %eax
xor %eax,%edi
mov %edi,%eax
shr $0x2,%eax
xor %edi,%eax
mov %eax,%edi
shr $0x4,%edi
xor %edi,%eax
mov %eax,%edi
shr $0x8,%edi
xor %eax,%edi
mov %edi,%eax
shr $0x10,%eax
xor %eax,%edi
test $0x1,%dil
lea 0xeaa(%rip),%rax
lea 0xeaf(... | func0:
endbr64
mov edx, edi
shr edx, 1
xor edx, edi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
test al, 1
lea rax, aEvenParity; "Even Parity"
lea ... | const char * func0(unsigned int a1)
{
const char *result; // rax
result = "Even Parity";
if ( (((unsigned __int8)((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8)) ... | func0:
ENDBR64
MOV EDX,EDI
SHR EDX,0x1
XOR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
TEST AL,0x1
LEA RAX,[0x10200f]
LEA RDX,[0x102004]
CMOVNZ RAX,RDX
RET | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 >> 2 ^ param_1;
param_1 = param_1 >> 4 ^ param_1;
param_1 = param_1 >> 8 ^ param_1;
pcVar1 = "Even Parity";
if (((param_1 ^ param_1 >> 0x10) & 1) != 0) {
pcVar1 = "Odd Parity";
}
return pcVar1;
} |
5,518 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
lea 0xec3(%rip),%rdx
shr %eax
xor %eax,%edi
mov %edi,%eax
shr $0x2,%eax
xor %edi,%eax
mov %eax,%edi
shr $0x4,%edi
xor %edi,%eax
mov %eax,%edi
shr $0x8,%edi
xor %eax,%edi
mov %edi,%eax
shr $0x10,%eax
xor %eax,%edi
lea 0xe90(%rip),%rax
and ... | func0:
endbr64
mov edx, edi
shr edx, 1
xor edx, edi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
lea rdx, aOddParity; "Odd Parity"
test al, 1
lea ... | const char * func0(unsigned int a1)
{
const char *result; // rax
result = "Even Parity";
if ( (((unsigned __int8)((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8)) ... | func0:
ENDBR64
MOV EDX,EDI
SHR EDX,0x1
XOR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
LEA RDX,[0x102004]
TEST AL,0x1
LEA RAX,[0x10200f]
CMOVNZ RAX,RDX
RET | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 >> 2 ^ param_1;
param_1 = param_1 >> 4 ^ param_1;
param_1 = param_1 >> 8 ^ param_1;
pcVar1 = "Even Parity";
if (((param_1 ^ param_1 >> 0x10) & 1) != 0) {
pcVar1 = "Odd Parity";
}
return pcVar1;
} |
5,519 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| const char* func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(strcmp(func0(12), "Even Parity") == 0);
assert(strcmp(func0(7), "Odd Parity") == 0);
assert(strcmp(func0(10), "Even Parity") == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
lea 0xec3(%rip),%rdx
shr %eax
xor %eax,%edi
mov %edi,%eax
shr $0x2,%eax
xor %edi,%eax
mov %eax,%edi
shr $0x4,%edi
xor %edi,%eax
mov %eax,%edi
shr $0x8,%edi
xor %eax,%edi
mov %edi,%eax
shr $0x10,%eax
xor %eax,%edi
lea 0xe90(%rip),%rax
and ... | func0:
endbr64
mov edx, edi
shr edx, 1
xor edx, edi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
lea rdx, aEvenParity; "Even Parity"
test al, 1
lea ... | const char * func0(unsigned int a1)
{
const char *result; // rax
result = "Odd Parity";
if ( (((unsigned __int8)((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2) ^ ((a1 ^ (a1 >> 1) ^ ((a1 ^ (a1 >> 1)) >> 2)) >> 4)) >> 8)) >... | func0:
ENDBR64
MOV EDX,EDI
SHR EDX,0x1
XOR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
LEA RDX,[0x10200f]
TEST AL,0x1
LEA RAX,[0x102004]
CMOVZ RAX,RDX
RET | char * func0(uint param_1)
{
char *pcVar1;
param_1 = param_1 >> 1 ^ param_1;
param_1 = param_1 >> 2 ^ param_1;
param_1 = param_1 >> 4 ^ param_1;
param_1 = param_1 >> 8 ^ param_1;
pcVar1 = "Odd Parity";
if (((param_1 ^ param_1 >> 0x10) & 1) == 0) {
pcVar1 = "Even Parity";
}
return pcVar1;
} |
5,520 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
... | int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %edi,-0x54(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x54(%rbp),%edx
lea -0x1e(%rbp),%rax
lea 0xdb3(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1130 <sprintf@plt>
lea -0x1e(%rbp),%rax
mov %rax,%rdi
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_54], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov edx, [rbp+var_54]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rax, [rbp+s]
... | int func0(int a1)
{
size_t v1; // rax
char v3; // [rsp+13h] [rbp-4Dh]
int i; // [rsp+14h] [rbp-4Ch]
unsigned long long j; // [rsp+18h] [rbp-48h]
size_t k; // [rsp+20h] [rbp-40h]
unsigned long long m; // [rsp+28h] [rbp-38h]
size_t v8; // [rsp+38h] [rbp-28h]
char s[11]; // [rsp+42h] [rbp-1Eh] BYREF
cha... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0x54],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EDX,dword ptr [RBP + -0x54]
LEA RAX,[RBP + -0x1e]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101130
LEA RAX,[RBP + -0x1e]
MOV RDI,RAX
CALL 0x00... | int func0(uint param_1)
{
int iVar1;
size_t sVar2;
long in_FS_OFFSET;
char local_55;
int local_54;
ulong local_50;
ulong local_48;
ulong local_40;
char local_26 [10];
char acStack_1c [12];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sprintf(local_26,"%d",(ulong)param_1);
sV... |
5,521 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
... | int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %edi,%r8d
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbx
lea 0xdae(%rip),%rcx
mov $0xb,%edx
mov $0x1,%esi
mov %rbx,%rdi
callq 1130 <__sprintf_chk@plt>
mov $0xffffffffffffffff,%rcx
... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r8d, edi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
lea rbx, [rsp+48h+var_46]
lea rcx, unk_2004
mov edx, 0Bh
mov esi, 1
mov rdi, rbx
call ___sprintf_chk
mov rdi, rbx
call _strlen... | long long func0(unsigned int a1)
{
int v1; // edx
long long v2; // rax
_BYTE *v3; // rdx
int v4; // ebp
long long v6; // r12
unsigned long long v7; // rax
int v8; // ebx
char *v9; // rdx
int v10; // esi
unsigned long long v11; // rdx
char *v12; // rdx
long long v13; // rax
_BYTE v14[11]; // [... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R8D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RBX,[RSP + 0x2]
LEA RCX,[0x102004]
MOV EDX,0xb
MOV ESI,0x1
MOV RDI,RBX
CALL 0x00101150
MOV RDI,RBX
CALL 0x00101100
MOV EDX,EAX
SUB EAX,0x2
JS 0x001013d3
MOVSXD RCX,EAX
M... | long func0(int4 param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
long lVar4;
char *pcVar5;
ulong uVar6;
char cVar7;
char cVar8;
long in_FS_OFFSET;
char local_46 [10];
char acStack_3c [12];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(local_46,1,0xb,&DAT_00102004... |
5,522 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
... | int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %edi,%r8d
mov $0xb,%edx
mov $0x1,%esi
push %r12
lea 0xce8(%rip),%rcx
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbp
mov %rbp,%rdi
callq 1150 <__sprintf_chk@plt>
mov %rbp,%rdi
callq 1100 <st... | func0:
endbr64
push r14
mov r8d, edi
mov edx, 0Bh
mov esi, 1
push r13
lea rcx, unk_2004
push r12
push rbp
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
lea rbp, [rsp+48h+var_46]
mov rdi, rbp
call ___sprintf_chk
mov rdi, rbp
cal... | long long func0(unsigned int a1)
{
int v1; // edx
long long v2; // rax
_BYTE *v3; // rdx
long long v4; // r12
long long v5; // rax
int v6; // ebx
unsigned long long v7; // rax
unsigned long long v8; // rsi
char v9; // r8
char *v10; // rcx
char *v11; // rdi
int i; // edx
int v13; // eax
unsi... | func0:
ENDBR64
PUSH R14
MOV R8D,EDI
MOV EDX,0xb
MOV ESI,0x1
PUSH R13
LEA RCX,[0x102004]
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x2]
MOV RDI,RBP
CALL 0x00101170
MOV RDI,RBP
CALL 0x00101110
MOV EDX,EAX
SUB EAX,0x2
JS 0x00101480
SUB EDX... | long func0(int4 param_1)
{
char *__s;
char cVar1;
int iVar2;
size_t sVar3;
long lVar4;
char *pcVar5;
char cVar6;
long lVar7;
ulong uVar8;
long lVar9;
long in_FS_OFFSET;
char local_46 [10];
char acStack_3c [12];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(l... |
5,523 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(int n) {
char nums[11];
sprintf(nums, "%d", n);
size_t length = strlen(nums);
for (int i = length - 2; i >= 0; --i) {
if (nums[i] < nums[i + 1]) {
char z[11]; // Segment of the array from i
strcpy(z, nums+i);
size_t z_len = strlen(z);
... | int main() {
assert(func0(12) == 21);
assert(func0(10) == 0);
assert(func0(102) == 120);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r14
mov %edi,%r8d
mov $0xb,%edx
mov $0x1,%esi
push %r13
lea 0xcc8(%rip),%rcx
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbp
mov %rbp,%rdi
callq 1170 <__sprintf_chk@plt>
mov %rbp,%rdi
cal... | func0:
endbr64
push r14
mov r8d, edi
mov edx, 0Bh
mov esi, 2
push r13
lea rcx, unk_2004
push r12
push rbp
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
lea rbp, [rsp+48h+s]
mov rdi, rbp
call ___sprintf_chk
mov rdi, rbp; s
call ... | long long func0(unsigned int a1)
{
int v1; // eax
int v2; // edx
long long v3; // rbx
char v4; // cl
char v5; // dl
char v6; // cl
char v7; // dl
char v8; // cl
char v9; // dl
char v10; // cl
char v11; // dl
bool v12; // zf
long long result; // rax
unsigned long long v14; // rax
size_t v1... | func0:
ENDBR64
PUSH R14
MOV R8D,EDI
MOV EDX,0xb
MOV ESI,0x2
PUSH R13
LEA RCX,[0x102004]
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x2]
MOV RDI,RBP
CALL 0x00101170
MOV RDI,RBP
CALL 0x00101100
MOV EDX,EAX
SUB EDX,0x2
JS 0x00101468
MOVSXD ... | long func0(int4 param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
size_t sVar4;
long lVar5;
ulong __nmemb;
uint uVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
char cVar10;
long in_FS_OFFSET;
char local_46 [11];
char local_3b [5];
char local_36;
char local_35;
char local_34;
char local... |
5,524 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
... | int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int... | int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &retu... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %rdx,-0x78(%rbp)
mov %ecx,-0x70(%rbp)
mov %r8d,-0x7c(%rbp)
mov %r9,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x6c(%rbp),%eax
imul -0x70(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_68], rdi
mov [rbp+var_6C], esi
mov [rbp+var_78], rdx
mov [rbp+var_70], ecx
mov [rbp+var_7C], r8d
mov [rbp+var_88], r9
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_6C]
imu... | _QWORD * func0(_DWORD *a1, int a2, _DWORD *a3, int a4, int a5, _DWORD *a6)
{
int v7; // edx
int v12; // [rsp+34h] [rbp-5Ch] BYREF
int i; // [rsp+38h] [rbp-58h]
int v14; // [rsp+3Ch] [rbp-54h]
void *ptr; // [rsp+40h] [rbp-50h]
_QWORD *v16; // [rsp+48h] [rbp-48h]
long long v17; // [rsp+54h] [rbp-3Ch]
int ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x68],RDI
MOV dword ptr [RBP + -0x6c],ESI
MOV qword ptr [RBP + -0x78],RDX
MOV dword ptr [RBP + -0x70],ECX
MOV dword ptr [RBP + -0x7c],R8D
MOV qword ptr [RBP + -0x88],R9
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX... | void * func0(int *param_1,int param_2,int *param_3,int param_4,int param_5,int *param_6)
{
long lVar1;
void *pvVar2;
long lVar3;
void *pvVar4;
int extraout_var;
int extraout_EDX;
long in_FS_OFFSET;
int local_64;
int local_60;
int local_5c;
void *local_58;
lVar1 = *(long *)(in_FS_OFFSET + 0x2... |
5,525 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
... | int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int... | int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &retu... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,0x10(%rsp)
mov %esi,0x24(%rsp)
mov %rdx,%r15
mov %ecx,0x18(%rsp)
mov %r8d,%ebx
mov %r8d,0x1c(%rsp)
mov %r9,0x28(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_90], rdi
mov [rsp+98h+var_74], esi
mov r14, rdx
mov [rsp+98h+var_88], ecx
mov ebx, r8d
mov [rsp+98h+var_84], r8d
mov [rsp+98h+var_70], r9
mov rax, fs:28h
mov [rsp+... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4, int a5, _DWORD *a6)
{
long long v8; // r15
long long v9; // r13
unsigned int v10; // eax
_QWORD *v11; // rbx
_QWORD *v12; // rbp
long long v13; // rbp
unsigned long long i; // rax
int v15; // edx
bool v17; // al
int v18; // ebx
unsigned long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x8],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV R14,RDX
MOV dword ptr [RSP + 0x10],ECX
MOV EBX,R8D
MOV dword ptr [RSP + 0x14],R8D
MOV qword ptr [RSP + 0x28],R9
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XO... | int8 * func0(int *param_1,int param_2,int *param_3,int param_4,uint param_5,int *param_6)
{
int *piVar1;
void *__ptr;
int8 *puVar2;
void *pvVar3;
int iVar4;
int iVar5;
int iVar6;
int8 *puVar7;
long lVar8;
int iVar9;
long in_FS_OFFSET;
int1 auVar10 [12];
int local_78;
int local_68;
int loc... |
5,526 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
... | int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int... | int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &retu... | O2 | c | func0:
endbr64
push %r15
mov %ecx,%r15d
push %r14
mov %rdx,%r14
push %r13
mov %esi,%r13d
push %r12
push %rbp
push %rbx
mov %r8d,%ebx
sub $0x58,%rsp
mov %rdi,0x10(%rsp)
mov %esi,0xc(%rsp)
mov %ecx,0x4(%rsp)
mov %r9,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,... | func0:
endbr64
push r15
mov r15d, ecx
push r14
mov r14, rdx
push r13
mov r13d, esi
push r12
push rbp
push rbx
mov ebx, r8d
sub rsp, 58h
mov [rsp+88h+var_78], rdi
mov [rsp+88h+var_7C], esi
mov [rsp+88h+var_84], ecx
mov [rsp+88h+var_70], r9
mov rax, fs:28h
mov ... | long long func0(_DWORD *a1, int a2, int *a3, int a4, int a5, _DWORD *a6)
{
long long v9; // rbp
long long v10; // r12
long long v11; // r15
int v13; // eax
long long v14; // rdi
long long v15; // r11
long long v16; // r15
long long v17; // rbx
signed int v18; // r11d
bool v19; // al
int v20; // e... | func0:
ENDBR64
PUSH R15
MOV R15D,ECX
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,R8D
SUB RSP,0x58
MOV qword ptr [RSP + 0x10],RDI
MOV dword ptr [RSP + 0xc],ESI
MOV dword ptr [RSP + 0x4],ECX
MOV qword ptr [RSP + 0x18],R9
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
MOV EAX,... | int8 * func0(int *param_1,int param_2,int *param_3,int param_4,uint param_5,int *param_6)
{
int iVar1;
int *piVar2;
void *__ptr;
int8 *puVar3;
void *pvVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int8 *puVar9;
int8 *puVar10;
long lVar11;
long in_FS_OFFSET;
int1 auVar12 [12];
int loca... |
5,527 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int sum;
int index1;
int index2;
} HeapNode;
void swap(HeapNode *a, HeapNode *b) {
HeapNode temp = *a;
*a = *b;
*b = temp;
}
void heapify(HeapNode heap[], int n, int i) {
int smallest = i;
... | int **func0(int nums1[], int nums1Size, int nums2[], int nums2Size, int k, int *returnSize) {
HeapNode *heap = (HeapNode *)malloc(sizeof(HeapNode) * (nums1Size * nums2Size));
int heapSize = 0;
int **result = (int **)malloc(sizeof(int *) * k);
for (int i = 0; i < k; i++) {
result[i] = (int... | int main() {
int returnSize;
int **result;
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 2, &returnSize);
assert(returnSize == 2 && result[0][0] == 1 && result[0][1] == 2 && result[1][0] == 1 && result[1][1] == 4);
result = func0((int[]){1, 3, 7}, 3, (int[]){2, 4, 6}, 3, 1, &retu... | O3 | c | func0:
endbr64
mov %esi,%eax
push %r15
mov %rdi,%r15
imul %ecx,%eax
push %r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
cltq
mov %r8d,%ebp
push %rbx
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
sub $0x38,%rsp
mov %esi,0x14(%rsp)
mov %ecx,0xc(%rsp)
mov %r9,0x28(%rsp)
callq 10b0 <ma... | func0:
endbr64
mov eax, esi
push r15
imul eax, ecx
push r14
push r13
mov r13, rdx
push r12
mov r12d, ecx
push rbp
cdqe
push rbx
movsxd rbx, r8d
sub rsp, 38h
mov [rsp+68h+var_60], rdi
lea rdi, [rax+rax*2]
shl rdi, 2; size
mov [rsp+68h+var_64], esi
mov [rsp+68h+va... | char * func0(_DWORD *a1, int a2, _DWORD *a3, int a4, int a5, _DWORD *a6)
{
size_t v8; // rbx
_DWORD *v9; // r14
char *v10; // rbp
char *v11; // rbx
char *v12; // r15
int v13; // r9d
int v14; // r15d
int v15; // r11d
int v16; // ebx
_DWORD *v17; // rax
int v18; // edi
int v19; // r12d
char *v20... | func0:
ENDBR64
MOV EAX,ESI
PUSH R15
IMUL EAX,ECX
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12D,ECX
PUSH RBP
CDQE
PUSH RBX
MOVSXD RBX,R8D
SUB RSP,0x38
MOV qword ptr [RSP + 0x8],RDI
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
MOV dword ptr [RSP + 0x4],ESI
MOV qword ptr [RSP + 0x20],R9
CALL 0x001010b0
MOV dword ptr [RSP],EBX
SH... | int8 *
func0(int *param_1,int param_2,int *param_3,int param_4,int param_5,int4 *param_6)
{
int *piVar1;
int *piVar2;
int iVar3;
int8 uVar4;
int *__ptr;
int8 *puVar5;
void *pvVar6;
int iVar7;
long lVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
long lVar13;
int iVar14;
int8 *puVar... |
5,528 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
mov 0x4(%rax),%eax
imul %eax,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
mov %edx,-0xc(%rbp)
sub %eax,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
j... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov edx, [rax]
mov rax, [rbp+var_18]
mov eax, [rax+4]
imul eax, edx
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_C], eax
mov [rbp+var_8], 1
jmp short loc_11E... | long long func0(_DWORD *a1, int a2)
{
int v2; // eax
int v3; // eax
int v5; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
v2 = *a1 * a1[1];
if ( v2 <= 0 )
v2 = -(*a1 * a1[1]);
v5 = v2;
for ( i = 1; i < a2; ++i )
{
v3 = a1[2 * i] * a1[2 * i + 1];
if ( v3 <= 0 )
v3 = -v3;
if... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
IMUL EAX,EDX
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0... | int func0(int *param_1,int param_2)
{
int iVar1;
int local_14;
int local_10;
local_14 = param_1[1] * *param_1;
if (local_14 < 1) {
local_14 = -local_14;
}
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
iVar1 = param_1[(long)local_10 * 2 + 1] * param_1[(long)local_10 * 2];
... |
5,529 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp $0x1,%esi
jle 11a6 <func0+0x3d>
lea 0x8(%rdi),%rcx
lea -0x2(%rsi),%edx
lea 0x10(%rdi,%rdx,8),%rdi
mov (%rcx),%edx
imul 0x4(%rcx),%edx
mov %edx,%esi
sar $0x1f,%esi
xor %esi,%edx
sub %esi,%ed... | func0:
endbr64
mov eax, [rdi]
imul eax, [rdi+4]
mov r8d, eax
neg r8d
cmovs r8d, eax
cmp esi, 1
jle short loc_11AB
lea rdx, [rdi+8]
lea eax, [rsi-2]
lea rsi, [rdi+rax*8+10h]
loc_118E:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp r8d, e... | long long func0(_DWORD *a1, int a2)
{
int v2; // r8d
_DWORD *v3; // rdx
long long v4; // rsi
int v5; // eax
v2 = -(a1[1] * *a1);
if ( a1[1] * *a1 > 0 )
v2 = a1[1] * *a1;
if ( a2 > 1 )
{
v3 = a1 + 2;
v4 = (long long)&a1[2 * (a2 - 2) + 4];
do
{
v5 = v3[1] * *v3;
if ( v5 <... | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
MOV R8D,EAX
NEG R8D
CMOVS R8D,EAX
CMP ESI,0x1
JLE 0x001011ab
LEA RDX,[RDI + 0x8]
LEA EAX,[RSI + -0x2]
LEA RSI,[RDI + RAX*0x8 + 0x10]
LAB_0010118e:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP R8D,EAX
C... | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
iVar1 = *param_1 * param_1[1];
iVar3 = -iVar1;
if (0 < iVar1) {
iVar3 = iVar1;
}
if (1 < param_2) {
piVar2 = param_1 + 2;
do {
iVar1 = *piVar2 * piVar2[1];
if (iVar1 < 1) {
iVar1 = -iVar1;
... |
5,530 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp $0x1,%esi
jle 117d <func0+0x3d>
lea -0x2(%rsi),%edx
lea 0x8(%rdi),%rcx
lea 0x10(%rdi,%rdx,8),%rdi
mov (%rcx),%edx
imul 0x4(%rcx),%edx
mov %edx,%esi
sar $0x1f,%esi
xor %esi,%edx
sub %esi,%ed... | func0:
endbr64
mov eax, [rdi]
imul eax, [rdi+4]
mov r8d, eax
neg r8d
cmovs r8d, eax
cmp esi, 1
jle short loc_1325
lea eax, [rsi-2]
lea rdx, [rdi+8]
lea rsi, [rdi+rax*8+10h]
nop dword ptr [rax]
loc_1308:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns ... | long long func0(_DWORD *a1, int a2)
{
int v2; // r8d
_DWORD *v3; // rdx
long long v4; // rsi
int v5; // eax
v2 = -(a1[1] * *a1);
if ( a1[1] * *a1 > 0 )
v2 = a1[1] * *a1;
if ( a2 > 1 )
{
v3 = a1 + 2;
v4 = (long long)&a1[2 * (a2 - 2) + 4];
do
{
v5 = v3[1] * *v3;
if ( v5 <... | func0:
ENDBR64
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
MOV R8D,EAX
NEG R8D
CMOVS R8D,EAX
CMP ESI,0x1
JLE 0x00101325
LEA EAX,[RSI + -0x2]
LEA RDX,[RDI + 0x8]
LEA RSI,[RDI + RAX*0x8 + 0x10]
NOP dword ptr [RAX]
LAB_00101308:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS E... | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
iVar1 = *param_1 * param_1[1];
iVar3 = -iVar1;
if (0 < iVar1) {
iVar3 = iVar1;
}
if (1 < param_2) {
piVar2 = param_1 + 2;
do {
iVar1 = *piVar2 * piVar2[1];
if (iVar1 < 1) {
iVar1 = -iVar1;
... |
5,531 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int length) {
int result_min = abs(list1[0][0] * list1[0][1]);
for (int i = 1; i < length; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product < result_min) {
result_min = product;
}
}
return result_min;
}
| int main() {
int list1[][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
int list2[][2] = {{10, 20}, {15, 2}, {5, 10}};
int list3[][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(list1, 4) == 8);
assert(func0(list2, 3) == 30);
assert(func0(list3, 4) == 100);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp $0x1,%esi
jle 12a1 <func0+0x161>
lea -0x2(%rsi),%edx
lea -0x1(%rsi),%r8d
cmp $0x2,%edx
jbe 12a9 <func0+0x169>
mov %r8d,%edx
movd %eax,%xmm6
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm6,%xmm3
... | func0:
endbr64
mov rcx, rdi
mov edi, esi
mov edx, [rcx]
imul edx, [rcx+4]
mov eax, edx
neg eax
cmovs eax, edx
cmp esi, 1
jle locret_12A5
lea edx, [rdi-2]
lea esi, [rsi-1]
cmp edx, 2
jbe loc_12A6
mov edx, esi
movd xmm6, eax
mov rax, rcx
shr edx, 2
pshufd x... | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
unsigned int v5; // esi
__m128i v6; // xmm6
_DWORD *v7; // rax
__m128i v8; // xmm3
__m128 v9; // xmm2
__m128 v10; // xmm4
__m128 v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm0
__m128i v14; // xmm0
__m128i v15; // xmm1
__m1... | func0:
ENDBR64
MOV RCX,RDI
MOV EDI,ESI
MOV EDX,dword ptr [RCX]
IMUL EDX,dword ptr [RCX + 0x4]
MOV EAX,EDX
NEG EAX
CMOVS EAX,EDX
CMP ESI,0x1
JLE 0x001012a5
LEA EDX,[RDI + -0x2]
LEA ESI,[RSI + -0x1]
CMP EDX,0x2
JBE 0x001012a6
MOV EDX,ESI
MOVD XMM6,EAX
MOV RAX,RCX
SHR EDX,0x2
PSHUFD XMM3,XMM6,0x0
SHL RDX,0x5
ADD RDX,RCX
N... | uint func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint *puVar6;
int *piVar7;
int *piVar8;
uint uVar9;
int *piVar10;
uint uVar11;
int iVar12;
long lVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar18;
uint uVar19;
uint uVa... |
5,532 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}... | int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x7fffffff,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1200 <func0+0x77>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_10], 7FFFFFFFh
mov [rbp+var_C], 0
jmp short loc_1203
loc_11BB:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mo... | long long func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h] BYREF
int v4; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
unsigned long long v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
v4 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( (unsigned int)__isoc99_sscanf(*(_QWORD... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x10],0x7fffffff
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101203
LAB_001011bb:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
L... | int func0(long param_1,int param_2)
{
int iVar1;
long in_FS_OFFSET;
int local_1c;
int local_18;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = 0x7fffffff;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
iVar1 = __isoc99_sscanf(*(int8 *)(par... |
5,533 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}... | int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
test %esi,%esi
jle 11f1 <func0+0x68>
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r13
mov $0x7fffffff,%ebp
lea 0x4(%rsp),%r12
jmp 11cb <func0+0x4... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
test esi, esi
jle short loc_11F1
mov rbx, rdi
lea eax, [rsi-1]
lea r13, [rdi+rax*8+8]
mov ebp, 7FFFFFFFh
lea r12, unk_2004
jmp short loc_11CD
... | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
int v3; // ebp
int v5; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v6; // [rsp+8h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
return 0x7FFFFFFF;
}
else
{
v2 = a1;
v3 = 0x7FFFFFFF;
do
{
if ( (unsigned i... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001011f1
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R13,[RDI + RAX*0x8 + 0x8]
MOV EBP,0x7fffffff
LEA R12,[0x102004]
JMP 0x001011cd
LAB_001011c4:
ADD RBX,0x8
CMP RBX,R13
JZ 0... | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
iVar3 = 0x7fffffff;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0x7fffffff;
d... |
5,534 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}... | int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13b0 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov $0x7fffffff,%r12d
lea 0x8(%rdi,%rax,8),%r14
lea 0x4(%rsp),%r13
lea 0x... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
test esi, esi
jle short loc_13B0
lea eax, [rsi-1]
mov rbx, rdi
mov r12d, 7FFFFFFFh
lea r14, [rdi+rax*8+8]
lea r13, [rsp+38h+var_34]
le... | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
int v3; // r12d
int v5; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v6; // [rsp+8h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
return 0x7FFFFFFF;
}
else
{
v2 = a1;
v3 = 0x7FFFFFFF;
do
{
if ( (unsigned ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001013b0
LEA EAX,[RSI + -0x1]
MOV RBX,RDI
MOV R12D,0x7fffffff
LEA R14,[RDI + RAX*0x8 + 0x8]
LEA R13,[RSP + 0x4]
LEA RBP,[0x102004]
NOP dword ptr [RAX]
LAB_001... | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
iVar3 = 0x7fffffff;
}
else {
iVar3 = 0x7fffffff;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
d... |
5,535 | func0 |
#include <assert.h>
#include <limits.h>
#include <stdio.h>
| int func0(char *listval[], int size) {
int min_val = INT_MAX;
int current_val;
for (int i = 0; i < size; i++) {
if (sscanf(listval[i], "%d", ¤t_val)) {
if (current_val < min_val) {
min_val = current_val;
}
}
}
return min_val;
}... | int main() {
char *list1[] = {"Python", "3", "2", "4", "5", "version"};
assert(func0(list1, 6) == 2);
char *list2[] = {"Python", "15", "20", "25"};
assert(func0(list2, 4) == 15);
char *list3[] = {"Python", "30", "20", "40", "50", "version"};
assert(func0(list3, 6) == 20);
... | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13e0 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov $0x7fffffff,%r12d
lea 0x8(%rdi,%rax,8),%r14
lea 0x4(%rsp),%r13
lea 0x... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
test esi, esi
jle short loc_1428
movsxd rsi, esi
mov rbx, rdi
lea r13, [rsp+38h+var_34]
mov ebp, 7FFFFFFFh
lea r14, [rdi+rsi*8]
lea r... | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
int v3; // ebp
int v5; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v6; // [rsp+8h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
return 0x7FFFFFFF;
}
else
{
v2 = a1;
v3 = 0x7FFFFFFF;
do
{
if ( (unsigned i... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101428
MOVSXD RSI,ESI
MOV RBX,RDI
LEA R13,[RSP + 0x4]
MOV EBP,0x7fffffff
LEA R14,[RDI + RSI*0x8]
LEA R12,[0x102004]
NOP
LAB_001013e0:
MOV RDI,qword ptr [RBX... | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
iVar3 = 0x7fffffff;
}
else {
iVar3 = 0x7fffffff;
puVar1 = param_1 + param_2;
do {
iVar2 =... |
5,536 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize =... | int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1260 <func0+0xb7>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5f,%al... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp loc_1260
loc_11D7:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax... | long long func0(long long a1, long long a2)
{
char v2; // cl
int v3; // eax
int v4; // eax
int v6; // [rsp+14h] [rbp-Ch]
int v7; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v6 = 0;
v7 = 1;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(_BYTE *)(i + a1) == 95 )
{
v7 = 1;
}... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101260
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX... | long func0(long param_1,long param_2)
{
bool bVar1;
int iVar2;
int4 local_14;
int4 local_c;
local_14 = 0;
bVar1 = true;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == '_') {
bVar1 = true;
}
else if (bVar1) {
... |
5,537 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize =... | int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rsi,%r13
movzbl (%rdi),%ebx
test %bl,%bl
je 120d <func0+0x84>
lea 0x1(%rdi),%rbp
mov $0x1,%eax
mov $0x0,%r12d
mov $0x1,%r14d
mov $0x0,%r15d
jmp 11e0 <func0+0x57>
movslq %r12d,%rdx
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_122D
lea rbp, [rdi+1]
mov eax, 1
mov r12d, 0
mov r14d, 1
mov r15d, 0
jmp short loc_1200
loc_11E2:
movsxd rdx, r12d
... | long long func0(char *a1, long long a2)
{
char v2; // bl
char *v3; // rbp
int v4; // eax
int v5; // r12d
v2 = *a1;
if ( *a1 )
{
v3 = a1 + 1;
v4 = 1;
v5 = 0;
do
{
if ( v2 == 95 )
{
v4 = 1;
}
else if ( v4 )
{
*(_BYTE *)(a2 + v5++) = *(_DWOR... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x0010122d
LEA RBP,[RDI + 0x1]
MOV EAX,0x1
MOV R12D,0x0
MOV R14D,0x1
MOV R15D,0x0
JMP 0x00101200
LAB_001011e2:
MOVSXD RDX,R12D
MOV byte ptr [R13 + RDX*0x1],BL
LEA R12D,[R12 + 0x1]
JMP 0x00... | long func0(char *param_1,long param_2)
{
bool bVar1;
__int32_t **pp_Var2;
char cVar3;
char *pcVar4;
int iVar5;
cVar3 = *param_1;
if (cVar3 == '\0') {
iVar5 = 0;
}
else {
bVar1 = true;
iVar5 = 0;
pcVar4 = param_1 + 1;
do {
if (cVar3 == '_') {
bVar1 = true;
}
... |
5,538 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize =... | int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
mov $0x1,%eax
xor %r15d,%r15d
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%... | func0:
endbr64
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
mov edx, 1
xor r12d, r12d
jmp short loc_1305
loc_12D8:
movsxd rax, r12d
add r12d, 1
lea r13, [r14+rax]
test edx, edx
... | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // edx
int v5; // r12d
long long v6; // rax
_BYTE *v7; // r13
_QWORD *v8; // rax
_BYTE *v9; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 1;
v5 = 0;
do
{
while ( (_BYTE)v2 == 95 )
... | func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
MOV EDX,0x1
XOR R12D,R12D
JMP 0x00101305
LAB_001012d8:
MOVSXD RAX,R12D
ADD R12D,0x1
LEA R13,[R14 + RAX*0x1]
TEST EDX,EDX
JZ 0x00101338
CALL 0x00101080
XOR EDX,EDX
MOV RAX,qword p... | int1 * func0(char *param_1,int1 *param_2)
{
char cVar1;
bool bVar2;
long lVar3;
__int32_t **pp_Var4;
long lVar5;
int iVar6;
int1 *puVar7;
lVar5 = (long)*param_1;
puVar7 = param_2;
if (*param_1 != '\0') {
param_1 = param_1 + 1;
bVar2 = true;
iVar6 = 0;
do {
while ((char)lVar... |
5,539 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* word, char* result) {
int index = 0, capitalize = 1;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == '_') {
capitalize = 1;
} else {
if (capitalize) {
result[index++] = toupper(word[i]);
capitalize =... | int main() {
char result[100];
assert(strcmp(func0("android_tv", result), "AndroidTv") == 0);
assert(strcmp(func0("google_pixel", result), "GooglePixel") == 0);
assert(strcmp(func0("apple_watch", result), "AppleWatch") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
mov $0x1,%eax
xor %r15d,%r15d
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%... | func0:
endbr64
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
mov eax, 1
xor r12d, r12d
jmp short loc_130B
loc_12E0:
test eax, eax
jz short loc_12F0
call ___ctype_toupper_loc
mo... | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // eax
int v5; // r12d
long long v6; // rax
_BYTE *v7; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 1;
v5 = 0;
do
{
while ( (_BYTE)v2 == 95 )
{
v2 = *v3++;
v4 = ... | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
MOV EAX,0x1
XOR R12D,R12D
JMP 0x0010130b
LAB_001012e0:
TEST EAX,EAX
JZ 0x001012f0
CALL 0x00101080
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + RBX*0x4]
LAB_001012f0:
MOVS... | int * func0(char *param_1,int *param_2)
{
char cVar1;
bool bVar2;
__int32_t **pp_Var3;
long lVar4;
ulong uVar5;
char *pcVar6;
int iVar7;
int *puVar8;
uVar5 = (ulong)*param_1;
puVar8 = param_2;
if (*param_1 != '\0') {
bVar2 = true;
iVar7 = 0;
pcVar6 = param_1 + 1;
do {
whi... |
5,540 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[]... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
je 1219 <func0+0x25>
mov $0x0,%eax
jmp 126a <func0+0x76>
movl $0x0,-0x4(%rbp)
jmp 125d <func0+0x69>
mov -0x4(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jz short loc_1219
mov eax, 0
jmp short loc_126A
loc_1219:
mov [rbp+var_4], 0
jmp short loc_125D
loc... | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+24h] [rbp-4h]
if ( a2 != a4 )
return 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) != *(_DWORD *)(4LL * i + a3) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JZ 0x00101219
MOV EAX,0x0
JMP 0x0010126a
LAB_00101219:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int8 uVar1;
int local_c;
if (param_2 == param_4) {
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) != *(int *)(param_3 + (long)local_c * 4)) {
return 0;
}
}
u... |
5,541 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[]... | O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %ecx,%esi
jne 11e2 <func0+0x40>
test %esi,%esi
jle 11d7 <func0+0x35>
lea -0x1(%rsi),%esi
mov $0x0,%eax
jmp 11c0 <func0+0x1e>
mov %rcx,%rax
mov (%rdx,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
jne 11dd <func0+0x3b>
lea 0x1(%rax),%rcx
cmp %rsi,%rax
jne ... | func0:
endbr64
mov eax, 0
cmp esi, ecx
jnz short locret_11E2
test esi, esi
jle short loc_11D7
lea esi, [rsi-1]
mov eax, 0
jmp short loc_11C0
loc_11BD:
mov rax, rcx
loc_11C0:
mov ecx, [rdx+rax*4]
cmp [rdi+rax*4], ecx
jnz short loc_11DD
lea rcx, [rax+1]
cmp rax, rsi
... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rsi
long long i; // rax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = (unsigned int)(a2 - 1);
for ( i = 0LL; *(_DWORD *)(a1 + 4 * i) ==... | func0:
ENDBR64
MOV EAX,0x0
CMP ESI,ECX
JNZ 0x001011e2
TEST ESI,ESI
JLE 0x001011d7
LEA ESI,[RSI + -0x1]
MOV EAX,0x0
JMP 0x001011c0
LAB_001011bd:
MOV RAX,RCX
LAB_001011c0:
MOV ECX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JNZ 0x001011dd
LEA RCX,[RAX + 0x1]
CMP RAX,RSI
JNZ 0x001011bd
MOV EAX,0x1
RET
LAB_... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
ulong uVar1;
bool bVar2;
if (param_2 == param_4) {
if (param_2 < 1) {
return 1;
}
uVar1 = 0;
while (*(int *)(param_1 + uVar1 * 4) == *(int *)(param_3 + uVar1 * 4)) {
bVar2 = uVar1 == param_2 - 1;
uVar1 = uVar1 + ... |
5,542 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[]... | O2 | c | func0:
endbr64
cmp %ecx,%esi
jne 1340 <func0+0x10>
jmpq 12b0 <func0.part.0>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
xor eax, eax
cmp esi, ecx
jnz short locret_135B
test esi, esi
jle short loc_1360
movsxd rsi, esi
xor eax, eax
jmp short loc_1351
loc_1348:
add rax, 1
cmp rax, rsi
jz short loc_1360
loc_1351:
mov ecx, [rdx+rax*4]
cmp [rdi+rax*4], ecx
jz short loc_1348
... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v5) == *(_DWORD *)(a3 + 4 * v5) )
{
if ... | func0:
ENDBR64
XOR EAX,EAX
CMP ESI,ECX
JNZ 0x0010135b
TEST ESI,ESI
JLE 0x00101360
MOVSXD RSI,ESI
XOR EAX,EAX
JMP 0x00101351
LAB_00101348:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101360
LAB_00101351:
MOV ECX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JZ 0x00101348
XOR EAX,EAX
LAB_0010135b:
RET
LAB_00101360:
MOV ... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
long lVar1;
if (param_2 != param_4) {
return 0;
}
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) != *(int *)(param_3 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 !... |
5,543 | func0 |
#include <assert.h>
#include <stdbool.h>
void remove_odd(int l[], int *size) {
int write_index = 0;
for (int i = 0; i < *size; ++i) {
if (l[i] % 2 == 0) {
l[write_index++] = l[i];
}
}
*size = write_index;
}
| bool func0(int arr1[], int size1, int arr2[], int size2) {
if (size1 != size2) return false;
for (int i = 0; i < size1; i++) {
if (arr1[i] != arr2[i]) return false;
}
return true;
}
| int main() {
int l1[] = {1, 2, 3};
int l2[] = {2, 4, 6};
int l3[] = {10, 20, 3};
int sizeL1 = 3, sizeL2 = 3, sizeL3 = 3;
remove_odd(l1, &sizeL1);
remove_odd(l2, &sizeL2);
remove_odd(l3, &sizeL3);
int expectedL1[] = {2};
int expectedL2[] = {2, 4, 6};
int expectedL3[]... | O3 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
jne 137e <func0+0x2e>
test %esi,%esi
jle 1380 <func0+0x30>
sub $0x1,%esi
xor %eax,%eax
jmp 1374 <func0+0x24>
nopl (%rax)
lea 0x1(%rax),%rcx
cmp %rsi,%rax
je 1380 <func0+0x30>
mov %rcx,%rax
mov (%rdx,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4... | func0_part_0:
test esi, esi
jle short loc_12D0
movsxd rsi, esi
xor eax, eax
lea rcx, ds:0[rsi*4]
jmp short loc_12C1
loc_12B8:
add rax, 4
cmp rcx, rax
jz short loc_12D0
loc_12C1:
mov esi, [rdx+rax]
cmp [rdi+rax], esi
jz short loc_12B8
xor eax, eax
retn
loc_12D0:
mov ... | long long func0_part_0(long long a1, int a2, long long a3)
{
long long v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + v3) == *(_DWORD *)(a3 + v3) )
{
v3 += 4LL;
if ( 4LL * a2 == v3 )
return 1LL;
}
return 0LL;
} | func0.part.0:
TEST ESI,ESI
JLE 0x001012d0
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RCX,[RSI*0x4]
JMP 0x001012c1
LAB_001012b8:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x001012d0
LAB_001012c1:
MOV ESI,dword ptr [RDX + RAX*0x1]
CMP dword ptr [RDI + RAX*0x1],ESI
JZ 0x001012b8
XOR EAX,EAX
RET
LAB_001012d0:
MOV EAX,0x1
RET | int8 func0_part_0(long param_1,int param_2,long param_3)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1) != *(int *)(param_3 + lVar1)) {
return 0;
}
lVar1 = lVar1 + 4;
} while ((long)param_2 * 4 - lVar1 != 0);
}
return 1;
} |
5,544 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1238 <func0+0x8f>
mov -0x4(%rbp),%eax
cltq
imul $0x96,%rax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x20(... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
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_1238
loc_11CC:
mov eax, [rbp+var_4]
cdqe
imul rdx, rax, 96h
mov rax, [rbp+var_18]
lea rcx, [rdx+rax... | long long func0(long long a1, int a2, int a3, long long a4)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
strcpy((char *)(50LL * i + a4), (const char *)(50LL * a3 + 150LL * i + a1));
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
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 0x00101238
LAB_001011cc:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
IMUL RDX,RAX,0x96
MOV RAX,qword ptr [RBP + -0x1... | 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) {
strcpy((char *)(param_4 + (long)local_c * 0x32),
(char *)((long)local_c * 0x96 + param_1 + (long)param_3 * 0x32));
}
return param_4;
} |
5,545 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") ... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rcx,%r13
test %esi,%esi
jle 11db <func0+0x52>
mov %rcx,%rbx
movslq %edx,%rdx
lea (%rdx,%rdx,4),%rax
lea (%rax,%rax,4),%rax
lea (%rdi,%rax,2),%rbp
lea -0x1(%rsi),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4)... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rcx
test esi, esi
jle short loc_11FB
mov rbx, rcx
movsxd rdx, edx
lea rax, [rdx+rdx*4]
lea rax, [rax+rax*4]
lea rbp, [rdi+rax*2]
lea eax, [rsi-1]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea ... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long v5; // rbx
long long v6; // rbp
long long v7; // r12
if ( a2 > 0 )
{
v5 = a4;
v6 = a1 + 50LL * a3;
v7 = a4 + 50LL * (unsigned int)(a2 - 1) + 50;
do
{
strcpy(v5, v6);
v5 += 50LL;
v6 += 150LL;
}
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RCX
TEST ESI,ESI
JLE 0x001011fb
MOV RBX,RCX
MOVSXD RDX,EDX
LEA RAX,[RDX + RDX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBP,[RDI + RAX*0x2]
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA R12,[RCX + RAX*0x2 + 0x32]
LAB_001011e0:
MOV ... | char * func0(long param_1,int param_2,int param_3,char *param_4)
{
char *__dest;
char *__src;
if (0 < param_2) {
__src = (char *)(param_1 + (long)param_3 * 0x32);
__dest = param_4;
do {
strcpy(__dest,__src);
__dest = __dest + 0x32;
__src = __src + 0x96;
} while (__dest != par... |
5,546 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") ... | O2 | c | func0:
endbr64
push %r12
mov %rcx,%r12
push %rbp
push %rbx
test %esi,%esi
jle 161e <func0+0x4e>
movslq %edx,%rdx
lea (%rdx,%rdx,4),%rax
lea (%rax,%rax,4),%rax
lea (%rdi,%rax,2),%rbx
lea -0x1(%rsi),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x32(%rcx,%rax,2),%rbp
xchg %ax... | func0:
endbr64
push r12
mov r12, rcx
push rbp
push rbx
test esi, esi
jle short loc_151E
movsxd rdx, edx
lea rax, [rdx+rdx*4]
lea rax, [rax+rax*4]
lea rbx, [rdi+rax*2]
lea eax, [rsi-1]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea rbp, [rcx+rax*2+32h]
xchg ax, ax
loc_1... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long v4; // r12
long long v5; // rbx
long long v6; // rbp
long long v7; // rsi
v4 = a4;
if ( a2 > 0 )
{
v5 = a1 + 50LL * a3;
v6 = a4 + 50LL * (unsigned int)(a2 - 1) + 50;
do
{
v7 = v5;
v5 += 150LL;
a4 = ... | func0:
ENDBR64
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x0010151e
MOVSXD RDX,EDX
LEA RAX,[RDX + RDX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBX,[RDI + RAX*0x2]
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBP,[RCX + RAX*0x2 + 0x32]
NOP
LAB_00101500:
MOV RSI,RBX
MOV RDI,RCX
ADD RBX,0... | char * func0(long param_1,int param_2,int param_3,char *param_4)
{
char *pcVar1;
char *__src;
if (0 < param_2) {
pcVar1 = param_4;
__src = (char *)(param_1 + (long)param_3 * 0x32);
do {
pcVar1 = strcpy(pcVar1,__src);
pcVar1 = pcVar1 + 0x32;
__src = __src + 0x96;
} while (pcVa... |
5,547 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char** func0(char list1[][3][50], int count, int n, char result[][50]) {
for(int i = 0; i < count; i++) {
strcpy(result[i], list1[i][n]);
}
return result;
}
| int main() {
char data[4][3][50] = {{"Greyson Fulton", "98", "99"}, {"Brady Kent", "97", "96"}, {"Wyatt Knott", "91", "94"}, {"Beau Turnbull", "94", "98"}};
char result[4][50];
func0(data, 4, 0, result);
assert(strcmp(result[0], "Greyson Fulton") == 0);
assert(strcmp(result[1], "Brady Kent") ... | O3 | c | func0:
endbr64
push %r12
mov %rcx,%r12
push %rbp
push %rbx
test %esi,%esi
jle 161e <func0+0x4e>
movslq %edx,%rdx
lea (%rdx,%rdx,4),%rax
lea (%rax,%rax,4),%rax
lea (%rdi,%rax,2),%rbx
lea -0x1(%rsi),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x32(%rcx,%rax,2),%rbp
xchg %ax... | func0:
endbr64
push r12
mov r12, rcx
push rbp
push rbx
test esi, esi
jle short loc_14FE
movsxd rdx, edx
movsxd rsi, esi
lea rax, [rdx+rdx*4]
lea rax, [rax+rax*4]
lea rbx, [rdi+rax*2]
lea rax, [rsi+rsi*4]
lea rax, [rax+rax*4]
lea rbp, [rcx+rax*2]
nop dword ptr [rax]
loc_... | char * func0(long long a1, int a2, int a3, char *a4)
{
char *v4; // r12
const char *v5; // rbx
char *v6; // rbp
const char *v7; // rsi
v4 = a4;
if ( a2 > 0 )
{
v5 = (const char *)(a1 + 50LL * a3);
v6 = &a4[50 * a2];
do
{
v7 = v5;
v5 += 150;
a4 = strcpy(a4, v7) + 50;
... | func0:
ENDBR64
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001014fe
MOVSXD RDX,EDX
MOVSXD RSI,ESI
LEA RAX,[RDX + RDX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBX,[RDI + RAX*0x2]
LEA RAX,[RSI + RSI*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBP,[RCX + RAX*0x2]
NOP dword ptr [RAX]
LAB_001014e0:
MOV RSI,RBX
MOV RDI,RCX
ADD RB... | char * func0(long param_1,int param_2,int param_3,char *param_4)
{
char *pcVar1;
char *__src;
if (0 < param_2) {
pcVar1 = param_4;
__src = (char *)(param_1 + (long)param_3 * 0x32);
do {
pcVar1 = strcpy(pcVar1,__src);
pcVar1 = pcVar1 + 0x32;
__src = __src + 0x96;
} while (pcVa... |
5,548 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d8 <func0+0x6f>
movl $0x0,-0x4(%rbp)
jmp 11cc <func0+0x63>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_8], 0
jmp short loc_11D8
loc_1188:
mov [rbp+var_4], 0
jmp short loc_11CC
loc_1191:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov ... | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a4; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a3) )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d8
LAB_00101188:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cc
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int local_10;
int local_c;
local_10 = 0;
do {
if (param_2 <= local_10) {
return 0;
}
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_10 * 4) == *(int *)(param_3 + (long)lo... |
5,549 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11ad <func0+0x44>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov %rdx,%rdi
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%rsi
test %ecx,%ecx
jle 119e <func0+0x35>
mov (%r8),%edx
mov %rdi,%rax
cmp (%rax),%edx
je 11b3 <func0+0x4a>
add ... | func0:
endbr64
test esi, esi
jle short loc_11AA
mov r8, rdi
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
lea eax, [rcx-1]
lea rdi, [rdx+rax*4+4]
loc_1184:
test ecx, ecx
jle short loc_119B
mov esi, [r8]
mov rax, rdx
loc_118E:
cmp esi, [rax]
jz short loc_11B0
add rax, 4
cm... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v4; // r8
_DWORD *v5; // rax
if ( a2 <= 0 )
return 0LL;
v4 = a1;
while ( a4 <= 0 )
{
LABEL_7:
if ( ++v4 == &a1[a2 - 1 + 1] )
return 0LL;
}
v5 = a3;
while ( *v4 != *v5 )
{
if ( ++v5 == &a3[a4 - 1 + 1] )
goto L... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011aa
MOV R8,RDI
LEA EAX,[RSI + -0x1]
LEA R9,[RDI + RAX*0x4 + 0x4]
LEA EAX,[RCX + -0x1]
LEA RDI,[RDX + RAX*0x4 + 0x4]
LAB_00101184:
TEST ECX,ECX
JLE 0x0010119b
MOV ESI,dword ptr [R8]
MOV RAX,RDX
LAB_0010118e:
CMP ESI,dword ptr [RAX]
JZ 0x001011b0
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x001011... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (param_2 < 1) {
return 0;
}
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (0 < param_4) {
piVar2 = param_3;
do {
if (*param_1 == *piVar2) {
return 1;
}
... |
5,550 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1289 <func0+0x49>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r8
test %ecx,%ecx
jle 1280 <func0+0x40>
mov (%rdi),%esi
mov %rdx,%rax
jmp 1271 <func0+0x31>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %r8,%rax
j... | func0:
endbr64
test esi, esi
jle short loc_1339
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
lea eax, [rcx-1]
lea r8, [rdx+rax*4+4]
loc_1308:
test ecx, ecx
jle short loc_1330
mov esi, [rdi]
mov rax, rdx
jmp short loc_1321
loc_1318:
add rax, 4
cmp rax, r8
jz short loc_133... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
long long v4; // r9
_DWORD *v5; // rax
if ( a2 <= 0 )
return 0LL;
v4 = (long long)&a1[a2 - 1 + 1];
while ( a4 <= 0 )
{
LABEL_8:
if ( ++a1 == (_DWORD *)v4 )
return 0LL;
}
v5 = a3;
while ( *a1 != *v5 )
{
if ( ++v5 == &a3[a4 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101339
LEA EAX,[RSI + -0x1]
LEA R9,[RDI + RAX*0x4 + 0x4]
LEA EAX,[RCX + -0x1]
LEA R8,[RDX + RAX*0x4 + 0x4]
LAB_00101308:
TEST ECX,ECX
JLE 0x00101330
MOV ESI,dword ptr [RDI]
MOV RAX,RDX
JMP 0x00101321
LAB_00101318:
ADD RAX,0x4
CMP RAX,R8
JZ 0x00101330
LAB_00101321:
CMP ESI,dword ptr [... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (0 < param_4) {
piVar2 = param_3;
do {
if (*param_1 == *piVar2) {
return 1;
}
... |
5,551 | func0 |
#include <assert.h>
| int func0(int *list1, int size1, int *list2, int size2) {
int i, j;
for (i = 0; i < size1; i++) {
for (j = 0; j < size2; j++) {
if (list1[i] == list2[j]) {
return 1;
}
}
}
return 0;
}
| int main() {
int list1_a[] = {1, 2, 3, 4, 5};
int list2_a[] = {6, 7, 8, 9};
assert(func0(list1_a, 5, list2_a, 4) == 0);
int list1_b[] = {1, 2, 3};
int list2_b[] = {4, 5, 6};
assert(func0(list1_b, 3, list2_b, 3) == 0);
int list1_c[] = {1, 4, 5};
int list2_c[] = {1, 4, 5};
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1239 <func0+0x49>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r8
test %ecx,%ecx
jle 1230 <func0+0x40>
mov (%rdi),%esi
mov %rdx,%rax
jmp 1221 <func0+0x31>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %r8,%rax
j... | func0:
endbr64
test esi, esi
jle short loc_1189
movsxd rsi, esi
movsxd rax, ecx
lea r8, [rdi+rsi*4]
lea rsi, [rdx+rax*4]
loc_1156:
test ecx, ecx
jle short loc_1190
loc_115A:
mov ecx, [rdi]
mov rax, rdx
jmp short loc_1171
loc_1168:
add rax, 4
cmp rax, rsi
jz short loc_118... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v4; // r8
_DWORD *v5; // rax
if ( a2 > 0 )
{
v4 = &a1[a2];
while ( a4 <= 0 )
{
if ( ++a1 == v4 )
return 0LL;
}
do
{
v5 = a3;
do
{
if ( *a1 == *v5 )
return 1LL;
++... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101189
MOVSXD RSI,ESI
MOVSXD RAX,ECX
LEA R8,[RDI + RSI*0x4]
LEA RSI,[RDX + RAX*0x4]
LAB_00101156:
TEST ECX,ECX
JLE 0x00101190
LAB_0010115a:
MOV ECX,dword ptr [RDI]
MOV RAX,RDX
JMP 0x00101171
LAB_00101168:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x00101180
LAB_00101171:
CMP ECX,dword ptr [RAX]
JNZ... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (0 < param_4) {
do {
piVar2 = param_3;
do {
if (*param_1 == *piVar2) {
return 1;
}
... |
5,552 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
... | int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
cmpl $0x1,-0x1c(%rbp)
jg 118c <func0+0x23>
mov $0x0,%eax
jmpq 1258 <func0+0xef>
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
mov -0x18(%rbp),%rax
mov 0x4(%rax),%eax
... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
cmp [rbp+var_1C], 1
jg short loc_118C
mov eax, 0
jmp loc_1258
loc_118C:
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_10], eax
mov rax, [rbp+var_18]
mov eax,... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v4; // [rsp+18h] [rbp-10h]
int v5; // [rsp+1Ch] [rbp-Ch]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
if ( a2 <= 1 )
return 0LL;
v4 = *a1;
v5 = a1[1];
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( a1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
CMP dword ptr [RBP + -0x1c],0x1
JG 0x0010118c
MOV EAX,0x0
JMP 0x00101258
LAB_0010118c:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV RAX,qword... | int * func0(int *param_1,int param_2,int *param_3)
{
int local_18;
int local_14;
int local_10;
int local_c;
if (param_2 < 2) {
param_3 = (int *)0x0;
}
else {
local_18 = *param_1;
local_14 = param_1[1];
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) ... |
5,553 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
... | int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11da <func0+0x71>
push %r12
push %rbp
push %rbx
mov %rdx,%r12
mov (%rdi),%r8d
mov 0x4(%rdi),%r9d
mov $0x0,%ebx
mov $0x1,%ebp
mov $0x1,%ecx
jmp 1195 <func0+0x2c>
mov %ebp,%ebx
mov %ecx,%ebp
movslq %ebx,%r10
mov (%rdi,%r10,4),%r10d
movslq %ecx,%r1... | func0:
endbr64
cmp esi, 1
jle short loc_11DE
push r12
push rbp
push rbx
mov rax, rdi
mov ebx, esi
mov r12, rdx
mov esi, [rdi]
mov edi, [rdi+4]
mov edx, 0
mov ebp, 1
mov ecx, 1
jmp short loc_1198
loc_1194:
mov edx, ebp
mov ebp, ecx
loc_1198:
movsxd r8, edx
mo... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v6; // esi
int v7; // edi
int v8; // edx
int v9; // ebp
int v10; // ecx
int v11; // r10d
int v12; // r9d
if ( a2 <= 1 )
return 0LL;
v6 = *a1;
v7 = a1[1];
v8 = 0;
v9 = 1;
v10 = 1;
while ( 1 )
{
do
{
v11 = a1[v10] * a1[v8];... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011de
PUSH R12
PUSH RBP
PUSH RBX
MOV RAX,RDI
MOV EBX,ESI
MOV R12,RDX
MOV ESI,dword ptr [RDI]
MOV EDI,dword ptr [RDI + 0x4]
MOV EDX,0x0
MOV EBP,0x1
MOV ECX,0x1
JMP 0x00101198
LAB_00101194:
MOV EDX,EBP
MOV EBP,ECX
LAB_00101198:
MOVSXD R8,EDX
MOV R8D,dword ptr [RAX + R8*0x4]
MOVSXD R9,E... | int * func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (1 < param_2) {
iVar5 = *param_1;
iVar6 = param_1[1];
iVar2 = 1;
iVar1 = 1;
iVar3 = 0;
do {
iVar4 = iVar1;
if (iVar5 * iVar6 < param_1[iVar3] * ... |
5,554 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
... | int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 143e <func0+0x6e>
mov (%rdi),%r8d
mov 0x4(%rdi),%r9d
push %rbp
mov $0x1,%ecx
push %rbx
mov %rdx,%rbp
mov $0x1,%ebx
mov %r8d,%edx
nopw 0x0(%rax,%rax,1)
movslq %ecx,%r10
mov (%rdi,%r10,4),%eax
mov %r9d,%r10d
imul %r8d,%r10d
mov %eax,%r11d
imul %e... | func0:
endbr64
cmp esi, 1
jle short loc_135D
push rbp
mov ecx, 1
mov rbp, rdx
mov edx, 1
push rbx
mov rbx, rdi
mov edi, [rdi]
mov r8d, [rbx+4]
mov r10d, edi
nop dword ptr [rax+00h]
loc_1318:
movsxd r9, ecx
mov r11d, r8d
mov r9d, [rbx+r9*4]
imul r11d, edi
mov ... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v3; // ecx
long long v5; // rdx
int v7; // edi
int v8; // r8d
int v9; // r10d
int v10; // r11d
int v11; // eax
_DWORD *result; // rax
if ( a2 <= 1 )
return 0LL;
v3 = 1;
v5 = 1LL;
v7 = *a1;
v8 = a1[1];
v9 = v7;
while ( 1 )
{
do
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010135d
PUSH RBP
MOV ECX,0x1
MOV RBP,RDX
MOV EDX,0x1
PUSH RBX
MOV RBX,RDI
MOV EDI,dword ptr [RDI]
MOV R8D,dword ptr [RBX + 0x4]
MOV R10D,EDI
NOP dword ptr [RAX]
LAB_00101318:
MOVSXD R9,ECX
MOV R11D,R8D
MOV R9D,dword ptr [RBX + R9*0x4]
IMUL R11D,EDI
MOV EAX,R9D
IMUL EAX,R10D
CMP EAX,R11... | int * func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 < 2) {
return (int *)0x0;
}
iVar1 = 1;
lVar2 = 1;
iVar3 = *param_1;
iVar4 = param_1[1];
iVar5 = iVar3;
while( true ) {
do {
if (iVar4 * iVar3 < param_1[iVa... |
5,555 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int arr[], int arr_len, int result[2]) {
if (arr_len < 2) {
return NULL; // No pairs exist
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > x * y) {
... | int main() {
int result1[2];
int arr1[] = {1,2,3,4,7,0,8,4};
func0(arr1, 8, result1);
assert(result1[0] == 7 && result1[1] == 8);
int result2[2];
int arr2[] = {0,-1,-2,-4,5,0,-6};
func0(arr2, 7, result2);
assert(result2[0] == -4 && result2[1] == -6);
int result3[2];
... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 140e <func0+0x6e>
mov (%rdi),%r8d
mov 0x4(%rdi),%r9d
push %rbp
mov $0x1,%ecx
push %rbx
mov %rdx,%rbp
mov $0x1,%ebx
mov %r8d,%edx
nopw 0x0(%rax,%rax,1)
movslq %ecx,%r10
mov (%rdi,%r10,4),%eax
mov %r9d,%r10d
imul %r8d,%r10d
mov %eax,%r11d
imul %e... | func0:
endbr64
cmp esi, 1
jle short loc_137D
push r12
mov r12d, esi
push rbp
mov rbp, rdx
mov edx, 1
push rbx
mov rbx, rdi
mov r8d, [rdi]
mov edi, [rdi+4]
nop dword ptr [rax+00000000h]
loc_1338:
mov r10d, [rbx+rdx*4-4]
mov rcx, rdx
loc_1340:
mov r9d, [rbx+rcx*4]
... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
long long v4; // rdx
int v6; // r8d
int v7; // edi
int v8; // r10d
long long v9; // rcx
int v10; // r9d
int v11; // r11d
_DWORD *result; // rax
if ( a2 <= 1 )
return 0LL;
v4 = 1LL;
v6 = *a1;
v7 = a1[1];
do
{
v8 = a1[v4 - 1];
v9 = v4;... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010137d
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDX
MOV EDX,0x1
PUSH RBX
MOV RBX,RDI
MOV R8D,dword ptr [RDI]
MOV EDI,dword ptr [RDI + 0x4]
NOP dword ptr [RAX]
LAB_00101338:
MOV R10D,dword ptr [RBX + RDX*0x4 + -0x4]
MOV RCX,RDX
LAB_00101340:
MOV R9D,dword ptr [RBX + RCX*0x4]
MOV R11D,R8D... | int * func0(int *param_1,uint param_2,int *param_3)
{
ulong uVar1;
ulong uVar2;
int iVar3;
int iVar4;
if ((int)param_2 < 2) {
return (int *)0x0;
}
uVar2 = 1;
iVar4 = *param_1;
iVar3 = param_1[1];
do {
uVar1 = uVar2;
do {
if (iVar4 * iVar3 < param_1[uVar2 - 1] * param_1[uVar1]) ... |
5,556 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x34(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_24]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov ... | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
_DWORD v4[3]; // [rsp+8h] [rbp-30h] BYREF
int v5; // [rsp+14h] [rbp-24h]
int i; // [rsp+1Ch] [rbp-1Ch]
long long v7; // [rsp+20h] [rbp-18h]
_DWORD *v8; // [rsp+28h] [rbp-10h]
unsigned long long v9; // [rsp+30h] [rbp-8h]
v5 = a1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB R... | int4 func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_38 [12];
int local_2c;
int local_24;
long local_20;
int *local_18;
long local_10;
local_2c = param_1;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_1 + 1) + -1;
... |
5,557 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r8d, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A7:
cm... | long long func0(int a1)
{
signed long long v2; // rax
void *v3; // rsp
unsigned long long v4; // rax
long long v5; // rdi
long long v6; // rax
int v7; // esi
int v8; // r9d
_BYTE v11[3]; // [rsp+8h] [rbp-10h] BYREF
char v12; // [rsp+Bh] [rbp-Dh] BYREF
unsigned long long v13; // [rsp+10h] [rbp-8h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R8D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a7:
CMP RSP,RDX
JZ 0x001011be
SUB RSP,0x1000
OR qword ptr [RSP ... | int4 func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int1 *puVar6;
uint uVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_1 + 1) * 4 + 0xf;
for (puVar6 = auStack_18; puVar6 != auSta... |
5,558 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rcx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%... | func0:
endbr64
push rbp
movsxd r9, edi
lea edi, [r9+1]
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cm... | long long func0(int a1)
{
long long v1; // r9
int v2; // edi
long long v3; // rdx
long long *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
long long v8; // rdx
int v9; // eax
long long v11; // [rsp+0h] [rbp-1018h]
long long v12; // [rsp+8h] [rbp-1010h] BYREF
int v13;... | func0:
ENDBR64
PUSH RBP
MOVSXD R9,EDI
LEA EDI,[R9 + 0x1]
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010126a
LAB_00101255:
SUB RSP,0x1000
OR qwor... | int4 func0(int param_1)
{
long lVar1;
int1 *puVar2;
uint uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int1 *puVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar8;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)(param_1 + 1U) * 4 + ... |
5,559 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 1000000
| int func0(int n) {
int dp[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i / 2] + dp[i / 3] + dp[i / 4];
if (dp[i] < i) {
dp[i] = i;
}
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rcx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%... | func0:
endbr64
push rbp
movsxd r10, edi
lea r8d, [r10+1]
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, r8d
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
... | long long func0(int a1)
{
int v1; // r8d
long long v2; // rdx
_QWORD *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
long long v7; // rdx
int v8; // r11d
int v9; // esi
int v10; // ecx
int v11; // eax
int v12; // eax
_QWORD v15[511]; // [rsp+8h] [rbp-1010h] BYREF
... | func0:
ENDBR64
PUSH RBP
MOVSXD R10,EDI
LEA R8D,[R10 + 0x1]
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,R8D
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010126a
LAB_00101255:
SUB RSP,0x1000
OR qw... | int4 func0(int param_1)
{
long lVar1;
int *puVar2;
int iVar3;
uint uVar4;
int iVar5;
ulong uVar6;
long lVar7;
int *puVar8;
int iVar10;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar9;
puVar8 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)(int... |
5,560 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t n... | int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov -0x40(%rbp),%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x3,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x3... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rdx, [rbp+var_40]
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov [rbp... | _QWORD * func0(long long a1, unsigned long long a2, _DWORD *a3)
{
int v5; // [rsp+20h] [rbp-30h]
int i; // [rsp+24h] [rbp-2Ch]
int v7; // [rsp+28h] [rbp-28h]
int j; // [rsp+2Ch] [rbp-24h]
_QWORD *v9; // [rsp+30h] [rbp-20h]
long long size; // [rsp+38h] [rbp-18h]
v9 = malloc(24 * a2);
v5 = 0;
for ( i =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x30... | void * func0(long param_1,ulong param_2,int *param_3)
{
long lVar1;
bool bVar2;
void *pvVar3;
size_t __size;
void *pvVar4;
int local_38;
int local_34;
int local_2c;
pvVar3 = malloc(param_2 * 0x18);
local_38 = 0;
local_34 = 0;
do {
if (param_2 <= (ulong)(long)local_34) {
*param_3 = ... |
5,561 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t n... | int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %rsi,%rbx
mov %rdx,0x18(%rsp)
lea (%rsi,%rsi,2),%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r13
test %rbx,%rbx
je 12e1 <func0+0xf8>
mov %r12,%rbp
lea (%r12,%... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r12, rdi
mov rbx, rsi
mov [rsp+58h+var_40], rdx
lea rdi, [rsi+rsi*2]
shl rdi, 3
call _malloc
mov r13, rax
test rbx, rbx
jz loc_12E1
mov rbp, r12
lea rax, [r12+rbx*2]
mov... | long long func0(char *a1, long long a2, int *a3)
{
long long v3; // r13
char *v4; // rbp
int v5; // r12d
long long v6; // r15
long long v7; // rax
long long v8; // rbx
char v9; // r14
_BYTE *v10; // rax
long long v11; // rax
long long v12; // rbx
v3 = malloc(24 * a2);
if ( a2 )
{
v4 = a1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R12,RDI
MOV RBX,RSI
MOV qword ptr [RSP + 0x18],RDX
LEA RDI,[RSI + RSI*0x2]
SHL RDI,0x3
CALL 0x001010e0
MOV R13,RAX
TEST RBX,RBX
JZ 0x001012e1
MOV RBP,R12
LEA RAX,[R12 + RBX*0x2]
MOV qword ptr [RSP + 0x8],RAX
MOV R12D,0x0
LEA RAX,[R13 ... | char * func0(char *param_1,long param_2,int *param_3)
{
size_t __size;
char *pcVar1;
char cVar2;
long lVar3;
char *pcVar4;
void *pvVar5;
char *pcVar6;
char *pcVar7;
int iVar8;
pcVar4 = (char *)malloc(param_2 * 0x18);
if (param_2 == 0) {
iVar8 = 0;
}
else {
pcVar1 = param_1 + param_... |
5,562 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t n... | int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
lea (%rsi,%rsi,1),%r13
push %r12
lea 0x0(%r13,%rsi,1),%rdi
push %rbp
shl $0x3,%rdi
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %rdx,0x18(%rsp)
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rbx,%rbx
je 15a6 <func0+0x116>
l... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
lea r13, [rsi+rsi]
push r12
lea rdi, [r13+rsi+0]
push rbp
shl rdi, 3
push rbx
mov rbx, rsi
sub rsp, 28h
mov [rsp+58h+var_40], rdx
call _malloc
mov r12, rax
test rbx, rbx
jz loc_15A6
lea rax, [r14+r13]... | long long func0(char *a1, long long a2, _DWORD *a3)
{
char *v3; // r14
long long v4; // r12
int v5; // r15d
char v6; // bp
long long v7; // rbx
long long v8; // r13
long long v9; // rax
char v10; // si
long long v12; // rax
long long v13; // rbx
_BYTE *v14; // rax
char v15; // si
char *v16; /... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
LEA R13,[RSI + RSI*0x1]
PUSH R12
LEA RDI,[R13 + RSI*0x1]
PUSH RBP
SHL RDI,0x3
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDX
CALL 0x001010c0
MOV R12,RAX
TEST RBX,RBX
JZ 0x001015a6
LEA RAX,[R14 + R13*0x1]
XOR R15D,R15D
MOV qword ptr [RSP + 0x8],RAX
... | char * func0(char *param_1,long param_2,int *param_3)
{
size_t __size;
char *pcVar1;
char cVar2;
char cVar3;
char *pcVar4;
void *pvVar5;
long lVar6;
char *pcVar7;
char *pcVar8;
int iVar9;
pcVar4 = (char *)malloc(param_2 * 0x18);
if (param_2 == 0) {
iVar9 = 0;
}
else {
pcVar1 = pa... |
5,563 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char key;
char *values;
size_t size;
} TupleGroup;
| TupleGroup *func0(char Input[][2], size_t n, int *returnSize) {
TupleGroup *out = malloc(n * sizeof(TupleGroup));
int outCount = 0;
for (int i = 0; i < n; i++) {
int found = 0;
for (int j = 0; j < outCount; j++) {
if (out[j].key == Input[i][0]) {
size_t n... | int main() {
char input1[][2] = { {'x', 'y'}, {'x', 'z'}, {'w', 't'} };
int size1;
TupleGroup *result1 = func0(input1, 3, &size1);
assert(size1 == 2);
assert(memcmp(result1[0].values, "xyz", 3) == 0 && result1[0].size == 3);
assert(memcmp(result1[1].values, "wt", 2) == 0 && result1[1].size... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
lea (%rsi,%rsi,1),%r13
push %r12
lea 0x0(%r13,%rsi,1),%rdi
push %rbp
shl $0x3,%rdi
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %rdx,0x18(%rsp)
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rbx,%rbx
je 15a6 <func0+0x116>
l... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
lea rbp, [rsi+rsi]
push rbx
lea rdi, [rbp+rsi+0]
mov rbx, rsi
shl rdi, 3; size
sub rsp, 28h
mov [rsp+58h+var_40], rdx
call _malloc
mov r13, rax
test rbx, rbx
jz loc_15BF
lea rax, [r1... | char * func0(char *a1, long long a2, int *a3)
{
char *v3; // r14
char *v4; // r13
int v5; // r15d
char v6; // bp
long long v7; // rcx
char *v8; // rbx
size_t v9; // rbp
_BYTE *v10; // rax
char v11; // si
char *v12; // rbx
_WORD *v13; // rax
char v14; // dl
__int16 v15; // cx
char *v17; // [r... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
LEA RBP,[RSI + RSI*0x1]
PUSH RBX
LEA RDI,[RBP + RSI*0x1]
MOV RBX,RSI
SHL RDI,0x3
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDX
CALL 0x001010c0
MOV R13,RAX
TEST RBX,RBX
JZ 0x001015bf
LEA RAX,[R14 + RBP*0x1]
XOR R15D,R15D
MOV qword ptr [RSP],RAX
NOP wo... | char * func0(char *param_1,long param_2,int *param_3)
{
size_t __size;
char cVar1;
long lVar2;
char *pcVar3;
void *pvVar4;
int2 *puVar5;
long lVar6;
char *pcVar7;
char cVar8;
char *pcVar9;
char *pcVar10;
int iVar11;
pcVar3 = (char *)malloc(param_2 * 0x18);
if (param_2 == 0) {
iVar11 ... |
5,564 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return ma... | int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1205 <func0+0x7c>
movl $0x0,-0xc(%rbp)
jmp 11e2 <func0+0x59>
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 11de <... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
mov [rbp+var_10], 0
jmp short loc_1205
loc_11B0:
mov [rbp+var_C], 0
jmp short loc_11E2
loc_11B9:
mov eax, [rbp+var_C]
cmp eax... | long long func0(long long a1, int a2)
{
int v3; // [rsp+18h] [rbp-14h]
int i; // [rsp+1Ch] [rbp-10h]
int j; // [rsp+20h] [rbp-Ch]
long long v6; // [rsp+24h] [rbp-8h]
v3 = 0;
v6 = a1;
for ( i = 0; i < a2; ++i )
{
for ( j = 0; *(_DWORD *)(a1 + 16LL * i + 4LL * j); ++j )
{
if ( j > v3 )
... | 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
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101205
LAB_001011b0:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011e2
LAB_001011b9:
MOV ... | long func0(long param_1,int param_2)
{
int4 local_1c;
int4 local_18;
int4 local_14;
int8 local_10;
local_1c = 0;
local_10 = param_1;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
local_14 = 0;
while (*(int *)((long)local_18 * 0x10 + param_1 + (long)local_14 * 4) != 0) {
... |
5,565 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return ma... | int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11d8 <func0+0x4f>
mov %rdi,%r8
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%r9
mov $0x0,%edx
jmp 11c5 <func0+0x3c>
add $0x1,%rax
cmpl $0x0,(%rcx,%rax,4)
je 11bc <func0+0x33>
cmp %eax,%edx
jge 11a7 <func0+0x1e>
mov %rsi,%rdi
mov %e... | func0:
endbr64
test esi, esi
jle short loc_11D5
mov r8, rdi
lea eax, [rsi-1]
shl rax, 4
lea rsi, [rdi+rax+10h]
mov ecx, 0
jmp short loc_11C5
loc_11A7:
add rax, 1
cmp dword ptr [rdx+rax*4], 0
jz short loc_11BC
loc_11B1:
cmp ecx, eax
jge short loc_11A7
mov rdi, rdx
... | _DWORD * func0(_DWORD *a1, int a2)
{
_DWORD *v2; // r8
long long v3; // rsi
int v4; // ecx
long long v5; // rax
if ( a2 > 0 )
{
v2 = a1;
v3 = (long long)&a1[4 * (a2 - 1) + 4];
v4 = 0;
do
{
v5 = 0LL;
if ( *v2 )
{
do
{
if ( v4 < (int)v5 )
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011d5
MOV R8,RDI
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA RSI,[RDI + RAX*0x1 + 0x10]
MOV ECX,0x0
JMP 0x001011c5
LAB_001011a7:
ADD RAX,0x1
CMP dword ptr [RDX + RAX*0x4],0x0
JZ 0x001011bc
LAB_001011b1:
CMP ECX,EAX
JGE 0x001011a7
MOV RDI,RDX
MOV ECX,EAX
JMP 0x001011a7
LAB_001011bc:
ADD R8,... | int * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
int iVar4;
int *piVar5;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
iVar4 = 0;
piVar5 = param_1;
do {
lVar3 = 0;
iVar2 = *piVar5;
while (iVar2 != 0) {
if (iVar4 <... |
5,566 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return ma... | int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1463 <func0+0x53>
lea -0x1(%rsi),%eax
mov %rdi,%r8
xor %edx,%edx
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%rcx
nopl 0x0(%rax)
mov (%rdi),%esi
xor %eax,%eax
test %esi,%esi
je 1456 <func0+0x46>
nopl 0x0(%rax,%rax,1)
cmp %eax,%edx
jge 1449 <func0+0x39>... | func0:
endbr64
test esi, esi
jle short loc_137B
lea eax, [rsi-1]
mov r8, rdi
xor edx, edx
shl rax, 4
lea rcx, [rdi+rax+10h]
nop dword ptr [rax+00000000h]
loc_1350:
mov esi, [rdi]
xor eax, eax
test esi, esi
jz short loc_136E
loc_1358:
cmp edx, eax
jge short loc_1361... | _DWORD * func0(_DWORD *a1, int a2)
{
_DWORD *v2; // r8
int v3; // edx
long long v4; // rcx
long long v5; // rax
if ( a2 <= 0 )
return a1;
v2 = a1;
v3 = 0;
v4 = (long long)&a1[4 * (a2 - 1) + 4];
do
{
v5 = 0LL;
if ( *a1 )
{
do
{
if ( v3 < (int)v5 )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010137b
LEA EAX,[RSI + -0x1]
MOV R8,RDI
XOR EDX,EDX
SHL RAX,0x4
LEA RCX,[RDI + RAX*0x1 + 0x10]
NOP dword ptr [RAX]
LAB_00101350:
MOV ESI,dword ptr [RDI]
XOR EAX,EAX
TEST ESI,ESI
JZ 0x0010136e
LAB_00101358:
CMP EDX,EAX
JGE 0x00101361
MOV R8,RDI
MOV EDX,EAX
LAB_00101361:
ADD RAX,0x1
MOV... | int * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
int iVar4;
int *piVar5;
if (param_2 < 1) {
return param_1;
}
iVar4 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
piVar5 = param_1;
do {
lVar3 = 0;
iVar2 = *param_1;
while (iVar2 != 0) {
if... |
5,567 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int lst[][4], int rows) {
int max_len = 0;
int* maxList = lst[0];
for (int i = 0; i < rows; i++) {
for (int j = 0; lst[i][j] != '\0'; j++) {
if (j > max_len) {
max_len = j;
maxList = lst[i];
}
}
}
return ma... | int main() {
int list1[][4] = {{'A','\0'}, {'A','B','\0'}, {'A','B','C','\0'}};
int list2[][4] = {{1,'\0'}, {1, 2, '\0'}, {1, 2, 3, '\0'}};
int list3[][4] = {{1,1,'\0'}, {1, 2, 3, '\0'}, {1, 5, 6, 1, '\0'}};
assert(func0(list1, 3)[2] == 'C');
assert(func0(list2, 3)[2] == 3);
assert(func0... | O3 | c | func0:
endbr64
mov %rdi,%rax
test %esi,%esi
jle 15ee <func0+0xbe>
lea -0x1(%rsi),%edx
mov %rdi,%r8
shl $0x4,%rdx
lea 0x10(%rdi,%rdx,1),%rsi
xor %edx,%edx
mov (%rax),%ecx
test %ecx,%ecx
je 15a0 <func0+0x70>
mov 0x4(%rax),%r9d
test %r9d,%r9d
je 15a0 <func0+0x70>
test %edx,%edx
j... | func0:
endbr64
test esi, esi
jle loc_161C
movsxd rsi, esi
xor eax, eax
shl rsi, 4
lea rdx, [rdi+rsi]
mov rsi, rdi
nop dword ptr [rax+00h]
loc_1560:
mov ecx, [rdi]
test ecx, ecx
jz short loc_15B8
mov r8d, [rdi+4]
test r8d, r8d
jz short loc_15B8
test eax, eax
jle ... | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // eax
_DWORD *v3; // rdx
_DWORD *v4; // rsi
long long v5; // rcx
if ( a2 > 0 )
{
v2 = 0;
v3 = &a1[4 * a2];
v4 = a1;
while ( 1 )
{
if ( !*a1 || !a1[1] )
goto LABEL_16;
if ( v2 <= 0 )
{
if ( a1[2] )
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010161c
MOVSXD RSI,ESI
XOR EAX,EAX
SHL RSI,0x4
LEA RDX,[RDI + RSI*0x1]
MOV RSI,RDI
NOP dword ptr [RAX]
LAB_00101560:
MOV ECX,dword ptr [RDI]
TEST ECX,ECX
JZ 0x001015b8
MOV R8D,dword ptr [RDI + 0x4]
TEST R8D,R8D
JZ 0x001015b8
TEST EAX,EAX
JLE 0x001015c8
MOV ECX,dword ptr [RDI + 0x8]
TE... | int * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
int *piVar4;
if (param_2 < 1) {
return param_1;
}
iVar2 = 0;
piVar1 = param_1 + (long)param_2 * 4;
piVar4 = param_1;
do {
if ((*piVar4 != 0) && (piVar4[1] != 0)) {
if (iVar2 < 1) {
if (piVar4[2] == ... |
5,568 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11e7 <func0+0x5e>
cvtsi2sdl -0x4(%rbp),%xmm1
movsd %xmm1,-0x28(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
mov [rbp+var_8], 0
jmp short loc_11EB
loc_11AC:
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_4]
movsd [rbp+var_28], xmm1
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
... | long long func0(long long a1, int a2)
{
int i; // [rsp+28h] [rbp-8h]
int v4; // [rsp+2Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
v4 = (int)(round(*(double *)(8LL * i + a1)) + (double)v4);
return (unsigned int)(a2 * v4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011eb
LAB_001011ac:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x4]
MOVSD qword ptr [RBP + -0x28],XMM1
MOV EAX,dword ptr [RBP + -0x8... | int func0(long param_1,int param_2)
{
double dVar1;
int4 local_10;
int4 local_c;
local_c = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
dVar1 = round(*(double *)(param_1 + (long)local_10 * 8));
local_c = (int)(dVar1 + (double)local_c);
}
return local_c * param_2;
} |
5,569 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == ... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %esi,%r13d
test %esi,%esi
jle 11e6 <func0+0x5d>
mov %rdi,%rbp
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r12
mov $0x0,%ebx
movsd 0x0(%rbp),%xmm0
callq 1070 <round@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13d, esi
test esi, esi
jle short loc_11E5
mov rbx, rdi
lea eax, [rsi-1]
lea r12, [rdi+rax*8+8]
mov ebp, 0
loc_11AE:
movsd xmm0, qword ptr [rbx]
call _round
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xm... | long long func0(double *a1, int a2)
{
double *v2; // rbx
int v3; // ebp
if ( a2 <= 0 )
{
v3 = 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 = (int)((double)v3 + round(*v2++));
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
}
return (unsigned int)(v3 * a2);
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13D,ESI
TEST ESI,ESI
JLE 0x001011e5
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R12,[RDI + RAX*0x8 + 0x8]
MOV EBP,0x0
LAB_001011ae:
MOVSD XMM0,qword ptr [RBX]
CALL 0x00101070
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
ADDSD XMM0,XMM1
CVTTSD2SI EBP,XMM0... | int func0(double *param_1,int param_2)
{
double *pdVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
pdVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
dVar3 = round(*param_1);
iVar2 = (int)((double)iVar2 + dVar3);
param_1 = param_1 + 1;
... |
5,570 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == ... | O2 | c | func0:
endbr64
test %esi,%esi
jle 13b0 <func0+0x60>
push %r13
lea -0x1(%rsi),%eax
mov %esi,%r13d
push %r12
lea 0x8(%rdi,%rax,8),%r12
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
nopw 0x0(%rax,%rax,1)
movsd 0x0(%rbp),%xmm0
add $0x8,%rbp
callq 1070 <round@plt>
movapd... | func0:
endbr64
test esi, esi
jle short loc_13B0
push r13
lea eax, [rsi-1]
mov r13d, esi
push r12
lea r12, [rdi+rax*8+8]
push rbp
xor ebp, ebp
push rbx
mov rbx, rdi
sub rsp, 8
nop word ptr [rax+rax+00h]
loc_1378:
movsd xmm0, qword ptr [rbx]
add rbx, 8
call _round
m... | long long func0(double *a1, int a2)
{
int v2; // ebp
double *v3; // rbx
double v4; // xmm0_8
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = a1;
do
{
v4 = *v3++;
v2 = (int)((double)v2 + round(v4));
}
while ( &a1[(unsigned int)(a2 - 1) + 1] != v3 );
return (unsigned int)(v2 * a2);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013b0
PUSH R13
LEA EAX,[RSI + -0x1]
MOV R13D,ESI
PUSH R12
LEA R12,[RDI + RAX*0x8 + 0x8]
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
NOP word ptr [RAX + RAX*0x1]
LAB_00101378:
MOVSD XMM0,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101070
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XM... | int func0(double *param_1,int param_2)
{
double *pdVar1;
int iVar2;
double dVar3;
if (0 < param_2) {
pdVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
dVar3 = *param_1;
param_1 = param_1 + 1;
dVar3 = round(dVar3);
iVar2 = (int)((double)iVar2 + dVar3);
} whi... |
5,571 | func0 |
#include <assert.h>
#include <math.h>
| int func0(double list1[], int length) {
int i;
int sum = 0;
for (i = 0; i < length; i++) {
sum += round(list1[i]);
}
return sum * length;
}
| int main() {
double list1[] = {22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50};
double list2[] = {5, 2, 9, 24.3, 29};
double list3[] = {25.0, 56.7, 89.2};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == 243);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == ... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1360 <func0+0x60>
push %r13
lea -0x1(%rsi),%eax
mov %esi,%r13d
push %r12
lea 0x8(%rdi,%rax,8),%r12
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
nopw 0x0(%rax,%rax,1)
movsd 0x0(%rbp),%xmm0
add $0x8,%rbp
callq 1070 <round@plt>
movapd... | func0:
endbr64
test esi, esi
jle short loc_1360
push r13
movsxd rax, esi
mov r13d, esi
push r12
lea r12, [rdi+rax*8]
push rbp
xor ebp, ebp
push rbx
mov rbx, rdi
sub rsp, 8
nop dword ptr [rax+00000000h]
loc_1328:
movsd xmm0, qword ptr [rbx]; x
add rbx, 8
call _round
m... | long long func0(double *a1, int a2)
{
int v2; // ebp
double *v3; // rbx
double v4; // xmm0_8
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = a1;
do
{
v4 = *v3++;
v2 = (int)((double)v2 + round(v4));
}
while ( &a1[a2] != v3 );
return (unsigned int)(v2 * a2);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101360
PUSH R13
MOVSXD RAX,ESI
MOV R13D,ESI
PUSH R12
LEA R12,[RDI + RAX*0x8]
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
NOP dword ptr [RAX]
LAB_00101328:
MOVSD XMM0,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101070
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
ADDSD XMM0,XMM... | int func0(double *param_1,int param_2)
{
double *pdVar1;
int iVar2;
double dVar3;
if (0 < param_2) {
pdVar1 = param_1 + param_2;
iVar2 = 0;
do {
dVar3 = *param_1;
param_1 = param_1 + 1;
dVar3 = round(dVar3);
iVar2 = (int)((double)iVar2 + dVar3);
} while (pdVar1 != par... |
5,572 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1178 <func0+0x2f>
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
shl $0x3,%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_1178
loc_1164:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
shl eax, 3
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_1178:
mov eax, [rbp+var_4]
cmp ... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += 8 * i * i * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101178
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
SHL EAX,0x3
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010117... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = local_10 + local_c * local_c * local_c * 8;
}
return local_10;
} |
5,573 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1173 <func0+0x2a>
add $0x1,%edi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
lea (%rcx,%rdx,8),%ecx
add $0x1,%eax
cmp %edi,%eax
jne 115e <func0+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1170 <func0+0x27>
| func0:
endbr64
test edi, edi
jle short loc_1173
add edi, 1
mov eax, 1
mov ecx, 0
loc_115E:
mov edx, eax
imul edx, eax
imul edx, eax
lea ecx, [rcx+rdx*8]
add eax, 1
cmp eax, edi
jnz short loc_115E
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short loc_1170 | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v3 += 8 * v2 * v2 * v2;
++v2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
ADD EDI,0x1
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115e:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
LEA ECX,[RCX + RDX*0x8]
ADD EAX,0x1
CMP EAX,EDI
JNZ 0x0010115e
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1 * 8;
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
return iVar2;
} |
5,574 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
lea (%r8,%rdx,8),%r8d
cmp %edi,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%e... | func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
lea r8d, [r8+rdx*8]
cmp eax, edi
jnz short loc_1158
mov eax, r8d
retn
loc_1170:
xor r8d, r... | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // r8d
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += 8 * v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
LEA R8D,[R8 + RDX*0x8]
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar3 = 0;
do {
iVar2 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar3 = iVar3 + iVar2 * 8;
} while (iVar1 != param_1 + 1);
return iVar3;
}
return 0;
} |
5,575 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
lea (%r8,%rdx,8),%r8d
cmp %eax,%edi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%e... | func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
lea ecx, [rcx+rdx*8]
cmp eax, edi
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ecx, e... | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += 8 * v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
LEA ECX,[RCX + RDX*0x8]
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar2 = iVar2 + iVar3 * 8;
} while (iVar1 != param_1 + 1);
return iVar2;
}
return 0;
} |
5,576 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movb $0x0,0x2e6e(%rip)
movw $0x2d,-0xa(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1229 <func0+0x80>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov cs:res_1, 0
mov word ptr [rbp+src], 2Dh ; '-'
mov [rbp+var_10], 0
jmp short loc_122F
loc_11E1:
mov eax, [rbp+var_10]
cdqe... | char * func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-10h]
char src[2]; // [rsp+16h] [rbp-Ah] BYREF
unsigned long long v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
res_1 = 0;
strcpy(src, "-");
for ( i = 0; i < a2; ++i )
{
strcat(&res_1, *(const char **)(8LL * i + a1));
if ( i < ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV byte ptr [0x00104040],0x0
MOV word ptr [RBP + -0xa],0x2d
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010122f
LAB_001011e1:
MOV EAX,dword ... | int1 * func0(long param_1,int param_2)
{
long in_FS_OFFSET;
int local_18;
char local_12 [2];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_12[0] = '-';
local_12[1] = '\0';
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
strcat(res_1,*(char **)(... |
5,577 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movb $0x0,0x2e92(%rip)
movw $0x2d,0x6(%rsp)
test %esi,%esi
jle 1207 <func0+0x7e>
mov %rdi,%r12
lea -0x1(%rsi),%r13d
mov $0x0,%ebx
lea -0x1(%rsi),%ebp
jmp 1... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov cs:res_1, 0
mov [rsp+38h+var_32], 2Dh ; '-'
test esi, esi
jle short loc_1227
mov r13, rdi
mov ebp, esi
mov r14d, esi
mov ebx, ... | char * func0(long long a1, int a2)
{
long long i; // rbx
__int16 v4; // [rsp+6h] [rbp-32h] BYREF
unsigned long long v5; // [rsp+8h] [rbp-30h]
v5 = __readfsqword(0x28u);
res_1 = 0;
v4 = 45;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
__strcat_chk(&res_1, *(_QWORD *)(a1 + 8 * i), 1000LL... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV byte ptr [0x00104040],0x0
MOV word ptr [RSP + 0x6],0x2d
TEST ESI,ESI
JLE 0x00101227
MOV R13,RDI
MOV EBP,ESI
MOV R14D,ESI
MOV EBX,0x0
LEA R12,[0x104040]
JMP 0x001011fa
LAB_00... | int1 * func0(long param_1,uint param_2)
{
ulong uVar1;
long in_FS_OFFSET;
int2 local_32;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_32 = 0x2d;
if (0 < (int)param_2) {
uVar1 = 0;
do {
__strcat_chk(res_1,*(int8 *)(param_1 + uVar1 * 8),1000);
if ((... |
5,578 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0x2d,%eax
movb $0x0,0x2cd2(%rip)
mov %ax,0x16(%rsp)
lea 0x16(%rsp),%rax
mov %rax,0x8(%rsp)
test %esi,%esi
jle 141c <func0+0xdc>
le... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov eax, 2Dh ; '-'
mov cs:res_1, 0
mov [rsp+48h+var_42], ax
test esi, esi
jle loc_1428
lea r12, res_1
mov r13, rdi
lea ... | char * func0(long long a1, int a2)
{
long long i; // rbx
long long v3; // rax
long long v4; // rax
__int16 v6; // [rsp+6h] [rbp-42h] BYREF
unsigned long long v7; // [rsp+8h] [rbp-40h]
v7 = __readfsqword(0x28u);
res_1[0] = 0;
v6 = 45;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
v3 ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV EAX,0x2d
MOV byte ptr [0x00104040],0x0
MOV word ptr [RSP + 0x6],AX
TEST ESI,ESI
JLE 0x00101428
LEA R12,[0x104040]
MOV R13,RDI
LEA R14D,[RSI + -0x1]
XOR EBX,EBX
MOVS... | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
int2 local_42;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_42 = 0x2d;
if (0 < param_2) {
lVar3 = 0;
do {
sVar1 = strlen(res_1);
lVar2 = __stpcpy... |
5,579 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *test_tup[], int size) {
static char res[1000];
strcpy(res, "");
char delim[] = "-";
for(int i = 0; i < size; i++) {
strcat(res, test_tup[i]);
if (i < size - 1) {
strcat(res, delim);
}
}
return res;
}
| int main() {
char *s1[] = {"ID", "is", "4", "UTS"};
char *s2[] = {"QWE", "is", "4", "RTY"};
char *s3[] = {"ZEN", "is", "4", "OP"};
assert(strcmp(func0(s1, 4), "ID-is-4-UTS") == 0);
assert(strcmp(func0(s2, 4), "QWE-is-4-RTY") == 0);
assert(strcmp(func0(s3, 4), "ZEN-is-4-OP") == 0);
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov $0x2d,%eax
movb $0x0,0x2c92(%rip)
mov %ax,0x6(%rsp)
test %esi,%esi
jle 147e <func0+0xfe>
lea -0x1(%rsi),%r12d
mov %rdi,%rbp
mov %... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov eax, 2Dh ; '-'
mov cs:res_1, 0
mov [rsp+58h+var_42], ax
test esi, esi
jle loc_14B0
lea r14d, [rsi-1]
mov r13, rdi
mov ... | char * func0(long long a1, int a2)
{
int v3; // r15d
long long v4; // rbp
long long v5; // rsi
long long v7; // rbp
size_t v8; // rax
long long v9; // rax
__int16 v10; // [rsp+16h] [rbp-42h] BYREF
unsigned long long v11; // [rsp+18h] [rbp-40h]
v11 = __readfsqword(0x28u);
res_1[0] = 0;
v10 = 45;
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV EAX,0x2d
MOV byte ptr [0x00104040],0x0
MOV word ptr [RSP + 0x16],AX
TEST ESI,ESI
JLE 0x001014b0
LEA R14D,[RSI + -0x1]
MOV R13,RDI
MOV R12D,ESI
XOR R15D,R15D
LEA RB... | int1 * func0(int8 *param_1,int param_2)
{
size_t sVar1;
long lVar2;
int8 *puVar3;
int iVar4;
long in_FS_OFFSET;
int2 local_42;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1[0] = 0;
local_42 = 0x2d;
if (0 < param_2) {
iVar4 = 0;
if (0 < param_2 + -1) {
puVar3 = p... |
5,580 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
pxor %xmm0,%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x1,-0xc(%rbp)
jmp 11aa <func0+0x41>
mov -0xc(%rbp),%eax
imul %eax,%eax
imul -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd -0x8(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x8... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm0, xmm0
movsd [rbp+var_8], xmm0
mov [rbp+var_C], 1
jmp short loc_11AE
loc_118A:
mov eax, [rbp+var_C]
imul eax, eax
imul eax, [rbp+var_C]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, [rbp+var_8]
a... | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
double v1; // rax
__int128 v2; // xmm1
int i; // [rsp+14h] [rbp-Ch]
double v5; // [rsp+18h] [rbp-8h]
v5 = 0.0;
for ( i = 1; i <= a1; ++i )
v5 = (double)(i * i * i) + v5;
v1 = round(v5 / (double)a1 * 1000000.0);
v2 = *(unsigned long long *)&v1;
*(do... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001011ae
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0xc]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr ... | double func0(int param_1)
{
double dVar1;
int4 local_14;
int8 local_10;
local_10 = 0.0;
for (local_14 = 1; local_14 <= param_1; local_14 = local_14 + 1) {
local_10 = (double)(local_14 * local_14 * local_14) + local_10;
}
dVar1 = round((local_10 / (double)param_1) * DAT_00102058);
return dVar1 / ... |
5,581 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
test %edi,%edi
jle 11c2 <func0+0x59>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
pxor %xmm0,%xmm0
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
pxor %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
addsd %xmm1,%xmm0
add $0x1,%eax
cmp %ecx,%eax
jne 1181 <func0+0x18>
pxor %xmm1,%xmm1
c... | func0:
endbr64
sub rsp, 8
test edi, edi
jle short loc_11C2
lea ecx, [rdi+1]
mov eax, 1
pxor xmm0, xmm0
loc_1181:
mov edx, eax
imul edx, eax
imul edx, eax
pxor xmm1, xmm1
cvtsi2sd xmm1, edx
addsd xmm0, xmm1
add eax, 1
cmp eax, ecx
jnz short loc_1181
loc_119C:
pxor xmm1... | double func0(int a1)
{
int v1; // eax
double v2; // xmm0_8
if ( a1 <= 0 )
{
v2 = 0.0;
}
else
{
v1 = 1;
v2 = 0.0;
do
{
v2 = v2 + (double)(v1 * v1 * v1);
++v1;
}
while ( v1 != a1 + 1 );
}
return round(v2 / (double)a1 * 1000000.0) / 1000000.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST EDI,EDI
JLE 0x001011c2
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
PXOR XMM0,XMM0
LAB_00101181:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDX
ADDSD XMM0,XMM1
ADD EAX,0x1
CMP EAX,ECX
JNZ 0x00101181
LAB_0010119c:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qwor... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
int iVar1;
double dVar2;
if (param_1 < 1) {
dVar2 = 0.0;
}
else {
iVar1 = 1;
dVar2 = 0.0;
do {
dVar2 = dVar2 + (double)(iVar1 * iVar1 * iVar1);
iVar1 = iVar1 + 1;
... |
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.