index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
4,382 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == ... | int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 123d <func0+0xd>
sub $0xdd0,%rsp
xor %esi,%esi
mov $0x2ee0,%edx
mov %fs:0x28,%rax
mov %rax,0x5dc8(%rsp)
xor %eax,%eax
mov %edi,%ebx
mov %rsp,%rdi
callq 1090 <memset@plt>
mov $0... | func0:
endbr64
push rbx
lea r11, [rsp+8+var_5008]
loc_123D:
sub rsp, 1000h
or [rsp+1008h+var_1008], 0
cmp rsp, r11
jnz short loc_123D
sub rsp, 0DD0h
xor esi, esi
mov edx, 2EE0h
mov rax, fs:28h
mov [rsp+1DD8h+arg_3FE8], rax
xor eax, eax
mov ebx, edi
mov rdi, rsp
ca... | // positive sp value has been detected, the output may be wrong!
long long func0(int a1)
{
long long v2; // rax
unsigned long long v3; // r8
long long v4; // rcx
int v5; // esi
long long v6; // rdi
int i; // eax
unsigned long long v8; // rax
int v9; // edx
long long v10; // rdx
long long v11; // rs... | func0:
ENDBR64
PUSH RBX
LEA R11,[RSP + -0x5000]
LAB_0010123d:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x0010123d
SUB RSP,0xdd0
XOR ESI,ESI
MOV EDX,0x2ee0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x5dc8],RAX
XOR EAX,EAX
MOV EBX,EDI
MOV RDI,RSP
CALL 0x00101090
MOV R8D,0x4
MOV ECX,0x2
XOR ESI,ESI
MOV... | int4 func0(int param_1)
{
int1 *puVar1;
void *pvVar2;
ulong uVar3;
int *piVar4;
long lVar5;
int iVar6;
uint uVar7;
long lVar8;
int1 *puVar9;
int iVar10;
ulong uVar11;
long in_FS_OFFSET;
int1 local_5008 [20480];
puVar1 = &stack0xfffffffffffffff8;
do {
puVar9 = puVar1;
*(int8 *)(... |
4,383 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == ... | int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 123d <func0+0xd>
sub $0xdd0,%rsp
xor %esi,%esi
mov $0x2ee0,%edx
mov %fs:0x28,%rax
mov %rax,0x5dc8(%rsp)
xor %eax,%eax
mov %edi,%ebx
mov %rsp,%rdi
callq 1090 <memset@plt>
mov $0... | func0:
endbr64
push rbx
lea r11, [rsp+8+var_5008]
loc_123D:
sub rsp, 1000h
or [rsp+1008h+var_1008], 0
cmp rsp, r11
jnz short loc_123D
sub rsp, 0DD0h
xor esi, esi; c
mov edx, 2EE0h; n
mov rax, fs:28h
mov [rsp+1DD8h+arg_3FE8], rax
xor eax, eax
mov ebx, edi
mov rdi, ... | // positive sp value has been detected, the output may be wrong!
long long func0(int a1)
{
_DWORD *v2; // rax
unsigned long long v3; // r8
long long v4; // rcx
int v5; // esi
_DWORD *v6; // rdi
unsigned long long v7; // rax
int v8; // edx
long long v9; // rdx
__m128i *v10; // rax
__m128i v11; // xm... | func0:
ENDBR64
PUSH RBX
LEA R11,[RSP + -0x5000]
LAB_0010123d:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x0010123d
SUB RSP,0xdd0
XOR ESI,ESI
MOV EDX,0x2ee0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x5dc8],RAX
XOR EAX,EAX
MOV EBX,EDI
MOV RDI,RSP
CALL 0x00101090
MOV R8D,0x4
MOV ECX,0x2
XOR ESI,ESI
MOV... | int4 func0(int param_1)
{
int *puVar1;
void *pvVar2;
ulong uVar3;
int8 *puVar4;
long lVar5;
int iVar6;
long lVar7;
int *puVar8;
int iVar9;
ulong uVar10;
long in_FS_OFFSET;
int iVar11;
int local_5008 [20480];
puVar1 = &stack0xfffffffffffffff8;
do {
puVar8 = puVar1;
*(int8 *)(puV... |
4,384 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == ... | int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
cmpl $0x0,-0x24(%rbp)
jg 1184 <func0+0x1b>
mov $0xffffffff,%eax
jmpq 1217 <func0+0xae>
movl $0x0,-0x18(%rbp)
movl $0x2,-0x14(%rbp)
jmp 120c <func0+0xa3>
movl $0x0,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 11bb <func0+0x52>
mov -0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
cmp [rbp+var_24], 0
jg short loc_1184
mov eax, 0FFFFFFFFh
jmp loc_1217
loc_1184:
mov [rbp+var_18], 0
mov [rbp+var_14], 2
jmp short loc_120C
loc_1194:
mov [rbp+var_10], 0
mov [rbp+var_C], 1
jmp short loc_11BB
l... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-18h]
int i; // [rsp+10h] [rbp-14h]
int v4; // [rsp+14h] [rbp-10h]
int j; // [rsp+18h] [rbp-Ch]
int v6; // [rsp+1Ch] [rbp-8h]
int k; // [rsp+20h] [rbp-4h]
if ( a1 <= 0 )
return 0xFFFFFFFFLL;
v2 = 0;
for ( i = 2; i <= a1; ++i )
{
v4... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
CMP dword ptr [RBP + -0x24],0x0
JG 0x00101184
MOV EAX,0xffffffff
JMP 0x00101217
LAB_00101184:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x2
JMP 0x0010120c
LAB_00101194:
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x1
JM... | int func0(int param_1)
{
int local_20;
int local_1c;
int local_18;
int local_14;
int local_10;
int local_c;
if (param_1 < 1) {
local_20 = -1;
}
else {
local_20 = 0;
for (local_1c = 2; local_1c <= param_1; local_1c = local_1c + 1) {
local_18 = 0;
for (local_14 = 1; local_14 ... |
4,385 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == ... | int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 11fa <func0+0x91>
cmp $0x1,%edi
jle 1202 <func0+0x99>
lea 0x1(%rdi),%r11d
mov $0x2,%edi
mov $0x0,%r9d
mov $0x0,%r10d
jmp 119d <func0+0x34>
add $0x1,%edi
cmp %edi,%r11d
je 1208 <func0+0x9f>
mov $0x1,%esi
mov %r10d,%ecx
mov %r10d,%r8d
cmp $... | func0:
endbr64
test edi, edi
jle loc_1201
cmp edi, 1
jle loc_1209
lea r11d, [rdi+1]
mov edi, 2
mov r9d, 0
mov r10d, 0
jmp short loc_119D
loc_1195:
add edi, 1
cmp r11d, edi
jz short loc_120F
loc_119D:
mov esi, 1
mov ecx, r10d
cmp edi, 1
jle short loc_11F7
l... | long long func0(int a1)
{
int v1; // r11d
int v2; // edi
unsigned int v3; // r9d
int v4; // esi
int v5; // ecx
int v6; // esi
int v7; // r8d
if ( a1 <= 0 )
{
return (unsigned int)-1;
}
else
{
if ( a1 > 1 )
{
v1 = a1 + 1;
v2 = 2;
v3 = 0;
while ( 1 )
{
... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101201
CMP EDI,0x1
JLE 0x00101209
LEA R11D,[RDI + 0x1]
MOV EDI,0x2
MOV R9D,0x0
MOV R10D,0x0
JMP 0x0010119d
LAB_00101195:
ADD EDI,0x1
CMP R11D,EDI
JZ 0x0010120f
LAB_0010119d:
MOV ESI,0x1
MOV ECX,R10D
CMP EDI,0x1
JLE 0x001011f7
LAB_001011aa:
MOV EAX,EDI
CDQ
IDIV ESI
LEA EAX,[RCX + RSI*... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_1 < 1) {
iVar4 = -1;
}
else if (param_1 < 2) {
iVar4 = 0;
}
else {
iVar3 = 2;
iVar4 = 0;
do {
iVar2 = 1;
iVar5 = 0;
iVar1 = 0;
if (iVar3 < 2) {
iVar2 = 0;... |
4,386 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == ... | int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 12bd <func0+0xd>
jmpq 1220 <func0.part.0>
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
cmp edi, 1
jle short loc_129E
lea r10d, [rdi+1]
xor r9d, r9d
mov edi, 2
nop dword ptr [rax+00000000h]
loc_1238:
xor ecx, ecx
mov esi, 1
nop
loc_1240:
mov eax, edi
cdq
idiv esi
lea eax, [rcx+rsi]
test edx, edx
cmovz ecx, eax
add esi, 1
cmp esi, edi
jn... | long long func0_part_0(int a1)
{
int v1; // r10d
unsigned int v2; // r9d
int v3; // edi
int v4; // ecx
int v5; // esi
int v6; // r8d
int i; // esi
if ( a1 <= 1 )
return 0LL;
v1 = a1 + 1;
v2 = 0;
v3 = 2;
do
{
v4 = 0;
v5 = 1;
do
{
if ( !(v3 % v5) )
v4 += v5;
... | func0.part.0:
CMP EDI,0x1
JLE 0x0010129e
LEA R10D,[RDI + 0x1]
XOR R9D,R9D
MOV EDI,0x2
NOP dword ptr [RAX]
LAB_00101238:
XOR ECX,ECX
MOV ESI,0x1
NOP
LAB_00101240:
MOV EAX,EDI
CDQ
IDIV ESI
LEA EAX,[RCX + RSI*0x1]
TEST EDX,EDX
CMOVZ ECX,EAX
ADD ESI,0x1
CMP ESI,EDI
JNZ 0x00101240
CMP ECX,0x1
JLE 0x00101292
XOR R8D,R8D
MOV ... | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (1 < param_1) {
iVar5 = 0;
iVar4 = 2;
do {
iVar1 = 0;
iVar2 = 1;
do {
if (iVar4 % iVar2 == 0) {
iVar1 = iVar1 + iVar2;
}
iVar2 = iVar2 + 1;
} wh... |
4,387 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int limit) {
if (limit < 1) {
return -1; // Returning error code -1 indicating input must be bigger than 0
}
int amicables_sum = 0;
for (int num = 2; num <= limit; num++) {
int sum_fact = 0;
for (int fact = 1; fact < num; fact++) {
if (num % fact == ... | int main() {
assert(func0(999) == 504);
assert(func0(9999) == 31626);
assert(func0(99) == 0);
// Print "Tests Passed" upon successful completion.
printf("Tests Passed\n");
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1345 <func0+0x95>
cmp $0x1,%edi
je 133e <func0+0x8e>
lea 0x1(%rdi),%r10d
xor %r9d,%r9d
mov $0x2,%edi
nopl (%rax)
xor %ecx,%ecx
mov $0x1,%esi
nopw 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %esi
lea (%rcx,%rsi,1),%eax
test %edx,%edx
cmove %eax,%ec... | func0_part_0:
cmp edi, 1
jle short loc_129E
lea r10d, [rdi+1]
xor r9d, r9d
mov edi, 2
nop dword ptr [rax+00000000h]
loc_1238:
xor ecx, ecx
mov esi, 1
nop
loc_1240:
mov eax, edi
cdq
idiv esi
lea eax, [rcx+rsi]
test edx, edx
cmovz ecx, eax
add esi, 1
cmp edi, esi
jn... | long long func0_part_0(int a1)
{
int v1; // r10d
unsigned int v2; // r9d
int v3; // edi
int v4; // ecx
int v5; // esi
int v6; // r8d
int i; // esi
if ( a1 <= 1 )
return 0LL;
v1 = a1 + 1;
v2 = 0;
v3 = 2;
do
{
v4 = 0;
v5 = 1;
do
{
if ( !(v3 % v5) )
v4 += v5;
... | func0.part.0:
CMP EDI,0x1
JLE 0x0010129e
LEA R10D,[RDI + 0x1]
XOR R9D,R9D
MOV EDI,0x2
NOP dword ptr [RAX]
LAB_00101238:
XOR ECX,ECX
MOV ESI,0x1
NOP
LAB_00101240:
MOV EAX,EDI
CDQ
IDIV ESI
LEA EAX,[RCX + RSI*0x1]
TEST EDX,EDX
CMOVZ ECX,EAX
ADD ESI,0x1
CMP EDI,ESI
JNZ 0x00101240
CMP ECX,0x1
JLE 0x00101292
XOR R8D,R8D
MOV ... | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (1 < param_1) {
iVar5 = 0;
iVar4 = 2;
do {
iVar1 = 0;
iVar2 = 1;
do {
if (iVar4 % iVar2 == 0) {
iVar1 = iVar1 + iVar2;
}
iVar2 = iVar2 + 1;
} wh... |
4,388 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
movsd %xmm0,-0x28(%rbp)
movsd %xmm1,-0x30(%rbp)
movsd -0x30(%rbp),%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd -0x28(%rbp),%xmm1
movsd %xmm1,-0x10(%rbp)
movsd %xmm0,-0x8(%rbp)
movsd -0x10(%rbp),%xmm0
mov -0x8(%rbp),%rax
movapd %xmm0,%xmm1
movq... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
movsd [rbp+var_38], xmm0
movsd [rbp+var_40], xmm1
movsd xmm0, [rbp+var_40]
movsd [rbp+y], xmm0
movsd xmm1, [rbp+y]
pxor xmm0, xmm0
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_38]
addsd xmm0, xmm1
movsd [rbp+x], xmm0
movsd xmm0, [rbp+y]
movsd ... | long long func0(double a1, double a2)
{
return atan2(a2, 0.0 * a2 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOVSD qword ptr [RBP + -0x38],XMM0
MOVSD qword ptr [RBP + -0x40],XMM1
MOVSD XMM0,qword ptr [RBP + -0x40]
MOVSD qword ptr [RBP + -0x20],XMM0
MOVSD XMM1,qword ptr [RBP + -0x20]
PXOR XMM0,XMM0
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x38]
ADDSD XMM0,XMM1
MOVSD qword pt... | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = atan2(param_2,param_2 * 0.0 + param_1);
return dVar1;
} |
4,389 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
movapd %xmm0,%xmm2
movapd %xmm1,%xmm0
mulsd 0xea7(%rip),%xmm1
addsd %xmm2,%xmm1
callq 1050 <atan2@plt>
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
movapd xmm2, xmm0
movapd xmm0, xmm1
mulsd xmm1, cs:qword_2008
addsd xmm1, xmm2
call _atan2
add rsp, 8
retn | double func0(double a1, double a2)
{
return atan2(a2, a2 * 0.0 + a1);
} | func0:
ENDBR64
SUB RSP,0x8
MOVAPD XMM2,XMM0
MOVAPD XMM0,XMM1
MULSD XMM1,qword ptr [0x00102008]
ADDSD XMM1,XMM2
CALL 0x00101050
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(double param_1,double param_2)
{
atan2(param_2,param_2 * _DAT_00102008 + param_1);
return;
} |
4,390 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm0,%xmm2
movapd %xmm1,%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd %xmm2,%xmm1
jmpq 1050 <atan2@plt>
nopl (%rax)
| func0:
endbr64
movapd xmm2, xmm0
movapd xmm0, xmm1
pxor xmm1, xmm1
mulsd xmm1, xmm0
addsd xmm1, xmm2
jmp _atan2 | double func0(double a1, double a2)
{
return atan2(a2, 0.0 * a2 + a1);
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MOVAPD XMM0,XMM1
PXOR XMM1,XMM1
MULSD XMM1,XMM0
ADDSD XMM1,XMM2
JMP 0x00101050 | void func0(double param_1,double param_2)
{
atan2(param_2,param_2 * 0.0 + param_1);
return;
} |
4,391 | func0 | #include <assert.h>
#include <complex.h>
#include <math.h>
| double func0(double a, double b) {
double complex cn = a + b * I;
double angle = carg(cn);
return angle;
}
| int main() {
assert(fabs(func0(0, 1) - 1.5707963267948966) < 1e-9);
assert(fabs(func0(2, 1) - 0.4636476090008061) < 1e-9);
assert(fabs(func0(0, 2) - 1.5707963267948966) < 1e-9);
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm0,%xmm2
movapd %xmm1,%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd %xmm2,%xmm1
jmpq 1050 <atan2@plt>
nopl (%rax)
| func0:
endbr64
movapd xmm2, xmm0
movapd xmm0, xmm1; y
pxor xmm1, xmm1
mulsd xmm1, xmm0
addsd xmm1, xmm2; x
jmp _atan2 | double func0(double a1, double a2)
{
return atan2(a2, 0.0 * a2 + a1);
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MOVAPD XMM0,XMM1
PXOR XMM1,XMM1
MULSD XMM1,XMM0
ADDSD XMM1,XMM2
JMP 0x00101050 | void func0(double param_1,double param_2)
{
atan2(param_2,param_2 * 0.0 + param_1);
return;
} |
4,392 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum... | int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
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)
movl $0x0,-0x4(%rbp)
jmp 11b1 <func0+0x68>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x30,%al
jne 118a <func... | 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
mov [rbp+var_4], 0
jmp short loc_11B1
loc_116F:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp a... | long long func0(long long a1, int a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = 0;
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == 48 )
v2 = 1;
else
v2 = -1;
v4 += v2;
if ( v4 < 0 )
v... | 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
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b1
LAB_0010116f:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EA... | int func0(long param_1,int param_2)
{
int iVar1;
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == '0') {
iVar1 = 1;
}
else {
iVar1 = -1;
}
local_14 =... |
4,393 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum... | int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1190 <func0+0x47>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x1(%rdi,%rax,1),%r8
mov $0x0,%ecx
mov $0x0,%eax
mov $0x0,%edi
cmpb $0x30,(%rdx)
sete %sil
movzbl %sil,%esi
lea -0x1(%rax,%rsi,2),%eax
test %eax,%eax
cmovs %edi,%eax
cmp %eax,%ecx
cmovl %eax,%e... | func0:
endbr64
test esi, esi
jle short loc_1190
mov rdx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax+1]
mov ecx, 0
mov eax, 0
loc_1166:
cmp byte ptr [rdx], 30h ; '0'
setz sil
movzx esi, sil
lea eax, [rax+rsi*2-1]
test eax, eax
mov esi, 0
cmovs eax, esi
cmp ecx, eax
cmovl ... | long long func0(_BYTE *a1, int a2)
{
_BYTE *v2; // rdx
long long v3; // rdi
int v4; // ecx
int v5; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
v5 = 0;
do
{
v5 = v5 + 2 * (*v2 == 48) - 1;
if ( v5 < 0 )
v5... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x1 + 0x1]
MOV ECX,0x0
MOV EAX,0x0
LAB_00101166:
CMP byte ptr [RDX],0x30
SETZ SIL
MOVZX ESI,SIL
LEA EAX,[RAX + RSI*0x2 + -0x1]
TEST EAX,EAX
MOV ESI,0x0
CMOVS EAX,ESI
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0x1
CMP RDX,RDI
JNZ 0x001... | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
}
else {
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
iVar2 = 0;
do {
iVar2 = iVar2 + -1 + (uint)(*param_1 == '0') * 2;
if (iVar2 < 0) {
iVar2 = 0;
... |
4,394 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum... | int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 12d8 <func0+0x48>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
xor %ecx,%ecx
lea 0x1(%rdi,%rax,1),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
cmpb $0x30,(%rdi)
sete %dl
lea -0x1(%rax,%rdx,2),%eax
test %eax,%eax
cmovs %ecx,%eax
cmp %eax,%r8d
cmovl ... | func0:
endbr64
test esi, esi
jle short loc_1258
lea eax, [rsi-1]
xor r8d, r8d
xor ecx, ecx
lea rdx, [rdi+rax+1]
xor eax, eax
jmp short loc_1239
loc_1220:
sub eax, 1
cmp eax, 0FFFFFFFFh
cmovz eax, ecx
cmp r8d, eax
cmovl r8d, eax
add rdi, 1
cmp rdi, rdx
jz short... | long long func0(_BYTE *a1, int a2)
{
unsigned int v2; // r8d
long long v3; // rdx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
while ( *a1 == 48 )
{
if ( (int)v2 < ++v4 )
v2 = v4;
if ( ++a1 == (_BYTE *)v3 )
re... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101258
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
XOR ECX,ECX
LEA RDX,[RDI + RAX*0x1 + 0x1]
XOR EAX,EAX
JMP 0x00101239
LAB_00101220:
SUB EAX,0x1
CMP EAX,-0x1
CMOVZ EAX,ECX
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0x1
CMP RDI,RDX
JZ 0x00101251
LAB_00101239:
CMP byte ptr [RDI],0x30
JNZ 0x00101220
ADD E... | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
iVar3 = 0;
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
while (*param_1 == '0') {
iVar2 = iVar2 + 1;
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
... |
4,395 | func0 | #include <assert.h>
| int func0(const char *string, int n) {
int current_sum = 0;
int max_sum = 0;
for (int i = 0; i < n; i++) {
current_sum += (string[i] == '0' ? 1 : -1);
if (current_sum < 0) {
current_sum = 0;
}
if (current_sum > max_sum) {
max_sum = current_sum... | int main() {
assert(func0("11000010001", 11) == 6);
assert(func0("10111", 5) == 1);
assert(func0("11011101100101", 14) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11a0 <func0+0x60>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
xor %ecx,%ecx
lea 0x1(%rdi,%rax,1),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
cmpb $0x30,(%rdi)
je 1180 <func0+0x40>
sub $0x1,%eax
cmovs %ecx,%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x1,%rdi
cmp ... | func0:
endbr64
test esi, esi
jle short loc_1190
movsxd rsi, esi
xor edx, edx
xor eax, eax
lea rcx, [rdi+rsi]
xor esi, esi
jmp short loc_1177
loc_1160:
sub eax, 1
cmp eax, 0FFFFFFFFh
cmovz eax, esi
cmp edx, eax
cmovl edx, eax
add rdi, 1
cmp rcx, rdi
jz short loc_1... | long long func0(_BYTE *a1, int a2)
{
unsigned int v2; // edx
int v3; // eax
_BYTE *v4; // rcx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = 0;
v4 = &a1[a2];
do
{
while ( *a1 == 48 )
{
if ( (int)v2 < ++v3 )
v2 = v3;
if ( v4 == ++a1 )
return v2;
}
if ( --v3 ==... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOVSXD RSI,ESI
XOR EDX,EDX
XOR EAX,EAX
LEA RCX,[RDI + RSI*0x1]
XOR ESI,ESI
JMP 0x00101177
LAB_00101160:
SUB EAX,0x1
CMP EAX,-0x1
CMOVZ EAX,ESI
CMP EDX,EAX
CMOVL EDX,EAX
ADD RDI,0x1
CMP RCX,RDI
JZ 0x0010118d
LAB_00101177:
CMP byte ptr [RDI],0x30
JNZ 0x00101160
ADD EAX,0x1
CMP E... | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
iVar3 = 0;
iVar2 = 0;
pcVar1 = param_1 + param_2;
do {
while (*param_1 == '0') {
iVar2 = iVar2 + 1;
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = para... |
4,396 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 118b <func0+0x42>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1187 <func0+0x3e>
mov -0x18(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_118B
loc_1167:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1187
mov eax, [rbp+var_18]
cdq
idiv ... | long long func0(int a1, int a2)
{
int v2; // eax
unsigned int v4; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v4 = 0;
for ( i = 1; ; ++i )
{
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( i >= v2 )
break;
if ( !(a1 % i) && !(a2 % i) )
v4 += i;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010118b
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101187
MOV EAX,dword ptr [RBP + ... | int func0(int param_1,int param_2)
{
int iVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
local_c = 1;
while( true ) {
iVar1 = param_1;
if (param_2 <= param_1) {
iVar1 = param_2;
}
if (iVar1 <= local_c) break;
if ((param_1 % local_c == 0) && (param_2 % local_c == 0)) {
l... |
4,397 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edi,%esi
mov %edi,%r9d
cmovle %esi,%r9d
cmp $0x1,%r9d
jle 118b <func0+0x42>
mov $0x1,%ecx
mov $0x0,%r8d
jmp 1171 <func0+0x28>
add $0x1,%ecx
cmp %r9d,%ecx
je 1191 <func0+0x48>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1169 <func0+0x20>
mov %esi,%eax
c... | func0:
endbr64
cmp esi, edi
mov r9d, edi
cmovle r9d, esi
cmp r9d, 1
jle short loc_118B
mov ecx, 1
mov r8d, 0
jmp short loc_1171
loc_1169:
add ecx, 1
cmp ecx, r9d
jz short loc_1191
loc_1171:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1169
mov eax, es... | long long func0(int a1, int a2)
{
int v2; // r9d
int v3; // ecx
unsigned int v4; // r8d
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( v2 <= 1 )
{
return 0;
}
else
{
v3 = 1;
v4 = 0;
do
{
if ( !(a1 % v3) && !(a2 % v3) )
v4 += v3;
++v3;
}
while ( v3 != v2 ... | func0:
ENDBR64
CMP ESI,EDI
MOV R9D,EDI
CMOVLE R9D,ESI
CMP R9D,0x1
JLE 0x0010118b
MOV ECX,0x1
MOV R8D,0x0
JMP 0x00101171
LAB_00101169:
ADD ECX,0x1
CMP ECX,R9D
JZ 0x00101191
LAB_00101171:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101169
MOV EAX,ESI
CDQ
IDIV ECX
LEA EAX,[R8 + RCX*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
JMP 0x... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1;
if (param_2 <= param_1) {
iVar3 = param_2;
}
if (iVar3 < 2) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
if ((param_1 % iVar1 == 0) && (param_2 % iVar1 == 0)) {
iVar2 = iVar... |
4,398 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edi,%esi
mov %edi,%r9d
cmovle %esi,%r9d
cmp $0x1,%r9d
jle 1268 <func0+0x48>
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1258 <func0+0x38>
mov %esi,%eax
cltd
idiv %ecx
lea (%r8,%rcx,1),%eax
test %edx,%edx
cm... | func0:
endbr64
cmp esi, edi
mov r9d, edi
cmovle r9d, esi
cmp r9d, 1
jle short loc_1268
mov ecx, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1240:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1258
mov eax, esi
cdq
idiv ecx
lea eax, [r8+rcx]
test edx, e... | long long func0(int a1, int a2)
{
int v2; // r9d
int v3; // ecx
unsigned int v4; // r8d
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( v2 <= 1 )
return 0LL;
v3 = 1;
v4 = 0;
do
{
if ( !(a1 % v3) && !(a2 % v3) )
v4 += v3;
++v3;
}
while ( v3 != v2 );
return v4;
} | func0:
ENDBR64
CMP ESI,EDI
MOV R9D,EDI
CMOVLE R9D,ESI
CMP R9D,0x1
JLE 0x00101268
MOV ECX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101240:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101258
MOV EAX,ESI
CDQ
IDIV ECX
LEA EAX,[R8 + RCX*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
LAB_00101258:
ADD ECX,0x1
CMP ECX,R9D
JNZ 0... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1;
if (param_2 <= param_1) {
iVar3 = param_2;
}
if (1 < iVar3) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
if (param_2 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
... |
4,399 | func0 | #include <assert.h>
| int func0(int a, int b) {
int sum = 0;
for (int i = 1; i < (a < b ? a : b); i++) {
if (a % i == 0 && b % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10, 15) == 6);
assert(func0(100, 150) == 93);
assert(func0(4, 6) == 3);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edi,%esi
mov %edi,%r9d
cmovle %esi,%r9d
cmp $0x1,%r9d
jle 1208 <func0+0x48>
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 11f8 <func0+0x38>
mov %esi,%eax
cltd
idiv %ecx
lea (%r8,%rcx,1),%eax
test %edx,%edx
cm... | func0:
endbr64
cmp esi, edi
mov r9d, edi
cmovle r9d, esi
cmp r9d, 1
jle short loc_11F8
mov ecx, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_11D0:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_11E8
mov eax, esi
cdq
idiv ecx
lea eax, [r8+rcx]
test edx, e... | long long func0(int a1, int a2)
{
int v2; // r9d
int v3; // ecx
unsigned int v4; // r8d
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
if ( v2 <= 1 )
return 0LL;
v3 = 1;
v4 = 0;
do
{
if ( !(a1 % v3) && !(a2 % v3) )
v4 += v3;
++v3;
}
while ( v3 != v2 );
return v4;
} | func0:
ENDBR64
CMP ESI,EDI
MOV R9D,EDI
CMOVLE R9D,ESI
CMP R9D,0x1
JLE 0x001011f8
MOV ECX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_001011d0:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001011e8
MOV EAX,ESI
CDQ
IDIV ECX
LEA EAX,[R8 + RCX*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
LAB_001011e8:
ADD ECX,0x1
CMP ECX,R9D
JNZ 0... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1;
if (param_2 <= param_1) {
iVar3 = param_2;
}
if (1 < iVar3) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
if (param_2 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
... |
4,400 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jns 1178 <func0+0x2f>
mov -0x8(%rbp),%eax
neg %eax
mov %eax,%edx
mov -0x4(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
neg %eax
jmp 11a7 <func0+0x5e... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
cmp [rbp+var_8], 0
jns short loc_1178
mov eax, [rbp+var_8]
neg eax
mov edx, eax
mov eax, [rbp+var_4]
mov esi, edx
mov edi, eax
call func0
neg eax
jmp short locret_11A... | long long func0(unsigned int a1, int a2)
{
if ( a2 < 0 )
return (unsigned int)-func0(a1, (unsigned int)-a2);
if ( !a2 )
return 0LL;
if ( a2 == 1 )
return a1;
return a1 + (unsigned int)func0(a1, (unsigned int)(a2 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
CMP dword ptr [RBP + -0x8],0x0
JNS 0x00101178
MOV EAX,dword ptr [RBP + -0x8]
NEG EAX
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
NEG EAX
JMP 0x001011a7
LAB_00101178:
CMP ... | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 < 0) {
param_1 = func0(param_1,-param_2);
param_1 = -param_1;
}
else if (param_2 == 0) {
param_1 = 0;
}
else if (param_2 != 1) {
iVar1 = func0(param_1,param_2 + -1);
param_1 = iVar1 + param_1;
}
return param_1;
} |
4,401 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
test %esi,%esi
js 1161 <func0+0x18>
mov %esi,%eax
je 115f <func0+0x16>
mov %edi,%eax
cmp $0x1,%esi
jne 116c <func0+0x23>
pop %rbx
retq
neg %esi
callq 1149 <func0>
neg %eax
jmp 115f <func0+0x16>
sub $0x1,%esi
callq 1149 <func0>
add %eb... | func0:
endbr64
push rbx
mov ebx, edi
test esi, esi
js short loc_1161
mov eax, esi
jz short loc_115F
mov eax, edi
cmp esi, 1
jnz short loc_116C
loc_115F:
pop rbx
retn
loc_1161:
neg esi
call func0
neg eax
jmp short loc_115F
loc_116C:
sub esi, 1
call func0
add ... | long long func0(long long a1, int a2)
{
long long result; // rax
if ( a2 < 0 )
return (unsigned int)-func0(a1, (unsigned int)-a2);
result = (unsigned int)a2;
if ( a2 )
{
result = (unsigned int)a1;
if ( a2 != 1 )
return (unsigned int)a1 + (unsigned int)func0(a1, (unsigned int)(a2 - 1));
}... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
TEST ESI,ESI
JS 0x00101161
MOV EAX,ESI
JZ 0x0010115f
MOV EAX,EDI
CMP ESI,0x1
JNZ 0x0010116c
LAB_0010115f:
POP RBX
RET
LAB_00101161:
NEG ESI
CALL 0x00101149
NEG EAX
JMP 0x0010115f
LAB_0010116c:
SUB ESI,0x1
CALL 0x00101149
ADD EAX,EBX
JMP 0x0010115f | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 < 0) {
iVar1 = func0(param_1,-param_2);
iVar1 = -iVar1;
}
else {
iVar1 = param_2;
if ((param_2 != 0) && (iVar1 = param_1, param_2 != 1)) {
iVar1 = func0(param_1,param_2 + -1);
iVar1 = iVar1 + param_1;
}
}
return ... |
4,402 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
test %esi,%esi
js 12ba <func0+0x2a>
je 12c0 <func0+0x30>
mov %edi,%edx
imul %eax,%edx
add %edx,%r8d
cmp $0x1,%esi
je 12c0 <func0+0x30>
sub $0x1,%esi
test %esi,%esi
jns 12a4 <func0+0x14>
neg %esi
neg %eax
jmp 12a0... | func0:
endbr64
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1210:
test esi, esi
js short loc_122A
loc_1214:
jz short loc_1230
mov edx, edi
imul edx, eax
add r8d, edx
cmp esi, 1
jz short loc_1230
sub esi, 1
test esi, esi
jns short loc_1214
loc_122A:
neg ... | long long func0(int a1, int a2)
{
int v2; // eax
unsigned int v3; // r8d
bool v4; // zf
v2 = 1;
v3 = 0;
while ( 1 )
{
v4 = a2 == 0;
if ( a2 >= 0 )
break;
LABEL_6:
a2 = -a2;
v2 = -v2;
}
while ( !v4 )
{
v3 += v2 * a1;
if ( a2 == 1 )
break;
v4 = --a2 == 0;
... | func0:
ENDBR64
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101210:
TEST ESI,ESI
JS 0x0010122a
LAB_00101214:
JZ 0x00101230
MOV EDX,EDI
IMUL EDX,EAX
ADD R8D,EDX
CMP ESI,0x1
JZ 0x00101230
SUB ESI,0x1
TEST ESI,ESI
JNS 0x00101214
LAB_0010122a:
NEG ESI
NEG EAX
JMP 0x00101210
LAB_00101230:
MOV EAX,R8D
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
iVar1 = 1;
iVar2 = 0;
while( true ) {
for (; param_2 < 0; param_2 = -param_2) {
iVar1 = -iVar1;
}
if ((param_2 == 0) || (iVar2 = iVar2 + param_1 * iVar1, param_2 == 1)) break;
param_2 = param_2 + -1;
}
return iVar2;
} |
4,403 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (y < 0) {
return -func0(x, -y);
} else if (y == 0) {
return 0;
} else if (y == 1) {
return x;
} else {
return x + func0(x, y - 1);
}
}
| int main() {
assert(func0(10, 20) == 200);
assert(func0(5, 10) == 50);
assert(func0(4, 8) == 32);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
test %esi,%esi
js 12ba <func0+0x2a>
je 12c0 <func0+0x30>
mov %edi,%edx
imul %eax,%edx
add %edx,%r8d
cmp $0x1,%esi
je 12c0 <func0+0x30>
sub $0x1,%esi
test %esi,%esi
jns 12a4 <func0+0x14>
neg %esi
neg %eax
jmp 12a0... | func0:
endbr64
mov eax, esi
test esi, esi
jns short loc_1180
neg eax
mov ecx, 0FFFFFFFFh
mov edx, eax
xor eax, eax
loc_1155:
imul edi, ecx
lea ecx, [rdx-1]
test dl, 1
jnz short loc_1175
mov eax, edi
mov edx, ecx
jmp short loc_1175
loc_1170:
add eax, edi
sub e... | long long func0(int a1, int a2)
{
long long result; // rax
int v3; // ecx
int v4; // edx
int v5; // eax
int v6; // edi
result = (unsigned int)a2;
if ( a2 >= 0 )
{
if ( !a2 )
return result;
v4 = a2;
v3 = 1;
v5 = 0;
}
else
{
v3 = -1;
v4 = -a2;
v5 = 0;
}
v6 = v... | func0:
ENDBR64
MOV EAX,ESI
TEST ESI,ESI
JNS 0x00101180
NEG EAX
MOV ECX,0xffffffff
MOV EDX,EAX
XOR EAX,EAX
LAB_00101155:
IMUL EDI,ECX
LEA ECX,[RDX + -0x1]
TEST DL,0x1
JNZ 0x00101175
MOV EAX,EDI
MOV EDX,ECX
JMP 0x00101175
LAB_00101170:
ADD EAX,EDI
SUB EDX,0x2
LAB_00101175:
ADD EAX,EDI
CMP EDX,0x1
JNZ 0x00101170
LAB_00101... | int func0(int param_1,uint param_2)
{
int iVar1;
if ((int)param_2 < 0) {
param_2 = -param_2;
iVar1 = -1;
}
else {
if (param_2 == 0) {
return 0;
}
iVar1 = 1;
}
param_1 = param_1 * iVar1;
iVar1 = 0;
if ((param_2 & 1) == 0) {
param_2 = param_2 - 1;
iVar1 = param_1;
}... |
4,404 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
... | int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "progra... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x20(%rbp),%rax
lea 0xe16(%rip),%rsi
mov %rax,%rdi
callq 10d0 <strtok@plt>
mov %rax,-0x8(%rbp)
jmp 124e <func0+0x85>
mov -0x8(%rbp),%rax
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+s], rsi
mov [rbp+var_28], rdx
mov [rbp+var_C], 0
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+var_8], rax
jmp short loc_1254
loc_1203:
... | _QWORD * func0(int a1, char *a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+24h] [rbp-Ch]
const char *i; // [rsp+28h] [rbp-8h]
v6 = 0;
for ( i = strtok(a2, " "); i; i = strtok(0LL, " ") )
{
if ( a1 < strlen(i) )
{
v3 = v6++;
word_len_1[v3] = i;
}
}
*a3 = v6;
return word_len_... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101254
LAB_001... | int1 * func0(int param_1,char *param_2,int *param_3)
{
size_t sVar1;
int local_14;
char *local_10;
local_14 = 0;
local_10 = strtok(param_2," ");
while (local_10 != (char *)0x0) {
sVar1 = strlen(local_10);
if ((ulong)(long)param_1 < sVar1) {
*(char **)(word_len_1 + (long)local_14 * 8) = loc... |
4,405 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
... | int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "progra... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebp
mov %rsi,%rdi
mov %rdx,%r13
lea 0xe5e(%rip),%rsi
callq 1090 <strtok@plt>
test %rax,%rax
je 1209 <func0+0x80>
mov %rax,%rdx
mov $0x0,%ebx
lea 0x2e81(%rip),%r12
jmp 11da <func0+0x51>
lea 0xe3c(%... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12d, edi
mov rdi, rsi
mov r15, rdx
lea rsi, unk_2004
call _strtok
test rax, rax
jz short loc_123E
mov rbx, rax
mov ebp, 0
movsxd r12, r12d
lea r14, _word_len_1
lea r13, ... | _QWORD * func0(int a1, long long a2, _DWORD *a3)
{
long long v4; // rax
long long v5; // rbx
int v6; // ebp
v4 = strtok(a2, &unk_2004);
if ( v4 )
{
v5 = v4;
v6 = 0;
do
{
if ( strlen(v5) > (unsigned long long)a1 )
word_len_1[v6++] = v5;
v5 = strtok(0LL, &unk_2004);
}
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12D,EDI
MOV RDI,RSI
MOV R15,RDX
LEA RSI,[0x102004]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x0010123e
MOV RBX,RAX
MOV EBP,0x0
MOVSXD R12,R12D
LEA R14,[0x104040]
LEA R13,[0x102004]
JMP 0x00101225
LAB_00101210:
MOV RSI,R13
MOV EDI,0x0
CALL 0x00... | int8 * func0(int param_1,char *param_2,int *param_3)
{
char *__s;
size_t sVar1;
int iVar2;
__s = strtok(param_2," ");
if (__s == (char *)0x0) {
iVar2 = 0;
}
else {
iVar2 = 0;
do {
sVar1 = strlen(__s);
if ((ulong)(long)param_1 < sVar1) {
(&word_len_1)[iVar2] = __s;
... |
4,406 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
... | int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "progra... | O2 | c | func0:
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
movslq %edi,%r12
mov %rsi,%rdi
lea 0xc3a(%rip),%rsi
push %rbp
push %rbx
callq 10b0 <strtok@plt>
test %rax,%rax
je 1430 <func0+0x80>
mov %rax,%rbx
xor %ebp,%ebp
lea 0x2c5e(%rip),%r14
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdi
cal... | func0:
endbr64
push r15
mov r15, rdx
push r14
push r13
lea r13, unk_2004
push r12
movsxd r12, edi
mov rdi, rsi
mov rsi, r13
push rbp
push rbx
sub rsp, 8
call _strtok
test rax, rax
jz short loc_1420
mov rbx, rax
xor ebp, ebp
lea r14, _word_len_1
nop dword... | _QWORD * func0(int a1, long long a2, _DWORD *a3)
{
long long v4; // rax
long long v5; // rbx
int v6; // ebp
long long v7; // rax
v4 = strtok(a2, &unk_2004);
if ( v4 )
{
v5 = v4;
v6 = 0;
do
{
if ( strlen(v5) > (unsigned long long)a1 )
{
v7 = v6++;
word_len_1[v7]... | func0:
ENDBR64
PUSH R15
MOV R15,RDX
PUSH R14
PUSH R13
LEA R13,[0x102004]
PUSH R12
MOVSXD R12,EDI
MOV RDI,RSI
MOV RSI,R13
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101420
MOV RBX,RAX
XOR EBP,EBP
LEA R14,[0x104040]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV RDI,RBX
CALL 0x00101090
CMP RAX,R12... | int8 * func0(int param_1,char *param_2,int *param_3)
{
char *__s;
size_t sVar1;
long lVar2;
int iVar3;
__s = strtok(param_2," ");
if (__s == (char *)0x0) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
sVar1 = strlen(__s);
if ((ulong)(long)param_1 < sVar1) {
lVar2 = (long)iVar3... |
4,407 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char** func0(int n, char* str, int* count) {
static char* word_len[100];
int index = 0;
char* token = strtok(str, " ");
while (token != NULL) {
if (strlen(token) > n) {
word_len[index++] = token;
}
token = strtok(NULL, " ");
}
*count = index;
... | int main() {
int count;
char test_str1[] = "python is a programming language";
char test_str2[] = "writing a program";
char test_str3[] = "sorting list";
char** result1 = func0(3, test_str1, &count);
assert(count == 3 && strcmp(result1[0], "python") == 0 && strcmp(result1[1], "progra... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
movslq %edi,%rbp
mov %rsi,%rdi
lea 0xc37(%rip),%rsi
push %rbx
sub $0x8,%rsp
callq 10b0 <strtok@plt>
test %rax,%rax
je 1460 <func0+0xb0>
mov %rax,%rbx
xor %r14d,%r14d
lea 0x2c53(%rip),%r13
nopl (%rax)... | func0:
endbr64
push r15
push r14
push r13
push r12
lea r12, delim; " "
push rbp
movsxd rbp, edi
mov rdi, rsi; s
mov rsi, r12; delim
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdx
call _strtok
test rax, rax
jz short loc_1450
mov r15, rax
xor ebx, ebx
lea r14... | _QWORD * func0(int a1, char *a2, _DWORD *a3)
{
char *v3; // rax
char *v4; // r15
long long v5; // rbx
char *v6; // rax
v3 = strtok(a2, " ");
if ( v3 )
{
v4 = v3;
v5 = 0LL;
while ( a1 >= strlen(v4) )
{
LABEL_6:
v4 = strtok(0LL, " ");
if ( !v4 )
goto LABEL_7;
}
w... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
LEA R12,[0x102004]
PUSH RBP
MOVSXD RBP,EDI
MOV RDI,RSI
MOV RSI,R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDX
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101450
MOV R15,RAX
XOR EBX,EBX
LEA R14,[0x104040]
NOP dword ptr [RAX]
LAB_001013e0:
MOV RDI,R15
CALL 0x00101090
CM... | int8 * func0(int param_1,char *param_2,int4 *param_3)
{
char *__s;
ulong uVar1;
ulong uVar2;
uint uVar3;
__s = strtok(param_2," ");
if (__s == (char *)0x0) {
uVar2 = 0;
}
else {
uVar2 = 0;
do {
uVar1 = strlen(__s);
while ((ulong)(long)param_1 < uVar1) {
(&word_len_1)[... |
4,408 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
... | int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
sub $0x60,%rsp
mov %edi,-0x64(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x64(%rbp),%ecx
movslq %ecx,%rax
sub $0x1,%rax
mov %rax,-0x30(%rbp)
movslq %ecx,%rax
mov %rax,%r12
mov $... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_54], edi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov ecx, [rbp+var_54]
movsxd rax, ecx
sub rax, 1
mov [rbp+var_20], rax
mov rax, rsp
mov rdi, rax
mov eax, [rbp+var_54]
a... | long long func0(int a1, long long a2)
{
int v2; // eax
unsigned long long v3; // rax
void *v4; // rsp
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
long long v10; // [rsp+8h] [rbp-60h] BYREF
int v11; // [rsp+14h] [rbp-54h]
int v12; // [rsp+18h] [rbp-50h]
int i; // [rsp+1Ch] [rbp-4Ch... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0x54],EDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV ECX,dword ptr [RBP + -0x54]
MOVSXD RAX,ECX
SUB RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,RSP
MOV RDI,RAX
MOV EAX,dword ptr [RB... | int8 func0(int param_1,long param_2)
{
int iVar1;
long lVar2;
ulong uVar3;
int8 uVar4;
long *plVar5;
long in_FS_OFFSET;
long local_68;
int local_5c;
int local_58;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
int loca... |
4,409 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
... | int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, ... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %edi,%r11
lea 0x2(%rdi,%rdi,1),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r8d, edi
mov r12, rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd r10, edi
lea eax, [rdi+rdi+2]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx... | long long func0(int a1, _DWORD *a2)
{
long long v4; // r10
signed long long v5; // rax
void *v6; // rsp
_DWORD *v7; // rsi
long long v8; // rdi
long long v9; // rax
_DWORD *v10; // r9
long long v11; // r11
_BYTE *v12; // r15
_DWORD *v13; // rcx
_DWORD *v14; // rax
int v15; // edx
_DWORD *v16;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R8D,EDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD R10,EDI
LEA EAX,[RDI + RDI*0x1 + 0x2]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SU... | int8 func0(uint param_1,int *param_2)
{
long lVar1;
uint uVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
int *piVar6;
ulong uVar7;
int iVar8;
uint uVar9;
int1 *puVar10;
uint uVar11;
int iVar12;
ulong uVar13;
long in_FS_OFFSET;
bool bVar14;
int1 auStack_58 [8];
ulong local_50;
long loca... |
4,410 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
... | int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, ... | O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
movslq %edi,%r13
push %r12
mov %rsi,%r12
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x2(%rdi,%rdi,1),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
movsxd r13, edi
push r12
mov r8, r13
mov r12, rsi
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [r13+r13+2]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx,... | long long func0(int a1, _DWORD *a2)
{
long long v2; // r13
long long v5; // rdx
long long *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
int v10; // r9d
_DWORD *v11; // rsi
_DWORD *v12; // r10
long long v13; // rax
long long v14; // rdi
long long v15; // r11
_BYTE ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,EDI
PUSH R12
MOV R8,R13
MOV R12,RSI
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[R13 + R13*0x1 + 0x2]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND R... | int8 func0(int param_1,int *param_2)
{
long lVar1;
int1 *puVar2;
int iVar3;
int *piVar4;
int *piVar5;
int8 uVar6;
int iVar7;
int *piVar8;
int iVar9;
ulong uVar10;
int1 *puVar11;
uint uVar13;
ulong uVar14;
long in_FS_OFFSET;
bool bVar15;
int1 auStack_58 [8];
ulong local_50;
long loca... |
4,411 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int size, int my_matrix[size][size]) {
int sum_list[2 * size + 2];
int index = 0;
// Sum of rows
for(int i = 0; i < size; i++) {
int sum = 0;
for(int j = 0; j < size; j++) {
sum += my_matrix[i][j];
}
sum_list[index++] = sum;
}
... | int main() {
int matrix1[4][4] = {
{7, 12, 1, 14},
{2, 13, 8, 11},
{16, 3, 10, 5},
{9, 6, 15, 4}
};
int matrix2[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, 3, 8}
};
int matrix3[3][3] = {
{2, 7, 6},
{9, 5, 1},
{4, ... | O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rsi,-0x48(%rbp)
mov %rsp,%rbx
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %edi,%rax
mov %rax,-0x50(%rbp)
lea 0x2(%rdi,%rdi,1),%eax
cltq
lea 0xf(,%rax,4),... | func0:
endbr64
push rbp
mov r10, rsi
mov rbp, rsp
push r15
movsxd r15, edi
push r14
mov rax, r15
push r13
push r12
push rbx
sub rsp, 38h
mov rdx, fs:28h
mov [rbp+var_38], rdx
xor edx, edx
lea edx, [r15+r15+2]
mov rsi, rsp
movsxd rdx, edx
lea rdx, ds:0Fh[rdx*4]... | long long func0(int a1, const __m128i *a2)
{
long long v3; // rcx
long long *v4; // rsi
__int16 v5; // cx
signed long long v6; // rcx
void *v7; // rsp
_QWORD *v8; // rcx
const __m128i *v9; // rsi
long long v10; // rdx
const __m128i *v11; // r8
__m128i v12; // xmm0
__m128i v13; // xmm2
signed in... | func0:
ENDBR64
PUSH RBP
MOV R10,RSI
MOV RBP,RSP
PUSH R15
MOVSXD R15,EDI
PUSH R14
MOV RAX,R15
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RDX
XOR EDX,EDX
LEA EDX,[R15 + R15*0x1 + 0x2]
MOV RSI,RSP
MOVSXD RDX,EDX
LEA RDX,[0xf + RDX*0x4]
MOV RCX,RDX
AND RDX,-0x1000
SUB RS... | int8 func0(uint param_1,int *param_2)
{
long lVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *puVar6;
uint uVar7;
int *piVar8;
int8 uVar9;
ulong uVar10;
int *puVar11;
uint uVar13;
int *piVar14;
int *piVar15;
uint uVar16;
long lVar17;
long in_FS_OFFSET;
bool bVar18;
in... |
4,412 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found... | int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x68,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x48(%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_5C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_28], rdx
cdqe
lea rdx, ds:0[rax*... | int * func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
unsigned long long v4; // rax
void *v5; // rsp
_BYTE v7[4]; // [rsp+8h] [rbp-60h] BYREF
int v8; // [rsp+Ch] [rbp-5Ch]
long long v9; // [rsp+10h] [rbp-58h]
int v10; // [rsp+24h] [rbp-44h]
int i; // [rsp+28h] [rbp-40h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
CDQE
LEA RDX,[RAX*0x4... | int8 * func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_68 [4];
int local_64;
long local_60;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
int *local_2... |
4,413 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found... | int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %esi,%rax
shl $0x2,%rax
lea 0xf(%rax),%rdx
mov %rdx,%rcx
and $0xfffffffffffffff0,%rcx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov ecx, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
shl rax, 2
lea rdx, [rax+0Fh]
mov r8, rdx
and r8, 0FFFFFFFFFFFFFFF0h
and rdx, 0FFFFFFFFFFFFF000h
mov rsi, rsp
sub rsi, rdx
loc_11A5:
cm... | int * func0(int *a1, int a2)
{
long long v2; // rax
signed long long v3; // rdx
void *v4; // rsp
long long v5; // rax
__int16 v6; // dx
signed long long v7; // rax
void *v8; // rsp
int *v9; // r9
int v10; // r8d
int v11; // ecx
long long v12; // rax
long long v13; // rax
int v14; // edx
_DWO... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV ECX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
SHL RAX,0x2
LEA RDX,[RAX + 0xf]
MOV R8,RDX
AND R8,-0x10
AND RDX,-0x1000
MOV RSI,RSP
SUB RSI,RDX
LAB_001011a5:
CMP RSP,RSI
JZ 0x001011bc
SUB RSP,0x1000
OR qword ptr [RSP + 0x... | int8 * func0(int *param_1,int param_2)
{
int *piVar1;
long lVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
int1 *puVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)param_2 * 4 + 0xf;
for (puVar6 = ... |
4,414 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found... | int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2... | O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
mov %rax,%rdx
and $0xfffffffffffff000,%rcx
and $0xfffffffffffffff0,%rdx
sub %rcx,%rbx
mov %rb... | func0:
endbr64
push rbp
mov r8, rdi
mov eax, esi
mov rbp, rsp
push rbx
sub rsp, 18h
mov rdx, fs:28h
mov [rbp+var_18], rdx
xor edx, edx
movsxd rdx, esi
mov rsi, rsp
lea rdx, ds:0Fh[rdx*4]
mov rdi, rdx
mov rcx, rdx
and rdi, 0FFFFFFFFFFFFF000h
and rcx, 0FFFFFFFFFF... | int * func0(int *a1, int a2)
{
int *v2; // r8
long long v4; // rdx
_DWORD *v5; // rsi
signed long long v6; // rcx
void *v7; // rsp
_DWORD *v8; // rsi
signed long long v9; // rcx
void *v10; // rsp
int v11; // r9d
long long v12; // r11
int v13; // esi
long long v14; // rcx
long long v15; // rax
... | func0:
ENDBR64
PUSH RBP
MOV R8,RDI
MOV EAX,ESI
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RDX
XOR EDX,EDX
MOVSXD RDX,ESI
MOV RSI,RSP
LEA RDX,[0xf + RDX*0x4]
MOV RDI,RDX
MOV RCX,RDX
AND RDI,-0x1000
AND RCX,-0x10
SUB RSI,RDI
CMP RSP,RSI
JZ 0x0010144d
LAB_00101438:
SUB RSP,0x... | int8 * func0(int *param_1,int param_2)
{
int *piVar1;
long lVar2;
long lVar3;
int1 *puVar4;
long lVar5;
ulong uVar6;
ulong uVar7;
long lVar8;
int1 *puVar9;
int1 *puVar11;
int iVar13;
long in_FS_OFFSET;
int1 auStack_28 [8];
long local_20;
int1 *puVar10;
int1 *puVar12;
puVar9 = auSta... |
4,415 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int size) {
int keys[size];
int counts[size];
int unique = 0;
for(int i = 0; i < size; i++) {
int num = nums[i];
int found = 0;
for(int j = 0; j < unique; j++) {
if(keys[j] == num) {
counts[j]++;
found... | int main(){
int nums1[] = {2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2};
int size1 = sizeof(nums1)/sizeof(nums1[0]);
int *result;
result = func0(nums1, size1);
assert(result[0] == 2 && result[1] == 5);
int nums2[] = {2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18};
int size2 = sizeof(nums2... | O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rcx
mov %rax,%rdx
and $0xfffffffffffff000,%rcx
and $0xfffffffffffffff0,%rdx
sub %rcx,%rbx
mov %rb... | func0:
endbr64
push rbp
movsxd r10, esi
mov r8, r10
shl r10, 2
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [r10+0Fh]
mov rcx, rsp
mov rsi, rax
mov rdx, rax
and rsi, 0FFFFFFFFFFFFF000h
and rdx, 0FFFFFFFFFFFFFFF0h
sub rcx... | long long * func0(int *a1, int a2)
{
long long v2; // r10
_DWORD *v3; // rcx
signed long long v4; // rdx
void *v5; // rsp
_DWORD *v6; // rcx
signed long long v7; // rdx
void *v8; // rsp
int *v9; // r10
int v10; // r8d
int v11; // edx
long long v12; // rcx
long long v13; // rax
signed int v14; ... | func0:
ENDBR64
PUSH RBP
MOVSXD R10,ESI
MOV R8,R10
SHL R10,0x2
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[R10 + 0xf]
MOV RCX,RSP
MOV RSI,RAX
MOV RDX,RAX
AND RSI,-0x1000
AND RDX,-0x10
SUB RCX,RSI
CMP RSP,RCX
JZ 0x0010138a
LAB_00101375:
SUB RSP,0x1000
OR qword ... | int8 * func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
long lVar3;
int *puVar4;
long lVar5;
ulong uVar6;
long lVar7;
int iVar8;
ulong uVar9;
int *puVar10;
int *puVar12;
ulong uVar14;
int iVar15;
int *piVar16;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar1... |
4,416 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
... | int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x78(%rbp)
movq $0x0,-0x70(%rbp)
movq $0x0,-0x68(%rbp)
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
movq ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_78], 0
mov qword ptr [rbp+s], 0
mov [rbp+var_68], 0
mov [rbp+var_60], 0
mov [rbp+var_58], 0
mov [rbp+var_50], 0
mov [rbp+var_48], ... | _BYTE * func0(long long a1)
{
int v1; // eax
int v2; // edx
int v3; // eax
char v4; // dl
char v6; // [rsp+13h] [rbp-7Dh]
int i; // [rsp+14h] [rbp-7Ch]
int j; // [rsp+14h] [rbp-7Ch]
int v9; // [rsp+18h] [rbp-78h]
int v10; // [rsp+18h] [rbp-78h]
int v11; // [rsp+1Ch] [rbp-74h]
char s[8]; // [rsp+20... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x78],0x0
MOV qword ptr [RBP + -0x70],0x0
MOV qword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV qwor... | int1 * func0(long param_1)
{
char cVar1;
size_t sVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_84;
int local_80;
int local_7c;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = 0;
local_78[0] = '\0';
local_78[1] = '\0';
local_78[2] = '\0';
loc... |
4,417 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
... | int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [rsp+0A8h+var_A8], 0
mov [rsp+0A8h+var_A0], 0
mov [rsp+0A8h+var_98], 0
mov [rsp+0A8h+var_90], 0
mov [rsp+0A8h+var_88], 0
mov... | _BYTE * func0(char *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
char v6; // bp
char *v7; // r12
char v8; // bl
int v9; // r13d
long long v10; // rbx
long long v11; // rax
long long v12; // rdx
long long v13; // r8
long long v14; // r9
long long v15; // rcx
int v16; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP +... | int1 * func0(char *param_1)
{
char *pcVar1;
char *pcVar2;
size_t sVar3;
char cVar4;
long lVar5;
char cVar6;
int iVar7;
int iVar8;
long in_FS_OFFSET;
char local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_a8[0] = '\0';
local_a8[1] = '\0';
local_a8[2] = '\0'... |
4,418 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
... | int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
movzbl (%rdi),%ebp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movl $0x0,0x60(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
m... | func0:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
movzx ebp, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [rsp+0A8h+var_48], 0
movaps [rsp+0A8h+var_A8], xmm0
movaps [rsp+0A8h+var_98], xmm0
movaps ... | _BYTE * func0(char *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
char v6; // bp
char *v7; // r12
char v8; // bl
int v9; // r15d
long long v10; // rax
long long v11; // rbx
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
int v16; ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOVZX EBP,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x60],0x0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP + 0x2... | void func0(char *param_1)
{
char *pcVar1;
long lVar2;
size_t sVar3;
long lVar4;
char cVar5;
long lVar6;
char cVar7;
char *pcVar8;
int iVar9;
long in_FS_OFFSET;
int1 local_a8 [16];
int1 local_98 [16];
int1 local_88 [16];
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int4 ... |
4,419 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char *str1) {
static char result_string[100];
int i, j = 0;
char vowels[100] = "";
for (i = 0; str1[i] != '\0'; i++) {
char char1 = str1[i];
if (strchr("aeiouAEIOU", char1) != NULL) {
vowels[j++] = char1;
}
}
vowels[j] = '\0';
... | int main() {
assert(strcmp(func0("Python"), "Python") == 0);
assert(strcmp(func0("USA"), "ASU") == 0);
assert(strcmp(func0("ab"), "ab") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
movzbl (%rdi),%ebp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movl $0x0,0x60(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
m... | func0:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
movzx r12d, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [rsp+0A8h+var_48], 0
movaps [rsp+0A8h+var_A8], xmm0
movaps [rsp+0A8h+var_98], xmm0
movaps ... | _BYTE * func0(char *a1)
{
char v1; // r12
char *v2; // r15
char v3; // bl
long long v4; // rbp
int v5; // eax
long long v6; // rbx
int v7; // ebp
char *v8; // rax
long long v9; // rdx
_BYTE *result; // rax
_OWORD v11[6]; // [rsp+0h] [rbp-A8h] BYREF
int v12; // [rsp+60h] [rbp-48h]
unsigned long... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOVZX R12D,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x60],0x0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP + 0x... | void func0(char *param_1)
{
int iVar1;
char *pcVar2;
size_t sVar3;
char cVar4;
long lVar5;
long lVar6;
char cVar7;
char *pcVar8;
long in_FS_OFFSET;
int local_a8 [16];
int local_98 [16];
int local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [16];
int4 local_48;
long loc... |
4,420 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov -0x8(%rbp),%rdx
mov -0x10(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1080 <strcpy@plt>
mov -0x10(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+src], rdi
mov [rbp+dest], rsi
mov rdx, [rbp+src]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rax, [rbp+dest]
leave
retn | char * func0(const char *a1, char *a2)
{
strcpy(a2, a1);
return a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x10]
LEAVE
RET | char * func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return param_2;
} |
4,421 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %rsi,%rbx
mov %rdi,%rsi
mov %rbx,%rdi
callq 1070 <strcpy@plt>
pop %rbx
retq
| func0:
endbr64
push rbx
mov rbx, rsi
mov rsi, rdi
mov rdi, rbx
call _strcpy
pop rbx
retn | long long func0(long long a1, long long a2)
{
return strcpy(a2, a1);
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RSI
MOV RSI,RDI
MOV RDI,RBX
CALL 0x00101080
POP RBX
RET | void func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return;
} |
4,422 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov %rsi,%r8
sub $0x8,%rsp
mov %rdi,%rsi
mov %r8,%rdi
callq 1070 <strcpy@plt>
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r8, rsi
sub rsp, 8
mov rsi, rdi
mov rdi, r8
call _strcpy
add rsp, 8
retn | long long func0(long long a1, long long a2)
{
return strcpy(a2, a1);
} | func0:
ENDBR64
MOV R8,RSI
SUB RSP,0x8
MOV RSI,RDI
MOV RDI,R8
CALL 0x00101060
ADD RSP,0x8
RET | void func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return;
} |
4,423 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* tup1, char* result) {
strcpy(result, tup1);
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("exercises", result), "exercises") == 0);
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov %rsi,%r8
sub $0x8,%rsp
mov %rdi,%rsi
mov %r8,%rdi
callq 1070 <strcpy@plt>
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov rdx, rsi
sub rsp, 8
mov rsi, rdi; src
mov rdi, rdx; dest
call _strcpy
add rsp, 8
retn | char * func0(char *src, char *dest)
{
return strcpy(dest, src);
} | func0:
ENDBR64
MOV RDX,RSI
SUB RSP,0x8
MOV RSI,RDI
MOV RDI,RDX
CALL 0x00101070
ADD RSP,0x8
RET | void func0(char *param_1,char *param_2)
{
strcpy(param_2,param_1);
return;
} |
4,424 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11bf <func0+0x56>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jns 11bb <func0+0x52>
mo... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11BF
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jns sho... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) < 0 )
v3 += *(_DWORD *)(4LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011bf
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EA... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < 0) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
}
return local_10;
} |
4,425 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1197 <func0+0x2e>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdi
mov $0x0,%edx
mov (%rax),%ecx
lea (%rdx,%rcx,1),%esi
test %ecx,%ecx
cmovs %esi,%edx
add $0x4,%rax
cmp %rdi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
... | func0:
endbr64
test esi, esi
jle short loc_1197
mov rax, rdi
lea edx, [rsi-1]
lea rdi, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
mov ecx, [rax]
lea esi, [rdx+rcx]
test ecx, ecx
cmovs edx, esi
add rax, 4
cmp rax, rdi
jnz short loc_1181
loc_1194:
mov eax, edx
retn
loc_1197:
mo... | long long func0(int *a1, int a2)
{
int *v2; // rax
long long v3; // rdi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
if ( *v2 < 0 )
v4 += *v2;
++v2;
}
while ( v2 != (int *)v3 );
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101197
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RDI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
TEST ECX,ECX
CMOVS EDX,ESI
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101181
LAB_00101194:
MOV EAX,EDX
RET
LAB_00101197:
MOV EDX,0x0
JMP 0x00101194 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if (*param_1 < 0) {
iVar2 = iVar2 + *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1)... |
4,426 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1390 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%edx
test %edx,%edx
lea (%rax,%rdx,1),%ecx
cmovs %ecx,%eax
add $0x4,%rdi
cmp %rsi,%rdi
jne 1378 <func0+0x18>
retq
nopl 0x0(%rax)
xor %ea... | func0:
endbr64
test esi, esi
jle short loc_1390
lea eax, [rsi-1]
lea rsi, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1378:
mov edx, [rdi]
test edx, edx
lea ecx, [rax+rdx]
cmovs eax, ecx
add rdi, 4
cmp rdi, rsi
jnz short loc_1378
retn
loc_1390:
xor eax, ... | long long func0(int *a1, int a2)
{
long long v2; // rsi
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
result = 0LL;
do
{
if ( *a1 < 0 )
result = (unsigned int)(result + *a1);
++a1;
}
while ( a1 != (int *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101390
LEA EAX,[RSI + -0x1]
LEA RSI,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101378:
MOV EDX,dword ptr [RDI]
TEST EDX,EDX
LEA ECX,[RAX + RDX*0x1]
CMOVS EAX,ECX
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x00101378
RET
LAB_00101390:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if (*param_1 < 0) {
iVar2 = iVar2 + *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
re... |
4,427 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (nums[i] < 0) {
sum += nums[i];
}
}
return sum;
}
| int main() {
int array1[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int array2[] = {10, 15, -14, 13, -18, 12, -20};
int array3[] = {19, -65, 57, 39, 152, -639, 121, 44, 90, -190};
assert(func0(array1, 9) == -32);
assert(func0(array2, 7) == -52);
assert(func0(array3, 10) == -894);
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1418 <func0+0xb8>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1421 <func0+0xc1>
mov %esi,%edx
pxor %xmm0,%xmm0
mov %rdi,%rax
shr $0x2,%edx
movdqa %xmm0,%xmm2
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm1
movdqu (%rax),%xmm3
add $0x10,%rax
pcmpgtd %xmm2,%xm... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1200
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1209
mov edx, esi
pxor xmm0, xmm0
mov rax, rdi
shr edx, 2
movdqa xmm2, xmm0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1178:
movdqu xmm3, xmmword ptr [rax]
movdqa... | long long func0(const __m128i *a1, int a2)
{
__m128i v3; // xmm0
const __m128i *v4; // rax
__m128i v5; // xmm3
signed int v6; // edx
__m128i v7; // xmm0
long long result; // rax
long long v9; // r8
int v10; // esi
int v11; // esi
int v12; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned in... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101200
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101209
MOV EDX,ESI
PXOR XMM0,XMM0
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM2,XMM0
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM3,xmmword ptr [RAX]
MOVDQA XMM1,XMM2
ADD RAX,0x10
PCMPGTD XMM1,XMM3
PAND XMM1,XMM... | int func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
if ((int)param_2 < 1) {
iVar6 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar5 = 0;
iVar6 = 0;
}
else {
iVar6 = ... |
4,428 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
i... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a8 <func0+0x3f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A8
loc_118B:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
ad... | const char * func0(long long a1, int a2, int a3)
{
int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
v4 += *(_DWORD *)(4LL * i + a1);
if ( a3 != 1 )
return "EVEN";
if ( (v4 & 1) != 0 )
return "EVEN";
return (const char *)&unk_2008;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a8
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX... | int * func0(long param_1,int param_2,int param_3)
{
int *puVar1;
uint local_10;
int local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
if (param_3 == 1) {
if ((local_10 & 1) == 0) {
puVar1 = ... |
4,429 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
i... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1199 <func0+0x30>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rsi
mov $0x0,%ecx
add (%rax),%ecx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
lea 0xe75(%rip),%rax
cmp $0x1,%edx
je 11a0 <func0+0x37>
retq
mov $0x0,%ecx
jmp 118c... | func0:
endbr64
test esi, esi
jle short loc_1199
mov rax, rdi
lea ecx, [rsi-1]
lea rsi, [rdi+rcx*4+4]
mov ecx, 0
loc_1181:
add ecx, [rax]
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_118C:
lea rax, aEven; "EVEN"
cmp edx, 1
jz short loc_11A0
locret_1198:
retn
loc_1199... | const char * func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
long long v4; // rsi
int v5; // ecx
const char *result; // rax
if ( a2 <= 0 )
{
LOBYTE(v5) = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
do
v5 += *v3++;
while ( v3 != (_DWORD *)v4 );
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101199
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RSI,[RDI + RCX*0x4 + 0x4]
MOV ECX,0x0
LAB_00101181:
ADD ECX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_0010118c:
LEA RAX,[0x102008]
CMP EDX,0x1
JZ 0x001011a0
LAB_00101198:
RET
LAB_00101199:
MOV ECX,0x0
JMP 0x0010118c
LAB_001... | int * func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int *puVar2;
uint uVar3;
if (param_2 < 1) {
uVar3 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar3 = 0;
do {
uVar3 = uVar3 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
... |
4,430 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
i... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
lea 0xe9a(%rip),%r8
cmp $0x1,%edx
jne 117c <func0+0x3c>
test $0x1,%al
lea 0xe9... | func0:
endbr64
test esi, esi
jle short loc_1180
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
add eax, [rdi]
add rdi, 4
cmp rdi, rcx
jnz short loc_1158
loc_1163:
lea r8, aEven; "EVEN"
cmp edx, 1
jnz short loc_117C
test al,... | const char * func0(_DWORD *a1, int a2, int a3)
{
long long v3; // rcx
int v4; // eax
const char *v5; // r8
if ( a2 <= 0 )
{
LOBYTE(v4) = 0;
}
else
{
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 += *a1++;
while ( a1 != (_DWORD *)v3 );
}
v5 = "EVEN";
if ( a3 == 1 && (v4 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101180
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RCX
JNZ 0x00101158
LAB_00101163:
LEA R8,[0x102008]
CMP EDX,0x1
JNZ 0x0010117c
TEST AL,0x1
LEA RAX,[0x102004]
CMOVZ R8,RAX
LAB_0... | int * func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
uint uVar2;
int *puVar3;
if (param_2 < 1) {
uVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar2 = 0;
do {
uVar2 = uVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
... |
4,431 | func0 |
#include <assert.h>
| char* func0(int arr[], int n, int p) {
int _sum = 0;
for (int i = 0; i < n; i++) {
_sum += arr[i];
}
if (p == 1) {
if (_sum % 2 == 0) {
return "ODD";
} else {
return "EVEN";
}
}
return "EVEN";
}
| int main() {
int arr1[3] = {5, 7, 10};
assert(func0(arr1, 3, 1)[0] == 'O' && func0(arr1, 3, 1)[1] == 'D' && func0(arr1, 3, 1)[2] == 'D');
int arr2[2] = {2, 3};
assert(func0(arr2, 2, 3)[0] == 'E' && func0(arr2, 2, 3)[1] == 'V' && func0(arr2, 2, 3)[2] == 'E' && func0(arr2, 2, 3)[3] == 'N');
i... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1200 <func0+0xc0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1204 <func0+0xc4>
mov %esi,%ecx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%ecx
shl $0x4,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rcx,%... | func0:
endbr64
mov ecx, esi
mov r8d, edx
test esi, esi
jle loc_11F0
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1209
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp ... | const char * func0(const __m128i *a1, int a2, int a3)
{
const __m128i *v4; // rax
__m128i v5; // xmm0
__m128i v6; // xmm2
signed int v7; // edx
__m128i v8; // xmm0
int v9; // eax
long long v10; // r9
const char *v11; // rdx
bool v13; // zf
void *v14; // rdx
if ( a2 > 0 )
{
if ( (unsigned in... | func0:
ENDBR64
MOV ECX,ESI
MOV R8D,EDX
TEST ESI,ESI
JLE 0x001011f0
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101209
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ECX
P... | int * func0(int *param_1,uint param_2,int param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int *puVar7;
int iVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
if ((int)param_2 < 1) {
puVar7 = &DAT_00102004;
if (param_3 != 1) {
puVar7 =... |
4,432 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
add %eax,%eax
sub $0x1,%eax
imul -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
add eax, eax
sub eax, 1
imul eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
SUB EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,433 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rdi,%rdi,1),%eax
imul %edi,%eax
retq
| func0:
endbr64
lea eax, [rdi+rdi-1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1 + -0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,434 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rdi,%rdi,1),%eax
imul %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
lea eax, [rdi+rdi-1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1 + -0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,435 | func0 |
#include <assert.h>
| int func0(int n) {
return n * (2 * n - 1);
}
| int main() {
assert(func0(10) == 190);
assert(func0(5) == 45);
assert(func0(7) == 91);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rdi,%rdi,1),%eax
imul %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
lea eax, [rdi+rdi-1]
imul eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (2 * a1 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + RDI*0x1 + -0x1]
IMUL EAX,EDI
RET | int func0(int param_1)
{
return (param_1 * 2 + -1) * param_1;
} |
4,436 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((uni... | int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
cmpl $0x31,-0x24(%rbp)
jg 117c <func0+0x33>
cvtsi2sdl -0x24(%rbp),%xmm1
movsd 0xf21(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
movl $0x19,-0x14(%rbp)
jmpq 121b <func0+0xd2>
cmpl $0x64,-0x24(%rbp)
jg 11b2 <func0+0x69>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
cmp [rbp+var_24], 31h ; '1'
jg short loc_1180
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_24]
movsd xmm0, cs:qword_2070
mulsd xmm0, xmm1
movsd [rbp+var_10], xmm0
mov [rbp+var_14], 19h
jmp loc_122B
loc_1180:
cmp [rbp+var_24],... | double func0(int a1)
{
int v2; // [rsp+10h] [rbp-14h]
double v3; // [rsp+14h] [rbp-10h]
if ( a1 > 49 )
{
if ( a1 > 100 )
{
if ( a1 > 200 )
{
v3 = (double)(a1 - 200) * 8.449999999999999 + 818.5;
v2 = 75;
}
else
{
v3 = (double)(a1 - 100) * 5.26 + 292... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
CMP dword ptr [RBP + -0x24],0x31
JG 0x00101180
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x24]
MOVSD XMM0,qword ptr [0x00102070]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
MOV dword ptr [RBP + -0x14],0x19
JMP 0x0010122b
LAB_00101180:
CMP d... | double func0(int param_1)
{
int4 local_1c;
int8 local_18;
if (param_1 < 0x32) {
local_18 = DAT_00102070 * (double)param_1;
local_1c = 0x19;
}
else if (param_1 < 0x65) {
local_18 = DAT_00102080 + (double)(param_1 + -0x32) * DAT_00102078;
local_1c = 0x23;
}
else if (param_1 < 0xc9) {
... |
4,437 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((uni... | int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x31,%edi
jg 1154 <func0+0x2b>
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xec6(%rip),%xmm0
mov $0x19,%eax
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
addsd %xmm1,%xmm0
retq
cmp $0x64,%edi
jg 117b <func0+0x52>
sub $0x32,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xea4(%rip... | func0:
endbr64
cmp edi, 31h ; '1'
jg short loc_1154
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
mulsd xmm1, cs:qword_2008
mov eax, 19h
loc_1147:
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
addsd xmm0, xmm1
retn
loc_1154:
cmp edi, 64h ; 'd'
jg short loc_117B
sub edi, 32h ; '2'
pxor xmm1, xmm1
cvtsi2... | double func0(int a1)
{
double v1; // xmm1_8
int v2; // eax
if ( a1 > 49 )
{
if ( a1 > 100 )
{
if ( a1 > 200 )
{
v1 = (double)(a1 - 200) * 8.449999999999999 + 818.5;
v2 = 75;
}
else
{
v1 = (double)(a1 - 100) * 5.26 + 292.5;
v2 = 45;
}
... | func0:
ENDBR64
CMP EDI,0x31
JG 0x00101154
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM1,qword ptr [0x00102008]
MOV EAX,0x19
LAB_00101147:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
ADDSD XMM0,XMM1
RET
LAB_00101154:
CMP EDI,0x64
JG 0x0010117b
SUB EDI,0x32
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM1,qword ptr [0x00102010]
ADDSD XMM1... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
int iVar1;
double dVar2;
if (param_1 < 0x32) {
dVar2 = (double)param_1 * _DAT_00102008;
iVar1 = 0x19;
}
else if (param_1 < 0x65) {
dVar2 = (double)(param_1 + -0x32) * _DAT_00102010... |
4,438 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((uni... | int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x31,%edi
jg 1170 <func0+0x30>
pxor %xmm0,%xmm0
movsd 0xeb3(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xec7(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
cmp $0x64,%edi
jg 11a0 <func0+0x60>
sub $0x32,%edi
pxor %xmm0,%xmm0
movsd 0xe8c(%rip),%xmm1
cvtsi2sd %edi,%x... | func0:
endbr64
cmp edi, 31h ; '1'
jg short loc_1170
pxor xmm0, xmm0
movsd xmm1, cs:qword_2008
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2028
addsd xmm0, xmm1
retn
loc_1170:
cmp edi, 64h ; 'd'
jg short loc_11A0
sub edi, 32h ; '2'
pxor xmm0, xmm0
movsd xmm1, cs:qword_2010
cvtsi2sd xmm0, ... | double func0(int a1)
{
if ( a1 <= 49 )
return (double)a1 * 2.6 + 25.0;
if ( a1 <= 100 )
return (double)(a1 - 50) * 3.25 + 130.0 + 35.0;
if ( a1 > 200 )
return (double)(a1 - 200) * 8.449999999999999 + 818.5 + 75.0;
return (double)(a1 - 100) * 5.26 + 292.5 + 45.0;
} | func0:
ENDBR64
CMP EDI,0x31
JG 0x00101170
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102008]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102028]
ADDSD XMM0,XMM1
RET
LAB_00101170:
CMP EDI,0x64
JG 0x001011a0
SUB EDI,0x32
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102010]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102030]
AD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
if (param_1 < 0x32) {
return (double)param_1 * _DAT_00102028 + DAT_00102008;
}
if (param_1 < 0x65) {
return (double)(param_1 + -0x32) * _DAT_00102030 + _DAT_00102038 + DAT_00102010;
}
if ... |
4,439 | func0 |
#include <assert.h>
| double func0(int units) {
double amount;
int surcharge;
if (units < 50) {
amount = units * 2.60;
surcharge = 25;
} else if (units <= 100) {
amount = 130 + ((units - 50) * 3.25);
surcharge = 35;
} else if (units <= 200) {
amount = 130 + 162.50 + ((uni... | int main() {
assert(func0(75) == 246.25);
assert(func0(265) == 1442.75);
assert(func0(100) == 327.5);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x31,%edi
jg 1170 <func0+0x30>
pxor %xmm0,%xmm0
movsd 0xeb3(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd 0xec7(%rip),%xmm0
addsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
cmp $0x64,%edi
jg 11a0 <func0+0x60>
sub $0x32,%edi
pxor %xmm0,%xmm0
movsd 0xe8c(%rip),%xmm1
cvtsi2sd %edi,%x... | func0:
endbr64
cmp edi, 31h ; '1'
jg short loc_1170
pxor xmm0, xmm0
movsd xmm1, cs:qword_2008
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2028
addsd xmm0, xmm1
retn
loc_1170:
cmp edi, 64h ; 'd'
jg short loc_11A0
sub edi, 32h ; '2'
pxor xmm0, xmm0
movsd xmm1, cs:qword_2010
cvtsi2sd xmm0, ... | double func0(int a1)
{
if ( a1 <= 49 )
return (double)a1 * 2.6 + 25.0;
if ( a1 <= 100 )
return (double)(a1 - 50) * 3.25 + 130.0 + 35.0;
if ( a1 > 200 )
return (double)(a1 - 200) * 8.449999999999999 + 818.5 + 75.0;
return (double)(a1 - 100) * 5.26 + 292.5 + 45.0;
} | func0:
ENDBR64
CMP EDI,0x31
JG 0x00101170
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102008]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102028]
ADDSD XMM0,XMM1
RET
LAB_00101170:
CMP EDI,0x64
JG 0x001011a0
SUB EDI,0x32
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x00102010]
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102030]
AD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
if (param_1 < 0x32) {
return (double)param_1 * _DAT_00102028 + DAT_00102008;
}
if (param_1 < 0x65) {
return (double)(param_1 + -0x32) * _DAT_00102030 + _DAT_00102038 + DAT_00102010;
}
if ... |
4,440 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] == 0){
n1++;
}
}
double ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11ce <func0+0x45>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jne 1... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_11CE
loc_11AC:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test ea... | double func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( !*(_DWORD *)(4LL * i + a1) )
++v3;
}
return round((double)v3 / (double)a2 * 100.0) / 100.0;
} | 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
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011ce
LAB_001011ac:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr... | double func0(long param_1,int param_2)
{
double dVar1;
int4 local_18;
int4 local_14;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) == 0) {
local_18 = local_18 + 1;
}
}
dVar1 = round(((double)local_18 / (double)p... |
4,441 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] == 0){
n1++;
}
}
double ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
... | O1 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 11e2 <func0+0x59>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
cmpl $0x1,(%rax)
adc $0x0,%edx
add $0x4,%rax
cmp %rcx,%rax
jne 11a5 <func0+0x1c>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
cvtsi2s... | func0:
endbr64
sub rsp, 8
test esi, esi
jle short loc_11E2
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_11A5:
cmp dword ptr [rax], 1
adc edx, 0
add rax, 4
cmp rax, rcx
jnz short loc_11A5
loc_11B4:
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
pxor xmm1, x... | double func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
int v3; // edx
if ( a2 <= 0 )
{
v3 = 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 += *v2++ == 0;
while ( v2 != &a1[a2 - 1 + 1] );
}
return round((double)v3 / (double)a2 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001011e2
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_001011a5:
CMP dword ptr [RAX],0x1
ADC EDX,0x0
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011a5
LAB_001011b4:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
MULSD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (... |
4,442 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] == 0){
n1++;
}
}
double ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
... | O2 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 13f0 <func0+0x60>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw %cs:0x0(%rax,%rax,1)
cmpl $0x1,(%rdi)
adc $0x0,%eax
add $0x4,%rdi
cmp %rdi,%rdx
jne 13b0 <func0+0x20>
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pxor %xmm1,%x... | func0:
endbr64
sub rsp, 8
test esi, esi
jle short loc_13F0
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_13B0:
cmp dword ptr [rdi], 1
adc eax, 0
add rdi, 4
cmp rdx, rdi
jnz short loc_13B0
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
loc... | double func0(_DWORD *a1, int a2)
{
long long v2; // rdx
int v3; // eax
double v4; // xmm0_8
if ( a2 <= 0 )
{
v4 = 0.0;
}
else
{
v2 = (long long)&a1[a2 - 1 + 1];
v3 = 0;
do
v3 += *a1++ == 0;
while ( (_DWORD *)v2 != a1 );
v4 = (double)v3;
}
return round(v4 / (double)a2 ... | func0:
ENDBR64
SUB RSP,0x8
TEST ESI,ESI
JLE 0x001013f0
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013b0:
CMP dword ptr [RDI],0x1
ADC EAX,0x0
ADD RDI,0x4
CMP RDX,RDI
JNZ 0x001013b0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
LAB_001013c7:
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
D... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
double dVar3;
if (param_2 < 1) {
dVar3 = 0.0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 +... |
4,443 | func0 |
#include <assert.h>
#include <math.h>
| double func0(int nums[], int n) {
int n1 = 0;
for(int i = 0; i < n; i++) {
if(nums[i] == 0){
n1++;
}
}
double ratio = ((double)n1 / n);
ratio = round(ratio * 100) / 100.0;
return ratio;
}
| int main() {
int arr1[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
assert(func0(arr1, 13) == 0.15);
int arr2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
assert(func0(arr2, 13) == 0.00);
int arr3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
assert(func0(arr3, 9) == 0.00);
... | O3 | c | func0:
endbr64
sub $0x8,%rsp
test %esi,%esi
jle 1408 <func0+0xe8>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 140e <func0+0xee>
mov %esi,%edx
pxor %xmm0,%xmm0
mov %rdi,%rax
shr $0x2,%edx
movdqa %xmm0,%xmm2
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
add $0x10,%... | func0:
endbr64
sub rsp, 8
test esi, esi
jle loc_1400
lea eax, [rsi-1]
mov rcx, rdi
cmp eax, 2
jbe loc_1406
mov edx, esi
pxor xmm0, xmm0
mov rax, rdi
shr edx, 2
movdqa xmm2, xmm0
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00000000h]
loc_1360:
movdqu xmm1, xmmwor... | double func0(const __m128i *a1, int a2)
{
__m128i v2; // xmm0
const __m128i *v3; // rax
__m128i v4; // xmm1
int v5; // edx
__m128i v6; // xmm0
int v7; // eax
long long v8; // r8
double v9; // xmm0_8
if ( a2 <= 0 )
{
v9 = 0.0;
return round(v9 / (double)a2 * 100.0) / 100.0;
}
if ( (unsig... | func0:
ENDBR64
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101400
LEA EAX,[RSI + -0x1]
MOV RCX,RDI
CMP EAX,0x2
JBE 0x00101406
MOV EDX,ESI
PXOR XMM0,XMM0
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM2,XMM0
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101360:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar9;
double dVar8;
int iVar10;
int iVar11;
if ((int)param_2 < 1) {
d... |
4,444 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 116e <func0+0x25>
mov $0x0,%eax
jmp 1173 <func0+0x2a>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov edx, [rbp+var_4]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_1174
mov eax, 0
jmp short loc_1179
loc_1174:
mov eax, 1
loc_1179... | _BOOL8 func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x00101174
MOV EAX,0x0
JMP 0x00101179
LAB_00101174:
MOV EAX,0x1
LAB_00101179:
POP RBP
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,445 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
add %eax,%edi
and $0x1,%edi
sub %eax,%edi
cmp $0x1,%edi
setne %al
retq
| func0:
endbr64
mov eax, edi
shr eax, 1Fh
add edi, eax
and edi, 1
sub edi, eax
cmp edi, 1
setnz al
retn | bool func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
MOV EAX,EDI
SHR EAX,0x1f
ADD EDI,EAX
AND EDI,0x1
SUB EDI,EAX
CMP EDI,0x1
SETNZ AL
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,446 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
add %eax,%edi
and $0x1,%edi
sub %eax,%edi
cmp $0x1,%edi
setne %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
shr eax, 1Fh
add edi, eax
and edi, 1
sub edi, eax
cmp edi, 1
setnz al
retn | bool func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
MOV EAX,EDI
SHR EAX,0x1f
ADD EDI,EAX
AND EDI,0x1
SUB EDI,EAX
CMP EDI,0x1
SETNZ AL
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,447 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 2 == 1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(7) == false);
assert(func0(14) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
shr $0x1f,%eax
add %eax,%edi
and $0x1,%edi
sub %eax,%edi
cmp $0x1,%edi
setne %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
shr eax, 1Fh
add edi, eax
and edi, 1
sub edi, eax
cmp edi, 1
setnz al
retn | bool func0(int a1)
{
return a1 % 2 != 1;
} | func0:
ENDBR64
MOV EAX,EDI
SHR EAX,0x1f
ADD EDI,EAX
AND EDI,0x1
SUB EDI,EAX
CMP EDI,0x1
SETNZ AL
RET | bool func0(int param_1)
{
return param_1 % 2 != 1;
} |
4,448 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf3d(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 6.283 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return DAT_00102080 * param_1;
} |
4,449 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O1 | c | func0:
endbr64
mulsd 0xed3(%rip),%xmm0
retq
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 6.283;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,450 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O2 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 6.283;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,451 | func0 |
#include <assert.h>
| double func0(double r) {
double perimeter = 2 * 3.1415 * r;
return perimeter;
}
| int main() {
assert(func0(10) == 62.830000000000005);
assert(func0(5) == 31.415000000000003);
assert(func0(4) == 25.132);
return 0;
}
| O3 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 6.283;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,452 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
... | int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xa0,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %edx,-0x94(%rbp)
mov %rcx,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x80(%rbp)
lea -0x70(%rbp),%rdx
mov $0x0,%eax
mov $0xc,%ecx
mov %rdx,%rdi
re... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov [rbp+var_94], edx
mov [rbp+var_A0], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_80], 0
lea rdx, [rbp+var_70]
mov eax, 0
mov ecx, 0Ch
mov rd... | long long func0(long long a1, long long a2, int a3, long long a4)
{
int v4; // eax
unsigned int v6; // [rsp+20h] [rbp-80h]
int i; // [rsp+24h] [rbp-7Ch]
int j; // [rsp+28h] [rbp-78h]
int v9; // [rsp+2Ch] [rbp-74h]
_BYTE v10[96]; // [rsp+30h] [rbp-70h] BYREF
int v11; // [rsp+90h] [rbp-10h]
unsigned long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV dword ptr [RBP + -0x94],EDX
MOV qword ptr [RBP + -0xa0],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x80],0x0
LEA RDX,[RBP + -0x70]
MOV EAX,0x0
MOV EC... | int func0(long param_1,long param_2,int param_3,long param_4)
{
int iVar1;
long lVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_88;
int local_84;
int local_80;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_88 = 0;
pcVar3 = local_78;
for (lVar2 = 0xc... |
4,453 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
... | int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i... | O1 | c | func0:
endbr64
push %rbx
sub $0x70,%rsp
mov %rdi,%r11
mov %rcx,%r10
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0xc,%ecx
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %edx,%edx
jle 11f7 <func0+0x8e>
mov %rsi,%r9
lea -0x1(%rdx),%eax
lea 0x4(%rsi,%rax,... | func0:
endbr64
push rbx
sub rsp, 70h
mov r11, rdi
mov r10, rcx
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 0Ch
rep stosq
mov dword ptr [rdi], 0
test edx, edx
jle short loc_11F7
mov r9, rsi
lea eax, [rdx-1]
lea rbx, [rsi+rax*4+4]
... | long long func0(long long a1, _DWORD *a2, int a3, long long a4)
{
_DWORD *v5; // r9
long long v6; // rbx
unsigned int v7; // esi
long long i; // rax
int v9; // edx
_BYTE v11[96]; // [rsp+0h] [rbp-78h] BYREF
int v12; // [rsp+60h] [rbp-18h]
unsigned long long v13; // [rsp+68h] [rbp-10h]
v13 = __readfs... | func0:
ENDBR64
PUSH RBX
SUB RSP,0x70
MOV R11,RDI
MOV R10,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0xc
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST EDX,EDX
JLE 0x001011f7
MOV R9,RSI
LEA EAX,[RDX + -0x1]
LEA RBX,[RSI + RAX*0x4 + 0x4]
MOV ESI,0x0
JMP 0x001011e4
LAB_00101... | int func0(long param_1,int *param_2,int param_3,long param_4)
{
int *piVar1;
int iVar2;
long lVar3;
int iVar4;
char *pcVar5;
long in_FS_OFFSET;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = local_78;
for (lVar3 = 0xc; lVar3 != 0; lVar3 = lVar3 + -1) {
... |
4,454 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
... | int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i... | O2 | c | func0:
endbr64
sub $0x78,%rsp
mov %rdi,%r8
mov %rcx,%r9
mov $0xc,%ecx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %edx,%edx
jle 15ac <func0+0x9c>
lea -0x1(%rdx),%eax
mov %r8,%rdi
xor %r8d,%r8d
lea 0x4(%rsi,%r... | func0:
endbr64
sub rsp, 78h
mov r8, rdi
mov r9, rcx
mov ecx, 0Ch
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test edx, edx
jle short loc_15AC
lea eax, [rdx-1]
mov rdi, r8
xor r8d, r8d
lea r10, [rsi+rax*4+... | long long func0(long long a1, _DWORD *a2, int a3, long long a4)
{
unsigned int v5; // r8d
long long v6; // r10
long long i; // rax
int v8; // edx
long long v9; // rcx
_BYTE v11[96]; // [rsp+0h] [rbp-78h] BYREF
int v12; // [rsp+60h] [rbp-18h]
unsigned long long v13; // [rsp+68h] [rbp-10h]
v13 = __rea... | func0:
ENDBR64
SUB RSP,0x78
MOV R8,RDI
MOV R9,RCX
MOV ECX,0xc
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST EDX,EDX
JLE 0x001015ac
LEA EAX,[RDX + -0x1]
MOV RDI,R8
XOR R8D,R8D
LEA R10,[RSI + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101558:
M... | int func0(long param_1,int *param_2,int param_3,long param_4)
{
int *piVar1;
int iVar2;
long lVar3;
long lVar4;
char *pcVar5;
int iVar6;
long in_FS_OFFSET;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = local_78;
for (lVar3 = 0xc; lVar3 != 0; lVar3 = ... |
4,455 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#define MAX_SIZE 100
| int func0(int test_list[][MAX_SIZE], int sizes[], int no_of_lists, int res[]) {
int res_index = 0;
bool found[MAX_SIZE] = {false};
for (int i = 0; i < no_of_lists; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int elem = test_list[i][j];
if (!found[elem]) {
... | int main() {
int test_list1[][MAX_SIZE] = {{3, 4, 5}, {4, 5, 7}, {1, 4}};
int sizes1[] = {3, 3, 2};
int result1[MAX_SIZE];
int len1 = func0(test_list1, sizes1, 3, result1);
int expected1[] = {3, 4, 5, 7, 1};
assert(len1 == 5);
for (int i = 0; i < len1; ++i) {
assert(result1[i... | O3 | c | func0:
endbr64
push %rbx
mov %rdi,%r9
mov %rcx,%r11
mov $0xc,%ecx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %edx,%edx
jle 161f <func0+0xbf>
lea -0x1(%rdx),%eax
mov %rsi,%r10
xor %r8d,%r8d
lea ... | func0:
endbr64
sub rsp, 78h
mov r9, rdi
mov r10, rcx
mov ecx, 0Ch
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test edx, edx
jle loc_159B
movsxd rdx, edx
lea r11, [rsi+rdx*4]
xchg ax, ax
loc_1520:
mov r8d, [rs... | long long func0(long long a1, int *a2, int a3, long long a4)
{
long long result; // rax
int *v7; // r11
int v8; // r8d
long long v9; // rdx
int v10; // ecx
_BYTE v11[96]; // [rsp+0h] [rbp-78h] BYREF
int v12; // [rsp+60h] [rbp-18h]
unsigned long long v13; // [rsp+68h] [rbp-10h]
v13 = __readfsqword(0x... | func0:
ENDBR64
SUB RSP,0x78
MOV R9,RDI
MOV R10,RCX
MOV ECX,0xc
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST EDX,EDX
JLE 0x0010159b
MOVSXD RDX,EDX
LEA R11,[RSI + RDX*0x4]
NOP
LAB_00101520:
MOV R8D,dword ptr [RSI]
XOR EDX,EDX
TEST R8D,R8D
JL... | int func0(long param_1,int *param_2,int param_3,long param_4)
{
int *piVar1;
int iVar2;
int iVar3;
long lVar4;
int iVar5;
char *pcVar6;
int iVar7;
long in_FS_OFFSET;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar6 = local_78;
for (lVar4 = 0xc; lVar4 !=... |
4,456 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
... | void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 1... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 12bf <func0+0x69>
mov -0x8(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 11f0 <find_max_index>
mov %eax,-0x4(%rbp)
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
mov [rbp+var_8], eax
jmp short loc_12BF
loc_1271:
mov edx, [rbp+var_8]
mov rax, [rbp+var_18]
mov esi, edx
mov rdi, rax
call find_max_index
mov [rbp+va... | long long func0(long long a1, unsigned int a2)
{
long long result; // rax
int i; // [rsp+18h] [rbp-8h]
unsigned int max_index; // [rsp+1Ch] [rbp-4h]
result = a2;
for ( i = a2; i > 1; --i )
{
max_index = find_max_index(a1, (unsigned int)i);
result = (unsigned int)(i - 1);
if ( max_index != (_DW... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012bf
LAB_00101271:
MOV EDX,dword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x001011f0
MOV dword pt... | void func0(int8 param_1,int param_2)
{
int iVar1;
int4 local_10;
for (local_10 = param_2; 1 < local_10; local_10 = local_10 + -1) {
iVar1 = find_max_index(param_1,local_10);
if (iVar1 != local_10 + -1) {
reverse(param_1,0,iVar1);
reverse(param_1,0,local_10 + -1);
}
}
return;
} |
4,457 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
... | void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 1... | O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
cmp $0x1,%esi
jg 11ff <func0+0x36>
pop %rbx
pop %rbp
retq
mov %eax,%edx
mov $0x0,%esi
mov %rbp,%rdi
callq 1169 <reverse>
mov %ebx,%edx
mov $0x0,%esi
mov %rbp,%rdi
callq 1169 <reverse>
cmp $0x1,%ebx
je 11d9 <... | func0:
endbr64
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
cmp esi, 1
jg short loc_11DC
loc_11D4:
pop rbx
pop rbp
retn
loc_11D7:
cmp ebx, 1
jz short loc_11D4
loc_11DC:
mov esi, ebx
mov rdi, rbp
call find_max_index
sub ebx, 1
cmp ebx, eax
jz short loc_11D7
... | void func0(long long a1, int a2)
{
unsigned int v2; // ebx
unsigned int max_index; // eax
v2 = a2;
if ( a2 > 1 )
{
do
{
max_index = find_max_index(a1, v2--);
if ( v2 != max_index )
{
reverse(a1, 0LL, max_index);
reverse(a1, 0LL, v2);
}
}
while ( v2 != ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
CMP ESI,0x1
JG 0x001011dc
LAB_001011d4:
POP RBX
POP RBP
RET
LAB_001011d7:
CMP EBX,0x1
JZ 0x001011d4
LAB_001011dc:
MOV ESI,EBX
MOV RDI,RBP
CALL 0x00101190
SUB EBX,0x1
CMP EBX,EAX
JZ 0x001011d7
MOV EDX,EAX
MOV ESI,0x0
MOV RDI,RBP
CALL 0x00101169
MOV EDX,EBX
MOV ESI... | void func0(int8 param_1,int param_2)
{
int iVar1;
if (1 < param_2) {
do {
iVar1 = find_max_index(param_1,param_2);
param_2 = param_2 + -1;
if (param_2 != iVar1) {
reverse(param_1,0,iVar1);
reverse(param_1,0,param_2);
}
} while (param_2 != 1);
}
return;
} |
4,458 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
... | void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 1... | O2 | c | func0:
endbr64
nopl 0x0(%rax)
cmp $0x1,%esi
jle 141f <func0+0x7f>
mov $0x1,%edx
xor %eax,%eax
nopl 0x0(%rax)
movslq %eax,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,(%rdi,%rdx,4)
cmovg %edx,%eax
add $0x1,%rdx
cmp %edx,%esi
jg 13b8 <func0+0x18>
sub $0x1,%esi
cmp %eax,%esi
je 13a8 <fun... | func0:
endbr64
nop dword ptr [rax+00h]
loc_1398:
cmp esi, 1
jle short locret_140F
loc_139D:
mov edx, 1
xor eax, eax
nop dword ptr [rax+00h]
loc_13A8:
movsxd rcx, eax
mov ecx, [rdi+rcx*4]
cmp [rdi+rdx*4], ecx
cmovg eax, edx
add rdx, 1
cmp esi, edx
jg short loc_13A8
sub ... | void func0(long long a1, int a2)
{
long long v2; // rdx
long long v3; // rax
long long v4; // rdx
int v5; // ecx
long long v6; // rdx
long long v7; // rax
int v8; // ecx
while ( a2 > 1 )
{
while ( 1 )
{
v2 = 1LL;
LODWORD(v3) = 0;
do
{
if ( *(_DWORD *)(a1 + 4 *... | func0:
ENDBR64
NOP dword ptr [RAX]
LAB_00101398:
CMP ESI,0x1
JLE 0x0010140f
LAB_0010139d:
MOV EDX,0x1
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001013a8:
MOVSXD RCX,EAX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP dword ptr [RDI + RDX*0x4],ECX
CMOVG EAX,EDX
ADD RDX,0x1
CMP ESI,EDX
JG 0x001013a8
SUB ESI,0x1
CMP ESI,EAX
JZ 0x00101398... | void func0(long param_1,int param_2)
{
int4 uVar1;
int iVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
long lVar6;
do {
if (param_2 < 2) {
return;
}
while( true ) {
uVar5 = 1;
uVar3 = 0;
do {
if (*(int *)(param_1 + (long)(int)uVar3 * 4) < *(int *)(param_1 + uVa... |
4,459 | func0 |
#include <assert.h>
#include <stdio.h>
void reverse(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
int find_max_index(int arr[], int n) {
int max_idx = 0;
... | void func0(int arr[], int n) {
for (int curr_size = n; curr_size > 1; --curr_size) {
int max_idx = find_max_index(arr, curr_size);
if (max_idx != curr_size - 1) {
reverse(arr, 0, max_idx);
reverse(arr, 0, curr_size - 1);
}
}
}
| int main() {
int arr1[] = {15, 79, 25, 38, 69};
int arr2[] = {98, 12, 54, 36, 85};
int arr3[] = {41, 42, 32, 12, 23};
func0(arr1, 5);
func0(arr2, 5);
func0(arr3, 5);
assert(arr1[0] == 15 && arr1[1] == 25 && arr1[2] == 38 && arr1[3] == 69 && arr1[4] == 79);
assert(arr2[0] == 1... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1747 <func0+0x2b7>
push %r14
mov $0x4,%r10d
xor %r9d,%r9d
mov $0x1,%r11d
push %r13
push %r12
push %rbp
push %rbx
nopl 0x0(%rax)
mov (%rdi),%ecx
mov $0x1,%eax
xor %r8d,%r8d
nopw 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%edx
cmp %ecx,%edx
jle 14d4 ... | func0:
endbr64
mov rdx, rdi
cmp esi, 1
jle locret_13FC
loc_1370:
mov edi, [rdx]
mov r9d, esi
mov eax, 1
xor ecx, ecx
nop dword ptr [rax+00h]
loc_1380:
mov r8d, [rdx+rax*4]
cmp r8d, edi
cmovg ecx, eax
cmovg edi, r8d
add rax, 1
cmp r9, rax
jnz short loc_1380
sub ... | void func0(int *a1, int a2)
{
int v3; // edi
long long v4; // rax
long long v5; // rcx
long long v6; // rax
int v7; // edi
long long v8; // rcx
long long v9; // rax
int v10; // edi
if ( a2 > 1 )
{
do
{
v3 = *a1;
v4 = 1LL;
LODWORD(v5) = 0;
do
{
if ( a1[... | func0:
ENDBR64
MOV RDX,RDI
CMP ESI,0x1
JLE 0x001013fc
LAB_00101370:
MOV EDI,dword ptr [RDX]
MOV R9D,ESI
MOV EAX,0x1
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101380:
MOV R8D,dword ptr [RDX + RAX*0x4]
CMP R8D,EDI
CMOVG ECX,EAX
CMOVG EDI,R8D
ADD RAX,0x1
CMP R9,RAX
JNZ 0x00101380
SUB ESI,0x1
CMP ESI,ECX
JNZ 0x001013a8
LAB_001... | void func0(int *param_1,uint param_2)
{
ulong uVar1;
long lVar2;
uint uVar3;
ulong uVar4;
long lVar5;
int iVar6;
if (1 < (int)param_2) {
do {
iVar6 = *param_1;
uVar1 = 1;
uVar4 = 0;
do {
if (iVar6 < param_1[uVar1]) {
uVar4 = uVar1 & 0xffffffff;
i... |
4,460 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0xc(%rbp)
movq $0x0,-0x8(%rbp)
jmp 11f7 <func0+0x8e>
mov -0x8(%rbp),%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
m... | 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_30], rcx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11F7
loc_1192:
mov rax, [rbp+var_8]
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
... | long long func0(long long a1, long long a2, long long a3, unsigned long long a4)
{
unsigned int v5; // [rsp+24h] [rbp-Ch]
unsigned long long i; // [rsp+28h] [rbp-8h]
v5 = 0;
for ( i = 0LL; i < a4; ++i )
{
if ( *(_DWORD *)(4 * i + a1) == *(_DWORD *)(4 * i + a2) && *(_DWORD *)(4 * i + a2) == *(_DWORD *)(4... | 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 qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0xc],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001011f7
LAB_00101192:
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[RAX*0x4]
MOV RAX,qword pt... | int func0(long param_1,long param_2,long param_3,ulong param_4)
{
int4 local_14;
int8 local_10;
local_14 = 0;
for (local_10 = 0; local_10 < param_4; local_10 = local_10 + 1) {
if ((*(int *)(param_1 + local_10 * 4) == *(int *)(param_2 + local_10 * 4)) &&
(*(int *)(param_2 + local_10 * 4) == *(int ... |
4,461 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4... | O1 | c | func0:
endbr64
test %rcx,%rcx
je 119e <func0+0x35>
mov $0x0,%eax
mov $0x0,%r9d
jmp 1188 <func0+0x1f>
add $0x1,%rax
cmp %rax,%rcx
je 11a4 <func0+0x3b>
mov (%rsi,%rax,4),%r8d
cmp %r8d,(%rdi,%rax,4)
jne 117f <func0+0x16>
cmp (%rdx,%rax,4),%r8d
jne 117f <func0+0x16>
add $0x1,%r9d
... | func0:
endbr64
test rcx, rcx
jz short loc_119E
mov eax, 0
mov r9d, 0
jmp short loc_1188
loc_117F:
add rax, 1
cmp rcx, rax
jz short loc_11A4
loc_1188:
mov r8d, [rsi+rax*4]
cmp [rdi+rax*4], r8d
jnz short loc_117F
cmp r8d, [rdx+rax*4]
jnz short loc_117F
add r9d, 1
j... | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v5; // r9d
int v6; // r8d
if ( a4 )
{
v4 = 0LL;
v5 = 0;
do
{
v6 = *(_DWORD *)(a2 + 4 * v4);
if ( *(_DWORD *)(a1 + 4 * v4) == v6 && v6 == *(_DWORD *)(a3 + 4 * v4) )
... | func0:
ENDBR64
TEST RCX,RCX
JZ 0x0010119e
MOV EAX,0x0
MOV R9D,0x0
JMP 0x00101188
LAB_0010117f:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x001011a4
LAB_00101188:
MOV R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JNZ 0x0010117f
CMP R8D,dword ptr [RDX + RAX*0x4]
JNZ 0x0010117f
ADD R9D,0x1
JMP 0x0010117f
LAB_0010119e:
... | int func0(long param_1,long param_2,long param_3,long param_4)
{
int iVar1;
long lVar2;
int iVar3;
if (param_4 == 0) {
iVar3 = 0;
}
else {
lVar2 = 0;
iVar3 = 0;
do {
iVar1 = *(int *)(param_2 + lVar2 * 4);
if ((*(int *)(param_1 + lVar2 * 4) == iVar1) && (iVar1 == *(int *)(para... |
4,462 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4... | O2 | c | func0:
endbr64
test %rcx,%rcx
je 1480 <func0+0x40>
xor %eax,%eax
xor %r9d,%r9d
jmp 1459 <func0+0x19>
add $0x1,%rax
cmp %rax,%rcx
je 1476 <func0+0x36>
mov (%rsi,%rax,4),%r8d
cmp %r8d,(%rdi,%rax,4)
jne 1450 <func0+0x10>
cmp (%rdx,%rax,4),%r8d
jne 1450 <func0+0x10>
add $0x1,%rax
... | func0:
endbr64
test rcx, rcx
jz short loc_1410
xor eax, eax
xor r9d, r9d
jmp short loc_13E9
loc_13E0:
add rax, 1
cmp rcx, rax
jz short loc_1406
loc_13E9:
mov r8d, [rsi+rax*4]
cmp [rdi+rax*4], r8d
jnz short loc_13E0
cmp r8d, [rdx+rax*4]
jnz short loc_13E0
add rax,... | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v5; // r9d
int v6; // r8d
if ( !a4 )
return 0LL;
v4 = 0LL;
v5 = 0;
do
{
while ( 1 )
{
v6 = *(_DWORD *)(a2 + 4 * v4);
if ( *(_DWORD *)(a1 + 4 * v4) == v6 && v6 == *(_DWORD... | func0:
ENDBR64
TEST RCX,RCX
JZ 0x00101410
XOR EAX,EAX
XOR R9D,R9D
JMP 0x001013e9
LAB_001013e0:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x00101406
LAB_001013e9:
MOV R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JNZ 0x001013e0
CMP R8D,dword ptr [RDX + RAX*0x4]
JNZ 0x001013e0
ADD RAX,0x1
ADD R9D,0x1
CMP RCX,RAX
JNZ 0... | int func0(long param_1,long param_2,long param_3,long param_4)
{
int iVar1;
long lVar2;
int iVar3;
if (param_4 == 0) {
return 0;
}
lVar2 = 0;
iVar3 = 0;
do {
while ((iVar1 = *(int *)(param_2 + lVar2 * 4), *(int *)(param_1 + lVar2 * 4) == iVar1 &&
(iVar1 == *(int *)(param_3 + lVar2... |
4,463 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, int* list2, int* list3, size_t len) {
int result = 0;
for (size_t i = 0; i < len; ++i) {
if (list1[i] == list2[i] && list2[i] == list3[i])
result++;
}
return result;
}
| int main() {
int list1a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2a[] = {2, 2, 3, 1, 2, 6, 7, 9};
int list3a[] = {2, 1, 3, 1, 2, 6, 7, 9};
int list1b[] = {1, 2, 3, 4, 5, 6, 7, 8};
int list2b[] = {2, 2, 3, 1, 2, 6, 7, 8};
int list3b[] = {2, 1, 3, 1, 2, 6, 7, 8};
int list1c[] = {1, 2, 3, 4... | O3 | c | func0:
endbr64
test %rcx,%rcx
je 15f0 <func0+0x40>
xor %eax,%eax
xor %r9d,%r9d
jmp 15c9 <func0+0x19>
add $0x1,%rax
cmp %rax,%rcx
je 15e6 <func0+0x36>
mov (%rsi,%rax,4),%r8d
cmp %r8d,(%rdi,%rax,4)
jne 15c0 <func0+0x10>
cmp (%rdx,%rax,4),%r8d
jne 15c0 <func0+0x10>
add $0x1,%rax
... | func0:
endbr64
test rcx, rcx
jz short loc_1180
xor eax, eax
xor r9d, r9d
jmp short loc_1159
loc_1150:
add rax, 1
cmp rcx, rax
jz short loc_1176
loc_1159:
mov r8d, [rsi+rax*4]
cmp [rdi+rax*4], r8d
jnz short loc_1150
cmp r8d, [rdx+rax*4]
jnz short loc_1150
add rax,... | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v5; // r9d
int v6; // r8d
if ( !a4 )
return 0LL;
v4 = 0LL;
v5 = 0;
do
{
while ( 1 )
{
v6 = *(_DWORD *)(a2 + 4 * v4);
if ( *(_DWORD *)(a1 + 4 * v4) == v6 && v6 == *(_DWORD... | func0:
ENDBR64
TEST RCX,RCX
JZ 0x00101180
XOR EAX,EAX
XOR R9D,R9D
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RCX,RAX
JZ 0x00101176
LAB_00101159:
MOV R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JNZ 0x00101150
CMP R8D,dword ptr [RDX + RAX*0x4]
JNZ 0x00101150
ADD RAX,0x1
ADD R9D,0x1
CMP RCX,RAX
JNZ 0... | int func0(long param_1,long param_2,long param_3,long param_4)
{
int iVar1;
long lVar2;
int iVar3;
if (param_4 == 0) {
return 0;
}
lVar2 = 0;
iVar3 = 0;
do {
while ((iVar1 = *(int *)(param_2 + lVar2 * 4), *(int *)(param_1 + lVar2 * 4) == iVar1 &&
(iVar1 == *(int *)(param_3 + lVar2... |
4,464 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
cmpl $0x0,-0x4(%rbp)
je 1164 <func0+0x1b>
mov $0x1,%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
cmp [rbp+var_4], 0
jz short loc_1164
mov eax, 1
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(int a1, unsigned int a2)
{
if ( a1 )
return 1LL;
else
return a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
CMP dword ptr [RBP + -0x4],0x0
JZ 0x00101164
MOV EAX,0x1
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int4 func0(int param_1,int4 param_2)
{
if (param_1 != 0) {
param_2 = 1;
}
return param_2;
} |
4,465 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
mov $0x1,%eax
cmove %esi,%eax
retq
| func0:
endbr64
test edi, edi
mov eax, 1
cmovz eax, esi
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
result = 1LL;
if ( !a1 )
return a2;
return result;
} | ||
4,466 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
mov $0x1,%eax
cmove %esi,%eax
retq
| func0:
endbr64
test edi, edi
mov eax, 1
cmovz eax, esi
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
result = 1LL;
if ( !a1 )
return a2;
return result;
} | func0:
ENDBR64
TEST EDI,EDI
MOV EAX,0x1
CMOVZ EAX,ESI
RET | int4 func0(int param_1,int4 param_2)
{
int4 uVar1;
uVar1 = 1;
if (param_1 == 0) {
uVar1 = param_2;
}
return uVar1;
} |
4,467 | func0 |
#include <assert.h>
| int func0(int is_list, int length) {
if (is_list) {
return 1;
} else {
return length;
}
}
| int main() {
// ([1, 2, 3, 4], [5, 6, 7, 8]) -> tuple of length 2
assert(func0(0, 2) == 2);
// ([1, 2], [3, 4], [5, 6]) -> tuple of length 3
assert(func0(0, 3) == 3);
// [9, 8, 7, 6, 5, 4, 3, 2, 1] -> list
assert(func0(1, 0) == 1);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
mov $0x1,%eax
cmove %esi,%eax
retq
| func0:
endbr64
test edi, edi
mov eax, 1
cmovz eax, esi
retn | long long func0(int a1, unsigned int a2)
{
long long result; // rax
result = 1LL;
if ( !a1 )
return a2;
return result;
} | func0:
ENDBR64
TEST EDI,EDI
MOV EAX,0x1
CMOVZ EAX,ESI
RET | int4 func0(int param_1,int4 param_2)
{
int4 uVar1;
uVar1 = 1;
if (param_1 == 0) {
uVar1 = param_2;
}
return uVar1;
} |
4,468 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11d5 <func0+0x6c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
imu... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_4], eax
jmp short loc_11D5
loc_118A:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = a2 - 1; i >= 0; --i )
v3 += i * *(_DWORD *)(4LL * i + a1) - (a2 - 1 - i) * *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011d5
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = param_2 + -1; -1 < local_c; local_c = local_c + -1) {
local_10 = local_10 +
(*(int *)(param_1 + (long)local_c * 4) * local_c -
*(int *)(param_1 + (long)local_c * 4) * ((param_2 +... |
4,469 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O1 | c | func0:
endbr64
mov %esi,%eax
sub $0x1,%eax
js 119c <func0+0x33>
cltq
mov $0x0,%ecx
sub $0x1,%esi
mov %esi,%edx
sub %eax,%edx
mov %eax,%r8d
sub %edx,%r8d
mov %r8d,%edx
imul (%rdi,%rax,4),%edx
add %edx,%ecx
sub $0x1,%rax
test %eax,%eax
jns 117e <func0+0x15>
mov %ecx,%eax
ret... | func0:
endbr64
mov eax, esi
sub eax, 1
js short loc_119A
cdqe
mov ecx, 0
sub esi, 1
loc_117E:
mov r8d, esi
sub r8d, eax
mov edx, eax
sub edx, r8d
imul edx, [rdi+rax*4]
add ecx, edx
sub rax, 1
test eax, eax
jns short loc_117E
loc_1197:
mov eax, ecx
retn
loc_119A... | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // ecx
int v4; // esi
LODWORD(v2) = a2 - 1;
if ( a2 - 1 < 0 )
{
return 0;
}
else
{
v2 = (int)v2;
v3 = 0;
v4 = a2 - 1;
do
{
v3 += *(_DWORD *)(a1 + 4 * v2) * (v2 - (v4 - v2));
--v2;
}
... | func0:
ENDBR64
MOV EAX,ESI
SUB EAX,0x1
JS 0x0010119a
CDQE
MOV ECX,0x0
SUB ESI,0x1
LAB_0010117e:
MOV R8D,ESI
SUB R8D,EAX
MOV EDX,EAX
SUB EDX,R8D
IMUL EDX,dword ptr [RDI + RAX*0x4]
ADD ECX,EDX
SUB RAX,0x1
TEST EAX,EAX
JNS 0x0010117e
LAB_00101197:
MOV EAX,ECX
RET
LAB_0010119a:
MOV ECX,0x0
JMP 0x00101197 | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
if (param_2 + -1 < 0) {
iVar2 = 0;
}
else {
lVar1 = (long)(param_2 + -1);
iVar2 = 0;
do {
iVar2 = iVar2 + ((int)lVar1 * 2 - (param_2 + -1)) * *(int *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + -1;
} while (-1 < (int)l... |
4,470 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%esi
js 12f0 <func0+0x30>
movslq %esi,%rax
xor %r8d,%r8d
mov %esi,%edx
mov %eax,%ecx
sub %eax,%edx
sub %edx,%ecx
mov (%rdi,%rax,4),%edx
sub $0x1,%rax
imul %ecx,%edx
add %edx,%r8d
test %eax,%eax
jns 12d0 <func0+0x10>
mov %r8d,%eax
retq
nopl (%rax)
xor ... | func0:
endbr64
sub esi, 1
js short loc_12F0
movsxd rax, esi
xor r8d, r8d
nop
loc_12D0:
mov ecx, esi
mov edx, eax
sub ecx, eax
sub edx, ecx
imul edx, [rdi+rax*4]
sub rax, 1
add r8d, edx
test eax, eax
jns short loc_12D0
mov eax, r8d
retn
loc_12F0:
xor r8d, r8d
mov ... | long long func0(long long a1, int a2)
{
int v2; // esi
long long v3; // rax
unsigned int v4; // r8d
int v5; // edx
v2 = a2 - 1;
if ( v2 < 0 )
return 0LL;
v3 = v2;
v4 = 0;
do
{
v5 = *(_DWORD *)(a1 + 4 * v3) * (v3 - (v2 - v3));
--v3;
v4 += v5;
}
while ( (int)v3 >= 0 );
return v... | func0:
ENDBR64
SUB ESI,0x1
JS 0x001012f0
MOVSXD RAX,ESI
XOR R8D,R8D
NOP
LAB_001012d0:
MOV ECX,ESI
MOV EDX,EAX
SUB ECX,EAX
SUB EDX,ECX
IMUL EDX,dword ptr [RDI + RAX*0x4]
SUB RAX,0x1
ADD R8D,EDX
TEST EAX,EAX
JNS 0x001012d0
MOV EAX,R8D
RET
LAB_001012f0:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
long lVar3;
int iVar4;
param_2 = param_2 + -1;
if (-1 < param_2) {
lVar3 = (long)param_2;
iVar4 = 0;
do {
iVar2 = (int)lVar3;
lVar1 = lVar3 * 4;
lVar3 = lVar3 + -1;
iVar4 = iVar4 + (iVar2 * 2 - param_2) * *(... |
4,471 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for (int i = n - 1; i >= 0; --i) {
sum += i * arr[i] - (n - 1 - i) * arr[i];
}
return sum;
}
| int main() {
int arr1[5] = {1, 8, 9, 15, 16};
assert(func0(arr1, 5) == 74);
int arr2[4] = {1, 2, 3, 4};
assert(func0(arr2, 4) == 10);
int arr3[9] = {1, 2, 3, 4, 5, 7, 9, 11, 14};
assert(func0(arr3, 9) == 188);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%ecx
sub $0x1,%ecx
js 1520 <func0+0x170>
cmp $0x3,%ecx
jbe 1529 <func0+0x179>
movslq %ecx,%rax
movd %esi,%xmm5
movd %ecx,%xmm6
mov %esi,%edx
lea -0xc(%rdi,%rax,4),%rax
shr $0x2,%edx
pshufd $0x0,%xmm5,%xmm4
movdqa 0xca6(%rip),%xmm5
shl $0x4,%rdx
pshufd $0x0,%xmm6,%... | func0:
endbr64
mov edx, esi
sub esi, 1
js loc_12A0
cmp esi, 2
jbe loc_12A3
movsxd rax, edx
movd xmm5, edx
movd xmm6, esi
mov r8d, edx
lea rax, [rdi+rax*4-10h]
shr r8d, 2
pshufd xmm4, xmm5, 0
movdqa xmm5, cs:xmmword_2020
shl r8, 4
pshufd xmm6, xmm6, 0
pxor xmm3, xmm3
mov... | long long func0(long long a1, signed int a2)
{
signed int v3; // esi
const __m128i *v4; // rax
__m128i si128; // xmm5
__m128i v6; // xmm6
__m128i v7; // xmm3
__m128i v8; // xmm4
__m128i v9; // xmm2
__m128i v10; // xmm8
__m128i v11; // xmm0
__m128i v12; // xmm9
__m128i v13; // xmm1
__m128i v14; ... | func0:
ENDBR64
MOV EDX,ESI
SUB ESI,0x1
JS 0x001012a0
CMP ESI,0x2
JBE 0x001012a3
MOVSXD RAX,EDX
MOVD XMM5,EDX
MOVD XMM6,ESI
MOV R8D,EDX
LEA RAX,[RDI + RAX*0x4 + -0x10]
SHR R8D,0x2
PSHUFD XMM4,XMM5,0x0
MOVDQA XMM5,xmmword ptr [0x00102020]
SHL R8,0x4
PSHUFD XMM6,XMM6,0x0
PXOR XMM3,XMM3
MOV RCX,RAX
PADDD XMM4,xmmword ptr [... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(long param_1,uint param_2)
{
long lVar1;
int auVar2 [16];
uint *puVar3;
uint uVar4;
uint uVar5;
uint *puVar6;
uint uVar7;
uint *puVar8;
uint uVar9;
int auVar10 [16];
int iVar11;
int iVar12;
int iVa... |
4,472 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11ff <func0+0x96>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_C], eax
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_8], eax
mov [rbp+var_4], 1
jmp short loc_11FF
loc_1193:
mov eax, [rbp+var_4]
cdq... | long long func0(int *a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = *a1;
v4 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v3 > a1[i] )
v3 = a1[i];
if ( v4 < a1[i] )
v4 = a1[i];
}
return (unsigned int)(v4 - v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011ff
... | int func0(int *param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = *param_1;
local_10 = *param_1;
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (param_1[local_c] < local_14) {
local_14 = param_1[local_c];
}
if (local_10 < param_1[local_c]) {
... |
4,473 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%r8d
cmp $0x1,%esi
jle 119f <func0+0x36>
lea 0x4(%rdi),%rcx
lea -0x2(%rsi),%eax
lea 0x8(%rdi,%rax,4),%rsi
mov %r8d,%eax
mov (%rcx),%edx
cmp %edx,%r8d
cmovg %edx,%r8d
cmp %edx,%eax
cmovl %edx,%eax
add $0x4,%rcx
cmp %rsi,%rcx
jne 1184 <func0+0x1b>
sub ... | func0:
endbr64
mov r8d, [rdi]
cmp esi, 1
jle short loc_119F
lea rcx, [rdi+4]
lea eax, [rsi-2]
lea rsi, [rdi+rax*4+8]
mov eax, r8d
loc_1184:
mov edx, [rcx]
cmp r8d, edx
cmovg r8d, edx
cmp eax, edx
cmovl eax, edx
add rcx, 4
cmp rcx, rsi
jnz short loc_1184
loc_119B:
... | long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // rcx
long long v4; // rsi
int v5; // eax
v2 = *a1;
if ( a2 <= 1 )
{
v5 = *a1;
}
else
{
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 2 + 2];
v5 = *a1;
do
{
if ( v2 > *v3 )
v2 = *v3;
if ( v5 < *v3 )
... | func0:
ENDBR64
MOV R8D,dword ptr [RDI]
CMP ESI,0x1
JLE 0x0010119f
LEA RCX,[RDI + 0x4]
LEA EAX,[RSI + -0x2]
LEA RSI,[RDI + RAX*0x4 + 0x8]
MOV EAX,R8D
LAB_00101184:
MOV EDX,dword ptr [RCX]
CMP R8D,EDX
CMOVG R8D,EDX
CMP EAX,EDX
CMOVL EAX,EDX
ADD RCX,0x4
CMP RCX,RSI
JNZ 0x00101184
LAB_0010119b:
SUB EAX,R8D
RET
LAB_0010119f... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
iVar4 = *param_1;
iVar2 = iVar4;
if (1 < param_2) {
piVar3 = param_1 + 1;
do {
iVar1 = *piVar3;
if (iVar1 < iVar4) {
iVar4 = iVar1;
}
if (iVar2 < iVar1) {
iVar2 = iVar1;
... |
4,474 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%r8d
cmp $0x1,%esi
jle 1180 <func0+0x40>
lea -0x2(%rsi),%eax
lea 0x4(%rdi),%rcx
lea 0x8(%rdi,%rax,4),%rsi
mov %r8d,%eax
nopl 0x0(%rax,%rax,1)
mov (%rcx),%edx
cmp %edx,%r8d
cmovg %edx,%r8d
cmp %edx,%eax
cmovl %edx,%eax
add $0x4,%rcx
cmp %rsi,%rcx
jne 1... | func0:
endbr64
mov r8d, [rdi]
cmp esi, 1
jle short loc_1260
lea eax, [rsi-2]
lea rcx, [rdi+4]
lea rsi, [rdi+rax*4+8]
mov eax, r8d
nop dword ptr [rax+rax+00h]
loc_1240:
mov edx, [rcx]
cmp r8d, edx
cmovg r8d, edx
cmp eax, edx
cmovl eax, edx
add rcx, 4
cmp rcx, rsi
j... | long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // rcx
long long v4; // rsi
int v5; // eax
v2 = *a1;
if ( a2 <= 1 )
return 0LL;
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 2 + 2];
v5 = *a1;
do
{
if ( v2 > *v3 )
v2 = *v3;
if ( v5 < *v3 )
v5 = *v3;
++v3;
}
whil... | func0:
ENDBR64
MOV R8D,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101260
LEA EAX,[RSI + -0x2]
LEA RCX,[RDI + 0x4]
LEA RSI,[RDI + RAX*0x4 + 0x8]
MOV EAX,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101240:
MOV EDX,dword ptr [RCX]
CMP R8D,EDX
CMOVG R8D,EDX
CMP EAX,EDX
CMOVL EAX,EDX
ADD RCX,0x4
CMP RCX,RSI
JNZ 0x00101240
SUB EAX,R8D
... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
iVar4 = *param_1;
if (1 < param_2) {
piVar3 = param_1 + 1;
iVar2 = iVar4;
do {
iVar1 = *piVar3;
if (iVar1 < iVar4) {
iVar4 = iVar1;
}
if (iVar2 < iVar1) {
iVar2 = iVar1... |
4,475 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int minEle = arr[0];
int maxEle = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < minEle) {
minEle = arr[i];
}
if (arr[i] > maxEle) {
maxEle = arr[i];
}
}
return (maxEle - minEle);
}
| int main() {
int arr1[] = {2, 1, 5, 3};
int arr2[] = {9, 3, 2, 5, 1};
int arr3[] = {3, 2, 1};
assert(func0(arr1, 4) == 4);
assert(func0(arr2, 5) == 8);
assert(func0(arr3, 3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%edx
cmp $0x1,%esi
jle 12a0 <func0+0x160>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%r8d
cmp $0x2,%eax
jbe 12a3 <func0+0x163>
movd %edx,%xmm5
mov %r8d,%edx
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm5,%xmm0
shl $0x4,%rdx
movdqa %xmm0,%xmm1
add %rdi,%rdx
nopl 0... | func0:
endbr64
mov edx, [rdi]
cmp esi, 1
jle loc_12A0
lea eax, [rsi-2]
lea ecx, [rsi-1]
cmp eax, 2
jbe loc_12A3
movd xmm5, edx
mov edx, ecx
mov rax, rdi
shr edx, 2
pshufd xmm0, xmm5, 0
shl rdx, 4
movdqa xmm1, xmm0
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_1180:... | long long func0(signed int *a1, int a2)
{
signed int v2; // edx
unsigned int v3; // ecx
signed int *v4; // rax
__m128i v5; // xmm0
__m128i v6; // xmm1
__m128i v7; // xmm3
__m128i v8; // xmm2
__m128i v9; // xmm4
__m128i v10; // xmm0
__m128i v11; // xmm2
__m128i v12; // xmm3
__m128i v13; // xmm2
... | func0:
ENDBR64
MOV EDX,dword ptr [RDI]
CMP ESI,0x1
JLE 0x001012a0
LEA EAX,[RSI + -0x2]
LEA ECX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001012a3
MOVD XMM5,EDX
MOV EDX,ECX
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM0,XMM5,0x0
SHL RDX,0x4
MOVDQA XMM1,XMM0
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM3,xmmword ptr [RAX +... | int func0(uint *param_1,int param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint *puVar6;
uint uVar7;
int iVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uVar13 = *param_1;
if (param_2 < 2) {
return 0;
}
... |
4,476 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
movzbl (%rax),%eax
movsbl %al,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax]
movsx eax, al
pop rbp
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
POP RBP
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,477 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O1 | c | func0:
endbr64
movsbl (%rdi),%eax
retq
| func0:
endbr64
movsx eax, byte ptr [rdi]
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,478 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O2 | c | func0:
endbr64
movsbl (%rdi),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsx eax, byte ptr [rdi]
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,479 | func0 |
#include <assert.h>
| int func0(char* str1) {
return str1[0];
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O3 | c | func0:
endbr64
movsbl (%rdi),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsx eax, byte ptr [rdi]
retn | long long func0(char *a1)
{
return (unsigned int)*a1;
} | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
RET | int func0(char *param_1)
{
return (int)*param_1;
} |
4,480 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int tri[3][3], int m, int n) {
for (int i = m-1; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
retur... | int main() {
int tri1[3][3] = {{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
int tri2[3][3] = {{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
int tri3[3][3] = {{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(tri1, 2, 2) == 14);
assert(func0(tri2, 2, 2) == 24);
assert(func0(tri3, 2, 2) == 53);
return ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 12ed <func0+0x184>
movl $0x0,-0x4(%rbp)
jmpq 12dd <func0+0x174>
mov -0x8(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
mov %rdx,%ra... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_8], eax
jmp loc_12ED
loc_1189:
mov [rbp+var_4], 0
jmp loc_12DD
loc_1195:
mov eax, [rbp+var_8]
cdqe
lea rdx, [rax+1]
mov ... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // ecx
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+1Ch] [rbp-4h]
for ( i = a2 - 1; i >= 0; --i )
{
for ( j = 0; j <= i; ++j )
{
if ( (int)a1[3 * i + 3 + j] <= (int)a1[3 * i + 4 + j] )
v2 = a1[3 * i + 4 + j];
else
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012ed
LAB_00101189:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012dd
LAB_00101195:
MOV EAX,dword ptr [RBP +... | int4 func0(int4 *param_1,int param_2)
{
int local_10;
int local_c;
for (local_10 = param_2 + -1; -1 < local_10; local_10 = local_10 + -1) {
for (local_c = 0; local_c <= local_10; local_c = local_c + 1) {
if ((int)param_1[((long)local_10 + 1) * 3 + (long)(local_c + 1)] <
(int)param_1[((long... |
4,481 | func0 | #include <assert.h>
#include <stdio.h>
| int func0(int tri[3][3], int m, int n) {
for (int i = m-1; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
retur... | int main() {
int tri1[3][3] = {{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
int tri2[3][3] = {{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
int tri3[3][3] = {{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(tri1, 2, 2) == 14);
assert(func0(tri2, 2, 2) == 24);
assert(func0(tri3, 2, 2) == 53);
return ... | O1 | c | func0:
endbr64
sub $0x1,%esi
js 11bc <func0+0x53>
movslq %esi,%rax
lea (%rax,%rax,2),%rax
lea (%rdi,%rax,4),%r10
jmp 11aa <func0+0x41>
add %edx,(%r8,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jl 119e <func0+0x35>
mov (%r9,%rax,4),%ecx
mov 0x4(%r9,%rax,4),%edx
cmp %edx,%ecx
jle 117f <fu... | func0:
endbr64
sub esi, 1
js short loc_11BC
movsxd rax, esi
lea rax, [rax+rax*2]
lea r10, [rdi+rax*4]
jmp short loc_11AA
loc_117F:
add [r8+rax*4], edx
loc_1183:
add rax, 1
cmp esi, eax
jl short loc_119E
loc_118B:
mov ecx, [r9+rax*4]
mov edx, [r9+rax*4+4]
cmp ecx, edx
j... | long long func0(unsigned int *a1, int a2)
{
int v2; // esi
unsigned int *v3; // r10
long long v4; // rax
signed int v5; // ecx
signed int v6; // edx
unsigned int *v7; // r9
v2 = a2 - 1;
if ( v2 >= 0 )
{
v3 = &a1[3 * v2];
do
{
if ( v2 >= 0 )
{
v7 = v3 + 3;
v4 =... | func0:
ENDBR64
SUB ESI,0x1
JS 0x001011bc
MOVSXD RAX,ESI
LEA RAX,[RAX + RAX*0x2]
LEA R10,[RDI + RAX*0x4]
JMP 0x001011aa
LAB_0010117f:
ADD dword ptr [R8 + RAX*0x4],EDX
LAB_00101183:
ADD RAX,0x1
CMP ESI,EAX
JL 0x0010119e
LAB_0010118b:
MOV ECX,dword ptr [R9 + RAX*0x4]
MOV EDX,dword ptr [R9 + RAX*0x4 + 0x4]
CMP ECX,EDX
JLE ... | int4 func0(int4 *param_1,int param_2)
{
long lVar1;
int4 *puVar2;
param_2 = param_2 + -1;
if (-1 < param_2) {
puVar2 = param_1 + (long)param_2 * 3;
do {
if (-1 < param_2) {
lVar1 = 0;
do {
if ((int)puVar2[lVar1 + 4] < (int)puVar2[lVar1 + 3]) {
puVar2[lVar1... |
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.