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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
6,282 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr1[], int arr2[], int m, int n, int k) {
int sorted1[m + n];
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
... | int main() {
int arr1_1[] = {2, 3, 6, 7, 9};
int arr2_1[] = {1, 4, 8, 10};
int arr1_2[] = {100, 112, 256, 349, 770};
int arr2_2[] = {72, 86, 113, 119, 265, 445, 892};
int arr1_3[] = {3, 4, 7, 8, 10};
int arr2_3[] = {2, 5, 9, 11};
assert(func0(arr1_1, arr2_1, 5, 4, 5) == 6);
ass... | O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea (%rdx,%rcx,1),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%r9
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xffffffffffff... | func0:
endbr64
push rbp
mov r9d, edx
mov rbp, rsp
push r15
mov r15, rsi
push r14
mov r14d, ecx
push r13
mov r13d, r8d
push r12
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdx+rcx]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[r... | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
long long v9; // rdx
_DWORD *v10; // rcx
__int16 v11; // dx
signed long long v12; // rdx
void *v13; // rsp
_DWORD *v14; // rcx
long long v15; // rax
int v16; // ebx
int v17; // r12d
long long v18; // r8
int v19; // edx
int v2... | func0:
ENDBR64
PUSH RBP
MOV R9D,EDX
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
MOV R14D,ECX
PUSH R13
MOV R13D,R8D
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDX + RCX*0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX... | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
int1 *puVar5;
ulong uVar6;
int iVar7;
int1 *puVar8;
long lVar10;
int iVar11;
long in_FS_OFFSET;
int1 auStack_68 [12];
int local_5c;
int1 *local_58;
int1 *local_50;
l... |
6,283 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr1[], int arr2[], int m, int n, int k) {
int sorted1[m + n];
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
... | int main() {
int arr1_1[] = {2, 3, 6, 7, 9};
int arr2_1[] = {1, 4, 8, 10};
int arr1_2[] = {100, 112, 256, 349, 770};
int arr2_2[] = {72, 86, 113, 119, 265, 445, 892};
int arr1_3[] = {3, 4, 7, 8, 10};
int arr2_3[] = {2, 5, 9, 11};
assert(func0(arr1_1, arr2_1, 5, 4, 5) == 6);
ass... | O3 | c | func0:
endbr64
push %rbp
mov %edx,%r9d
mov %rsp,%rbp
push %r15
mov %rsi,%r15
push %r14
mov %ecx,%r14d
push %r13
mov %r8d,%r13d
push %r12
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea (%rdx,%rcx,1),%eax
mov %rsp,%rsi
cltq
lea 0xf(,%rax,4... | func0:
endbr64
push rbp
mov r9d, edx
mov rbp, rsp
push r15
mov r15, rsi
push r14
mov r14d, ecx
push r13
mov r13d, r8d
push r12
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdx+rcx]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[r... | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
long long v9; // rdx
_DWORD *v10; // rcx
__int16 v11; // dx
signed long long v12; // rdx
void *v13; // rsp
_DWORD *v14; // rcx
long long v15; // rax
int v16; // ebx
int v17; // r12d
long long v18; // r10
long long i; // r8
in... | func0:
ENDBR64
PUSH RBP
MOV R9D,EDX
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
MOV R14D,ECX
PUSH R13
MOV R13D,R8D
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDX + RCX*0x1]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX... | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
int *puVar5;
int iVar6;
ulong uVar7;
int iVar8;
int *puVar9;
long lVar11;
int iVar12;
long lVar13;
int iVar14;
long in_FS_OFFSET;
int auStack_68 [12];
int local_5c... |
6,284 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == ... | int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11b0 <func0+0x47>
addl $0x1,-0xc(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_11B0
loc_118E:
add [rbp+var_C], 1
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 2... | _BOOL8 func0(int a1)
{
int v2; // [rsp+10h] [rbp-10h]
int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+18h] [rbp-8h]
v2 = 0;
v3 = 0;
for ( i = a1; i > 0; i /= 10 )
++v3;
for ( j = a1; j > 0; j /= 10 )
v2 = (int)(pow((double)(j % 10), (double)v3) + (double)v2);
return... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011b0
LAB_0010118e:
ADD dword ptr [RBP + -0xc],0x1
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RD... | bool func0(int param_1)
{
int iVar1;
double dVar2;
int local_18;
int local_14;
int local_10;
local_18 = 0;
local_14 = 0;
for (local_10 = param_1; iVar1 = param_1, 0 < local_10; local_10 = local_10 / 10) {
local_14 = local_14 + 1;
}
while (local_10 = iVar1, 0 < local_10) {
dVar2 = pow((do... |
6,285 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == ... | int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%ebp
test %edi,%edi
jle 1226 <func0+0xbd>
mov %edi,%eax
mov $0x0,%ecx
add $0x1,%ecx
mov %eax,%esi
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13d, edi
test edi, edi
jle loc_121F
mov edx, edi
mov ecx, 0
loc_1187:
add ecx, 1
mov esi, edx
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov edi, edx
sar edi, 1Fh
sub eax, edi
mov edx... | _BOOL8 func0(int a1)
{
int v1; // edx
int v2; // ecx
int v3; // esi
int v4; // ebp
int v5; // r12d
double v6; // r14
int v7; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 10;
}
while ( v3 > 9 );
v4 = a1;
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13D,EDI
TEST EDI,EDI
JLE 0x0010121f
MOV EDX,EDI
MOV ECX,0x0
LAB_00101187:
ADD ECX,0x1
MOV ESI,EDX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDI,EDX
SAR EDI,0x1f
SUB EAX,EDI
MOV EDX,EAX
CMP ESI,0x9
JG 0x00101187
MOV EBP,R13D
MOV R12D,0x0
PXOR... | bool func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
double dVar5;
if (param_1 < 1) {
iVar4 = 0;
}
else {
iVar2 = 0;
iVar4 = param_1;
do {
iVar2 = iVar2 + 1;
bVar1 = 9 < iVar4;
iVar4 = iVar4 / 10;
} while (bVar1);
iVar4 = 0;
iVar3 = par... |
6,286 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == ... | int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 12c8 <func0+0xb8>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp ... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr rax... | _BOOL8 func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0x... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR ... | bool func0(uint param_1)
{
bool bVar1;
int iVar2;
uint uVar3;
uint uVar4;
double dVar5;
if ((int)param_1 < 1) {
uVar4 = 0;
}
else {
iVar2 = 0;
uVar4 = param_1;
do {
iVar2 = iVar2 + 1;
bVar1 = 9 < (int)uVar4;
uVar4 = uVar4 / 10;
} while (bVar1);
uVar4 = 0;
... |
6,287 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while (temp > 0) {
times++;
temp /= 10;
}
temp = number;
while (temp > 0) {
int reminder = temp % 10;
sum += pow(reminder, times);
temp /= 10;
}
if (number == ... | int main() {
assert(func0(153) == 1);
assert(func0(259) == 0);
assert(func0(4458) == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 12c8 <func0+0xb8>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp ... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr rax... | _BOOL8 func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0x... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR ... | bool func0(uint param_1)
{
bool bVar1;
ulong uVar2;
int iVar3;
int iVar4;
uint uVar5;
uint uVar6;
double dVar7;
if ((int)param_1 < 1) {
uVar6 = 0;
}
else {
iVar3 = 0;
uVar2 = (ulong)param_1;
do {
iVar3 = iVar3 + 1;
iVar4 = (int)uVar2;
uVar2 = uVar2 / 10;
} w... |
6,288 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 116e <func0+0x25>
mov -0xc(%rbp),%eax
add %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1164 <func0+0x1b>
cvtsi2sdl -0x10(%rbp),%xmm0
cvtsi2sdl ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_10], 0
mov [rbp+var_C], 1
jmp short loc_116E
loc_1164:
mov eax, [rbp+var_C]
add [rbp+var_10], eax
add [rbp+var_C], 1
loc_116E:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jle short loc_1164
pxor xmm0... | long long * func0(int a1)
{
int v2; // [rsp+4h] [rbp-10h]
int i; // [rsp+8h] [rbp-Ch]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += i;
*(double *)&result_1 = (double)v2;
*(double *)&qword_4028 = (double)v2 / (double)a1;
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x0010116e
LAB_00101164:
MOV EAX,dword ptr [RBP + -0xc]
ADD dword ptr [RBP + -0x10],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_0010116e:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RB... | int1 * func0(int param_1)
{
int local_18;
int local_14;
local_18 = 0;
for (local_14 = 1; local_14 <= param_1; local_14 = local_14 + 1) {
local_18 = local_18 + local_14;
}
result_1._0_8_ = (double)local_18;
result_1._8_8_ = (double)local_18 / (double)param_1;
return result_1;
} |
6,289 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1193 <func0+0x4a>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x0,%edx
add %eax,%edx
add $0x1,%eax
cmp %ecx,%eax
jne 115e <func0+0x15>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd %xmm0,0x2ea9(%rip)
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
movsd %... | func0:
endbr64
test edi, edi
jle short loc_1193
lea ecx, [rdi+1]
mov eax, 1
mov edx, 0
loc_115E:
add edx, eax
add eax, 1
cmp eax, ecx
jnz short loc_115E
loc_1167:
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
movsd cs:result_1, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
m... | long long * func0(int a1)
{
int v1; // eax
int v2; // edx
if ( a1 <= 0 )
{
v2 = 0;
}
else
{
v1 = 1;
v2 = 0;
do
v2 += v1++;
while ( v1 != a1 + 1 );
}
*(double *)&result_1 = (double)v2;
*(double *)&qword_4028 = (double)v2 / (double)a1;
return &result_1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101193
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
MOV EDX,0x0
LAB_0010115e:
ADD EDX,EAX
ADD EAX,0x1
CMP EAX,ECX
JNZ 0x0010115e
LAB_00101167:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
MOVSD qword ptr [0x00104020],XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MOVSD qword ptr [0x00104028],XMM0
LEA ... | int1 * func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1;
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
result_1._0_8_ = (double)iVar2;
result_1._8_8_ = (double)iVar2 / (double)par... |
6,290 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 11b0 <func0+0x50>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
add %eax,%edx
add $0x1,%eax
cmp %eax,%ecx
jne 1178 <func0+0x18>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
movsd %xmm0,0x2e8b(%rip)
lea 0x2e84(%rip),%ra... | func0:
endbr64
test edi, edi
jle short loc_11B0
lea ecx, [rdi+1]
mov eax, 1
xor edx, edx
nop word ptr [rax+rax+00h]
loc_1178:
add edx, eax
add eax, 1
cmp ecx, eax
jnz short loc_1178
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
loc_1189:
pxor xmm1, xmm1
movsd cs:result_1, xmm0
lea ... | long long * func0(int a1)
{
int v1; // eax
int v2; // edx
double v3; // xmm0_8
long long *result; // rax
if ( a1 <= 0 )
{
v3 = 0.0;
}
else
{
v1 = 1;
v2 = 0;
do
v2 += v1++;
while ( a1 + 1 != v1 );
v3 = (double)v2;
}
result_1 = *(_QWORD *)&v3;
result = &result_1;
*... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011b0
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101178:
ADD EDX,EAX
ADD EAX,0x1
CMP ECX,EAX
JNZ 0x00101178
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
LAB_00101189:
PXOR XMM1,XMM1
MOVSD qword ptr [0x00104020],XMM0
LEA RAX,[0x104020]
CVTSI2SD XMM1,EDI
DIVSD ... | int1 * func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
result_1._0_8_ = 0.0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1;
iVar1 = iVar1 + 1;
} while (param_1 + 1 != iVar1);
result_1._0_8_ = (int8)iVar2;
}
result_1._8_8_ = (double)result_1... |
6,291 | func0 |
#include <assert.h>
| double* func0(int number) {
static double result[2];
int total = 0;
for (int value = 1; value <= number; value++) {
total += value;
}
double average = (double)total / number;
result[0] = total;
result[1] = average;
return result;
}
| int main() {
double* result;
result = func0(10);
assert(result[0] == 55 && result[1] == 5.5);
result = func0(15);
assert(result[0] == 120 && result[1] == 8.0);
result = func0(20);
assert(result[0] == 210 && result[1] == 10.5);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1200 <func0+0xb0>
lea -0x1(%rdi),%eax
cmp $0x11,%eax
jbe 1206 <func0+0xb6>
mov %edi,%edx
movdqa 0xe9e(%rip),%xmm1
xor %eax,%eax
pxor %xmm0,%xmm0
movdqa 0xea0(%rip),%xmm3
shr $0x2,%edx
nopl 0x0(%rax,%rax,1)
movdqa %xmm1,%xmm2
add $0x1,%eax
paddd %xmm3,%xmm... | func0:
endbr64
mov edx, edi
test edi, edi
jle loc_1250
lea eax, [rdi-1]
cmp eax, 9
jbe loc_1256
mov ecx, edi
movdqa xmm1, cs:xmmword_2010
xor eax, eax
pxor xmm0, xmm0
movdqa xmm3, cs:xmmword_2020
shr ecx, 2
nop dword ptr [rax]
loc_1188:
movdqa xmm2, xmm1
add eax, 1
paddd... | __int128 * func0(int a1)
{
__m128i si128; // xmm1
int v2; // eax
__m128i v3; // xmm0
__m128i v4; // xmm3
__m128i v5; // xmm2
__m128i v6; // xmm0
unsigned int v7; // ecx
int v8; // eax
int v9; // ecx
__m128d v10; // xmm0
__m128d v11; // xmm1
__int128 *result; // rax
if ( a1 <= 0 )
{
v10 ... | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x00101250
LEA EAX,[RDI + -0x1]
CMP EAX,0x9
JBE 0x00101256
MOV ECX,EDI
MOVDQA XMM1,xmmword ptr [0x00102010]
XOR EAX,EAX
PXOR XMM0,XMM0
MOVDQA XMM3,xmmword ptr [0x00102020]
SHR ECX,0x2
NOP dword ptr [RAX]
LAB_00101188:
MOVDQA XMM2,XMM1
ADD EAX,0x1
PADDD XMM1,XMM3
PADDD XMM0,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * func0(uint param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
if ((int)param_1 < 1) {
result_1._0_8_ = 0.0;
goto LAB_00101223;
}
if... |
6,292 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
xor $0x1,%eax
mov %eax,%edx
mov -0x4(%rbp),%eax
add $0x1,%eax
cmp %eax,%edx
jne 116d <func0+0x24>
mov $0x1,%eax
jmp 1172 <func0+0x29>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
xor eax, 1
mov edx, eax
mov eax, [rbp+var_4]
add eax, 1
cmp edx, eax
jnz short loc_116D
mov eax, 1
jmp short loc_1172
loc_116D:
mov eax, 0
loc_1172:
pop rbp
retn | _BOOL8 func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP EDX,EAX
JNZ 0x0010116d
MOV EAX,0x1
JMP 0x00101172
LAB_0010116d:
MOV EAX,0x0
LAB_00101172:
POP RBP
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,293 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
xor $0x1,%eax
add $0x1,%edi
cmp %edi,%eax
sete %al
retq
| func0:
endbr64
mov eax, edi
xor eax, 1
add edi, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
XOR EAX,0x1
ADD EDI,0x1
CMP EAX,EDI
SETZ AL
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,294 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,295 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | bool func0(uint param_1)
{
return (param_1 ^ 1) == param_1 + 1;
} |
6,296 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
... | int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1d0,%rsp
mov %rdi,-0x1c8(%rbp)
mov %esi,-0x1cc(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x1b4(%rbp)
movl $0x0,-0x1b0(%rbp)
jmp 11c4 <func0+0x5b>
mov -0x1b0(%rbp),%eax
cltq
movl $0x1,-0x1a0(%rbp,%rax,4)
addl $0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1D0h
mov [rbp+var_1C8], rdi
mov [rbp+var_1CC], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_1B4], 0
mov [rbp+var_1B0], 0
jmp short loc_11C4
loc_11AA:
mov eax, [rbp+var_1B0]
cdqe
mov [rbp+rax*4+var_1A0]... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+1Ch] [rbp-1B4h]
int i; // [rsp+20h] [rbp-1B0h]
int j; // [rsp+24h] [rbp-1ACh]
int k; // [rsp+28h] [rbp-1A8h]
int m; // [rsp+2Ch] [rbp-1A4h]
_DWORD v8[102]; // [rsp+30h] [rbp-1A0h]
unsigned long long v9; // [rsp+1C8h] [rbp-8h]
v9 = __read... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1d0
MOV qword ptr [RBP + -0x1c8],RDI
MOV dword ptr [RBP + -0x1cc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x1b4],0x0
MOV dword ptr [RBP + -0x1b0],0x0
JMP 0x001011c4
LAB_001011aa:
MOV EAX,dword ptr [RBP + -0x1b0]
CDQE
... | int func0(long param_1,int param_2)
{
long in_FS_OFFSET;
int local_1bc;
int local_1b8;
int local_1b4;
int local_1b0;
int local_1ac;
int aiStack_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1bc = 0;
for (local_1b8 = 0; local_1b8 < param_2; local_1b8 = local_1b8 + 1... |
6,297 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
... | int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
... | O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %esi,%esi
jle 11a5 <func0+0x3c>
mov %rsp,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rsp,%rdx,4),%rdx
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1196 <func0+0x2d>
cmp $0x1,%esi
jle 11fa <func0... | func0:
endbr64
sub rsp, 1A8h
mov r9d, esi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
test esi, esi
jle short loc_11A8
mov rax, rsp
lea edx, [rsi-1]
lea rdx, [rsp+rdx*4+1A8h+var_1A4]
loc_1199:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc... | long long func0(long long a1, int a2)
{
int *v3; // rax
_DWORD *v4; // r8
long long i; // rcx
long long v6; // rax
int v7; // edx
int v8; // esi
int v9; // edx
long long v10; // rax
int v12; // [rsp+0h] [rbp-1A8h] BYREF
_DWORD v13[101]; // [rsp+4h] [rbp-1A4h] BYREF
unsigned long long v14; // [rsp... | func0:
ENDBR64
SUB RSP,0x1a8
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001011a8
MOV RAX,RSP
LEA EDX,[RSI + -0x1]
LEA RDX,[RSP + RDX*0x4 + 0x4]
LAB_00101199:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101199
LAB_001011a8:
CMP R9D,0x1
JLE 0x001011f... | int func0(long param_1,uint param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar2 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < (int)param_2) {
do {
*piVar2 = 1;
piVar2 = piVar2 +... |
6,298 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
... | int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
... | O2 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13e9 <func0+0xd9>
mov %rsp,%r10
lea -0x1(%rsi),%edx
lea 0x4(%rsp),%r9
mov %r10,%rax
lea (%r9,%rdx,4),%rdx
nopl 0x0(%rax,%rax,1)
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jn... | func0:
endbr64
sub rsp, 1A8h
mov r10d, esi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
test esi, esi
jle loc_13E2
mov r9, rsp
lea edx, [rsi-1]
lea r8, [rsp+1A8h+var_1A4]
mov rax, r9
lea rdx, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_1350:
mov dword ptr... | long long func0(long long a1, int a2)
{
_DWORD *v3; // r8
int *v4; // rax
long long i; // rcx
int v6; // esi
long long v7; // rax
int v8; // edx
long long v9; // rax
int v10; // r8d
int v12; // [rsp+0h] [rbp-1A8h] BYREF
_DWORD v13[101]; // [rsp+4h] [rbp-1A4h] BYREF
unsigned long long v14; // [rsp... | func0:
ENDBR64
SUB RSP,0x1a8
MOV R10D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001013e2
MOV R9,RSP
LEA EDX,[RSI + -0x1]
LEA R8,[RSP + 0x4]
MOV RAX,R9
LEA RDX,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101350:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
J... | int func0(long param_1,int param_2)
{
int iVar1;
int *piVar2;
long lVar3;
long lVar4;
int *piVar5;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar2 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < param_2) {
piVar5 = local_1a8 + 1;
do {
*piVar2 = 1;
... |
6,299 | func0 |
#include <assert.h>
typedef struct {
int a;
int b;
} Pair;
| int func0(Pair arr[], int n) {
int max = 0;
int mcl[100]; // assuming maximum 100 pairs
for (int i = 0; i < n; i++) {
mcl[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
... | int main() {
Pair arr1[] = {{5, 24}, {15, 25}, {27, 40}, {50, 60}};
assert(func0(arr1, 4) == 3);
Pair arr2[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
assert(func0(arr2, 4) == 4);
Pair arr3[] = {{19, 10}, {11, 12}, {13, 14}, {15, 16}, {31, 54}};
assert(func0(arr3, 5) == 5);
return 0;
... | O3 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %esi,%esi
jle 1471 <func0+0x1d1>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 147a <func0+0x1da>
mov %esi,%edx
mov %rsp,%rax
movdqa 0xdb1(%rip),%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rax,%rdx
nopl ... | func0:
endbr64
sub rsp, 1A8h
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
test esi, esi
jle loc_1465
lea r11d, [rsi-1]
mov r9d, esi
cmp r11d, 2
jbe loc_147A
mov edx, esi
mov rax, rsp
movdqa xmm0, cs:xmmword_2070
shr edx, 2
shl rdx, 4
lea rcx, [rdx+r... | long long func0(long long a1, int a2)
{
int v2; // eax
unsigned int v3; // r11d
__m128i *v5; // rax
__m128i si128; // xmm0
long long v7; // rdx
__m128i *v8; // rcx
int v9; // edx
int v10; // eax
__int32 *v11; // r8
long long v12; // rcx
int v13; // esi
long long v14; // rax
__int32 v15; // ed... | func0:
ENDBR64
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101465
LEA R11D,[RSI + -0x1]
MOV R9D,ESI
CMP R11D,0x2
JBE 0x0010147a
MOV EDX,ESI
MOV RAX,RSP
MOVDQA XMM0,xmmword ptr [0x00102070]
SHR EDX,0x2
SHL RDX,0x4
LEA RCX,[RDX + RAX*0x1]
AND EDX,0x10
JZ 0x00... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(long param_1,ulong param_2)
{
int iVar1;
ulong uVar2;
uint uVar3;
int8 *puVar4;
ulong uVar5;
uint *puVar6;
uint *puVar7;
ulong uVar8;
int iVar9;
uint uVar10;
uint uVar11;
int *piVar12;
long in_FS_... |
6,300 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11e9 <func0+0x80>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_10], 0
jmp short loc_11E9
loc_1191:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ... | long long func0(const char *a1)
{
unsigned __int8 v2; // [rsp+1Fh] [rbp-11h]
int i; // [rsp+20h] [rbp-10h]
int v4; // [rsp+24h] [rbp-Ch]
int j; // [rsp+28h] [rbp-8h]
int v6; // [rsp+2Ch] [rbp-4h]
v6 = strlen(a1);
for ( i = 0; i < v6; ++i )
{
v2 = a1[i];
v4 = 0;
for ( j = 0; j <= i; ++j )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011e9
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,... | char func0(char *param_1)
{
size_t sVar1;
int local_18;
int local_14;
int local_10;
sVar1 = strlen(param_1);
local_18 = 0;
while( true ) {
if ((int)sVar1 <= local_18) {
return '0';
}
local_14 = 0;
for (local_10 = 0; local_10 <= local_18; local_10 = local_10 + 1) {
if (param... |
6,301 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
mov %ecx,%r10d
test %ecx,%ecx
jle 11ba <func0+0x71>
mov %rdx,%r9
lea 0x1(%rdx),%rdi
mov $0x0,%r8d
movzbl -0x1(%rdi),%esi
test %r8d,%r8d
js 11a6 <func0+0x5d>
mov ... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_11C9
mov r9d, eax
lea rsi, [rbx+1]
mov r8d, 0
loc_1187:
movzx edi, byte ptr [rsi-1]
test r8d, r8d
js short loc_11B5
mov rax, rbx
mov edx, 0
loc_1198:
cmp [rax], dil
setz cl
movzx ecx, cl... | long long func0(_BYTE *a1)
{
int v2; // eax
int v3; // r9d
_BYTE *v4; // rsi
int v5; // r8d
unsigned int v6; // edi
_BYTE *v7; // rax
int v8; // edx
v2 = strlen();
if ( v2 <= 0 )
{
return 48;
}
else
{
v3 = v2;
v4 = a1 + 1;
v5 = 0;
while ( 1 )
{
v6 = (unsigned __... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011c9
MOV R9D,EAX
LEA RSI,[RBX + 0x1]
MOV R8D,0x0
LAB_00101187:
MOVZX EDI,byte ptr [RSI + -0x1]
TEST R8D,R8D
JS 0x001011b5
MOV RAX,RBX
MOV EDX,0x0
LAB_00101198:
CMP byte ptr [RAX],DIL
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0... | char func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
int iVar5;
sVar1 = strlen(param_1);
if (0 < (int)sVar1) {
pcVar4 = param_1 + 1;
iVar5 = 0;
do {
if (-1 < iVar5) {
iVar3 = 0;
pcVar2 = param_1;
do {
iVar3 = iVar3 + (uint... |
6,302 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
test %eax,%eax
jle 1261 <func0+0x51>
sub $0x1,%eax
lea 0x1(%rbx),%rsi
lea 0x2(%rbx,%rax,1),%rdi
nopl (%rax)
movzbl -0x1(%rsi),%r8d
mov %rbx,%rax
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
cmp %r8b,(%rax)
sete %cl... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_1261
sub eax, 1
lea rsi, [rbx+1]
lea rdi, [rbx+rax+2]
nop dword ptr [rax]
loc_1230:
movzx r8d, byte ptr [rsi-1]
mov rax, rbx
xor edx, edx
nop word ptr [rax+rax+00h]
loc_1240:
xor ecx, ecx
cmp... | long long func0(_BYTE *a1)
{
int v2; // eax
_BYTE *v3; // rsi
long long v4; // rdi
unsigned int v5; // r8d
_BYTE *v6; // rax
int v7; // edx
int v8; // ecx
v2 = strlen();
if ( v2 <= 0 )
{
return 48;
}
else
{
v3 = a1 + 1;
v4 = (long long)&a1[v2 - 1 + 2];
while ( 1 )
{
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101261
SUB EAX,0x1
LEA RSI,[RBX + 0x1]
LEA RDI,[RBX + RAX*0x1 + 0x2]
NOP dword ptr [RAX]
LAB_00101230:
MOVZX R8D,byte ptr [RSI + -0x1]
MOV RAX,RBX
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101240:
XOR ECX,ECX
CMP byte ptr [RAX],R8B
SETZ CL
AD... | char func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
pcVar5 = param_1 + 1;
do {
iVar4 = 0;
pcVar1 = param_1;
do {
pcVar3 = pcVar1;
iVar4 = iVar4 + (uint)(*pcVar3 == pcVar5... |
6,303 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char func0(char* str1) {
int length = strlen(str1);
for (int i = 0; i < length; i++) {
char c = str1[i];
int count = 0;
for (int j = 0; j <= i; j++) {
if (str1[j] == c) {
count++;
}
}
if (count > 1) {
return c... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == '0');
assert(func0("123123") == '1');
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
test %eax,%eax
jle 14ad <func0+0x29d>
mov %eax,%r9d
mov $0x1,%esi
pxor %xmm4,%xmm4
xor %ecx,%ecx
movdqa 0xe65(%rip),%xmm5
pxor %xmm3,%xmm3
movzbl -0x1(%rbx,%rsi,1),%r8d
mov %esi,%edi
cmp $0xe,%ecx
jle 14c0 <func0+0x2b0>
movd... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle loc_1474
mov edi, eax
mov esi, 1
pxor xmm6, xmm6
xor edx, edx
pxor xmm5, xmm5
pxor xmm4, xmm4
pxor xmm3, xmm3
xchg ax, ax
loc_1240:
movzx ecx, byte ptr [rbx+rsi-1]
mov r9d, esi
cmp edx, 0Eh
jle ... | long long func0(const char *a1)
{
int v2; // eax
int v3; // edi
long long v4; // rsi
int v5; // edx
unsigned int v6; // ecx
__m128i v7; // xmm8
__m128i v8; // xmm1
const __m128i *v9; // rax
__m128i v10; // xmm8
__m128i v11; // xmm8
__m128i v12; // xmm0
__m128i v13; // xmm0
__m128i v14; // xmm... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101474
MOV EDI,EAX
MOV ESI,0x1
PXOR XMM6,XMM6
XOR EDX,EDX
PXOR XMM5,XMM5
PXOR XMM4,XMM4
PXOR XMM3,XMM3
NOP
LAB_00101240:
MOVZX ECX,byte ptr [RBX + RSI*0x1 + -0x1]
MOV R9D,ESI
CMP EDX,0xe
JLE 0x00101480
MOVD XMM8,ECX
MOV R8D,ESI
PXOR XMM1,XMM1
MOV ... | char func0(char *param_1)
{
uint uVar1;
char cVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar1... |
6,304 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index ... | int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] =... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x20(%rbp)
jmp 11fa <func0+0x51>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_30], rsi
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_20], 0
jmp short loc_11FA
loc_11DA:
mov eax, [rbp+var_20]
cdqe
lea r... | _DWORD * func0(int a1, int *a2)
{
int i; // [rsp+10h] [rbp-20h]
int v4; // [rsp+14h] [rbp-1Ch]
int j; // [rsp+18h] [rbp-18h]
int k; // [rsp+1Ch] [rbp-14h]
int m; // [rsp+20h] [rbp-10h]
int v8; // [rsp+24h] [rbp-Ch]
_DWORD *v9; // [rsp+28h] [rbp-8h]
v9 = malloc(4LL * a1);
for ( i = 0; i < a1; ++i )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x30],RSI
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001011fa
LAB_001011da:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
L... | void * func0(int param_1,int *param_2)
{
int iVar1;
void *pvVar2;
int4 local_28;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
pvVar2 = malloc((long)param_1 << 2);
for (local_28 = 0; local_28 < param_1; local_28 = local_28 + 1) {
*(int *)((long)pvVar2 + (long)local_28 * 4) = loca... |
6,305 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index ... | int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] =... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov %rsi,%r14
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r11
test %ebx,%ebx
jle 11e7 <func0+0x3e>
lea -0x1(%rbx),%edx
add $0x2,%rdx
mov $0x1,%eax
mov %eax,-0x4(%r11,%rax,4)
add ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov ebx, edi
mov r14, rsi
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r11, rax
test ebx, ebx
jle short loc_11E3
lea edx, [rbx+1]
mov eax, 1
loc_11D5:
mov [r11+rax*4-4], eax
add rax, 1
cmp rax, rdx
j... | long long func0(int a1, int *a2)
{
int v2; // ebx
long long v4; // r11
long long v5; // rax
long long v6; // r13
_DWORD *v7; // rax
int v8; // esi
unsigned int v9; // r8d
long long v10; // rdi
int v11; // r9d
v2 = a1;
v4 = malloc(4LL * a1);
if ( a1 > 0 )
{
v5 = 1LL;
do
{
*(... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV R14,RSI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R11,RAX
TEST EBX,EBX
JLE 0x001011e3
LEA EDX,[RBX + 0x1]
MOV EAX,0x1
LAB_001011d5:
MOV dword ptr [R11 + RAX*0x4 + -0x4],EAX
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001011d5
LAB_001011e3:
CMP EBX,0x1
J... | void * func0(int param_1,int *param_2)
{
int iVar1;
void *pvVar2;
ulong uVar3;
int4 *puVar4;
int iVar5;
long lVar6;
uint uVar7;
long lVar8;
pvVar2 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
do {
*(int *)((long)pvVar2 + uVar3 * 4 + -4) = (int)uVar3;
uVar3 = uV... |
6,306 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index ... | int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] =... | O2 | c | func0:
endbr64
push %r14
movslq %edi,%rdi
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r11
test %ebx,%ebx
jle 1445 <func0+0xb5>
lea -0x1(%rbx),%edx
mov $0x1,%eax
add $0x2,%rdx
nopl (%rax)
mov %eax,-0x4(%r11,... | func0:
endbr64
push r15
movsxd rdi, edi
push r14
mov r14, rdi
shl rdi, 2
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
lea edx, [r14+1]
mov [rsp+48h+var_48], rax
mov eax, 1
test r14d, r14d
jle loc_147C
nop dword ptr [... | long long func0(int a1, int *a2)
{
int v2; // r14d
long long v3; // rax
long long v4; // r12
int v5; // r9d
int v6; // r15d
int v7; // r13d
unsigned int v8; // ebx
long long v9; // rcx
long long v11; // [rsp+0h] [rbp-48h]
v2 = a1;
v11 = malloc(4LL * a1);
v3 = 1LL;
if ( a1 > 0 )
{
do
... | func0:
ENDBR64
PUSH R15
MOVSXD RDI,EDI
PUSH R14
MOV R14,RDI
SHL RDI,0x2
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x001010c0
LEA EDX,[R14 + 0x1]
MOV qword ptr [RSP],RAX
MOV EAX,0x1
TEST R14D,R14D
JLE 0x0010147c
NOP dword ptr [RAX]
LAB_001013f0:
MOV RDI,qword ptr [RSP]
MOV dword... | void * func0(int param_1,int *param_2)
{
void *pvVar1;
ulong uVar2;
void *__dest;
uint uVar3;
ulong uVar4;
long lVar5;
int iVar6;
uint uVar7;
int iVar8;
uVar4 = (ulong)param_1;
pvVar1 = malloc(uVar4 << 2);
uVar2 = 1;
if (0 < param_1) {
do {
*(int *)((long)pvVar1 + uVar2 * 4 + -4)... |
6,307 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(int n, int* ludic_size){
int* ludics = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
ludics[i] = i + 1;
}
int current_size = n;
int index = 1;
while(index < current_size){
int first_ludic = ludics[index];
int remove_index = index ... | int main() {
int size;
int* result;
result = func0(10, &size);
assert(size == 5 && result[0] == 1 && result[1] == 2 && result[2] == 3 && result[3] == 5 && result[4] == 7);
free(result);
result = func0(25, &size);
assert(size == 10 && result[0] == 1 && result[1] == 2 && result[2] =... | O3 | c | func0:
endbr64
push %r15
movslq %edi,%rdi
push %r14
mov %rdi,%r15
shl $0x2,%rdi
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rsi,0x18(%rsp)
callq 10c0 <malloc@plt>
mov %rax,0x10(%rsp)
test %r15d,%r15d
jle 14f6 <func0+0x146>
mov %rax,%rcx
lea -0x1(%r15),%eax
cmp $... | func0:
endbr64
push r15
movsxd rdi, edi
push r14
mov r15, rdi
shl rdi, 2; size
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
mov [rsp+48h+var_48], rax
test r15d, r15d
jle loc_14EC
lea eax, [r15-1]
cmp eax, 2
jbe loc_1... | __m128i * func0(int a1, int *a2)
{
int v2; // r15d
__m128i si128; // xmm1
__m128i v4; // xmm3
__m128i v5; // xmm2
__m128i *v6; // rax
__m128i v7; // xmm0
unsigned int v8; // eax
long long v9; // rdx
long long v10; // r12
int v11; // r9d
int v12; // r14d
int v13; // r13d
unsigned int v14; // eb... | func0:
ENDBR64
PUSH R15
MOVSXD RDI,EDI
PUSH R14
MOV R15,RDI
SHL RDI,0x2
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x001010c0
MOV qword ptr [RSP],RAX
TEST R15D,R15D
JLE 0x001014ec
LEA EAX,[R15 + -0x1]
CMP EAX,0x2
JBE 0x00101507
MOV EDX,R15D
MOV RDI,qword ptr [RSP]
MOVDQA XMM1,xm... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int * func0(uint param_1,uint *param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
uint uVar7;
int *piVar8;
int *piVar9;
int *piVar10;
ulong uVar11;
long lVar12;
int iVar13;
int iV... |
6,308 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0... | int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "m... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x70(%rbp)
mov -0x78(%rbp),%rax
lea 0xe0e(%rip),%rsi
mov %rax,%rdi
callq 10c0 <strtok@plt>
mov %rax,-0x68(%rbp)
jmp 1231 <func0+0x... | func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_70], 0
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+var_68], rax
jmp ... | char * func0(char *a1)
{
int v1; // eax
int v3; // [rsp+10h] [rbp-70h]
long long j; // [rsp+14h] [rbp-6Ch]
char *i; // [rsp+18h] [rbp-68h]
char *src[12]; // [rsp+20h] [rbp-60h]
src[11] = (char *)__readfsqword(0x28u);
v3 = 0;
for ( i = strtok(a1, " "); i; i = strtok(0LL, " ") )
{
v1 = v3++;
sr... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x78],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x70],0x0
MOV RAX,qword ptr [RBP + -0x78]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x68],RAX
JMP 0x001012... | int1 * func0(char *param_1)
{
size_t sVar1;
long in_FS_OFFSET;
int local_78;
int local_74;
char *local_70;
int8 auStack_68 [11];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_78 = 0;
local_70 = strtok(param_1," ");
while (local_70 != (char *)0x0) {
auStack_68[local_78] = ... |
6,309 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0... | int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "m... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xe38(%rip),%rsi
callq 10b0 <strtok@plt>
test %rax,%rax
je 1279 <func0+0xd0>
mov $0x0,%ebx
lea 0xe1e(%rip),%r12
mov %ebx,%ebp
mov %rax,(%rsp,%rbx,8)
mov %r12,%rs... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea rsi, unk_2004
call _strtok
test rax, rax
jz loc_127E
mov ebp, 0
lea r12, unk_2004
loc_1208:
mov ebx, ebp
mov [rsp+rbp*8+88h+var_88], rax
m... | char * func0(long long a1)
{
long long v1; // rax
long long v2; // rbp
int v3; // ebx
_QWORD *v4; // rbp
int i; // ebx
_QWORD v7[17]; // [rsp+0h] [rbp-88h] BYREF
v7[11] = __readfsqword(0x28u);
v1 = strtok(a1, &unk_2004);
if ( v1 )
{
v2 = 0LL;
do
{
v3 = v2;
v7[v2] = v1;
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RSI,[0x102004]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x0010127e
MOV EBP,0x0
LEA R12,[0x102004]
LAB_00101208:
MOV EBX,EBP
MOV qword ptr [RSP + RBP*0x8],RAX
MOV RSI,R12
MOV EDI,0x0
CALL 0x0... | int1 * func0(char *param_1)
{
long lVar1;
char *pcVar2;
int iVar3;
long lVar4;
int8 *puVar5;
long in_FS_OFFSET;
int8 local_88 [11];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strtok(param_1," ");
if (pcVar2 == (char *)0x0) {
result_1[0] = 0;
}
else {
lVar1 =... |
6,310 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0... | int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "m... | O2 | c | func0:
endbr64
push %r15
lea 0xcc7(%rip),%rsi
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
callq 10d0 <strtok@plt>
test %rax,%rax
je 1458 <func0+0x128>
xor %r13d,%r13d
mov %rsp,%rbp
lea 0xc90(%rip),%r12
no... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
lea rbx, unk_2004
mov rsi, rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
call _strtok
test rax, rax
jz loc_1450
xor r14d, r14d
mov r13, rsp
loc_13A0:
mov [r13+r... | char * func0(long long a1)
{
long long v1; // rax
long long v2; // r14
long long v3; // rbp
long long v4; // r12
long long v5; // rdx
long long *v6; // r12
long long *v7; // r14
long long v8; // rax
long long v9; // rax
_QWORD v11[19]; // [rsp+0h] [rbp-98h] BYREF
v11[11] = __readfsqword(0x28u);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x102004]
MOV RSI,RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101450
XOR R14D,R14D
MOV R13,RSP
LAB_001013a0:
MOV qword ptr [R13 + R14*0x8],RAX
MOV RSI,RBX
XOR EDI... | int1 * func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
int8 *puVar5;
long lVar6;
int8 *puVar7;
long in_FS_OFFSET;
int8 local_98 [11];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = strtok(param_1," ");
if (pcVar1 == (char *)0x0) {
result... |
6,311 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* s) {
static char result[100];
int word_count = 0;
char* words[10];
char* token = strtok(s, " ");
while (token != NULL) {
words[word_count++] = token;
token = strtok(NULL, " ");
}
result[0] = '\0';
for (int i = word_count - 1; i >= 0... | int main() {
char test_string1[] = "python program";
char test_string2[] = "java language";
char test_string3[] = "indian man";
assert(strcmp(func0(test_string1), "program python") == 0);
assert(strcmp(func0(test_string2), "language java") == 0);
assert(strcmp(func0(test_string3), "m... | O3 | c | func0:
endbr64
push %r15
lea 0xcc7(%rip),%rsi
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
callq 10d0 <strtok@plt>
test %rax,%rax
je 1458 <func0+0x128>
xor %ebp,%ebp
mov %rsp,%rbx
lea 0xc91(%rip),%r13
nopl... | func0:
endbr64
push r14
push r13
push r12
push rbp
lea rbp, delim; " "
push rbx
mov rsi, rbp; delim
sub rsp, 60h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
call _strtok
test rax, rax
jz loc_1430
xor ebx, ebx
mov r12, rsp
nop dword ptr [rax]
loc_1... | char * func0(char *a1)
{
char *v1; // rax
long long v2; // rbx
long long v3; // rdx
_QWORD *v4; // rbx
_QWORD *v5; // r13
size_t v6; // rax
long long v7; // rax
_QWORD v9[17]; // [rsp+0h] [rbp-88h] BYREF
v9[11] = __readfsqword(0x28u);
v1 = strtok(a1, " ");
if ( v1 )
{
v2 = 0LL;
do
{... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
LEA RBP,[0x102004]
PUSH RBX
MOV RSI,RBP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101430
XOR EBX,EBX
MOV R12,RSP
NOP dword ptr [RAX]
LAB_00101390:
MOV RSI,RBP
XOR EDI,EDI
MOV qword ptr [R12 +... | int1 * func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
long lVar3;
long lVar4;
int8 *puVar5;
int8 *puVar6;
long in_FS_OFFSET;
int8 local_88 [11];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = strtok(param_1," ");
if (pcVar1 == (char *)0x0) {
result_1[0] = 0;
}
... |
6,312 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jle 1193 <func0+0x4a>
movl $0x2,-0x4(%rbp)
jmp 117b <func0+0x32>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1177 <func0+0x2e>
mov $0x0,%eax
jmp 1198 <func0+0x4f>
addl ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jle short loc_1193
mov [rbp+var_4], 2
jmp short loc_117B
loc_1163:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1177
mov eax, 0
jmp short loc_1198
lo... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
if ( a1 <= 0 )
return 0LL;
for ( i = 2; i <= a1 / 2; ++i )
{
if ( !(a1 % i) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JLE 0x00101193
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010117b
LAB_00101163:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101177
MOV EAX,0x0
JMP 0x00101198
LAB_00101177:
... | int8 func0(int param_1)
{
int8 uVar1;
int local_c;
if (param_1 < 1) {
uVar1 = 0;
}
else {
for (local_c = 2; local_c <= param_1 / 2; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
return 0;
}
}
uVar1 = 1;
}
return uVar1;
} |
6,313 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
test %edi,%edi
jle 1184 <func0+0x3b>
mov %edi,%esi
shr $0x1f,%esi
add %edi,%esi
sar %esi
cmp $0x3,%edi
jle 118b <func0+0x42>
test $0x1,%dil
je 1191 <func0+0x48>
mov $0x2,%ecx
add $0x1,%ecx
cmp %esi,%ecx
jg 1185 <func0+0x3c>
mov %edi,%eax
cltd
... | func0:
endbr64
mov eax, 0
test edi, edi
jle short locret_1184
mov esi, edi
shr esi, 1Fh
add esi, edi
sar esi, 1
cmp edi, 3
jle short loc_118B
test dil, 1
jz short loc_1191
mov ecx, 2
loc_116F:
add ecx, 1
cmp ecx, esi
jg short loc_1185
mov eax, edi
cdq
idiv... | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 <= 3 )
{
return 1LL;
}
else if ( (a1 & 1) != 0 )
{
v2 = 2;
while ( ++v2 <= a1 / 2 )
{
if ( !(a1 % v2) )
return 0LL;
}
return 1LL;
... | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JLE 0x00101184
MOV ESI,EDI
SHR ESI,0x1f
ADD ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x0010118b
TEST DIL,0x1
JZ 0x00101191
MOV ECX,0x2
LAB_0010116f:
ADD ECX,0x1
CMP ECX,ESI
JG 0x00101185
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010116f
MOV EAX,0x0
LAB_00101184:
RET
LAB_00101185:
M... | int8 func0(uint param_1)
{
int iVar1;
if (0 < (int)param_1) {
if ((int)param_1 < 4) {
return 1;
}
if ((param_1 & 1) == 0) {
return 0;
}
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if ((int)param_1 / 2 < iVar1) {
return 1;
}
} while ((int)param_1 % iVar1 !... |
6,314 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
jle 1182 <func0+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 1178 <func0+0x38>
test $0x1,%dil
je 1182 <func0+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 1171 <func0+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx... | func0:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_118... | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET... | int8 func0(uint param_1)
{
int iVar1;
if (0 < (int)param_1) {
if ((int)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == ((int)param_1 >> 1) + 1) {
return 1;
}
} while ((int)param_1 % iVar1 !... |
6,315 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
jle 1182 <func0+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 1178 <func0+0x38>
test $0x1,%dil
je 1182 <func0+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 1171 <func0+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx... | func0:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_118... | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET... | int8 func0(uint param_1)
{
int iVar1;
if (0 < (int)param_1) {
if ((int)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == ((int)param_1 >> 1) + 1) {
return 1;
}
} while ((int)param_1 % iVar1 !... |
6,316 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf4d(%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_2090
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 0.0174532925199433 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102090]
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_00102090 * param_1;
} |
6,317 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
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 * 0.0174532925199433;
} | 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;
} |
6,318 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
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 * 0.0174532925199433;
} | 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;
} |
6,319 | func0 | #include <math.h>
#include <assert.h>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
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 * 0.0174532925199433;
} | 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;
} |
6,320 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern ... | int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 1... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movq $0x0,-0x10(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0xffffffff,-0x4(%rbp)
mov -0x30(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1110 <strstr@plt>
mov %rax,-0x20(%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+haystack], rdi
mov [rbp+needle], rsi
mov [rbp+dest], 0
mov dword ptr [rbp+var_8], 0FFFFFFFFh
mov dword ptr [rbp+var_8+4], 0FFFFFFFFh
mov rdx, [rbp+needle]
mov rax, [rbp+haystack]
mov rsi, rdx; needle
mov rdi, rax; ... | char * func0(const char *a1, const char *a2)
{
size_t v2; // rax
char *dest; // [rsp+20h] [rbp-10h]
dest = 0LL;
if ( strstr(a1, a2) )
{
strlen(a2);
v2 = strlen(a2);
dest = (char *)malloc(v2 + 1);
strcpy(dest, a2);
}
return dest;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
MOV RDX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010... | int [16] func0(char *param_1,char *param_2)
{
int auVar1 [16];
char *pcVar2;
size_t sVar3;
size_t sVar4;
int8 local_18;
int4 local_10;
int4 uStack_c;
local_18 = (char *)0x0;
local_10 = -1;
uStack_c = -1;
pcVar2 = strstr(param_1,param_2);
if (pcVar2 != (char *)0x0) {
sVar3 = strlen(param... |
6,321 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern ... | int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 1... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r13
mov %rsi,%r14
callq 10d0 <strstr@plt>
mov %rax,%rbx
test %rax,%rax
je 123a <func0+0x71>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %r14,%rdi
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
lea ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r14, rsi
call _strstr
mov rbp, rax
test rax, rax
jz short loc_126F
mov rdi, r14
call _strlen
mov rbx, rax
lea rdi, [rax+1]
call _malloc
mov r13, rax
mov rsi, r14
mov rdi, rax
... | long long func0(long long a1, long long a2)
{
long long v2; // rbp
long long v3; // rbx
long long v4; // r13
v2 = strstr();
if ( v2 )
{
v3 = strlen(a2);
v4 = malloc(v3 + 1);
strcpy(v4, a2);
return v4;
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R14,RSI
CALL 0x00101110
MOV RBP,RAX
TEST RAX,RAX
JZ 0x0010126f
MOV RDI,R14
CALL 0x001010d0
MOV RBX,RAX
LEA RDI,[RAX + 0x1]
CALL 0x00101100
MOV R13,RAX
MOV RSI,R14
MOV RDI,RAX
CALL 0x001010c0
MOV EDX,EBP
SUB EDX,R12D
LEA RAX,[RBP + RBX*0x1]
SUB ... | int1 [16] func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
char *__dest;
ulong uVar3;
uint uVar4;
int1 auVar5 [16];
pcVar1 = strstr(param_1,param_2);
if (pcVar1 == (char *)0x0) {
uVar3 = 0xffffffff;
uVar4 = 0xffffffff;
__dest = (char *)0x0;
}
else {
sVar2 = strle... |
6,322 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern ... | int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 1... | O2 | c | func0:
endbr64
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
callq 10f0 <strstr@plt>
mov %rax,%r12
test %rax,%rax
je 13c0 <func0+0x70>
mov %r13,%rdi
callq 10b0 <strlen@plt>
lea 0x1(%rax),%r14
mov %rax,%rbx
mov %r14,%rdi
callq 10e0 <malloc@plt>
mov ... | func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
push rbp
mov rbp, rdi
push rbx
call _strstr
mov r12, rax
test rax, rax
jz short loc_13E0
mov rdi, r13
call _strlen
lea r14, [rax+1]
mov rbx, rax
mov rdi, r14
call _malloc
mov rdx, r14
mov rsi, r13
... | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // r14
long long v4; // rax
v2 = strstr();
if ( v2 )
{
v3 = strlen(a2) + 1;
v4 = malloc(v3);
return memcpy(v4, a2, v3);
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101110
MOV R12,RAX
TEST RAX,RAX
JZ 0x001013e0
MOV RDI,R13
CALL 0x001010c0
LEA R14,[RAX + 0x1]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00101100
MOV RDX,R14
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010f0
MOV EDX,R12D
MOV RCX,RAX
LEA RAX,[R12 + R... | int1 [16] func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
void *pvVar3;
ulong uVar4;
ulong uVar5;
int1 auVar6 [16];
pcVar1 = strstr(param_1,param_2);
if (pcVar1 == (char *)0x0) {
uVar4 = 0xffffffff;
uVar5 = 0xffffffff;
pvVar3 = (void *)0x0;
}
else {
sVar2 = strl... |
6,323 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct MatchResult {
char* pattern;
int start;
int end;
} MatchResult;
| MatchResult func0(const char* text, const char* pattern) {
MatchResult result;
result.pattern = NULL;
result.start = -1;
result.end = -1;
const char *start, *end;
start = strstr(text, pattern);
if (start != NULL) {
end = start + strlen(pattern);
result.pattern ... | int main() {
MatchResult r1, r2, r3;
r1 = func0("The quick brown fox jumps over the lazy dog.", "fox");
r2 = func0("Its been a very crazy procedure right", "crazy");
r3 = func0("Hardest choices required strongest will", "will");
assert(strcmp(r1.pattern, "fox") == 0 && r1.start == 1... | O3 | c | func0:
endbr64
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
callq 10f0 <strstr@plt>
mov %rax,%r12
test %rax,%rax
je 13c0 <func0+0x70>
mov %r13,%rdi
callq 10b0 <strlen@plt>
lea 0x1(%rax),%r14
mov %rax,%rbx
mov %r14,%rdi
callq 10e0 <malloc@plt>
mov ... | func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
call _strstr
mov rbp, rax
test rax, rax
jz short loc_13E0
mov rdi, r13; s
call _strlen
lea r14, [rax+1]
mov rbx, rax
mov rdi, r14; size
call _malloc
mov rdx, r14
mov ... | long long func0(const char *a1, const char *a2)
{
char *v2; // rbp
size_t v3; // r14
void *v4; // rax
v2 = strstr(a1, a2);
if ( v2 )
{
v3 = strlen(a2) + 1;
v4 = malloc(v3);
return __memcpy_chk(v4, a2, v3, v3);
}
return (long long)v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
CALL 0x00101110
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001013e0
MOV RDI,R13
CALL 0x001010c0
LEA R14,[RAX + 0x1]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00101100
MOV RDX,R14
MOV RCX,R14
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010f0
MOV EDX,EBP
MOV RDI,RAX
LEA R... | int [16] func0(char *param_1,char *param_2)
{
size_t __size;
char *pcVar1;
size_t sVar2;
void *pvVar3;
int8 uVar4;
ulong uVar5;
ulong uVar6;
int auVar7 [16];
pcVar1 = strstr(param_1,param_2);
if (pcVar1 == (char *)0x0) {
uVar5 = 0xffffffff;
uVar6 = 0xffffffff;
uVar4 = 0;
}
else ... |
6,324 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %edi,-0x64(%rbp)
mov %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
mov %rsp,%rcx
mov %rcx,%r15
mov -0x64(%rbp),%ecx
lea 0x1(%rcx),%esi
mov -0x64(%rbp),%ecx
lea 0... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov r11, rax
mov eax, [rbp+var_44]
lea edi, [rax+1]
mov eax, [rbp+var_44]
lea r8d, [rax+1]
movsxd rax, edi
sub rax, ... | long long func0(int a1)
{
int v1; // edi
unsigned long long v2; // rsi
unsigned long long v3; // rax
void *v4; // rsp
_DWORD v6[3]; // [rsp+8h] [rbp-50h] BYREF
int v7; // [rsp+14h] [rbp-44h]
int i; // [rsp+20h] [rbp-38h]
int j; // [rsp+24h] [rbp-34h]
long long v10; // [rsp+28h] [rbp-30h]
long long ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV R11,RAX
MOV EAX,dword ptr [RBP + -0x44]
LEA EDI,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x44]
LEA R8D,[RAX + 0x1]
MOVSXD RAX,EDI
SUB RAX,0x1
MOV... | int4 func0(int param_1)
{
int iVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int *puVar5;
long in_FS_OFFSET;
int auStack_58 [12];
int local_4c;
int local_40;
int local_3c;
long local_38;
long local_30;
int *local_28;
long local_20;
local_4c = param_1;
local_20 = *(long *)(in_FS_OFFSET ... |
6,325 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %edi,%eax
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
add $0x1,%eax
cltq
lea 0x0(,%rax,4),%rbx
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13d, edi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
lea rbx, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and ... | long long func0(int a1)
{
long long v2; // rax
unsigned long long v3; // rbx
long long v4; // rax
__int16 v5; // cx
signed long long v6; // rax
void *v7; // rsp
unsigned long long v8; // r11
_DWORD *v9; // r9
_DWORD *v10; // rsi
long long v11; // r15
long long v12; // rdi
long long v13; // r8
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
LEA RBX,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX... | int4 func0(int param_1)
{
long lVar1;
ulong uVar2;
int *piVar3;
int1 *puVar4;
int *piVar5;
ulong uVar7;
long lVar8;
ulong uVar9;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int *piVar6;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = (ulong)(param_1 + 1);
uVar9 = uVar2 * ... |
6,326 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
movslq %edi,%r14
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%r14),%eax
mov %rsp,%rbx
cltq
lea 0x0(,%rax,4),%r12
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov %... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
movsxd r14, edi
push r13
push r12
push rbx
lea ebx, [r14+1]
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, ebx
mov rcx, rsp
lea r12, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[ra... | long long func0(int a1)
{
long long v1; // r14
int v2; // ebx
unsigned long long v3; // r12
long long v4; // rdx
_DWORD *v5; // rcx
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned long long v9; // r10
long long v10; // rdi
long long v11; // r8
int *v12; // r9
int v13; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
MOVSXD R14,EDI
PUSH R13
PUSH R12
PUSH RBX
LEA EBX,[R14 + 0x1]
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,EBX
MOV RCX,RSP
LEA R12,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,R... | int4 func0(int param_1)
{
long lVar1;
int1 *puVar2;
ulong uVar3;
int *piVar4;
int iVar5;
int1 *puVar6;
int *piVar8;
ulong uVar9;
long lVar10;
int *piVar11;
ulong uVar12;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int1 *puVar7;
puVar6 = auStack_48;
local_40 = *(long *)(i... |
6,327 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int bell[n+1][n+1];
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
printf("All assertions passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
movslq %edi,%r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%r12),%eax
mov %rsp,%rdi
cltq
lea 0x0(,%rax,4),%rbx
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov %... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
mov r12d, edi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdi+1]
mov rcx, rsp
cdqe
lea rbx, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov ... | long long func0(int a1)
{
long long v2; // rax
unsigned long long v3; // rbx
long long v4; // rdx
int *v5; // rcx
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned long long v9; // r10
int *v10; // r8
int *v11; // rsi
long long v12; // r9
long long v13; // rdi
int i; // ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
MOV RCX,RSP
CDQE
LEA RBX,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-... | int4 func0(uint param_1)
{
long lVar1;
int *puVar2;
ulong uVar3;
int *piVar4;
int4 uVar5;
int iVar6;
int *puVar7;
int *piVar9;
ulong uVar10;
int *piVar11;
long lVar12;
ulong uVar13;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int *puVar8;
puVar7 = auStack_48;
local_40 =... |
6,328 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x18(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x1c(%rbp)
cmovge -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
imul -0x4(%rbp),%eax
cltd
idivl -0x18(%rbp)
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_18]
sub eax, 1
mov edx, [rbp+var_1C]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
imul eax, [rbp+var_4]
cdq
idiv [rbp+var_... | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a2 - 1;
if ( a3 >= a2 - 1 )
v3 = a3;
return (unsigned int)(v3 * a1 / a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
MOV EDX,dword ptr [RBP + -0x1c]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RB... | int [16] func0(int param_1,int param_2,int param_3)
{
int iVar1;
int auVar2 [16];
iVar1 = param_2 + -1;
if (param_2 + -1 <= param_3) {
iVar1 = param_3;
}
auVar2._0_8_ = (long)(param_1 * iVar1) / (long)param_2 & 0xffffffff;
auVar2._8_8_ = (long)(param_1 * iVar1) % (long)param_2 & 0xffffffff;
ret... |
6,329 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rsi),%ecx
cmp %edx,%ecx
mov %edx,%eax
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
| func0:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2,int param_3)
{
int1 auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
6,330 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r8d, edx
lea edx, [rsi-1]
cmp edx, r8d
mov eax, r8d
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV R8D,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,R8D
MOV EAX,R8D
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2,int param_3)
{
int1 auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
6,331 | func0 |
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 > N) ? B - 1 : N;
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
6,332 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
cmpl $0x0,-0x20(%rbp)
jle 11f4 <func0+0x6b>
mov -0x20(%rbp),%eax
cmp -0x1c(%rbp),%eax
jg 11f4 <func0+0x6b>
mov -0x20(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11e9 <func0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
cmp [rbp+var_20], 0
jle short loc_11F4
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jg short loc_11F4
mov eax, [rbp+var_20]
sub eax, 1
mov [rbp+var_4], eax
jmp sh... | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
int i; // [rsp+1Ch] [rbp-4h]
if ( a3 > 0 )
{
result = (unsigned int)a3;
if ( a3 <= a2 )
{
for ( i = a3 - 1; ; ++i )
{
result = (unsigned int)(a2 - 1);
if ( i >= (int)result )
break;
... | 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
CMP dword ptr [RBP + -0x20],0x0
JLE 0x001011f4
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JG 0x001011f4
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,0x1
MOV dword ptr [RBP ... | void func0(long param_1,int param_2,int param_3)
{
int4 local_c;
if ((0 < param_3) && (param_3 <= param_2)) {
for (local_c = param_3 + -1; local_c < param_2 + -1; local_c = local_c + 1) {
*(int4 *)(param_1 + (long)local_c * 4) =
*(int4 *)(param_1 + ((long)local_c + 1) * 4);
}
}
retu... |
6,333 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int ... | O1 | c | func0:
endbr64
test %edx,%edx
jle 11bd <func0+0x34>
cmp %esi,%edx
jg 11bd <func0+0x34>
lea -0x1(%rdx),%eax
jge 11bd <func0+0x34>
cltq
lea (%rdi,%rax,4),%rax
sub $0x1,%esi
sub %edx,%esi
movslq %edx,%rdx
add %rsi,%rdx
lea (%rdi,%rdx,4),%rcx
mov 0x4(%rax),%edx
mov %edx,(%rax)
add ... | func0:
endbr64
test edx, edx
jle short locret_11BD
cmp edx, esi
jg short locret_11BD
lea eax, [rdx-1]
jge short locret_11BD
cdqe
lea rax, [rdi+rax*4]
sub esi, 1
sub esi, edx
movsxd rdx, edx
add rsi, rdx
lea rcx, [rdi+rsi*4]
loc_11AF:
mov edx, [rax+4]
mov [rax], edx
a... | void func0(long long a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a3 > 0 && a3 < a2 )
{
v3 = (_DWORD *)(a1 + 4LL * (a3 - 1));
do
{
*v3 = v3[1];
++v3;
}
while ( v3 != (_DWORD *)(a1 + 4 * (a3 + (unsigned long long)(unsigned int)(a2 - 1 - a3))) );
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011bd
CMP EDX,ESI
JG 0x001011bd
LEA EAX,[RDX + -0x1]
JGE 0x001011bd
CDQE
LEA RAX,[RDI + RAX*0x4]
SUB ESI,0x1
SUB ESI,EDX
MOVSXD RDX,EDX
ADD RSI,RDX
LEA RCX,[RDI + RSI*0x4]
LAB_001011af:
MOV EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RAX],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011af
LAB_... | void func0(long param_1,int param_2,int param_3)
{
int4 *puVar1;
if (((0 < param_3) && (param_3 <= param_2)) && (param_3 < param_2)) {
puVar1 = (int4 *)(param_1 + (long)(param_3 + -1) * 4);
do {
*puVar1 = puVar1[1];
puVar1 = puVar1 + 1;
} while (puVar1 != (int4 *)
... |
6,334 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int ... | O2 | c | func0:
endbr64
test %edx,%edx
jle 14e0 <func0+0x10>
cmp %esi,%edx
jg 14e0 <func0+0x10>
jmp 14a0 <func0.part.0>
xchg %ax,%ax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0_part_0:
lea eax, [rdx-1]
cmp edx, esi
jge short locret_1510
cdqe
sub esi, 1
shl rax, 2
sub esi, edx
lea rdx, ds:4[rsi*4]
lea rsi, [rdi+rax+4]
add rdi, rax
jmp _memmove
locret_1510:
retn | long long func0_part_0(long long a1, int a2, int a3)
{
long long result; // rax
result = (unsigned int)(a3 - 1);
if ( a3 < a2 )
return memmove(4LL * (int)result + a1, a1 + 4LL * (int)result + 4, 4LL * (unsigned int)(a2 - 1 - a3) + 4);
return result;
} | func0.part.0:
LEA EAX,[RDX + -0x1]
CMP EDX,ESI
JGE 0x00101510
CDQE
SUB ESI,0x1
SHL RAX,0x2
SUB ESI,EDX
LEA RDX,[0x4 + RSI*0x4]
LEA RSI,[RDI + RAX*0x1 + 0x4]
ADD RDI,RAX
JMP 0x001010b0
LAB_00101510:
RET | void func0_part_0(long param_1,int param_2,int param_3)
{
long lVar1;
if (param_3 < param_2) {
lVar1 = (long)(param_3 + -1) * 4;
memmove((void *)(param_1 + lVar1),(void *)(param_1 + 4 + lVar1),
(ulong)(uint)((param_2 + -1) - param_3) * 4 + 4);
return;
}
return;
} |
6,335 | func0 | #include <stdio.h>
#include <assert.h>
| void func0(int list1[], int size, int L) {
if (L > 0 && L <= size) {
for(int i = L - 1; i < size - 1; i++) {
list1[i] = list1[i+1];
}
}
}
| int main() {
int list1[] = {1, 1, 2, 3, 4, 4, 5, 1};
func0(list1, 8, 3);
int expected1[] = {1, 1, 3, 4, 4, 5, 1};
for (int i = 0; i < 7; i++) {
assert(list1[i] == expected1[i]);
}
int list2[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
func0(list2, 16, 4);
int ... | O3 | c | func0:
endbr64
test %edx,%edx
jle 1760 <func0+0xe0>
cmp %esi,%edx
jg 1760 <func0+0xe0>
lea -0x1(%rdx),%r9d
lea -0x1(%rsi),%r10d
jge 1760 <func0+0xe0>
movslq %edx,%r11
push %rbp
lea 0x10(,%r11,4),%rcx
push %rbx
mov %r10d,%ebx
lea 0x0(,%r11,4),%r8
lea -0x14(%rcx),%rax
sub %edx,%ebx... | func0_part_0:
lea eax, [rdx-1]
cmp edx, esi
jge short locret_1490
cdqe
sub esi, 1
shl rax, 2
sub esi, edx
lea rdx, ds:4[rsi*4]; n
lea rsi, [rdi+rax+4]; src
add rdi, rax; dest
jmp _memmove
locret_1490:
retn | unsigned long long func0_part_0(long long a1, int a2, int a3)
{
unsigned long long result; // rax
result = (unsigned int)(a3 - 1);
if ( a3 < a2 )
return (unsigned long long)memmove(
(void *)(4LL * (int)result + a1),
(const void *)(a1 + 4LL * (int... | func0.part.0:
LEA EAX,[RDX + -0x1]
CMP EDX,ESI
JGE 0x00101490
CDQE
SUB ESI,0x1
SHL RAX,0x2
SUB ESI,EDX
LEA RDX,[0x4 + RSI*0x4]
LEA RSI,[RDI + RAX*0x1 + 0x4]
ADD RDI,RAX
JMP 0x001010b0
LAB_00101490:
RET | void func0_part_0(long param_1,int param_2,int param_3)
{
long lVar1;
if (param_3 < param_2) {
lVar1 = (long)(param_3 + -1) * 4;
memmove((void *)(param_1 + lVar1),(void *)(param_1 + 4 + lVar1),
(ulong)(uint)((param_2 + -1) - param_3) * 4 + 4);
return;
}
return;
} |
6,336 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11ea <func0+0x81>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mo... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov rax, [rbp+var_18]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov [rbp+var_8], eax
mov [rbp+var_4], 1
jmp short loc_11EA
loc_1194:
mov eax, [rbp+var_4... | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = *(_DWORD *)(a1 + 4LL * a3);
for ( i = 1; i < a2; ++i )
{
if ( (signed int)v4 < *(_DWORD *)(a1 + 12LL * i + 4LL * a3) )
v4 = *(_DWORD *)(a1 + 12LL * i + 4LL * a3);
}
return v... | 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 RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011e... | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = *(int *)(param_1 + (long)param_3 * 4);
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (local_10 < *(int *)((long)local_c * 0xc + param_1 + (long)param_3 * 4)) {
local_10 = *(int *)((long)loc... |
6,337 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(... | O1 | c | func0:
endbr64
movslq %edx,%rax
mov (%rdi,%rax,4),%ecx
cmp $0x1,%esi
jle 119f <func0+0x36>
mov %rax,%rdx
lea (%rdi,%rax,4),%rax
lea -0x2(%rsi),%esi
lea (%rsi,%rsi,2),%rsi
add %rsi,%rdx
lea 0xc(%rdi,%rdx,4),%rsi
mov 0xc(%rax),%edx
cmp %edx,%ecx
cmovl %edx,%ecx
add $0xc,%rax
cmp %r... | func0:
endbr64
movsxd rax, edx
mov ecx, [rdi+rax*4]
cmp esi, 1
jle short loc_119F
mov rdx, rax
lea rax, [rdi+rax*4]
lea esi, [rsi-2]
lea rsi, [rsi+rsi*2]
add rdx, rsi
lea rsi, [rdi+rdx*4+0Ch]
loc_118E:
mov edx, [rax+0Ch]
cmp ecx, edx
cmovl ecx, edx
add rax, 0Ch
cmp ... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // ecx
long long v4; // rax
long long v5; // rsi
v3 = *(_DWORD *)(a1 + 4LL * a3);
if ( a2 > 1 )
{
v4 = a1 + 4LL * a3;
v5 = a1 + 4 * (3LL * (unsigned int)(a2 - 2) + a3) + 12;
do
{
if ( (signed int)v3 < *(_DWORD *)(v4 + 1... | func0:
ENDBR64
MOVSXD RAX,EDX
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP ESI,0x1
JLE 0x0010119f
MOV RDX,RAX
LEA RAX,[RDI + RAX*0x4]
LEA ESI,[RSI + -0x2]
LEA RSI,[RSI + RSI*0x2]
ADD RDX,RSI
LEA RSI,[RDI + RDX*0x4 + 0xc]
LAB_0010118e:
MOV EDX,dword ptr [RAX + 0xc]
CMP ECX,EDX
CMOVL ECX,EDX
ADD RAX,0xc
CMP RAX,RSI
JNZ 0x001011... | int func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
int iVar3;
lVar1 = (long)param_3;
iVar3 = *(int *)(param_1 + lVar1 * 4);
if (1 < param_2) {
lVar2 = param_1 + lVar1 * 4;
do {
if (iVar3 < *(int *)(lVar2 + 0xc)) {
iVar3 = *(int *)(lVar2 + 0xc);
}
... |
6,338 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(... | O2 | c | func0:
endbr64
movslq %edx,%rdx
mov (%rdi,%rdx,4),%r8d
cmp $0x1,%esi
jle 117b <func0+0x3b>
lea -0x2(%rsi),%ecx
lea (%rdi,%rdx,4),%rax
lea (%rcx,%rcx,2),%rcx
add %rcx,%rdx
lea 0xc(%rdi,%rdx,4),%rcx
nopl 0x0(%rax,%rax,1)
mov 0xc(%rax),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0xc,%rax
cm... | func0:
endbr64
movsxd rdx, edx
mov r8d, [rdi+rdx*4]
cmp esi, 1
jle short loc_117B
lea ecx, [rsi-2]
lea rax, [rdi+rdx*4]
lea rcx, [rcx+rcx*2]
add rdx, rcx
lea rcx, [rdi+rdx*4+0Ch]
nop dword ptr [rax+rax+00h]
loc_1168:
mov edx, [rax+0Ch]
cmp r8d, edx
cmovl r8d, edx
add r... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r8d
long long v4; // rax
v3 = *(_DWORD *)(a1 + 4LL * a3);
if ( a2 > 1 )
{
v4 = a1 + 4LL * a3;
do
{
if ( (signed int)v3 < *(_DWORD *)(v4 + 12) )
v3 = *(_DWORD *)(v4 + 12);
v4 += 12LL;
}
while ( v4 != a... | func0:
ENDBR64
MOVSXD RDX,EDX
MOV R8D,dword ptr [RDI + RDX*0x4]
CMP ESI,0x1
JLE 0x0010117b
LEA ECX,[RSI + -0x2]
LEA RAX,[RDI + RDX*0x4]
LEA RCX,[RCX + RCX*0x2]
ADD RDX,RCX
LEA RCX,[RDI + RDX*0x4 + 0xc]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101168:
MOV EDX,dword ptr [RAX + 0xc]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0xc
CMP RA... | int func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
int iVar3;
lVar2 = (long)param_3;
iVar3 = *(int *)(param_1 + lVar2 * 4);
if (1 < param_2) {
lVar1 = param_1 + lVar2 * 4;
do {
if (iVar3 < *(int *)(lVar1 + 0xc)) {
iVar3 = *(int *)(lVar1 + 0xc);
}
... |
6,339 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int test_list[][3], int list_size, int N) {
int res = test_list[0][N];
for (int i = 1; i < list_size; i++) {
if (test_list[i][N] > res) {
res = test_list[i][N];
}
}
return res;
}
| int main() {
int test_list1[3][3] = {{5, 6, 7}, {1, 3, 5}, {8, 9, 19}};
int test_list2[3][3] = {{6, 7, 8}, {2, 4, 6}, {9, 10, 20}};
int test_list3[3][3] = {{7, 8, 9}, {3, 5, 7}, {10, 11, 21}};
assert(func0(test_list1, 3, 2) == 19);
assert(func0(test_list2, 3, 1) == 10);
assert(func0(... | O3 | c | func0:
endbr64
movslq %edx,%rdx
mov (%rdi,%rdx,4),%r8d
cmp $0x1,%esi
jle 117b <func0+0x3b>
lea -0x2(%rsi),%ecx
lea (%rdi,%rdx,4),%rax
lea (%rcx,%rcx,2),%rcx
add %rcx,%rdx
lea 0xc(%rdi,%rdx,4),%rcx
nopl 0x0(%rax,%rax,1)
mov 0xc(%rax),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0xc,%rax
cm... | func0:
endbr64
mov r8, rdi
mov edi, esi
movsxd rsi, edx
mov eax, [r8+rsi*4]
cmp edi, 1
jle locret_1252
lea edx, [rdi-2]
cmp edx, 3
jbe loc_1253
mov ecx, edx
movd xmm4, eax
lea rax, [r8+rsi*4+0Ch]
shr ecx, 2
pshufd xmm2, xmm4, 0
lea rcx, [rcx+rcx*2]
shl rcx, 4
add... | long long func0(long long a1, int a2, int a3)
{
long long v5; // rsi
long long result; // rax
unsigned int v7; // edx
__m128i v8; // xmm4
const __m128i *v9; // rax
__m128i v10; // xmm2
const __m128i *v11; // rcx
__m128 v12; // xmm3
__m128 v13; // xmm1
__m128 v14; // xmm0
__m128i v15; // xmm0
__... | func0:
ENDBR64
MOV R8,RDI
MOV EDI,ESI
MOVSXD RSI,EDX
MOV EAX,dword ptr [R8 + RSI*0x4]
CMP EDI,0x1
JLE 0x00101252
LEA EDX,[RDI + -0x2]
CMP EDX,0x3
JBE 0x00101253
MOV ECX,EDX
MOVD XMM4,EAX
LEA RAX,[R8 + RSI*0x4 + 0xc]
SHR ECX,0x2
PSHUFD XMM2,XMM4,0x0
LEA RCX,[RCX + RCX*0x2]
SHL RCX,0x4
ADD RCX,RAX
NOP dword ptr [RAX + RA... | uint func0(long param_1,int param_2,int param_3)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
int iVar6;
long lVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
lVar7 = (long)param_3;
uVar2 = *(uint *)(param_1 + lVar... |
6,340 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov -0x30(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 1271 <func0+0xc8>
mov -0x2c(... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov eax, [rbp+var_30]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_20], 0
jmp loc_1271
loc_11E1:
mov ... | _QWORD * func0(long long a1, int a2, int a3)
{
int i; // [rsp+10h] [rbp-20h]
int j; // [rsp+14h] [rbp-1Ch]
_QWORD *v7; // [rsp+18h] [rbp-18h]
v7 = malloc(8LL * a3);
for ( i = 0; i < a3; ++i )
{
v7[i] = malloc(4LL * a2);
for ( j = 0; j < a2; ++j )
*(_DWORD *)(4LL * j + v7[i]) = *(_DWORD *)(4LL... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101271
LAB_001011... | void * func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
void *pvVar2;
int4 local_28;
int4 local_24;
pvVar1 = malloc((long)param_3 << 3);
for (local_28 = 0; local_28 < param_3; local_28 = local_28 + 1) {
pvVar2 = malloc((long)param_2 << 2);
*(void **)((long)local_28 * 8 + (long)pvVar1)... |
6,341 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %esi,%r14d
mov %edx,%ebx
movslq %edx,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 1244 <func0+0x9b>
mov %rax,%rdi
movslq %r14d,%rax
shl ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov r14d, esi
mov ebx, edx
movsxd rdi, edx
shl rdi, 3
call _malloc
mov r15, rax
test ebx, ebx
jle short loc_1229
movsxd rax, r14d
shl rax, 2
mov [rsp+48h+var_40], ... | long long func0(long long a1, int a2, int a3)
{
long long v4; // r15
long long v5; // r13
long long v6; // rbx
long long v7; // rax
long long i; // rdx
v4 = malloc(8LL * a3);
if ( a3 > 0 )
{
v5 = 4LL * (unsigned int)a3;
v6 = 0LL;
do
{
v7 = malloc(4LL * a2);
*(_QWORD *)(v4 +... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV R14D,ESI
MOV EBX,EDX
MOVSXD RDI,EDX
SHL RDI,0x3
CALL 0x001010b0
MOV R15,RAX
TEST EBX,EBX
JLE 0x00101229
MOVSXD RAX,R14D
SHL RAX,0x2
MOV qword ptr [RSP + 0x8],RAX
MOV EBX,EBX
LEA R13,[RBX*0x4]
MOV EBX,0x0
MOV R12D,R14D
LAB_... | void * func0(long param_1,uint param_2,uint param_3)
{
void *pvVar1;
void *pvVar2;
ulong uVar3;
long lVar4;
pvVar1 = malloc((long)(int)param_3 << 3);
if (0 < (int)param_3) {
lVar4 = 0;
do {
pvVar2 = malloc((long)(int)param_2 << 2);
*(void **)((long)pvVar1 + lVar4 * 2) = pvVar2;
... |
6,342 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %edx,%rdi
push %r13
mov %rdi,%r13
shl $0x3,%rdi
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x18,%rsp
callq 10b0 <malloc@plt>
mov %rax,%r12
test %r13d,%r13d
jle 1630 <func0+0x90>
lea -0x1(%r13),%eax
movslq %ebx,%rbp
xor ... | func0:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
push rbp
movsxd rbp, edx
push rbx
lea rdi, ds:0[rbp*8]
movsxd rbx, esi
sub rsp, 18h
mov [rsp+48h+var_3C], ebx
call _malloc
mov r12, rax
test ebp, ebp
jle short loc_161D
lea r13, ds:0[rbx*4]
shl rbp,... | long long func0(long long a1, int a2, int a3)
{
long long v3; // rbp
long long v4; // r12
long long v5; // rbp
long long v6; // r14
long long v7; // rax
long long i; // rdx
v3 = a3;
v4 = malloc(8LL * a3);
if ( (int)v3 > 0 )
{
v5 = 4 * v3;
v6 = 0LL;
do
{
v7 = malloc(4LL * a2);... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
LEA RDI,[RBP*0x8]
MOVSXD RBX,ESI
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EBX
CALL 0x001010b0
MOV R12,RAX
TEST EBP,EBP
JLE 0x0010161d
LEA R13,[RBX*0x4]
SHL RBP,0x2
XOR R14D,R14D
NOP word ptr [RAX + RAX*0x1]
LAB_001015e8:
MOV R... | void * func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
void *pvVar2;
long lVar3;
long lVar4;
pvVar1 = malloc((long)param_3 * 8);
if (0 < param_3) {
lVar4 = 0;
do {
pvVar2 = malloc((long)param_2 * 4);
*(void **)((long)pvVar1 + lVar4 * 2) = pvVar2;
if (0 < param_2) {
... |
6,343 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int** func0(int** lst, int rows, int cols) {
int** result = malloc(sizeof(int*) * cols);
for (int i = 0; i < cols; i++) {
result[i] = malloc(sizeof(int) * rows);
for (int j = 0; j < rows; j++) {
result[i][j] = lst[j][i];
}
}
return result;
}
| int main() {
int* test1[] = {(int[]){1, 2}, (int[]){3, 4}, (int[]){5, 6}, (int[]){7, 8}};
int** result1 = func0(test1, 4, 2);
assert(result1[0][0] == 1 && result1[0][1] == 3 && result1[0][2] == 5 && result1[0][3] == 7);
assert(result1[1][0] == 2 && result1[1][1] == 4 && result1[1][2] == 6 && result1... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %edx,%rdi
push %r13
mov %rdi,%r13
shl $0x3,%rdi
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x18,%rsp
callq 10b0 <malloc@plt>
mov %rax,%r12
test %r13d,%r13d
jle 1650 <func0+0x90>
lea -0x1(%r13),%eax
movslq %ebx,%rbp
xor ... | func0:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
movsxd r12, edx
push rbp
lea rdi, ds:0[r12*8]; size
mov ebp, esi
push rbx
sub rsp, 18h
call _malloc
mov rbx, rax
test r12d, r12d
jle short loc_1645
movsxd r13, ebp
shl r12, 2
xor r14d, r14d
lea ... | char * func0(long long a1, int a2, int a3)
{
long long v3; // r12
char *v4; // rbx
long long v5; // r12
long long v6; // r14
_DWORD *v7; // rax
long long i; // rdx
v3 = a3;
v4 = (char *)malloc(8LL * a3);
if ( (int)v3 > 0 )
{
v5 = 4 * v3;
v6 = 0LL;
do
{
v7 = malloc(4LL * a2);
... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,EDX
PUSH RBP
LEA RDI,[R12*0x8]
MOV EBP,ESI
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
MOV RBX,RAX
TEST R12D,R12D
JLE 0x00101645
MOVSXD R13,EBP
SHL R12,0x2
XOR R14D,R14D
LEA RAX,[R13*0x4]
MOV qword ptr [RSP + 0x8],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LA... | void * func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
void *pvVar2;
long lVar3;
long lVar4;
pvVar1 = malloc((long)param_3 * 8);
if (0 < param_3) {
lVar4 = 0;
do {
pvVar2 = malloc((long)param_2 * 4);
*(void **)((long)pvVar1 + lVar4 * 2) = pvVar2;
if (0 < param_2) {
... |
6,344 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] >... | int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,%rax
mov %rsi,%rcx
mov %rcx,%rdx
mov %rax,-0x30(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x28(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 12f0 <func0+0x147... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, rdi
mov rcx, rsi
mov rdx, rcx
mov [rbp+var_30], rax
mov [rbp+var_28], rdx
mov eax, dword ptr [rbp+var_28]
cdqe
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
jmp loc_... | _QWORD * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
_QWORD *v6; // [rsp+28h] [rbp-8h]
v6 = malloc(16LL * a2);
for ( i = 0; i < a2; ++i )
{
v4 = **(_DWORD **)(a1 + 24LL * i + 8);
for ( j = 1; j < *(_DWORD *)(a1 + 24LL * i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,RDI
MOV RCX,RSI
MOV RDX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x28]
CDQE
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012f0
LAB_001011e7:
MO... | void * func0(long param_1,int param_2)
{
void *pvVar1;
int local_1c;
int local_18;
int local_14;
pvVar1 = malloc((long)param_2 << 4);
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
local_18 = **(int **)((long)local_1c * 0x18 + param_1 + 8);
for (local_14 = 1; local_14 < *(int ... |
6,345 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] >... | int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", ... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
movslq %esi,%rdi
shl $0x4,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1227 <func0+0x7e>
mov %rbp,%r8
mov %rax,%r9
lea -0x1(%rbx),%r11d
add $0x1,%r11
shl $0x4,%r11
add %rax,%r11
jmp 11f7 <func0+0x4... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
movsxd rdi, esi
shl rdi, 4
call _malloc
mov r11, rax
test ebx, ebx
jle short loc_1220
mov rdi, rbp
mov r8, rax
mov ebx, ebx
shl rbx, 4
lea r9, [rbx+rax]
loc_11DC:
mov r10, rdi
mov rcx, ... | long long func0(long long a1, int a2)
{
long long v2; // rax
long long v3; // r11
long long v4; // r8
long long v5; // r9
int *v6; // rcx
int v7; // edx
int v8; // esi
int *v9; // rax
long long v10; // rsi
v2 = malloc(16LL * a2);
v3 = v2;
if ( a2 > 0 )
{
v4 = v2;
v5 = 16LL * (unsigne... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
MOVSXD RDI,ESI
SHL RDI,0x4
CALL 0x001010b0
MOV R11,RAX
TEST EBX,EBX
JLE 0x00101220
MOV RDI,RBP
MOV R8,RAX
MOV EBX,EBX
SHL RBX,0x4
LEA R9,[RBX + RAX*0x1]
LAB_001011dc:
MOV R10,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOV EDX,dword ptr [RCX]
MOV ESI,dword ptr ... | int8 * func0(int8 *param_1,uint param_2)
{
int *piVar1;
int8 *puVar2;
int *piVar3;
int iVar4;
int8 *puVar5;
puVar2 = (int8 *)malloc((long)(int)param_2 << 4);
if (0 < (int)param_2) {
puVar5 = puVar2;
do {
piVar1 = (int *)param_1[1];
iVar4 = *piVar1;
if (1 < *(int *)(param_1 + ... |
6,346 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] >... | int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", ... | O2 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
shl $0x4,%rdi
mov %rsi,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1550 <func0+0x80>
lea -0x1(%rbx),%r10d
mov %rbp,%r8
mov %rax,%r9
add $0x1,%r10
shl $0x4,%r10
add %rax,%r10
nopl (%rax)
mov 0... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
movsxd rdi, esi
shl rdi, 4
sub rsp, 8
call _malloc
mov r10, rax
test ebp, ebp
jle short loc_1550
mov ebp, ebp
mov rdi, rbx
mov r8, rax
shl rbp, 4
lea r9, [rbp+rax+0]
nop dword ptr [rax+00h]
loc_1508:
... | long long func0(long long *a1, int a2)
{
long long v2; // rax
long long v3; // r10
long long v4; // r8
long long v5; // r9
int *v6; // rcx
int v7; // esi
int v8; // edx
int *v9; // rax
long long v10; // rsi
long long v11; // rax
v2 = malloc(16LL * a2);
v3 = v2;
if ( a2 > 0 )
{
v4 = v2;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
SHL RDI,0x4
SUB RSP,0x8
CALL 0x001010b0
MOV R10,RAX
TEST EBP,EBP
JLE 0x00101550
MOV EBP,EBP
MOV RDI,RBX
MOV R8,RAX
SHL RBP,0x4
LEA R9,[RBP + RAX*0x1]
NOP dword ptr [RAX]
LAB_00101508:
MOV RCX,qword ptr [RDI + 0x8]
MOV ESI,dword ptr [RDI + 0x10]
MOV... | int8 * func0(int8 *param_1,uint param_2)
{
int *piVar1;
int8 uVar2;
int8 *puVar3;
int *piVar4;
int iVar5;
int8 *puVar6;
int8 *puVar7;
puVar3 = (int8 *)malloc((long)(int)param_2 << 4);
if (0 < (int)param_2) {
puVar6 = puVar3;
do {
piVar1 = (int *)param_1[1];
iVar5 = *piVar1;
... |
6,347 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char *key;
int *values;
int length;
} KeyValue;
typedef struct {
KeyValue *items;
int length;
} KeyValueList;
typedef struct {
char *key;
int max_value;
} Result;
| Result* func0(KeyValueList test_list) {
Result *res = (Result*)malloc(test_list.length * sizeof(Result));
for (int i = 0; i < test_list.length; i++) {
int max = test_list.items[i].values[0];
for (int j = 1; j < test_list.items[i].length; j++) {
if (test_list.items[i].values[j] >... | int main() {
int a1[] = {3, 4, 5}, a2[] = {1, 4, 2}, a3[] = {9, 3};
KeyValue items1[] = {{"key1", a1, 3}, {"key2", a2, 3}, {"key3", a3, 2}};
KeyValueList kv1 = {items1, 3};
int a4[] = {4, 5, 6}, a5[] = {2, 5, 3}, a6[] = {10, 4};
KeyValue items2[] = {{"key1", a4, 3}, {"key2", a5, 3}, {"key3", ... | O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
shl $0x4,%rdi
mov %rsi,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 164a <func0+0x14a>
lea -0x1(%rbx),%r11d
mov %rbp,%rdi
mov %rax,%r8
add $0x1,%r11
shl $0x4,%r11
add %rax,%r11
nopl 0x0(%rax)
mov... | func0:
endbr64
push r12
movsxd r10, esi
mov r12, rdi
push rbp
shl r10, 4
push rbx
mov rdi, r10; size
mov rbx, rsi
mov rbp, r10
call _malloc
mov r11, rax
test ebx, ebx
jle loc_1640
mov rsi, r12
mov r8, rax
lea r10, [rbp+rax+0]
nop word ptr [rax+rax+00000000h]
l... | char * func0(long long *a1, int a2)
{
size_t v2; // rbp
char *v3; // rax
char *v4; // r11
char *v6; // r8
char *v7; // r10
signed int *v8; // rdi
int v9; // r9d
signed int v10; // eax
unsigned int v11; // ecx
__m128i v12; // xmm3
long long v13; // rax
__m128i v14; // xmm2
__m128i v15; // xmm0
... | func0:
ENDBR64
PUSH R12
MOVSXD R10,ESI
MOV R12,RDI
PUSH RBP
SHL R10,0x4
PUSH RBX
MOV RDI,R10
MOV RBX,RSI
MOV RBP,R10
CALL 0x001010b0
MOV R11,RAX
TEST EBX,EBX
JLE 0x00101640
MOV RSI,R12
MOV R8,RAX
LEA R10,[RBP + RAX*0x1]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101540:
MOV RDI,qword ptr [RSI + 0x8]
MOV R9D,dword ptr [RSI +... | int8 * func0(int8 *param_1,int param_2)
{
uint uVar1;
uint *puVar2;
int iVar3;
uint *puVar4;
int8 uVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint uVar9;
int8 *puVar10;
uint *puVar11;
int iVar12;
int8 *puVar13;
int8 *puVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
... |
6,348 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes,... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 1201 <func0+0x78>
movl $0x0,-0x4(%rbp)
jmp 11e2 <func0+0x59>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_1201
loc_11AC:
mov [rbp+var_4], 0
jmp short loc_11E2
loc_11B5:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
shl ... | long long func0(long long a1, long long a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-Ch]
int i; // [rsp+1Ch] [rbp-8h]
int j; // [rsp+20h] [rbp-4h]
v4 = 0;
for ( i = 0; i < a3; ++i )
{
for ( j = 0; j < *(_DWORD *)(4LL * i + a2); ++j )
v4 += *(_DWORD *)(a1 + 40LL * i + 4LL * j);
}
return v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101201
LAB_001011ac:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011e2
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD... | int func0(long param_1,long param_2,int param_3)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_3; local_10 = local_10 + 1) {
for (local_c = 0; local_c < *(int *)(param_2 + (long)local_10 * 4); local_c = local_c + 1) {
local_14 = local_14 + *(int ... |
6,349 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes,... | O1 | c | func0:
endbr64
test %edx,%edx
jle 11cf <func0+0x46>
mov %rsi,%r8
lea -0x1(%rdx),%eax
lea 0x4(%rsi,%rax,4),%rsi
mov $0x0,%edx
jmp 11c6 <func0+0x3d>
lea -0x1(%rax),%eax
lea 0x4(%rdi,%rax,4),%rcx
mov %rdi,%rax
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 11ae <func0+0x25>
add ... | func0:
endbr64
test edx, edx
jle short loc_11CF
mov r8, rsi
lea eax, [rdx-1]
lea rsi, [rsi+rax*4+4]
mov edx, 0
jmp short loc_11C6
loc_11A3:
lea eax, [rax-1]
lea rcx, [rdi+rax*4+4]
mov rax, rdi
loc_11AE:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_11AE
loc_... | long long func0(_DWORD *a1, int *a2, int a3)
{
int *v3; // r8
long long v4; // rsi
unsigned int v5; // edx
_DWORD *v6; // rax
if ( a3 <= 0 )
{
return 0;
}
else
{
v3 = a2;
v4 = (long long)&a2[a3 - 1 + 1];
v5 = 0;
do
{
if ( *v3 > 0 )
{
v6 = a1;
do
... | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011cf
MOV R8,RSI
LEA EAX,[RDX + -0x1]
LEA RSI,[RSI + RAX*0x4 + 0x4]
MOV EDX,0x0
JMP 0x001011c6
LAB_001011a3:
LEA EAX,[RAX + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
MOV RAX,RDI
LAB_001011ae:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011ae
LAB_001011b9:
ADD R8,0x4
ADD RDI,0... | int func0(int *param_1,int *param_2,int param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
if (param_3 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
iVar3 = 0;
do {
if (0 < *param_2) {
piVar2 = param_1;
do {
iVar3 = iVar3 + *piVar2;
... |
6,350 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes,... | O2 | c | func0:
endbr64
test %edx,%edx
jle 147d <func0+0x4d>
lea -0x1(%rdx),%eax
xor %r8d,%r8d
lea 0x4(%rsi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rsi),%eax
test %eax,%eax
jle 146c <func0+0x3c>
sub $0x1,%eax
lea 0x4(%rdi,%rax,4),%rdx
mov %rdi,%rax
nopl 0x0(%rax)
add (%rax),%r8d
add $0x... | func0:
endbr64
test edx, edx
jle short loc_141D
lea eax, [rdx-1]
xor r8d, r8d
lea rcx, [rsi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_13E8:
mov eax, [rsi]
test eax, eax
jle short loc_140C
sub eax, 1
lea rdx, [rdi+rax*4+4]
mov rax, rdi
nop dword ptr [rax+00000000h]
loc_14... | long long func0(_DWORD *a1, int *a2, int a3)
{
unsigned int v3; // r8d
long long v4; // rcx
_DWORD *v5; // rax
if ( a3 <= 0 )
return 0LL;
v3 = 0;
v4 = (long long)&a2[a3 - 1 + 1];
do
{
if ( *a2 > 0 )
{
v5 = a1;
do
v3 += *v5++;
while ( v5 != &a1[*a2 - 1 + 1] );
... | func0:
ENDBR64
TEST EDX,EDX
JLE 0x0010141d
LEA EAX,[RDX + -0x1]
XOR R8D,R8D
LEA RCX,[RSI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e8:
MOV EAX,dword ptr [RSI]
TEST EAX,EAX
JLE 0x0010140c
SUB EAX,0x1
LEA RDX,[RDI + RAX*0x4 + 0x4]
MOV RAX,RDI
NOP dword ptr [RAX]
LAB_00101400:
ADD R8D,dword ptr [RAX]
ADD RA... | int func0(int *param_1,int *param_2,int param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
if (0 < param_3) {
iVar3 = 0;
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
do {
if (0 < *param_2) {
piVar2 = param_1;
do {
iVar3 = iVar3 + *piVar2;
piVar2 = piVar2 + ... |
6,351 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int test_list[][10], int list_of_sizes[], int list_size) {
int res = 0;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < list_of_sizes[i]; j++) {
res += test_list[i][j];
}
}
return res;
}
| int main() {
int list1[][10] = {{1, 3}, {5, 6, 7}, {2, 6}};
int list1_sizes[] = {2, 3, 2};
int list2[][10] = {{2, 4}, {6, 7, 8}, {3, 7}};
int list2_sizes[] = {2, 3, 2};
int list3[][10] = {{3, 5}, {7, 8, 9}, {4, 8}};
int list3_sizes[] = {2, 3, 2};
assert(func0(list1, list1_sizes,... | O3 | c | func0:
endbr64
test %edx,%edx
jle 16d6 <func0+0xe6>
lea -0x1(%rdx),%eax
xor %r8d,%r8d
lea 0x4(%rsi,%rax,4),%r10
nopw 0x0(%rax,%rax,1)
mov (%rsi),%edx
test %edx,%edx
jle 16bd <func0+0xcd>
lea -0x1(%rdx),%eax
cmp $0x3,%eax
jbe 16d2 <func0+0xe2>
mov %edx,%eax
movdqu (%rdi),%xmm0
shr ... | func0:
endbr64
test edx, edx
jle loc_16A5
mov r8, rsi
movsxd rdx, edx
mov rsi, rdi
xor ecx, ecx
lea r10, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_15F0:
mov edx, [r8]
test edx, edx
jle loc_168D
lea eax, [rdx-1]
cmp eax, 2
jbe loc_16A1
mov eax, edx
movdqu xmm0, xm... | long long func0(const __m128i *a1, int *a2, int a3)
{
unsigned int v5; // ecx
int *v6; // r10
int v7; // edx
__m128i v8; // xmm0
unsigned int v9; // eax
long long v10; // rdi
long long v11; // r9
__m128i v12; // xmm0
signed int v13; // eax
__int32 *v14; // rdi
if ( a3 > 0 )
{
v5 = 0;
v... | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001016a5
MOV R8,RSI
MOVSXD RDX,EDX
MOV RSI,RDI
XOR ECX,ECX
LEA R10,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001015f0:
MOV EDX,dword ptr [R8]
TEST EDX,EDX
JLE 0x0010168d
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x001016a1
MOV EAX,EDX
MOVDQU XMM0,xmmword ptr [RSI]
SHR EAX,0x2
CMP EAX... | int func0(int *param_1,uint *param_2,int param_3)
{
uint *puVar1;
int *piVar2;
uint uVar3;
int iVar4;
uint uVar5;
int iVar6;
long lVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
if (param_3 < 1) {
return 0;
}
iVar6 = 0;
puVar1 = param_2 + param_3;
do {
uVar3 = *param_2;
... |
6,352 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = ... | int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(r... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %edi,-0x34(%rbp)
mov %esi,-0x38(%rbp)
mov %rdx,-0x40(%rbp)
mov -0x38(%rbp),%ebx
movslq %ebx,%rax
sub $0x1,%rax
mov %rax,-0x20(%rbp)
movslq %ebx,%rax
mov %rax,%r8
mov $0x0,%r9d
mov -0x38(%rbp),%eax
cltq
shl $0x3,%... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov [rbp+var_40], rdx
mov ebx, [rbp+var_38]
movsxd rax, ebx
sub rax, 1
mov [rbp+var_20], rax
mov eax, [rbp+var_38]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
... | double * func0(int a1, int a2, long long a3)
{
int i; // [rsp+10h] [rbp-30h]
int j; // [rsp+14h] [rbp-2Ch]
double v7; // [rsp+18h] [rbp-28h]
double *v8; // [rsp+28h] [rbp-18h]
v8 = (double *)malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
v7 = 0.0;
for ( j = 0; j < a1; ++j )
v7 = (double)*(i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV qword ptr [RBP + -0x40],RDX
MOV EBX,dword ptr [RBP + -0x38]
MOVSXD RAX,EBX
SUB RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b... | void * func0(int param_1,int param_2,long param_3)
{
void *pvVar1;
int4 local_38;
int4 local_34;
int8 local_30;
pvVar1 = malloc((long)param_2 << 3);
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
local_30 = 0.0;
for (local_34 = 0; local_34 < param_1; local_34 = local_34 + 1) {... |
6,353 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = ... | int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(r... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
mov %esi,%r13d
mov %rdx,%r12
movslq %esi,%rbp
lea 0x0(,%rbp,8),%rdi
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 1236 <func0+0x8d>
mov %rax,%rdi
mov %r12,%r8
lea -0x1(%r13),%edx
lea 0x8(%rax,%rdx,... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edi
mov r12d, esi
mov r13, rdx
movsxd rbp, esi
lea rdi, ds:0[rbp*8]
call _malloc
test r12d, r12d
jle short loc_1238
mov r8, rax
mov rdi, r13
lea edx, [r12-1]
lea r9, [r13+rdx*4+4]
lea rs... | long long func0(int a1, int a2, int *a3)
{
long long result; // rax
double *v6; // r8
int *v7; // rdi
int *v8; // rcx
int v9; // edx
double v10; // xmm0_8
result = malloc(8LL * a2);
if ( a2 > 0 )
{
v6 = (double *)result;
v7 = a3;
do
{
v10 = 0.0;
if ( a1 > 0 )
{
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV R12D,ESI
MOV R13,RDX
MOVSXD RBP,ESI
LEA RDI,[RBP*0x8]
CALL 0x001010b0
TEST R12D,R12D
JLE 0x00101238
MOV R8,RAX
MOV RDI,R13
LEA EDX,[R12 + -0x1]
LEA R9,[R13 + RDX*0x4 + 0x4]
LEA RSI,[RBP*0x4]
JMP 0x0010122e
LAB_001011ee:
MOV RCX,RDI
MOV EDX,0... | void func0(int param_1,int param_2,int *param_3)
{
int *piVar1;
double *pdVar2;
int *piVar3;
int iVar4;
double dVar5;
pdVar2 = (double *)malloc((long)param_2 * 8);
if (0 < param_2) {
piVar1 = param_3 + (ulong)(param_2 - 1) + 1;
do {
dVar5 = 0.0;
if (0 < param_1) {
iVar4 = 0... |
6,354 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = ... | int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(r... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
movslq %esi,%rbp
push %rbx
mov %edi,%ebx
lea 0x0(,%rbp,8),%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 158c <func0+0x8c>
pxor %xmm3,%xmm3
lea -0x1(%rbp),%edx
mov %rax,%rdi
mov %r12,%r8
cvtsi2sd %ebx,%xmm3
le... | func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
movsxd rbp, esi
push rbx
mov ebx, edi
lea rdi, ds:0[rbp*8]
sub rsp, 8
call _malloc
test ebp, ebp
jle short loc_158D
pxor xmm3, xmm3
lea edx, [rbp-1]
mov r8, rax
mov rdi, r12
cvtsi2sd xmm3, ebx
lea r9, [r12+r... | long long func0(int a1, int a2, int *a3)
{
long long result; // rax
long long v6; // r8
int *v7; // rdi
int *v8; // rcx
int v9; // edx
double v10; // xmm0_8
double v11; // xmm1_8
result = malloc(8LL * a2);
if ( a2 > 0 )
{
v6 = result;
v7 = a3;
do
{
v8 = v7;
v9 = 0;
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV EBX,EDI
LEA RDI,[RBP*0x8]
SUB RSP,0x8
CALL 0x001010b0
TEST EBP,EBP
JLE 0x0010158d
PXOR XMM3,XMM3
LEA EDX,[RBP + -0x1]
MOV R8,RAX
MOV RDI,R12
CVTSI2SD XMM3,EBX
LEA R9,[R12 + RDX*0x4 + 0x4]
PXOR XMM2,XMM2
LEA RSI,[RBP*0x4]
NOP dword ptr [RA... | void func0(int param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
double *pdVar3;
int *piVar4;
int iVar5;
double dVar6;
pdVar3 = (double *)malloc((long)param_2 * 8);
if (0 < param_2) {
piVar1 = param_3 + (ulong)(param_2 - 1) + 1;
do {
iVar5 = 0;
dVar6 = 0.0;
piVar4... |
6,355 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| double* func0(int num_tuples, int tuple_length, int nums[][tuple_length]) {
double* result = malloc(tuple_length * sizeof(double));
for(int i = 0; i < tuple_length; i++) {
double sum = 0.0;
for(int j = 0; j < num_tuples; j++) {
sum += nums[j][i];
}
result[i] = ... | int main() {
// First assertion
int nums1[][4] = {
{10, 10, 10, 12},
{30, 45, 56, 45},
{81, 80, 39, 32},
{1, 2, 3, 4}
};
double expected1[] = {30.5, 34.25, 27.0, 23.25};
double* result1 = func0(4, 4, nums1);
for(int i = 0; i < 4; i++) {
assert(r... | O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
movslq %esi,%rbp
push %rbx
mov %edi,%ebx
lea 0x0(,%rbp,8),%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 14fc <func0+0x8c>
pxor %xmm3,%xmm3
lea -0x1(%rbp),%edx
mov %rax,%rdi
mov %r12,%r8
cvtsi2sd %ebx,%xmm3
le... | func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
movsxd rbp, esi
push rbx
mov ebx, edi
lea rdi, ds:0[rbp*8]; size
sub rsp, 8
call _malloc
test ebp, ebp
jle short loc_14B5
pxor xmm2, xmm2
lea rsi, ds:0[rbp*4]
mov r8, rax
mov rdi, r12
cvtsi2sd xmm2, ebx
lea ... | double * func0(int a1, int a2, int *a3)
{
double *result; // rax
double *v6; // r8
int *v7; // rdi
int *v8; // rcx
int v9; // edx
double v10; // xmm0_8
double v11; // xmm1_8
result = (double *)malloc(8LL * a2);
if ( a2 > 0 )
{
v6 = result;
v7 = a3;
do
{
v8 = v7;
v9 = 0;
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV EBX,EDI
LEA RDI,[RBP*0x8]
SUB RSP,0x8
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001014b5
PXOR XMM2,XMM2
LEA RSI,[RBP*0x4]
MOV R8,RAX
MOV RDI,R12
CVTSI2SD XMM2,EBX
LEA R9,[R12 + RSI*0x1]
NOP dword ptr [RAX]
LAB_00101478:
MOV RCX,RDI
XOR EDX,EDX
P... | void func0(int param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
double *pdVar3;
int *piVar4;
int iVar5;
long lVar6;
double dVar7;
lVar6 = (long)param_2;
pdVar3 = (double *)malloc(lVar6 * 8);
if (0 < param_2) {
piVar1 = param_3 + lVar6;
do {
iVar5 = 0;
dVar7 = 0.0;
... |
6,356 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
in... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d6 <func0+0x6d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11D8
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]... | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
*(_DWORD *)(4LL * (int)i + a3) = *(_DWORD *)(4LL * (int)i + a1) % *(_DWORD *)(4LL * (int)i + a2);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d8
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(int *)(param_3 + (long)local_c * 4) =
*(int *)(param_1 + (long)local_c * 4) % *(int *)(param_2 + (long)local_c * 4);
}
return;
} |
6,357 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
in... | O1 | c | func0:
endbr64
mov %rdx,%r8
test %ecx,%ecx
jle 1194 <func0+0x2b>
lea -0x1(%rcx),%r9d
mov $0x0,%ecx
mov (%rdi,%rcx,4),%eax
cltd
idivl (%rsi,%rcx,4)
mov %edx,(%r8,%rcx,4)
mov %rcx,%rax
add $0x1,%rcx
cmp %r9,%rax
jne 117d <func0+0x14>
retq
| func0:
endbr64
mov r9, rdx
test ecx, ecx
jle short locret_1192
mov ecx, ecx
mov r8d, 0
loc_117C:
mov eax, [rdi+r8*4]
cdq
idiv dword ptr [rsi+r8*4]
mov [r9+r8*4], edx
add r8, 1
cmp r8, rcx
jnz short loc_117C
locret_1192:
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // r8
long long result; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
result = (unsigned int)(*(_DWORD *)(a1 + 4 * i) / *(_DWORD *)(a2 + 4 * i));
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) % *(... | func0:
ENDBR64
MOV R9,RDX
TEST ECX,ECX
JLE 0x00101192
MOV ECX,ECX
MOV R8D,0x0
LAB_0010117c:
MOV EAX,dword ptr [RDI + R8*0x4]
CDQ
IDIV dword ptr [RSI + R8*0x4]
MOV dword ptr [R9 + R8*0x4],EDX
ADD R8,0x1
CMP R8,RCX
JNZ 0x0010117c
LAB_00101192:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 4) = *(int *)(param_1 + uVar1 * 4) % *(int *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
return;
} |
6,358 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
in... | O2 | c | func0:
endbr64
mov %rdx,%r8
test %ecx,%ecx
jle 116f <func0+0x2f>
lea -0x1(%rcx),%r9d
xor %ecx,%ecx
nopl 0x0(%rax)
mov (%rdi,%rcx,4),%eax
cltd
idivl (%rsi,%rcx,4)
mov %rcx,%rax
mov %edx,(%r8,%rcx,4)
add $0x1,%rcx
cmp %r9,%rax
jne 1158 <func0+0x18>
retq
| func0:
endbr64
mov r9, rdx
test ecx, ecx
jle short locret_141E
movsxd rcx, ecx
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_1408:
mov eax, [rdi+r8*4]
cdq
idiv dword ptr [rsi+r8*4]
mov [r9+r8*4], edx
add r8, 1
cmp rcx, r8
jnz short loc_1408
locret_141E:
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // r8
long long result; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
result = (unsigned int)(*(_DWORD *)(a1 + 4 * i) / *(_DWORD *)(a2 + 4 * i));
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) % *(... | func0:
ENDBR64
MOV R9,RDX
TEST ECX,ECX
JLE 0x0010141e
MOVSXD RCX,ECX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101408:
MOV EAX,dword ptr [RDI + R8*0x4]
CDQ
IDIV dword ptr [RSI + R8*0x4]
MOV dword ptr [R9 + R8*0x4],EDX
ADD R8,0x1
CMP RCX,R8
JNZ 0x00101408
LAB_0010141e:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) % *(int *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
return;
} |
6,359 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(int test_tup1[], int test_tup2[], int res[], int size) {
for (int i = 0; i < size; i++) {
res[i] = test_tup1[i] % test_tup2[i];
}
}
| int main() {
int result[4];
int a1[] = {10, 4, 5, 6};
int b1[] = {5, 6, 7, 5};
int expected1[] = {0, 4, 5, 1};
func0(a1, b1, result, 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected1[i]);
}
int a2[] = {11, 5, 6, 7};
int b2[] = {6, 7, 8, 6};
in... | O3 | c | func0:
endbr64
mov %rdx,%r8
test %ecx,%ecx
jle 116f <func0+0x2f>
lea -0x1(%rcx),%r9d
xor %ecx,%ecx
nopl 0x0(%rax)
mov (%rdi,%rcx,4),%eax
cltd
idivl (%rsi,%rcx,4)
mov %rcx,%rax
mov %edx,(%r8,%rcx,4)
add $0x1,%rcx
cmp %rax,%r9
jne 1158 <func0+0x18>
retq
| func0:
endbr64
mov r8, rdi
mov r9, rdx
test ecx, ecx
jle short locret_1175
movsxd rcx, ecx
lea rdi, ds:0[rcx*4]
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1160:
mov eax, [r8+rcx]
cdq
idiv dword ptr [rsi+rcx]
mov [r9+rcx], edx
add rcx, 4
cmp rdi, rcx
jnz short loc_116... | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long v5; // rdi
long long v6; // rcx
long long result; // rax
if ( a4 > 0 )
{
v5 = 4LL * a4;
v6 = 0LL;
do
{
result = (unsigned int)(*(_DWORD *)(a1 + v6) / *(_DWORD *)(a2 + v6));
*(_DWORD *)(a3 + v6) = *(_DWO... | func0:
ENDBR64
MOV R8,RDI
MOV R9,RDX
TEST ECX,ECX
JLE 0x00101175
MOVSXD RCX,ECX
LEA RDI,[RCX*0x4]
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101160:
MOV EAX,dword ptr [R8 + RCX*0x1]
CDQ
IDIV dword ptr [RSI + RCX*0x1]
MOV dword ptr [R9 + RCX*0x1],EDX
ADD RCX,0x4
CMP RDI,RCX
JNZ 0x00101160
LAB_00101175:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1) = *(int *)(param_1 + lVar1) % *(int *)(param_2 + lVar1);
lVar1 = lVar1 + 4;
} while ((long)param_4 * 4 - lVar1 != 0);
}
return;
} |
6,360 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovle -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x4(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovge -0x18(%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_14], eax
mov edx, [rbp+var_18]
mov e... | long long func0(int a1, int a2, int a3)
{
int v3; // eax
int v4; // eax
int v6; // [rsp+8h] [rbp-14h]
v3 = a2;
if ( a1 <= a2 )
v3 = a1;
v6 = v3;
v4 = a1;
if ( a2 >= a1 )
v4 = a2;
if ( a3 >= v4 )
return (unsigned int)((a3 + v4 - 1) / v4);
if ( !a3 )
return 0LL;
if ( a3 == v6 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
MO... | int [16] func0(uint param_1,uint param_2,uint param_3)
{
long lVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
int auVar5 [16];
uVar2 = param_2;
if ((int)param_1 <= (int)param_2) {
uVar2 = param_1;
}
uVar4 = (ulong)param_2;
if ((int)param_1 <= (int)param_2) {
param_1 = param_2;
}
if ((i... |
6,361 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %edx,%ecx
jle 114f <func0+0x26>
mov %edx,%eax
test %edx,%edx
je 114e <func0+0x25>
cmp %esi,%edi
cmovg %esi,%edi
cmp %edx,%edi
setne %al
movzbl %al,%eax
add $0x1,%eax
retq
lea -0x1(%rcx,%rdx,1),%eax
cltd
idiv %ecx
retq
| func0:
endbr64
cmp edi, esi
mov ecx, esi
cmovge ecx, edi
cmp ecx, edx
jle short loc_114F
mov eax, edx
test edx, edx
jz short locret_114E
cmp edi, esi
cmovg edi, esi
cmp edi, edx
setnz al
movzx eax, al
add eax, 1
locret_114E:
retn
loc_114F:
lea eax, [rcx+rdx-1]
cdq
idiv... | long long func0(int a1, int a2, unsigned int a3)
{
int v3; // ecx
long long result; // rax
v3 = a2;
if ( a1 >= a2 )
v3 = a1;
if ( v3 <= (int)a3 )
return (unsigned int)((int)(v3 + a3 - 1) / v3);
result = a3;
if ( a3 )
{
if ( a1 > a2 )
a1 = a2;
return (unsigned int)(a1 != a3) + 1;
... | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
CMOVGE ECX,EDI
CMP ECX,EDX
JLE 0x0010114f
MOV EAX,EDX
TEST EDX,EDX
JZ 0x0010114e
CMP EDI,ESI
CMOVG EDI,ESI
CMP EDI,EDX
SETNZ AL
MOVZX EAX,AL
ADD EAX,0x1
LAB_0010114e:
RET
LAB_0010114f:
LEA EAX,[RCX + RDX*0x1 + -0x1]
CDQ
IDIV ECX
RET | int1 [16] func0(int param_1,int param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
int iVar3;
int iVar4;
int1 auVar5 [16];
int1 auVar6 [16];
iVar3 = param_2;
if (param_2 <= param_1) {
iVar3 = param_1;
}
iVar4 = (int)param_3;
if (iVar4 < iVar3) {
uVar2 = param_3 & 0xffffffff;
if (iV... |
6,362 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %edx,%ecx
jle 1168 <func0+0x28>
xor %eax,%eax
test %edx,%edx
je 1164 <func0+0x24>
cmp %esi,%edi
cmovg %esi,%edi
xor %eax,%eax
cmp %edx,%edi
setne %al
add $0x1,%eax
retq
nopl (%rax)
lea -0x1(%rcx,%rdx,1),%eax
cltd
idi... | func0:
endbr64
cmp edi, esi
mov ecx, esi
cmovge ecx, edi
cmp ecx, edx
jle short loc_1168
xor eax, eax
test edx, edx
jz short locret_1164
cmp edi, esi
cmovg edi, esi
xor eax, eax
cmp edi, edx
setnz al
add eax, 1
locret_1164:
retn
loc_1168:
lea eax, [rcx+rdx-1]
cdq
idi... | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
v3 = a2;
if ( a1 >= a2 )
v3 = a1;
if ( v3 <= a3 )
return (unsigned int)((v3 + a3 - 1) / v3);
result = 0LL;
if ( a3 )
{
if ( a1 > a2 )
a1 = a2;
return (unsigned int)(a1 != a3) + 1;
}
return resul... | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
CMOVGE ECX,EDI
CMP ECX,EDX
JLE 0x00101168
XOR EAX,EAX
TEST EDX,EDX
JZ 0x00101164
CMP EDI,ESI
CMOVG EDI,ESI
XOR EAX,EAX
CMP EDI,EDX
SETNZ AL
ADD EAX,0x1
LAB_00101164:
RET
LAB_00101168:
LEA EAX,[RCX + RDX*0x1 + -0x1]
CDQ
IDIV ECX
RET | int1 [16] func0(int param_1,int param_2,int8 param_3)
{
long lVar1;
ulong uVar2;
int iVar3;
int iVar4;
int1 auVar5 [16];
int1 auVar6 [16];
iVar3 = param_2;
if (param_2 <= param_1) {
iVar3 = param_1;
}
iVar4 = (int)param_3;
if (iVar4 < iVar3) {
uVar2 = 0;
if (iVar4 != 0) {
if... |
6,363 | func0 |
#include <assert.h>
| int func0(int a, int b, int d) {
int temp = a;
a = a < b ? a : b;
b = temp > b ? temp : b;
if (d >= b) {
return (d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
return 2;
}
| int main() {
assert(func0(3, 4, 11) == 3);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %edx,%ecx
jle 1168 <func0+0x28>
xor %eax,%eax
test %edx,%edx
je 1164 <func0+0x24>
cmp %esi,%edi
cmovg %esi,%edi
xor %eax,%eax
cmp %edx,%edi
setne %al
add $0x1,%eax
retq
nopl (%rax)
lea -0x1(%rcx,%rdx,1),%eax
cltd
idi... | func0:
endbr64
cmp edi, esi
mov ecx, esi
cmovge ecx, edi
cmp ecx, edx
jle short loc_1168
xor eax, eax
test edx, edx
jz short locret_1164
cmp edi, esi
cmovg edi, esi
xor eax, eax
cmp edi, edx
setnz al
add eax, 1
locret_1164:
retn
loc_1168:
lea eax, [rcx+rdx-1]
cdq
idi... | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
v3 = a2;
if ( a1 >= a2 )
v3 = a1;
if ( v3 <= a3 )
return (unsigned int)((v3 + a3 - 1) / v3);
result = 0LL;
if ( a3 )
{
if ( a1 > a2 )
a1 = a2;
return (unsigned int)(a1 != a3) + 1;
}
return resul... | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
CMOVGE ECX,EDI
CMP ECX,EDX
JLE 0x00101168
XOR EAX,EAX
TEST EDX,EDX
JZ 0x00101164
CMP EDI,ESI
CMOVG EDI,ESI
XOR EAX,EAX
CMP EDI,EDX
SETNZ AL
ADD EAX,0x1
LAB_00101164:
RET
LAB_00101168:
LEA EAX,[RCX + RDX*0x1 + -0x1]
CDQ
IDIV ECX
RET | int [16] func0(int param_1,int param_2,int8 param_3)
{
long lVar1;
ulong uVar2;
int iVar3;
int iVar4;
int auVar5 [16];
int auVar6 [16];
iVar3 = param_2;
if (param_2 <= param_1) {
iVar3 = param_1;
}
iVar4 = (int)param_3;
if (iVar4 < iVar3) {
uVar2 = 0;
if (iVar4 != 0) {
if (p... |
6,364 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(r... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1232 <func0+0x89>
mov -0xc(%rbp),%eax
cltq... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov eax, [rbp+var_24]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_123A
loc_11DE:
mov eax, [r... | double * func0(long long a1, long long a2, int a3)
{
int i; // [rsp+24h] [rbp-Ch]
double *v6; // [rsp+28h] [rbp-8h]
v6 = (double *)malloc(8LL * a3);
for ( i = 0; i < a3; ++i )
v6[i] = (double)*(int *)(4LL * i + a1) / (double)*(int *)(4LL * i + a2);
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010123a
LAB_001011de:
MOV EAX... | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_3 << 3);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
*(double *)((long)pvVar1 + (long)local_14 * 8) =
(double)*(int *)(param_1 + (long)local_14 * 4) /
(d... |
6,365 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(r... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rsi,%rbp
mov %edx,%r12d
movslq %edx,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 11fd <func0+0x54>
lea -0x1(%r12),%esi
mov $0x0,%edx
pxor %xmm0,%xmm0
cvtsi2sdl (%rbx,%rdx,4),%xmm0
pxor %xmm1,%xmm1
cvtsi2... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rsi
mov r12d, edx
movsxd rdi, edx
shl rdi, 3
call _malloc
test r12d, r12d
jle short loc_11F8
mov ecx, r12d
mov edx, 0
loc_11D3:
pxor xmm0, xmm0
cvtsi2sd xmm0, dword ptr [rbx+rdx*4]
pxor xmm1, xmm1
cvtsi2sd ... | long long func0(long long a1, long long a2, int a3)
{
long long result; // rax
long long v5; // rdx
result = malloc(8LL * a3);
if ( a3 > 0 )
{
v5 = 0LL;
do
{
*(double *)(result + 8 * v5) = (double)*(int *)(a1 + 4 * v5) / (double)*(int *)(a2 + 4 * v5);
++v5;
}
while ( v5 != a3... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RBP,RSI
MOV R12D,EDX
MOVSXD RDI,EDX
SHL RDI,0x3
CALL 0x001010b0
TEST R12D,R12D
JLE 0x001011f8
MOV ECX,R12D
MOV EDX,0x0
LAB_001011d3:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBX + RDX*0x4]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + RDX*0x4]
DIVSD XMM0,XMM1
MOV... | void func0(long param_1,long param_2,uint param_3)
{
void *pvVar1;
ulong uVar2;
pvVar1 = malloc((long)(int)param_3 << 3);
if (0 < (int)param_3) {
uVar2 = 0;
do {
*(double *)((long)pvVar1 + uVar2 * 8) =
(double)*(int *)(param_1 + uVar2 * 4) / (double)*(int *)(param_2 + uVar2 * 4);
... |
6,366 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(r... | O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
movslq %edx,%rdi
mov %rdi,%r12
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 13f8 <func0+0x58>
lea -0x1(%r12),%esi
xor %edx,%edx
nopl 0x0(%rax)
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
mov %rdx,%rcx
cvt... | func0:
endbr64
push r13
push r12
movsxd r12, edx
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
lea rdi, ds:0[r12*8]
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_13F5
xor edx, edx
nop dword ptr [rax+rax+00h]
loc_13D0:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xm... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // r12
long long result; // rax
long long i; // rdx
v3 = a3;
result = malloc(8LL * a3);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
*(double *)(result + 8 * i) = (double)*(int *)(a1 + 4 * i) / (double)*(int *)(a2 + 4 * ... | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,EDX
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
LEA RDI,[R12*0x8]
SUB RSP,0x8
CALL 0x001010b0
TEST R12D,R12D
JLE 0x001013f5
XOR EDX,EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [RBX + RDX*0x4]
CVTSI2SD XMM1,dword ptr [RBP... | void func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
long lVar2;
pvVar1 = malloc((long)param_3 * 8);
if (0 < param_3) {
lVar2 = 0;
do {
*(double *)((long)pvVar1 + lVar2 * 8) =
(double)*(int *)(param_1 + lVar2 * 4) / (double)*(int *)(param_2 + lVar2 * 4);
lVar2 = l... |
6,367 | func0 | #include <assert.h>
#include <stdlib.h>
| double* func0(int* nums1, int* nums2, int size) {
double* result = malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
result[i] = (double)nums1[i] / nums2[i];
}
return result;
}
| int main() {
int nums1a[] = {4, 5, 6}, nums2a[] = {1, 2, 3};
double* result1 = func0(nums1a, nums2a, 3);
assert(result1[0] == 4.0 && result1[1] == 2.5 && result1[2] == 2.0);
free(result1);
int nums1b[] = {3, 2}, nums2b[] = {1, 4};
double* result2 = func0(nums1b, nums2b, 2);
assert(r... | O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %edx,%rdi
push %rbx
mov %rdi,%r12
shl $0x3,%rdi
mov %rsi,%rbx
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 149b <func0+0xfb>
lea -0x1(%r12),%edx
cmp $0x2,%edx
jbe 14a0 <func0+0x100>
mov %r12d,%edx
xor %ecx,%ecx
shr $0x2,%e... | func0:
endbr64
push r12
push rbp
mov rbp, rdi
movsxd rdi, edx
push rbx
mov r12, rdi
shl rdi, 3; size
mov rbx, rsi
call _malloc
mov rdx, rax
test r12d, r12d
jle loc_14A1
lea eax, [r12-1]
cmp eax, 2
jbe loc_14A9
mov ecx, r12d
xor eax, eax
shr ecx, 2
shl ... | char * func0(long long a1, long long a2, int a3)
{
char *v6; // rdx
long long v7; // rax
__m128i v8; // xmm2
__m128d v9; // xmm1
int v10; // ecx
long long v11; // rsi
long long v12; // rdi
v6 = (char *)malloc(8LL * a3);
if ( a3 > 0 )
{
if ( (unsigned int)(a3 - 1) <= 2 )
{
v10 = 0;
... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,EDX
PUSH RBX
MOV R12,RDI
SHL RDI,0x3
MOV RBX,RSI
CALL 0x001010b0
MOV RDX,RAX
TEST R12D,R12D
JLE 0x001014a1
LEA EAX,[R12 + -0x1]
CMP EAX,0x2
JBE 0x001014a9
MOV ECX,R12D
XOR EAX,EAX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d8:
CVTDQ2PD XMM1,qw... | void * func0(long param_1,long param_2,uint param_3)
{
int iVar1;
int iVar2;
void *pvVar3;
long lVar4;
long lVar5;
uint uVar6;
ulong uVar7;
int auVar8 [16];
int auVar9 [16];
int auVar10 [16];
int auVar11 [16];
uVar7 = (ulong)(int)param_3;
pvVar3 = malloc(uVar7 << 3);
if (0 < (int)param_3... |
6,368 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
... | int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x41c(%rbp)
movl $0x0,-0x418(%rbp)
movl $0x0,-0x414(%rbp)
jmpq 12b2 <func0+0xe9>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x414(%rbp),... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+var_428], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_41C], 0
mov [rbp+var_418], 0
mov [rbp+var_414], 0
jmp loc_12B2
loc_1211:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_414... | char * func0(long long a1)
{
int v1; // eax
int v2; // eax
int v4; // [rsp+14h] [rbp-41Ch]
int v5; // [rsp+18h] [rbp-418h]
int i; // [rsp+1Ch] [rbp-414h]
char src[1032]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v8; // [rsp+428h] [rbp-8h]
v8 = __readfsqword(0x28u);
v4 = 0;
v5 = 0;
for ( i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x41c],0x0
MOV dword ptr [RBP + -0x418],0x0
MOV dword ptr [RBP + -0x414],0x0
JMP 0x001012b2
LAB_00101211:
CALL 0x001010d0
MOV RAX,qword ptr [RAX... | int1 * func0(long param_1)
{
ushort **ppuVar1;
long in_FS_OFFSET;
int local_424;
int local_420;
int local_41c;
char local_418 [1032];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_424 = 0;
local_420 = 0;
for (local_41c = 0; *(char *)(param_1 + local_41c) != '\0'; local_41c = ... |
6,369 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
... | int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x418,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
movzbl (%rdi),%ebx
test %bl,%bl
je 1220 <func0+0x77>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov $0x0,%r8d
mov $0x0,%esi
lea 0x2e52(%rip),%r9
jmp 1206 ... | func0:
endbr64
push rbp
push rbx
sub rsp, 418h
mov rax, fs:28h
mov [rsp+428h+var_20], rax
xor eax, eax
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_1240
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
mov r8d, 0
mov esi, 0
lea r9, res_1
jmp short loc_12... | _BYTE * func0(char *a1, long long a2, long long a3, long long a4, long long a5, _BYTE *a6)
{
char v6; // bl
long long *v7; // rax
char *v8; // rdi
int v9; // r8d
int v10; // esi
_BYTE v12[1032]; // [rsp+0h] [rbp-428h] BYREF
unsigned long long v13; // [rsp+408h] [rbp-20h]
v13 = __readfsqword(0x28u);
v... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x418
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101240
MOV RBP,RDI
CALL 0x001010d0
LEA RDI,[RBP + 0x1]
MOV R8D,0x0
MOV ESI,0x0
LEA R9,[0x104040]
JMP 0x00101226
LAB_00101210:
MOVSXD RDX,ESI
MOV byte ptr [R9 ... | int1 * func0(char *param_1)
{
ushort **ppuVar1;
char cVar2;
int iVar3;
char *pcVar4;
int iVar5;
long in_FS_OFFSET;
char local_428 [1032];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar2 = *param_1;
if (cVar2 == '\0') {
iVar5 = 0;
iVar3 = 0;
}
else {
ppuVar1 = __... |
6,370 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
... | int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
... | O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x418,%rsp
movzbl (%rdi),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
test %bl,%bl
je 1360 <func0+0xd0>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %r8d,%r8d
xor %esi,%esi
lea 0x2d6d(%rip),%r9
jmp 12ee ... | func0:
endbr64
push rbp
push rbx
sub rsp, 418h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+428h+var_20], rax
xor eax, eax
test bl, bl
jz loc_1368
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor r8d, r8d
xor esi, esi
lea r9, res_1
jmp short loc_12FE... | long long func0(char *a1)
{
char v1; // bl
_QWORD *v2; // rax
_BYTE *v3; // rdi
int v4; // r8d
int v5; // esi
long long v6; // rdx
long long v7; // rdx
_BYTE v9[1032]; // [rsp+0h] [rbp-428h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-20h]
v1 = *a1;
v10 = __readfsqword(0x28u);
if ( v1 )
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x418
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
TEST BL,BL
JZ 0x00101368
MOV RBP,RDI
CALL 0x001010d0
LEA RDI,[RBP + 0x1]
XOR R8D,R8D
XOR ESI,ESI
LEA R9,[0x104040]
JMP 0x001012fe
LAB_001012e8:
MOVSXD RDX,R8D
ADD RDI,0x1
ADD R... | int8 func0(char *param_1)
{
ushort **ppuVar1;
int8 uVar2;
long lVar3;
char cVar4;
int iVar5;
char *pcVar6;
int iVar7;
long in_FS_OFFSET;
char local_428 [1032];
long local_20;
cVar4 = *param_1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar4 == '\0') {
iVar7 = 0;
iVar5 = 0;
}... |
6,371 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* test_str) {
static char res[1024];
char dig[1024];
int i = 0, j = 0;
for (int idx = 0; test_str[idx] != '\0'; idx++) {
if (isdigit(test_str[idx])) {
dig[j++] = test_str[idx];
} else {
res[i++] = test_str[idx];
}
}
dig[j] = '\0';
res[i] = '\0';
... | int main() {
assert(strcmp(func0("I1love143you55three3000thousand"), "Iloveyouthreethousand1143553000") == 0);
assert(strcmp(func0("Avengers124Assemble"), "AvengersAssemble124") == 0);
assert(strcmp(func0("Its11our12path13to14see15things16do17things"), "Itsourpathtoseethingsdothings11121314151617") == 0);
... | O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x418,%rsp
movzbl (%rdi),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
test %bl,%bl
je 1328 <func0+0x98>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %ecx,%ecx
xor %edx,%edx
mov (%rax),%r8
lea 0x2d6f(%rip... | func0:
endbr64
push rbp
push rbx
sub rsp, 418h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+428h+var_20], rax
xor eax, eax
test bl, bl
jz loc_1370
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor edx, edx
xor ecx, ecx
mov r8, [rax]
lea r9, res_1
nop ... | long long func0(char *a1)
{
char v1; // bl
const unsigned __int16 **v2; // rax
_BYTE *v3; // rdi
long long v4; // rdx
long long v5; // rcx
const unsigned __int16 *v6; // r8
int v7; // esi
_BYTE v9[1032]; // [rsp+0h] [rbp-428h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-20h]
v1 = *a1;
v10 =... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x418
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
TEST BL,BL
JZ 0x00101370
MOV RBP,RDI
CALL 0x001010d0
LEA RDI,[RBP + 0x1]
XOR EDX,EDX
XOR ECX,ECX
MOV R8,qword ptr [RAX]
LEA R9,[0x104040]
NOP dword ptr [RAX]
LAB_001012e8:
MOVS... | int8 func0(char *param_1)
{
ushort **ppuVar1;
int8 uVar2;
long lVar3;
long lVar4;
char cVar5;
int iVar6;
char *pcVar7;
ushort *puVar8;
long in_FS_OFFSET;
char local_428 [1032];
long local_20;
cVar5 = *param_1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar5 == '\0') {
lVar4 = 0;... |
6,372 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
... | int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x4c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*... | long long func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[4]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+Ch] [rbp-3Ch]
long long v7; // [rsp+10h] [rbp-38h]
int i; // [rsp+1Ch] [rbp-2Ch]
int v9; // [rsp+20h] [rbp-28h]
int j; // [rsp+24h] [rbp-24h]
unsigned int v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],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 + -0x3c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4... | int func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
long local_40;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_40 = param_1;
loc... |
6,373 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
... | int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov r10, rdi
mov r9d, esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, esi
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
m... | long long func0(long long a1, int a2)
{
signed long long v3; // rax
void *v4; // rsp
int v5; // r12d
long long v6; // rbx
int v7; // r8d
long long v8; // rcx
int v9; // edi
unsigned int v10; // edx
int *v11; // rax
long long v13; // [rsp+0h] [rbp-38h]
unsigned int v14; // [rsp+8h] [rbp-30h] BYREF... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R10,RDI
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011ad:
CMP RSP,RDX
JZ 0x001011c4
SUB... | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
int *piVar5;
long lVar6;
long lVar7;
int1 *puVar8;
int iVar9;
int iVar10;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)param_2 * 4 + 0... |
6,374 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
... | int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffff... | func0:
endbr64
push rbp
mov r10, rdi
mov r9d, esi
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub ... | long long func0(long long a1, int a2)
{
long long v3; // rdx
unsigned int *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
int v8; // r12d
long long v9; // rbx
int v10; // edi
long long v11; // rcx
int v12; // r8d
int v13; // r8d
unsigned int v14; // r8d
_BYTE *v15; ... | func0:
ENDBR64
PUSH RBP
MOV R10,RDI
MOV R9D,ESI
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101320
LAB_0010... | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int1 *puVar4;
int *piVar5;
long lVar6;
ulong uVar7;
uint uVar8;
long lVar9;
int1 *puVar10;
int iVar12;
int iVar13;
uint uVar14;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar11;
puVar10 = ... |
6,375 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n) {
int dp[n];
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
int mxm = 0;
for (int j = i + 1; j < n; j++) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
if (mxm < dp[j]) {
mxm = dp[j];
}
... | int main() {
int array1[] = {1, 3, 6, 13, 17, 18};
int array2[] = {10, 5, 3, 15, 20};
int array3[] = {18, 1, 3, 6, 13, 17};
assert(func0(array1, 6) == 4);
assert(func0(array2, 5) == 3);
assert(func0(array3, 6) == 4);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xf... | func0:
endbr64
push rbp
mov r10, rdi
mov r9d, esi
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFF... | long long func0(long long a1, int a2)
{
long long v4; // rdx
unsigned int *v5; // rcx
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned int v9; // r13d
unsigned int v10; // r14d
long long v11; // rbx
int v12; // r12d
int v13; // edi
long long v14; // rcx
signed int v15; //... | func0:
ENDBR64
PUSH RBP
MOV R10,RDI
MOV R9D,ESI
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012f2... | uint func0(long param_1,int param_2)
{
uint *puVar1;
int iVar2;
int iVar3;
long lVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
int *puVar8;
ulong uVar9;
long lVar10;
int *puVar11;
int iVar13;
uint uVar14;
uint uVar15;
uint uVar16;
long in_FS_OFFSET;
uint uVar17;
uint uVar18;
uin... |
6,376 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremente... | int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / siz... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1130 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x28(%rbp)
jmpq 13c5 <func0+0x15c>
callq 1170 ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_28], 0
jmp loc_13CB
loc_12A1:
call ... | _QWORD * func0(long long a1, int a2, int a3)
{
int i; // [rsp+18h] [rbp-28h]
int v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+24h] [rbp-1Ch]
_QWORD *v8; // [rsp+28h] [rbp-18h]
v8 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
if ( ((*__ctype_b_loc())[**(char **)(8LL * i + a1)] & 0x800) != 0 )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001013cb
LAB_001012... | void * func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
void *pvVar3;
ushort **ppuVar4;
void *pvVar5;
char *pcVar6;
int local_30;
pvVar3 = malloc((long)param_2 << 3);
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
ppuVar4 = __ctype_b_loc();
if (((*ppuV... |
6,377 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremente... | int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / siz... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r13
mov %esi,%ebx
mov %edx,0xc(%rsp)
movslq %esi,%rdi
shl $0x3,%rdi
callq 1120 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1331 <func0+0xe8>
callq 1140 <__ctype_b_loc@plt>
mov %r... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r14, rdi
mov r12d, esi
mov [rsp+48h+var_44], edx
movsxd rdi, esi
shl rdi, 3
call _malloc
mov [rsp+48h+var_40], rax
test r12d, r12d
jle loc_135C
mov rbp, rax
call ___ctype_b_l... | long long func0(char **a1, int a2, int a3)
{
long long v3; // rax
_QWORD *v4; // rbp
_QWORD *v5; // r13
char **v6; // rbx
long long v7; // r12
int v8; // eax
long long v9; // rax
long long v12; // [rsp+8h] [rbp-40h]
v3 = malloc(8LL * a2);
v12 = v3;
if ( a2 > 0 )
{
v4 = (_QWORD *)v3;
v5... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV R12D,ESI
MOV dword ptr [RSP + 0x4],EDX
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x0010135c
MOV RBP,RAX
CALL 0x00101160
MOV R13,RAX
MOV RBX,R14
LEA EAX,[R12 + -0x1]
LEA R15... | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int iVar2;
int8 *puVar3;
ushort **ppuVar4;
char *pcVar5;
long lVar6;
void *pvVar7;
int8 *puVar8;
int iVar9;
puVar3 = (int8 *)malloc((long)param_2 << 3);
if (0 < param_2) {
ppuVar4 = __ctype_b_loc();
puVar1 = param_1 + ... |
6,378 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremente... | int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / siz... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x3,%rdi
sub $0x18,%rsp
mov %edx,0xc(%rsp)
callq 1120 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 16e8 <func0+0xe8>
callq 1140 <__ctype_b_loc@plt>
lea -0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov r12, rdi
shl rdi, 3
sub rsp, 18h
mov [rsp+48h+var_44], edx
call _malloc
mov [rsp+48h+var_40], rax
test r12d, r12d
jle loc_16C8
mov rbp, rax
call ___ctype_b_lo... | long long func0(char **a1, int a2, int a3)
{
char **v3; // rbx
long long v4; // rax
long long v5; // rbp
_QWORD *v6; // r15
long long v7; // r13
unsigned int v8; // r14d
int v9; // eax
long long v10; // rax
char *v11; // rdi
long long v14; // [rsp+8h] [rbp-40h]
v3 = a1;
v4 = malloc(8LL * a2);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV R12,RDI
SHL RDI,0x3
SUB RSP,0x18
MOV dword ptr [RSP + 0x4],EDX
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x001016c8
MOV RBP,RAX
CALL 0x00101160
MOV R15,RAX
LEA EAX,[R12 + -0x1]
LEA R12,[0x102004]
L... | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int iVar2;
int8 *puVar3;
ushort **ppuVar4;
long lVar5;
void *pvVar6;
char *pcVar7;
int8 *puVar8;
int iVar9;
puVar3 = (int8 *)malloc((long)param_2 << 3);
if (0 < param_2) {
ppuVar4 = __ctype_b_loc();
puVar1 = param_1 + ... |
6,379 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char** func0(char** test_list, int size, int K) {
char** res = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
if (isdigit(test_list[i][0])) {
int num = atoi(test_list[i]);
int incremented = num + K;
int length = snprintf(NULL, 0, "%d", incremente... | int main() {
char* test1[] = {"MSM", "234", "is", "98", "123", "best", "4"};
char* test2[] = {"Dart", "356", "is", "88", "169", "Super", "6"};
char* test3[] = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
int size1 = sizeof(test1) / sizeof(test1[0]);
int size2 = sizeof(test2) / siz... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x3,%rdi
sub $0x18,%rsp
mov %edx,0xc(%rsp)
callq 1120 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1728 <func0+0xe8>
callq 1140 <__ctype_b_loc@plt>
lea -0... | func0:
endbr64
push r15
push r14
push r13
push r12
movsxd r12, esi
push rbp
mov rbp, r12
shl r12, 3
push rbx
mov rbx, rdi
mov rdi, r12; size
sub rsp, 18h
mov [rsp+48h+var_44], edx
call _malloc
mov [rsp+48h+var_40], rax
test ebp, ebp
jle loc_170B
mov r14, rax
... | void * func0(const char **a1, int a2, int a3)
{
const char **v3; // rbx
void *v4; // rax
const char **v5; // r12
_QWORD *v6; // rbp
const unsigned __int16 **v7; // r15
unsigned int v8; // r13d
size_t v9; // r14
void *v10; // rax
const char *v11; // rdi
void *v14; // [rsp+8h] [rbp-40h]
v3 = a1;
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,R12
SHL R12,0x3
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x18
MOV dword ptr [RSP + 0x4],EDX
CALL 0x00101140
MOV qword ptr [RSP + 0x8],RAX
TEST EBP,EBP
JLE 0x0010170b
MOV R14,RAX
ADD R12,RBX
CALL 0x00101160
MOV RBP,R14
MOV R15,RAX
JMP 0x0... | int8 * func0(int8 *param_1,int param_2,int param_3)
{
int iVar1;
int8 *puVar2;
ushort **ppuVar3;
long lVar4;
void *pvVar5;
char *pcVar6;
int8 *puVar7;
int8 *puVar8;
int iVar9;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar8 = param_1 + param_2;
ppuVar3 = __ctype_b... |
6,380 | func0 |
#include <assert.h>
| float func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 = ... | int main() {
int arr1_1[] = {1, 12, 15, 26, 38};
int arr2_1[] = {2, 13, 17, 30, 45};
int arr1_2[] = {2, 4, 8, 9};
int arr2_2[] = {7, 13, 19, 28};
int arr1_3[] = {3, 6, 14, 23, 36, 42};
int arr2_3[] = {2, 18, 27, 39, 49, 55};
assert(func0(arr1_1, arr2_1, 5) == 16.0);
assert(func... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1258 <func0+0xef>
addl $0x1,-0x4(%rbp)
mov -0x14(%rbp),%eax
c... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0FFFFFFFFh
mov [rbp+var_8], 0FFFFFFFFh
mov [rbp+var_4], 0
jmp loc_1258
loc_11A4:
add [rbp+var_4], 1
mov eax, ... | float func0(int *a1, int *a2, int a3)
{
int v4; // [rsp+20h] [rbp-14h]
int v5; // [rsp+24h] [rbp-10h]
int v6; // [rsp+28h] [rbp-Ch]
int v7; // [rsp+2Ch] [rbp-8h]
int v8; // [rsp+30h] [rbp-4h]
v4 = 0;
v5 = 0;
v6 = -1;
v7 = -1;
v8 = 0;
while ( a3 >= v8 )
{
++v8;
if ( v4 == a3 )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0xffffffff
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101258
LA... | int8 func0(int *param_1,int *param_2,int param_3)
{
double dVar1;
int local_1c;
int local_18;
int local_14;
int local_10;
int local_c;
local_1c = 0;
local_18 = 0;
local_14 = -1;
local_10 = -1;
local_c = 0;
do {
if (param_3 < local_c) {
LAB_00101264:
dVar1 = (double)(local_10 + loca... |
6,381 | func0 |
#include <assert.h>
| float func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 = ... | int main() {
int arr1_1[] = {1, 12, 15, 26, 38};
int arr2_1[] = {2, 13, 17, 30, 45};
int arr1_2[] = {2, 4, 8, 9};
int arr2_2[] = {7, 13, 19, 28};
int arr1_3[] = {3, 6, 14, 23, 36, 42};
int arr2_3[] = {2, 18, 27, 39, 49, 55};
assert(func0(arr1_1, arr2_1, 5) == 16.0);
assert(func... | O1 | c | func0:
endbr64
test %edx,%edx
js 11e8 <func0+0x7f>
je 118c <func0+0x23>
mov $0x1,%r9d
mov $0xffffffff,%r11d
mov $0x0,%r8d
mov $0x0,%ecx
jmp 11ce <func0+0x65>
mov $0xffffffff,%eax
mov %eax,%r11d
mov (%rsi),%eax
add %r11d,%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd 0xf0f(%rip),... | func0:
endbr64
test edx, edx
js short loc_11E9
jz short loc_118C
mov r9d, 1
mov r11d, 0FFFFFFFFh
mov r8d, 0
mov ecx, 0
jmp short loc_11CF
loc_118C:
mov eax, 0FFFFFFFFh
loc_1191:
mov r11d, eax
mov eax, [rsi]
loc_1196:
add r11d, eax
pxor xmm0, xmm0
cvtsi2sd xmm0, r11d
m... | float func0(int *a1, int *a2, int a3)
{
int v3; // r9d
int v4; // r11d
int v5; // r8d
int v6; // ecx
int v7; // eax
int v9; // r10d
if ( a3 < 0 )
{
v7 = -1;
v4 = -1;
}
else if ( a3 )
{
v3 = 1;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
v9 = a1[v6];
v7 = a2... | func0:
ENDBR64
TEST EDX,EDX
JS 0x001011e9
JZ 0x0010118c
MOV R9D,0x1
MOV R11D,0xffffffff
MOV R8D,0x0
MOV ECX,0x0
JMP 0x001011cf
LAB_0010118c:
MOV EAX,0xffffffff
LAB_00101191:
MOV R11D,EAX
MOV EAX,dword ptr [RSI]
LAB_00101196:
ADD R11D,EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,R11D
MULSD XMM0,qword ptr [0x00102098]
CVTSD2SS XMM0,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 func0(int *param_1,int *param_2,int param_3)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
double dVar8;
if (param_3 < 0) {
iVar2 = -1;
iVar7 = -1;
}
else if (pa... |
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.