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,182 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void print_array(int arr[], int size) {
printf("[");
for (int i = 0; i < size; i++) {
printf("%d", arr[i]);
if (i < size - 1) printf(", ");
}
printf("]\n");
}
int arrays_equal(int a[], int b[], int sizeA, int sizeB... | int* func0(int nums[], int size, int *returnSize) {
int *result = (int*)malloc(size * sizeof(int));
int k = 0;
for (int i = 0; i < size; i++) {
int count = 0;
for (int j = 0; j < size; j++) {
if (nums[i] == nums[j]) {
count++;
}
}
... | int main() {
int sz;
int testArr1[] = {1, 2, 3, 2, 3, 4, 5};
int expected1[] = {1, 4, 5};
int* result1 = func0(testArr1, 7, &sz);
assert(arrays_equal(result1, expected1, sz, 3));
int testArr2[] = {1, 2, 3, 2, 4, 5};
int expected2[] = {1, 3, 4, 5};
int* result2 = func0(tes... | O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 1100 <malloc@plt>
test %ebp,%ebp
jle 15b6 <func0+0x76>
lea -0x1(%rbp),%edx
mov %rbx,%r10
xor %r11d,%r11d
lea 0x4(%rbx,%rdx,4),%r9
mov (%r10),%r8d
mov %rbx... | func0:
endbr64
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 2
call _malloc
test ebp, ebp
jle short loc_15B4
lea edx, [rbp-1]
mov r9, rbx
xor r10d, r10d
lea r8, [rbx+rdx*4+4]
nop
loc_1570:
mov edi, [r9]
mov rdx, rbx... | long long func0(int *a1, int a2, _DWORD *a3)
{
long long result; // rax
int *v6; // r9
int v7; // r10d
long long v8; // r8
int v9; // edi
int *v10; // rdx
int v11; // ecx
int v12; // esi
long long v13; // rdx
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
... | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x2
CALL 0x00101100
TEST EBP,EBP
JLE 0x001015b4
LEA EDX,[RBP + -0x1]
MOV R9,RBX
XOR R10D,R10D
LEA R8,[RBX + RDX*0x4 + 0x4]
NOP
LAB_00101570:
MOV EDI,dword ptr [R9]
MOV RDX,RBX
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
L... | void func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
int iVar3;
int *piVar4;
long lVar5;
int *piVar6;
int iVar7;
pvVar2 = malloc((long)param_2 << 2);
if (0 < param_2) {
iVar7 = 0;
piVar6 = param_1;
do {
iVar3 = 0;
piVar4 = param_1;
do {
... |
6,183 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void print_array(int arr[], int size) {
printf("[");
for (int i = 0; i < size; i++) {
printf("%d", arr[i]);
if (i < size - 1) printf(", ");
}
printf("]\n");
}
int arrays_equal(int a[], int b[], int sizeA, int sizeB... | int* func0(int nums[], int size, int *returnSize) {
int *result = (int*)malloc(size * sizeof(int));
int k = 0;
for (int i = 0; i < size; i++) {
int count = 0;
for (int j = 0; j < size; j++) {
if (nums[i] == nums[j]) {
count++;
}
}
... | int main() {
int sz;
int testArr1[] = {1, 2, 3, 2, 3, 4, 5};
int expected1[] = {1, 4, 5};
int* result1 = func0(testArr1, 7, &sz);
assert(arrays_equal(result1, expected1, sz, 3));
int testArr2[] = {1, 2, 3, 2, 4, 5};
int expected2[] = {1, 3, 4, 5};
int* result2 = func0(tes... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
sub $0x8,%rsp
callq 1100 <malloc@plt>
mov %rax,%r13
test %ebp,%ebp
jle 16ca <func0+0x14a>
mov %ebp,%edi
lea -0x1(%rbp),%edx
mov ... | func0:
endbr64
push r15
movsxd r9, esi
push r14
lea r14, ds:0[r9*4]
push r13
push r12
mov r12, rdx
push rbp
mov rbp, r9
push rbx
mov rbx, rdi
mov rdi, r14; size
sub rsp, 8
call _malloc
mov r13, rax
test ebp, ebp
jle loc_1686
mov edx, ebp
mov r8d, ebp
lea ... | _DWORD * func0(unsigned int *a1, int a2, _DWORD *a3)
{
const __m128i *v5; // rbx
_DWORD *v6; // r13
unsigned int *v7; // r9
int v8; // r10d
unsigned int v9; // esi
const __m128i *v10; // rax
__m128i v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm0
int v14; // ecx
__m128i v15; // xmm1
int v... | func0:
ENDBR64
PUSH R15
MOVSXD R9,ESI
PUSH R14
LEA R14,[R9*0x4]
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,R9
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
SUB RSP,0x8
CALL 0x00101100
MOV R13,RAX
TEST EBP,EBP
JLE 0x00101686
MOV EDX,EBP
MOV R8D,EBP
LEA R9,[R14 + RBX*0x1]
MOV RDI,RBX
SHR EDX,0x2
LEA R11D,[RBP + -0x1]
AND R8D,0xff... | void * func0(int *param_1,uint param_2,int *param_3)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
void *pvVar6;
int *piVar7;
long lVar8;
uint uVar9;
int *piVar10;
ulong uVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
uVar11 = (ulong)(int)param_... |
6,184 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1c0,%rsp
mov %rdi,-0x1b8(%rbp)
mov %esi,-0x1bc(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x1,-0x1a8(%rbp)
lea -0x1a0(%rbp),%rdx
mov $0x0,%eax
mov $0x32,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
mov %rdi,%rdx
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1C0h
mov [rbp+var_1B8], rdi
mov [rbp+var_1BC], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_1A8], 1
lea rdx, [rbp+var_1A0]
mov eax, 0
mov ecx, 32h ; '2'
mov rdi, rdx
rep stosq
mov rdx, rdi
mov ... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-1A8h]
int i; // [rsp+1Ch] [rbp-1A4h]
_DWORD v5[102]; // [rsp+20h] [rbp-1A0h] BYREF
unsigned long long v6; // [rsp+1B8h] [rbp-8h]
v6 = __readfsqword(0x28u);
v3 = 1;
memset(v5, 0, 404);
for ( i = 0; i < a2; ++i )
{
if ( !v5... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1c0
MOV qword ptr [RBP + -0x1b8],RDI
MOV dword ptr [RBP + -0x1bc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x1a8],0x1
LEA RDX,[RBP + -0x1a0]
MOV EAX,0x0
MOV ECX,0x32
MOV RDI,RDX
STOSQ.REP RDI
MOV RDX,RDI
MOV dword ptr ... | int func0(long param_1,int param_2)
{
long lVar1;
int *piVar2;
long in_FS_OFFSET;
int local_1b0;
int local_1ac;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1b0 = 1;
piVar2 = local_1a8;
for (lVar1 = 0x32; lVar1 != 0; lVar1 = lVar1 + -1) {
piVar2[0] =... |
6,185 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x32,%ecx
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %esi,%esi
jle 11d1 <func0+0x68>
mov %rdx,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdx,%rcx,4),%rdi
mov $0x1,%esi
... | func0:
endbr64
sub rsp, 1A8h
mov rdx, rdi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 32h ; '2'
rep stosq
mov dword ptr [rdi], 0
test esi, esi
jle short loc_11D1
mov rax, rdx
lea ecx, [rsi-1]
lea rdi, [rdx+rcx*4+4]
mov esi, 1
jmp ... | long long func0(int *a1, int a2)
{
int *v2; // rax
long long v3; // rdi
unsigned int v4; // esi
int v5; // edx
_DWORD v7[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v8; // [rsp+198h] [rbp-10h]
v8 = __readfsqword(0x28u);
memset(v7, 0, 404);
if ( a2 <= 0 )
{
return 1;
}
else
{
... | func0:
ENDBR64
SUB RSP,0x1a8
MOV RDX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x32
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST ESI,ESI
JLE 0x001011d1
MOV RAX,RDX
LEA ECX,[RSI + -0x1]
LEA RDI,[RDX + RCX*0x4 + 0x4]
MOV ESI,0x1
JMP 0x001011ba
LAB_001011b1:
ADD RAX,0x4
... | int func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
int iVar3;
int *piVar4;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = local_1a8;
for (lVar2 = 0x32; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (i... |
6,186 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %rdi,%rdx
mov $0x32,%ecx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %esi,%esi
jle 1430 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdx,%rdi
mov $0x1,%r8d
lea 0x4(%rdx,%rax,4),%rcx
... | func0:
endbr64
sub rsp, 1A8h
mov rdx, rdi
mov ecx, 32h ; '2'
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test esi, esi
jle short loc_1360
lea eax, [rsi-1]
mov rdi, rdx
mov r8d, 1
lea rcx, [rdx+rax*4+4]
nop ... | long long func0(int *a1, int a2)
{
int *v2; // rdx
unsigned int v3; // r8d
long long v4; // rax
_DWORD v6[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v7; // [rsp+198h] [rbp-10h]
v2 = a1;
v7 = __readfsqword(0x28u);
memset(v6, 0, 404);
if ( a2 <= 0 )
{
return 1;
}
else
{
v3 =... | func0:
ENDBR64
SUB RSP,0x1a8
MOV RDX,RDI
MOV ECX,0x32
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST ESI,ESI
JLE 0x00101360
LEA EAX,[RSI + -0x1]
MOV RDI,RDX
MOV R8D,0x1
LEA RCX,[RDX + RAX*0x4 + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101320... | int func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
int *piVar3;
int iVar4;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_1a8;
for (lVar2 = 0x32; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar3 = 0;
piVar3 = (i... |
6,187 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int list_data[], int size) {
int p = 1;
int exists[101] = {0}; // assuming numbers are in the range 0-100
for (int i = 0; i < size; i++) {
if (!exists[list_data[i]]) {
p *= list_data[i];
exists[list_data[i]] = 1;
}
}
return p;
}
| int main() {
int data1[] = {10, 20, 30, 40, 20, 50, 60, 40};
assert(func0(data1, 8) == 720000000);
int data2[] = {1, 2, 3, 1};
assert(func0(data2, 4) == 6);
int data3[] = {7, 8, 9, 0, 1, 1};
assert(func0(data3, 6) == 0);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %rdi,%rdx
mov $0x32,%ecx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,(%rdi)
test %esi,%esi
jle 14a0 <func0+0x90>
lea -0x1(%rsi),%eax
mov %rdx,%rdi
mov $0x1,%r8d
lea 0x4(%rdx,%rax,4),%rcx
... | func0:
endbr64
sub rsp, 1A8h
mov rdx, rdi
mov ecx, 32h ; '2'
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov dword ptr [rdi], 0
test esi, esi
jle short loc_11E8
movsxd rsi, esi
mov rdi, rdx
mov ecx, 1
lea rsi, [rdx+rsi*4]
nop dwo... | long long func0(int *a1, int a2)
{
unsigned int v2; // ecx
int *v3; // rsi
long long v4; // rax
_DWORD v6[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v7; // [rsp+198h] [rbp-10h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 404);
if ( a2 <= 0 )
{
return 1;
}
else
{
v2 = 1;
v3 ... | func0:
ENDBR64
SUB RSP,0x1a8
MOV RDX,RDI
MOV ECX,0x32
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RDI],0x0
TEST ESI,ESI
JLE 0x001011e8
MOVSXD RSI,ESI
MOV RDI,RDX
MOV ECX,0x1
LEA RSI,[RDX + RSI*0x4]
NOP dword ptr [RAX]
LAB_001011a8:
MOVSXD RAX,dword pt... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = local_1a8;
for (lVar3 = 0x32; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (i... |
6,188 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf38(%rip),%xmm0
mulsd %xmm1,%xmm0
movapd %xmm0,%xmm1
mulsd -0x18(%rbp),%xmm1
movsd -0x18(%rbp),%xmm2
movsd 0xf1e(%rip),%xmm0
mulsd %xmm2,%xmm0
mulsd -0x20(%rbp),%xmm0
addsd %xmm1,%xmm0
... | func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm1
movapd xmm1, xmm0
mulsd xmm1, [rbp+var_18]
movsd xmm2, [rbp+var_18]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm2
mulsd xmm0, [rbp+var_20]
a... | double func0(double a1, double a2)
{
return 6.283 * a1 * a2 + 6.283 * a1 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XMM0,XMM1
MOVAPD XMM1,XMM0
MULSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM2,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XM... | double func0(double param_1,double param_2)
{
return DAT_00102080 * param_1 * param_2 + DAT_00102080 * param_1 * param_1;
} |
6,189 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm2
mulsd 0xecf(%rip),%xmm2
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
retq
| func0:
endbr64
movapd xmm2, xmm0
mulsd xmm2, cs:qword_2008
mulsd xmm0, xmm2
mulsd xmm2, xmm1
addsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * (a1 * 6.283) + a1 * 6.283 * a2;
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MULSD XMM2,qword ptr [0x00102008]
MULSD XMM0,XMM2
MULSD XMM2,XMM1
ADDSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * param_1 * _DAT_00102008 + param_1 * _DAT_00102008 * param_2;
} |
6,190 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O2 | c | func0:
endbr64
movsd 0xebc(%rip),%xmm2
mulsd %xmm0,%xmm2
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movsd xmm2, cs:qword_2008
mulsd xmm2, xmm0
mulsd xmm0, xmm2
mulsd xmm2, xmm1
addsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * (6.283 * a1) + 6.283 * a1 * a2;
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102008]
MULSD XMM2,XMM0
MULSD XMM0,XMM2
MULSD XMM2,XMM1
ADDSD XMM0,XMM2
RET | double func0(double param_1,double param_2)
{
return param_1 * DAT_00102008 * param_1 + DAT_00102008 * param_1 * param_2;
} |
6,191 | func0 |
#include <assert.h>
| double func0(double r, double h) {
double surfacearea = ((2 * 3.1415 * r * r) + (2 * 3.1415 * r * h));
return surfacearea;
}
| int main() {
assert(func0(10, 5) == 942.45);
assert(func0(4, 5) == 226.18800000000002);
assert(func0(4, 10) == 351.848);
return 0;
}
| O3 | c | func0:
endbr64
movsd 0xebc(%rip),%xmm2
mulsd %xmm0,%xmm2
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm2
addsd %xmm2,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movsd xmm2, cs:qword_2008
mulsd xmm2, xmm0
mulsd xmm0, xmm2
mulsd xmm2, xmm1
addsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * (6.283 * a1) + 6.283 * a1 * a2;
} | func0:
ENDBR64
MOVSD XMM2,qword ptr [0x00102008]
MULSD XMM2,XMM0
MULSD XMM0,XMM2
MULSD XMM2,XMM1
ADDSD XMM0,XMM2
RET | double func0(double param_1,double param_2)
{
return param_1 * DAT_00102008 * param_1 + DAT_00102008 * param_1 * param_2;
} |
6,192 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1189 <func0+0x40>
mov -0x4(%rbp),%eax
cltd
idivl -0x14(%rbp)
mov %edx,%eax
test %eax,%eax
je ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov [rbp+var_8], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp short loc_1189
loc_116C:
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_14]
mov eax, ed... | long long func0(int a1, int a2, signed int a3, signed int a4)
{
int v5; // [rsp+18h] [rbp-8h]
v5 = 0;
while ( a3 <= a4 )
{
if ( a3 % a1 )
++v5;
if ( v5 == a2 )
break;
++a3;
}
return (unsigned int)a3;
} | 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 dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101189
LAB_0010116c:
MOV EAX,dword ptr [RBP + -0x4]
CD... | int func0(int param_1,int param_2,int param_3,int param_4)
{
int local_10;
int local_c;
local_10 = 0;
local_c = param_3;
while( true ) {
if (param_4 < local_c) {
return local_c;
}
if (local_c % param_1 != 0) {
local_10 = local_10 + 1;
}
if (local_10 == param_2) break;
l... |
6,193 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O1 | c | func0:
endbr64
mov %edx,%r8d
cmp %ecx,%edx
jg 1179 <func0+0x30>
mov $0x0,%r9d
mov %r8d,%eax
cltd
idiv %edi
cmp $0x1,%edx
sbb $0xffffffff,%r9d
cmp %esi,%r9d
je 117c <func0+0x33>
add $0x1,%r8d
cmp %r8d,%ecx
jge 115a <func0+0x11>
mov %r8d,%eax
retq
mov %edx,%eax
retq
mov %r... | func0:
endbr64
mov r8d, edx
cmp edx, ecx
jg short loc_1179
mov r9d, 0
loc_115A:
mov eax, r8d
cdq
idiv edi
cmp edx, 1
sbb r9d, 0FFFFFFFFh
cmp r9d, esi
jz short loc_117C
add r8d, 1
cmp ecx, r8d
jge short loc_115A
mov eax, r8d
retn
loc_1179:
mov eax, edx
retn
lo... | long long func0(int a1, int a2, unsigned int a3, int a4)
{
unsigned int v4; // r8d
int v5; // r9d
v4 = a3;
if ( (int)a3 > a4 )
return a3;
v5 = 0;
while ( 1 )
{
v5 -= ((int)v4 % a1 == 0) - 1;
if ( v5 == a2 )
break;
if ( a4 < (int)++v4 )
return v4;
}
return v4;
} | func0:
ENDBR64
MOV R8D,EDX
CMP EDX,ECX
JG 0x00101179
MOV R9D,0x0
LAB_0010115a:
MOV EAX,R8D
CDQ
IDIV EDI
CMP EDX,0x1
SBB R9D,-0x1
CMP R9D,ESI
JZ 0x0010117c
ADD R8D,0x1
CMP ECX,R8D
JGE 0x0010115a
MOV EAX,R8D
RET
LAB_00101179:
MOV EAX,EDX
RET
LAB_0010117c:
MOV EAX,R8D
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
if (param_4 < param_3) {
return param_3;
}
iVar1 = 0;
do {
iVar1 = (iVar1 + 1) - (uint)(param_3 % param_1 == 0);
if (iVar1 == param_2) {
return param_3;
}
param_3 = param_3 + 1;
} while (param_3 <= param_4)... |
6,194 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O2 | c | func0:
endbr64
mov %edx,%r8d
cmp %ecx,%edx
jg 127b <func0+0x2b>
xor %r9d,%r9d
jmp 1269 <func0+0x19>
add $0x1,%r8d
cmp %r8d,%ecx
jl 127b <func0+0x2b>
mov %r8d,%eax
cltd
idiv %edi
cmp $0x1,%edx
sbb $0xffffffff,%r9d
cmp %esi,%r9d
jne 1260 <func0+0x10>
mov %r8d,%eax
retq
| func0:
endbr64
mov r8d, edx
cmp edx, ecx
jg short loc_127B
xor r9d, r9d
jmp short loc_1269
loc_1260:
add r8d, 1
cmp ecx, r8d
jl short loc_127B
loc_1269:
mov eax, r8d
cdq
idiv edi
cmp edx, 1
sbb r9d, 0FFFFFFFFh
cmp r9d, esi
jnz short loc_1260
loc_127B:
mov eax... | long long func0(int a1, int a2, signed int a3, signed int a4)
{
signed int v4; // r8d
int v5; // r9d
v4 = a3;
if ( a3 <= a4 )
{
v5 = 0;
do
{
v5 -= (v4 % a1 == 0) - 1;
if ( v5 == a2 )
break;
++v4;
}
while ( a4 >= v4 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
MOV R8D,EDX
CMP EDX,ECX
JG 0x0010127b
XOR R9D,R9D
JMP 0x00101269
LAB_00101260:
ADD R8D,0x1
CMP ECX,R8D
JL 0x0010127b
LAB_00101269:
MOV EAX,R8D
CDQ
IDIV EDI
CMP EDX,0x1
SBB R9D,-0x1
CMP R9D,ESI
JNZ 0x00101260
LAB_0010127b:
MOV EAX,R8D
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
if (param_3 <= param_4) {
iVar1 = 0;
do {
iVar1 = (iVar1 + 1) - (uint)(param_3 % param_1 == 0);
if (iVar1 == param_2) {
return param_3;
}
param_3 = param_3 + 1;
} while (param_3 <= param_4);
}
... |
6,195 | func0 |
#include <assert.h>
| int func0(int A, int N, int L, int R) {
int count = 0;
int i;
for (i = L; i <= R; i++) {
if (i % A != 0) {
count += 1;
}
if (count == N) {
break;
}
}
return i;
}
| int main() {
assert(func0(2, 3, 1, 10) == 5);
assert(func0(3, 6, 4, 20) == 11);
assert(func0(5, 10, 4, 20) == 16);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%r8d
cmp %ecx,%edx
jg 116b <func0+0x2b>
xor %r9d,%r9d
jmp 1159 <func0+0x19>
add $0x1,%r8d
cmp %r8d,%ecx
jl 116b <func0+0x2b>
mov %r8d,%eax
cltd
idiv %edi
cmp $0x1,%edx
sbb $0xffffffff,%r9d
cmp %esi,%r9d
jne 1150 <func0+0x10>
mov %r8d,%eax
retq
| func0:
endbr64
mov r8d, edx
cmp edx, ecx
jg short loc_116B
xor r9d, r9d
jmp short loc_1159
loc_1150:
add r8d, 1
cmp ecx, r8d
jl short loc_116B
loc_1159:
mov eax, r8d
cdq
idiv edi
cmp edx, 1
sbb r9d, 0FFFFFFFFh
cmp r9d, esi
jnz short loc_1150
loc_116B:
mov eax... | long long func0(int a1, int a2, signed int a3, signed int a4)
{
signed int v4; // r8d
int v5; // r9d
v4 = a3;
if ( a3 <= a4 )
{
v5 = 0;
do
{
v5 -= (v4 % a1 == 0) - 1;
if ( v5 == a2 )
break;
++v4;
}
while ( a4 >= v4 );
}
return (unsigned int)v4;
} | func0:
ENDBR64
MOV R8D,EDX
CMP EDX,ECX
JG 0x0010116b
XOR R9D,R9D
JMP 0x00101159
LAB_00101150:
ADD R8D,0x1
CMP ECX,R8D
JL 0x0010116b
LAB_00101159:
MOV EAX,R8D
CDQ
IDIV EDI
CMP EDX,0x1
SBB R9D,-0x1
CMP R9D,ESI
JNZ 0x00101150
LAB_0010116b:
MOV EAX,R8D
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
if (param_3 <= param_4) {
iVar1 = 0;
do {
iVar1 = (iVar1 + 1) - (uint)(param_3 % param_1 == 0);
if (iVar1 == param_2) {
return param_3;
}
param_3 = param_3 + 1;
} while (param_3 <= param_4);
}
... |
6,196 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
... | int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
ret... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %ecx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11e9 <func0+0x80>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_28], ecx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11E9
loc_118F:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax,... | long long func0(long long a1, long long a2, int a3, int a4)
{
int v5; // [rsp+20h] [rbp-8h]
int v6; // [rsp+24h] [rbp-4h]
v5 = 0;
v6 = 0;
while ( v5 < a3 && v6 < a4 )
{
if ( *(_DWORD *)(4LL * v5 + a1) == *(_DWORD *)(4LL * v6 + a2) )
{
++v5;
if ( ++v6 == a4 )
return 1LL;
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x28],ECX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011e9
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qwo... | int8 func0(long param_1,long param_2,int param_3,int param_4)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while ((local_10 < param_3 && (local_c < param_4))) {
if (*(int *)(param_1 + (long)local_10 * 4) == *(int *)(param_2 + (long)local_c * 4)) {
local_10 = local_10 + 1;
local_... |
6,197 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
... | int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
ret... | O1 | c | func0:
endbr64
test %edx,%edx
setg %al
test %ecx,%ecx
setg %r11b
and %al,%r11b
je 11cc <func0+0x63>
mov $0x0,%r9d
mov $0x0,%r8d
jmp 11aa <func0+0x41>
sub %r9d,%r8d
add $0x1,%r8d
mov $0x0,%r9d
cmp %edx,%r8d
setl %al
cmp %ecx,%r9d
setl %r10b
and %r10b,%al
je 11cb <func0+0... | func0:
endbr64
mov r9, rdi
mov r10, rsi
mov r8d, edx
mov edi, ecx
test edx, edx
setnle al
test ecx, ecx
setnle dl
and al, dl
mov r11d, eax
jz short locret_11CF
mov ecx, 0
mov edx, 0
jmp short loc_11B0
loc_1195:
sub edx, ecx
add edx, 1
mov ecx, 0
loc_119F:
cmp... | bool func0(long long a1, long long a2, int a3, int a4)
{
bool result; // al
bool v8; // r11
int v9; // ecx
int v10; // edx
result = a4 > 0 && a3 > 0;
v8 = result;
if ( result )
{
v9 = 0;
v10 = 0;
do
{
if ( *(_DWORD *)(a1 + 4LL * v10) == *(_DWORD *)(a2 + 4LL * v9) )
{
... | func0:
ENDBR64
MOV R9,RDI
MOV R10,RSI
MOV R8D,EDX
MOV EDI,ECX
TEST EDX,EDX
SETG AL
TEST ECX,ECX
SETG DL
AND AL,DL
MOV R11D,EAX
JZ 0x001011cf
MOV ECX,0x0
MOV EDX,0x0
JMP 0x001011b0
LAB_00101195:
SUB EDX,ECX
ADD EDX,0x1
MOV ECX,0x0
LAB_0010119f:
CMP EDX,R8D
SETL AL
CMP ECX,EDI
SETL SIL
AND AL,SIL
JZ 0x001011ce
LAB_001011... | bool func0(long param_1,long param_2,int param_3,int param_4)
{
bool bVar1;
int iVar2;
int iVar3;
bVar1 = 0 < param_3 && 0 < param_4;
if (0 >= param_3 || 0 >= param_4) {
return bVar1;
}
iVar2 = 0;
iVar3 = 0;
do {
if (*(int *)(param_1 + (long)iVar3 * 4) == *(int *)(param_2 + (long)iVar2 * 4... |
6,198 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
... | int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
ret... | O2 | c | func0:
endbr64
test %ecx,%ecx
setg %r11b
test %edx,%edx
setg %al
and %al,%r11b
je 13ac <func0+0x6c>
xor %r9d,%r9d
xor %r8d,%r8d
jmp 1378 <func0+0x38>
nopl 0x0(%rax)
sub %r9d,%r8d
xor %r9d,%r9d
mov %r11d,%r10d
add $0x1,%r8d
cmp %edx,%r8d
setl %al
and %r10b,%al
je 13a4 <f... | func0:
endbr64
test ecx, ecx
mov r8, rdi
mov r9, rsi
mov edi, edx
setnle r10b
test edx, edx
mov r11d, ecx
setnle al
and r10b, al
jz short loc_1344
xor ecx, ecx
xor edx, edx
jmp short loc_130C
loc_12F8:
sub edx, ecx
xor ecx, ecx
mov esi, r10d
add edx, 1
cmp ... | bool func0(long long a1, long long a2, int a3, int a4)
{
bool v7; // r10
int v8; // ecx
int v9; // edx
int v10; // edx
bool result; // al
v7 = a3 > 0 && a4 > 0;
if ( !v7 )
return 0;
v8 = 0;
v9 = 0;
while ( 1 )
{
while ( *(_DWORD *)(a1 + 4LL * v9) != *(_DWORD *)(a2 + 4LL * v8) )
{
... | func0:
ENDBR64
TEST ECX,ECX
MOV R8,RDI
MOV R9,RSI
MOV EDI,EDX
SETG R10B
TEST EDX,EDX
MOV R11D,ECX
SETG AL
AND R10B,AL
JZ 0x00101344
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0010130c
LAB_001012f8:
SUB EDX,ECX
XOR ECX,ECX
MOV ESI,R10D
ADD EDX,0x1
CMP EDX,EDI
SETL AL
AND AL,SIL
JZ 0x00101335
LAB_0010130c:
MOVSXD RSI,ECX
MOVSXD RAX,E... | ulong func0(long param_1,long param_2,int param_3,int param_4)
{
bool bVar1;
bool bVar2;
bool bVar3;
uint uVar4;
bool bVar5;
int iVar6;
int iVar7;
int4 in_R10D;
bVar2 = 0 < param_4;
bVar3 = 0 < param_3;
if (!bVar2 || !bVar3) {
return 0;
}
iVar6 = 0;
iVar7 = 0;
do {
while (uVar4... |
6,199 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int B[], int n, int m) {
int i = 0, j = 0;
while (i < n && j < m) {
if (A[i] == B[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
i = i - j + 1;
j = 0;
}
}
... | int main() {
int A1[] = {1, 4, 3, 5};
int B1[] = {1, 2};
assert(func0(A1, B1, 4, 2) == false);
int A2[] = {1, 2, 1};
int B2[] = {1, 2, 1};
assert(func0(A2, B2, 3, 3) == true);
int A3[] = {1, 0, 2, 2};
int B3[] = {2, 2, 0};
assert(func0(A3, B3, 4, 3) == false);
ret... | O3 | c | func0:
endbr64
test %ecx,%ecx
setg %r11b
test %edx,%edx
setg %al
and %al,%r11b
je 13ac <func0+0x6c>
xor %r9d,%r9d
xor %r8d,%r8d
jmp 1378 <func0+0x38>
nopl 0x0(%rax)
sub %r9d,%r8d
xor %r9d,%r9d
mov %r11d,%r10d
add $0x1,%r8d
cmp %edx,%r8d
setl %al
and %r10b,%al
je 13a4 <f... | func0:
endbr64
test edx, edx
mov r8, rdi
mov r9, rsi
mov edi, edx
setnle r10b
test ecx, ecx
mov r11d, ecx
setnle al
and r10b, al
jz short loc_1394
xor ecx, ecx
xor edx, edx
jmp short loc_135C
loc_1348:
sub edx, ecx
xor ecx, ecx
mov esi, r10d
add edx, 1
cmp ... | bool func0(long long a1, long long a2, int a3, int a4)
{
bool v7; // r10
int v8; // ecx
int v9; // edx
int v10; // edx
bool result; // al
v7 = a4 > 0 && a3 > 0;
if ( !v7 )
return 0;
v8 = 0;
v9 = 0;
while ( 1 )
{
while ( *(_DWORD *)(a1 + 4LL * v9) != *(_DWORD *)(a2 + 4LL * v8) )
{
... | func0:
ENDBR64
TEST EDX,EDX
MOV R8,RDI
MOV R9,RSI
MOV EDI,EDX
SETG R10B
TEST ECX,ECX
MOV R11D,ECX
SETG AL
AND R10B,AL
JZ 0x00101394
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0010135c
LAB_00101348:
SUB EDX,ECX
XOR ECX,ECX
MOV ESI,R10D
ADD EDX,0x1
CMP EDX,EDI
SETL AL
AND AL,SIL
JZ 0x00101385
LAB_0010135c:
MOVSXD RSI,ECX
MOVSXD RAX,E... | ulong func0(long param_1,long param_2,int param_3,int param_4)
{
bool bVar1;
bool bVar2;
bool bVar3;
uint uVar4;
bool bVar5;
int iVar6;
int iVar7;
int4 in_R10D;
bVar2 = 0 < param_3;
bVar3 = 0 < param_4;
if (!bVar2 || !bVar3) {
return 0;
}
iVar6 = 0;
iVar7 = 0;
do {
while (uVar4... |
6,200 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 1161 <func0+0x18>
mov $0x1,%eax
jmp 118b <func0+0x42>
cmpl $0x2,-0x4(%rbp)
jg 116c <func0+0x23>
mov -0x4(%rbp),%eax
jmp 118b <func0+0x42>
cmpl $0x3,-0x4(%rbp)
jne 1179 <func0+0x30>
mov $0x6,%eax
jm... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jnz short loc_1161
mov eax, 1
jmp short loc_118B
loc_1161:
cmp [rbp+var_4], 2
jg short loc_116C
mov eax, [rbp+var_4]
jmp short loc_118B
loc_116C:
cmp [rbp+var_4], 3
jnz short loc_1179
mov ... | long long func0(int a1)
{
if ( !a1 )
return 1LL;
if ( a1 <= 2 )
return (unsigned int)a1;
if ( a1 == 3 )
return 6LL;
if ( a1 == 4 )
return 4LL;
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x00101161
MOV EAX,0x1
JMP 0x0010118b
LAB_00101161:
CMP dword ptr [RBP + -0x4],0x2
JG 0x0010116c
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x0010118b
LAB_0010116c:
CMP dword ptr [RBP + -0x4],0x3
JNZ 0x00101179
MOV EAX,0x6
JMP... | int func0(int param_1)
{
if (param_1 == 0) {
param_1 = 1;
}
else if (2 < param_1) {
if (param_1 == 3) {
param_1 = 6;
}
else if (param_1 == 4) {
param_1 = 4;
}
else {
param_1 = 0;
}
}
return param_1;
} |
6,201 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
test %edi,%edi
je 1153 <func0+0x2a>
mov %edi,%eax
cmp $0x2,%edi
jle 1153 <func0+0x2a>
cmp $0x3,%edi
je 114e <func0+0x25>
cmp $0x4,%edi
mov $0x0,%eax
cmove %edi,%eax
retq
mov $0x6,%eax
retq
| func0:
endbr64
mov eax, 1
test edi, edi
jz short locret_1154
mov eax, edi
cmp edi, 2
jle short locret_1154
cmp edi, 3
jz short loc_114F
cmp edi, 4
setz al
movzx eax, al
shl eax, 2
retn
loc_114F:
mov eax, 6
locret_1154:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( a1 > 2 )
{
if ( a1 == 3 )
return 6LL;
else
return 4 * (unsigned int)(a1 == 4);
}
}
return result;
} | ||
6,202 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
test %edi,%edi
je 1175 <func0+0x35>
mov %edi,%eax
cmp $0x2,%edi
jle 1175 <func0+0x35>
cmp $0x3,%edi
je 1170 <func0+0x30>
cmp $0x4,%edi
sete %al
movzbl %al,%eax
shl $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x6,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
test edi, edi
jz short locret_1175
mov eax, edi
cmp edi, 2
jle short locret_1175
cmp edi, 3
jz short loc_1170
cmp edi, 4
setz al
movzx eax, al
shl eax, 2
retn
loc_1170:
mov eax, 6
locret_1175:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( a1 > 2 )
{
if ( a1 == 3 )
return 6LL;
else
return 4 * (unsigned int)(a1 == 4);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST EDI,EDI
JZ 0x00101175
MOV EAX,EDI
CMP EDI,0x2
JLE 0x00101175
CMP EDI,0x3
JZ 0x00101170
CMP EDI,0x4
SETZ AL
MOVZX EAX,AL
SHL EAX,0x2
RET
LAB_00101170:
MOV EAX,0x6
LAB_00101175:
RET | ulong func0(uint param_1)
{
ulong uVar1;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = (ulong)param_1, 2 < (int)param_1)) {
if (param_1 != 3) {
return (ulong)(param_1 == 4) << 2;
}
uVar1 = 6;
}
return uVar1;
} |
6,203 | func0 | #include <assert.h>
| int func0(int n) {
if (n == 0) return 1;
else if (n <= 2) return n;
else if (n == 3) return 6;
else if (n == 4) return 4;
else return 0;
}
| int main() {
assert(func0(4) == 4);
assert(func0(21) == 0);
assert(func0(30) == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
test %edi,%edi
je 1175 <func0+0x35>
mov %edi,%eax
cmp $0x2,%edi
jle 1175 <func0+0x35>
cmp $0x3,%edi
je 1170 <func0+0x30>
cmp $0x4,%edi
sete %al
movzbl %al,%eax
shl $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x6,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
test edi, edi
jz short locret_1175
mov eax, edi
cmp edi, 2
jle short locret_1175
cmp edi, 3
jz short loc_1170
cmp edi, 4
setz al
movzx eax, al
shl eax, 2
retn
loc_1170:
mov eax, 6
locret_1175:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( a1 > 2 )
{
if ( a1 == 3 )
return 6LL;
else
return 4 * (unsigned int)(a1 == 4);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST EDI,EDI
JZ 0x00101175
MOV EAX,EDI
CMP EDI,0x2
JLE 0x00101175
CMP EDI,0x3
JZ 0x00101170
CMP EDI,0x4
SETZ AL
MOVZX EAX,AL
SHL EAX,0x2
RET
LAB_00101170:
MOV EAX,0x6
LAB_00101175:
RET | ulong func0(uint param_1)
{
ulong uVar1;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = (ulong)param_1, 2 < (int)param_1)) {
if (param_1 != 3) {
return (ulong)(param_1 == 4) << 2;
}
uVar1 = 6;
}
return uVar1;
} |
6,204 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 40... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8d,-0x34(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1255 <func0+0xcc>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_34], r8d
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_1255
loc_11B8:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+... | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
int v5; // eax
long long result; // rax
int v7; // [rsp+2Ch] [rbp-8h]
unsigned int i; // [rsp+30h] [rbp-4h]
v7 = 0;
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a5 )
break;
*(_DWORD *)(a4 + 4LL * v7)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x34],R8D
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101255
LAB_001011b8:
MOV EAX,dword ptr [RBP + -0x4]
CD... | void func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_5; local_c = local_c + 1) {
*(int4 *)((long)local_10 * 4 + param_4) = *(int4 *)((long)local_c * 4 + param_1);
iVar1 = local_10 + 2;
... |
6,205 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 40... | O1 | c | func0:
endbr64
test %r8d,%r8d
jle 11c2 <func0+0x39>
lea -0x1(%r8),%r9d
mov $0x0,%eax
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rcx)
mov (%rsi,%rax,4),%r8d
mov %r8d,0x4(%rcx)
mov (%rdx,%rax,4),%r8d
mov %r8d,0x8(%rcx)
mov %rax,%r8
add $0x1,%rax
add $0xc,%rcx
cmp %r9,%r8
jne 119b <func0... | func0:
endbr64
mov r9, rsi
test r8d, r8d
jle short locret_11BC
mov r8d, r8d
mov eax, 0
loc_119D:
mov esi, [rdi+rax*4]
mov [rcx], esi
mov esi, [r9+rax*4]
mov [rcx+4], esi
mov esi, [rdx+rax*4]
mov [rcx+8], esi
add rax, 1
add rcx, 0Ch
cmp rax, r8
jnz short loc_119... | void func0(long long a1, long long a2, long long a3, _DWORD *a4, int a5)
{
long long v5; // rax
if ( a5 > 0 )
{
v5 = 0LL;
do
{
*a4 = *(_DWORD *)(a1 + 4 * v5);
a4[1] = *(_DWORD *)(a2 + 4 * v5);
a4[2] = *(_DWORD *)(a3 + 4 * v5++);
a4 += 3;
}
while ( v5 != a5 );
}
} | func0:
ENDBR64
MOV R9,RSI
TEST R8D,R8D
JLE 0x001011bc
MOV R8D,R8D
MOV EAX,0x0
LAB_0010119d:
MOV ESI,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX],ESI
MOV ESI,dword ptr [R9 + RAX*0x4]
MOV dword ptr [RCX + 0x4],ESI
MOV ESI,dword ptr [RDX + RAX*0x4]
MOV dword ptr [RCX + 0x8],ESI
ADD RAX,0x1
ADD RCX,0xc
CMP RAX,R8
JNZ 0x00... | void func0(long param_1,long param_2,long param_3,int4 *param_4,uint param_5)
{
ulong uVar1;
if (0 < (int)param_5) {
uVar1 = 0;
do {
*param_4 = *(int4 *)(param_1 + uVar1 * 4);
param_4[1] = *(int4 *)(param_2 + uVar1 * 4);
param_4[2] = *(int4 *)(param_3 + uVar1 * 4);
uVar1 = uVar1 ... |
6,206 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 40... | O2 | c | func0:
endbr64
test %r8d,%r8d
jle 1588 <func0+0x38>
lea -0x1(%r8),%r9d
xor %eax,%eax
mov (%rdi,%rax,4),%r8d
add $0xc,%rcx
mov %r8d,-0xc(%rcx)
mov (%rsi,%rax,4),%r8d
mov %r8d,-0x8(%rcx)
mov (%rdx,%rax,4),%r8d
mov %r8d,-0x4(%rcx)
mov %rax,%r8
add $0x1,%rax
cmp %r8,%r9
jne 1560 ... | func0:
endbr64
mov r9, rsi
test r8d, r8d
jle short locret_1588
movsxd r8, r8d
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1568:
mov esi, [rdi+rax*4]
add rcx, 0Ch
mov [rcx-0Ch], esi
mov esi, [r9+rax*4]
mov [rcx-8], esi
mov esi, [rdx+rax*4]
add rax, 1
mov [rcx-4], es... | void func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v6; // rax
int v7; // esi
if ( a5 > 0 )
{
v6 = 0LL;
do
{
a4 += 12LL;
*(_DWORD *)(a4 - 12) = *(_DWORD *)(a1 + 4 * v6);
*(_DWORD *)(a4 - 8) = *(_DWORD *)(a2 + 4 * v6);
v7 = *(_DWORD *)(a3 +... | func0:
ENDBR64
MOV R9,RSI
TEST R8D,R8D
JLE 0x00101588
MOVSXD R8,R8D
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101568:
MOV ESI,dword ptr [RDI + RAX*0x4]
ADD RCX,0xc
MOV dword ptr [RCX + -0xc],ESI
MOV ESI,dword ptr [R9 + RAX*0x4]
MOV dword ptr [RCX + -0x8],ESI
MOV ESI,dword ptr [RDX + RAX*0x4]
ADD RAX,0x1
MOV dword ptr [RCX ... | void func0(long param_1,long param_2,long param_3,int4 *param_4,int param_5)
{
long lVar1;
long lVar2;
if (0 < param_5) {
lVar2 = 0;
do {
*param_4 = *(int4 *)(param_1 + lVar2 * 4);
param_4[1] = *(int4 *)(param_2 + lVar2 * 4);
lVar1 = lVar2 * 4;
lVar2 = lVar2 + 1;
param_4[... |
6,207 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int list1[], int list2[], int list3[], int result[], int size) {
int idx = 0;
for (int i = 0; i < size; i++) {
result[idx++] = list1[i];
result[idx++] = list2[i];
result[idx++] = list3[i];
}
}
| int main() {
int size1 = 7;
int list1[] = {1, 2, 3, 4, 5, 6, 7};
int list2[] = {10, 20, 30, 40, 50, 60, 70};
int list3[] = {100, 200, 300, 400, 500, 600, 700};
int result1[21];
func0(list1, list2, list3, result1, size1);
int expected1[] = {1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 40... | O3 | c | func0:
endbr64
test %r8d,%r8d
jle 14f8 <func0+0x38>
lea -0x1(%r8),%r9d
xor %eax,%eax
mov (%rdi,%rax,4),%r8d
add $0xc,%rcx
mov %r8d,-0xc(%rcx)
mov (%rsi,%rax,4),%r8d
mov %r8d,-0x8(%rcx)
mov (%rdx,%rax,4),%r8d
mov %r8d,-0x4(%rcx)
mov %rax,%r8
add $0x1,%rax
cmp %r9,%r8
jne 14d0 ... | func0:
endbr64
test r8d, r8d
jle locret_1640
mov r9, rdx
lea edx, [r8-1]
push r14
mov rax, rcx
push rbp
movsxd rcx, r8d
push rbx
cmp edx, 2
jbe loc_1608
lea rdx, ds:0[rcx*4]
lea r10, [rcx+rcx*2]
lea rbx, [rax+r10*4]
lea r10, [rdi+rdx]
cmp rax, r10
setnb r11b
cm... | void func0(unsigned long long a1, unsigned long long a2, unsigned long long a3, unsigned long long a4, int a5)
{
unsigned long long v6; // rax
unsigned long long v7; // rbx
long long v8; // rdx
__m128 v9; // xmm1
__m128 v10; // xmm3
__m128 v11; // xmm0
__m128 v12; // xmm2
__m128 v13; // xmm2
unsigned... | func0:
ENDBR64
TEST R8D,R8D
JLE 0x00101640
MOV R9,RDX
LEA EDX,[R8 + -0x1]
PUSH R14
MOV RAX,RCX
PUSH RBP
MOVSXD RCX,R8D
PUSH RBX
CMP EDX,0x2
JBE 0x00101608
LEA RDX,[RCX*0x4]
LEA R10,[RCX + RCX*0x2]
LEA RBX,[RAX + R10*0x4]
LEA R10,[RDI + RDX*0x1]
CMP RAX,R10
SETNC R11B
CMP RDI,RBX
SETNC R10B
OR R11D,R10D
LEA R10,[RSI + R... | void func0(int4 *param_1,int4 *param_2,int4 *param_3,int4 *param_4,
uint param_5)
{
int4 *puVar1;
int4 *puVar2;
int iVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
int4 uVar10;
int4 uVar11;
int4 uVar12;
int4 uVar13;
int4 uVar14;
long lVar15;
int4... |
6,208 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (... | tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
... | int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.d... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %rdx,-0x68(%rbp)
mov %rcx,-0x70(%rbp)
mov -0x60(%rbp),%rdx
mov -0x70(%rbp),%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movq $0x0,-0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_70], rcx
mov rdx, [rbp+var_60]
mov rax, [rbp+var_70]
add rax, rdx
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov ... | _DWORD * func0(long long a1, unsigned long long a2, long long a3, unsigned long long a4)
{
unsigned long long v4; // rax
unsigned long long v5; // rax
int v9; // [rsp+2Ch] [rbp-44h]
unsigned long long v10; // [rsp+30h] [rbp-40h]
unsigned long long i; // [rsp+38h] [rbp-38h]
unsigned long long j; // [rsp+40h]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV qword ptr [RBP + -0x70],RCX
MOV RDX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,RDX
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18]... | int [16] func0(long param_1,ulong param_2,long param_3,ulong param_4)
{
int4 uVar1;
int auVar2 [16];
int iVar3;
void *pvVar4;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
pvVar4 = malloc((param_4 + param_2) * 4);
local_48 = 0;
for (local_40 = 0; local_40 < para... |
6,209 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (... | tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
... | int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.d... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r15
mov %rdi,0x10(%rsp)
mov %rsi,%rbx
mov %rsi,0x8(%rsp)
mov %rdx,%r13
mov %rcx,%r12
lea (%rsi,%rcx,1),%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %rbx,%rbx
... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r15, rdi
mov [rsp+58h+var_48], rdi
mov rbx, rsi
mov [rsp+58h+var_50], rsi
mov r13, rdx
mov r12, rcx
lea rdi, [rsi+rcx]
shl rdi, 2
call _malloc
mov r14, rax
test rbx, rbx
... | long long func0(unsigned int *a1, long long a2, long long a3, unsigned long long a4)
{
long long v6; // r14
unsigned int *v7; // rbp
unsigned long long v8; // rbx
unsigned int v9; // r15d
unsigned long long v10; // rbp
unsigned int v11; // r15d
unsigned long long v12; // r9
_DWORD *v13; // rsi
unsign... | ||
6,210 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (... | tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
... | int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.d... | O2 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
lea (%rsi,%rcx,1),%rdi
push %rbp
shl $0x2,%rdi
mov %rcx,%rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %r13,%r13
je 160a <func0+0x14a>
mov %r12,%rcx
lea (%r12,%r13,4),%rsi
xor %r9d,%r9d
n... | func0:
endbr64
push r13
mov r13, rsi
push r12
mov r12, rdi
lea rdi, [rsi+rcx]
push rbp
shl rdi, 2
mov rbp, rcx
push rbx
mov rbx, rdx
sub rsp, 8
call _malloc
mov r9, rax
test r13, r13
jz loc_160A
mov rcx, r12
lea rsi, [r12+r13*4]
xor r8d, r8d
nop dwo... | long long func0(int *a1, long long a2, int *a3, long long a4)
{
long long v7; // r9
int *v8; // rcx
int *v9; // rsi
unsigned long long v10; // r8
int v11; // edx
long long v12; // rax
int *v13; // rcx
int v14; // edx
long long v15; // rax
long long v16; // r11
_DWORD *v17; // rsi
long long v18;... | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
LEA RDI,[RSI + RCX*0x1]
PUSH RBP
SHL RDI,0x2
MOV RBP,RCX
PUSH RBX
MOV RBX,RDX
SUB RSP,0x8
CALL 0x001010b0
MOV R9,RAX
TEST R13,R13
JZ 0x0010160a
MOV RCX,R12
LEA RSI,[R12 + R13*0x4]
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101500:
MOV EDX,dword ptr [RCX]
TEST RBP,RBP
... | int1 [16] func0(int *param_1,long param_2,int *param_3,long param_4)
{
int iVar1;
long lVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
int1 auVar8 [16];
auVar8._0_8_ = (int *)malloc((param_2 + param_4) * 4);
if (param_2 == 0) {
uVar5 = 0;
uVar7 = 0xffffffffffffff... |
6,211 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Structure to hold the result tuple
typedef struct {
int *data;
size_t size;
} tuple;
// Function to check if a value exists in an array
int contains(int *arr, size_t len, int val) {
for (size_t i = 0; i < len; i++) {
if (... | tuple func0(int *a, size_t a_len, int *b, size_t b_len) {
int *temp = malloc((a_len + b_len) * sizeof(int));
size_t count = 0;
for (size_t i = 0; i < a_len; i++) {
if (!contains(b, b_len, a[i])) {
temp[count++] = a[i];
}
}
for (size_t i = 0; i < b_len; i++) {
... | int main() {
// Test 1
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
int expected1[] = {3, 6, 7, 10};
tuple res1 = func0(test1_a, 4, test1_b, 4);
assert(res1.size == 4);
for (int i = 0; i < 4; i++) {
assert(res1.data[i] == expected1[i]);
}
free(res1.d... | O3 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
lea (%rsi,%rcx,1),%rdi
push %rbp
shl $0x2,%rdi
mov %rcx,%rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %r13,%r13
je 155a <func0+0x14a>
mov %r12,%rcx
lea (%r12,%r13,4),%rsi
xor %r9d,%r9d
n... | func0:
endbr64
push r13
mov r13, rdi
lea rdi, [rsi+rcx]
push r12
shl rdi, 2; size
mov r12, rsi
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
sub rsp, 8
call _malloc
mov r9, rax
test r12, r12
jz loc_1541
mov rcx, r13
lea rdi, [r13+r12*4+0]
xor esi, esi
nop... | _DWORD * func0(int *a1, long long a2, long long a3, unsigned long long a4)
{
_DWORD *v8; // r9
int *v9; // rcx
int *v10; // rdi
unsigned long long i; // rsi
int v12; // edx
long long v13; // rax
unsigned long long v14; // r8
unsigned long long v15; // rcx
int v16; // edx
long long v17; // rax
unsi... | func0:
ENDBR64
PUSH R13
MOV R13,RDI
LEA RDI,[RSI + RCX*0x1]
PUSH R12
SHL RDI,0x2
MOV R12,RSI
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
SUB RSP,0x8
CALL 0x001010b0
MOV R9,RAX
TEST R12,R12
JZ 0x00101541
MOV RCX,R13
LEA RDI,[R13 + R12*0x4]
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_00101450:
MOV EDX,dword ptr [RCX]
TEST RBX,RBX
... | int [16] func0(int *param_1,long param_2,long param_3,ulong param_4)
{
long lVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
int auVar8 [16];
auVar8._0_8_ = (int *)malloc((param_2 + param_4) * 4);
if (param_2 == 0) {
uVar6 = 0;
uVar4 = 0xfffffffffffffff... |
6,212 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an int... | int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) ret... | int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_e... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov -0x38(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x40(%rbp),%rax
mov 0x8(%rax),%eax
cmp %eax,%edx
je 14be <func0+0x30>
mov $0x0,%eax
jmpq 1570 <func0+0xe2>
movl $0x0,-0x24(%rbp)
jmpq 155... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, [rbp+var_38]
mov edx, [rax+8]
mov rax, [rbp+var_40]
mov eax, [rax+8]
cmp edx, eax
jz short loc_14D4
mov eax, 0
jmp locret_1586
loc_14D4:
mov [rbp+var_24], 0
jmp ... | long long func0(long long a1, long long a2)
{
long long *v3; // rax
_QWORD *v4; // rax
int i; // [rsp+1Ch] [rbp-24h]
long long v6; // [rsp+20h] [rbp-20h]
long long v7; // [rsp+28h] [rbp-18h]
long long v8; // [rsp+38h] [rbp-8h]
if ( *(_DWORD *)(a1 + 8) != *(_DWORD *)(a2 + 8) )
return 0LL;
for ( i =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x8]
CMP EDX,EAX
JZ 0x001014d4
MOV EAX,0x0
JMP 0x00101586
LAB_001014d4:
MOV dword ptr [R... | int8 func0(long *param_1,long *param_2)
{
int8 uVar1;
int iVar2;
int8 uVar3;
int8 *puVar4;
int8 *puVar5;
int local_2c;
int local_28;
int local_20;
int local_18;
int local_10;
if (*(int *)(param_1 + 1) == *(int *)(param_2 + 1)) {
for (local_2c = 0; local_2c < *(int *)(param_1 + 1); local_2c... |
6,213 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an int... | int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) ret... | int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_e... | O1 | c | func0:
endbr64
mov 0x8(%rdi),%eax
mov $0x0,%edx
cmp 0x8(%rsi),%eax
jne 13f1 <func0+0x8e>
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%r12
test %eax,%eax
jle 13ea <func0+0x87>
lea -0x1(%rax),%r13d
add $0x1,%r13
shl $0x4,%r13
mov $0x0,%ebx
jmp... | func0:
endbr64
mov eax, [rdi+8]
mov edx, 0
cmp eax, [rsi+8]
jnz short loc_13E6
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12, rsi
test eax, eax
jle short loc_13DF
lea r13d, [rax-1]
add r13, 1
shl r13, 4
mov ebx, 0
jmp short loc_13A... | long long func0(long long a1, long long a2)
{
int v2; // eax
long long v4; // r13
long long v5; // rbx
int *v6; // rax
long long v7; // rdi
int v8; // edx
long long v9; // rax
v2 = *(_DWORD *)(a1 + 8);
if ( v2 != *(_DWORD *)(a2 + 8) )
return 0LL;
if ( v2 <= 0 )
{
return 1;
}
else
{... | func0:
ENDBR64
MOV EAX,dword ptr [RDI + 0x8]
MOV EDX,0x0
CMP EAX,dword ptr [RSI + 0x8]
JNZ 0x001013e6
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12,RSI
TEST EAX,EAX
JLE 0x001013df
LEA R13D,[RAX + -0x1]
ADD R13,0x1
SHL R13,0x4
MOV EBX,0x0
JMP 0x001013a2
LAB_00101390:
CALL 0x00101358
TEST EAX,EAX
JZ... | int8 func0(long *param_1,long *param_2)
{
int iVar1;
int iVar2;
long lVar3;
iVar1 = (int)param_1[1];
if (iVar1 != (int)param_2[1]) {
return 0;
}
if (0 < iVar1) {
lVar3 = 0;
do {
iVar2 = *(int *)(lVar3 + *param_1);
if (iVar2 != *(int *)(lVar3 + *param_2)) {
return 0;
... |
6,214 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an int... | int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) ret... | int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_e... | O2 | c | func0:
endbr64
mov 0x8(%rsi),%eax
cmp %eax,0x8(%rdi)
jne 19d0 <func0+0x10>
jmp 19e0 <func0.part.0>
xchg %ax,%ax
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0_part_0_isra_0:
test esi, esi
jle short loc_189B
lea eax, [rsi-1]
push r12
shl rax, 4
push rbp
lea r12, [rdi+rax+10h]
push rbx
mov rbx, rdi
mov rbp, [rdx]
jmp short loc_1851
loc_1840:
cmp ecx, edx
jnz short loc_186C
add rbx, 10h
add rbp, 10h
cmp rbx, r12
... | long long func0_part_0_isra_0(long long a1, int a2, long long *a3)
{
long long v3; // r12
long long v4; // rbx
long long v5; // rbp
long long v6; // rcx
long long v7; // rdx
if ( a2 <= 0 )
return 1LL;
v3 = a1 + 16LL * (unsigned int)(a2 - 1) + 16;
v4 = a1;
v5 = *a3;
do
{
while ( 1 )
{... | func0.part.0.isra.0:
TEST ESI,ESI
JLE 0x0010189b
LEA EAX,[RSI + -0x1]
PUSH R12
SHL RAX,0x4
PUSH RBP
LEA R12,[RDI + RAX*0x1 + 0x10]
PUSH RBX
MOV RBX,RDI
MOV RBP,qword ptr [RDX]
JMP 0x00101851
LAB_00101840:
CMP ECX,EDX
JNZ 0x0010186c
ADD RBX,0x10
ADD RBP,0x10
CMP RBX,R12
JZ 0x00101891
LAB_00101851:
MOV RCX,qword ptr [RBX... | int8 func0_part_0_isra_0(int *param_1,int param_2,int8 *param_3)
{
int *piVar1;
int8 *puVar2;
int iVar3;
int *piVar4;
if (param_2 < 1) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
piVar4 = (int *)*param_3;
do {
puVar2 = *(int8 **)(param_1 + 2);
if (*param_1 != *piVar4... |
6,215 | func0 |
#include <assert.h>
#include <stdlib.h>
// Structure Definitions
typedef struct Tuple Tuple;
typedef struct Element {
int is_tuple;
union {
int value;
Tuple* tuple;
} data;
} Element;
struct Tuple {
Element* elements;
int size;
};
// Function to create an int... | int func0(Tuple* a, Tuple* b) {
if(a->size != b->size) return 0;
for(int i = 0; i < a->size; i++) {
Element ea = a->elements[i];
Element eb = b->elements[i];
if(ea.is_tuple != eb.is_tuple) return 0;
if(ea.is_tuple) {
if(!func0(ea.data.tuple, eb.data.tuple)) ret... | int main() {
// Construct first input tuple: (4, 5, (7, 6, (2, 4)), 6, 8)
Element sub_sub_elements1[] = { make_int(2), make_int(4) };
Element sub_elements1[] = { make_int(7), make_int(6), make_tuple_element(sub_sub_elements1, 2) };
Element input_elements1[] = { make_int(4), make_int(5), make_tuple_e... | O3 | c | func0:
endbr64
mov 0x8(%rdi),%eax
xor %r8d,%r8d
cmp 0x8(%rsi),%eax
je 1c88 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
test %eax,%eax
jle 1d30 <func0+0xc0>
mov (%rdi),%rdx
sub $0x1,%eax
mov (%rsi),%rcx
shl $0x4,%rax
lea 0x10(%rdx,%rax,1),%r8
jmp 1cb9 <func0+0x49>
nopl ... | func0:
endbr64
movsxd rax, dword ptr [rdi+8]
cmp eax, [rsi+8]
jz short loc_1BA0
xor eax, eax
retn
loc_1BA0:
test eax, eax
jle loc_20A0
push r15
shl rax, 4
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rbp, [rdi]
mov r12, [rsi]
lea r14, [rax+rbp... | long long func0(long long *a1, long long *a2)
{
long long v2; // rax
long long v4; // rbp
long long v5; // rbx
long long v6; // r13
long long *v7; // rcx
long long *v8; // rdx
long long v9; // rax
long long v10; // r12
long long v11; // r14
long long v12; // rsi
long long v13; // rdx
long long ... | func0:
ENDBR64
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP EAX,dword ptr [RSI + 0x8]
JZ 0x00101ba0
XOR EAX,EAX
RET
LAB_00101ba0:
TEST EAX,EAX
JLE 0x001020a0
PUSH R15
SHL RAX,0x4
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RBP,qword ptr [RDI]
MOV R12,qword ptr [RSI]
LEA R14,[RAX + RBP*0x1]
MOV RBX,R12
MOV R13... | int8 func0(int8 *param_1,int8 *param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 *puVar4;
int8 *puVar5;
int iVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int *piVar10;
int *piVar11;
int *piVar12;
int *piVar13;
int *piVar14;
int *piVar15;
int *piVar16;
int *piVar17;
int *piVar18... |
6,216 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
imul -0x8(%rbp),%eax
add %eax,%eax
cvtsi2sd %eax,%xmm2
movsd %xmm2,-0x10(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm0
movsd 0xee6(%rip),%xmm1
callq 1060 <pow@plt>
addsd -0x10(%rbp),%xmm0
cvtts... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
imul eax, [rbp+var_8]
add eax, eax
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
movsd [rbp+var_10], xmm2
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_4]
movq rax, xmm3
movsd xmm0,... | long long func0(int a1, int a2)
{
return (unsigned int)(int)(pow((double)a1, 2.0) + (double)(2 * a2 * a1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
MOVSD qword ptr [RBP + -0x10],XMM2
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x4]
MOVQ RAX,XMM3
... | int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)param_1,DAT_00102060);
return (int)(dVar1 + (double)(param_1 * param_2 * 2));
} |
6,217 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O1 | c | func0:
endbr64
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
imul %esi,%edi
add %edi,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd %xmm1,%xmm1
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
| func0:
endbr64
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
imul edi, esi
add edi, edi
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
mulsd xmm0, xmm0
addsd xmm0, xmm1
cvttsd2si eax, xmm0
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)((double)a1 * (double)a1 + (double)(2 * a2 * a1));
} | func0:
ENDBR64
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
IMUL EDI,ESI
ADD EDI,EDI
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MULSD XMM0,XMM0
ADDSD XMM0,XMM1
CVTTSD2SI EAX,XMM0
RET | int func0(int param_1,int param_2)
{
return (int)((double)param_1 * (double)param_1 + (double)(param_1 * param_2 * 2));
} |
6,218 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm1
imul %esi,%edi
mulsd %xmm1,%xmm1
add %edi,%edi
cvtsi2sd %edi,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, edi
imul edi, esi
mulsd xmm0, xmm0
add edi, edi
cvtsi2sd xmm1, edi
addsd xmm1, xmm0
cvttsd2si eax, xmm1
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)((double)(2 * a2 * a1) + (double)a1 * (double)a1);
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDI
IMUL EDI,ESI
MULSD XMM0,XMM0
ADD EDI,EDI
CVTSI2SD XMM1,EDI
ADDSD XMM1,XMM0
CVTTSD2SI EAX,XMM1
RET | int func0(int param_1,int param_2)
{
return (int)((double)(param_1 * param_2 * 2) + (double)param_1 * (double)param_1);
} |
6,219 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int b, int s) {
return 2 * b * s + pow(b, 2);
}
| int main() {
assert(func0(3, 4) == 33);
assert(func0(4, 5) == 56);
assert(func0(1, 2) == 5);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm1
imul %esi,%edi
mulsd %xmm1,%xmm1
add %edi,%edi
cvtsi2sd %edi,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, edi
imul edi, esi
mulsd xmm0, xmm0
add edi, edi
cvtsi2sd xmm1, edi
addsd xmm1, xmm0
cvttsd2si eax, xmm1
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)((double)(2 * a2 * a1) + (double)a1 * (double)a1);
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDI
IMUL EDI,ESI
MULSD XMM0,XMM0
ADD EDI,EDI
CVTSI2SD XMM1,EDI
ADDSD XMM1,XMM0
CVTTSD2SI EAX,XMM1
RET | int func0(int param_1,int param_2)
{
return (int)((double)(param_1 * param_2 * 2) + (double)param_1 * (double)param_1);
} |
6,220 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
je 1161 <func0+0x18>
mov $0x0,%eax
jmp 1166 <func0+0x1d>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jz short loc_1161
mov eax, 0
jmp short loc_1166
loc_1161:
mov eax, 1
loc_1166:
pop rbp
retn | _BOOL8 func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JZ 0x00101161
MOV EAX,0x0
JMP 0x00101166
LAB_00101161:
MOV EAX,0x1
LAB_00101166:
POP RBP
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,221 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
sete %al
retq
| func0:
endbr64
test edi, edi
setz al
retn | bool func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
TEST EDI,EDI
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,222 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
setz al
retn | bool func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
TEST EDI,EDI
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,223 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int dict1) {
if (dict1) {
return false;
} else {
return true;
}
}
| int main() {
assert(func0(10) == false);
assert(func0(11) == false);
assert(func0(0) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
setz al
retn | bool func0(int a1)
{
return a1 == 0;
} | func0:
ENDBR64
TEST EDI,EDI
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 0;
} |
6,224 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %edi,-0x24(%rbp)
cmpl $0x1,-0x24(%rbp)
jg 1166 <func0+0x1d>
mov $0x1,%eax
jmp 11a7 <func0+0x5e>
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 119c <func0+0x53>
mov -0x14(%rbp),%eax
mov %eax,%edi
callq 1149 <func... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_24], edi
cmp [rbp+var_24], 1
jg short loc_1166
mov eax, 1
jmp short loc_11A7
loc_1166:
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_119C
loc_1176:
mov eax, [rbp+var_14]
mov edi, eax
ca... | long long func0(int a1)
{
int v2; // ebx
unsigned int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
if ( a1 <= 1 )
return 1LL;
v3 = 0;
for ( i = 0; i < a1; ++i )
{
v2 = func0((unsigned int)i);
v3 += v2 * func0((unsigned int)(a1 - i - 1));
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RBP + -0x24],EDI
CMP dword ptr [RBP + -0x24],0x1
JG 0x00101166
MOV EAX,0x1
JMP 0x001011a7
LAB_00101166:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010119c
LAB_00101176:
MOV EAX,dword ptr [RBP + -0x14]
MOV EDI,EAX
CALL 0... | int func0(int param_1)
{
int iVar1;
int iVar2;
int4 local_20;
int4 local_1c;
if (param_1 < 2) {
local_20 = 1;
}
else {
local_20 = 0;
for (local_1c = 0; local_1c < param_1; local_1c = local_1c + 1) {
iVar1 = func0(local_1c);
iVar2 = func0((param_1 - local_1c) + -1);
local_... |
6,225 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov $0x1,%r12d
cmp $0x1,%edi
jle 118f <func0+0x46>
lea -0x1(%rdi),%ebp
mov $0x0,%r12d
mov %ebp,%r13d
mov %r13d,%edi
sub %ebp,%edi
callq 1149 <func0>
mov %eax,%ebx
mov %ebp,%edi
callq 1149 <func0>
imul %eax,... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12d, 1
cmp edi, 1
jle short loc_118F
lea ebp, [rdi-1]
mov r12d, 0
mov r13d, ebp
loc_116E:
mov edi, r13d
sub edi, ebp
call func0
mov ebx, eax
mov edi, ebp
call func0
imul ebx, eax
add r... | long long func0(int a1)
{
unsigned int v1; // r12d
unsigned int v2; // ebp
int v3; // ebx
v1 = 1;
if ( a1 > 1 )
{
v2 = a1 - 1;
v1 = 0;
do
{
v3 = func0(a1 - 1 - v2);
v1 += func0(v2--) * v3;
}
while ( v2 != -1 );
}
return v1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12D,0x1
CMP EDI,0x1
JLE 0x0010118f
LEA EBP,[RDI + -0x1]
MOV R12D,0x0
MOV R13D,EBP
LAB_0010116e:
MOV EDI,R13D
SUB EDI,EBP
CALL 0x00101149
MOV EBX,EAX
MOV EDI,EBP
CALL 0x00101149
IMUL EBX,EAX
ADD R12D,EBX
SUB EBP,0x1
CMP EBP,-0x1
JNZ 0x0010116e
LAB_00101... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = 1;
if (1 < param_1) {
iVar4 = 0;
iVar3 = param_1 + -1;
do {
iVar1 = func0((param_1 + -1) - iVar3);
iVar2 = func0(iVar3);
iVar4 = iVar4 + iVar1 * iVar2;
iVar3 = iVar3 + -1;
} while (iVar3 ... |
6,226 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%edi
jle 1200 <func0+0x10>
jmp 1210 <func0.part.0>
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov [rsp+88h+var_58], edi
mov [rsp+88h+var_5C], 0
test edi, edi
jle loc_24A2
mov eax, edi
mov [rsp+88h+var_6C], 0
sub eax, 1
mov [rsp+88h+var_70], 1
mov [rsp+88h+var_60], eax
loc_122... | long long func0_part_0(int a1)
{
int v1; // eax
int v2; // esi
int v3; // edx
int v4; // r15d
int j; // ecx
int v6; // r9d
int v7; // r11d
int v8; // r14d
int v9; // r13d
int v10; // ebx
int v11; // ebp
unsigned int v12; // r12d
int v13; // r10d
unsigned int v14; // r8d
int v15; // eax
... | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RSP + 0x30],EDI
MOV dword ptr [RSP + 0x2c],0x0
TEST EDI,EDI
JLE 0x001024a2
MOV EAX,EDI
MOV dword ptr [RSP + 0x1c],0x0
SUB EAX,0x1
MOV dword ptr [RSP + 0x18],0x1
MOV dword ptr [RSP + 0x28],EAX
LAB_0010122b:
MOV EAX,dword ptr ... | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
uint uVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int local_7c;
int local_78;
int loca... |
6,227 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num) {
if (num <= 1)
return 1;
int res_num = 0;
for (int i = 0; i < num; i++)
res_num += func0(i) * func0(num - i - 1);
return res_num;
}
| int main() {
assert(func0(10) == 16796);
assert(func0(9) == 4862);
assert(func0(7) == 429);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%edi
jle 12c0 <func0+0x60>
lea -0x1(%rdi),%edx
sub $0x8,%rsp
mov %edi,%esi
xor %r8d,%r8d
mov $0x1,%ecx
cmp $0x1,%edx
jbe 12a4 <func0+0x44>
mov %edx,%edi
callq 11f0 <func0.part.0>
imul %eax,%ecx
mov %esi,%edi
sub %edx,%edi
add %ecx,%r8d
cmp $0x1,%edi
j... | func0_part_0:
push r15
push r14
push r13
push r12
push rbp
xor ebp, ebp
push rbx
sub rsp, 48h
test edi, edi
jle loc_2571
xor r12d, r12d
mov [rsp+78h+var_58], 1
lea ebx, [rdi-1]
mov [rsp+78h+var_4C], r12d
mov [rsp+78h+var_48], ebp
loc_121F:
cmp ebx, 1
jle loc_... | long long func0_part_0(int a1)
{
unsigned int v1; // ebp
int v2; // ebx
int v3; // r12d
int v4; // ebp
int v5; // r12d
int v6; // ebx
int v7; // r14d
int v8; // r15d
long long v9; // rdi
int j; // edx
int v11; // ecx
int v12; // ebp
int v13; // r13d
int v14; // eax
int v15; // edx
int i... | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
XOR EBP,EBP
PUSH RBX
SUB RSP,0x48
TEST EDI,EDI
JLE 0x00102571
XOR R12D,R12D
MOV dword ptr [RSP + 0x20],0x1
LEA EBX,[RDI + -0x1]
MOV dword ptr [RSP + 0x2c],R12D
MOV dword ptr [RSP + 0x30],EBP
LAB_0010121f:
CMP EBX,0x1
JLE 0x00102542
LAB_00101228:
SUB EBX,0x1
MOV... | int func0_part_0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
uint uVar8;
int iVar9;
uint uVar10;
uint uVar11;
int iVar12;
int iVar13;
int iVar14;
bool bVar15;
int local_74;
int local_70;
int local_6c;
int local_68;
int local_64;
... |
6,228 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NU... | int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xe0,%rsp
mov %rdi,-0xd8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0xc0(%rbp),%rax
mov $0x1,%edx
lea 0xd87(%rip),%rsi
mov %rax,%rdi
callq 1130 <regcomp@plt>
test %eax,%eax
je 12a3 <func0+0x5a>
lea 0xd7a(%rip),%rdi... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+preg]
mov edx, 1; cflags
lea rcx, pattern; "\\w+ly"
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
test eax, eax
jz s... | char * func0(const char *a1)
{
regmatch_t v2; // [rsp+18h] [rbp-C8h]
regex_t preg; // [rsp+20h] [rbp-C0h] BYREF
regmatch_t pmatch; // [rsp+68h] [rbp-78h] BYREF
char dest[104]; // [rsp+70h] [rbp-70h] BYREF
unsigned long long v6; // [rsp+D8h] [rbp-8h]
v6 = __readfsqword(0x28u);
if ( regcomp(&preg, "\\w+ly"... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0xd8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xc0]
MOV EDX,0x1
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101130
TEST EAX,EAX
JZ 0x001012a9
LEA RAX,[0x10200e]
MOV RDI,RAX
CALL 0x001010e0
M... | int1 * func0(char *param_1)
{
int iVar1;
int1 *puVar2;
long in_FS_OFFSET;
regex_t local_c8;
regmatch_t local_80;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_c8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_c8,param_1,1,&local_... |
6,229 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NU... | int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0xc8,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xda5(%rip),%rsi
callq 1110 <regcomp@plt>
test %eax,%eax
jne 1325 <func0+0xfc>
lea 0x48(%rsp),%rcx
mov %rsp,... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+0E8h+var_30], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aWLy; "\\w+ly"
call _regcomp
test eax, eax
jnz loc_1345
lea rcx, [rsp+0E8h+var_A0]
mov rdi,... | void * func0(long long a1)
{
int v1; // r12d
int v2; // r13d
long long v3; // rbp
_BYTE v5[72]; // [rsp+0h] [rbp-E8h] BYREF
int v6; // [rsp+48h] [rbp-A0h] BYREF
int v7; // [rsp+4Ch] [rbp-9Ch]
char v8[104]; // [rsp+50h] [rbp-98h] BYREF
unsigned long long v9; // [rsp+B8h] [rbp-30h]
v9 = __readfsqword(0... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102004]
CALL 0x00101120
TEST EAX,EAX
JNZ 0x00101345
LEA RCX,[RSP + 0x48]
MOV RDI,RSP
MOV R8D,0x0
MOV EDX,0x1
MOV RSI,RBX
CALL 0x00101140
T... | int1 * func0(char *param_1)
{
int iVar1;
int1 *puVar2;
long in_FS_OFFSET;
regex_t local_e8;
regmatch_t local_a0;
int1 local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_e8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_e8,param_1,1,&local_... |
6,230 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NU... | int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
mov $0x1,%edx
lea 0xce2(%rip),%rsi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0xc0,%rsp
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 1110 <regcomp@plt>
test %eax,%eax
jne 1420 <func0+0x110>
xor ... | func0:
endbr64
push r14
mov edx, 1
lea rsi, aWLy; "\\w+ly"
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0C0h
mov rax, fs:28h
mov [rsp+var_sB8], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
test eax, eax
jnz loc_1430
xor r8d, r8d
l... | void * func0(long long a1)
{
int v1; // r14d
int v2; // r13d
long long v3; // r12
const char *v4; // rax
_BYTE _0[72]; // [rsp+0h] [rbp+0h] BYREF
int vars48; // [rsp+48h] [rbp+48h] BYREF
int vars4C; // [rsp+4Ch] [rbp+4Ch]
_BYTE vars50[104]; // [rsp+50h] [rbp+50h] BYREF
unsigned long long varsB8; // [r... | func0:
ENDBR64
PUSH R14
MOV EDX,0x1
LEA RSI,[0x102004]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x00101120
TEST EAX,EAX
JNZ 0x00101430
XOR R8D,R8D
LEA RCX,[RSP + 0x48]
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,... | int1 * func0(char *param_1)
{
int iVar1;
int8 uVar2;
int1 *puVar3;
long in_FS_OFFSET;
regex_t rStack_e8;
regmatch_t local_a0;
int1 local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_e8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_e8,... |
6,231 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
regmatch_t match[1];
static char result[100]; // Ensure it's large enough to hold a result message
// Compile regular expression
if (regcomp(®ex, "\\w+ly", REG_EXTENDED) != 0) {
printf("Could not compile regex\n");
return NU... | int main() {
assert(strcmp(func0("Clearly, he has no excuse for such behavior."), "0-7: Clearly") == 0);
assert(strcmp(func0("Please handle the situation carefuly"), "28-36: carefuly") == 0);
assert(strcmp(func0("Complete the task quickly"), "18-25: quickly") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
mov $0x1,%edx
lea 0xce2(%rip),%rsi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0xc0,%rsp
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 1110 <regcomp@plt>
test %eax,%eax
jne 1420 <func0+0x110>
xor ... | func0:
endbr64
push r14
mov edx, 1; cflags
lea rsi, pattern; "\\w+ly"
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0C0h
mov rax, fs:28h
mov [rsp+var_sB8], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jnz loc_1430
x... | void * func0(char *string)
{
regoff_t rm_eo; // r14d
regoff_t rm_so; // r13d
long long v3; // r12
const char *v4; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
regmatch_t pmatch; // [rsp+48h] [rbp+48h] BYREF
_BYTE vars50[104]; // [rsp+50h] [rbp+50h] BYREF
unsigned long long varsB8; // [rsp+B8h] [rbp+B8h... | func0:
ENDBR64
PUSH R14
MOV EDX,0x1
LEA RSI,[0x102004]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x00101120
TEST EAX,EAX
JNZ 0x00101430
XOR R8D,R8D
LEA RCX,[RSP + 0x48]
MOV EDX,0x1
MOV RSI,RBX
MOV RDI,... | int1 * func0(char *param_1)
{
int iVar1;
int8 uVar2;
int1 *puVar3;
long in_FS_OFFSET;
regex_t rStack_e8;
regmatch_t local_a0;
int local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_e8,"\\w+ly",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_e8,p... |
6,232 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->pr... | Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .p... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x8c(%rip),%rcx
mov $0x20,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x20(%rbp),%eax
cltq
shl $0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 20h ; ' '; size
mov rdi, rax; base
call _qs... | char * func0(char *a1, int a2, int a3)
{
char *v3; // rsi
char *v4; // rcx
long long v5; // rdx
long long v6; // rdx
int i; // [rsp+14h] [rbp-Ch]
char *v10; // [rsp+18h] [rbp-8h]
qsort(a1, a2, 0x20uLL, compare);
v10 = (char *)malloc(32LL * a3);
for ( i = 0; i < a3; ++i )
{
v3 = &a1[32 * i];
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x20
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP +... | void * func0(void *param_1,int param_2,int param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
void *pvVar4;
int local_14;
qsort(param_1,(long)param_2,0x20,compare);
pvVar4 = malloc((long)param_3 << 5);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
puVar1 = (int8 *)((long)loca... |
6,233 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->pr... | Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .p... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %edx,%ebp
movslq %esi,%rsi
lea -0x3f(%rip),%rcx
mov $0x20,%edx
callq 10a0 <qsort@plt>
movslq %ebp,%rdi
shl $0x5,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 124f <func0+0x60>
lea -0x1(%rbp),%ecx
add $0x1,%rcx
shl ... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, edx
movsxd rsi, esi
lea rcx, compare
mov edx, 20h ; ' '
call _qsort
movsxd rdi, ebp
shl rdi, 5
call _malloc
test ebp, ebp
jle short loc_124A
mov ecx, ebp
shl rcx, 5
mov edx, 0
loc_122D:
movdqu xmm... | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
long long v5; // rdx
qsort(a1, a2, 32LL, compare);
result = malloc(32LL * a3);
if ( a3 > 0 )
{
v5 = 0LL;
do
{
*(__m128i *)(result + v5) = _mm_loadu_si128((const __m128i *)(a1 + v5));
*(__m128i *)(result + v5 +... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,EDX
MOVSXD RSI,ESI
LEA RCX,[0x1011c9]
MOV EDX,0x20
CALL 0x001010a0
MOVSXD RDI,EBP
SHL RDI,0x5
CALL 0x001010d0
TEST EBP,EBP
JLE 0x0010124a
MOV ECX,EBP
SHL RCX,0x5
MOV EDX,0x0
LAB_0010122d:
MOVDQU XMM0,xmmword ptr [RBX + RDX*0x1]
MOVUPS xmmword ptr [RAX + R... | void func0(void *param_1,int param_2,uint param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
void *pvVar4;
long lVar5;
qsort(param_1,(long)param_2,0x20,compare);
pvVar4 = malloc((long)(int)param_3 << 5);
if (0 < (int)param_3) {
lVar5 = 0;
do {
uVar3 = ((int8 *)((long)param_1 + lVar5))[... |
6,234 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->pr... | Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .p... | O2 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
mov %edx,%ebp
lea -0x41(%rip),%rcx
push %rbx
mov $0x20,%edx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10a0 <qsort@plt>
movslq %ebp,%rdi
shl $0x5,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 14fd <func0+0x5d>
lea -0x1(%rbp),%ecx
xor %edx,%edx
add ... | func0:
endbr64
push r12
movsxd r12, edx
movsxd rsi, esi
lea rcx, compare
push rbp
mov edx, 20h ; ' '
mov rbp, rdi
push rbx
mov rbx, r12
shl r12, 5
call _qsort
mov rdi, r12
call _malloc
mov r8, rax
test ebx, ebx
jle short loc_1509
mov rdx, r12
mov rsi, rbp
mov ... | long long func0(long long a1, int a2, int a3)
{
long long v4; // r12
long long v5; // rax
long long v6; // rcx
long long v7; // r8
v4 = 32LL * a3;
qsort(a1, a2, 32LL, compare);
v5 = malloc(v4);
v7 = v5;
if ( a3 > 0 )
return memcpy(v5, a1, v4, v6, v5);
return v7;
} | func0:
ENDBR64
PUSH R12
MOVSXD R12,EDX
MOVSXD RSI,ESI
LEA RCX,[0x101490]
PUSH RBP
MOV EDX,0x20
MOV RBP,RDI
PUSH RBX
MOV RBX,R12
SHL R12,0x5
CALL 0x001010b0
MOV RDI,R12
CALL 0x001010f0
MOV R8,RAX
TEST EBX,EBX
JLE 0x00101509
MOV RDX,R12
MOV RSI,RBP
MOV RDI,RAX
CALL 0x001010e0
MOV R8,RAX
LAB_00101509:
POP RBX
MOV RAX,R8
P... | void * func0(void *param_1,int param_2,int param_3)
{
void *__dest;
qsort(param_1,(long)param_2,0x20,compare);
__dest = malloc((long)param_3 << 5);
if (0 < param_3) {
__dest = memcpy(__dest,param_1,(long)param_3 << 5);
}
return __dest;
} |
6,235 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char name[20];
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item*)a;
Item *itemB = (Item*)b;
if (itemB->price > itemA->price) {
return 1;
} else if (itemB->pr... | Item* func0(Item items[], int total_items, int n) {
qsort(items, total_items, sizeof(Item), compare);
Item *expensiveItems = malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
expensiveItems[i] = items[i];
}
return expensiveItems;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}, {.name = "Item-3", .price = 45.09}};
Item items3[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .p... | O3 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
lea -0x3f(%rip),%rcx
mov %rdi,%rbp
push %rbx
mov %edx,%ebx
mov $0x20,%edx
sub $0x8,%rsp
callq 10b0 <qsort@plt>
movslq %ebx,%rdi
shl $0x5,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r8
test %ebx,%ebx
jle 150f <func0+0x4f>
lea -0x1(%rbx),%edx
mov ... | func0:
endbr64
push rbp
lea rcx, compare; compar
movsxd rsi, esi; nmemb
mov rbp, rdi
push rbx
mov ebx, edx
mov edx, 20h ; ' '; size
sub rsp, 8
call _qsort
movsxd rdi, ebx
shl rdi, 5; size
call _malloc
mov rcx, rax
test ebx, ebx
jle short loc_150A
mov edx, ebx
mov ... | void * func0(void *src, int a2, int a3)
{
void *v4; // rax
void *v5; // rcx
qsort(src, a2, 0x20uLL, compare);
v4 = malloc(32LL * a3);
v5 = v4;
if ( a3 > 0 )
return memcpy(v4, src, 32LL * (unsigned int)a3);
return v5;
} | func0:
ENDBR64
PUSH RBP
LEA RCX,[0x101490]
MOVSXD RSI,ESI
MOV RBP,RDI
PUSH RBX
MOV EBX,EDX
MOV EDX,0x20
SUB RSP,0x8
CALL 0x001010b0
MOVSXD RDI,EBX
SHL RDI,0x5
CALL 0x001010f0
MOV RCX,RAX
TEST EBX,EBX
JLE 0x0010150a
MOV EDX,EBX
MOV RSI,RBP
MOV RDI,RAX
SHL RDX,0x5
CALL 0x001010e0
MOV RCX,RAX
LAB_0010150a:
ADD RSP,0x8
MOV... | void * func0(void *param_1,int param_2,uint param_3)
{
void *__dest;
qsort(param_1,(long)param_2,0x20,compare);
__dest = malloc((long)(int)param_3 << 5);
if (0 < (int)param_3) {
__dest = memcpy(__dest,param_1,(ulong)param_3 << 5);
}
return __dest;
} |
6,236 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x30(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_30]
movsxd rdx, eax
sub rdx, 1
m... | unsigned long long func0(long long a1, int a2, int a3, long long a4)
{
unsigned long long v4; // rax
void *v5; // rsp
int v6; // eax
int v7; // eax
_BYTE v9[8]; // [rsp+8h] [rbp-40h] BYREF
long long v10; // [rsp+10h] [rbp-38h]
int v11; // [rsp+18h] [rbp-30h]
int v12; // [rsp+1Ch] [rbp-2Ch]
long long ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
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 + -0x30]
MOVSXD RDX,EAX
S... | void func0(long param_1,int param_2,int param_3,long param_4)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int local_38;
int local_34;
long local_30;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_30 = par... |
6,237 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %edx,%rax
lea 0xf(,%rax,4),%r8
mov %r8,%r9
and $0xfffffffffffffff0,%r9
and $0xfffffffffffff000,%r8
mov %rsp,%r11
sub %r8,%r11
mov %r11,%r8
cmp %r8,%rsp
je 11bd <f... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r9d, esi
mov esi, edx
mov r11, rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edx
lea rdx, ds:0Fh[rax*4]
mov r8, rdx
and r8, 0FFFFFFFFFFFFFFF0h
and rdx, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub ... | unsigned long long func0(long long a1, int a2, int a3, long long a4)
{
long long v6; // rax
long long v7; // rdx
__int16 v8; // r8
signed long long v9; // rdx
void *v10; // rsp
long long v11; // rdx
long long v12; // r8
int v13; // eax
long long v14; // rdi
long long v15; // rax
_DWORD v18[2]; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R9D,ESI
MOV ESI,EDX
MOV R11,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
LEA RDX,[0xf + RAX*0x4]
MOV R8,RDX
AND R8,-0x10
AND RDX,-0x1000
MOV RCX,RSP
SUB RCX,RDX
LAB_001011ab:
CMP RSP,RCX
JZ 0x001011c2
SUB RSP,0x1000
OR qwo... | void func0(long param_1,int param_2,uint param_3,long param_4)
{
long lVar1;
long lVar2;
int iVar3;
long lVar4;
ulong uVar5;
int1 *puVar6;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar4 = (long)(int)param_3;
uVar5 = lVar4 * 4 + 0xf;
... |
6,238 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2... | O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %edx,%rax
mov %rsp,%r11
lea 0xf(,%rax,4),%r8
mov %r8,%r9
and $0xfffffffffffff000,%r8
sub %r8,%r11
and $0xfffffffffffffff0,%r9
mov %r11,%r8
cmp %r8,%rsp
je 13d7 <f... | func0:
endbr64
push rbp
movsxd rdx, edx
mov rbp, rsp
push r15
mov r15, rcx
lea rcx, ds:0[rdx*4]
push r14
mov r14, rdx
push r13
mov r13, rdi
push r12
mov r12d, esi
push rbx
mov rbx, rdx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea ... | unsigned long long func0(long long a1, int a2, int a3, long long a4)
{
long long v5; // rcx
long long v9; // rbx
long long *v10; // rdi
signed long long v11; // rsi
void *v12; // rsp
_BYTE *v13; // r8
long long v14; // rax
int v15; // eax
_BYTE v18[4088]; // [rsp+8h] [rbp-1050h] BYREF
long long v19... | func0:
ENDBR64
PUSH RBP
MOVSXD RDX,EDX
MOV RBP,RSP
PUSH R15
MOV R15,RCX
LEA RCX,[RDX*0x4]
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV RBX,RDX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RCX + 0xf]
MOV RDI,RSP
MOV RSI,RAX
AND RAX,-0x1000
... | void func0(void *param_1,int param_2,int param_3,long param_4)
{
long lVar1;
int iVar2;
int1 *puVar3;
long lVar4;
long lVar5;
size_t __n;
int1 *puVar6;
ulong uVar8;
long in_FS_OFFSET;
int1 auStack_58 [8];
long local_50;
long local_40;
int1 *puVar7;
lVar5 = (long)param_3;
lVar4 = lVar5 ... |
6,239 | func0 | #include <assert.h>
#include <stdio.h>
| void func0(int a[], int n, int k, int result[]) {
int b[k];
int i;
for (i = 0; i < k; i++) {
b[i] = a[i];
}
int j = 0;
for (i = k; i < n; i++) {
result[j++] = a[i];
}
for (i = 0; i < k; i++) {
result[j++] = b[i];
}
}
| int main() {
int result[6];
func0((int[]){12, 10, 5, 6, 52, 36}, 6, 2, result);
assert(result[0] == 5 && result[1] == 6 && result[2] == 52 && result[3] == 36 && result[4] == 12 && result[5] == 10);
func0((int[]){1, 2, 3, 4}, 4, 1, result);
assert(result[0] == 2 && result[1] == 3 && result[2... | O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
mov %rdi,%r15
push %r14
movslq %edx,%r14
push %r13
lea 0x0(,%r14,4),%r9
mov %esi,%r13d
push %r12
mov %rcx,%r12
push %rbx
mov %r14,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0xf(%r9),%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15, rcx
push r14
push r13
mov r13, rdi
push r12
mov r12d, esi
push rbx
movsxd rbx, edx
lea r8, ds:0[rbx*4]
mov r14, rbx
sub rsp, 28h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [r8+0Fh]
mov ... | unsigned long long func0(char *src, int a2, int a3, long long a4)
{
long long v6; // rbx
long long v7; // r8
long long *v9; // rcx
signed long long v10; // rdx
void *v11; // rsp
_BYTE *v12; // rcx
_BYTE *v13; // rax
int v14; // edx
long long v15; // r9
char *v17; // r8
long long v18; // rax
uns... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15,RCX
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12D,ESI
PUSH RBX
MOVSXD RBX,EDX
LEA R8,[RBX*0x4]
MOV R14,RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[R8 + 0xf]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AN... | void func0(void *param_1,int param_2,uint param_3,long param_4)
{
int iVar1;
int8 *puVar2;
long lVar3;
int8 uVar4;
long *plVar5;
uint uVar6;
int *__src;
uint uVar7;
ulong uVar8;
long lVar9;
long *plVar10;
int iVar12;
long lVar13;
long in_FS_OFFSET;
long local_58;
ulong local_50;
long ... |
6,240 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f6 <func0+0x4d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%r... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_4], 0
jmp short loc_11F6
loc_11C5:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_4]
movsxd rdx, edx
le... | long long func0(long long a1, int a2, long long a3)
{
int i; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2; ++i )
*(_DWORD *)(4LL * i + a3) = *(_DWORD *)(4LL * i + a1);
return a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f6
LAB_001011c5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x4]... | long func0(long param_1,int param_2,long param_3)
{
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(int4 *)(param_3 + (long)local_c * 4) = *(int4 *)(param_1 + (long)local_c * 4);
}
return param_3;
} |
6,241 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (... | O1 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 11ce <func0+0x25>
lea -0x1(%rsi),%edx
mov $0x0,%ecx
mov (%rdi,%rcx,4),%esi
mov %esi,(%rax,%rcx,4)
mov %rcx,%rsi
add $0x1,%rcx
cmp %rdx,%rsi
jne 11bc <func0+0x13>
retq
| func0:
endbr64
mov rax, rdx
test esi, esi
jle short locret_11CC
mov esi, esi
mov ecx, 0
loc_11BB:
mov r8d, [rdi+rcx*4]
mov [rax+rcx*4], r8d
add rcx, 1
cmp rcx, rsi
jnz short loc_11BB
locret_11CC:
retn | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
long long i; // rcx
result = a3;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RDX
TEST ESI,ESI
JLE 0x001011cc
MOV ESI,ESI
MOV ECX,0x0
LAB_001011bb:
MOV R8D,dword ptr [RDI + RCX*0x4]
MOV dword ptr [RAX + RCX*0x4],R8D
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001011bb
LAB_001011cc:
RET | void func0(long param_1,uint param_2,long param_3)
{
ulong uVar1;
if (0 < (int)param_2) {
uVar1 = 0;
do {
*(int4 *)(param_3 + uVar1 * 4) = *(int4 *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return;
} |
6,242 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (... | O2 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 12c2 <func0+0x22>
lea -0x1(%rsi),%edx
xor %ecx,%ecx
mov (%rdi,%rcx,4),%esi
mov %esi,(%rax,%rcx,4)
mov %rcx,%rsi
add $0x1,%rcx
cmp %rdx,%rsi
jne 12b0 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov rax, rdx
test esi, esi
jle short locret_1401
movsxd rsi, esi
xor ecx, ecx
loc_13F0:
mov r8d, [rdi+rcx*4]
mov [rax+rcx*4], r8d
add rcx, 1
cmp rcx, rsi
jnz short loc_13F0
locret_1401:
retn | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
long long i; // rcx
result = a3;
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RDX
TEST ESI,ESI
JLE 0x00101401
MOVSXD RSI,ESI
XOR ECX,ECX
LAB_001013f0:
MOV R8D,dword ptr [RDI + RCX*0x4]
MOV dword ptr [RAX + RCX*0x4],R8D
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001013f0
LAB_00101401:
RET | void func0(long param_1,int param_2,long param_3)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
*(int4 *)(param_3 + lVar1 * 4) = *(int4 *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
}
return;
} |
6,243 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| void *func0(int *listx, int size, int *result){
for(int i = 0; i < size; i++){
result[i] = listx[i];
}
return result;
}
| int main() {
int result1[6];
int list1[6] = {5, 10, 7, 4, 15, 3};
func0(list1, 6, result1);
assert(memcmp(result1, (int[]){5, 10, 7, 4, 15, 3}, sizeof(result1)) == 0);
int result2[9];
int list2[9] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
func0(list2, 9, result2);
assert(memcmp(result2, (... | O3 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 13ea <func0+0x9a>
lea 0xf(%rax),%rcx
lea -0x1(%rsi),%edx
sub %rdi,%rcx
cmp $0x1e,%rcx
jbe 13d0 <func0+0x80>
cmp $0x3,%edx
jbe 13d0 <func0+0x80>
mov %esi,%edx
xor %ecx,%ecx
shr $0x2,%edx
shl $0x4,%rdx
movdqu (%rdi,%rcx,1),%xmm0
movu... | func0:
endbr64
movsxd rax, esi
mov rsi, rdx
test eax, eax
jle short loc_135F
lea edx, [rax-1]
cmp edx, 2
jbe short loc_1346
lea rcx, [rdi+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
ja short loc_1368
loc_1346:
lea rdx, ds:0[rax*4]
xor eax, eax
loc_1350:
mov ecx, [rdi... | long long func0(long long a1, int a2, long long a3)
{
long long v3; // rax
long long v5; // rdx
long long v6; // rax
long long v8; // rdx
unsigned int v9; // edx
long long v10; // rcx
v3 = a2;
if ( (int)v3 <= 0 )
return a3;
if ( (unsigned int)(v3 - 1) <= 2 || (unsigned long long)(a3 - (a1 + 4)) ... | func0:
ENDBR64
MOVSXD RAX,ESI
MOV RSI,RDX
TEST EAX,EAX
JLE 0x0010135f
LEA EDX,[RAX + -0x1]
CMP EDX,0x2
JBE 0x00101346
LEA RCX,[RDI + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JA 0x00101368
LAB_00101346:
LEA RDX,[RAX*0x4]
XOR EAX,EAX
LAB_00101350:
MOV ECX,dword ptr [RDI + RAX*0x1]
MOV dword ptr [RSI + RAX*0x1],ECX
ADD RA... | long func0(long param_1,uint param_2,long param_3)
{
int8 uVar1;
long lVar2;
uint uVar3;
ulong uVar4;
if (0 < (int)param_2) {
if ((param_2 - 1 < 3) || ((ulong)(param_3 - (param_1 + 4)) < 9)) {
lVar2 = 0;
do {
*(int4 *)(param_3 + lVar2) = *(int4 *)(param_1 + lVar2);
lVar2 = ... |
6,244 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x80000000,-0xc(%rbp)
movl $0x7fffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11fb <func0+0x92>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 80000000h
mov [rbp+var_8], 7FFFFFFFh
mov [rbp+var_4], 0
jmp short loc_11FB
loc_118F:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ... | long long func0(long long a1, int a2)
{
signed int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0x80000000;
v4 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( v3 < *(_DWORD *)(4LL * i + a1) )
v3 = *(_DWORD *)(4LL * i + a1);
if ( v4 > *(_DWORD *)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x80000000
MOV dword ptr [RBP + -0x8],0x7fffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011fb
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18... | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = -0x80000000;
local_10 = 0x7fffffff;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_14 < *(int *)(param_1 + (long)local_c * 4)) {
local_14 = *(int *)(param_1 + (long)local_c * 4... |
6,245 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 119e <func0+0x35>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x7fffffff,%esi
mov $0x80000000,%eax
mov (%rcx),%edx
cmp %edx,%eax
cmovl %edx,%eax
cmp %edx,%esi
cmovg %edx,%esi
add $0x4,%rcx
cmp %rdi,%rcx
jne 1186 <func0+0x1d>
... | func0:
endbr64
test esi, esi
jle short loc_119E
mov rcx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
mov esi, 7FFFFFFFh
mov eax, 80000000h
loc_1186:
mov edx, [rcx]
cmp eax, edx
cmovl eax, edx
cmp esi, edx
cmovg esi, edx
add rcx, 4
cmp rcx, rdi
jnz short loc_1186
lo... | long long func0(signed int *a1, int a2)
{
signed int *v2; // rcx
long long v3; // rdi
int v4; // esi
signed int v5; // eax
if ( a2 <= 0 )
{
v4 = 0x7FFFFFFF;
v5 = 0x80000000;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x7FFFFFFF;
v5 = 0x80000000;
do
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119e
MOV RCX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
MOV ESI,0x7fffffff
MOV EAX,0x80000000
LAB_00101186:
MOV EDX,dword ptr [RCX]
CMP EAX,EDX
CMOVL EAX,EDX
CMP ESI,EDX
CMOVG ESI,EDX
ADD RCX,0x4
CMP RCX,RDI
JNZ 0x00101186
LAB_0010119b:
SUB EAX,ESI
RET
LAB_0010119e:
MOV... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_2 < 1) {
iVar4 = 0x7fffffff;
iVar3 = -0x80000000;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0x7fffffff;
iVar3 = -0x80000000;
do {
iVar2 = *param_1;
if (... |
6,246 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
mov $0x7fffffff,%ecx
lea 0x4(%rdi,%rax,4),%rsi
mov $0x80000000,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%edx
cmp %edx,%eax
cmovl %edx,%eax
cmp %edx,%ecx
cmovg %edx,%ecx
add $0x4,%rdi
cmp %rsi,%rdi
jne 1160 <func0... | func0:
endbr64
test esi, esi
jle short loc_1180
lea eax, [rsi-1]
mov ecx, 7FFFFFFFh
lea rsi, [rdi+rax*4+4]
mov eax, 80000000h
nop word ptr [rax+rax+00h]
loc_1160:
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
cmp ecx, edx
cmovg ecx, edx
add rdi, 4
cmp rdi, rsi
jnz sho... | long long func0(signed int *a1, int a2)
{
int v2; // ecx
long long v3; // rsi
signed int v4; // eax
if ( a2 <= 0 )
return 1LL;
v2 = 0x7FFFFFFF;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x80000000;
do
{
if ( v4 < *a1 )
v4 = *a1;
if ( v2 > *a1 )
v2 = *a1;
++a1;
}
while ( a... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101180
LEA EAX,[RSI + -0x1]
MOV ECX,0x7fffffff
LEA RSI,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x80000000
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVL EAX,EDX
CMP ECX,EDX
CMOVG ECX,EDX
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x00101160
SUB EAX,ECX
RET
LAB_00101180:
... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
iVar4 = 0x7fffffff;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = -0x80000000;
do {
iVar2 = *param_1;
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
if (iVar... |
6,247 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_val = INT_MIN;
int min_val = INT_MAX;
for (int i = 0; i < size; i++) {
if (nums[i] > max_val) {
max_val = nums[i];
}
if (nums[i] < min_val) {
min_val = nums[i];
}
}
return max_val - min_val;
... | int main() {
int arr1[] = {1, 2, 3, 4};
int arr2[] = {4, 5, 12};
int arr3[] = {9, 2, 3};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 3) == 8);
assert(func0(arr3, 3) == 7);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1298 <func0+0x158>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 129e <func0+0x15e>
mov %esi,%edx
movdqa 0xeae(%rip),%xmm4
movdqa 0xeb6(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqa %xmm1,%xmm... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1298
lea eax, [rsi-1]
cmp eax, 2
jbe loc_129E
mov edx, esi
movdqa xmm3, cs:xmmword_2010
movdqa xmm1, cs:xmmword_2020
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1180:
movdqu xmm0, xm... | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm3
__m128i v4; // xmm1
const __m128i *v5; // rax
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm2
__m128i v9; // xmm0
signed int v10; // esi
__m128i v11; // xmm2
__m128i v12; // xmm2
__m128i v13; // xmm3
__m128i v14; //... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101298
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x0010129e
MOV EDX,ESI
MOVDQA XMM3,xmmword ptr [0x00102010]
MOVDQA XMM1,xmmword ptr [0x00102020]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM2,XMM1
AD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
... |
6,248 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
... | int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %esi,-0x28(%rbp)
mov %rdx,-0x30(%rbp)
mov -0x28(%rbp),%eax
sub -0x24(%rbp),%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov [rbp+var_30], rdx
mov eax, [rbp+var_28]
sub eax, [rbp+var_24]
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov ... | _DWORD * func0(int a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
_DWORD *v9; // [rsp+28h] [rbp-8h]
v9 = malloc(4LL * (a2 - a1 + 1));
v6 = 0;
for ( i = a1; i <= a2; ++i )
{
for ( j = 1; i >= j * j; ++j )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV qword ptr [RBP + -0x30],RDX
MOV EAX,dword ptr [RBP + -0x28]
SUB EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0... | void * func0(int param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)((param_2 - param_1) + 1) << 2);
local_1c = 0;
local_18 = param_1;
do {
if (param_2 < local_18) {
*param_3 = local_1c;
return pvVar1;
}
for (l... |
6,249 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
... | int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov %esi,%r12d
mov %rdx,%rbp
mov %esi,%edi
sub %ebx,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
cmp %ebx,%r12d
jl 120b <func0+0x62>
lea 0x1(%r12),%edi
mov $0x0,%esi
jmp 11ed <func0+0x44>
... | func0:
endbr64
push r12
push rbp
push rbx
mov ebx, edi
mov r12d, esi
mov rbp, rdx
mov edi, esi
sub edi, ebx
add edi, 1
movsxd rdi, edi
shl rdi, 2
call _malloc
cmp r12d, ebx
jl short loc_120B
lea edi, [r12+1]
mov esi, 0
jmp short loc_11ED
loc_11DD:
movsxd rd... | long long func0(int a1, int a2, _DWORD *a3)
{
int v3; // ebx
long long result; // rax
int v7; // esi
int v8; // edx
v3 = a1;
result = malloc(4LL * (a2 - a1 + 1));
if ( a2 < a1 )
{
v7 = 0;
}
else
{
v7 = 0;
do
{
if ( v3 > 0 )
{
if ( v3 == 1 )
{
LABEL_3:
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV R12D,ESI
MOV RBP,RDX
MOV EDI,ESI
SUB EDI,EBX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
CMP R12D,EBX
JL 0x0010120b
LEA EDI,[R12 + 0x1]
MOV ESI,0x0
JMP 0x001011ed
LAB_001011dd:
MOVSXD RDX,ESI
MOV dword ptr [RAX + RDX*0x4],EBX
LEA ESI,[RSI + 0x1]
LAB_0... | void func0(int param_1,int param_2,int *param_3)
{
void *pvVar1;
int iVar2;
int iVar3;
pvVar1 = malloc((long)((param_2 - param_1) + 1) << 2);
if (param_2 < param_1) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
if (0 < param_1) {
if (param_1 != 1) {
iVar2 = 1;
do ... |
6,250 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
... | int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
... | O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %esi,%ebp
push %rbx
mov %edi,%ebx
mov %esi,%edi
sub %ebx,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
cmp %ebx,%ebp
jl 1433 <func0+0x73>
lea 0x1(%rbp),%edi
xor %r8d,%r8d
nopl 0x0(%rax)
test %eb... | func0:
endbr64
push r12
mov r12, rdx
push rbp
mov ebp, esi
push rbx
mov ebx, edi
mov edi, esi
sub edi, ebx
add edi, 1
movsxd rdi, edi
shl rdi, 2
call _malloc
cmp ebp, ebx
jl short loc_1432
lea esi, [rbp+1]
xor edi, edi
nop dword ptr [rax+rax+00h]
loc_13F0:
t... | long long func0(int a1, int a2, _DWORD *a3)
{
int v4; // ebx
long long result; // rax
int v6; // esi
int v7; // edi
int v8; // edx
long long v9; // rdx
v4 = a1;
result = malloc(4LL * (a2 - a1 + 1));
if ( a2 >= a1 )
{
v6 = a2 + 1;
v7 = 0;
while ( 1 )
{
while ( v4 <= 0 )
... | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDI
MOV EDI,ESI
SUB EDI,EBX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
CMP EBP,EBX
JL 0x00101432
LEA ESI,[RBP + 0x1]
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001013f0:
TEST EBX,EBX
JLE 0x0010140e
CMP EBX,0x1
JZ 0x00101420
MOV EDX... | void func0(int param_1,int param_2,int *param_3)
{
void *pvVar1;
int iVar2;
long lVar3;
int iVar4;
pvVar1 = malloc((long)((param_2 - param_1) + 1) << 2);
if (param_2 < param_1) {
*param_3 = 0;
return;
}
iVar4 = 0;
do {
while (0 < param_1) {
if (param_1 != 1) {
iVar2 = 1;
... |
6,251 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int a, int b, int *size) {
int* lists = malloc((b - a + 1) * sizeof(int));
int idx = 0;
for (int i = a; i <= b; i++) {
int j = 1;
while (j * j <= i) {
if (j * j == i) {
lists[idx++] = i;
break;
}
j++;
... | int main() {
int size;
int *result;
result = func0(1, 30, &size);
int expected_1[] = {1, 4, 9, 16, 25};
int expected_1_size = sizeof(expected_1) / sizeof(expected_1[0]);
assert(size == expected_1_size);
for (int i = 0; i < size; i++) {
assert(result[i] == expected_1[i]);
... | O3 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %esi,%ebp
push %rbx
mov %edi,%ebx
mov %esi,%edi
sub %ebx,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
cmp %ebx,%ebp
jl 14e4 <func0+0x124>
test %ebx,%ebx
jle 1428 <func0+0x68>
xor %esi,%esi
mov ... | func0:
endbr64
push r12
mov r12, rdx
push rbp
mov ebp, esi
push rbx
mov ebx, edi
mov edi, esi
sub edi, ebx
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax
cmp ebp, ebx
jl loc_1470
mov eax, ebx
test ebx, ebx
jg short loc_1439
xor ... | _DWORD * func0(signed int a1, int a2, _DWORD *a3)
{
signed int v5; // ebx
_DWORD *v6; // rdi
int v7; // eax
signed int v8; // edx
unsigned int v9; // esi
__m128i si128; // xmm2
int v11; // eax
__m128i v12; // xmm0
__m128i v13; // xmm1
int v14; // ebx
int v15; // esi
int v16; // edx
long long v... | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDI
MOV EDI,ESI
SUB EDI,EBX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
CMP EBP,EBX
JL 0x00101470
MOV EAX,EBX
TEST EBX,EBX
JG 0x00101439
XOR EDX,EDX
TEST EBP,EBP
MOV ECX,0x1
CMOVLE EDX,EBP
MOV EAX,EDX
SUB EAX,EBX
CMP EBX,ED... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(int param_1,int param_2,int *param_3)
{
uint uVar1;
uint uVar2;
void *pvVar3;
int iVar4;
long lVar5;
int iVar6;
int iVar7;
pvVar3 = malloc((long)((param_2 - param_1) + 1) << 2);
if (param_2 < param_1... |
6,252 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.051650212548... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x58(%rbp)
movsd %xmm0,-0x60(%rbp)
movsd %xmm1,-0x68(%rbp)
movsd -0x68(%rbp),%xmm0
pxor %xmm1,%xmm1
mulsd %xmm0,%xmm1
addsd -0x60(%rbp),%xmm1
movsd %xmm1,-0x40(%rbp)
movsd %xmm0,-0x38(%rbp)
mov -0x40(%rbp),%rax
movsd -0x38(%rbp),%xm... | func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+var_68], rdi
movsd [rbp+var_70], xmm0
movsd [rbp+var_78], xmm1
movsd xmm0, [rbp+var_78]
movsd [rbp+y], xmm0
movsd xmm1, [rbp+y]
pxor xmm0, xmm0
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_70]
addsd xmm0, xmm1
movsd [... | double * func0(double *a1, double a2, double a3)
{
double x; // [rsp+20h] [rbp-60h]
double v5; // [rsp+60h] [rbp-20h]
double v6; // [rsp+68h] [rbp-18h]
x = 0.0 * a3 + a2;
v5 = cabs(x, a3);
v6 = atan2(a3, x);
*a1 = v5;
a1[1] = v6;
a1[2] = -2.0;
a1[3] = 2.449293598294706e-16;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x68],RDI
MOVSD qword ptr [RBP + -0x70],XMM0
MOVSD qword ptr [RBP + -0x78],XMM1
MOVSD XMM0,qword ptr [RBP + -0x78]
MOVSD qword ptr [RBP + -0x58],XMM0
MOVSD XMM1,qword ptr [RBP + -0x58]
PXOR XMM0,XMM0
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x7... | double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
param_1 = param_2 * 0.0 + param_1;
dVar3 = cabs(param_1);
dVar4 = atan2(param_2,param_1);
dVar2 = DAT_00102128;
dVar1 = DAT_00102120;
*param_3 = dVar3;
param_3[1] = dVar4;
... |
6,253 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.051650212548... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
movapd %xmm1,%xmm2
mulsd 0xf7e(%rip),%xmm1
addsd %xmm0,%xmm1
movsd %xmm1,(%rsp)
movapd %xmm1,%xmm0
movsd %xmm2,0x8(%rsp)
movapd %xmm2,%xmm1
callq 10b0 <cabs@plt>
movq %xmm0,%rbp
movsd (%rsp),%xmm1
movsd 0x8(%rsp),%xmm0
callq 10a0 <atan2... | func0:
endbr64
push r14
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
movapd xmm2, xmm0
movq rbp, xmm1
movapd xmm0, xmm1
mulsd xmm0, cs:qword_2118
addsd xmm0, xmm2
movq r14, xmm0
call _cabs
movq r12, xmm0
movq xmm1, r14
movq xmm0, rbp
call _atan2
mov [rbx], r12
mo... | long long func0(long long a1, double a2, double a3)
{
double v3; // r14
double v4; // r12
double v5; // xmm0_8
v3 = a3 * 0.0 + a2;
v4 = cabs();
v5 = atan2(a3, v3);
*(double *)a1 = v4;
*(double *)(a1 + 8) = v5;
*(_QWORD *)(a1 + 16) = 0xC000000000000000LL;
*(_QWORD *)(a1 + 24) = 0x3CB1A62633145C07LL... | func0:
ENDBR64
PUSH R14
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOVAPD XMM2,XMM0
MOVQ RBP,XMM1
MOVAPD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102118]
ADDSD XMM0,XMM2
MOVQ R14,XMM0
CALL 0x001010b0
MOVQ R12,XMM0
MOVQ XMM1,R14
MOVQ XMM0,RBP
CALL 0x001010a0
MOV qword ptr [RBX],R12
MOVSD qword ptr [RBX + 0x8],XMM0
MO... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
param_1 = param_2 * _DAT_00102118 + param_1;
dVar1 = cabs(param_1);
dVar2 = atan2(param_2,param_1);
*param_3 = dVar1;
param_... |
6,254 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.051650212548... | O2 | c | func0:
endbr64
pxor %xmm3,%xmm3
push %r12
mov %rdi,%r12
mulsd %xmm1,%xmm3
sub $0x20,%rsp
movsd %xmm1,0x10(%rsp)
addsd %xmm0,%xmm3
movapd %xmm3,%xmm0
movsd %xmm3,0x18(%rsp)
callq 1070 <cabs@plt>
movsd 0x18(%rsp),%xmm3
movsd 0x10(%rsp),%xmm2
movsd %xmm0,0x8(%rsp)
movapd %xmm3,%xmm1
movapd %xmm2,%xmm0
ca... | func0:
endbr64
pxor xmm3, xmm3
push r12
mov r12, rdi
mulsd xmm3, xmm1
sub rsp, 20h
movsd [rsp+28h+var_18], xmm1
addsd xmm3, xmm0
movapd xmm0, xmm3
movsd [rsp+28h+var_10], xmm3
call _cabs
movsd xmm3, [rsp+28h+var_10]
movsd xmm2, [rsp+28h+var_18]
movsd [rsp+28h+var_20], xmm0
movapd xmm1, ... | long long func0(long long a1, double a2, double a3)
{
double v3; // xmm0_8
long long result; // rax
double v5; // [rsp+0h] [rbp-20h]
double v6; // [rsp+10h] [rbp-10h]
v6 = 0.0 * a3 + a2;
v5 = cabs(v6);
v3 = atan2(a3, v6);
result = a1;
*(double *)(a1 + 8) = v3;
*(double *)a1 = v5;
*(_QWORD *)(a1 ... | func0:
ENDBR64
PXOR XMM3,XMM3
PUSH R12
MOV R12,RDI
MULSD XMM3,XMM1
SUB RSP,0x20
MOVSD qword ptr [RSP + 0x10],XMM1
ADDSD XMM3,XMM0
MOVAPD XMM0,XMM3
MOVSD qword ptr [RSP + 0x18],XMM3
CALL 0x001010b0
MOVSD XMM3,qword ptr [RSP + 0x18]
MOVSD XMM2,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM1,XMM3
MOVAP... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
param_1 = param_2 * 0.0 + param_1;
dVar1 = cabs(param_1);
dVar2 = atan2(param_2,param_1);
param_3[1] = dVar2;
dVar2 = DAT_00... |
6,255 | func0 |
#include <assert.h>
#include <complex.h>
#include <math.h>
typedef struct {
double r;
double theta;
double complex cn1;
} PolarRect;
| PolarRect func0(double x, double y) {
double complex cn = x + y * I;
double r = cabs(cn);
double theta = carg(cn);
double complex cn1 = 2 * cexp(I * M_PI);
PolarRect result;
result.r = r;
result.theta = theta;
result.cn1 = cn1;
return result;
}
| int main() {
PolarRect pr;
pr = func0(3, 4);
assert(pr.r == 5.0);
assert(pr.theta == 0.9272952180016122);
assert(creal(pr.cn1) == -2.0);
assert(cimag(pr.cn1) == 2.4492935982947064e-16);
pr = func0(4, 7);
assert(pr.r == 8.06225774829855);
assert(pr.theta == 1.051650212548... | O3 | c | func0:
endbr64
pxor %xmm4,%xmm4
push %r12
mov %rdi,%r12
mulsd %xmm1,%xmm4
sub $0x20,%rsp
movsd %xmm1,0x10(%rsp)
addsd %xmm0,%xmm4
movapd %xmm4,%xmm0
movsd %xmm4,0x18(%rsp)
callq 1070 <cabs@plt>
movsd 0x18(%rsp),%xmm4
movsd 0x10(%rsp),%xmm3
movsd %xmm0,0x8(%rsp)
movapd %xmm4,%xmm1
movapd %xmm3,%xmm0
ca... | func0:
endbr64
pxor xmm2, xmm2
push rbx
mov rbx, rdi
mulsd xmm2, xmm1
sub rsp, 20h
movsd [rsp+28h+y], xmm1
addsd xmm2, xmm0
movapd xmm0, xmm2
movsd [rsp+28h+x], xmm2
call _cabs
movsd xmm2, [rsp+28h+x]
movsd xmm4, [rsp+28h+y]
movsd [rsp+28h+var_20], xmm0
movapd xmm1, xmm2; x
movapd xmm0... | long long func0(long long a1, double a2, double a3)
{
__m128d v3; // xmm0
long long result; // rax
double v5; // [rsp+0h] [rbp-20h]
double x; // [rsp+10h] [rbp-10h]
x = 0.0 * a3 + a2;
v5 = cabs(x);
v3 = (__m128d)*(unsigned long long *)&a3;
v3.m128d_f64[0] = atan2(a3, x);
result = a1;
*(__m128d *)a... | func0:
ENDBR64
PXOR XMM2,XMM2
PUSH RBX
MOV RBX,RDI
MULSD XMM2,XMM1
SUB RSP,0x20
MOVSD qword ptr [RSP + 0x10],XMM1
ADDSD XMM2,XMM0
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x18],XMM2
CALL 0x00101070
MOVSD XMM2,qword ptr [RSP + 0x18]
MOVSD XMM4,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM1,XMM2
MOVAP... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double * func0(double param_1,double param_2,double *param_3)
{
double dVar1;
double dVar2;
param_1 = param_2 * 0.0 + param_1;
dVar1 = cabs(param_1);
dVar2 = atan2(param_2,param_1);
*param_3 = dVar1;
param_3[1] = dVa... |
6,256 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] ==... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
mov %e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_18]... | int * func0(int *a1, int a2)
{
int v3; // [rsp+18h] [rbp-4h]
v3 = *a1;
*a1 = a1[a2 - 1];
a1[a2 - 1] = v3;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [... | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,257 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] ==... | O1 | c | func0:
endbr64
mov %rdi,%rax
mov (%rdi),%ecx
movslq %esi,%rsi
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
| func0:
endbr64
mov rax, rdi
mov ecx, [rdi]
movsxd rsi, esi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
_DWORD *result; // rax
int v3; // ecx
_DWORD *v4; // rdx
result = a1;
v3 = *a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v3;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV ECX,dword ptr [RDI]
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,258 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] ==... | O2 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi),%ecx
mov %rdi,%rax
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
mov ecx, [rdi]
mov rax, rdi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // ecx
_DWORD *result; // rax
_DWORD *v4; // rdx
v2 = *a1;
result = a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v2;
return result;
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV ECX,dword ptr [RDI]
MOV RAX,RDI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,259 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* newList, int size) {
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
int list1[] = {12, 35, 9, 56, 24};
int list2[] = {1, 2, 3};
int list3[] = {4, 5, 6};
int* result1 = func0(list1, 5);
int* result2 = func0(list2, 3);
int* result3 = func0(list3, 3);
assert(result1[0] == 24 && result1[1] == 35 && result1[2] == 9 && result1[3] ==... | O3 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi),%ecx
mov %rdi,%rax
lea -0x4(%rdi,%rsi,4),%rdx
mov (%rdx),%esi
mov %esi,(%rdi)
mov %ecx,(%rdx)
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
mov ecx, [rdi]
mov rax, rdi
lea rdx, [rdi+rsi*4-4]
mov esi, [rdx]
mov [rdi], esi
mov [rdx], ecx
retn | _DWORD * func0(_DWORD *a1, int a2)
{
int v2; // ecx
_DWORD *result; // rax
_DWORD *v4; // rdx
v2 = *a1;
result = a1;
v4 = &a1[a2 - 1];
*a1 = *v4;
*v4 = v2;
return result;
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV ECX,dword ptr [RDI]
MOV RAX,RDI
LEA RDX,[RDI + RSI*0x4 + -0x4]
MOV ESI,dword ptr [RDX]
MOV dword ptr [RDI],ESI
MOV dword ptr [RDX],ECX
RET | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
uVar1 = *param_1;
*param_1 = param_1[(long)param_2 + -1];
param_1[(long)param_2 + -1] = uVar1;
return param_1;
} |
6,260 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k]... | int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x44(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x2c(%rbp)
shll -0x44(%rbp)
mov -0x2c(%rbp),%eax
add $0x1,%eax
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
sub eax, 1
mov [rbp+var_1C], eax
shl [rbp+var_34], 1
mov eax, [rbp+var_1C]
add eax, 1
movsx... | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
int v3; // eax
_BYTE v5[12]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+14h] [rbp-34h]
int i; // [rsp+20h] [rbp-28h]
int j; // [rsp+24h] [rbp-24h]
int k; // [rsp+28h] [rbp-20h]
int v10; // [rsp+2Ch] [rbp-1Ch]
long long v11; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
SHL dword ptr [RBP + -0x34],0x1
MOV EAX,dword ptr [RBP + -0x1c]
ADD ... | int4 func0(int param_1)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [12];
int local_3c;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_24 = param_1 + -1;... |
6,261 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k]... | int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x1(%rdi),%r8d
lea (%rdi,%rdi,1),%ecx
movslq %edi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov edx, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea edi, [rdi-1]
lea r9d, [rdx+rdx]
movsxd rax, edx
lea rax, ds:0Fh[rax*4]
mov rsi, rax
and rsi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rcx... | long long func0(int a1)
{
int v2; // edi
int v3; // r9d
signed long long v4; // rax
void *v5; // rsp
_DWORD *v6; // rax
_DWORD *v7; // rdx
int v8; // r9d
int v9; // esi
int v10; // edx
long long v11; // rcx
_DWORD *v12; // rax
_DWORD *v13; // rcx
_DWORD v16[2]; // [rsp+8h] [rbp-10h] BYREF
u... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV EDX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EDI,[RDI + -0x1]
LEA R9D,[RDX + RDX*0x1]
MOVSXD RAX,EDX
LEA RAX,[0xf + RAX*0x4]
MOV RSI,RAX
AND RSI,-0x10
AND RAX,-0x1000
MOV RCX,RSP
SUB RCX,RAX
LAB_001011ab:
CMP RSP,RCX
JZ 0x001011c... | int4 func0(int param_1)
{
int iVar1;
long lVar2;
ulong uVar3;
int4 *puVar4;
int *piVar5;
int iVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = param_1 + -1;
uVar3 = (long)param_1 * 4 + 0xf;
for (puV... |
6,262 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k]... | int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
lea -0x1(%rdi),%r8d
lea (%rdi,%rdi,1),%r9d
movslq %edi,%rdi
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xf(,%rdi,4),%rax
mov %rsp,%rdi
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffff... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
lea r12d, [rdi+rdi]
push rbx
lea ebx, [rdi-1]
movsxd rdi, edi
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea rax, ds:0Fh[rdi*4]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub ... | long long func0(int a1)
{
int v1; // r12d
int v2; // ebx
long long v3; // rdx
_DWORD *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
_DWORD *v8; // rdi
int v9; // esi
int v10; // edx
long long v11; // rcx
_DWORD *v12; // rax
long long v13; // rcx
_DWORD v16[1022];... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
LEA R12D,[RDI + RDI*0x1]
PUSH RBX
LEA EBX,[RDI + -0x1]
MOVSXD RDI,EDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA RAX,[0xf + RDI*0x4]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010... | int4 func0(int param_1)
{
uint uVar1;
long lVar2;
int1 *puVar3;
int *piVar4;
uint uVar5;
ulong uVar6;
int1 *puVar7;
uint uVar9;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar8;
uVar1 = param_1 - 1;
puVar7 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uV... |
6,263 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int k = n - 1;
n = n * 2;
int C[k + 1];
for (int i = 0; i < k + 1; i++) {
C[i] = 0;
}
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < k ? i : k); j > 0; j--) {
C[j] = C[j] + C[j - 1];
}
}
return C[k]... | int main() {
assert(func0(3) == 15);
assert(func0(4) == 56);
assert(func0(1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
lea (%rdi,%rdi,1),%r12d
push %rbx
lea -0x1(%rdi),%ebx
movslq %edi,%rdi
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea 0xf(,%rdi,4),%rax
mov %rsp,%rdi
mov %rax,%rdx
and $0xfffffffffffff000,%rax
su... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
mov r12d, edi
push rbx
lea ebx, [rdi-1]
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, edi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx... | long long func0(unsigned int a1)
{
int v2; // ebx
long long v3; // rdx
_DWORD *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
_DWORD *v8; // rdi
_DWORD *v9; // rax
int v10; // esi
int v11; // edx
long long v12; // rax
long long v13; // r9
long long v14; // r10
lon... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBX
LEA EBX,[RDI + -0x1]
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x0010128e
LAB_001... | int4 func0(uint param_1)
{
uint uVar1;
int *piVar2;
int *piVar3;
int *piVar4;
long lVar5;
int8 uVar6;
long lVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
uint uVar14;
int *puVar15;
long lVar16;
ulong uVar17;
uint uVar18;
int *puVar19;
uint uVar21;
... |
6,264 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current... | int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(tes... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xa0,%rsp
mov %rdi,-0x98(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x2b302e5c,-0xd(%rbp)
movb $0x0,-0x9(%rbp)
mov -0x98(%rbp),%rax
mov %rax,%rdi
callq 1120 <strlen@plt>
add $0x1,%rax
mov %rax,%rdi
callq 1170 <malloc@... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov dword ptr [rbp+pattern], 2B302E5Ch
mov [rbp+var_9], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
add rax, 1
mov rdi, rax; size
call _mallo... | char * func0(const char *a1)
{
size_t v1; // rax
int i; // eax
char *string; // [rsp+18h] [rbp-88h]
char *dest; // [rsp+20h] [rbp-80h]
size_t v6; // [rsp+28h] [rbp-78h]
long long rm_so; // [rsp+30h] [rbp-70h]
regex_t preg; // [rsp+40h] [rbp-60h] BYREF
regmatch_t pmatch; // [rsp+88h] [rbp-18h] BYREF
ch... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x98],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xd],0x2b302e5c
MOV byte ptr [RBP + -0x9],0x0
MOV RAX,qword ptr [RBP + -0x98]
MOV RDI,RAX
CALL 0x00101120
ADD RAX,0x1
MOV RDI,RAX
CALL 0x00101170
... | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *__dest;
long lVar3;
long in_FS_OFFSET;
char *local_90;
regex_t local_68;
regmatch_t local_20;
char local_15 [5];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_15,"\\.0+",5);
sVar2 = strlen(param_... |
6,265 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current... | int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(tes... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movl $0x2b302e5c,0x53(%rsp)
movb $0x0,0x57(%rsp)
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
callq 1130 <malloc@plt>
mov %... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 60h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+78h+var_20], rax
xor eax, eax
mov [rsp+78h+var_25], 2B302E5Ch
mov [rsp+78h+var_21], 0
call _strlen
lea rdi, [rax+1]
call _malloc
mov r12, rax
lea rsi, [rsp+78h+var_25]
mov ... | long long func0(long long a1)
{
long long v1; // rax
long long v2; // r12
long long i; // rbx
long long v4; // rax
long long v5; // rsi
_BYTE v7[72]; // [rsp+0h] [rbp-78h] BYREF
int v8; // [rsp+48h] [rbp-30h] BYREF
int v9; // [rsp+4Ch] [rbp-2Ch]
char v10[5]; // [rsp+53h] [rbp-25h] BYREF
unsigned lo... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x53],0x2b302e5c
MOV byte ptr [RSP + 0x57],0x0
CALL 0x00101120
LEA RDI,[RAX + 0x1]
CALL 0x00101170
MOV R12,RAX
LEA RSI,[RSP + 0x53]
MOV RDI,RSP
MOV EDX,0x1
CALL ... | char * func0(char *param_1)
{
char *__src;
int iVar1;
size_t sVar2;
char *__dest;
char *__string;
long in_FS_OFFSET;
regex_t rStack_78;
regmatch_t local_30;
char local_25 [5];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_25,"\\.0+",5);
sVar2 = strlen(para... |
6,266 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current... | int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(tes... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movl $0x2b302e5c,0x53(%rsp)
mov %rsp,%rbp
movb $0x0,0x57(%rsp)
callq 1110 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1150 <malloc@plt>
lea 0x53(%rsp),%... | func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+var_s58], rax
xor eax, eax
mov [rsp+var_s53], 2B302E5Ch
mov rbp, rsp
mov [rsp+var_s57], 0
call _strlen
lea rdi, [rax+1]
call _malloc
lea rsi, [rsp+var_s53]
mov ... | long long func0(long long a1)
{
long long v1; // rax
long long v2; // r13
long long v3; // rbx
long long v4; // rax
long long v5; // rsi
_BYTE _0[72]; // [rsp+0h] [rbp+0h] BYREF
int vars48; // [rsp+48h] [rbp+48h] BYREF
int vars4C; // [rsp+4Ch] [rbp+4Ch]
char vars53[5]; // [rsp+53h] [rbp+53h] BYREF
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x53],0x2b302e5c
MOV RBP,RSP
MOV byte ptr [RSP + 0x57],0x0
CALL 0x00101120
LEA RDI,[RAX + 0x1]
CALL 0x00101170
LEA RSI,[RSP + 0x53]
MOV EDX,0x1
MOV RDI,... | char * func0(char *param_1)
{
char *__src;
int iVar1;
size_t sVar2;
char *__dest;
char *__string;
long in_FS_OFFSET;
regex_t rStack_88;
regmatch_t local_40;
char local_35 [5];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_35,"\\.0+",5);
sVar2 = strlen(para... |
6,267 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* ip) {
regex_t regex;
regmatch_t matches[1];
char pattern[] = "\\.0+";
char* result = (char*)malloc(strlen(ip) + 1);
char* current_location;
regcomp(®ex, pattern, REG_EXTENDED);
strcpy(result, ip);
current_location = result;
while (regexec(®ex, current... | int main() {
char* test1 = func0("216.08.094.196");
assert(strcmp(test1, "216.8.94.196") == 0);
free(test1);
char* test2 = func0("12.01.024");
assert(strcmp(test2, "12.1.24") == 0);
free(test2);
char* test3 = func0("216.08.094.0196");
assert(strcmp(test3, "216.8.94.196") == 0);
free(tes... | O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movl $0x2b302e5c,0x53(%rsp)
mov %rsp,%rbp
movb $0x0,0x57(%rsp)
callq 1110 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1150 <malloc@plt>
lea 0x53(%rsp),%... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov [rsp+98h+var_41], 0
mov r13, rsp
lea r14, [rsp+98h+pmatch]
mov dword ptr [rsp+98h+pattern], 2B302E5Ch
call _s... | const char * func0(const char *a1)
{
size_t v1; // r12
const char *v2; // r15
size_t v3; // rbx
const char *i; // rbp
size_t v5; // rdi
size_t v6; // rcx
const char *v7; // rsi
long long v8; // rax
size_t v9; // rdx
regex_t v11; // [rsp+0h] [rbp-98h] BYREF
regmatch_t pmatch; // [rsp+48h] [rbp-50h]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV byte ptr [RSP + 0x57],0x0
MOV R13,RSP
LEA R14,[RSP + 0x48]
MOV dword ptr [RSP + 0x53],0x2b302e5c
CALL 0x00101110
LEA R12,[RAX + 0x1]
MOV RDI,R12
CALL 0... | char * func0(char *param_1)
{
long lVar1;
char *pcVar2;
int iVar3;
size_t sVar4;
char *pcVar5;
size_t sVar6;
ulong uVar7;
size_t sVar8;
char *__string;
ulong uVar9;
long in_FS_OFFSET;
regex_t rStack_98;
regmatch_t local_50;
char local_45 [5];
long local_40;
local_40 = *(long *)(in_FS... |
6,268 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
fir... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0xffffffff,-0x10(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11cb <func0+0x62>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0FFFFFFFFh
mov [rbp+var_C], 0FFFFFFFFh
mov [rbp+var_8], 0
jmp short loc_11CB
loc_118F:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ... | long long func0(long long a1, int a2)
{
int v3; // [rsp+Ch] [rbp-10h]
int v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = -1;
v4 = -1;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
{
v3 = *(_DWORD *)(4LL * i + a1);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0xffffffff
MOV dword ptr [RBP + -0xc],0xffffffff
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011cb
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x1... | int func0(long param_1,int param_2)
{
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_18 = -1;
local_14 = -1;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(uint *)(param_1 + (long)local_10 * 4) & 1) == 0) {
local_18 = *(int *)(param_1 + (long)local... |
6,269 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
fir... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a8 <func0+0x3f>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
mov (%rdi),%eax
test $0x1,%al
je 1190 <func0+0x27>
add $0x4,%rdi
cmp %rsi,%rdi
jne 117c <func0+0x13>
mov $0xffffffff,%eax
mov (%rdx),%ecx
test $0x1,%cl
jne 11a5 <fun... | func0:
endbr64
test esi, esi
jle short loc_11A8
mov rdx, rdi
lea eax, [rsi-1]
lea rsi, [rdi+rax*4+4]
loc_117C:
mov eax, [rdi]
test al, 1
jz short loc_1190
add rdi, 4
cmp rdi, rsi
jnz short loc_117C
mov eax, 0FFFFFFFFh
loc_1190:
mov ecx, [rdx]
test cl, 1
jnz shor... | long long func0(int *a1, int a2)
{
int *v2; // rdx
long long v3; // rsi
int v4; // eax
int v5; // ecx
if ( a2 <= 0 )
{
v4 = -1;
v5 = -1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
do
{
v4 = *a1;
if ( (*a1 & 1) == 0 )
goto LABEL_6;
++a1;
}... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a8
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RSI,[RDI + RAX*0x4 + 0x4]
LAB_0010117c:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JZ 0x00101190
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x0010117c
MOV EAX,0xffffffff
LAB_00101190:
MOV ECX,dword ptr [RDX]
TEST CL,0x1
JNZ 0x001011a5
ADD RDX,0x4
CMP RDX,RSI
JNZ... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
if (param_2 < 1) {
uVar2 = 0xffffffff;
uVar3 = 0xffffffff;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar4 = param_1;
do {
uVar2 = *puVar4;
if ((uVar2 & 1) == 0) goto... |
6,270 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
fir... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1344 <func0+0x54>
lea -0x1(%rsi),%eax
mov %rdi,%rdx
lea 0x4(%rdi,%rax,4),%rcx
jmp 1311 <func0+0x21>
nopl (%rax)
add $0x4,%rdx
cmp %rcx,%rdx
je 1338 <func0+0x48>
mov (%rdx),%eax
test $0x1,%al
jne 1308 <func0+0x18>
jmp 1329 <func0+0x39>
nopl 0x0(... | func0:
endbr64
test esi, esi
jle short loc_1344
lea eax, [rsi-1]
mov rdx, rdi
lea rcx, [rdi+rax*4+4]
jmp short loc_1311
loc_1308:
add rdx, 4
cmp rdx, rcx
jz short loc_1338
loc_1311:
mov eax, [rdx]
test al, 1
jnz short loc_1308
jmp short loc_1329
loc_1320:
add rdi, ... | long long func0(int *a1, int a2)
{
int *v2; // rdx
long long v3; // rcx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
v4 = *v2;
if ( (*v2 & 1) == 0 )
break;
if ( ++v2 == (int *)v3 )
{
v4 = -1;
goto LABEL_7;
}... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101344
LEA EAX,[RSI + -0x1]
MOV RDX,RDI
LEA RCX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101311
LAB_00101308:
ADD RDX,0x4
CMP RDX,RCX
JZ 0x00101338
LAB_00101311:
MOV EAX,dword ptr [RDX]
TEST AL,0x1
JNZ 0x00101308
JMP 0x00101329
LAB_00101320:
ADD RDI,0x4
CMP RDI,RCX
JZ 0x00101340
LAB_00101329:
M... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
if (param_2 < 1) {
return 0;
}
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
puVar3 = param_1;
do {
uVar2 = *puVar3;
if ((uVar2 & 1) == 0) goto LAB_00101329;
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1... |
6,271 | func0 |
#include <assert.h>
| int func0(int list1[], int size) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < size; i++) {
if (list1[i] % 2 == 0) {
first_even = list1[i];
break;
}
}
for (int i = 0; i < size; i++) {
if (list1[i] % 2 != 0) {
fir... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int list3[] = {1,5,7,9,10};
assert(func0(list1, 8) == 3);
assert(func0(list2, 10) == 1);
assert(func0(list3, 5) == 9);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 12f4 <func0+0x54>
lea -0x1(%rsi),%eax
mov %rdi,%rdx
lea 0x4(%rdi,%rax,4),%rcx
jmp 12c1 <func0+0x21>
nopl (%rax)
add $0x4,%rdx
cmp %rcx,%rdx
je 12e8 <func0+0x48>
mov (%rdx),%eax
test $0x1,%al
jne 12b8 <func0+0x18>
jmp 12d9 <func0+0x39>
nopl 0x0(... | func0:
endbr64
test esi, esi
jle short loc_12E4
movsxd rsi, esi
mov rdx, rdi
lea rcx, [rdi+rsi*4]
jmp short loc_12B1
loc_12A8:
add rdx, 4
cmp rdx, rcx
jz short loc_12D8
loc_12B1:
mov eax, [rdx]
test al, 1
jnz short loc_12A8
jmp short loc_12C9
loc_12C0:
add rdi, 4
cmp ... | long long func0(int *a1, int a2)
{
int *v2; // rdx
int *v3; // rcx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = &a1[a2];
while ( 1 )
{
v4 = *v2;
if ( (*v2 & 1) == 0 )
break;
if ( ++v2 == v3 )
{
v4 = -1;
goto LABEL_7;
}
}
do
{
LABEL_7:
if (... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012e4
MOVSXD RSI,ESI
MOV RDX,RDI
LEA RCX,[RDI + RSI*0x4]
JMP 0x001012b1
LAB_001012a8:
ADD RDX,0x4
CMP RDX,RCX
JZ 0x001012d8
LAB_001012b1:
MOV EAX,dword ptr [RDX]
TEST AL,0x1
JNZ 0x001012a8
JMP 0x001012c9
LAB_001012c0:
ADD RDI,0x4
CMP RDI,RCX
JZ 0x001012e0
LAB_001012c9:
MOV EDX,dword... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
if (param_2 < 1) {
return 0;
}
puVar1 = param_1 + param_2;
puVar3 = param_1;
do {
uVar2 = *puVar3;
if ((uVar2 & 1) == 0) goto LAB_001012c9;
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1);
uVar2 = 0xff... |
6,272 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represen... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11c8 <func0+0x5f>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_11C8
loc_119C:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov r... | long long func0(const char *a1, long long a2)
{
int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v3 = 0;
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
if ( a1[i] != *(_BYTE *)(i + a2) )
++v3;
}
if ( (v3 & 1) != 0 )
return 0xFFFFFFFFLL;
else
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011c8
LAB_0010119c:
MOV EAX,dword ptr [RBP + ... | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
uint local_14;
int local_10;
local_14 = 0;
sVar2 = strlen(param_1);
for (local_10 = 0; local_10 < (int)sVar2; local_10 = local_10 + 1) {
if (param_1[local_10] != *(char *)(param_2 + local_10)) {
local_14 = local_14 + 1;
}
... |
6,273 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represen... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11a3 <func0+0x5a>
lea -0x1(%rcx),%edi
mov $0x0,%eax
mov $0x0,%edx
jmp 117b <func0+0x32>
mov %rcx,%rax
movzbl (%rsi,%rax,1),%ecx
cmp %cl,(%r8,%r... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rbp, rsi
call _strlen
test eax, eax
jle short loc_11C3
lea esi, [rax-1]
mov eax, 0
mov edx, 0
jmp short loc_1194
loc_1191:
mov rax, rcx
loc_1194:
movzx edi, byte ptr [rbp+rax+0]
cmp [rbx+rax], dil
setnz ... | long long func0(long long a1, long long a2)
{
int v3; // eax
long long v4; // rsi
long long v5; // rax
int v6; // edx
v3 = strlen();
if ( v3 <= 0 )
{
v6 = 0;
return (unsigned int)(v6 / 2);
}
v4 = (unsigned int)(v3 - 1);
v5 = 0LL;
v6 = 0;
while ( 1 )
{
v6 += *(_BYTE *)(a1 + v5) !=... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RBP,RSI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011c3
LEA ESI,[RAX + -0x1]
MOV EAX,0x0
MOV EDX,0x0
JMP 0x00101194
LAB_00101191:
MOV RAX,RCX
LAB_00101194:
MOVZX EDI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],DIL
SETNZ CL
MOVZX ECX,CL
ADD EDX,ECX
LEA R... | int func0(char *param_1,long param_2)
{
size_t sVar1;
ulong uVar2;
uint uVar3;
bool bVar4;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
uVar3 = 0;
}
else {
uVar3 = 0;
uVar2 = 0;
do {
uVar3 = uVar3 + (param_1[uVar2] != *(char *)(param_2 + uVar2));
bVar4 = uVar2 != (int)s... |
6,274 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represen... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 1290 <func0+0x60>
lea -0x1(%rax),%esi
xor %edx,%edx
xor %eax,%eax
jmp 125b <func0+0x2b>
nopw 0x0(%rax,%rax,1)
mov %rcx,%rax
xor %ecx,%ecx
movzbl 0x0(%rbp,%rax,1)... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_1280
lea esi, [rax-1]
xor edx, edx
xor eax, eax
jmp short loc_124B
loc_1248:
mov rax, rcx
loc_124B:
xor ecx, ecx
movzx edi, byte ptr [rbp+rax+0]
cmp [r... | long long func0(long long a1, long long a2)
{
int v3; // eax
long long v4; // rsi
int v5; // edx
long long i; // rax
long long result; // rax
v3 = strlen();
if ( v3 <= 0 )
return 0LL;
v4 = (unsigned int)(v3 - 1);
v5 = 0;
for ( i = 0LL; ; ++i )
{
v5 += *(_BYTE *)(a1 + i) != *(_BYTE *)(a2 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101280
LEA ESI,[RAX + -0x1]
XOR EDX,EDX
XOR EAX,EAX
JMP 0x0010124b
LAB_00101248:
MOV RAX,RCX
LAB_0010124b:
XOR ECX,ECX
MOVZX EDI,byte ptr [RBP + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1],DIL
SETNZ CL
ADD EDX,ECX
LEA RC... | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
uint uVar4;
bool bVar5;
sVar2 = strlen(param_1);
if ((int)sVar2 < 1) {
return 0;
}
uVar4 = 0;
uVar3 = 0;
do {
uVar4 = uVar4 + (param_1[uVar3] != *(char *)(param_2 + uVar3));
bVar5 = (int)sVar2 - 1 != uVar... |
6,275 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *str1, const char *str2) {
int count = 0;
int len = strlen(str1);
for (int i = 0; i < len; i++) {
if (str1[i] != str2[i]) {
count++;
}
}
if (count % 2 == 0) {
return count / 2;
} else {
return -1; // Using -1 to represen... | int main() {
assert(func0("1101", "1110") == 1);
assert(func0("111", "000") == -1); // -1 is returned for "Not Possible"
assert(func0("111", "110") == -1); // -1 is returned for "Not Possible"
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 1500 <func0+0x2d0>
lea -0x1(%rax),%edx
cmp $0xe,%edx
jbe 1509 <func0+0x2d9>
mov %eax,%ecx
movdqa 0xe4d(%rip),%xmm6
xor %edx,%edx
pxor %xmm1,%xmm1
shr $0x4,%ecx
p... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle loc_1460
mov rdx, rax
lea eax, [rax-1]
cmp eax, 0Eh
jbe loc_1469
mov ecx, edx
pxor xmm1, xmm1
pxor xmm5, xmm5
xor eax, eax
shr ecx, 4
pxor xmm4, xmm4
shl ... | long long func0(const char *a1, long long a2)
{
int v4; // eax
int v5; // edx
__m128i v6; // xmm1
long long v7; // rax
__m128i v8; // xmm0
__m128i v9; // xmm7
__m128i v10; // xmm0
__m128i v11; // xmm3
__m128i v12; // xmm2
__m128i v13; // xmm0
__m128i v14; // xmm3
__m128i v15; // xmm1
__m128i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x00101460
MOV RDX,RAX
LEA EAX,[RAX + -0x1]
CMP EAX,0xe
JBE 0x00101469
MOV ECX,EDX
PXOR XMM1,XMM1
PXOR XMM5,XMM5
XOR EAX,EAX
SHR ECX,0x4
PXOR XMM4,XMM4
SHL RCX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101268:
MOVDQU XMM... | int func0(char *param_1,long param_2)
{
char *pcVar1;
char *pcVar2;
int8 uVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
int auVar12 [14];
int auVar13 [12];
unkbyte10 Var14;
int auVar15 [12];
int auVar16 [14];
int auVar17 [12];
... |
6,276 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(t... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movq $0x0,-0x10(%rbp)
movq $0x0,-0x8(%rbp)
jmp 11b5 <func0+0x2c>
addq $0x8,-0x10(%rbp)
addq $0x1,-0x8(%rbp)
mov -0x8(%rbp),%rax
cmp -0x20(%rbp),%rax
jb 11ab <func0+0x22>
mov -0x10(%rbp),%rax
pop %rbp
r... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_10], 0
mov [rbp+var_8], 0
jmp short loc_11B5
loc_11AB:
add [rbp+var_10], 8
add [rbp+var_8], 1
loc_11B5:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jb short loc_11AB
mov rax, ... | long long func0(long long a1, unsigned long long a2)
{
long long v3; // [rsp+10h] [rbp-10h]
unsigned long long i; // [rsp+18h] [rbp-8h]
v3 = 0LL;
for ( i = 0LL; i < a2; ++i )
v3 += 8LL;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001011b5
LAB_001011ab:
ADD qword ptr [RBP + -0x10],0x8
ADD qword ptr [RBP + -0x8],0x1
LAB_001011b5:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [R... | long func0(int8 param_1,ulong param_2)
{
int8 local_18;
int8 local_10;
local_18 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
local_18 = local_18 + 8;
}
return local_18;
} |
6,277 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(t... | O1 | c | func0:
endbr64
test %rsi,%rsi
je 1165 <func0+0x1c>
mov $0x0,%eax
add $0x1,%rax
cmp %rax,%rsi
jne 1157 <func0+0xe>
shl $0x3,%rax
retq
mov %rsi,%rax
retq
| func0:
endbr64
test rsi, rsi
jz short loc_1169
mov edx, 0
loc_1157:
add rdx, 1
cmp rsi, rdx
jnz short loc_1157
lea rax, ds:0[rdx*8]
retn
loc_1169:
mov rax, rsi
retn | long long func0(long long a1, long long a2)
{
long long i; // rdx
if ( !a2 )
return 0LL;
for ( i = 0LL; i != a2; ++i )
;
return 8 * i;
} | func0:
ENDBR64
TEST RSI,RSI
JZ 0x00101169
MOV EDX,0x0
LAB_00101157:
ADD RDX,0x1
CMP RSI,RDX
JNZ 0x00101157
LEA RAX,[RDX*0x8]
RET
LAB_00101169:
MOV RAX,RSI
RET | long func0(int8 param_1,long param_2)
{
long lVar1;
if (param_2 != 0) {
lVar1 = 0;
do {
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
return lVar1 * 8;
}
return 0;
} |
6,278 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(t... | O2 | c | func0:
endbr64
lea 0x0(,%rsi,8),%rax
retq
nopl (%rax)
| func0:
endbr64
lea rax, ds:0[rsi*8]
retn | long long func0(long long a1, long long a2)
{
return 8 * a2;
} | func0:
ENDBR64
LEA RAX,[RSI*0x8]
RET | long func0(int8 param_1,long param_2)
{
return param_2 * 8;
} |
6,279 | func0 | #include <stdio.h>
#include <assert.h>
| size_t func0(const char *tuple[], size_t size) {
size_t total_size = 0;
for (size_t i = 0; i < size; i++) {
total_size += sizeof(tuple[i]); // Size of the pointer to string
}
return total_size;
}
| int main() {
// Tuple 1 with string elements
const char *tuple1[] = {"A", "1", "B", "2", "C", "3"};
// Tuple 2 with string elements
const char *tuple2[] = {"1", "Raju", "2", "Nikhil", "3", "Deepanshu"};
// Get the size of the tuples by the number of elements
size_t tuple1_size = sizeof(t... | O3 | c | func0:
endbr64
lea 0x0(,%rsi,8),%rax
retq
nopl (%rax)
| func0:
endbr64
lea rax, ds:0[rsi*8]
retn | long long func0(long long a1, long long a2)
{
return 8 * a2;
} | func0:
ENDBR64
LEA RAX,[RSI*0x8]
RET | long func0(int8 param_1,long param_2)
{
return param_2 * 8;
} |
6,280 | 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... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %edx,-0x54(%rbp)
mov %ecx,-0x58(%rbp)
mov %r8d,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x54(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov [rbp+var_48], ecx
mov [rbp+var_4C], r8d
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov edx, [rbp+var_44]
mov ... | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
unsigned long long v5; // rax
void *v6; // rsp
_BYTE v8[4]; // [rsp+8h] [rbp-50h] BYREF
int v9; // [rsp+Ch] [rbp-4Ch]
int v10; // [rsp+10h] [rbp-48h]
int v11; // [rsp+14h] [rbp-44h]
long long v12; // [rsp+18h] [rbp-40h]
long long v13... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV dword ptr [RBP + -0x48],ECX
MOV dword ptr [RBP + -0x4c],R8D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EDX,dword pt... | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_58 [4];
int local_54;
int local_50;
int local_4c;
long local_48;
long local_40;
int local_2c;
int local_28;
int local_24;
long local_20;
int *lo... |
6,281 | 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... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea (%rdx,%rcx,1),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%r9
and $0xfffffffffffffff0,%r9
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r11, rsi
mov edi, edx
mov r9d, ecx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [rdx+rcx]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFF... | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
long long v9; // rax
__int16 v10; // cx
signed long long v11; // rax
void *v12; // rsp
long long v13; // rdx
long long v14; // rax
int v15; // esi
int v16; // ecx
int v17; // r10d
int v18; // r10d
long long v19; // rdx
long l... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R11,RSI
MOV EDI,EDX
MOV R9D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[RDX + RCX*0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_0... | int4 func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
int iVar1;
long lVar2;
int iVar3;
ulong uVar4;
long lVar5;
long lVar6;
int1 *puVar7;
int iVar8;
int iVar9;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 =... |
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.