index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
4,282 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
typedef struct {
Pair *pairs;
int size;
int capacity;
} Dictionary;
void init_dictionary(Dictionary *dict) {
dict->capacity = 10;
dict->size = 0;
dict->pairs = (... | Dictionary func0(int list1[][4], int numLists) {
Dictionary dict;
init_dictionary(&dict);
for (int i = 0; i < numLists; i++) {
for (int j = 0; j < 4; j++) {
dictionary_add(&dict, list1[i][j]);
}
}
return dict;
}
| int main() {
int list1[3][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}};
Dictionary result1 = func0(list1, 3);
assert(result1.size == 9);
assert(result1.pairs[1].value == 3);
assert(result1.pairs[4].value == 2);
int list2[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Dict... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
mov $0x50,%edi
push %rbp
push %rbx
mov %esi,%ebx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movabs $0xa00000000,%rax
mov %rax,0x8(%rsp)
callq 10c0 <malloc@plt>
mov %rax,(%rsp)
test %ebx,%ebx
jle 1650 <func0... | func0:
endbr64
push r13
push r12
mov r12, rdi
mov edi, 50h ; 'P'
push rbp
push rbx
mov ebx, esi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
mov rax, 0A00000000h
mov [rsp+48h+var_40], rax
call _malloc
mov [rsp+48h+var_48], rax
test ebx, ebx
jle short l... | long long func0(long long a1, int a2)
{
unsigned int *v2; // rbp
long long v3; // r13
unsigned int *v4; // rbx
long long v5; // rsi
_QWORD v7[9]; // [rsp+0h] [rbp-48h] BYREF
v7[3] = __readfsqword(0x28u);
v7[1] = 0xA00000000LL;
v7[0] = malloc(80LL);
if ( a2 > 0 )
{
v2 = (unsigned int *)(a1 + 16... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
MOV EDI,0x50
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,0xa00000000
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001010c0
MOV qword ptr [RSP],RAX
TEST EBX,EBX
JLE 0x00101650
LEA EAX,[RBX + -0x1]
LEA RBP,[R12 + 0x10]
... | void * func0(long param_1,int param_2)
{
int4 uVar1;
int4 *puVar2;
int4 *puVar3;
long in_FS_OFFSET;
void *local_48;
int8 local_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = 0xa00000000;
local_48 = malloc(0x50);
if (0 < param_2) {
puVar3 = (int4 *)(param_1 + 0x10)... |
4,283 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
typedef struct {
Pair *pairs;
int size;
int capacity;
} Dictionary;
void init_dictionary(Dictionary *dict) {
dict->capacity = 10;
dict->size = 0;
dict->pairs = (... | Dictionary func0(int list1[][4], int numLists) {
Dictionary dict;
init_dictionary(&dict);
for (int i = 0; i < numLists; i++) {
for (int j = 0; j < 4; j++) {
dictionary_add(&dict, list1[i][j]);
}
}
return dict;
}
| int main() {
int list1[3][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}};
Dictionary result1 = func0(list1, 3);
assert(result1.size == 9);
assert(result1.pairs[1].value == 3);
assert(result1.pairs[4].value == 2);
int list2[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Dict... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
mov $0x50,%edi
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
callq 10c0 <malloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 1674 <func0+0xd4>
lea -0x1(%rbx),%eax
lea 0x10(%rbp),%r13
mov $0xa,%r14d
shl $0x4,%rax... | func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 50h ; 'P'; size
push r13
push r12
push rbp
push rbx
mov ebx, esi
sub rsp, 18h
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jle loc_167E
movsxd rcx, ebx
add r14, 10h
mov r15d, 0Ah
xor r12d, r12d
shl rc... | char * func0(long long a1, int a2)
{
char *v3; // rdi
int *v4; // r14
int v5; // r15d
int v6; // r12d
int *v7; // rcx
int *v8; // rbp
int v9; // ebx
long long v10; // r13
char *v11; // rax
char *v13; // rax
char *v14; // rax
int *v15; // [rsp+8h] [rbp-40h]
v3 = (char *)malloc(0x50uLL);
if (... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x50
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x18
CALL 0x001010c0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x0010167e
MOVSXD RCX,EBX
ADD R14,0x10
MOV R15D,0xa
XOR R12D,R12D
SHL RCX,0x4
ADD RCX,R14
NOP dword ptr [RAX + RAX*0x1]
LAB_001015d8:
LEA RBP,[R14 + -0x10]
... | int [16] func0(long param_1,int param_2)
{
int iVar1;
int *__ptr;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
long lVar6;
int *piVar7;
int iVar8;
int auVar9 [16];
__ptr = (int *)malloc(0x50);
if (param_2 < 1) {
iVar8 = 10;
iVar5 = 0;
}
else {
piVar7 = (int *)(param_1 +... |
4,284 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movsd 0xf18(%rip),%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11ba <func0+0x51>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
movsd xmm0, cs:qword_2078
movsd [rbp+var_8], xmm0
mov [rbp+var_C], 0
jmp short loc_11BE
loc_118E:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [ra... | double func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
double v4; // [rsp+14h] [rbp-8h]
v4 = 1.0;
for ( i = 0; i < a2; ++i )
v4 = (double)*(int *)(4LL * i + a1) * v4;
return v4 / (double)a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOVSD XMM0,qword ptr [0x00102078]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011be
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RA... | double func0(long param_1,int param_2)
{
int4 local_14;
int8 local_10;
local_10 = DAT_00102078;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
local_10 = (double)*(int *)(param_1 + (long)local_14 * 4) * local_10;
}
return local_10 / (double)param_2;
} |
4,285 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a6 <func0+0x3d>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
movsd 0xf14(%rip),%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl (%rax),%xmm1
mulsd %xmm1,%xmm0
add $0x4,%rax
cmp %rdx,%rax
jne 1184 <func0+0x1b>
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xm... | func0:
endbr64
test esi, esi
jle short loc_11A6
mov rax, rdi
lea edx, [rsi-1]
lea rdx, [rdi+rdx*4+4]
movsd xmm0, cs:qword_2078
loc_1184:
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rax]
mulsd xmm0, xmm1
add rax, 4
cmp rax, rdx
jnz short loc_1184
loc_1199:
pxor xmm1, xmm1
cvtsi2sd ... | double func0(int *a1, int a2)
{
int *v2; // rax
double v3; // xmm0_8
if ( a2 <= 0 )
{
v3 = 1.0;
}
else
{
v2 = a1;
v3 = 1.0;
do
v3 = v3 * (double)*v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a6
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RDX,[RDI + RDX*0x4 + 0x4]
MOVSD XMM0,qword ptr [0x00102078]
LAB_00101184:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RAX]
MULSD XMM0,XMM1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101184
LAB_00101199:
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET... | double func0(int *param_1,int param_2)
{
int *piVar1;
double dVar2;
dVar2 = DAT_00102078;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
dVar2 = dVar2 * (double)*param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return dVar2 / (double)param_2;
} |
4,286 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1188 <func0+0x48>
lea -0x1(%rsi),%eax
movsd 0xeb5(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
add $0x4,%rdi
cvtsi2sdl -0x4(%rdi),%xmm1
mulsd %xmm1,%xmm0
cmp %rax,%rdi
jne 1160 <func0+0x20>
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1... | func0:
endbr64
test esi, esi
jle short loc_1278
lea eax, [rsi-1]
movsd xmm0, cs:qword_2040
lea rax, [rdi+rax*4+4]
nop dword ptr [rax+rax+00000000h]
loc_1250:
pxor xmm1, xmm1
add rdi, 4
cvtsi2sd xmm1, dword ptr [rdi-4]
mulsd xmm0, xmm1
cmp rdi, rax
jnz short loc_1250
pxor xmm1, x... | double func0(long long a1, int a2)
{
double v2; // xmm0_8
long long v3; // rax
if ( a2 <= 0 )
return 1.0 / (double)a2;
v2 = 1.0;
v3 = a1 + 4LL * (unsigned int)(a2 - 1) + 4;
do
{
a1 += 4LL;
v2 = v2 * (double)*(int *)(a1 - 4);
}
while ( a1 != v3 );
return v2 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101278
LEA EAX,[RSI + -0x1]
MOVSD XMM0,qword ptr [0x00102040]
LEA RAX,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101250:
PXOR XMM1,XMM1
ADD RDI,0x4
CVTSI2SD XMM1,dword ptr [RDI + -0x4]
MULSD XMM0,XMM1
CMP RDI,RAX
JNZ 0x00101250
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XM... | double func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
double dVar3;
if (0 < param_2) {
piVar1 = param_1;
dVar3 = DAT_00102040;
do {
piVar2 = piVar1 + 1;
dVar3 = dVar3 * (double)*piVar1;
piVar1 = piVar2;
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
... |
4,287 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int numbers[], int size) {
double total = 1;
for (int i = 0; i < size; i++) {
total *= numbers[i];
}
return total / size;
}
| int main() {
int arr1[] = {8, 2, 3, -1, 7};
int arr2[] = {-10, -20, -30};
int arr3[] = {19, 15, 18};
assert(func0(arr1, 5) == -67.2);
assert(func0(arr2, 3) == -2000.0);
assert(func0(arr3, 3) == 1710.0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1268 <func0+0x48>
lea -0x1(%rsi),%eax
movsd 0xe2d(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
add $0x4,%rdi
cvtsi2sdl -0x4(%rdi),%xmm1
mulsd %xmm1,%xmm0
cmp %rdi,%rax
jne 1240 <func0+0x20>
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1... | func0:
endbr64
test esi, esi
jle short loc_1188
movsxd rax, esi
movsd xmm0, cs:qword_2008
lea rax, [rdi+rax*4]
nop word ptr [rax+rax+00000000h]
loc_1160:
pxor xmm1, xmm1
add rdi, 4
cvtsi2sd xmm1, dword ptr [rdi-4]
mulsd xmm0, xmm1
cmp rax, rdi
jnz short loc_1160
pxor xmm1, xmm1
cvt... | double func0(long long a1, int a2)
{
double v2; // xmm0_8
long long v3; // rax
if ( a2 <= 0 )
return 1.0 / (double)a2;
v2 = 1.0;
v3 = a1 + 4LL * a2;
do
{
a1 += 4LL;
v2 = v2 * (double)*(int *)(a1 - 4);
}
while ( v3 != a1 );
return v2 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101188
MOVSXD RAX,ESI
MOVSD XMM0,qword ptr [0x00102008]
LEA RAX,[RDI + RAX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
PXOR XMM1,XMM1
ADD RDI,0x4
CVTSI2SD XMM1,dword ptr [RDI + -0x4]
MULSD XMM0,XMM1
CMP RAX,RDI
JNZ 0x00101160
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
L... | double func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
double dVar3;
if (0 < param_2) {
piVar1 = param_1;
dVar3 = DAT_00102008;
do {
piVar2 = piVar1 + 1;
dVar3 = dVar3 * (double)*piVar1;
piVar1 = piVar2;
} while (param_1 + param_2 != piVar2);
return dVar3 / ... |
4,288 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[sta... | int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11b2 <func0+0x49>
mov -0x14(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
lea 0x30(%rax),%ecx
mov -0xc(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x2... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
jmp short loc_11B8
loc_117D:
mov edx, [rbp+var_14]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
lea ecx, [rax+30h]
mov eax, [rbp+var_C]
lea... | _BYTE * func0(int a1)
{
int v1; // eax
char v4; // [rsp+7h] [rbp-Dh]
int v5; // [rsp+8h] [rbp-Ch]
int v6; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v5 = 0;
while ( a1 > 0 )
{
v1 = v5++;
binary_1[v1] = a1 % 2 + 48;
a1 /= 2;
}
binary_1[v5] = 0;
v6 = 0;
for ( i = v5 - 1; v6 < i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011b8
LAB_0010117d:
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
LEA ECX,[RAX + 0x30]
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + 0x1]
MO... | int1 * func0(int param_1)
{
int uVar1;
char cVar2;
int local_1c;
int local_14;
int local_10;
int local_c;
local_14 = 0;
for (local_1c = param_1; 0 < local_1c; local_1c = local_1c / 2) {
cVar2 = (char)(local_1c >> 0x1f);
binary_1[local_14] = ((char)local_1c - cVar2 & 1U) + cVar2 + '0';
lo... |
4,289 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[sta... | int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 11d9 <func0+0x90>
lea 0x2ee4(%rip),%rcx
mov $0x0,%edx
mov %edx,%r8d
add $0x1,%edx
mov %edi,%esi
shr $0x1f,%esi
lea (%rdi,%rsi,1),%eax
and $0x1,%eax
sub %esi,%eax
add $0x30,%eax
mov %al,(%rcx)
mov %edi,%eax
mov %edi,%esi
shr $0x1f,%esi
add ... | func0:
endbr64
test edi, edi
jle loc_11F9
lea rcx, binary_1
mov edx, 0
loc_1181:
mov r8d, edx
add edx, 1
mov esi, edi
shr esi, 1Fh
lea eax, [rdi+rsi]
and eax, 1
sub eax, esi
add eax, 30h ; '0'
mov [rcx], al
mov eax, edi
mov esi, edi
shr esi, 1Fh
add edi... | char * func0(int a1)
{
char *v1; // rcx
int v2; // edx
int v3; // r8d
int v4; // eax
char *v5; // rdx
long long v6; // rax
char v7; // si
if ( a1 <= 0 )
{
binary_1[0] = 0;
}
else
{
v1 = binary_1;
v2 = 0;
do
{
v3 = v2++;
*v1 = a1 % 2 + 48;
v4 = a1;
a1 ... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011f9
LEA RCX,[0x104040]
MOV EDX,0x0
LAB_00101181:
MOV R8D,EDX
ADD EDX,0x1
MOV ESI,EDI
SHR ESI,0x1f
LEA EAX,[RDI + RSI*0x1]
AND EAX,0x1
SUB EAX,ESI
ADD EAX,0x30
MOV byte ptr [RCX],AL
MOV EAX,EDI
MOV ESI,EDI
SHR ESI,0x1f
ADD EDI,ESI
SAR EDI,0x1
ADD RCX,0x1
CMP EAX,0x1
JG 0x00101181
M... | int1 * func0(int param_1)
{
int1 uVar1;
bool bVar2;
char cVar3;
int iVar4;
long lVar5;
char *pcVar6;
int iVar7;
int1 *puVar8;
if (param_1 < 1) {
binary_1 = 0;
}
else {
pcVar6 = &binary_1;
iVar4 = 0;
do {
iVar7 = iVar4;
cVar3 = (char)(param_1 >> 0x1f);
*pcVar6 ... |
4,290 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[sta... | int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1350 <func0+0x80>
lea 0x2d61(%rip),%rsi
xor %r8d,%r8d
mov %rsi,%rdx
nopl (%rax)
mov %edi,%eax
add $0x1,%rdx
mov %r8d,%ecx
and $0x1,%eax
lea 0x1(%r8),%r8d
add $0x30,%eax
mov %al,-0x1(%rdx)
sar %edi
jne 12e8 <func0+0x18>
movslq %r8d,%r8
movb $... | func0:
endbr64
test edi, edi
jle short loc_12B0
lea r8, binary_1
xor esi, esi
mov rdx, r8
nop dword ptr [rax+00h]
loc_1258:
mov eax, edi
add rdx, 1
mov ecx, esi
and eax, 1
lea esi, [rsi+1]
add eax, 30h ; '0'
mov [rdx-1], al
sar edi, 1
jnz short loc_1258
movsxd ... | char * func0(int a1)
{
int v1; // esi
char *v2; // rdx
int v3; // ecx
long long v4; // rax
char *v5; // rdx
char v6; // si
char v7; // di
if ( a1 <= 0 )
{
binary_1[0] = 0;
return binary_1;
}
else
{
v1 = 0;
v2 = binary_1;
do
{
++v2;
v3 = v1++;
*(v2 - 1) ... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012b0
LEA R8,[0x104040]
XOR ESI,ESI
MOV RDX,R8
NOP dword ptr [RAX]
LAB_00101258:
MOV EAX,EDI
ADD RDX,0x1
MOV ECX,ESI
AND EAX,0x1
LEA ESI,[RSI + 0x1]
ADD EAX,0x30
MOV byte ptr [RDX + -0x1],AL
SAR EDI,0x1
JNZ 0x00101258
MOVSXD RSI,ESI
MOV byte ptr [R8 + RSI*0x1],0x0
TEST ECX,ECX
JZ 0x... | int1 * func0(int param_1)
{
int1 uVar1;
int iVar2;
long lVar3;
char *pcVar4;
int1 *puVar5;
int iVar6;
if (0 < param_1) {
pcVar4 = &binary_1;
iVar2 = 0;
do {
iVar6 = iVar2;
*pcVar4 = ((byte)param_1 & 1) + 0x30;
param_1 = param_1 >> 1;
pcVar4 = pcVar4 + 1;
iVar2... |
4,291 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
static char binary[32];
int index = 0;
while(n > 0) {
binary[index++] = (n % 2) + '0';
n /= 2;
}
binary[index] = '\0';
// Reverse the string
int start = 0;
int end = index - 1;
while (start < end) {
char temp = binary[sta... | int main() {
assert(strcmp(func0(8), "1000") == 0);
assert(strcmp(func0(18), "10010") == 0);
assert(strcmp(func0(7), "111") == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 14c8 <func0+0x278>
lea 0x2ddd(%rip),%r8
xor %esi,%esi
mov %r8,%rdx
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
add $0x1,%rdx
mov %esi,%ecx
and $0x1,%eax
lea 0x1(%rsi),%esi
add $0x30,%eax
mov %al,-0x1(%rdx)
sar %edi
jne 1270 <func0+0x20>
movslq %esi,%r... | func0:
endbr64
test edi, edi
jle short loc_12B8
lea rsi, binary_1
xor r8d, r8d
mov rdx, rsi
nop dword ptr [rax]
loc_1258:
mov eax, edi
add rdx, 1
mov ecx, r8d
and eax, 1
lea r8d, [r8+1]
add eax, 30h ; '0'
mov [rdx-1], al
sar edi, 1
jnz short loc_1258
movsxd r8... | char * func0(int a1)
{
int v1; // r8d
char *v2; // rdx
int v3; // ecx
long long v4; // rax
char *v5; // rdx
char v6; // di
char v7; // r8
if ( a1 <= 0 )
{
binary_1[0] = 0;
return binary_1;
}
else
{
v1 = 0;
v2 = binary_1;
do
{
++v2;
v3 = v1++;
*(v2 - 1) ... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012b8
LEA RSI,[0x104040]
XOR R8D,R8D
MOV RDX,RSI
NOP dword ptr [RAX]
LAB_00101258:
MOV EAX,EDI
ADD RDX,0x1
MOV ECX,R8D
AND EAX,0x1
LEA R8D,[R8 + 0x1]
ADD EAX,0x30
MOV byte ptr [RDX + -0x1],AL
SAR EDI,0x1
JNZ 0x00101258
MOVSXD R8,R8D
MOV byte ptr [RSI + R8*0x1],0x0
TEST ECX,ECX
JZ 0x... | int1 * func0(int param_1)
{
int uVar1;
int iVar2;
long lVar3;
char *pcVar4;
int1 *puVar5;
int iVar6;
if (0 < param_1) {
pcVar4 = &binary_1;
iVar2 = 0;
do {
iVar6 = iVar2;
*pcVar4 = ((byte)param_1 & 1) + 0x30;
param_1 = param_1 >> 1;
pcVar4 = pcVar4 + 1;
iVar2 ... |
4,292 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
... | int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x34(%rbp),%eax
add $0x1,%eax
mov %eax,-0x30(%rbp)
jmpq 125a <func0+0xb1>
mov -0x30(%rbp),%edx
lea -0x20(%rbp),%rax
lea 0xe25(%rip),%rsi
mov %rax... | 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 eax, [rbp+var_34]
add eax, 1
mov [rbp+var_30], eax
jmp loc_125D
loc_11D5:
mov edx, [rbp+var_30]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov ... | long long func0(int a1)
{
unsigned int i; // [rsp+10h] [rbp-30h]
int v3; // [rsp+14h] [rbp-2Ch]
int j; // [rsp+18h] [rbp-28h]
int v5; // [rsp+1Ch] [rbp-24h]
char s[24]; // [rsp+20h] [rbp-20h] BYREF
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
for ( i = a1 + 1; i != 0x7FFFFFF... | 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 EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0010125d
LAB_001011d5:
MOV EDX,dword ptr [RBP + -0x30]
LEA RAX,[RBP + -0x20]
LEA RCX,[... | uint func0(int param_1)
{
bool bVar1;
size_t sVar2;
long in_FS_OFFSET;
uint local_38;
int local_30;
char local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
for (local_38 = param_1 + 1; local_38 != 0x7fffffff; local_38 = local_38 + 1) {
sprintf(local_28,"%d",(ulong)local_3... |
4,293 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
... | int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp $0x7ffffffe,%edi
je 11b3 <func0+0x2a>
lea 0x1(%rdi),%ebp
mov %rsp,%rbx
jmp 11c9 <func0+0x40>
mov $0xffffffff,%ebp
jmp 1233 <func0+0xaa>
add $0x1,%ebp
cmp $0x7fffffff,%ebp... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
cmp edi, 7FFFFFFEh
jz short loc_11D9
lea ebx, [rdi+1]
lea rbp, unk_2004
jmp short loc_11EB
loc_11D9:
mov ebx, 0FFFFFFFFh
jmp short loc_1242
loc_11E0:
add ... | long long func0(int a1)
{
unsigned int v1; // ebx
int v2; // eax
int v3; // ecx
_BYTE *v4; // rdx
long long v5; // rax
_BYTE v7[24]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v8; // [rsp+18h] [rbp-20h]
v8 = __readfsqword(0x28u);
if ( a1 == 2147483646 )
{
return (unsigned int)-1;
}
els... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CMP EDI,0x7ffffffe
JZ 0x001011d9
LEA EBX,[RDI + 0x1]
LEA RBP,[0x102004]
JMP 0x001011eb
LAB_001011d9:
MOV EBX,0xffffffff
JMP 0x00101242
LAB_001011e0:
ADD EBX,0x1
CMP EBX,0x7fffffff
JZ 0x0010125d
... | int func0(int param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 == 0x7ffffffe) {
param_1 = -1;
}
else {
param_1 = param_1 + 1;
do {
__sprintf_chk(local_38,... |
4,294 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
... | int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp $0x7ffffffe,%edi
je 1307 <func0+0xd7>
lea 0x1(%rdi),%r12d
mov %rsp,%rbp
lea 0x1(%rsp),%rbx
nopl 0x0(%rax)
mov %r12d,%r8d
lea 0xd92(%rip),%rcx
mov %rbp,%rdi
xor... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
cmp edi, 7FFFFFFEh
jz short loc_12F3
lea r12d, [rdi+1]
mov r13, rsp
lea rbp, [rsp+48h+var_47]
lea rbx, unk_2004
nop dword ptr [rax+00000000h]
lo... | long long func0(int a1)
{
unsigned int v1; // r12d
int v2; // eax
int v3; // ecx
char *v4; // rdx
char *v5; // rax
char *v6; // rcx
_QWORD v8[9]; // [rsp+0h] [rbp-48h] BYREF
v8[3] = __readfsqword(0x28u);
if ( a1 == 2147483646 )
{
return (unsigned int)-1;
}
else
{
v1 = a1 + 1;
whi... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CMP EDI,0x7ffffffe
JZ 0x001012f3
LEA R12D,[RDI + 0x1]
MOV R13,RSP
LEA RBP,[RSP + 0x1]
LEA RBX,[0x102004]
NOP dword ptr [RAX]
LAB_00101290:
MOV RCX,RBX
MOV R8D,R12D
MOV EDX,0x14
MOV ESI,... | int func0(int param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_48 [24];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 != 0x7ffffffe) {
param_1 = param_1 + 1;
do {
__sprintf_chk(local_48,1,0x14,&DAT_00102004,param_1)... |
4,295 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
| int func0(int num) {
for (int i = num + 1; i < INT_MAX; i++) {
char numstr[20];
sprintf(numstr, "%d", i);
int len = strlen(numstr);
int isPalindrome = 1;
for (int j = 0; j < len / 2; j++) {
if (numstr[j] != numstr[len - 1 - j]) {
... | int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp $0x7ffffffe,%edi
je 13d1 <func0+0x1a1>
lea 0x1(%rdi),%r12d
mov %rsp,%rbp
lea 0xd9e(%rip),%rbx
nopw %cs:0x0(%rax,%rax,1)
mov %r12d,%r8d
mov %rbx,%rcx
mov $0x14,... | func0:
endbr64
push r12
lea r12d, [rdi+1]
push rbp
lea rbp, unk_2004
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov rbx, rsp
cmp edi, 7FFFFFFEh
jz loc_13C9
nop word ptr [rax+rax+00000000h]
loc_1290:
mov edx, 14h
mov r8d, r12d
mo... | long long func0(int a1)
{
unsigned int v1; // r12d
int v2; // eax
int v3; // edx
char v5[24]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v6; // [rsp+18h] [rbp-20h]
v1 = a1 + 1;
v6 = __readfsqword(0x28u);
if ( a1 == 2147483646 )
{
return (unsigned int)-1;
}
else
{
while ( 1 )
{
... | func0:
ENDBR64
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
LEA RBP,[0x102004]
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RBX,RSP
CMP EDI,0x7ffffffe
JZ 0x001013c9
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101290:
MOV EDX,0x14
MOV R8D,R12D
MOV RCX,RBP
MOV ESI,0x2
MOV RDI,RBX
X... | int func0(int param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
char local_38 [4];
char local_34;
char local_33;
char local_32;
char local_31;
char local_30;
long local_20;
iVar4 = param_1 + 1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 != 0x7ffff... |
4,296 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
retu... | int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1248 <func0+0xdf>
movl $0x0,-0x8(%rbp)
jmpq 1232 <func0+0xc9>
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_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_C], 0
jmp loc_1248
loc_1187:
mov [rbp+var_8], 0
jmp loc_1232
loc_1193:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
... | long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+14h] [rbp-Ch]
int j; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( *(_DWORD *)(4LL * j + a1) > *(_DWORD *)(4 * (j + 1LL) + a1) )
{
v6 = *(_D... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101248
LAB_00101187:
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101232
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ... | int4 func0(long param_1,int param_2,int param_3)
{
int4 uVar1;
int4 local_14;
int4 local_10;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
for (local_10 = 0; local_10 < (param_2 - local_14) + -1; local_10 = local_10 + 1) {
if (*(int *)(param_1 + ((long)local_10 + 1) * 4) < *(in... |
4,297 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
retu... | int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 119e <func0+0x35>
lea -0x1(%rsi),%r9d
lea 0x4(%rdi),%r10
jmp 11aa <func0+0x41>
add $0x4,%rax
cmp %r8,%rax
je 11a6 <func0+0x3d>
mov (%rax),%ecx
mov 0x4(%rax),%esi
cmp %esi,%ecx
jle 117b <func0+0x12>
mov %esi,(%rax)
mov %ecx,0x4(%rax)
jmp 117b... | func0:
endbr64
test esi, esi
jle short loc_119E
lea r9d, [rsi-1]
lea r10, [rdi+4]
jmp short loc_11AA
loc_117B:
add rax, 4
cmp rax, r8
jz short loc_11A6
loc_1184:
mov ecx, [rax]
mov esi, [rax+4]
cmp ecx, esi
jle short loc_117B
mov [rax], esi
mov [rax+4], ecx
jmp ... | long long func0(int *a1, int a2, int a3)
{
int v3; // r9d
int *v4; // rax
int v5; // ecx
int v6; // esi
if ( a2 > 0 )
{
v3 = a2 - 1;
do
{
while ( v3 > 0 )
{
v4 = a1;
do
{
v5 = *v4;
v6 = v4[1];
if ( *v4 > v6 )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119e
LEA R9D,[RSI + -0x1]
LEA R10,[RDI + 0x4]
JMP 0x001011aa
LAB_0010117b:
ADD RAX,0x4
CMP RAX,R8
JZ 0x001011a6
LAB_00101184:
MOV ECX,dword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x4]
CMP ECX,ESI
JLE 0x0010117b
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],ECX
JMP 0x0010117b
LAB_00... | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
if (0 < param_2) {
param_2 = param_2 + -1;
do {
for (; 0 < param_2; param_2 = param_2 + -1) {
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar... |
4,298 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
retu... | int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1306 <func0+0x46>
lea -0x1(%rsi),%ecx
lea 0x4(%rdi),%r10
test %ecx,%ecx
je 1306 <func0+0x46>
nopl 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rdi,%rax
mov %rcx,%r9
lea (%r10,%rcx,4),%r8
nopl (%rax)
mov (%rax),%ecx
mov 0x4(%rax),%esi
cmp %esi,%ecx
jle ... | func0:
endbr64
mov r9, rdi
test esi, esi
jle short loc_130E
lea ecx, [rsi-1]
lea r10, [rdi+4]
test ecx, ecx
jz short loc_130E
nop word ptr [rax+rax+00000000h]
loc_12E0:
sub ecx, 1
mov rax, r9
mov r8, rcx
lea rdi, [r10+rcx*4]
nop dword ptr [rax]
loc_12F0:
mov ecx, [... | long long func0(int *a1, int a2, int a3)
{
int v4; // ecx
_DWORD *v5; // r10
int *v6; // rax
int v7; // r8d
int *v8; // rdi
int v9; // ecx
int v10; // esi
if ( a2 > 0 )
{
v4 = a2 - 1;
v5 = a1 + 1;
if ( a2 != 1 )
{
do
{
v6 = a1;
v7 = v4 - 1;
v8 = &v... | func0:
ENDBR64
MOV R9,RDI
TEST ESI,ESI
JLE 0x0010130e
LEA ECX,[RSI + -0x1]
LEA R10,[RDI + 0x4]
TEST ECX,ECX
JZ 0x0010130e
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001012e0:
SUB ECX,0x1
MOV RAX,R9
MOV R8,RCX
LEA RDI,[R10 + RCX*0x4]
NOP dword ptr [RAX]
LAB_001012f0:
MOV ECX,dword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x4]
CMP EC... | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
uint uVar3;
ulong uVar4;
if (0 < param_2) {
uVar3 = param_2 - 1;
uVar4 = (ulong)uVar3;
while (uVar3 != 0) {
uVar3 = (int)uVar4 - 1;
uVar4 = (ulong)uVar3;
piVar2 = param_1;
do {
iVar1 = *pi... |
4,299 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
retu... | int main() {
int arr1[] = {12, 3, 5, 7, 19};
assert(func0(arr1, 5, 2) == 5);
int arr2[] = {17, 24, 8, 23};
assert(func0(arr2, 4, 3) == 23);
int arr3[] = {16, 21, 25, 36, 4};
assert(func0(arr3, 5, 4) == 25);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 12d6 <func0+0x46>
lea -0x1(%rsi),%ecx
lea 0x4(%rdi),%r10
test %ecx,%ecx
je 12d6 <func0+0x46>
nopl 0x0(%rax,%rax,1)
sub $0x1,%ecx
mov %rdi,%rax
mov %rcx,%r9
lea (%r10,%rcx,4),%r8
nopl (%rax)
mov (%rax),%ecx
mov 0x4(%rax),%esi
cmp %esi,%ecx
jle ... | func0:
endbr64
mov r9, rdi
test esi, esi
jle short loc_12EC
lea r10, [rdi+4]
loc_129F:
cmp esi, 1
jle short loc_12E7
nop dword ptr [rax+00h]
loc_12A8:
lea ecx, [rsi-2]
mov rax, r9
lea r8, [r10+rcx*4]
nop word ptr [rax+rax+00h]
loc_12B8:
movq xmm0, qword ptr [rax]
pshufd xm... | long long func0(__m128i *a1, int a2, int a3)
{
__m128i *v3; // rax
__m128i v4; // xmm0
if ( a2 > 0 )
{
do
{
for ( ; a2 > 1; --a2 )
{
v3 = a1;
do
{
v4 = _mm_loadl_epi64(v3);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v4, 229)) < _mm_cvtsi128_si32(v4... | func0:
ENDBR64
MOV R9,RDI
TEST ESI,ESI
JLE 0x001012ec
LEA R10,[RDI + 0x4]
LAB_0010129f:
CMP ESI,0x1
JLE 0x001012e7
NOP dword ptr [RAX]
LAB_001012a8:
LEA ECX,[RSI + -0x2]
MOV RAX,R9
LEA R8,[R10 + RCX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001012b8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDI,XM... | int4 func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
do {
for (; 1 < param_2; param_2 = param_2 + -1) {
puVar1 = param_1;
do {
iVar2 = (int)*puVar1;
iVar3 = (int)((ulong)*puVar1 >> 0x20);
if (iVar3 ... |
4,300 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
outpu... | int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmpq 1260 <func0+0xb7>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5f,%al... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp loc_1260
loc_11D7:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax... | long long func0(long long a1, long long a2)
{
char v2; // cl
int v3; // eax
int v4; // eax
int v6; // [rsp+14h] [rbp-Ch]
int v7; // [rsp+18h] [rbp-8h]
int v8; // [rsp+1Ch] [rbp-4h]
v6 = 0;
v7 = 0;
v8 = 1;
while ( *(_BYTE *)(v6 + a1) )
{
if ( *(_BYTE *)(v6 + a1) == 95 )
{
v8 = 1;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101260
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX... | long func0(long param_1,long param_2)
{
bool bVar1;
int iVar2;
int4 local_14;
int4 local_10;
local_10 = 0;
bVar1 = true;
for (local_14 = 0; *(char *)(param_1 + local_14) != '\0'; local_14 = local_14 + 1) {
if (*(char *)(param_1 + local_14) == '_') {
bVar1 = true;
}
else if (bVar1) {
... |
4,301 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
outpu... | int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rsi,%r13
movzbl (%rdi),%ebx
test %bl,%bl
je 120d <func0+0x84>
lea 0x1(%rdi),%rbp
mov $0x0,%r12d
mov $0x1,%eax
mov $0x1,%r14d
mov $0x0,%r15d
jmp 11e0 <func0+0x57>
movslq %r12d,%rdx
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_122D
lea rbp, [rdi+1]
mov r12d, 0
mov eax, 1
mov r14d, 1
mov r15d, 0
jmp short loc_1200
loc_11E2:
movsxd rdx, r12d
... | long long func0(char *a1, long long a2)
{
char v2; // bl
char *v3; // rbp
int v4; // r12d
int v5; // eax
v2 = *a1;
if ( *a1 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 1;
do
{
if ( v2 == 95 )
{
v5 = 1;
}
else if ( v5 )
{
*(_BYTE *)(a2 + v4++) = *(_DWOR... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x0010122d
LEA RBP,[RDI + 0x1]
MOV R12D,0x0
MOV EAX,0x1
MOV R14D,0x1
MOV R15D,0x0
JMP 0x00101200
LAB_001011e2:
MOVSXD RDX,R12D
MOV byte ptr [R13 + RDX*0x1],BL
LEA R12D,[R12 + 0x1]
JMP 0x00... | long func0(char *param_1,long param_2)
{
bool bVar1;
__int32_t **pp_Var2;
char cVar3;
char *pcVar4;
int iVar5;
cVar3 = *param_1;
if (cVar3 == '\0') {
iVar5 = 0;
}
else {
iVar5 = 0;
bVar1 = true;
pcVar4 = param_1 + 1;
do {
if (cVar3 == '_') {
bVar1 = true;
}
... |
4,302 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
outpu... | int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
xor %r15d,%r15d
mov $0x1,%eax
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%... | func0:
endbr64
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
xor r12d, r12d
mov edx, 1
jmp short loc_1305
loc_12D8:
movsxd rax, r12d
add r12d, 1
lea r13, [r14+rax]
test edx, edx
... | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // r12d
int v5; // edx
long long v6; // rax
_BYTE *v7; // r13
_QWORD *v8; // rax
_BYTE *v9; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 1;
do
{
while ( (_BYTE)v2 == 95 )
... | func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
XOR R12D,R12D
MOV EDX,0x1
JMP 0x00101305
LAB_001012d8:
MOVSXD RAX,R12D
ADD R12D,0x1
LEA R13,[R14 + RAX*0x1]
TEST EDX,EDX
JZ 0x00101338
CALL 0x00101080
XOR EDX,EDX
MOV RAX,qword p... | int1 * func0(char *param_1,int1 *param_2)
{
char cVar1;
bool bVar2;
long lVar3;
__int32_t **pp_Var4;
long lVar5;
int iVar6;
int1 *puVar7;
lVar5 = (long)*param_1;
puVar7 = param_2;
if (*param_1 != '\0') {
param_1 = param_1 + 1;
iVar6 = 0;
bVar2 = true;
do {
while ((char)lVar... |
4,303 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* word, char *output) {
int word_index = 0;
int output_index = 0;
int capitalize_next = 1;
while (word[word_index] != '\0') {
if (word[word_index] == '_') {
capitalize_next = 1;
} else {
if (capitalize_next) {
outpu... | int main() {
char output[100];
assert(strcmp(func0("python_program", output), "PythonProgram") == 0);
assert(strcmp(func0("python_language", output), "PythonLanguage") == 0);
assert(strcmp(func0("programming_language", output), "ProgrammingLanguage") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1368 <func0+0xb8>
lea 0x1(%rdi),%rbp
xor %r15d,%r15d
mov $0x1,%eax
xor %r13d,%r13d
jmp 1322 <func0+0x72>
nopw 0x0(%rax,%rax,1)
add $0x1,%... | func0:
endbr64
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1340
lea rbp, [rdi+1]
xor r12d, r12d
mov eax, 1
jmp short loc_130B
loc_12E0:
test eax, eax
jz short loc_12F0
call ___ctype_toupper_loc
mo... | _BYTE * func0(char *a1, _BYTE *a2)
{
long long v2; // rbx
char *v3; // rbp
int v4; // r12d
int v5; // eax
long long v6; // rax
_BYTE *v7; // r12
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 1;
do
{
while ( (_BYTE)v2 == 95 )
{
v2 = *v3++;
v5 = ... | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101340
LEA RBP,[RDI + 0x1]
XOR R12D,R12D
MOV EAX,0x1
JMP 0x0010130b
LAB_001012e0:
TEST EAX,EAX
JZ 0x001012f0
CALL 0x00101080
MOV RAX,qword ptr [RAX]
MOVZX EBX,byte ptr [RAX + RBX*0x4]
LAB_001012f0:
MOVS... | int * func0(char *param_1,int *param_2)
{
char cVar1;
bool bVar2;
__int32_t **pp_Var3;
long lVar4;
ulong uVar5;
char *pcVar6;
int iVar7;
int *puVar8;
uVar5 = (ulong)*param_1;
puVar8 = param_2;
if (*param_1 != '\0') {
iVar7 = 0;
bVar2 = true;
pcVar6 = param_1 + 1;
do {
whi... |
4,304 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 116c <func0+0x23>
cmpl $0x0,-0x14(%rbp)
jne 1173 <func0+0x2a>
mov $0x0,%eax
jmp 11bf <func0+0x76>
cmpl $0x0,-0x18(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 10h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jge short loc_116C
cmp [rbp+var_14], 0
jnz short loc_1173
loc_116C:
mov eax, 0
jmp short loc_11BF
loc_1173:
cmp... | long long func0(int a1, unsigned int a2)
{
int v3; // ebx
if ( (int)a2 >= a1 || !a1 )
return 0LL;
if ( !a2 )
return 1LL;
v3 = func0((unsigned int)(a1 - 1), a2 - 1) * (a1 - a2);
return v3 + (a2 + 1) * (unsigned int)func0((unsigned int)(a1 - 1), a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x0010116c
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101173
LAB_0010116c:
MOV EAX,0x0
JMP 0x001011bf
LAB_00101173:
CMP dwor... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if ((param_2 < param_1) && (param_1 != 0)) {
if (param_2 == 0) {
iVar1 = 1;
}
else {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
iVar1 = iVar2 * (param_2 + 1) + (param_1 - param_2)... |
4,305 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edi,%esi
jge 119d <func0+0x54>
push %r12
push %rbp
push %rbx
mov %esi,%ebx
test %edi,%edi
je 1196 <func0+0x4d>
mov $0x1,%eax
test %esi,%esi
jne 1169 <func0+0x20>
pop %rbx
pop %rbp
pop %r12
retq
mov %edi,%r12d
sub %esi,%r12d
lea -0x1(%rdi),%ebp
lea -0... | func0:
endbr64
cmp esi, edi
jge short loc_119C
push r12
push rbp
push rbx
mov ebx, esi
test edi, edi
jz short loc_1195
mov eax, 1
test esi, esi
jnz short loc_1169
loc_1164:
pop rbx
pop rbp
pop r12
retn
loc_1169:
mov r12d, edi
sub r12d, esi
lea ebp, [rdi-1]... | long long func0(int a1, unsigned int a2)
{
long long result; // rax
int v3; // r12d
if ( (int)a2 >= a1 )
return 0LL;
if ( !a1 )
return 0LL;
result = 1LL;
if ( a2 )
{
v3 = func0((unsigned int)(a1 - 1), a2 - 1) * (a1 - a2);
return (unsigned int)func0((unsigned int)(a1 - 1), a2) * (a2 + 1) ... | func0:
ENDBR64
CMP ESI,EDI
JGE 0x0010119c
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
TEST EDI,EDI
JZ 0x00101195
MOV EAX,0x1
TEST ESI,ESI
JNZ 0x00101169
LAB_00101164:
POP RBX
POP RBP
POP R12
RET
LAB_00101169:
MOV R12D,EDI
SUB R12D,ESI
LEA EBP,[RDI + -0x1]
LEA ESI,[RSI + -0x1]
MOV EDI,EBP
CALL 0x00101149
IMUL R12D,EAX
MOV ES... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_2 < param_1) {
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = 1;
if (param_2 != 0) {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
iVar1 = (param_2 + 1) ... |
4,306 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
je 1280 <func0+0x80>
mov %edi,%ebx
mov %esi,%r13d
cmp %esi,%edi
jle 1280 <func0+0x80>
test %esi,%esi
je 1288 <func0+0x88>
lea 0x1(%rsi),%eax
lea -0x1(%rsi),%r12d
mov $... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test edi, edi
jz short loc_1280
mov ebx, edi
mov r13d, esi
cmp edi, esi
jle short loc_1280
test esi, esi
jz short loc_1288
lea eax, [rsi+1]
lea r12d, [rsi-1]
mov r15d, 1
xo... | long long func0(int a1, int a2)
{
unsigned int v2; // ebx
int v3; // r15d
unsigned int v4; // ebp
int v5; // r14d
int v6; // eax
if ( a1 && (v2 = a1, a1 > a2) )
{
if ( a2 )
{
v3 = 1;
v4 = 0;
do
{
v5 = v2--;
v6 = v3 * (v5 - a2) * func0(v2, (unsigned int)(a2... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JZ 0x00101280
MOV EBX,EDI
MOV R13D,ESI
CMP EDI,ESI
JLE 0x00101280
TEST ESI,ESI
JZ 0x00101288
LEA EAX,[RSI + 0x1]
LEA R12D,[RSI + -0x1]
MOV R15D,0x1
XOR EBP,EBP
MOV dword ptr [RSP + 0xc],EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if ((param_1 == 0) || (param_1 <= param_2)) {
iVar3 = 0;
}
else if (param_2 == 0) {
iVar3 = 1;
}
else {
iVar4 = 1;
iVar3 = 0;
do {
iVar2 = param_1 + -1;
iVar1 = func0(iVar2,param_2 + -1... |
4,307 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m >= n || n == 0) {
return 0;
}
if (m == 0) {
return 1;
}
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
je 1280 <func0+0x80>
mov %edi,%ebx
mov %esi,%r13d
cmp %esi,%edi
jle 1280 <func0+0x80>
test %esi,%esi
je 1288 <func0+0x88>
lea 0x1(%rsi),%eax
lea -0x1(%rsi),%r12d
mov $... | func0_constprop_1:
xor edx, edx
cmp edi, 1
jle short loc_1221
mov eax, 1
nop dword ptr [rax+00h]
loc_1210:
sub edi, 1
mov ecx, edi
imul ecx, eax
add eax, eax
add edx, ecx
cmp edi, 1
jnz short loc_1210
loc_1221:
mov eax, edx
retn | long long func0_constprop_1(int a1)
{
unsigned int v1; // edx
int v2; // eax
int v3; // ecx
v1 = 0;
if ( a1 > 1 )
{
v2 = 1;
do
{
--a1;
v3 = v2 * a1;
v2 *= 2;
v1 += v3;
}
while ( a1 != 1 );
}
return v1;
} | func0.constprop.1:
XOR EDX,EDX
CMP EDI,0x1
JLE 0x00101221
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101210:
SUB EDI,0x1
MOV ECX,EDI
IMUL ECX,EAX
ADD EAX,EAX
ADD EDX,ECX
CMP EDI,0x1
JNZ 0x00101210
LAB_00101221:
MOV EAX,EDX
RET | int func0_constprop_1(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 0;
if (1 < param_1) {
iVar1 = 1;
do {
param_1 = param_1 + -1;
iVar2 = param_1 * iVar1;
iVar1 = iVar1 * 2;
iVar3 = iVar3 + iVar2;
} while (param_1 != 1);
}
return iVar3;
} |
4,308 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list... | int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %rcx,-0x40(%rbp)
mov -0x34(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rdx
mov -0x40(%rbp),%rax
mov %rdx,(%rax)
mo... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_40], rcx
mov eax, [rbp+var_34]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_40]
mov [rax], ... | long long func0(long long a1, long long a2, int a3, void **a4)
{
void **v4; // rbx
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
*a4 = malloc(8LL * a3);
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
v4 = (void **)((char *)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr... | void func0(long param_1,long param_2,int param_3,long *param_4)
{
long lVar1;
void *pvVar2;
int local_20;
int local_1c;
pvVar2 = malloc((long)param_3 << 3);
*param_4 = (long)pvVar2;
for (local_20 = 0; local_20 < param_3; local_20 = local_20 + 1) {
lVar1 = *param_4;
pvVar2 = malloc((long)*(int ... |
4,309 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list... | int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r13
mov %rsi,%r14
mov %edx,%ebx
mov %rcx,%r12
movslq %edx,%rdi
shl $0x3,%rdi
callq 10f0 <malloc@plt>
mov %rax,(%r12)
test %ebx,%ebx
jle 12c3 <func0+0xc2>
mov %r13,%rbp
lea -0x... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13, rdi
mov r14, rsi
mov ebx, edx
mov r12, rcx
movsxd rdi, edx
shl rdi, 3
call _malloc
mov [r12], rax
test ebx, ebx
jle loc_12BF
mov rbp, r13
lea eax, [rbx-1]
lea r... | long long func0(_QWORD *a1, int *a2, int a3, long long *a4)
{
long long result; // rax
_QWORD *v8; // rbp
long long v9; // rbx
_QWORD *v10; // r15
int v11; // esi
long long v12; // rax
long long v13; // [rsp+8h] [rbp-40h]
result = malloc(8LL * a3);
*a4 = result;
if ( a3 > 0 )
{
v8 = a1;
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,RDI
MOV R14,RSI
MOV EBX,EDX
MOV R12,RCX
MOVSXD RDI,EDX
SHL RDI,0x3
CALL 0x001010f0
MOV qword ptr [R12],RAX
TEST EBX,EBX
JLE 0x001012bf
MOV RBP,R13
LEA EAX,[RBX + -0x1]
LEA RAX,[R13 + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x8],RAX
MO... | void func0(long *param_1,int *param_2,int param_3,long *param_4)
{
long *plVar1;
void *pvVar2;
long lVar3;
long lVar4;
int iVar5;
pvVar2 = malloc((long)param_3 << 3);
*param_4 = (long)pvVar2;
if (0 < param_3) {
plVar1 = param_1 + (ulong)(param_3 - 1) + 1;
lVar4 = 0;
do {
lVar3 = *p... |
4,310 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list... | int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x18(%rsp)
movslq %edx,%rdi
mov %rdi,%r13
shl $0x3,%rdi
mov %rsi,0x8(%rsp)
callq 10f0 <malloc@plt>
mov %rax,0x0(%rbp)
test %r13d,%r13d
jle 14d0 <func0+0xd0>
mov %rax... | func0:
endbr64
push r15
movsxd rax, edx
push r14
mov r14, rax
push r13
push r12
push rbp
mov rbp, rcx
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], rdi
lea rdi, ds:0[rax*8]
mov [rsp+58h+var_50], rsi
mov [rsp+58h+var_48], rax
call _malloc
mov [rbp+0], rax
test r14d,... | long long func0(long long a1, long long a2, int a3, long long *a4)
{
long long result; // rax
long long v7; // r13
long long v8; // r12
long long v9; // r15
long long v10; // rax
long long v11; // rdi
long long v12; // rcx
long long i; // rax
long long v14; // [rsp+10h] [rbp-48h]
v14 = a3;
resul... | func0:
ENDBR64
PUSH R15
MOVSXD RAX,EDX
PUSH R14
MOV R14,RAX
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
LEA RDI,[RAX*0x8]
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010f0
MOV qword ptr [RBP],RAX
TEST R14D,R14D
JLE 0x001014a8
MOV R13,RAX
XOR R12... | void func0(long param_1,long param_2,int param_3,int8 *param_4)
{
int iVar1;
long lVar2;
void *pvVar3;
void *__base;
size_t sVar4;
long lVar5;
size_t __nmemb;
pvVar3 = malloc((long)param_3 * 8);
*param_4 = pvVar3;
if (0 < param_3) {
lVar5 = 0;
while( true ) {
iVar1 = *(int *)(param... |
4,311 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int compare(const void* a, const void* b) {
const char* str1 = *(const char**)a;
const char* str2 = *(const char**)b;
return strcmp(str1, str2);
}
| void func0(char*** input_list, int* lengths, int list_size, char**** result) {
*result = malloc(list_size * sizeof(char**));
for (int i = 0; i < list_size; i++) {
(*result)[i] = malloc(lengths[i] * sizeof(char*));
for (int j = 0; j < lengths[i]; j++)
(*result)[i][j] = input_list... | int main() {
char* set1[] = {"green", "orange"};
char* set2[] = {"black", "white"};
char* set3[] = {"white", "black", "orange"};
char** input1[] = {set1, set2, set3};
int lengths1[] = {2, 2, 3};
char* expected1_1[] = {"green", "orange"};
char* expected1_2[] = {"black", "white"};
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x18(%rsp)
movslq %edx,%rdi
mov %rdi,%r13
shl $0x3,%rdi
mov %rsi,0x8(%rsp)
callq 10f0 <malloc@plt>
mov %rax,0x0(%rbp)
test %r13d,%r13d
jle 1530 <func0+0x120>
mov %ra... | func0:
endbr64
push r15
mov r15, rcx
push r14
movsxd r14, edx
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 28h
mov [rsp+58h+var_48], rdi
lea rdi, ds:0[r14*8]; size
mov [rsp+58h+var_40], rcx
call _malloc
mov [r15], rax
test r14d, r14d
jle loc_1520
mov... | char * func0(long long a1, int *a2, int a3, char **a4)
{
long long v5; // r14
int *v6; // rbx
char *result; // rax
char *v8; // r13
long long v9; // rbp
size_t v10; // r14
int v11; // r12d
_QWORD *v12; // rax
_QWORD *v13; // rdi
long long v14; // rdx
long long i; // rax
int *v16; // [rsp+8h] [rb... | func0:
ENDBR64
PUSH R15
MOV R15,RCX
PUSH R14
MOVSXD R14,EDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
LEA RDI,[R14*0x8]
MOV qword ptr [RSP + 0x18],RCX
CALL 0x001010f0
MOV qword ptr [R15],RAX
TEST R14D,R14D
JLE 0x00101520
MOV R13,RAX
LEA RAX,[RBX + R14*0x4]
XOR EBP,EBP
M... | void func0(long param_1,uint *param_2,int param_3,int8 *param_4)
{
uint *puVar1;
size_t __size;
uint uVar2;
long lVar3;
int8 uVar4;
void *pvVar5;
void *__base;
long lVar6;
long lVar7;
pvVar5 = malloc((long)param_3 * 8);
*param_4 = pvVar5;
if (param_3 < 1) {
return;
}
puVar1 = param_2... |
4,312 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
add... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dwo... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
4,313 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118C:
mov eax, edx
retn
loc_118F:
mov edx, 0
jmp short loc_118C | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 += *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118c:
MOV EAX,EDX
RET
LAB_0010118f:
MOV EDX,0x0
JMP 0x0010118c | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
4,314 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1168 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1168
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
add eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_1158
retn
loc_1168:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
result = (unsigned int)(*a1++ + result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101168
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101158
RET
LAB_00101168:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
} |
4,315 | func0 | #include <assert.h>
| int func0(int lst[], int size) {
int total = 0;
for (int i = 0; i < size; i++) {
total += lst[i];
}
return total;
}
| int main() {
int lst1[] = {1, 0, 1};
int lst2[] = {0, 0};
int lst3[] = {1, 1, 1};
assert(func0(lst1, 3) == 2);
assert(func0(lst2, 2) == 0);
assert(func0(lst3, 3) == 3);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11e0 <func0+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 11e9 <func0+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%... | func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11D8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11E1
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp ... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
... | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011d8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011e1
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XM... | int func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
iVar7 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
... |
4,316 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}... | int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov %r8,-0x30(%rbp)
mov %r9d,-0x34(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11e1 <func0+0x58>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov [rbp+var_8], 0
jmp short loc_11E1
loc_11B0:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov ra... | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
int i; // [rsp+2Ch] [rbp-8h]
int j; // [rsp+30h] [rbp-4h]
for ( i = 0; i < a4; ++i )
*(_DWORD *)(4LL * i + a5) = *(_DWORD *)(4LL * i + a3);
for ( j = 0; j < a2; ++j )
*(_DWORD *)(4LL * (i + j) + a5) = *(_DWORD *)(4LL * j + a1)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011e1
LAB_001011b0:
MOV EAX,dword ptr [RBP + -0x8]
CD... | long func0(long param_1,int param_2,long param_3,int param_4,long param_5)
{
int4 local_10;
int4 local_c;
for (local_10 = 0; local_10 < param_4; local_10 = local_10 + 1) {
*(int4 *)(param_5 + (long)local_10 * 4) = *(int4 *)(param_3 + (long)local_10 * 4);
}
for (local_c = 0; local_c < param_2; local_c ... |
4,317 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}... | int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && ... | O1 | c | func0:
endbr64
mov %r8,%rax
test %ecx,%ecx
jle 11d9 <func0+0x50>
lea -0x1(%rcx),%r8d
mov $0x0,%r9d
mov (%rdx,%r9,4),%r10d
mov %r10d,(%rax,%r9,4)
mov %r9,%r10
add $0x1,%r9
cmp %r8,%r10
jne 119e <func0+0x15>
test %esi,%esi
jle 11d8 <func0+0x4f>
lea -0x1(%rsi),%r8d
movslq %ecx,%rcx
... | func0:
endbr64
mov r10, rdi
mov rax, r8
test ecx, ecx
jle short loc_11D3
mov r8d, ecx
mov edi, 0
loc_119F:
mov r9d, [rdx+rdi*4]
mov [rax+rdi*4], r9d
add rdi, 1
cmp rdi, r8
jnz short loc_119F
loc_11B0:
test esi, esi
jle short locret_11D2
mov esi, esi
movsxd rcx, ecx... | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long result; // rax
long long i; // rdi
long long j; // rdx
result = a5;
if ( a4 <= 0 )
{
a4 = 0;
}
else
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a5 + 4 * i) = *(_DWORD *)(a3 + 4 * i);
}
if ( a2 > 0... | func0:
ENDBR64
MOV R10,RDI
MOV RAX,R8
TEST ECX,ECX
JLE 0x001011d3
MOV R8D,ECX
MOV EDI,0x0
LAB_0010119f:
MOV R9D,dword ptr [RDX + RDI*0x4]
MOV dword ptr [RAX + RDI*0x4],R9D
ADD RDI,0x1
CMP RDI,R8
JNZ 0x0010119f
LAB_001011b0:
TEST ESI,ESI
JLE 0x001011d2
MOV ESI,ESI
MOVSXD RCX,ECX
LEA RDI,[RAX + RCX*0x4]
MOV EDX,0x0
LAB_0... | void func0(long param_1,uint param_2,long param_3,uint param_4,long param_5)
{
ulong uVar1;
if ((int)param_4 < 1) {
param_4 = 0;
}
else {
uVar1 = 0;
do {
*(int4 *)(param_5 + uVar1 * 4) = *(int4 *)(param_3 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
if (0 < ... |
4,318 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}... | int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && ... | O2 | c | func0:
endbr64
mov %r8,%rax
test %ecx,%ecx
jle 11c8 <func0+0x58>
lea -0x1(%rcx),%r8d
xor %r9d,%r9d
nopw 0x0(%rax,%rax,1)
mov (%rdx,%r9,4),%r10d
mov %r10d,(%rax,%r9,4)
mov %r9,%r10
add $0x1,%r9
cmp %r8,%r10
jne 1188 <func0+0x18>
test %esi,%esi
jle 11c2 <func0+0x52>
movslq %ecx,%rcx... | func0:
endbr64
mov r10, rdi
mov rax, r8
test ecx, ecx
jle short loc_1418
movsxd r8, ecx
xor edi, edi
nop dword ptr [rax+rax+00h]
loc_13D8:
mov r9d, [rdx+rdi*4]
mov [rax+rdi*4], r9d
add rdi, 1
cmp rdi, r8
jnz short loc_13D8
loc_13E9:
test esi, esi
jle short locret_1410
... | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long result; // rax
long long i; // rdi
long long j; // rdx
result = a5;
if ( a4 <= 0 )
{
a4 = 0;
}
else
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a5 + 4 * i) = *(_DWORD *)(a3 + 4 * i);
}
if ( a2 > 0... | func0:
ENDBR64
MOV R10,RDI
MOV RAX,R8
TEST ECX,ECX
JLE 0x00101418
MOVSXD R8,ECX
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d8:
MOV R9D,dword ptr [RDX + RDI*0x4]
MOV dword ptr [RAX + RDI*0x4],R9D
ADD RDI,0x1
CMP RDI,R8
JNZ 0x001013d8
LAB_001013e9:
TEST ESI,ESI
JLE 0x00101410
MOVSXD RCX,ECX
MOVSXD RSI,ESI
XOR ED... | void func0(long param_1,int param_2,long param_3,int param_4,long param_5)
{
long lVar1;
if (param_4 < 1) {
param_4 = 0;
}
else {
lVar1 = 0;
do {
*(int4 *)(param_5 + lVar1 * 4) = *(int4 *)(param_3 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != param_4);
}
if (0 < param_2)... |
4,319 | func0 | #include <stdio.h>
#include <assert.h>
| int *func0(int test_list[], int test_list_size, int test_tup[], int test_tup_size, int res[], int res_size) {
int i, j;
for (i = 0; i < test_tup_size; i++) {
res[i] = test_tup[i];
}
for (j = 0; j < test_list_size; j++) {
res[i+j] = test_list[j];
}
return res;
}... | int main() {
int res1[5], res2[5], res3[5];
int list1[] = {5, 6, 7}, tup1[] = {9, 10};
int list2[] = {6, 7, 8}, tup2[] = {10, 11};
int list3[] = {7, 8, 9}, tup3[] = {11, 12};
func0(list1, 3, tup1, 2, res1, 5);
assert(res1[0] == 9 && res1[1] == 10 && res1[2] == 5 && res1[3] == 6 && ... | O3 | c | func0:
endbr64
mov %r8,%rax
test %ecx,%ecx
jle 1300 <func0+0x190>
lea 0xf(%rax),%r9
lea -0x1(%rcx),%r8d
sub %rdx,%r9
cmp $0x1e,%r9
jbe 12d0 <func0+0x160>
cmp $0x3,%r8d
jbe 12d0 <func0+0x160>
mov %ecx,%r8d
xor %r9d,%r9d
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax)
movdqu (%rdx,%r9... | func0:
endbr64
test ecx, ecx
jle loc_1300
lea eax, [rcx-1]
cmp eax, 2
jbe short loc_1194
lea r9, [rdx+4]
mov rax, r8
sub rax, r9
cmp rax, 8
ja short loc_1200
loc_1194:
movsxd r10, ecx
xor eax, eax
shl r10, 2
nop dword ptr [rax]
loc_11A0:
mov r9d, [rdx+rax]
mov ... | long long func0(long long a1, int a2, long long a3, int a4, long long a5)
{
long long v5; // rax
long long v6; // rax
long long v7; // rsi
long long result; // rax
long long v9; // rax
unsigned int v10; // eax
long long v11; // r9
long long v12; // rax
unsigned int v13; // eax
long long v14; // r9
... | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101300
LEA EAX,[RCX + -0x1]
CMP EAX,0x2
JBE 0x00101194
LEA R9,[RDX + 0x4]
MOV RAX,R8
SUB RAX,R9
CMP RAX,0x8
JA 0x00101200
LAB_00101194:
MOVSXD R10,ECX
XOR EAX,EAX
SHL R10,0x2
NOP dword ptr [RAX]
LAB_001011a0:
MOV R9D,dword ptr [RDX + RAX*0x1]
MOV dword ptr [R8 + RAX*0x1],R9D
ADD RAX,... | long func0(long param_1,uint param_2,long param_3,uint param_4,long param_5)
{
int8 *puVar1;
int8 uVar2;
uint uVar3;
long lVar4;
long lVar5;
ulong uVar6;
if ((int)param_4 < 1) {
param_4 = 0;
}
else if ((param_4 - 1 < 3) || ((ulong)(param_5 - (param_3 + 4)) < 9)) {
lVar4 = 0;
do {
... |
4,320 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11b8 <func0+0x6f>
cmpl $0x9,-0x8(%rbp)
jle 1178 <func0+0x2f>
cmpl $0xf,-0x8(%rbp)
jg 1178 <func0+0x2f>
addl $0x1,-0xc(%rbp)
jmp 11b4 <f... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_11BE
loc_1166:
cmp [rbp+var_8], 9
jle short loc_1178
cmp [rbp+var_8], 0Fh
jg short loc_1178
add [rbp+var_C], 1
... | long long func0(int a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-Ch]
int i; // [rsp+14h] [rbp-4h]
v3 = 0;
while ( a1 <= a2 )
{
if ( a1 <= 9 || a1 > 15 )
{
if ( a1 > 15 )
{
for ( i = a1; i; i /= 16 )
{
if ( i % 16 > 9 )
++v3;
}
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011be
LAB_00101166:
CMP dword ptr [RBP + -0x8],0x9
JLE 0x00101178
CMP dword ptr [RBP + -0x8],0xf
JG 0x00101178
ADD dw... | int func0(int param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = param_1; local_10 <= param_2; local_10 = local_10 + 1) {
if ((local_10 < 10) || (0xf < local_10)) {
if (0xf < local_10) {
for (local_c = local_10; local_c != 0; local_c = local_... |
4,321 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
jg 11a4 <func0+0x5b>
lea 0x1(%rsi),%r8d
mov $0x0,%esi
jmp 1169 <func0+0x20>
cmp $0xf,%edi
jg 1176 <func0+0x2d>
add $0x1,%edi
cmp %r8d,%edi
je 11a9 <func0+0x60>
lea -0xa(%rdi),%eax
cmp $0x5,%eax
ja 115c <func0+0x13>
add $0x1,%esi
jmp 1161 <fun... | func0:
endbr64
cmp edi, esi
jg short loc_11A5
add esi, 1
mov r8d, 0
jmp short loc_1168
loc_115C:
cmp edi, 0Fh
jg short loc_1176
loc_1161:
add edi, 1
cmp edi, esi
jz short loc_11AB
loc_1168:
lea eax, [rdi-0Ah]
cmp eax, 5
ja short loc_115C
add r8d, 1
jmp sho... | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // esi
unsigned int v4; // r8d
int v5; // edx
if ( a1 > a2 )
{
return 0;
}
else
{
v3 = a2 + 1;
v4 = 0;
do
{
if ( (unsigned int)(a1 - 10) > 5 )
{
if ( a1 > 15 )
{
v5 = a1;
do
... | func0:
ENDBR64
CMP EDI,ESI
JG 0x001011a5
ADD ESI,0x1
MOV R8D,0x0
JMP 0x00101168
LAB_0010115c:
CMP EDI,0xf
JG 0x00101176
LAB_00101161:
ADD EDI,0x1
CMP EDI,ESI
JZ 0x001011ab
LAB_00101168:
LEA EAX,[RDI + -0xa]
CMP EAX,0x5
JA 0x0010115c
ADD R8D,0x1
JMP 0x00101161
LAB_00101176:
MOV EDX,EDI
LAB_00101178:
MOV ECX,EDX
SAR ECX,... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_2 < param_1) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
if (param_1 - 10U < 6) {
iVar3 = iVar3 + 1;
}
else {
iVar1 = param_1;
if (0xf < param_1) {
do {
i... |
4,322 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
jg 1198 <func0+0x58>
add $0x1,%esi
xor %r8d,%r8d
jmp 115b <func0+0x1b>
add $0x1,%r8d
add $0x1,%edi
cmp %edi,%esi
je 118d <func0+0x4d>
lea -0xa(%rdi),%eax
cmp $0x5,%eax
jbe 1150 <func0+0x10>
cmp $0xf,%edi
jle 1154 <func0+0x14>
mov %edi,%eax
nopw... | func0:
endbr64
cmp edi, esi
jg short loc_1258
add esi, 1
xor r8d, r8d
jmp short loc_121B
loc_1210:
add r8d, 1
loc_1214:
add edi, 1
cmp esi, edi
jz short loc_124D
loc_121B:
lea eax, [rdi-0Ah]
cmp eax, 5
jbe short loc_1210
cmp edi, 0Fh
jle short loc_1214
mov e... | long long func0(int a1, int a2)
{
int v2; // esi
unsigned int v3; // r8d
int v4; // eax
if ( a1 <= a2 )
{
v2 = a2 + 1;
v3 = 0;
while ( 1 )
{
while ( (unsigned int)(a1 - 10) <= 5 )
{
++v3;
LABEL_4:
if ( v2 == ++a1 )
return v3;
}
if ( a1 <= 15 ... | func0:
ENDBR64
CMP EDI,ESI
JG 0x00101258
ADD ESI,0x1
XOR R8D,R8D
JMP 0x0010121b
LAB_00101210:
ADD R8D,0x1
LAB_00101214:
ADD EDI,0x1
CMP ESI,EDI
JZ 0x0010124d
LAB_0010121b:
LEA EAX,[RDI + -0xa]
CMP EAX,0x5
JBE 0x00101210
CMP EDI,0xf
JLE 0x00101214
MOV EAX,EDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101230:
MOV EDX,EAX
AND ED... | int func0(uint param_1,int param_2)
{
uint uVar1;
int iVar2;
if ((int)param_1 <= param_2) {
iVar2 = 0;
do {
if (param_1 - 10 < 6) {
iVar2 = iVar2 + 1;
}
else {
uVar1 = param_1;
if (0xf < (int)param_1) {
do {
iVar2 = iVar2 + (uint)(9 < (uV... |
4,323 | func0 |
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count++;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count++;
}
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
jg 1308 <func0+0x1c8>
cmp $0xf,%edi
jg 1300 <func0+0x1c0>
cmp $0xf,%esi
mov $0xf,%edx
mov $0x1,%eax
cmovle %esi,%edx
lea 0x1(%rdx),%ecx
sub %edi,%ecx
cmp %edx,%edi
cmovg %eax,%ecx
mov %edx,%eax
sub %edi,%eax
cmp $0x5,%eax
jbe 130f <func0+0x1cf>
c... | func0:
endbr64
mov ecx, edi
mov r8d, esi
xor edi, edi
cmp ecx, esi
jg short loc_11A0
cmp ecx, 0Fh
jg short loc_116B
jmp short loc_11A8
loc_1160:
add edi, 1
loc_1163:
add ecx, 1
loc_1166:
cmp r8d, ecx
jl short loc_11A0
loc_116B:
lea eax, [rcx-0Ah]
cmp eax, 5
jbe... | long long func0(signed int a1, int a2)
{
unsigned int v3; // edi
signed int v4; // eax
int v6; // edx
unsigned int v7; // r9d
__m128i v8; // xmm2
int v9; // eax
__m128i si128; // xmm7
__m128i v11; // xmm1
__m128i v12; // xmm6
__m128i v13; // xmm5
__m128i v14; // xmm8
__m128i v15; // xmm3
__m1... | func0:
ENDBR64
MOV ECX,EDI
MOV R8D,ESI
XOR EDI,EDI
CMP ECX,ESI
JG 0x001011a0
CMP ECX,0xf
JG 0x0010116b
JMP 0x001011a8
LAB_00101160:
ADD EDI,0x1
LAB_00101163:
ADD ECX,0x1
LAB_00101166:
CMP R8D,ECX
JL 0x001011a0
LAB_0010116b:
LEA EAX,[RCX + -0xa]
CMP EAX,0x5
JBE 0x00101160
MOV EAX,ECX
LAB_00101175:
MOV ESI,EAX
SAR ESI,0x... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1,int param_2)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
iVar5 = 0;
if (param_2 < par... |
4,324 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
... | int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %ecx,-0x30(%rbp)
mov %r8,-0x40(%rbp)
mov %r9d,-0x44(%rbp)
mov -0x2c(%rbp),%eax
movslq %eax,%rsi
mov -0x28(%rbp),%rax
lea -0x73(%rip),%rcx
mov $0x4,%edx
mov %r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+base], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_30], ecx
mov [rbp+var_40], r8
mov [rbp+var_44], r9d
mov eax, [rbp+var_2C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx... | _DWORD * func0(char *a1, int a2, char *a3, int a4, char *a5, int a6, int *a7)
{
int v7; // eax
char *v8; // rcx
int v9; // eax
int v10; // eax
char *v11; // rcx
int v12; // eax
int v13; // eax
char *v14; // rcx
int v15; // eax
int v16; // eax
int v17; // eax
int v18; // eax
int v19; // edx
i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x30],ECX
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x44],R9D
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x28]
L... | void * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int4 uVar1;
void *pvVar2;
int local_20;
int local_1c;
int local_18;
int local_14;
qsort(param_1,(long)param_2,4,compare);
qsort(param_3,(long)param_4,4,compare);
qsort(param_5,(l... |
4,325 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
... | int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r15
mov %esi,%ebx
mov %rdx,%r14
mov %ecx,%ebp
mov %r8,%r12
mov %r9d,%r13d
movslq %esi,%rsi
lea -0x45(%rip),%rcx
mov $0x4,%edx
callq 10c0 <qsort@plt>
movslq %ebp,%rsi
lea -0x59(%r... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r15, rdi
mov ebx, esi
mov r14, rdx
mov ebp, ecx
mov r12, r8
mov r13d, r9d
movsxd rsi, esi
lea rcx, compare
mov edx, 4
call _qsort
movsxd rsi, ebp
lea rcx, compare
mov ed... | long long func0(long long a1, int a2, long long a3, int a4, long long a5, int a6, int *a7)
{
int v13; // edi
long long v14; // rax
long long v15; // rdi
_DWORD *v16; // r9
int v17; // r8d
int v18; // ecx
int v19; // edx
int v20; // esi
long long v21; // r8
int v22; // r10d
int v23; // r11d
int ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R15,RDI
MOV EBX,ESI
MOV R14,RDX
MOV EBP,ECX
MOV R12,R8
MOV R13D,R9D
MOVSXD RSI,ESI
LEA RCX,[0x101209]
MOV EDX,0x4
CALL 0x001010c0
MOVSXD RSI,EBP
LEA RCX,[0x101209]
MOV EDX,0x4
MOV RDI,R14
CALL 0x001010c0
MOVSXD RSI,R13D
LEA RCX,[0x1012... | int * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
long lVar7;
int iVar8;
int *piVar9;
long lVar10;
qsort(param_1,(long)param_2,4,compare);
qsort(param_3,(lo... |
4,326 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
... | int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) ... | O2 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov %r9d,%r15d
push %r14
mov %r8,%r14
push %r13
mov %rdi,%r13
push %r12
mov %rdx,%r12
mov $0x4,%edx
push %rbp
mov %rsi,%rbp
push %rbx
mov %ecx,%ebx
lea -0x4e(%rip),%rcx
sub $0x18,%rsp
callq 10c0 <qsort@plt>
movslq %ebx,%rsi
mov $0x4,%e... | func0:
endbr64
push r15
movsxd rsi, esi
push r14
mov r14d, ecx
mov r15, rsi
push r13
push r12
lea r12, compare
push rbp
mov rcx, r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_48], rdx
mov edx, 4
mov dword ptr [rsp+58h+var_58], r9d
mov [rsp+58h+var_50], r8
mov [rsp... | long long func0(long long a1, int a2, long long a3, int a4, long long a5, int a6, _DWORD *a7)
{
int v9; // edi
long long v10; // rax
int v11; // r9d
long long v12; // rcx
long long v13; // r8
long long v14; // r10
long long v15; // r11
bool v16; // dl
bool v17; // al
bool v18; // si
long long v19... | func0:
ENDBR64
PUSH R15
MOVSXD RSI,ESI
PUSH R14
MOV R14D,ECX
MOV R15,RSI
PUSH R13
PUSH R12
LEA R12,[0x101850]
PUSH RBP
MOV RCX,R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDX
MOV EDX,0x4
MOV dword ptr [RSP],R9D
MOV qword ptr [RSP + 0x8],R8
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001010d0
MOV RDI,qword ptr [RSP +... | void * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int iVar1;
int iVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
int iVar7;
void *pvVar8;
int iVar9;
int iVar10;
int iVar11;
long lVar12;
int iVar13;
qsort(param_1... |
4,327 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Compare function for qsort
int compare(const void *a, const void *b) {
int int_a = *(const int*) a;
int int_b = *(const int*) b;
return (int_a > int_b) - (int_a < int_b);
}
// Function to merge three sorted lists
| int* func0(int num1[], int size1, int num2[], int size2, int num3[], int size3, int *result_size) {
// Sort the input arrays
qsort(num1, size1, sizeof(int), compare);
qsort(num2, size2, sizeof(int), compare);
qsort(num3, size3, sizeof(int), compare);
// Allocate memory for the merged array
... | int main() {
// First test case
int num1_1[] = {25, 24, 15, 4, 5, 29, 110};
int size1_1 = sizeof(num1_1) / sizeof(num1_1[0]);
int num2_1[] = {19, 20, 11, 56, 25, 233, 154};
int size2_1 = sizeof(num2_1) / sizeof(num2_1[0]);
int num3_1[] = {24, 26, 54, 48};
int size3_1 = sizeof(num3_1) ... | O3 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov %rdi,%r15
push %r14
mov %rdx,%r14
mov $0x4,%edx
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %r9d,%ebp
push %rbx
mov %ecx,%ebx
sub $0x28,%rsp
mov %ecx,0x4(%rsp)
lea -0x53(%rip),%rcx
mov %r8,0x8(%rsp)
mov %r9d,0x10(%rsp)
callq ... | func0:
endbr64
push r15
movsxd rsi, esi; nmemb
mov r15d, ecx
push r14
mov r14, rdx
push r13
push r12
push rbp
push rbx
lea rbx, compare
mov rcx, rbx; compar
sub rsp, 38h
mov [rsp+68h+var_60], rdx
mov edx, 4; size
mov dword ptr [rsp+68h+var_58], r9d
mov [rsp+68h+bas... | _DWORD * func0(char *a1, int a2, char *a3, int a4, char *a5, int a6, _DWORD *a7)
{
int v9; // edi
_DWORD *v10; // rax
int v12; // r9d
_DWORD *v13; // r14
char *v14; // r8
bool v15; // cl
bool v16; // al
bool v17; // dl
long long i; // rbx
int v19; // ebp
int v20; // r13d
int v21; // r12d
int v... | func0:
ENDBR64
PUSH R15
MOVSXD RSI,ESI
MOV R15D,ECX
PUSH R14
MOV R14,RDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x1016e0]
MOV RCX,RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x8],RDX
MOV EDX,0x4
MOV dword ptr [RSP + 0x10],R9D
MOV qword ptr [RSP + 0x20],R8
MOV dword ptr [RSP + 0x18],ESI
MOV qword ptr [RSP + 0x28],RDI
CA... | void * func0(void *param_1,int param_2,void *param_3,int param_4,void *param_5,int param_6,
int *param_7)
{
int iVar1;
bool bVar2;
bool bVar3;
bool bVar4;
int iVar5;
void *pvVar6;
int iVar7;
long lVar8;
bool bVar9;
long lVar10;
int iVar11;
long lVar12;
int iVar13;
int iVar14;
... |
4,328 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1184 <func0+0x3b>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x31,%al
jne 1180 <func0+0x37>
addl $0x1,-0x... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1184
loc_1168:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 31h ; '1'
jnz sh... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == 49 )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101184
LAB_00101168:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x31
JN... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(char *)(param_1 + local_c) == '1') {
local_10 = local_10 + 1;
}
}
return local_10;
} |
4,329 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1178 <func0+0x2f>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x1(%rdi,%rdx,1),%rsi
mov $0x0,%edx
cmpb $0x31,(%rax)
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x1,%rax
cmp %rsi,%rax
jne 1161 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1175 <fu... | func0:
endbr64
test esi, esi
jle short loc_1178
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx+1]
mov edx, 0
loc_1161:
cmp byte ptr [rax], 31h ; '1'
setz cl
movzx ecx, cl
add edx, ecx
add rax, 1
cmp rax, rsi
jnz short loc_1161
loc_1175:
mov eax, edx
retn
loc_1178:
mo... | long long func0(_BYTE *a1, int a2)
{
_BYTE *v2; // rax
long long v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 += *v2++ == 49;
while ( v2 != (_BYTE *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101178
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x1 + 0x1]
MOV EDX,0x0
LAB_00101161:
CMP byte ptr [RAX],0x31
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101161
LAB_00101175:
MOV EAX,EDX
RET
LAB_00101178:
MOV EDX,0x0
JMP 0x00101175 | int func0(char *param_1,int param_2)
{
char *pcVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 == '1');
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
}
return iVar... |
4,330 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1280 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x1(%rdi,%rax,1),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
cmpb $0x31,(%rdi)
sete %dl
add $0x1,%rdi
add %edx,%eax
cmp %rcx,%rdi
jne 1268 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
no... | func0:
endbr64
test esi, esi
jle short loc_1280
lea eax, [rsi-1]
lea rcx, [rdi+rax+1]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1268:
xor edx, edx
cmp byte ptr [rdi], 31h ; '1'
setz dl
add rdi, 1
add eax, edx
cmp rdi, rcx
jnz short loc_1268
retn
loc_1280:
xor eax,... | long long func0(_BYTE *a1, int a2)
{
long long v2; // rcx
long long result; // rax
BOOL v4; // edx
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v4 = *a1++ == 49;
result = (unsigned int)(v4 + result);
}
while ( a1 != (_BYTE *)v2 );
return resul... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101280
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x1 + 0x1]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101268:
XOR EDX,EDX
CMP byte ptr [RDI],0x31
SETZ DL
ADD RDI,0x1
ADD EAX,EDX
CMP RDI,RCX
JNZ 0x00101268
RET
LAB_00101280:
XOR EAX,EAX
RET | int func0(char *param_1,int param_2)
{
char *pcVar1;
char cVar2;
int iVar3;
if (0 < param_2) {
pcVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
cVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar3 + (uint)(cVar2 == '1');
} while (param_1 != pcVar1);
return... |
4,331 | func0 |
#include <assert.h>
| int func0(const char* s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count = count + 1;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1388 <func0+0x248>
lea -0x1(%rsi),%eax
cmp $0xe,%eax
jbe 138b <func0+0x24b>
mov %esi,%edx
pxor %xmm1,%xmm1
pxor %xmm5,%xmm5
mov %rdi,%rax
shr $0x4,%edx
movdqa 0xea0(%rip),%xmm7
movdqa 0xea8(%rip),%xmm6
pxor %xmm4,%xmm4
shl $0x4,%rdx
add %rdi,%rdx
nopl... | func0:
endbr64
mov rdx, rdi
mov ecx, esi
test esi, esi
jle loc_1360
lea eax, [rsi-1]
cmp eax, 0Eh
jbe loc_1363
shr esi, 4
pxor xmm1, xmm1
pxor xmm5, xmm5
mov rax, rdi
shl rsi, 4
movdqa xmm6, cs:xmmword_2010
pxor xmm4, xmm4
add rsi, rdi
xchg ax, ax
loc_1180:
movdqu... | long long func0(const __m128i *a1, int a2)
{
__m128i v4; // xmm1
const __m128i *v5; // rax
__m128i si128; // xmm6
const __m128i *v7; // rsi
__m128i v8; // xmm0
__m128i v9; // xmm0
__m128i v10; // xmm3
__m128i v11; // xmm2
__m128i v12; // xmm0
__m128i v13; // xmm3
__m128i v14; // xmm1
__m128i v1... | func0:
ENDBR64
MOV RDX,RDI
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101360
LEA EAX,[RSI + -0x1]
CMP EAX,0xe
JBE 0x00101363
SHR ESI,0x4
PXOR XMM1,XMM1
PXOR XMM5,XMM5
MOV RAX,RDI
SHL RSI,0x4
MOVDQA XMM6,xmmword ptr [0x00102010]
PXOR XMM4,XMM4
ADD RSI,RDI
NOP
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM3,XMM5
ADD RAX,0x... | int func0(char *param_1,uint param_2)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
char *pcVar9;
char *pcVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18... |
4,332 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first =... | int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
ass... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %ecx,-0x24(%rbp)
mov %r8,-0x30(%rbp)
movq $0x0,-0x8(%rbp)
mov -0x30(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0xc(%rbp)
jmpq 1319 <func0+0x170>
mov -0xc(%rbp),%eax
c... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+ptr], 0
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov [rbp+var_C], 0
jmp loc_1319
loc_11E4:
mov ... | void * func0(long long a1, int a2, int a3, int a4, int *a5)
{
int i; // [rsp+24h] [rbp-Ch]
void *ptr; // [rsp+28h] [rbp-8h]
ptr = 0LL;
*a5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( a3 < *(_DWORD *)(8LL * i + a1) )
{
ptr = realloc(ptr, 8LL * (*a5 + 1));
*((_DWORD *)ptr + 2 * *a5) = a3;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x8],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0xc... | void * func0(long param_1,int param_2,int param_3,int param_4,int *param_5)
{
int local_28;
int local_14;
void *local_10;
local_10 = (void *)0x0;
*param_5 = 0;
local_28 = param_3;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (local_28 < *(int *)(param_1 + (long)local_14 * 8... |
4,333 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first =... | int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
ass... | O1 | c | func0:
endbr64
movl $0x0,(%r8)
test %esi,%esi
jle 125d <func0+0xb4>
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebp
mov %ecx,%r14d
mov %r8,%r12
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r15
mov $0x0,%edi
jmp 124e <func0+... | func0:
endbr64
mov dword ptr [r8], 0
test esi, esi
jle loc_125D
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebp, edx
mov r14d, ecx
mov r12, r8
mov rbx, rdi
lea eax, [rsi-1]
lea r15, [rdi+rax*8+8]
mov edi, 0
jmp short loc_1220
loc_... | long long func0(int *a1, int a2, int a3, int a4, int *a5)
{
int *v8; // rbx
long long v9; // r15
long long v10; // rdi
int v11; // eax
_DWORD *v12; // rdx
int v13; // r13d
int v14; // eax
_DWORD *v15; // rdx
*a5 = 0;
if ( a2 <= 0 )
return 0LL;
v8 = a1;
v9 = (long long)&a1[2 * (a2 - 1) + 2]... | func0:
ENDBR64
MOV dword ptr [R8],0x0
TEST ESI,ESI
JLE 0x0010125d
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDX
MOV R14D,ECX
MOV R12,R8
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R15,[RDI + RAX*0x8 + 0x8]
MOV EDI,0x0
JMP 0x00101220
LAB_001011e4:
MOV EAX,dword ptr [R12]
LEA ESI,[RAX + 0x1]
MOVS... | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
*param_5 = 0;
if (0 < param_2) {
piVar2 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
__ptr = (void *)0x0;
do {
iVar4 = *param_1;
if (param_3 <... |
4,334 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first =... | int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
ass... | O2 | c | func0:
endbr64
movl $0x0,(%r8)
test %esi,%esi
jle 16d0 <func0+0xd0>
push %r15
lea -0x1(%rsi),%eax
push %r14
mov %r8,%r14
push %r13
lea 0x8(%rdi,%rax,8),%r13
push %r12
mov %ecx,%r12d
push %rbp
mov %edx,%ebp
push %rbx
mov %rdi,%rbx
xor %edi,%edi
sub $0x8,%rsp
jmp 164e <func0+... | func0:
endbr64
mov dword ptr [r8], 0
test esi, esi
jle loc_16D0
push r15
lea eax, [rsi-1]
push r14
mov r14, r8
push r13
lea r13, [rdi+rax*8+8]
push r12
mov r12d, ecx
push rbp
mov ebp, edx
push rbx
mov rbx, rdi
xor edi, edi
sub rsp, 8
jmp short loc_164E
lo... | long long func0(int *a1, int a2, int a3, int a4, int *a5)
{
long long v6; // r13
int *v9; // rbx
long long v10; // rdi
int v11; // r15d
_DWORD *v12; // rdx
int v13; // eax
_DWORD *v14; // rdx
int v15; // eax
*a5 = 0;
if ( a2 > 0 )
{
v6 = (long long)&a1[2 * (a2 - 1) + 2];
v9 = a1;
v10... | func0:
ENDBR64
MOV dword ptr [R8],0x0
TEST ESI,ESI
JLE 0x001016d0
PUSH R15
LEA EAX,[RSI + -0x1]
PUSH R14
MOV R14,R8
PUSH R13
LEA R13,[RDI + RAX*0x8 + 0x8]
PUSH R12
MOV R12D,ECX
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RDI
XOR EDI,EDI
SUB RSP,0x8
JMP 0x0010164e
LAB_00101640:
CMP EBP,R12D
JL 0x00101689
LAB_00101645:
ADD RBX... | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
*param_5 = 0;
if (param_2 < 1) {
return (void *)0x0;
}
piVar2 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
__ptr = (void *)0x0;
do {
while (iVar3 = *p... |
4,335 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} pair;
| pair* func0(pair test_list[], int test_size, int strt_val, int stop_val, int* res_size) {
pair* res = NULL;
*res_size = 0;
for(int i = 0; i < test_size; i++) {
if(test_list[i].first > strt_val) {
res = realloc(res, (*res_size + 1) * sizeof(pair));
res[*res_size].first =... | int main() {
// Test 1
pair test1[] = { {6, 9}, {15, 34}, {48, 70} };
int res_size1;
pair* result1 = func0(test1, 3, 2, 100, &res_size1);
pair expected1[] = { {2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100} };
assert(res_size1 == 6);
for(int i = 0; i < 6; i++) {
ass... | O3 | c | func0:
endbr64
movl $0x0,(%r8)
test %esi,%esi
jle 1770 <func0+0xd0>
push %r15
lea -0x1(%rsi),%eax
push %r14
mov %r8,%r14
push %r13
lea 0x8(%rdi,%rax,8),%r13
push %r12
mov %ecx,%r12d
push %rbp
mov %edx,%ebp
push %rbx
mov %rdi,%rbx
xor %edi,%edi
sub $0x8,%rsp
jmp 16ee <func0+... | func0:
endbr64
mov dword ptr [r8], 0
test esi, esi
jle loc_1600
push r15
movsxd rsi, esi
push r14
mov r14, r8
push r13
mov r13d, ecx
push r12
lea r12, [rdi+rsi*8]
push rbp
mov ebp, edx
push rbx
mov rbx, rdi
xor edi, edi; ptr
sub rsp, 8
jmp short loc_156E
loc... | char * func0(unsigned int *a1, int a2, signed int a3, signed int a4, int *a5)
{
unsigned int *v7; // r12
unsigned int *v9; // rbx
char *v10; // rdi
unsigned int v11; // r15d
int v12; // eax
signed int *v13; // rdx
int v14; // eax
*a5 = 0;
if ( a2 > 0 )
{
v7 = &a1[2 * a2];
v9 = a1;
v10 =... | func0:
ENDBR64
MOV dword ptr [R8],0x0
TEST ESI,ESI
JLE 0x00101600
PUSH R15
MOVSXD RSI,ESI
PUSH R14
MOV R14,R8
PUSH R13
MOV R13D,ECX
PUSH R12
LEA R12,[RDI + RSI*0x8]
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RDI
XOR EDI,EDI
SUB RSP,0x8
JMP 0x0010156e
LAB_00101560:
CMP EBP,R13D
JL 0x001015b1
LAB_00101565:
ADD RBX,0x8
CMP RBX... | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
*param_5 = 0;
if (param_2 < 1) {
return (void *)0x0;
}
piVar1 = param_1 + (long)param_2 * 2;
__ptr = (void *)0x0;
do {
while (iVar3 = *param_1, par... |
4,336 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize res... | int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1,... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %rcx,-0x50(%rbp)
cmpl $0x0,-0x3c(%rbp)
jne 1220 <func0+0x35>
mov -0x50(%rbp),%rax
movl $0x0,(%rax)
mov $0x0,%eax
jmpq 1489 <func0+0x29e>
movl $0x0,-0x2c(%rbp)
jmp... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_50], rcx
cmp [rbp+var_3C], 0
jnz short loc_1220
mov rax, [rbp+var_50]
mov dword ptr [rax], 0
mov eax, 0
jmp locret_148C
loc_1220:
mov [r... | _DWORD * func0(_QWORD *a1, int a2, int *a3, _DWORD *a4)
{
int v5; // eax
int v6; // eax
int i; // [rsp+24h] [rbp-2Ch]
int v10; // [rsp+28h] [rbp-28h]
int j; // [rsp+2Ch] [rbp-24h]
int k; // [rsp+30h] [rbp-20h]
int v13; // [rsp+34h] [rbp-1Ch]
int v14; // [rsp+38h] [rbp-18h]
int v15; // [rsp+3Ch] [rbp-1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x00101220
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x0
MOV EAX,0x0
JMP 0x0010148c
LAB_00101220:... | void * func0(long *param_1,int param_2,int *param_3,int *param_4)
{
void *pvVar1;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
void *local_18;
if (param_2 == 0) {
*param_4 = 0;
local_18 = (void *)0x0;
}
else {
for (local_34 = 0... |
4,337 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize res... | int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1,... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rcx,(%rsp)
test %esi,%esi
jne 120e <func0+0x3c>
mov (%rsp),%rax
movl $0x0,(%rax)
mov $0x0,%r13d
mov %r13,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov ebp, esi
mov [rsp+48h+var_48], rcx
mov r15d, 0
test esi, esi
jnz short loc_120C
loc_11F4:
mov rax, [rsp+48h+var_48]
mov [rax], ebp
mov rax, r15
add rsp, 18h
pop rbx
pop ... | long long func0(_QWORD *a1, int a2, int *a3, int *a4)
{
int v4; // ebp
long long v5; // r15
long long i; // rbx
long long v10; // r13
int v11; // edi
long long v12; // rdx
int v13; // eax
int v14; // ebx
_QWORD *v15; // r14
long long v16; // r12
int v17; // r8d
int v18; // ecx
int v19; // edx... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV EBP,ESI
MOV qword ptr [RSP],RCX
MOV R15D,0x0
TEST ESI,ESI
JNZ 0x0010120c
LAB_001011f4:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX],EBP
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010120c:
MOV R12,... | void * func0(long *param_1,uint param_2,int *param_3,uint *param_4)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
uint uVar7;
ulong uVar8;
uint uVar9;
void *__ptr;
long *plVar10;
void *pvVar11;
int *local_40;
pvVar11 = (void *)0x0;
uVar9 = param_2;
if (param_2 ... |
4,338 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize res... | int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1,... | O2 | c | func0:
endbr64
test %esi,%esi
je 17b0 <func0+0x10>
jmpq 1600 <func0.part.0>
nopl (%rax)
movl $0x0,(%rcx)
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0_part_0:
push r15
mov r15, rdi
push r14
movsxd r14, esi
push r13
lea r13, cmpfunc
push r12
xor r12d, r12d
push rbp
mov rbp, r14
push rbx
mov rbx, rdx
sub rsp, 18h
mov [rsp+48h+var_40], rcx
test r14d, r14d
jle short loc_164E
xchg ax, ax
loc_1630:
movsxd rsi,... | long long func0_part_0(long long *a1, int a2, int *a3, _DWORD *a4)
{
long long v5; // r14
long long v6; // r12
long long v9; // rsi
long long v10; // rdi
long long v11; // rax
int v12; // r9d
long long v13; // r12
long long v14; // rcx
long long v15; // rdx
int v16; // r13d
int v17; // eax
long... | func0.part.0:
PUSH R15
MOV R15,RDI
PUSH R14
MOVSXD R14,ESI
PUSH R13
LEA R13,[0x1015f0]
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,R14
PUSH RBX
MOV RBX,RDX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
TEST R14D,R14D
JLE 0x0010164e
NOP
LAB_00101630:
MOVSXD RSI,dword ptr [RBX + R12*0x4]
MOV RDI,qword ptr [R15 + R12*0x8]
MOV RC... | void * func0_part_0(long *param_1,int param_2,int *param_3,int *param_4)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
void *__ptr;
void *pvVar6;
int iVar7;
int iVar8;
long lVar9;
long lVar10;
long lVar11;
int iVar12;
long *plVar13;
lVar11 = 0;
if (0 < param_2) {
do ... |
4,339 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare integers for qsort
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Function to find common elements in nested lists
| int* func0(int **nestedlist, int num_lists, int *sizes, int *result_size) {
if (num_lists == 0) {
*result_size = 0;
return NULL;
}
// Sort each list
for(int i = 0; i < num_lists; i++) {
qsort(nestedlist[i], sizes[i], sizeof(int), cmpfunc);
}
// Initialize res... | int main() {
// First test case
int list1_1[] = {12, 18, 23, 25, 45};
int list1_2[] = {7, 12, 18, 24, 28};
int list1_3[] = {1, 5, 8, 12, 15, 16, 18};
int *nested1[] = {list1_1, list1_2, list1_3};
int sizes1[] = {5, 5, 7};
int result_size1;
int *result1 = func0(nested1, 3, sizes1,... | O3 | c | func0:
endbr64
test %esi,%esi
je 1740 <func0+0x10>
jmpq 1590 <func0.part.0>
nopl (%rax)
movl $0x0,(%rcx)
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
mov ebp, esi
push rbx
mov rbx, rdx
sub rsp, 18h
movsxd rax, dword ptr [rdx]
mov [rsp+48h+var_48], rdi
mov [rsp+48h+var_40], rcx
test esi, esi
jle loc_1750
mov r15, rdx
movsxd rdx, esi
lea r13, cmpfunc
mov ... | _DWORD * func0_part_0(_QWORD *a1, int a2, int *a3, int *a4)
{
int *v6; // r15
void **v7; // r12
int *v8; // r14
size_t v9; // rsi
void *v10; // rdi
_DWORD *v11; // rax
int v12; // edi
_DWORD *v13; // r12
int v14; // r13d
_DWORD *v15; // rdx
long long v16; // rax
long long v17; // rcx
int *v18;... | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDX
SUB RSP,0x18
MOVSXD RAX,dword ptr [RDX]
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x8],RCX
TEST ESI,ESI
JLE 0x00101750
MOV R15,RDX
MOVSXD RDX,ESI
LEA R13,[0x1015b0]
MOV R12,RDI
LEA R14,[RBX + RDX*0x4]
NOP dword ptr [RAX + RAX... | void * func0_part_0(long *param_1,int param_2,int *param_3,int *param_4)
{
int iVar1;
int iVar2;
int iVar3;
void *pvVar4;
long lVar5;
long lVar6;
int iVar7;
long lVar8;
int iVar9;
int iVar10;
long *plVar11;
void *__ptr;
int iVar12;
int *piVar13;
if (param_2 < 1) {
pvVar4 = malloc((... |
4,340 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
add %eax,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
add eax, eax
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a1 + a2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
ADD EAX,EAX
POP RBP
RET | int func0(int param_1,int param_2)
{
return (param_2 + param_1) * 2;
} |
4,341 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
4,342 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
4,343 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
4,344 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} ... | int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x8(%rbp)
jmp 1193 <func0+0x2a>
addq $0x1,-0x18(%rbp)
subl $0x1,-0x8(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 118a <... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
jmp short loc_1193
loc_118A:
add [rbp+s], 1
sub [rbp+var_8], 1
loc_1193:
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
... | long long func0(const char *a1)
{
char *s; // [rsp+8h] [rbp-18h]
int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
int j; // [rsp+1Ch] [rbp-4h]
s = (char *)a1;
v3 = strlen(a1);
while ( *s == 32 )
{
++s;
--v3;
}
if ( v3 <= 0 )
return 0xFFFFFFFFLL;
if ( *s == 43 || *s == 45 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101193
LAB_0010118a:
ADD qword ptr [RBP + -0x18],0x1
SUB dword ptr [RBP + -0x8],0x1
LAB_00101193:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,... | int8 func0(char *param_1)
{
size_t sVar1;
int8 uVar2;
char *local_20;
int local_10;
int local_c;
sVar1 = strlen(param_1);
local_10 = (int)sVar1;
for (local_20 = param_1; *local_20 == ' '; local_20 = local_20 + 1) {
local_10 = local_10 + -1;
}
if (local_10 < 1) {
uVar2 = 0xffffffff;
}
... |
4,345 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} ... | int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rsi
mov %esi,%edx
movzbl (%r8),%ecx
cmp $0x20,%cl
jne 11c2 <func0+0x79>
mov %r8,%rax
add $0x1,%rax
mov %r8d,%edx
sub %eax,%edx
add %esi,%edx
movzbl (%rax),%ecx... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
movzx esi, byte ptr [rbx]
cmp sil, 20h ; ' '
jnz short loc_11D2
mov rdx, rbx
loc_1182:
add rdx, 1
mov ecx, ebx
sub ecx, edx
add ecx, eax
movzx esi, byte ptr [rdx]
cmp sil, 20h ; ' '
jz short loc_1182
loc_1195:
mov e... | long long func0(_BYTE *a1)
{
int v1; // eax
char v2; // si
_BYTE *v3; // rdx
int v4; // ecx
long long result; // rax
_BYTE *v6; // rsi
long long v7; // rdx
_BYTE *v8; // rsi
long long v9; // rdx
v1 = strlen();
v2 = *a1;
if ( *a1 == 32 )
{
v3 = a1;
do
{
v4 = v1 + (_DWORD)a1 ... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOVZX ESI,byte ptr [RBX]
CMP SIL,0x20
JNZ 0x001011d2
MOV RDX,RBX
LAB_00101182:
ADD RDX,0x1
MOV ECX,EBX
SUB ECX,EDX
ADD ECX,EAX
MOVZX ESI,byte ptr [RDX]
CMP SIL,0x20
JZ 0x00101182
LAB_00101195:
MOV EAX,0xffffffff
TEST ECX,ECX
JLE 0x0010120a
SUB ESI,0x2b
TEST SIL,0xfd
J... | int8 func0(char *param_1)
{
char cVar1;
size_t sVar2;
int8 uVar3;
int iVar4;
char *pcVar5;
char *pcVar6;
sVar2 = strlen(param_1);
cVar1 = *param_1;
pcVar5 = param_1;
iVar4 = (int)sVar2;
while (cVar1 == ' ') {
pcVar5 = pcVar5 + 1;
iVar4 = ((int)param_1 - (int)pcVar5) + (int)sVar2;
c... |
4,346 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} ... | int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
movzbl (%rbx),%ecx
cmp $0x20,%cl
jne 12c0 <func0+0xb0>
mov %rax,%rsi
mov %rbx,%rdx
add $0x1,%rdx
mov %ebx,%eax
movzbl (%rdx),%ecx
sub %edx,%eax
add %esi,%eax
cmp $0x20,%cl
je 1230 <func0+0x20>
test %eax,%eax
jle 12b... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
movzx ecx, byte ptr [rbx]
cmp cl, 20h ; ' '
jnz loc_12C0
mov rsi, rax
mov rdx, rbx
nop
loc_1230:
add rdx, 1
mov eax, ebx
movzx ecx, byte ptr [rdx]
sub eax, edx
add eax, esi
cmp cl, 20h ; ' '
jz short loc_1230
loc_12... | long long func0(_BYTE *a1)
{
long long result; // rax
char v2; // cl
int v3; // esi
_BYTE *v4; // rdx
_BYTE *v5; // rcx
long long v6; // rdx
long long v7; // rcx
result = strlen();
v2 = *a1;
if ( *a1 == 32 )
{
v3 = result;
v4 = a1;
do
{
v2 = *++v4;
result = (unsigned ... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOVZX ECX,byte ptr [RBX]
CMP CL,0x20
JNZ 0x001012c0
MOV RSI,RAX
MOV RDX,RBX
NOP
LAB_00101230:
ADD RDX,0x1
MOV EAX,EBX
MOVZX ECX,byte ptr [RDX]
SUB EAX,EDX
ADD EAX,ESI
CMP CL,0x20
JZ 0x00101230
LAB_00101242:
TEST EAX,EAX
JLE 0x001012b0
SUB ECX,0x2b
AND ECX,0xfd
JNZ 0x0... | size_t func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
char *pcVar5;
char *pcVar6;
sVar3 = strlen(param_1);
cVar1 = *param_1;
sVar4 = sVar3;
pcVar6 = param_1;
while (cVar1 == ' ') {
pcVar6 = pcVar6 + 1;
sVar4 = (size_t)(uint)(((int)param_1 - (int)pcVar6) + (in... |
4,347 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char *text) {
int len = strlen(text);
int i;
// Strip leading and trailing spaces (Assuming only leading spaces as in original Python code)
while (*text == ' ') {
text++;
len--;
}
if (len < 1) {
return -1; // Using -1 to represent None
} ... | int main() {
assert(func0("python") == 0);
assert(func0("1") == 1);
assert(func0("12345") == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
movzbl (%rbx),%ecx
cmp $0x20,%cl
jne 12c0 <func0+0xb0>
mov %rax,%rsi
mov %rbx,%rdx
add $0x1,%rdx
mov %ebx,%eax
movzbl (%rdx),%ecx
sub %edx,%eax
add %esi,%eax
cmp $0x20,%cl
je 1230 <func0+0x20>
test %eax,%eax
jle 12b... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
movzx ecx, byte ptr [rbx]
mov rdx, rbx
cmp cl, 20h ; ' '
jnz short loc_1241
nop dword ptr [rax+rax+00000000h]
loc_1230:
movzx ecx, byte ptr [rdx+1]
add rdx, 1
cmp cl, 20h ; ' '
jz short loc_1230
sub ebx, edx
add eax, eb... | size_t func0(const char *a1)
{
size_t result; // rax
char v2; // cl
const char *v3; // rdx
_BYTE *v4; // rcx
long long v5; // rdx
const char *v6; // rax
result = strlen(a1);
v2 = *a1;
v3 = a1;
if ( *a1 == 32 )
{
do
v2 = *++v3;
while ( v2 == 32 );
result = (unsigned int)((_DWORD... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOVZX ECX,byte ptr [RBX]
MOV RDX,RBX
CMP CL,0x20
JNZ 0x00101241
NOP dword ptr [RAX + RAX*0x1]
LAB_00101230:
MOVZX ECX,byte ptr [RDX + 0x1]
ADD RDX,0x1
CMP CL,0x20
JZ 0x00101230
SUB EBX,EDX
ADD EAX,EBX
LAB_00101241:
TEST EAX,EAX
JLE 0x001012c0
SUB ECX,0x2b
AND ECX,0xfd... | size_t func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
char *pcVar5;
sVar3 = strlen(param_1);
cVar1 = *param_1;
pcVar5 = param_1;
if (cVar1 == ' ') {
do {
cVar1 = pcVar5[1];
pcVar5 = pcVar5 + 1;
} while (cVar1 == ' ');
sVar3 = (size_t)(uint)((int)s... |
4,348 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
... | int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .ele... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x70,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rsi
mov %rsi,-0x18(%rbp)
xor %esi,%esi
mov %rsp,%rsi
mov %rsi,%r12
mov -0x7c(%rbp),%esi
movslq %esi,%rdi
sub $0x1,%rdi
mov %rdi,-0x40(%rbp)
movslq %... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov ecx, [rbp+var_7C]
movsxd rax, ecx
sub rax, 1
mov [rbp+var_40], rax
movsxd rax, e... | char * func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_QWORD *v4; // rsi
_QWORD *v5; // rcx
long long v6; // rdx
int v7; // eax
int v8; // eax
size_t v9; // rax
size_t v10; // rax
size_t v11; // rax
size_t v12; // rax
size_t v13; // rax
size_t v14; // rax
_BYTE ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV ECX,dword ptr [RBP + -0x7c]
MOVSXD RAX,ECX
SUB RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOVSXD RAX,... | char * func0(long param_1,int param_2)
{
int8 *puVar1;
uint uVar2;
int8 uVar3;
long lVar4;
ulong uVar5;
size_t sVar6;
char *pcVar7;
int *puVar8;
long in_FS_OFFSET;
int auStack_88 [4];
int local_84;
long local_80;
int local_74;
int local_70;
int local_6c;
int local_68;
int local_64;
... |
4,349 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
... | int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .ele... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea (%rax,%rax,4),%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffff... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rdx, rdi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
lea rax, [rax+rax*4]
lea rax, ds:0Fh[rax*4]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFF0h
a... | char * func0(const __m128i *a1, long long a2)
{
long long v2; // rdx
signed long long v3; // rax
void *v4; // rsp
const __m128i *v5; // r9
long long m128i_i64; // r11
int v7; // ebx
int i; // ecx
_DWORD *v9; // rdx
long long v10; // rax
long long v11; // rcx
int v12; // eax
char *v13; // r13
l... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RDX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[0xf + RAX*0x4]
MOV RDI,RAX
AND RDI,-0x10
AND RAX,-0x1000
MOV RCX,RSP
SUB RCX,RAX
LAB_001012b2:... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int4 uVar2;
long lVar3;
int8 uVar4;
ulong uVar5;
long lVar6;
size_t sVar7;
char *pcVar8;
char *__s;
int1 *puVar9;
int iVar10;
int1 *puVar11;
int iVar12;
int iVar13;
int1 *puVar14;
long in_FS_OFFSET;
int1 auStack_88 [12];
int lo... |
4,350 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
... | int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .ele... | O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea (%rax,%rax,4),%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
su... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, [rax+rax*4]
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
s... | char * func0(const __m128i *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v5; // rdx
_DWORD *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
_DWORD *v10; // r9
int v11; // ebx
long long m128i_i64; // r8
int v13; // esi
_DWORD *v14; // rdx
int i; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101590... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int8 *puVar2;
int4 uVar3;
long lVar4;
int8 uVar5;
int8 uVar6;
long lVar7;
size_t sVar8;
char *__s;
char *pcVar9;
ulong uVar10;
int1 *puVar11;
int iVar12;
int1 *puVar13;
int iVar15;
int iVar16;
int1 *puVar17;
long in_FS_OFFSET;
... |
4,351 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int elements[3];
int length;
} Tuple;
typedef struct {
Tuple tuple;
int count;
} TupleCount;
| char* func0(Tuple input[], int input_size) {
TupleCount counts[input_size];
int unique = 0;
for(int i = 0; i < input_size; i++) {
int found = 0;
for(int j = 0; j < unique; j++) {
if(counts[j].tuple.length == input[i].length) {
int match = 1;
... | int main() {
// First test case
Tuple test1[] = {
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {2, 7, 0}, .length = 2 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {6, 5, 8}, .length = 3 },
{ .elements = {9, 0, 0}, .length = 1 },
{ .ele... | O3 | c | func0:
endbr64
push %rbp
movslq %esi,%rdx
mov %rdx,%rax
lea (%rdx,%rdx,4),%rdx
lea 0xf(,%rdx,4),%rdx
mov %rsp,%rbp
push %r15
mov %rdx,%rcx
and $0xfffffffffffff000,%rdx
push %r14
and $0xfffffffffffffff0,%rcx
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rbx
mov %rbx... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
mov r8, rsp
lea rdx, [rax+rax*4]
lea rdx, ds:0Fh[rdx*4]
mov rcx, rdx
and rdx, 0FFFFFFFFFFFFF000h
su... | char * func0(const __m128i *a1, int a2)
{
long long v2; // rcx
long long *v3; // r8
__int16 v4; // cx
signed long long v5; // rcx
void *v6; // rsp
long long v7; // rax
const __m128i *v8; // rsi
int v9; // ebx
const __m128i *v10; // rdi
int v11; // ecx
_DWORD *v12; // rax
int v13; // edx
unsign... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV R8,RSP
LEA RDX,[RAX + RAX*0x4]
LEA RDX,[0xf + RDX*0x4]
MOV RCX,RDX
AND RDX,-0x1000
SUB R8,RDX
AND RCX,-0x10
CMP RSP,R8
JZ 0x00101511
LA... | char * func0(int *param_1,int param_2)
{
int *piVar1;
int8 *puVar2;
int4 uVar3;
long lVar4;
int8 uVar5;
int8 uVar6;
int *puVar7;
int4 *puVar8;
int *piVar9;
size_t sVar10;
char *__s;
size_t sVar11;
long lVar12;
long lVar13;
int iVar14;
uint uVar15;
int4 *puVar16;
int4 *puVar17;
int... |
4,352 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0)... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a9 <func0+0x40>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov (%rax),%eax
test %eax,%eax
je 11a5 <func0+0x3c>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11A9
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov eax, [rax]
test eax, eax
jz short l... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( **(_DWORD **)(8LL * i + a1) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a9
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
J... | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (**(int **)(param_1 + (long)local_c * 8) != 0) break;
local_c = local_c + 1;
}
return 0;
} |
4,353 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0)... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1193 <func0+0x2a>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x8(%rdi,%rdx,8),%rcx
mov (%rax),%rdx
cmpl $0x0,(%rdx)
jne 1199 <func0+0x30>
add $0x8,%rax
cmp %rcx,%rax
jne 117c <func0+0x13>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1193
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*8+8]
loc_117C:
mov rdx, [rax]
cmp dword ptr [rdx], 0
jnz short loc_1199
add rax, 8
cmp rax, rcx
jnz short loc_117C
mov eax, 1
retn
loc_1193:
mov eax, 1
retn
loc_1199:
mov ... | long long func0(_DWORD **a1, int a2)
{
_DWORD **v2; // rax
if ( a2 <= 0 )
return 1LL;
v2 = a1;
while ( !**v2 )
{
if ( ++v2 == &a1[(unsigned int)(a2 - 1) + 1] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101193
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x8 + 0x8]
LAB_0010117c:
MOV RDX,qword ptr [RAX]
CMP dword ptr [RDX],0x0
JNZ 0x00101199
ADD RAX,0x8
CMP RAX,RCX
JNZ 0x0010117c
MOV EAX,0x1
RET
LAB_00101193:
MOV EAX,0x1
RET
LAB_00101199:
MOV EAX,0x0
RET | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
if (param_2 < 1) {
return 1;
}
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*(int *)*param_1 != 0) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return 1;
} |
4,354 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0)... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdx
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x8,%rdi
cmp %rdx,%rdi
je 1170 <func0+0x30>
mov (%rdi),%rax
mov (%rax),%eax
test %eax,%eax
je 1158 <func0+0x18>
xor %eax,%eax
retq
n... | func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rdx, [rdi+rax*8+8]
jmp short loc_1161
loc_1158:
add rdi, 8
cmp rdi, rdx
jz short loc_1170
loc_1161:
mov rax, [rdi]
mov eax, [rax]
test eax, eax
jz short loc_1158
xor eax, eax
retn
loc_1170:
mov e... | long long func0(_DWORD **a1, int a2)
{
long long v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
while ( !**a1 )
{
if ( ++a1 == (_DWORD **)v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x8 + 0x8]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x8
CMP RDI,RDX
JZ 0x00101170
LAB_00101161:
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*(int *)*param_1 != 0) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 1;
} |
4,355 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(void **list1, int length) {
for (int i = 0; i < length; i++) {
if (*((int *)list1[i]) != 0) {
return false;
}
}
return true;
}
| int main() {
void *list1[3];
int set1 = 0;
list1[0] = &set1;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == true);
int set2 = 1;
list1[0] = &set2;
list1[1] = &set1;
list1[2] = &set1;
assert(func0(list1, 3) == false);
assert(func0(list1, 0)... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdx
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x8,%rdi
cmp %rdx,%rdi
je 1170 <func0+0x30>
mov (%rdi),%rax
mov (%rax),%eax
test %eax,%eax
je 1158 <func0+0x18>
xor %eax,%eax
retq
n... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rdx, [rdi+rsi*8]
jmp short loc_1161
loc_1158:
add rdi, 8
cmp rdi, rdx
jz short loc_1170
loc_1161:
mov rax, [rdi]
mov eax, [rax]
test eax, eax
jz short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
... | long long func0(_DWORD **a1, int a2)
{
_DWORD **v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = &a1[a2];
while ( !**a1 )
{
if ( ++a1 == v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x8]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x8
CMP RDI,RDX
JZ 0x00101170
LAB_00101161:
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
if (0 < param_2) {
puVar1 = param_1 + param_2;
do {
if (*(int *)*param_1 != 0) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 1;
} |
4,356 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(n... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b5 <func0+0x4c>
mov -0x8(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11B5
loc_1188:
mov edx, [rbp+var_8]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov ecx, eax
mov eax, [rbp+var_4]
cdqe
lea ... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 = 10 * v3 + *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b5
LAB_00101188:
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LE... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = *(int *)(param_1 + (long)local_c * 4) + local_10 * 10;
}
return local_10;
} |
4,357 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(n... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1195 <func0+0x2c>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%edx
lea (%rdx,%rdx,4),%ecx
mov (%rax),%edx
lea (%rdx,%rcx,2),%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1... | func0:
endbr64
test esi, esi
jle short loc_1195
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
lea ecx, [rdx+rdx*4]
mov edx, [rax]
lea edx, [rdx+rcx*2]
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1192:
mov eax, edx
retn
loc_1195:
mov e... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 = *v2++ + 10 * v4;
while ( v2 != (_DWORD *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101195
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
LEA ECX,[RDX + RDX*0x4]
MOV EDX,dword ptr [RAX]
LEA EDX,[RDX + RCX*0x2]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101192:
MOV EAX,EDX
RET
LAB_00101195:
MOV EDX,0x0
JMP 0x00101192 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = *param_1 + iVar2 * 10;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
4,358 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(n... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rcx,%rdi
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax... | func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rdi, rcx
jnz short loc_1158
retn
loc_1170:
xor eax, eax
ret... | long long func0(int *a1, int a2)
{
long long v2; // rcx
long long result; // rax
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( a1 != ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RDI,RCX
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (param_1 != piVar1);
return iVar3;
}
... |
4,359 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int result = 0;
for (int i = 0; i < size; i++) {
result = result * 10 + nums[i];
}
return result;
}
| int main() {
int nums1[] = {1, 2, 3};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
assert(func0(nums1, size1) == 123);
int nums2[] = {4, 5, 6};
int size2 = sizeof(nums2) / sizeof(nums2[0]);
assert(func0(nums2, size2) == 456);
int nums3[] = {5, 6, 7};
int size3 = sizeof(n... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rdi,%rcx
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
xor eax, eax
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rcx, rdi
jnz short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rcx
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
LODWORD(result) = 0;
v3 = &a1[a2];
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RCX,RDI
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (piVar1 != param_1);
return iVar3;
}
return 0;
} |
4,360 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, s... | int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xa0,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movw $0x5b,0x2e23(%rip)
movl $0x0,-0x84(%rbp)
jmpq 131e <func0+0x135>
mov -0x84(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x98(%rbp),... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_98], rdi
mov [rbp+var_9C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov cs:res_1, 5Bh ; '['
mov [rbp+var_84], 0
jmp loc_132E
loc_124C:
mov eax, [rbp+var_84]
cdqe
lea rdx, ds:0[rax*8]
mov r... | char * func0(long long a1, int a2)
{
double v2; // xmm1_8
int i; // [rsp+1Ch] [rbp-84h]
double v5; // [rsp+20h] [rbp-80h]
char s[104]; // [rsp+30h] [rbp-70h] BYREF
unsigned long long v7; // [rsp+98h] [rbp-8h]
v7 = __readfsqword(0x28u);
strcpy(res_1, "[");
for ( i = 0; i < a2; i += 2 )
{
v5 = atof... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x98],RDI
MOV dword ptr [RBP + -0x9c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV word ptr [0x00104040],0x5b
MOV dword ptr [RBP + -0x84],0x0
JMP 0x0010132e
LAB_0010124c:
MOV EAX,dword ptr [RBP + -0x84]
CDQE
LEA RDX... | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
long in_FS_OFFSET;
double dVar2;
double dVar3;
int local_8c;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
for (local_8c = 0; local_8c < param_2; local_8c = local_8c + 2) {
dVar2 = ato... |
4,361 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, s... | int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == ... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
add $0xffffffffffffff80,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
movw $0x5b,0x2e4e(%rip)
test %esi,%esi
jle 12ab <func0+0xe2>
mov %rdi,%rbp
mov %esi,%r13d
lea -0x1(%rsi),%eax
shr %eax
mov %eax,%e... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov cs:res_1, 5Bh ; '['
test esi, esi
jle loc_12CD
mov rbp, rdi
lea eax, [rsi-1]
shr eax, 1
lea r15d, [rax+1]
add r15... | __int16 * func0(long long a1, int a2)
{
long long v2; // rbx
double v3; // xmm1_8
double v5; // [rsp+8h] [rbp-B0h]
_BYTE v6[104]; // [rsp+10h] [rbp-A8h] BYREF
unsigned long long v7; // [rsp+78h] [rbp-40h]
v7 = __readfsqword(0x28u);
res_1 = 91;
if ( a2 > 0 )
{
v2 = 0LL;
do
{
v5 = str... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV word ptr [0x00104040],0x5b
TEST ESI,ESI
JLE 0x001012cd
MOV RBP,RDI
LEA EAX,[RSI + -0x1]
SHR EAX,0x1
LEA R15D,[RAX + 0x1]
ADD R15,R15
MOV EBX,0x0
LEA R12,[RSP + 0x1... | int1 * func0(long param_1,int param_2)
{
long lVar1;
long in_FS_OFFSET;
double dVar2;
double dVar3;
int1 local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
if (0 < param_2) {
lVar1 = 0;
do {
dVar2 = strtod(*(char **)(param_1 + lVar1 * 8),(ch... |
4,362 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, s... | int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == ... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov $0x5b,%eax
mov %ax,0x2bcf(%rip)
test %esi,%esi
jle 1574 <func0+0x134>
lea -0x2(%rsi),%r14d
sub $0x1,%esi
mov %rdi,%rbx
xor %r15... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov eax, 5Bh ; '['
mov cs:res_1, ax
test esi, esi
jle loc_15A0
lea r14d, [rsi-2]
sub esi, 1
mov rbx, rdi
xor r15d, r1... | __int16 * func0(long long a1, int a2)
{
long long v2; // r15
double v3; // xmm1_8
long long v4; // rax
long long v5; // rax
double v7; // [rsp+8h] [rbp-B0h]
_BYTE v8[104]; // [rsp+10h] [rbp-A8h] BYREF
unsigned long long v9; // [rsp+78h] [rbp-40h]
v9 = __readfsqword(0x28u);
res_1[0] = 91;
if ( a2 > ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV EAX,0x5b
MOV word ptr [0x00104040],AX
TEST ESI,ESI
JLE 0x001015a0
LEA R14D,[RSI + -0x2]
SUB ESI,0x1
MOV RBX,RDI
XOR R15D,R15D
SHR ESI,0x1
LEA R12,[0x104040]
LEA RB... | int1 * func0(long param_1,int param_2)
{
size_t sVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
double dVar4;
double dVar5;
int1 local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
if (0 < param_2) {
lVar3 = 0;
do {
dVar4 = strtod(*(cha... |
4,363 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
| char* func0(char *test_list[], int size) {
static char res[1000];
strcpy(res, "[");
for (int i = 0; i < size; i += 2) {
char temp[100];
double first, second;
first = atof(test_list[i]);
second = atof(test_list[i+1]);
snprintf(temp, sizeof(temp), "(%.2f, %.2f)", first, s... | int main() {
char *list1[] = {"3", "4", "1", "26.45", "7.32", "8", "4", "8"};
char *list2[] = {"4", "4", "2", "27", "4.12", "9", "7", "11"};
char *list3[] = {"6", "78", "5", "26.45", "1.33", "4", "82", "13"};
assert(strcmp(func0(list1, 8), "[(3.00, 4.00), (1.00, 26.45), (7.32, 8.00), (4.00, 8.00)]") == ... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov $0x5b,%eax
mov %ax,0x2b8f(%rip)
test %esi,%esi
jle 1620 <func0+0x1a0>
lea -0x2(%rsi),%r15d
mov %rdi,%r13
mov %esi,%r14d
test %r1... | func0:
endbr64
push r15
mov eax, 5Bh ; '['
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rdx, fs:28h
mov [rsp+0B8h+var_40], rdx
xor edx, edx
mov cs:res_1, ax
test esi, esi
jle loc_1678
lea edx, [rsi-2]
mov r12, rdi
mov r14d, esi
test edx, e... | char * func0(const char **a1, int a2)
{
const char **v2; // r12
long long v3; // r13
double v4; // xmm0_8
const char *v5; // rdi
double v6; // xmm1_8
int v8; // r12d
const char **v9; // r13
const char *v10; // rdi
double v11; // xmm1_8
size_t v12; // rax
long long v13; // rax
double v14; // [rsp... | func0:
ENDBR64
PUSH R15
MOV EAX,0x5b
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RDX
XOR EDX,EDX
MOV word ptr [0x00104040],AX
TEST ESI,ESI
JLE 0x00101678
LEA EDX,[RSI + -0x2]
MOV R12,RDI
MOV R14D,ESI
TEST EDX,EDX
JG 0x001015b0
XOR R13D,R13D
LEA RBP,[0... | int1 * func0(int8 *param_1,int param_2)
{
long lVar1;
size_t sVar2;
int iVar3;
long lVar4;
int8 *puVar5;
long in_FS_OFFSET;
double dVar6;
double dVar7;
int local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1._0_2_ = 0x5b;
if (0 < param_2) {
if (param_2 + -2 ... |
4,364 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((c... | int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Se... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
movl $0x1,-0x38(%rbp)
mov -0x48(%rbp),%rax
mov %rax,-0x30(%rbp)
jmp 121f <func0+0x36>
mov -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 121a <func0+0x31>
addl $0x1,-0x38(%rbp)
addq $0x1,-0x3... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+s], rdi
mov [rbp+var_38], 1
mov rax, [rbp+s]
mov [rbp+var_30], rax
jmp short loc_121F
loc_120B:
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_121A
add [rbp+var_38], 1... | _QWORD * func0(const char *a1)
{
int v2; // eax
int v3; // [rsp+18h] [rbp-38h]
int v4; // [rsp+1Ch] [rbp-34h]
const char *i; // [rsp+20h] [rbp-30h]
const char *j; // [rsp+28h] [rbp-28h]
_QWORD *ptr; // [rsp+30h] [rbp-20h]
char *v8; // [rsp+38h] [rbp-18h]
v3 = 1;
for ( i = a1; *i; ++i )
{
if ( *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x38],0x1
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0010121f
LAB_0010120b:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x0010121a
ADD dword ptr [RBP + ... | void * func0(char *param_1)
{
void *__ptr;
char *__s;
char *pcVar1;
int local_40;
int local_3c;
char *local_38;
char *local_30;
local_40 = 1;
for (local_38 = param_1; *local_38 != '\0'; local_38 = local_38 + 1) {
if (*local_38 == ' ') {
local_40 = local_40 + 1;
}
}
__ptr = malloc... |
4,365 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((c... | int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Se... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movzbl (%rdi),%eax
test %al,%al
je 1290 <func0+0xc7>
mov %rdi,%rdx
mov $0x1,%ecx
cmp $0x20,%al
sete %al
movzbl %al,%eax
add %eax,%ecx
add $0x1,%rdx
movzbl (%rdx),%eax
test %al,%al
jne 11eb <func0+0x22... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
movzx eax, byte ptr [rdi]
test al, al
jz loc_12B0
mov rdx, rdi
mov ecx, 1
loc_120B:
cmp al, 20h ; ' '
setz al
movzx eax, al
add ecx, eax
add rdx, 1
movzx eax, byte ptr [rdx]
test al, al
jn... | long long func0(_BYTE *a1)
{
char v1; // al
_BYTE *v2; // rdx
int v3; // ecx
long long v4; // rbp
long long v5; // rax
long long v6; // r14
long long v7; // rdi
long long v8; // rbx
int v9; // r12d
v1 = *a1;
if ( *a1 )
{
v2 = a1;
v3 = 1;
do
{
v3 += v1 == 32;
v1 = *+... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001012b0
MOV RDX,RDI
MOV ECX,0x1
LAB_0010120b:
CMP AL,0x20
SETZ AL
MOVZX EAX,AL
ADD ECX,EAX
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x0010120b
LAB_00101220:
LEA EDI,[RCX + 0x1]
MOVSXD RDI,EDI
SHL... | void * func0(char *param_1)
{
char cVar1;
void *__ptr;
char *pcVar2;
int iVar3;
char *pcVar4;
long lVar5;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar3 = 1;
}
else {
iVar3 = 1;
pcVar4 = param_1;
do {
iVar3 = iVar3 + (uint)(cVar1 == ' ');
pcVar4 = pcVar4 + 1;
cVar... |
4,366 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((c... | int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Se... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
movzbl (%rdi),%eax
test %al,%al
je 15a8 <func0+0xd8>
mov %rdi,%rdx
mov $0x1,%ecx
nopw 0x0(%rax,%rax,1)
lea 0x1(%rcx),%edi
cmp $0x20,%al
jne 1506 <func0+0x36>
lea 0x2(%rcx),%eax
mov %edi,%ecx
mov %... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
movzx eax, byte ptr [rdi]
test al, al
jz loc_1598
mov rdx, rdi
mov ecx, 1
nop word ptr [rax+rax+00h]
loc_14E8:
cmp al, 20h ; ' '
setz al
add rdx, 1
movzx eax, al
add ecx, eax
movzx eax, b... | long long func0(char *a1)
{
char v2; // al
char *v3; // rdx
int v4; // ecx
long long v5; // rdi
long long v6; // r12
long long v7; // rax
long long v8; // r14
long long v9; // rdi
long long v10; // rbx
long long v11; // rbp
_QWORD *v12; // rax
long long v14; // rdi
v2 = *a1;
if ( *a1 )
{... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101598
MOV RDX,RDI
MOV ECX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001014e8:
CMP AL,0x20
SETZ AL
ADD RDX,0x1
MOVZX EAX,AL
ADD ECX,EAX
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x001014e8
LEA EDI,[RCX + 0x1]
MOV... | int8 * func0(char *param_1)
{
char cVar1;
int8 *puVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
long lVar6;
size_t __size;
int8 *puVar7;
cVar1 = *param_1;
if (cVar1 == '\0') {
__size = 0x10;
}
else {
iVar4 = 1;
pcVar5 = param_1;
do {
pcVar5 = pcVar5 + 1;
iVar4 = iV... |
4,367 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
| char** func0(const char* string) {
// Count the number of spaces to determine the number of words
int count = 1;
for (const char* ptr = string; *ptr; ptr++) {
if (*ptr == ' ') {
count++;
}
}
// Allocate memory for the list of strings
char** list = malloc((c... | int main() {
// First test case
char** result1 = func0("python programming");
assert(strcmp(result1[0], "python") == 0);
assert(strcmp(result1[1], "programming") == 0);
assert(result1[2] == NULL);
// Free memory
free(result1[0]);
free(result1[1]);
free(result1);
// Se... | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
movzbl (%rdi),%eax
test %al,%al
je 15a8 <func0+0xd8>
mov %rdi,%rdx
mov $0x1,%ecx
nopw 0x0(%rax,%rax,1)
lea 0x1(%rcx),%edi
cmp $0x20,%al
jne 1506 <func0+0x36>
lea 0x2(%rcx),%eax
mov %edi,%ecx
mov %... | func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
movzx eax, byte ptr [rdi]
test al, al
jz loc_15A0
mov rdx, rdi
mov ecx, 1
nop dword ptr [rax+00h]
loc_14E8:
cmp al, 20h ; ' '
setz al
add rdx, 1
movzx eax, al
add ecx, eax
movzx eax, b... | char * func0(char *s)
{
char v2; // al
char *v3; // rdx
int v4; // ecx
size_t v5; // rdi
char *v6; // rbx
char *v7; // rax
char *v8; // r12
char *v9; // rdi
long long v10; // r13
int v11; // eax
char *v12; // rax
v2 = *s;
if ( *s )
{
v3 = s;
v4 = 1;
do
{
++v3;
v4... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001015a0
MOV RDX,RDI
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_001014e8:
CMP AL,0x20
SETZ AL
ADD RDX,0x1
MOVZX EAX,AL
ADD ECX,EAX
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x001014e8
LEA EDI,[RCX + 0x1]
MOVSXD RD... | int8 * func0(char *param_1)
{
long lVar1;
char cVar2;
int8 *__ptr;
char *pcVar3;
int8 *puVar4;
int iVar5;
char *pcVar6;
size_t __size;
long lVar7;
cVar2 = *param_1;
if (cVar2 == '\0') {
__size = 0x10;
}
else {
iVar5 = 1;
pcVar6 = param_1;
do {
pcVar6 = pcVar6 + 1;
... |
4,368 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
xor %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
xor [rbp+var_8], eax
add... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 ^= *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
XOR dwo... | uint func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 ^ *(uint *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
4,369 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
xor (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
xor edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118C:
mov eax, edx
retn
loc_118F:
mov edx, 0
jmp short loc_118C | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 ^= *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
XOR EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118c:
MOV EAX,EDX
RET
LAB_0010118f:
MOV EDX,0x0
JMP 0x0010118c | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (param_2 < 1) {
uVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar2 = 0;
do {
uVar2 = uVar2 ^ *param_1;
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return uVar2;
} |
4,370 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1268 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1258 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12E8
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_12D8:
xor eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_12D8
retn
loc_12E8:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
result = *a1++ ^ (unsigned int)result;
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012e8
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001012d8:
XOR EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x001012d8
RET
LAB_001012e8:
XOR EAX,EAX
RET | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar2 = 0;
do {
uVar2 = uVar2 ^ *param_1;
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return uVar2;
}
return 0;
} |
4,371 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11e0 <func0+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 11e9 <func0+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
pxor %xmm2,%xmm0
cmp %rdx,%... | func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11D8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11E1
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
pxor xmm0, xmm2
cmp ... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
... | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011d8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011e1
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PXOR XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XMM... | uint func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
if ((int)param_2 < 1) {
uVar4 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar6 = 0;
uVar4 = 0;
}
else {
uVa... |
4,372 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d7 <func0+0x6e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D4
loc_1188:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdq... | long long func0(long long a1, int a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v2 = *(_DWORD *)(8LL * i + a1) * *(_DWORD *)(8LL * i + a1 + 4);
if ( v2 <= 0 )
v2 = -v2;
if ( v2 > v4 )
v4 = v2;
}
return (unsi... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d4
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX... | int func0(long param_1,int param_2)
{
int iVar1;
int4 local_14;
int4 local_10;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
iVar1 = *(int *)(param_1 + (long)local_10 * 8 + 4) * *(int *)(param_1 + (long)local_10 * 8);
if (iVar1 < 1) {
iVar1 = -iVar1;
}
... |
4,373 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a1 <func0+0x38>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rdi
mov $0x0,%ecx
mov (%rdx),%eax
imul 0x4(%rdx),%eax
mov %eax,%esi
sar $0x1f,%esi
xor %esi,%eax
sub %esi,%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0x8,%rdx
cmp %rdi,%rdx... | func0:
endbr64
test esi, esi
jle short loc_119F
mov rdx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*8+8]
mov esi, 0
loc_1181:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp esi, eax
cmovl esi, eax
add rdx, 8
cmp rdx, rdi
jnz short loc_1181
... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rdx
long long v3; // rdi
int v4; // esi
int v5; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[2 * (a2 - 1) + 2];
v4 = 0;
do
{
v5 = v2[1] * *v2;
if ( v5 <= 0 )
v5 = -(v2[1] * *v2... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119f
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x8 + 0x8]
MOV ESI,0x0
LAB_00101181:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP ESI,EAX
CMOVL ESI,EAX
ADD RDX,0x8
CMP RDX,RDI
JNZ 0x00101181
LAB_0010119c:
MOV EAX,ESI
RET
LAB... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
iVar3 = 0;
do {
iVar2 = *param_1 * param_1[1];
if (iVar2 < 1) {
iVar2 = -iVar2;
}
if (iVar3 < i... |
4,374 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x8(%rdi,%rax,8),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
imul 0x4(%rdi),%eax
cltd
xor %edx,%eax
sub %edx,%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x8,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x1... | func0:
endbr64
test esi, esi
jle short loc_1310
lea eax, [rsi-1]
xor r8d, r8d
lea rcx, [rdi+rax*8+8]
nop dword ptr [rax+rax+00h]
loc_12E8:
mov eax, [rdi]
imul eax, [rdi+4]
mov edx, eax
neg edx
cmovns eax, edx
cmp r8d, eax
cmovl r8d, eax
add rdi, 8
cmp rdi, rcx
jnz ... | long long func0(_DWORD *a1, int a2)
{
int v2; // r8d
long long v3; // rcx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[2 * (a2 - 1) + 2];
do
{
v4 = a1[1] * *a1;
if ( v4 <= 0 )
v4 = -(a1[1] * *a1);
if ( v2 < v4 )
v2 = v4;
a1 += 2;
}
while ( a... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101310
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RCX,[RDI + RAX*0x8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012e8:
MOV EAX,dword ptr [RDI]
IMUL EAX,dword ptr [RDI + 0x4]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0x8
CMP RDI,RCX
JNZ 0x001012e8
MOV EAX,R8D
RET... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
iVar2 = *param_1 * param_1[1];
if (iVar2 < 1) {
iVar2 = -iVar2;
}
if (iVar3 < iVar2) {
iVar3 = iVar... |
4,375 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int list1[][2], int size) {
int result_max = 0;
for (int i = 0; i < size; i++) {
int product = abs(list1[i][0] * list1[i][1]);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
int arr1[4][2] = {{2, 7}, {2, 6}, {1, 8}, {4, 9}};
assert(func0(arr1, 4) == 36);
int arr2[3][2] = {{10, 20}, {15, 2}, {5, 10}};
assert(func0(arr2, 3) == 200);
int arr3[4][2] = {{11, 44}, {10, 15}, {20, 5}, {12, 9}};
assert(func0(arr3, 4) == 484);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1440 <func0+0x150>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1449 <func0+0x159>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm3,%xmm3
shr $0x2,%edx
shl $0x5,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
movdqu 0x10(%rax),%xmm4
add $0x20,%rax
movdqa... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_13B0
lea eax, [rsi-1]
cmp eax, 2
jbe loc_13B9
mov edx, esi
mov rax, rdi
pxor xmm3, xmm3
shr edx, 2
shl rdx, 5
add rdx, rdi
nop dword ptr [rax]
loc_1290:
movdqu xmm2, xmmword ptr [rax]
movdqu xmm4, xmmword ptr [rax+10h]... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v3; // rax
__m128i v4; // xmm3
__m128 v5; // xmm2
__m128 v6; // xmm4
__m128 v7; // xmm1
__m128i v8; // xmm2
__m128i v9; // xmm0
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm0
__m128i v13; // xmm1
__m128i v14; // xmm1
... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x001013b0
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001013b9
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM3,XMM3
SHR EDX,0x2
SHL RDX,0x5
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101290:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQU XMM4,xmmword ptr [RAX + 0x10]
ADD RAX,0x20
MOVDQA XMM1,XMM2
SHUFPS XMM2... | uint func0(int *param_1,uint param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint *puVar6;
int *piVar7;
int *piVar8;
uint uVar9;
int *piVar10;
uint uVar11;
long lVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVa... |
4,376 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
mov %ecx,-0x14(%rbp)
cmpl $0x3,-0x14(%rbp)
jne 1195 <func0+0x2c>
cmpl $0x0,-0x10(%rbp)
jne 1195 <func0+0x2c>
mov $0x1,%eax
jmp 1210 <func0+0xa7>
cmpl $0x3,-0x14(%rbp)
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_14], ecx
cmp [rbp+var_14], 3
jnz short loc_1195
cmp [rbp+var_10], 0
jnz short loc_1195
mov eax, 1
jmp short locret_1210
loc_1195:
cmp [rbp... | long long func0(long long a1, int a2, int a3, unsigned int a4)
{
if ( a4 == 3 && !a3 )
return 1LL;
if ( a4 == 3 || !a2 || a3 < 0 )
return 0LL;
return (unsigned __int8)func0(a1, (unsigned int)(a2 - 1), (unsigned int)(a3 - *(_DWORD *)(4LL * a2 - 4 + a1)), a4 + 1)
|| (unsigned __int8)func0(a1, (unsign... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV dword ptr [RBP + -0x14],ECX
CMP dword ptr [RBP + -0x14],0x3
JNZ 0x00101195
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x00101195
MOV EAX,0x1
JMP 0x00101210
LAB_00101195:
CMP dword ... | int4 func0(long param_1,int param_2,int param_3,int param_4)
{
char cVar1;
int4 uVar2;
if ((param_4 == 3) && (param_3 == 0)) {
uVar2 = 1;
}
else if (((param_4 == 3) || (param_2 == 0)) || (param_3 < 0)) {
uVar2 = 0;
}
else {
cVar1 = func0(param_1,param_2 + -1,param_3 - *(int *)(param_1 + (l... |
4,377 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebx
cmp $0x3,%ecx
sete %dl
test %ebx,%ebx
sete %al
and %dl,%al
jne 11cb <func0+0x62>
mov %rdi,%r12
mov %ecx,%ebp
test %esi,%esi
sete %dil
mov %ebx,%ecx
shr $0x1f,%ecx
or %cl,%dil
jne 11cb <... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edx
cmp ecx, 3
setz dl
test ebx, ebx
setz al
and al, dl
jnz short loc_11CA
mov r12, rdi
mov ebp, ecx
test esi, esi
setz cl
mov edi, ebx
shr edi, 1Fh
or cl, dil
jnz short loc_11C... | bool func0(long long a1, int a2, int a3, unsigned int a4)
{
bool result; // al
char v7; // dl
char v8; // al
result = a4 == 3 && a3 == 0;
if ( !result && a3 >= 0 && a2 != 0 && a4 != 3 )
{
v7 = func0(a1, (unsigned int)(a2 - 1), (unsigned int)(a3 - *(_DWORD *)(a1 + 4LL * a2 - 4)), a4 + 1);
v8 = 1;
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDX
CMP ECX,0x3
SETZ DL
TEST EBX,EBX
SETZ AL
AND AL,DL
JNZ 0x001011ca
MOV R12,RDI
MOV EBP,ECX
TEST ESI,ESI
SETZ CL
MOV EDI,EBX
SHR EDI,0x1f
OR CL,DIL
JNZ 0x001011ca
TEST DL,DL
JNZ 0x001011ca
LEA R13D,[RSI + -0x1]
LEA ECX,[RBP + 0x1]
MOVSXD RSI,ESI
M... | bool func0(long param_1,int param_2,int param_3,int param_4)
{
bool bVar1;
char cVar2;
byte bVar3;
bool bVar4;
bVar4 = param_4 == 3;
bVar1 = param_3 == 0 && bVar4;
if (((param_3 != 0 || !bVar4) && (param_2 != 0 && -1 < param_3)) && (!bVar4)) {
cVar2 = func0(param_1,param_2 + -1,param_3 - *(int *)(... |
4,378 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x3,%ecx
sete %r8b
test %edx,%edx
sete %al
and %r8b,%al
jne 1320 <func0+0x30>
test %esi,%esi
mov %edx,%r9d
sete %r10b
shr $0x1f,%r9d
or %r9b,%r10b
jne 1320 <func0+0x30>
test %r8b,%r8b
jne 1320 <func0+0x30>
jmp 1330 <func0.part.0>
xchg %ax,%ax
retq
data16 nop... | func0_part_0:
push r15
lea r15d, [rcx+1]
push r14
mov r14d, edx
push r13
shr r14d, 1Fh
mov r13d, ecx
push r12
mov r12, rdi
push rbp
mov ebp, esi
push rbx
mov ebx, edx
sub rsp, 18h
loc_1313:
movsxd rax, ebp
cmp r15d, 3
mov r9d, ebx
setz dl
sub r9d, [r12+r... | char func0_part_0(long long a1, unsigned int a2, unsigned int a3, int a4)
{
unsigned int v4; // r15d
unsigned int v5; // r14d
int v9; // r9d
char result; // al
bool v11; // r8
v4 = a4 + 1;
v5 = a3 >> 31;
do
{
v9 = a3 - *(_DWORD *)(a1 + 4LL * (int)a2 - 4);
result = v4 == 3 && a3 == *(_DWORD *... | func0.part.0:
PUSH R15
LEA R15D,[RCX + 0x1]
PUSH R14
MOV R14D,EDX
PUSH R13
SHR R14D,0x1f
MOV R13D,ECX
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
LAB_00101313:
MOVSXD RAX,EBP
CMP R15D,0x3
MOV R9D,EBX
SETZ DL
SUB R9D,dword ptr [R12 + RAX*0x4 + -0x4]
SETZ AL
AND AL,DL
JNZ 0x0010135c
SUB EB... | void func0_part_0(long param_1,int param_2,int param_3,int param_4)
{
char cVar1;
int iVar2;
int iVar3;
iVar3 = param_4 + 1;
while( true ) {
iVar2 = param_3 - *(int *)(param_1 + -4 + (long)param_2 * 4);
if (iVar2 == 0 && iVar3 == 3) {
return;
}
param_2 = param_2 + -1;
if (((iVar3... |
4,379 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int A1[] = {2, 7, 4, 0, 9, 5, 1, 3};
int A2[] = {1, 4, 5, 6, 7, 8, 5, 9};
int A3[] = {10, 4, 2, 3, 5};
assert(func0(A1, 8, 6, 0) == true);
assert(func0(A2, 8, 6, 0) == false);
assert(func0(A3, 5, 15, 0) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%r10d
cmp $0x3,%ecx
sete %dl
test %r10d,%r10d
sete %al
and %dl,%al
jne 13d8 <func0+0x88>
push %r12
mov %ecx,%r11d
mov %r10d,%ecx
push %rbp
mov %rdi,%rbp
sub $0x8,%rsp
test %esi,%esi
sete %dil
shr $0x1f,%ecx
or %cl,%dil
jne 13ca <func0+0x7a>
test ... | func0_part_0:
push r15
push r14
lea r14d, [rcx+1]
push r13
mov r13d, ecx
push r12
mov r12, rdi
push rbp
mov ebp, edx
push rbx
mov ebx, esi
sub rsp, 8
loc_12BC:
movsxd rax, ebx
cmp r14d, 3
mov esi, ebp
setz dl
sub esi, [r12+rax*4-4]
setz al
and al, dl
jnz ... | char func0_part_0(long long a1, unsigned int a2, int a3, int a4)
{
unsigned int v4; // r14d
int v8; // esi
char result; // al
bool v10; // r15
v4 = a4 + 1;
do
{
v8 = a3 - *(_DWORD *)(a1 + 4LL * (int)a2 - 4);
result = v4 == 3 && a3 == *(_DWORD *)(a1 + 4LL * (int)a2 - 4);
if ( result )
b... | func0.part.0:
PUSH R15
PUSH R14
LEA R14D,[RCX + 0x1]
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV EBX,ESI
SUB RSP,0x8
LAB_001012bc:
MOVSXD RAX,EBX
CMP R14D,0x3
MOV ESI,EBP
SETZ DL
SUB ESI,dword ptr [R12 + RAX*0x4 + -0x4]
SETZ AL
AND AL,DL
JNZ 0x001012f7
SUB EBX,0x1
SETZ R15B
TEST ESI,ESI... | void func0_part_0(long param_1,int param_2,int param_3,int param_4)
{
char cVar1;
int iVar2;
int iVar3;
iVar3 = param_4 + 1;
while( true ) {
iVar2 = param_3 - *(int *)(param_1 + -4 + (long)param_2 * 4);
if (iVar2 == 0 && iVar3 == 3) {
return;
}
param_2 = param_2 + -1;
if (((-1 < ... |
4,380 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == ... | int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 1199 <func0+0x10>
sub $0xe00,%rsp
mov %edi,-0x5df4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x5dd0(%rbp),%rax
mov $0x2ee0,%edx
mov $0x0,%esi
... | func0:
endbr64
push rbp
mov rbp, rsp
lea r11, [rsp+var_5000]
loc_1199:
sub rsp, 1000h
or [rsp+1000h+var_1000], 0
cmp rsp, r11
jnz short loc_1199
sub rsp, 0E00h
mov [rbp+var_5DF4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+s]
mov edx, 2EE0... | // bad sp value at call has been detected, the output may be wrong!
long long func0(int a1)
{
int v1; // eax
int v3; // [rsp+Ch] [rbp-5DE8h]
int i; // [rsp+10h] [rbp-5DE4h]
int j; // [rsp+14h] [rbp-5DE0h]
int k; // [rsp+18h] [rbp-5DDCh]
int m; // [rsp+1Ch] [rbp-5DD8h]
int v8; // [rsp+20h] [rbp-5DD4h]
_... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
LEA R11,[RSP + -0x5000]
LAB_00101199:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x00101199
SUB RSP,0xe00
MOV dword ptr [RBP + -0x5df4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x5dd0]
MOV EDX,0x2ee0
MOV ESI,0x0
MOV RDI,RAX... | int func0(int param_1)
{
int iVar1;
int *puVar2;
int *puVar3;
long in_FS_OFFSET;
int local_5df0;
int local_5dec;
int local_5de8;
int local_5de4;
int local_5de0;
int local_5dd8 [884];
int local_5008 [8464];
int aiStack_2ef8 [3002];
long local_10;
puVar2 = &stack0xfffffffffffffff8;
do {
... |
4,381 | func0 |
#include <stdio.h>
#include <assert.h>
#define MAX 3000
| int func0(int n) {
int primes[MAX] = {0};
int result[MAX], resultIndex = 0;
for (int i = 2; i < MAX; i++) {
if (primes[i] == 0) {
primes[i] = 1;
int j = i * 2;
while (j < MAX) {
primes[j] -= 1;
if ((primes[j] + 3) == ... | int main() {
assert(func0(1) == 30);
assert(func0(50) == 273);
assert(func0(1000) == 2664);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
lea -0x5000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 1196 <func0+0xd>
sub $0xdd0,%rsp
mov %edi,%ebx
mov %fs:0x28,%rax
mov %rax,0x5dc8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x2ee0,%edx
mov $0x0,%esi
callq 1090 <memset@plt>
mov $0... | func0:
endbr64
push rbx
lea r11, [rsp+8+var_5008]
loc_1196:
sub rsp, 1000h
or [rsp+1008h+var_1008], 0
cmp rsp, r11
jnz short loc_1196
sub rsp, 0DD0h
mov ebx, edi
mov rax, fs:28h
mov [rsp+1DD8h+arg_3FE8], rax
xor eax, eax
mov rdi, rsp
mov edx, 2EE0h
mov esi, 0
call... | // positive sp value has been detected, the output may be wrong!
long long func0(int a1)
{
long long v2; // r8
long long v3; // rcx
int v4; // edi
long long v5; // rax
int v6; // edx
int v7; // edi
_QWORD *v8; // rax
int v9; // edx
int v10; // ecx
_DWORD v12[884]; // [rsp-DD0h] [rbp-5DD8h] BYREF
... | func0:
ENDBR64
PUSH RBX
LEA R11,[RSP + -0x5000]
LAB_00101196:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x00101196
SUB RSP,0xdd0
MOV EBX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x5dc8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x2ee0
MOV ESI,0x0
CALL 0x00101090
MOV R8D,0x4
MOV ECX,0x2
MOV EDI,0x0
MOV... | int4 func0(int param_1)
{
int1 *puVar1;
int iVar2;
long lVar3;
int *piVar4;
long lVar5;
int1 *puVar6;
int iVar7;
long lVar8;
long in_FS_OFFSET;
int aiStack_5dd0 [882];
int1 local_5008 [20480];
puVar1 = &stack0xfffffffffffffff8;
do {
puVar6 = puVar1;
*(int8 *)(puVar6 + -0x1000) = *(... |
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.