index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
6,482 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int len = strlen(text);
char** result = malloc(len * sizeof(char*));
if (result == NULL) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
int current_word = 0;
int start = 0;
for (int i = 1; i <= len; i++... | int main() {
int count = 0;
char** result;
result = func0("PythonProgramLanguage", &count);
assert(count == 3);
assert(strcmp(result[0], "Python") == 0);
assert(strcmp(result[1], "Program") == 0);
assert(strcmp(result[2], "Language") == 0);
for (int i = 0; i < count; i++) free(... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rsi,0x18(%rsp)
callq 10e0 <strlen@plt>
movslq %eax,%rdi
mov %eax,0x4(%rsp)
mov %rax,%rbx
shl $0x3,%rdi
callq 1120 <malloc@plt>
mov %rax,0x10(%rsp)
test %rax,%rax
je 1670 ... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], rsi
call _strlen
movsxd rdi, eax
mov [rsp+58h+var_54], eax
mov rbx, rax
shl rdi, 3
call _malloc
mov [rsp+58h+var_48], rax
test rax, rax
jz loc... | long long func0(long long a1, _DWORD *a2)
{
int v3; // ebp
long long v4; // r13
int v5; // r15d
long long v6; // rsi
int v7; // r14d
long long v8; // rdi
long long v9; // rdx
int v11; // [rsp+4h] [rbp-54h]
long long v12; // [rsp+8h] [rbp-50h]
long long v13; // [rsp+10h] [rbp-48h]
v11 = strlen();... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RSI
CALL 0x001010f0
MOVSXD RDI,EAX
MOV dword ptr [RSP + 0x4],EAX
MOV RBX,RAX
SHL RDI,0x3
CALL 0x00101140
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x0010163a
XOR EBP,EBP
TEST EBX,EBX
JLE 0x00101... | void * func0(char *param_1,int *param_2)
{
ushort *puVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
ushort **ppuVar5;
void *pvVar6;
int iVar7;
long lVar8;
int iVar9;
int iVar10;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
if (pvVar4 != (void *)0x0) {
... |
6,483 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int len = strlen(text);
char** result = malloc(len * sizeof(char*));
if (result == NULL) {
perror("Failed to allocate memory");
exit(EXIT_FAILURE);
}
int current_word = 0;
int start = 0;
for (int i = 1; i <= len; i++... | int main() {
int count = 0;
char** result;
result = func0("PythonProgramLanguage", &count);
assert(count == 3);
assert(strcmp(result[0], "Python") == 0);
assert(strcmp(result[1], "Program") == 0);
assert(strcmp(result[2], "Language") == 0);
for (int i = 0; i < count; i++) free(... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rsi,0x18(%rsp)
callq 10e0 <strlen@plt>
movslq %eax,%rdi
mov %eax,0x4(%rsp)
mov %rax,%rbx
shl $0x3,%rdi
callq 1120 <malloc@plt>
mov %rax,0x10(%rsp)
test %rax,%rax
je 1650 ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], rsi
call _strlen
movsxd rdi, eax
mov [rsp+58h+var_4C], eax
mov rbx, rax
shl rdi, 3; size
call _malloc
mov [rsp+58h+var_48], rax
test rax, rax
jz ... | _QWORD * func0(const char *a1, _DWORD *a2)
{
long long v3; // r13
int v4; // r15d
int v5; // ebx
const unsigned __int16 *v6; // r14
long long v7; // rcx
int v8; // r12d
void *v9; // rdi
const char *v10; // rsi
int v12; // [rsp+Ch] [rbp-4Ch]
_QWORD *v13; // [rsp+10h] [rbp-48h]
v12 = strlen(a1);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RSI
CALL 0x001010f0
MOVSXD RDI,EAX
MOV dword ptr [RSP + 0xc],EAX
MOV RBX,RAX
SHL RDI,0x3
CALL 0x00101140
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x00101180
TEST EBX,EBX
JLE 0x00101660
CALL 0x0... | void * func0(char *param_1,int *param_2)
{
ushort *puVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
ushort **ppuVar5;
void *pvVar6;
long lVar7;
int iVar8;
int iVar9;
long lVar10;
int iVar11;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
if (pvVar4 != (vo... |
6,484 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int lst[], int size) {
int* result = malloc(size * sizeof(int));
int i;
for (i = 0; i < size; i += 2) {
if (i + 1 < size) {
result[i] = lst[i + 1];
result[i + 1] = lst[i];
} else {
result[i] = lst[i];
}
}
return result... | int main() {
int lst1[] = {0, 1, 2, 3, 4, 5};
int size1 = sizeof(lst1) / sizeof(lst1[0]);
int* result1 = func0(lst1, size1);
int expected1[] = {1, 0, 3, 2, 5, 4};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int lst2[] = {5, 6, 7, 8, 9, 10};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 127d <func0+0xd4>
mov -0xc(%rbp),%eax
add $0x1,%eax
cmp %eax... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp loc_127D
loc_11DD:
mov eax, [rbp+var_C]
add eax, 1
cmp ... | _DWORD * func0(long long a1, int a2)
{
long long v2; // rcx
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v5; // [rsp+18h] [rbp-8h]
v5 = malloc(4LL * a2);
for ( i = 0; i < a2; i += 2 )
{
if ( a2 <= i + 1 )
{
v2 = i;
}
else
{
v5[i] = *(_DWORD *)(4 * (i + 1LL) + a1);
v2 = i + 1LL... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010127d
LAB_001011dd:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,... | void * func0(long param_1,int param_2)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 2) {
if (local_14 + 1 < param_2) {
*(int4 *)((long)pvVar1 + (long)local_14 * 4) =
*(int4 *)(param_1 + ((long)local_14 +... |
6,485 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int lst[], int size) {
int* result = malloc(size * sizeof(int));
int i;
for (i = 0; i < size; i += 2) {
if (i + 1 < size) {
result[i] = lst[i + 1];
result[i + 1] = lst[i];
} else {
result[i] = lst[i];
}
}
return result... | int main() {
int lst1[] = {0, 1, 2, 3, 4, 5};
int size1 = sizeof(lst1) / sizeof(lst1[0]);
int* result1 = func0(lst1, size1);
int expected1[] = {1, 0, 3, 2, 5, 4};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int lst2[] = {5, 6, 7, 8, 9, 10};
... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%ebx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 11f6 <func0+0x4d>
mov $0x0,%edx
jmp 11de <func0+0x35>
mov 0x0(%rbp,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
add $0x2,%rdx
cmp %edx,%eb... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebx, ebx
jle short loc_11F6
mov edx, 0
jmp short loc_11DE
loc_11CF:
mov ecx, [rbp+rdx*4+0]
mov [rax+rdx*4], ecx
loc_11D6:
add rdx, 2
cmp ebx, edx
jl... | long long func0(long long a1, int a2)
{
long long result; // rax
long long v3; // rdx
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v3 = 0LL;
do
{
if ( a2 <= (int)v3 + 1 )
{
*(_DWORD *)(result + 4 * v3) = *(_DWORD *)(a1 + 4 * v3);
}
else
{
*(_DWORD *)(r... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001011f6
MOV EDX,0x0
JMP 0x001011de
LAB_001011cf:
MOV ECX,dword ptr [RBP + RDX*0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_001011d6:
ADD RDX,0x2
CMP EBX,EDX
JLE 0x001011f6
LAB_001011de:
LEA ... | void func0(long param_1,int param_2)
{
void *pvVar1;
long lVar2;
pvVar1 = malloc((long)param_2 << 2);
if (0 < param_2) {
lVar2 = 0;
do {
if ((int)lVar2 + 1 < param_2) {
*(int4 *)((long)pvVar1 + lVar2 * 4) = *(int4 *)(param_1 + 4 + lVar2 * 4);
*(int4 *)((long)pvVar1 + lVar2 * 4 ... |
6,486 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int lst[], int size) {
int* result = malloc(size * sizeof(int));
int i;
for (i = 0; i < size; i += 2) {
if (i + 1 < size) {
result[i] = lst[i + 1];
result[i + 1] = lst[i];
} else {
result[i] = lst[i];
}
}
return result... | int main() {
int lst1[] = {0, 1, 2, 3, 4, 5};
int size1 = sizeof(lst1) / sizeof(lst1[0]);
int* result1 = func0(lst1, size1);
int expected1[] = {1, 0, 3, 2, 5, 4};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int lst2[] = {5, 6, 7, 8, 9, 10};
... | O2 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1481 <func0+0x51>
xor %edx,%edx
jmp 146b <func0+0x3b>
nopl 0x0(%rax)
mov 0x4(%rbp,%rdx,4),%ecx
mov %esi,0x4(%rax,%rdx,4)
mov %ecx,... | func0:
endbr64
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov rbx, rdi
shl rdi, 2
sub rsp, 8
call _malloc
test ebx, ebx
jle short loc_1481
xor edx, edx
jmp short loc_146B
loc_1458:
mov ecx, [rbp+rdx*4+4]
mov [rax+rdx*4+4], esi
mov [rax+rdx*4], ecx
add rdx, 2
... | long long func0(long long a1, int a2)
{
long long result; // rax
long long v4; // rdx
int v5; // ecx
int v6; // esi
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v4 = 0LL;
do
{
while ( 1 )
{
v6 = *(_DWORD *)(a1 + 4 * v4);
if ( (int)v4 + 1 >= a2 )
break;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
TEST EBX,EBX
JLE 0x00101481
XOR EDX,EDX
JMP 0x0010146b
LAB_00101458:
MOV ECX,dword ptr [RBP + RDX*0x4 + 0x4]
MOV dword ptr [RAX + RDX*0x4 + 0x4],ESI
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x2
CMP EBX,EDX
J... | void func0(long param_1,int param_2)
{
int4 uVar1;
int4 uVar2;
void *pvVar3;
long lVar4;
pvVar3 = malloc((long)param_2 << 2);
if (0 < param_2) {
lVar4 = 0;
do {
while (uVar2 = *(int4 *)(param_1 + lVar4 * 4), param_2 <= (int)lVar4 + 1) {
*(int4 *)((long)pvVar3 + lVar4 * 4) = uVar2;
... |
6,487 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int lst[], int size) {
int* result = malloc(size * sizeof(int));
int i;
for (i = 0; i < size; i += 2) {
if (i + 1 < size) {
result[i] = lst[i + 1];
result[i + 1] = lst[i];
} else {
result[i] = lst[i];
}
}
return result... | int main() {
int lst1[] = {0, 1, 2, 3, 4, 5};
int size1 = sizeof(lst1) / sizeof(lst1[0]);
int* result1 = func0(lst1, size1);
int expected1[] = {1, 0, 3, 2, 5, 4};
for (int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
}
int lst2[] = {5, 6, 7, 8, 9, 10};
... | O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1451 <func0+0x51>
xor %edx,%edx
jmp 143b <func0+0x3b>
nopl 0x0(%rax)
mov 0x4(%rbp,%rdx,4),%ecx
mov %esi,0x4(%rax,%rdx,4)
mov %ecx,... | func0:
endbr64
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov rbx, rdi
shl rdi, 2; size
sub rsp, 8
call _malloc
test ebx, ebx
jle short loc_13D9
xor edx, edx
jmp short loc_13BF
loc_13A8:
movd xmm1, dword ptr [rbp+rdx*4+4]
punpckldq xmm1, xmm0
movq qword ptr [rax+rdx*4]... | _DWORD * func0(long long a1, int a2)
{
_DWORD *result; // rax
long long v3; // rdx
__m128i v4; // xmm0
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v3 = 0LL;
do
{
while ( 1 )
{
v4 = _mm_cvtsi32_si128(*(_DWORD *)(a1 + 4 * v3));
if ( a2 <= (int)v3 + 1 )
break;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001013d9
XOR EDX,EDX
JMP 0x001013bf
LAB_001013a8:
MOVD XMM1,dword ptr [RBP + RDX*0x4 + 0x4]
PUNPCKLDQ XMM1,XMM0
MOVQ qword ptr [RAX + RDX*0x4],XMM1
ADD RDX,0x2
CMP EBX,EDX
JLE 0x001013d9
LA... | void func0(long param_1,int param_2)
{
int4 uVar1;
void *pvVar2;
long lVar3;
pvVar2 = malloc((long)param_2 << 2);
if (0 < param_2) {
lVar3 = 0;
do {
while (uVar1 = *(int4 *)(param_1 + lVar3 * 4), param_2 <= (int)lVar3 + 1) {
*(int4 *)((long)pvVar2 + lVar3 * 4) = uVar1;
lVar3 ... |
6,488 | func0 | #include <assert.h>
| int func0(int nums[], int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; i++) {
sum_range += nums[i];
}
return sum_range;
}
| int main() {
int arr1[] = {2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12};
assert(func0(arr1, 8, 10) == 29);
int arr2[] = {1, 2, 3, 4, 5};
assert(func0(arr2, 1, 2) == 5);
int arr3[] = {1, 0, 1, 2, 5, 6};
assert(func0(arr3, 4, 5) == 11);
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,-0x8(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 11a7 <func0+0x3e>
mov -0x4(%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_8], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp short loc_11A7
loc_118A:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add ra... | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
v4 = 0;
while ( a2 <= a3 )
v4 += *(_DWORD *)(4LL * a2++ + a1);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011a7
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qwo... | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = param_2; local_c <= param_3; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
6,489 | func0 | #include <assert.h>
| int func0(int nums[], int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; i++) {
sum_range += nums[i];
}
return sum_range;
}
| int main() {
int arr1[] = {2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12};
assert(func0(arr1, 8, 10) == 29);
int arr2[] = {1, 2, 3, 4, 5};
assert(func0(arr2, 1, 2) == 5);
int arr3[] = {1, 0, 1, 2, 5, 6};
assert(func0(arr3, 4, 5) == 11);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edx,%esi
jg 1195 <func0+0x2c>
movslq %esi,%rcx
lea (%rdi,%rcx,4),%rax
sub %esi,%edx
add %rcx,%rdx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1187 <func0+0x1e>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1192 <func0+0x29... | func0:
endbr64
cmp esi, edx
jg short loc_1195
movsxd rcx, esi
lea rax, [rdi+rcx*4]
sub edx, esi
add rdx, rcx
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1187:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1187
loc_1192:
mov eax, edx
retn
loc_1195:
mov edx, 0
jmp ... | long long func0(long long a1, int a2, int a3)
{
_DWORD *v3; // rax
unsigned long long v4; // rcx
unsigned int v5; // edx
if ( a2 > a3 )
{
return 0;
}
else
{
v3 = (_DWORD *)(a1 + 4LL * a2);
v4 = a1 + 4 * (a2 + (unsigned long long)(unsigned int)(a3 - a2)) + 4;
v5 = 0;
do
v5 += ... | func0:
ENDBR64
CMP ESI,EDX
JG 0x00101195
MOVSXD RCX,ESI
LEA RAX,[RDI + RCX*0x4]
SUB EDX,ESI
ADD RDX,RCX
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101187:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101187
LAB_00101192:
MOV EAX,EDX
RET
LAB_00101195:
MOV EDX,0x0
JMP 0x00101192 | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_3 < param_2) {
iVar2 = 0;
}
else {
piVar1 = (int *)(param_1 + (long)param_2 * 4);
iVar2 = 0;
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)(param_1 + 4 + ((ulo... |
6,490 | func0 | #include <assert.h>
| int func0(int nums[], int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; i++) {
sum_range += nums[i];
}
return sum_range;
}
| int main() {
int arr1[] = {2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12};
assert(func0(arr1, 8, 10) == 29);
int arr2[] = {1, 2, 3, 4, 5};
assert(func0(arr2, 1, 2) == 5);
int arr3[] = {1, 0, 1, 2, 5, 6};
assert(func0(arr3, 4, 5) == 11);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edx,%esi
jg 1170 <func0+0x30>
movslq %esi,%rcx
sub %esi,%edx
xor %r8d,%r8d
add %rcx,%rdx
lea (%rdi,%rcx,4),%rax
lea 0x4(%rdi,%rdx,4),%rdx
nopl 0x0(%rax)
add (%rax),%r8d
add $0x4,%rax
cmp %rdx,%rax
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov ... | func0:
endbr64
cmp esi, edx
jg short loc_1170
movsxd rcx, esi
sub edx, esi
xor r8d, r8d
add rdx, rcx
lea rax, [rdi+rcx*4]
lea rdx, [rdi+rdx*4+4]
nop dword ptr [rax+00h]
loc_1160:
add r8d, [rax]
add rax, 4
cmp rax, rdx
jnz short loc_1160
mov eax, r8d
retn
loc_1170:
x... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r8d
_DWORD *v4; // rax
unsigned long long v5; // rdx
if ( a2 > a3 )
return 0LL;
v3 = 0;
v4 = (_DWORD *)(a1 + 4LL * a2);
v5 = a1 + 4 * (a2 + (unsigned long long)(unsigned int)(a3 - a2)) + 4;
do
v3 += *v4++;
while ( v4 != (_DW... | func0:
ENDBR64
CMP ESI,EDX
JG 0x00101170
MOVSXD RCX,ESI
SUB EDX,ESI
XOR R8D,R8D
ADD RDX,RCX
LEA RAX,[RDI + RCX*0x4]
LEA RDX,[RDI + RDX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101160:
ADD R8D,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101160
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_2 <= param_3) {
iVar2 = 0;
piVar1 = (int *)(param_1 + (long)param_2 * 4);
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)(param_1 + 4 + ((ulong)(uint)(param_3 - param_2... |
6,491 | func0 | #include <assert.h>
| int func0(int nums[], int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; i++) {
sum_range += nums[i];
}
return sum_range;
}
| int main() {
int arr1[] = {2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12};
assert(func0(arr1, 8, 10) == 29);
int arr2[] = {1, 2, 3, 4, 5};
assert(func0(arr2, 1, 2) == 5);
int arr3[] = {1, 0, 1, 2, 5, 6};
assert(func0(arr3, 4, 5) == 11);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edx,%esi
jg 11f0 <func0+0xb0>
mov %edx,%eax
lea 0x1(%rdx),%r8d
sub %esi,%eax
sub %esi,%r8d
cmp $0x3,%eax
jbe 11f9 <func0+0xb9>
mov %r8d,%ecx
movslq %esi,%rax
pxor %xmm0,%xmm0
shr $0x2,%ecx
lea (%rdi,%rax,4),%rax
shl $0x4,%rcx
add %rax,%rcx
nopl 0x0(%rax,%r... | func0:
endbr64
mov ecx, esi
mov esi, edx
cmp ecx, edx
jg loc_11E0
mov eax, edx
sub eax, ecx
lea r8d, [rax+1]
cmp eax, 2
jbe loc_11E3
mov edx, r8d
movsxd rax, ecx
pxor xmm0, xmm0
shr edx, 2
lea rax, [rdi+rax*4]
shl rdx, 4
add rdx, rax
nop dword ptr [rax+00... | long long func0(long long a1, int a2, int a3)
{
unsigned int v5; // r8d
__m128i v6; // xmm0
const __m128i *v7; // rax
const __m128i *v8; // rdx
__m128i v9; // xmm2
__m128i v10; // xmm0
long long result; // rax
long long v12; // r8
if ( a2 > a3 )
return 0LL;
v5 = a3 - a2 + 1;
if ( (unsigned i... | func0:
ENDBR64
MOV ECX,ESI
MOV ESI,EDX
CMP ECX,EDX
JG 0x001011e0
MOV EAX,EDX
SUB EAX,ECX
LEA R8D,[RAX + 0x1]
CMP EAX,0x2
JBE 0x001011e3
MOV EDX,R8D
MOVSXD RAX,ECX
PXOR XMM0,XMM0
SHR EDX,0x2
LEA RAX,[RDI + RAX*0x4]
SHL RDX,0x4
ADD RDX,RAX
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD... | int func0(long param_1,int param_2,int param_3)
{
uint uVar1;
long lVar2;
int iVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if (param_3 < param_2) {
iVar9 = 0;
}
else {
uVar1 = (param_3 - param_2) + 1;
... |
6,492 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr1[], int arr2[], int n, int m) {
if (n != m) {
return false;
}
// Bubble sort arr1
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr1[j] > arr1[j + 1]) {
int temp = arr1[j];
arr1[j] = a... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {3, 2, 1};
int arr3[] = {1, 1, 1};
int arr4[] = {2, 2, 2};
int arr5[] = {8, 9};
int arr6[] = {4, 5, 6};
assert(func0(arr1, arr2, 3, 3) == true);
assert(func0(arr3, arr4, 3, 3) == false);
assert(func0(arr5, arr6, 2, 3) == fa... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %ecx,-0x38(%rbp)
mov -0x34(%rbp),%eax
cmp -0x38(%rbp),%eax
je 1191 <func0+0x28>
mov $0x0,%eax
jmpq 139a <func0+0x231>
movl $0x0,-0x1c(%rbp)
jmpq 125e <func0+0xf5>
movl $0x0,-0x... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_38], ecx
mov eax, [rbp+var_34]
cmp eax, [rbp+var_38]
jz short loc_1191
mov eax, 0
jmp loc_139A
loc_1191:
mov [rbp+var_1C], 0
jmp loc_125E
loc_119D:
mov ... | long long func0(long long a1, long long a2, int a3, int a4)
{
int i; // [rsp+1Ch] [rbp-1Ch]
int j; // [rsp+20h] [rbp-18h]
int k; // [rsp+24h] [rbp-14h]
int m; // [rsp+28h] [rbp-10h]
int n; // [rsp+2Ch] [rbp-Ch]
int v10; // [rsp+30h] [rbp-8h]
int v11; // [rsp+34h] [rbp-4h]
if ( a3 != a4 )
return 0L... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV dword ptr [RBP + -0x38],ECX
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x38]
JZ 0x00101191
MOV EAX,0x0
JMP 0x0010139a
LAB_00101191:
MOV dword ptr [RBP + -0x1c],0x0
JMP 0... | int8 func0(long param_1,long param_2,int param_3,int param_4)
{
int4 uVar1;
int8 uVar2;
int local_24;
int local_20;
int local_1c;
int local_18;
int local_14;
if (param_3 == param_4) {
for (local_24 = 0; local_24 < param_3 + -1; local_24 = local_24 + 1) {
for (local_20 = 0; local_20 < (para... |
6,493 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr1[], int arr2[], int n, int m) {
if (n != m) {
return false;
}
// Bubble sort arr1
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr1[j] > arr1[j + 1]) {
int temp = arr1[j];
arr1[j] = a... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {3, 2, 1};
int arr3[] = {1, 1, 1};
int arr4[] = {2, 2, 2};
int arr5[] = {8, 9};
int arr6[] = {4, 5, 6};
assert(func0(arr1, arr2, 3, 3) == true);
assert(func0(arr3, arr4, 3, 3) == false);
assert(func0(arr5, arr6, 2, 3) == fa... | O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %ecx,%edx
jne 1235 <func0+0xcc>
push %rbx
lea -0x1(%rdx),%eax
mov %eax,%r10d
mov %eax,%r11d
lea 0x4(%rdi),%rbx
test %eax,%eax
jg 11c0 <func0+0x57>
test %edx,%edx
jle 1227 <func0+0xbe>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
jmp 120f <func0+0xa6>
add ... | func0:
endbr64
mov eax, 0
cmp edx, ecx
jnz locret_1238
push rbx
mov r9, rdi
mov r10, rsi
mov r11d, edx
lea eax, [rdx-1]
mov edi, eax
mov r8d, eax
lea rbx, [r9+4]
test eax, eax
jg short loc_11C7
loc_1194:
test r11d, r11d
jle loc_122A
lea ecx, [r11-1]
mov ... | long long func0(int *a1, int *a2, int a3, int a4)
{
long long result; // rax
int v7; // edi
int v8; // r8d
long long i; // rax
int *v10; // rax
int v11; // edx
int v12; // ecx
int *v13; // rax
int v14; // edx
int v15; // ecx
result = 0LL;
if ( a3 == a4 )
{
v7 = a3 - 1;
v8 = a3 - 1;
... | func0:
ENDBR64
MOV EAX,0x0
CMP EDX,ECX
JNZ 0x00101238
PUSH RBX
MOV R9,RDI
MOV R10,RSI
MOV R11D,EDX
LEA EAX,[RDX + -0x1]
MOV EDI,EAX
MOV R8D,EAX
LEA RBX,[R9 + 0x4]
TEST EAX,EAX
JG 0x001011c7
LAB_00101194:
TEST R11D,R11D
JLE 0x0010122a
LEA ECX,[R11 + -0x1]
MOV EAX,0x0
JMP 0x00101210
LAB_001011a8:
ADD RAX,0x4
CMP RAX,RSI
... | int8 func0(int *param_1,int *param_2,int param_3,int param_4)
{
int iVar1;
int *piVar2;
ulong uVar3;
int iVar4;
int iVar5;
bool bVar6;
if (param_3 != param_4) {
return 0;
}
iVar4 = param_3 + -1;
iVar5 = iVar4;
if (0 < iVar4) {
do {
if (0 < iVar5) {
piVar2 = param_1;
... |
6,494 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr1[], int arr2[], int n, int m) {
if (n != m) {
return false;
}
// Bubble sort arr1
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr1[j] > arr1[j + 1]) {
int temp = arr1[j];
arr1[j] = a... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {3, 2, 1};
int arr3[] = {1, 1, 1};
int arr4[] = {2, 2, 2};
int arr5[] = {8, 9};
int arr6[] = {4, 5, 6};
assert(func0(arr1, arr2, 3, 3) == true);
assert(func0(arr3, arr4, 3, 3) == false);
assert(func0(arr5, arr6, 2, 3) == fa... | O2 | c | func0:
endbr64
cmp %ecx,%edx
jne 1370 <func0+0x10>
jmpq 1270 <func0.part.0>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
movsxd r11, edx
mov r9, rdi
push rbx
mov r10, rsi
lea edi, [r11-1]
lea rbx, [r9+4]
mov edx, edi
test edi, edi
jle short loc_12F3
nop dword ptr [rax+rax+00000000h]
loc_1290:
sub edx, 1
mov rax, r9
mov r8, rdx
lea rsi, [rbx+rdx*4]
nop dword ptr [rax]
lo... | long long func0_part_0(unsigned long long a1, int *a2, int a3)
{
long long v3; // r11
int *v4; // r9
int v6; // edx
int *v7; // rax
int v8; // r8d
long long v9; // rsi
int v10; // edx
int v11; // ecx
int *v12; // rax
int v13; // edx
int v14; // ecx
long long v15; // rax
v3 = a3;
v4 = (int ... | func0.part.0:
MOVSXD R11,EDX
MOV R9,RDI
PUSH RBX
MOV R10,RSI
LEA EDI,[R11 + -0x1]
LEA RBX,[R9 + 0x4]
MOV EDX,EDI
TEST EDI,EDI
JLE 0x001012f3
NOP dword ptr [RAX + RAX*0x1]
LAB_00101290:
SUB EDX,0x1
MOV RAX,R9
MOV R8,RDX
LEA RSI,[RBX + RDX*0x4]
NOP dword ptr [RAX]
LAB_001012a0:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [... | int8 func0_part_0(int *param_1,int *param_2,int param_3)
{
int iVar1;
int *piVar2;
long lVar3;
uint uVar4;
ulong uVar6;
ulong uVar5;
uVar6 = (ulong)(param_3 - 1U);
uVar5 = uVar6;
if (0 < (int)(param_3 - 1U)) {
do {
uVar4 = (int)uVar5 - 1;
piVar2 = param_1;
do {
iVar1 ... |
6,495 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int arr1[], int arr2[], int n, int m) {
if (n != m) {
return false;
}
// Bubble sort arr1
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr1[j] > arr1[j + 1]) {
int temp = arr1[j];
arr1[j] = a... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {3, 2, 1};
int arr3[] = {1, 1, 1};
int arr4[] = {2, 2, 2};
int arr5[] = {8, 9};
int arr6[] = {4, 5, 6};
assert(func0(arr1, arr2, 3, 3) == true);
assert(func0(arr3, arr4, 3, 3) == false);
assert(func0(arr5, arr6, 2, 3) == fa... | O3 | c | func0:
endbr64
cmp %ecx,%edx
jne 1370 <func0+0x10>
jmpq 1270 <func0.part.0>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
cmp edx, ecx
jz short loc_12E0
xor eax, eax
retn
loc_12E0:
push rbx
mov r8, rsi
mov r10d, edx
mov r9d, edx
mov r11d, edx
lea rbx, [rdi+4]
cmp edx, 1
jle loc_13D6
nop word ptr [rax+rax+00h]
loc_1300:
lea edx, [r11-2]
mov rax, rdi
lea rsi, [rbx+rd... | long long func0(__m128i *a1, __m128i *a2, int a3, int a4)
{
int v5; // r9d
int v6; // r11d
__m128i *v7; // rax
__m128i v8; // xmm0
__m128i *v9; // rax
__m128i v10; // xmm0
unsigned long long v11; // rax
long long v12; // rdx
if ( a3 != a4 )
return 0LL;
v5 = a3;
v6 = a3;
if ( a3 <= 1 )
{
... | func0:
ENDBR64
CMP EDX,ECX
JZ 0x001012e0
XOR EAX,EAX
RET
LAB_001012e0:
PUSH RBX
MOV R8,RSI
MOV R10D,EDX
MOV R9D,EDX
MOV R11D,EDX
LEA RBX,[RDI + 0x4]
CMP EDX,0x1
JLE 0x001013d6
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
LEA EDX,[R11 + -0x2]
MOV RAX,RDI
LEA RSI,[RBX + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101310:
... | int8 func0(int8 *param_1,int8 *param_2,int param_3,int param_4)
{
int8 *puVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_3 != param_4) {
return 0;
}
iVar4 = param_3;
if (param_3 < 2) {
if (param_3 != 1) {
return 1;
}
}
else {
while( true ) {
puVar1 = p... |
6,496 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int n1, int test_tup2[], int n2) {
for (int i = 0; i < n2; i++) {
bool found = false;
for (int j = 0; j < n1; j++) {
if (test_tup2[i] == test_tup1[j]) {
found = true;
break;
}
}
if (!found) {... | int main() {
int set1[] = {10, 4, 5, 6};
int subset1[] = {5, 10};
assert(func0(set1, 4, subset1, 2) == true);
int set2[] = {1, 2, 3, 4};
int subset2[] = {5, 6};
assert(func0(set2, 4, subset2, 2) == false);
int set3[] = {7, 8, 9, 10};
int subset3[] = {10, 8};
assert(func0... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11ed <func0+0x84>
movb $0x0,-0x9(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11cf <func0+0x66>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_8], 0
jmp short loc_11ED
loc_1188:
mov [rbp+var_9], 0
mov [rbp+var_4], 0
jmp short loc_11CF
loc_1195:
mov eax, [rbp+var_8]
cdqe
lea ... | long long func0(long long a1, int a2, long long a3, int a4)
{
char v5; // [rsp+1Fh] [rbp-9h]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a4; ++i )
{
v5 = 0;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a3) == *(_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 dword ptr [RBP + -0x8],0x0
JMP 0x001011ed
LAB_00101188:
MOV byte ptr [RBP + -0x9],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cf
LAB_00101195:
MOV EA... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
bool bVar1;
int local_10;
int local_c;
local_10 = 0;
do {
if (param_4 <= local_10) {
return 1;
}
bVar1 = false;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_3 + (long)local_10 * ... |
6,497 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int n1, int test_tup2[], int n2) {
for (int i = 0; i < n2; i++) {
bool found = false;
for (int j = 0; j < n1; j++) {
if (test_tup2[i] == test_tup1[j]) {
found = true;
break;
}
}
if (!found) {... | int main() {
int set1[] = {10, 4, 5, 6};
int subset1[] = {5, 10};
assert(func0(set1, 4, subset1, 2) == true);
int set2[] = {1, 2, 3, 4};
int subset2[] = {5, 6};
assert(func0(set2, 4, subset2, 2) == false);
int set3[] = {7, 8, 9, 10};
int subset3[] = {10, 8};
assert(func0... | O1 | c | func0:
endbr64
test %ecx,%ecx
jle 1189 <func0+0x20>
mov %rdx,%r8
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r10
mov %rdi,%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
jmp 119e <func0+0x35>
mov $0x1,%eax
retq
mov $0x0,%eax
retq
add $0x4,%r8
cmp %r10,%r8
je 11bb <func0+0x52>
t... | func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1189
mov rdi, rdx
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rcx, [r8+rax*4+4]
jmp short loc_119E
loc_1189:
mov eax, 1
retn
loc_118F:
mov eax, 0
retn
loc_1195:
add rdi, 4
cmp rdi, r9
jz short ... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 1LL;
v5 = a3;
while ( 2 )
{
if ( a2 <= 0 )
return 0LL;
v7 = a1;
while ( *v5 != *v7 )
{
if ( ++v7 == &a1[a2 - 1 + 1] )
return 0LL;
}
if ( ++v... | ||
6,498 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int n1, int test_tup2[], int n2) {
for (int i = 0; i < n2; i++) {
bool found = false;
for (int j = 0; j < n1; j++) {
if (test_tup2[i] == test_tup1[j]) {
found = true;
break;
}
}
if (!found) {... | int main() {
int set1[] = {10, 4, 5, 6};
int subset1[] = {5, 10};
assert(func0(set1, 4, subset1, 2) == true);
int set2[] = {1, 2, 3, 4};
int subset2[] = {5, 6};
assert(func0(set2, 4, subset2, 2) == false);
int set3[] = {7, 8, 9, 10};
int subset3[] = {10, 8};
assert(func0... | O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1186 <func0+0x46>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1190 <func0+0x50>
mov (%r8),%edx
mov %rdi,%rax
jmp 1179 <func0+0x39>
nopl 0x0(%rax)
a... | func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1326
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_1300:
test esi, esi
jle short loc_1330
mov ecx, [rdx]
mov rax, r8
jmp short loc_1319
loc_1310:
add ... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
long long v5; // r9
long long v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 1LL;
v5 = (long long)&a3[a4 - 1 + 1];
v6 = (long long)&a1[a2 - 1 + 1];
while ( a2 > 0 )
{
v7 = a1;
while ( *a3 != *v7 )
{
if ( ++v7 == (_DWO... | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101326
LEA EAX,[RCX + -0x1]
LEA R9,[RDX + RAX*0x4 + 0x4]
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101300:
TEST ESI,ESI
JLE 0x00101330
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x00101319
LAB_00101310:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
if (param_2 < 1) {
return 0;
}
piVar2 = param_1;
while (*param_3 != *piVar2) {
piVar2 = piVar2 + 1;
... |
6,499 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int n1, int test_tup2[], int n2) {
for (int i = 0; i < n2; i++) {
bool found = false;
for (int j = 0; j < n1; j++) {
if (test_tup2[i] == test_tup1[j]) {
found = true;
break;
}
}
if (!found) {... | int main() {
int set1[] = {10, 4, 5, 6};
int subset1[] = {5, 10};
assert(func0(set1, 4, subset1, 2) == true);
int set2[] = {1, 2, 3, 4};
int subset2[] = {5, 6};
assert(func0(set2, 4, subset2, 2) == false);
int set3[] = {7, 8, 9, 10};
int subset3[] = {10, 8};
assert(func0... | O3 | c | func0:
endbr64
test %ecx,%ecx
jle 1186 <func0+0x46>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1190 <func0+0x50>
mov (%r8),%edx
mov %rdi,%rax
jmp 1179 <func0+0x39>
nopl 0x0(%rax)
a... | func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1186
movsxd rcx, ecx
movsxd rax, esi
lea r9, [rdx+rcx*4]
lea rdi, [rdi+rax*4]
test esi, esi
jle short loc_1190
nop dword ptr [rax]
loc_1160:
mov ecx, [rdx]
mov rax, r8
jmp short loc_1179
loc_1170:
add rax, 4
cmp r... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // r9
_DWORD *v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 1LL;
v5 = &a3[a4];
v6 = &a1[a2];
if ( a2 > 0 )
{
do
{
v7 = a1;
while ( *a3 != *v7 )
{
if ( v6 == ++v7 )
return 0LL;
... | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101186
MOVSXD RCX,ECX
MOVSXD RAX,ESI
LEA R9,[RDX + RCX*0x4]
LEA RDI,[RDI + RAX*0x4]
TEST ESI,ESI
JLE 0x00101190
NOP dword ptr [RAX]
LAB_00101160:
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x00101179
LAB_00101170:
ADD RAX,0x4
CMP RDI,RAX
JZ 0x00101190
LAB_00101179:
CMP ECX,dwo... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + param_4;
if (param_2 < 1) {
return 0;
}
do {
piVar2 = param_1;
while (*param_3 != *piVar2) {
piVar2 = piVar2 + 1;
if (param_1 + para... |
6,500 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int test_list[3][2][2], int rows, int cols, int pairs) {
static char res[100];
int flat_list[6][2];
int f = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
flat_list[f][0] = test_list[i][j][0];
flat_list[f][1] = test_list[i][j][1];
... | int main() {
int test1[3][2][2] = {{{4, 5}, {7, 8}}, {{10, 13}, {18, 17}}, {{0, 4}, {10, 1}}};
int test2[3][2][2] = {{{5, 6}, {8, 9}}, {{11, 14}, {19, 18}}, {{1, 5}, {11, 2}}};
int test3[3][2][2] = {{{6, 7}, {9, 10}}, {{12, 15}, {20, 21}}, {{23, 7}, {15, 8}}};
assert(strcmp(func0(test1, 3, 2, 2), ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x100,%rsp
mov %rdi,-0xe8(%rbp)
mov %esi,-0xec(%rbp)
mov %edx,-0xf0(%rbp)
mov %ecx,-0xf4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0xe0(%rbp)
movl $0x0,-0xdc(%rbp)
jmpq 12d3 <func0+0xea>
movl $0x0,-0xd8(%rbp)
jmp... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 100h
mov [rbp+var_E8], rdi
mov [rbp+var_EC], esi
mov [rbp+var_F0], edx
mov [rbp+var_F4], ecx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_E0], 0
mov [rbp+var_DC], 0
jmp loc_12F3
loc_1259:
mov [rbp+var_... | char * func0(long long a1, int a2, int a3)
{
int v4; // [rsp+20h] [rbp-E0h]
int i; // [rsp+24h] [rbp-DCh]
int j; // [rsp+28h] [rbp-D8h]
int k; // [rsp+2Ch] [rbp-D4h]
_DWORD v8[15]; // [rsp+30h] [rbp-D0h]
char s[10]; // [rsp+6Ch] [rbp-94h] BYREF
char src[10]; // [rsp+76h] [rbp-8Ah] BYREF
char dest[8]; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
MOV qword ptr [RBP + -0xe8],RDI
MOV dword ptr [RBP + -0xec],ESI
MOV dword ptr [RBP + -0xf0],EDX
MOV dword ptr [RBP + -0xf4],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xe0],0x0
MOV dword ptr [RBP + -0xdc],0x0
JMP 0x0... | int1 * func0(long param_1,int param_2,int param_3)
{
size_t sVar1;
long in_FS_OFFSET;
int local_e8;
int local_e4;
int local_e0;
int local_dc;
uint auStack_d8 [15];
char local_9c [10];
char local_92 [10];
char local_88 [64];
char local_48 [56];
long local_10;
local_10 = *(long *)(in_FS_OFFS... |
6,501 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int test_list[3][2][2], int rows, int cols, int pairs) {
static char res[100];
int flat_list[6][2];
int f = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
flat_list[f][0] = test_list[i][j][0];
flat_list[f][1] = test_list[i][j][1];
... | int main() {
int test1[3][2][2] = {{{4, 5}, {7, 8}}, {{10, 13}, {18, 17}}, {{0, 4}, {10, 1}}};
int test2[3][2][2] = {{{5, 6}, {8, 9}}, {{11, 14}, {19, 18}}, {{1, 5}, {11, 2}}};
int test3[3][2][2] = {{{6, 7}, {9, 10}}, {{12, 15}, {20, 21}}, {{23, 7}, {15, 8}}};
assert(strcmp(func0(test1, 3, 2, 2), ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xd8,%rsp
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
test %esi,%esi
jle 1248 <func0+0x7f>
mov %rdi,%r8
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%r10
mov $0x0,%r9d
mov %r... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0E8h
mov rax, fs:28h
mov [rsp+118h+var_40], rax
xor eax, eax
test esi, esi
jle short loc_126E
mov r8d, edx
mov r9, rdi
lea eax, [rsi-1]
shl rax, 4
lea r10, [rdi+rax+10h]
mov edi... | void * func0(long long a1, int a2, int a3)
{
long long v4; // r9
long long v5; // r10
int v6; // edi
_DWORD *v7; // rdx
long long v8; // rax
char *v9; // rbx
_DWORD v11[10]; // [rsp+10h] [rbp-108h] BYREF
char v12; // [rsp+38h] [rbp-E0h] BYREF
_BYTE v13[10]; // [rsp+4Ch] [rbp-CCh] BYREF
_BYTE v14[10]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xe8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x0010126e
MOV R8D,EDX
MOV R9,RDI
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA R10,[RDI + RAX*0x1 + 0x10]
MOV EDI,0x0
LEA R11,[RSP + 0x10]
JMP 0x00101267
LAB_... | int1 * func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
int4 *puVar3;
int iVar4;
long in_FS_OFFSET;
int4 local_108 [10];
int4 local_e0 [5];
int1 local_cc [10];
int1 local_c2 [10];
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_90... |
6,502 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int test_list[3][2][2], int rows, int cols, int pairs) {
static char res[100];
int flat_list[6][2];
int f = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
flat_list[f][0] = test_list[i][j][0];
flat_list[f][1] = test_list[i][j][1];
... | int main() {
int test1[3][2][2] = {{{4, 5}, {7, 8}}, {{10, 13}, {18, 17}}, {{0, 4}, {10, 1}}};
int test2[3][2][2] = {{{5, 6}, {8, 9}}, {{11, 14}, {19, 18}}, {{1, 5}, {11, 2}}};
int test3[3][2][2] = {{{6, 7}, {9, 10}}, {{12, 15}, {20, 21}}, {{23, 7}, {15, 8}}};
assert(strcmp(func0(test1, 3, 2, 2), ... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xe8,%rsp
mov %fs:0x28,%rax
mov %rax,0xd8(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rbx
test %esi,%esi
jle 14aa <func0+0x7a>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x10(%rsp),%rbx
shl $0x4,%rax
lea 0x... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0E8h
mov rax, fs:28h
mov [rsp+118h+var_40], rax
xor eax, eax
lea rbx, [rsp+118h+var_108]
test esi, esi
jle short loc_14FA
lea eax, [rsi-1]
xor r8d, r8d
lea rbx, [rsp+118h+var_108]
shl ... | void * func0(long long a1, int a2, int a3)
{
char *v3; // rbx
int v4; // r8d
long long v5; // r9
_DWORD *v6; // rcx
long long v7; // rax
int v8; // esi
long long v9; // rax
long long v10; // rax
_DWORD v12[10]; // [rsp+10h] [rbp-108h] BYREF
char v13; // [rsp+38h] [rbp-E0h] BYREF
_BYTE v14[10]; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xe8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
XOR EAX,EAX
LEA RBX,[RSP + 0x10]
TEST ESI,ESI
JLE 0x001014fa
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RBX,[RSP + 0x10]
SHL RAX,0x4
LEA R9,[RDI + RAX*0x1 + 0x10]
NOP dword ptr [RAX]
LA... | int1 * func0(long param_1,int param_2,int param_3)
{
long lVar1;
long lVar2;
long lVar3;
size_t sVar4;
int4 *puVar5;
int4 *puVar6;
int iVar7;
long in_FS_OFFSET;
int4 local_108 [10];
int4 local_e0 [5];
int1 local_cc [10];
int1 local_c2 [10];
int1 local_b8 [16];
int1 local_a8 [16];
int1 loc... |
6,503 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int test_list[3][2][2], int rows, int cols, int pairs) {
static char res[100];
int flat_list[6][2];
int f = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
flat_list[f][0] = test_list[i][j][0];
flat_list[f][1] = test_list[i][j][1];
... | int main() {
int test1[3][2][2] = {{{4, 5}, {7, 8}}, {{10, 13}, {18, 17}}, {{0, 4}, {10, 1}}};
int test2[3][2][2] = {{{5, 6}, {8, 9}}, {{11, 14}, {19, 18}}, {{1, 5}, {11, 2}}};
int test3[3][2][2] = {{{6, 7}, {9, 10}}, {{12, 15}, {20, 21}}, {{23, 7}, {15, 8}}};
assert(strcmp(func0(test1, 3, 2, 2), ... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xe8,%rsp
mov %fs:0x28,%rax
mov %rax,0xd8(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rbx
test %esi,%esi
jle 1446 <func0+0xb6>
test %edx,%edx
jle 1446 <func0+0xb6>
lea -0x1(%rsi),%eax
mov %edx,%r10d
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0F8h
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
lea rbx, [rsp+128h+var_108]
test esi, esi
jle loc_14B0
mov ecx, edx
lea rbx, [rsp+128h+var_108]
test edx, edx
jle loc_14B... | void * func0(long long a1, int a2, int a3)
{
char *v3; // rbx
long long v5; // rax
long long v6; // r9
unsigned int v7; // r11d
unsigned int v8; // r10d
int v9; // r8d
long long v10; // rsi
long long v11; // rbp
long long v12; // rdx
__m128i *v13; // rsi
long long v14; // r8
size_t v15; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xf8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
LEA RBX,[RSP + 0x20]
TEST ESI,ESI
JLE 0x001014b0
MOV ECX,EDX
LEA RBX,[RSP + 0x20]
TEST EDX,EDX
JLE 0x001014b0
MOVSXD RSI,ESI
MOV R11D,EDX
MOV R10D,EDX
XOR EAX,EAX
LEA ... | int1 * func0(long param_1,int param_2,ulong param_3)
{
long lVar1;
int8 uVar2;
long lVar3;
size_t sVar4;
uint uVar5;
long lVar6;
int8 *puVar7;
ulong uVar8;
int iVar9;
uint uVar10;
long in_FS_OFFSET;
int8 local_108;
int8 auStack_100 [5];
int8 local_d8;
int local_cc [10];
int local_c2 [10... |
6,504 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct List {
int *values;
int size;
int capacity;
} List;
typedef struct Map {
char **keys;
List *values;
int size;
int capacity;
} Map;
void initList(List *list) {
list->value... | Map func0(const char *input[], int length) {
Map map;
initMap(&map);
for (int i = 0; i < length; i += 2) {
addToMap(&map, (char*)input[i], atoi(input[i + 1]));
}
return map;
}
| int main() {
const char *data1[] = {"yellow", "1", "blue", "2", "yellow", "3", "blue", "4", "red", "1"};
const char *data2[] = {"yellow", "10", "blue", "20", "yellow", "30", "blue", "40", "red", "10"};
const char *data3[] = {"yellow", "15", "blue", "25", "yellow", "35", "blue", "45", "red", "15"};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 12d0 <initMap>
movl $0x0,-0x24(%rbp)
jmp 1568 <func0+0x8a>
mov -0x24(... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+var_20]
mov rdi, rax
call initMap
mov [rbp+var_24], 0
jmp short loc_1567
loc_1518:
mov... | _QWORD * func0(_QWORD *a1, long long a2, int a3)
{
unsigned int v3; // eax
long long v4; // rdx
int i; // [rsp+2Ch] [rbp-24h]
_QWORD v8[4]; // [rsp+30h] [rbp-20h] BYREF
v8[3] = __readfsqword(0x28u);
initMap(v8);
for ( i = 0; i < a3; i += 2 )
{
v3 = atoi(*(const char **)(8 * (i + 1LL) + a2));
ad... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x001012d0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101567
LAB_001... | int8 * func0(int8 *param_1,long param_2,int param_3)
{
int iVar1;
long in_FS_OFFSET;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
initMap(&local_28);
for (local_2c = 0; local_2c < param_3; local_2c = local_2c + 2) {
iVar... |
6,505 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct List {
int *values;
int size;
int capacity;
} List;
typedef struct Map {
char **keys;
List *values;
int size;
int capacity;
} Map;
void initList(List *list) {
list->value... | Map func0(const char *input[], int length) {
Map map;
initMap(&map);
for (int i = 0; i < length; i += 2) {
addToMap(&map, (char*)input[i], atoi(input[i + 1]));
}
return map;
}
| int main() {
const char *data1[] = {"yellow", "1", "blue", "2", "yellow", "3", "blue", "4", "red", "1"};
const char *data2[] = {"yellow", "10", "blue", "20", "yellow", "30", "blue", "40", "red", "10"};
const char *data3[] = {"yellow", "15", "blue", "25", "yellow", "35", "blue", "45", "red", "15"};
... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %rsi,%r13
mov %edx,%ebp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rdi
callq 1276 <initMap>
test %ebp,%ebp
jle 1439 <func0+0x72>
mov %r13,%rbx
sub $0x1,%ebp
shr %ebp
... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r12, rdi
mov r13, rsi
mov ebp, edx
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov rdi, rsp
call initMap
test ebp, ebp
jle short loc_142C
mov rbx, r13
sub ebp, 1
shr ebp, 1
mo... | __m128i * func0(__m128i *a1, _QWORD *a2, int a3)
{
_QWORD *v4; // rbx
unsigned int v5; // eax
__m128i v7; // [rsp+0h] [rbp-48h] BYREF
long long v8; // [rsp+10h] [rbp-38h]
unsigned long long v9; // [rsp+18h] [rbp-30h]
v9 = __readfsqword(0x28u);
initMap(&v7);
if ( a3 > 0 )
{
v4 = a2;
do
{
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R12,RDI
MOV R13,RSI
MOV EBP,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RDI,RSP
CALL 0x00101276
TEST EBP,EBP
JLE 0x0010142c
MOV RBX,R13
SUB EBP,0x1
SHR EBP,0x1
MOV EBP,EBP
SHL RBP,0x4
LEA R13,[R13 + RBP*0x1 + 0x10]
MO... | int8 * func0(int8 *param_1,int8 *param_2,int param_3)
{
int8 *puVar1;
ulong uVar2;
long in_FS_OFFSET;
int8 local_48;
int8 uStack_40;
int8 local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
initMap(&local_48);
if (0 < param_3) {
puVar1 = param_2 + (ulong)(param_3 - 1U >> 1) *... |
6,506 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct List {
int *values;
int size;
int capacity;
} List;
typedef struct Map {
char **keys;
List *values;
int size;
int capacity;
} Map;
void initList(List *list) {
list->value... | Map func0(const char *input[], int length) {
Map map;
initMap(&map);
for (int i = 0; i < length; i += 2) {
addToMap(&map, (char*)input[i], atoi(input[i + 1]));
}
return map;
}
| int main() {
const char *data1[] = {"yellow", "1", "blue", "2", "yellow", "3", "blue", "4", "red", "1"};
const char *data2[] = {"yellow", "10", "blue", "20", "yellow", "30", "blue", "40", "red", "10"};
const char *data3[] = {"yellow", "15", "blue", "25", "yellow", "35", "blue", "45", "red", "15"};
... | O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
push %r12
mov %edx,%r12d
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 14e0 <initMap>
test %r12d,%r12d
jle 16e8 <func0+0x78>
sub $0x1,%r12d
shr %... | func0:
endbr64
push r13
mov r13, rdi
mov edi, 50h ; 'P'
push r12
push rbp
mov ebp, edx
push rbx
mov rbx, rsi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
call _malloc
mov edi, 0A0h
mov qword ptr [rsp+48h+var_48], rax
call _malloc
mov q... | __m128i * func0(__m128i *a1, long long a2, int a3)
{
long long v5; // rbx
long long v6; // rdi
unsigned int v7; // eax
__m128i v8; // xmm0
__m128i v10; // [rsp+0h] [rbp-48h] BYREF
long long v11; // [rsp+10h] [rbp-38h]
unsigned long long v12; // [rsp+18h] [rbp-30h]
v5 = a2;
v12 = __readfsqword(0x28u);... | func0:
ENDBR64
PUSH R13
MOV R13,RDI
MOV EDI,0x50
PUSH R12
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV EDI,0xa0
MOV qword ptr [RSP],RAX
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,0xa00000000
MOV qword ptr [RS... | int8 * func0(int8 *param_1,int8 *param_2,int param_3)
{
ulong uVar1;
int8 *puVar2;
int8 *puVar3;
long in_FS_OFFSET;
void *local_48;
void *pvStack_40;
int8 local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = malloc(0x50);
pvStack_40 = malloc(0xa0);
local_38 = 0xa000... |
6,507 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct List {
int *values;
int size;
int capacity;
} List;
typedef struct Map {
char **keys;
List *values;
int size;
int capacity;
} Map;
void initList(List *list) {
list->value... | Map func0(const char *input[], int length) {
Map map;
initMap(&map);
for (int i = 0; i < length; i += 2) {
addToMap(&map, (char*)input[i], atoi(input[i + 1]));
}
return map;
}
| int main() {
const char *data1[] = {"yellow", "1", "blue", "2", "yellow", "3", "blue", "4", "red", "1"};
const char *data2[] = {"yellow", "10", "blue", "20", "yellow", "30", "blue", "40", "red", "10"};
const char *data3[] = {"yellow", "15", "blue", "25", "yellow", "35", "blue", "45", "red", "15"};
... | O3 | c | func0:
endbr64
push %r13
mov %rdi,%r13
mov $0x50,%edi
push %r12
push %rbp
mov %edx,%ebp
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10f0 <malloc@plt>
mov $0xa0,%edi
mov %rax,(%rsp)
callq 10f0 <malloc@plt>
mov %rax,0x8(%rsp)
... | func0:
endbr64
push r13
push r12
mov r12, rdi
mov edi, 50h ; 'P'; size
push rbp
mov ebp, edx
push rbx
mov rbx, rsi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
call _malloc
mov edi, 0A0h; size
mov qword ptr [rsp+48h+var_48], rax
call _mall... | __m128i * func0(__m128i *a1, long long a2, int a3)
{
long long v5; // rbx
const char *v6; // rdi
unsigned int v7; // eax
__m128i v8; // xmm0
__m128i v10; // [rsp+0h] [rbp-48h] BYREF
long long v11; // [rsp+10h] [rbp-38h]
unsigned long long v12; // [rsp+18h] [rbp-30h]
v5 = a2;
v12 = __readfsqword(0x28u... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
MOV EDI,0x50
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV EDI,0xa0
MOV qword ptr [RSP],RAX
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [0x00102090]
MOV qw... | int8 * func0(int8 *param_1,int8 *param_2,int param_3)
{
ulong uVar1;
int8 *puVar2;
int8 *puVar3;
long in_FS_OFFSET;
void *local_48;
void *pvStack_40;
int8 local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = malloc(0x50);
pvStack_40 = malloc(0xa0);
local_38 = DAT_00... |
6,508 | func0 |
#include <assert.h>
| int func0(int l, int b) {
int perimeter = 2 * (l + b);
return perimeter;
}
| int main() {
assert(func0(10, 20) == 60);
assert(func0(10, 5) == 30);
assert(func0(4, 2) == 12);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
add %eax,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add eax, edx
add eax, eax
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
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 + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
ADD EAX,EAX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2)
{
return (param_2 + param_1) * 2;
} |
6,509 | func0 |
#include <assert.h>
| int func0(int l, int b) {
int perimeter = 2 * (l + b);
return perimeter;
}
| int main() {
assert(func0(10, 20) == 60);
assert(func0(10, 5) == 30);
assert(func0(4, 2) == 12);
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;
} |
6,510 | func0 |
#include <assert.h>
| int func0(int l, int b) {
int perimeter = 2 * (l + b);
return perimeter;
}
| int main() {
assert(func0(10, 20) == 60);
assert(func0(10, 5) == 30);
assert(func0(4, 2) == 12);
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;
} |
6,511 | func0 |
#include <assert.h>
| int func0(int l, int b) {
int perimeter = 2 * (l + b);
return perimeter;
}
| int main() {
assert(func0(10, 20) == 60);
assert(func0(10, 5) == 30);
assert(func0(4, 2) == 12);
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;
} |
6,512 | func0 |
#include <assert.h>
| int func0(int n) {
int sm = 0;
for (int i = 1; i <= n; i++) {
sm += i * i * i * i * i;
}
return sm;
}
| int main() {
assert(func0(2) == 33);
assert(func0(4) == 1300);
assert(func0(3) == 276);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 117d <func0+0x34>
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
imul -0x4(%rbp),%eax
imul -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_117D
loc_1164:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
imul eax, [rbp+var_4]
imul eax, [rbp+var_4]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_11... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += i * i * i * i * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010117d
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + ... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = local_10 + local_c * local_c * local_c * local_c * local_c;
}
return local_10;
} |
6,513 | func0 |
#include <assert.h>
| int func0(int n) {
int sm = 0;
for (int i = 1; i <= n; i++) {
sm += i * i * i * i * i;
}
return sm;
}
| int main() {
assert(func0(2) == 33);
assert(func0(4) == 1300);
assert(func0(3) == 276);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1175 <func0+0x2c>
add $0x1,%edi
mov $0x1,%edx
mov $0x0,%ecx
mov %edx,%eax
imul %edx,%eax
imul %eax,%eax
imul %edx,%eax
add %eax,%ecx
add $0x1,%edx
cmp %edi,%edx
jne 115e <func0+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1172 <func0+0x29>
| func0:
endbr64
test edi, edi
jle short loc_1175
add edi, 1
mov edx, 1
mov ecx, 0
loc_115E:
mov eax, edx
imul eax, edx
imul eax, eax
imul eax, edx
add ecx, eax
add edx, 1
cmp edx, edi
jnz short loc_115E
loc_1172:
mov eax, ecx
retn
loc_1175:
mov ecx, 0
jmp short... | long long func0(int a1)
{
int v1; // edi
int v2; // edx
unsigned int v3; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v3 += v2 * v2 * v2 * v2 * v2;
++v2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101175
ADD EDI,0x1
MOV EDX,0x1
MOV ECX,0x0
LAB_0010115e:
MOV EAX,EDX
IMUL EAX,EDX
IMUL EAX,EAX
IMUL EAX,EDX
ADD ECX,EAX
ADD EDX,0x1
CMP EDX,EDI
JNZ 0x0010115e
LAB_00101172:
MOV EAX,ECX
RET
LAB_00101175:
MOV ECX,0x0
JMP 0x00101172 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar1 = 0;
}
else {
iVar2 = 1;
iVar1 = 0;
do {
iVar1 = iVar1 + iVar2 * iVar2 * iVar2 * iVar2 * iVar2;
iVar2 = iVar2 + 1;
} while (iVar2 != param_1 + 1);
}
return iVar1;
} |
6,514 | func0 |
#include <assert.h>
| int func0(int n) {
int sm = 0;
for (int i = 1; i <= n; i++) {
sm += i * i * i * i * i;
}
return sm;
}
| int main() {
assert(func0(2) == 33);
assert(func0(4) == 1300);
assert(func0(3) == 276);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1178 <func0+0x38>
add $0x1,%edi
mov $0x1,%edx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edx,%eax
imul %edx,%eax
imul %eax,%eax
imul %edx,%eax
add $0x1,%edx
add %eax,%r8d
cmp %edx,%edi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor ... | func0:
endbr64
test edi, edi
jle short loc_1178
add edi, 1
mov edx, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1158:
mov eax, edx
imul eax, edx
imul eax, eax
imul eax, edx
add edx, 1
add r8d, eax
cmp edi, edx
jnz short loc_1158
mov eax, r8d
retn
loc_1178:
xor ... | long long func0(int a1)
{
int v1; // edi
int v2; // edx
unsigned int v3; // r8d
int v4; // eax
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2 * v2 * v2;
++v2;
v3 += v4;
}
while ( v1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
ADD EDI,0x1
MOV EDX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EAX,EDX
IMUL EAX,EDX
IMUL EAX,EAX
IMUL EAX,EDX
ADD EDX,0x1
ADD R8D,EAX
CMP EDI,EDX
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101178:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 1;
iVar3 = 0;
do {
iVar1 = iVar2 * iVar2 * iVar2 * iVar2 * iVar2;
iVar2 = iVar2 + 1;
iVar3 = iVar3 + iVar1;
} while (param_1 + 1 != iVar2);
return iVar3;
}
return 0;
} |
6,515 | func0 |
#include <assert.h>
| int func0(int n) {
int sm = 0;
for (int i = 1; i <= n; i++) {
sm += i * i * i * i * i;
}
return sm;
}
| int main() {
assert(func0(2) == 33);
assert(func0(4) == 1300);
assert(func0(3) == 276);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1178 <func0+0x38>
add $0x1,%edi
mov $0x1,%edx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edx,%eax
imul %edx,%eax
imul %eax,%eax
imul %edx,%eax
add $0x1,%edx
add %eax,%r8d
cmp %edi,%edx
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor ... | func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov edx, 1
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1158:
mov eax, edx
imul eax, edx
imul eax, eax
imul eax, edx
add edx, 1
add ecx, eax
cmp edx, edi
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ... | long long func0(int a1)
{
int v1; // edi
int v2; // edx
unsigned int v3; // ecx
int v4; // eax
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2 * v2 * v2;
++v2;
v3 += v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EDX,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EAX,EDX
IMUL EAX,EDX
IMUL EAX,EAX
IMUL EAX,EDX
ADD EDX,0x1
ADD ECX,EAX
CMP EDX,EDI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar3 = 1;
iVar2 = 0;
do {
iVar1 = iVar3 * iVar3 * iVar3 * iVar3 * iVar3;
iVar3 = iVar3 + 1;
iVar2 = iVar2 + iVar1;
} while (iVar3 != param_1 + 1);
return iVar2;
}
return 0;
} |
6,516 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sort(int arr[], int n) {
int i, j;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
... | int func0(int a[], int b[], int n) {
sort(a, n);
sort(b, n);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += abs(a[i] - b[i]);
}
return sum;
}
| int main() {
int a1[] = {3, 2, 1};
int b1[] = {2, 1, 3};
assert(func0(a1, b1, 3) == 0);
int a2[] = {1, 2, 3};
int b2[] = {4, 5, 6};
assert(func0(a2, b2, 3) == 9);
int a3[] = {4, 1, 8, 7};
int b3[] = {2, 3, 6, 5};
assert(func0(a3, b3, 4) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x28,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x24(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1169 <sort>
mov -0x24(%rbp),%edx
mov -0x20(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
cal... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 28h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov edx, [rbp+var_24]
mov rax, [rbp+var_18]
mov esi, edx
mov rdi, rax
call sort
mov edx, [rbp+var_24]
mov rax, [rbp+var_20]
mov esi, edx
mov rdi, ... | long long func0(long long a1, long long a2, unsigned int a3)
{
long long v3; // rcx
int v4; // eax
unsigned int v7; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
sort(a1, a3);
sort(a2, a3);
v7 = 0;
for ( i = 0; i < (int)a3; ++i )
{
v3 = 4LL * i;
v4 = *(_DWORD *)(v3 + a1) - *(_DWORD *)(v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x28
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV EDX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101169
MOV EDX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI... | int func0(long param_1,long param_2,int param_3)
{
int iVar1;
int4 local_10;
int4 local_c;
sort(param_1,param_3);
sort(param_2,param_3);
local_10 = 0;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
iVar1 = *(int *)(param_1 + (long)local_c * 4) - *(int *)(param_2 + (long)local_c * 4)... |
6,517 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sort(int arr[], int n) {
int i, j;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
... | int func0(int a[], int b[], int n) {
sort(a, n);
sort(b, n);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += abs(a[i] - b[i]);
}
return sum;
}
| int main() {
int a1[] = {3, 2, 1};
int b1[] = {2, 1, 3};
assert(func0(a1, b1, 3) == 0);
int a2[] = {1, 2, 3};
int b2[] = {4, 5, 6};
assert(func0(a2, b2, 3) == 9);
int a3[] = {4, 1, 8, 7};
int b3[] = {2, 3, 6, 5};
assert(func0(a3, b3, 4) == 6);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rsi,%rbp
mov %edx,%r12d
mov %edx,%esi
callq 1169 <sort>
mov %r12d,%esi
mov %rbp,%rdi
callq 1169 <sort>
test %r12d,%r12d
jle 120a <func0+0x5c>
lea -0x1(%r12),%edi
mov $0x0,%edx
mov $0x0,%esi
mov (%rbx,%rdx,4),%eax
... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rsi
mov r12d, edx
mov esi, edx
call sort
mov esi, r12d
mov rdi, rbp
call sort
test r12d, r12d
jle short loc_1203
mov edx, r12d
mov ecx, 0
mov edi, 0
loc_11E3:
mov eax, [rbx+rcx*4]
sub eax, [... | long long func0(long long a1, long long a2, int a3)
{
long long v5; // rcx
unsigned int v6; // edi
int v7; // eax
sort(a1, (unsigned int)a3);
sort(a2, (unsigned int)a3);
if ( a3 <= 0 )
{
return 0;
}
else
{
v5 = 0LL;
v6 = 0;
do
{
v7 = *(_DWORD *)(a1 + 4 * v5) - *(_DWORD *)... | ||
6,518 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sort(int arr[], int n) {
int i, j;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
... | int func0(int a[], int b[], int n) {
sort(a, n);
sort(b, n);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += abs(a[i] - b[i]);
}
return sum;
}
| int main() {
int a1[] = {3, 2, 1};
int b1[] = {2, 1, 3};
assert(func0(a1, b1, 3) == 0);
int a2[] = {1, 2, 3};
int b2[] = {4, 5, 6};
assert(func0(a2, b2, 3) == 9);
int a3[] = {4, 1, 8, 7};
int b3[] = {2, 3, 6, 5};
assert(func0(a3, b3, 4) == 6);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rsi,%r11
mov %edx,%esi
mov %edx,%ebx
mov %rdi,%r10
callq 12f0 <sort>
mov %ebx,%esi
mov %r11,%rdi
callq 12f0 <sort>
test %ebx,%ebx
jle 1388 <func0+0x58>
lea -0x1(%rbx),%esi
xor %edx,%edx
xor %r8d,%r8d
nopw 0x0(%rax,%rax,1)
mov (%r10,%rdx,4),%eax
sub ... | func0:
endbr64
push rbx
mov r10d, edx
mov rbx, rsi
mov esi, edx
mov r11, rdi
call sort
mov esi, r10d
mov rdi, rbx
call sort
test r10d, r10d
jle short loc_1380
movsxd rdx, r10d
xor ecx, ecx
xor r8d, r8d
nop dword ptr [rax]
loc_1360:
mov eax, [r11+rcx*4]
sub ea... | long long func0(long long a1, long long a2, unsigned int a3)
{
unsigned int v3; // r10d
int v4; // r10d
long long v5; // r11
long long v6; // rcx
unsigned int v7; // r8d
int v8; // eax
sort(a1, a3);
sort(a2, v3);
if ( v4 <= 0 )
return 0LL;
v6 = 0LL;
v7 = 0;
do
{
v8 = *(_DWORD *)(v5 +... | func0:
ENDBR64
PUSH RBX
MOV R10D,EDX
MOV RBX,RSI
MOV ESI,EDX
MOV R11,RDI
CALL 0x001012f0
MOV ESI,R10D
MOV RDI,RBX
CALL 0x001012f0
TEST R10D,R10D
JLE 0x00101380
MOVSXD RDX,R10D
XOR ECX,ECX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101360:
MOV EAX,dword ptr [R11 + RCX*0x4]
SUB EAX,dword ptr [RBX + RCX*0x4]
MOV ESI,EAX
NEG ES... | int func0(long param_1,long param_2,ulong param_3)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
ulong uVar5;
uVar5 = param_3 & 0xffffffff;
sort(param_1,param_3 & 0xffffffff);
iVar4 = (int)uVar5;
sort(param_2,uVar5 & 0xffffffff);
if (0 < iVar4) {
lVar2 = 0;
iVar3 = 0;
do {
iVa... |
6,519 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
void sort(int arr[], int n) {
int i, j;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
... | int func0(int a[], int b[], int n) {
sort(a, n);
sort(b, n);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += abs(a[i] - b[i]);
}
return sum;
}
| int main() {
int a1[] = {3, 2, 1};
int b1[] = {2, 1, 3};
assert(func0(a1, b1, 3) == 0);
int a2[] = {1, 2, 3};
int b2[] = {4, 5, 6};
assert(func0(a2, b2, 3) == 9);
int a3[] = {4, 1, 8, 7};
int b3[] = {2, 3, 6, 5};
assert(func0(a3, b3, 4) == 6);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rdx),%r11d
push %rbp
lea 0x4(%rdi),%rbp
push %rbx
mov %r11d,%ecx
mov %r11d,%r8d
test %r11d,%r11d
jle 13a0 <func0+0x90>
nopl 0x0(%rax)
lea -0x1(%r8),%r9d
mov %rdi,%rax
mov %r9,%r8
lea 0x0(%rbp,%r9,4),%rbx
mov (%rax),%r9d
mov 0x4(%rax),%r10d
cmp %r10d,%... | func0:
endbr64
mov r8, rdi
mov r9, rsi
mov r10d, edx
mov edi, edx
lea r11, [r8+4]
cmp edx, 1
jle loc_14C0
nop dword ptr [rax+00h]
loc_1340:
lea edx, [rdi-2]
mov rax, r8
lea rsi, [r11+rdx*4]
nop word ptr [rax+rax+00h]
loc_1350:
movq xmm0, qword ptr [rax]
pshufd xmm3, x... | long long func0(__m128i *a1, __m128i *a2, int a3)
{
int v6; // edi
__m128i *v7; // rax
__m128i v8; // xmm0
int i; // edi
__m128i *v10; // rax
__m128i v11; // xmm0
unsigned long long v12; // rax
__m128i v13; // xmm1
long long v14; // rdx
__m128i v15; // xmm0
__m128i v16; // xmm5
__m128i v17; // ... | func0:
ENDBR64
MOV R8,RDI
MOV R9,RSI
MOV R10D,EDX
MOV EDI,EDX
LEA R11,[R8 + 0x4]
CMP EDX,0x1
JLE 0x001014c0
NOP dword ptr [RAX]
LAB_00101340:
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R11 + RDX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101350:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM3,XMM0,0xe5
MOVD EDX,XMM0
MOVD ECX,XMM3
CMP... | int func0(int *param_1,int *param_2,uint param_3)
{
int *piVar1;
int *piVar2;
long lVar3;
uint uVar4;
uint uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
uint uVar10;
uint uVar11;
uVar4 = param_3;
if ((int)param_3 < 2) {
if (param_3 == 1) {
iVar7 = *param_1 - *param_2;
... |
6,520 | func0 | #include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int fact = 1;
for (int i = 2; i <= n; i++) {
fact = fact * i;
while (fact % 10 == 0) {
fact = fact / 10;
}
}
while (fact >= 10) {
fact = fact / 10;
}
return floor(fact);
}
| int main() {
assert(func0(5) == 1);
assert(func0(10) == 3);
assert(func0(7) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 11c0 <func0+0x77>
mov -0x8(%rbp),%eax
imul -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 118e <func0+0x45>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
mov [rbp+var_4], 2
jmp short loc_11C0
loc_1164:
mov eax, [rbp+var_8]
imul eax, [rbp+var_4]
mov [rbp+var_8], eax
jmp short loc_118E
loc_1170:
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667... | long long func0(int a1)
{
int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 1;
for ( i = 2; i <= a1; ++i )
{
for ( v2 *= i; !(v2 % 10); v2 /= 10 )
;
}
while ( v2 > 9 )
v2 /= 10;
return (unsigned int)(int)(double)v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001011c0
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x0010118e
LAB_00101170:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD ... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 2; local_c <= param_1; local_c = local_c + 1) {
for (local_10 = local_10 * local_c; local_10 % 10 == 0; local_10 = local_10 / 10) {
}
}
for (; 9 < local_10; local_10 = local_10 / 10) {
}
return (int)(double)lo... |
6,521 | func0 | #include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int fact = 1;
for (int i = 2; i <= n; i++) {
fact = fact * i;
while (fact % 10 == 0) {
fact = fact / 10;
}
}
while (fact >= 10) {
fact = fact / 10;
}
return floor(fact);
}
| int main() {
assert(func0(5) == 1);
assert(func0(10) == 3);
assert(func0(7) == 5);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x1(%rdi),%r9d
mov $0x2,%r8d
mov $0x2,%eax
cmp $0x1,%edi
jle 11c1 <func0+0x78>
add $0x1,%r8d
cmp %r9d,%r8d
je 11c7 <func0+0x7e>
imul %r8d,%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %eax,%ecx
sar $0x1f,%ecx
sub %ecx,%edx
lea (%rdx,%r... | func0:
endbr64
lea r9d, [rdi+1]
mov r8d, 2
mov ecx, 2
cmp edi, 1
jg short loc_11C0
mov ecx, 1
jmp loc_11EC
loc_116B:
imul ecx, r8d
movsxd rax, ecx
imul rax, 66666667h
sar rax, 22h
mov edx, ecx
sar edx, 1Fh
sub eax, edx
lea eax, [rax+rax*4]
add eax, eax
cmp ... | long long func0(int a1)
{
int v1; // r8d
int v2; // ecx
int v3; // edx
v1 = 2;
v2 = 2;
if ( a1 > 1 )
{
while ( ++v1 != a1 + 1 )
{
for ( v2 *= v1; v2 == 10 * (v2 / 10); v2 /= 10 )
;
}
if ( v2 > 9 )
{
do
{
v3 = v2;
v2 /= 10;
}
while... | func0:
ENDBR64
LEA R9D,[RDI + 0x1]
MOV R8D,0x2
MOV ECX,0x2
CMP EDI,0x1
JG 0x001011c0
MOV ECX,0x1
JMP 0x001011ec
LAB_0010116b:
IMUL ECX,R8D
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,ECX
SAR EDX,0x1f
SUB EAX,EDX
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
CMP ECX,EAX
JNZ 0x001011c0
LAB_0010118d:
MOVSXD RAX,ECX
... | int func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
iVar3 = 2;
iVar2 = 2;
if (param_1 < 2) {
iVar2 = 1;
}
else {
while (iVar3 = iVar3 + 1, iVar3 != param_1 + 1) {
iVar2 = iVar2 * iVar3;
if (iVar2 == (iVar2 / 10) * 10) {
do {
iVar2 = iVar2 / 10;
} ... |
6,522 | func0 | #include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int fact = 1;
for (int i = 2; i <= n; i++) {
fact = fact * i;
while (fact % 10 == 0) {
fact = fact / 10;
}
}
while (fact >= 10) {
fact = fact / 10;
}
return floor(fact);
}
| int main() {
assert(func0(5) == 1);
assert(func0(10) == 3);
assert(func0(7) == 5);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%esi
mov $0x2,%ecx
mov $0x2,%eax
cmp $0x1,%edi
jle 13b3 <func0+0x83>
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%ecx
cmp %esi,%ecx
je 1390 <func0+0x60>
imul %ecx,%eax
nopw 0x0(%rax,%rax,1)
imul $0xcccccccd,%eax,%edx
add $0x19999998,%edx
ror %edx
cmp $0x1999... | func0:
endbr64
lea esi, [rdi+1]
mov ecx, 2
mov r8d, 2
cmp edi, 1
jle short loc_1277
nop word ptr [rax+rax+00000000h]
loc_1210:
add ecx, 1
cmp ecx, esi
jz short loc_1250
imul r8d, ecx
nop dword ptr [rax+rax+00h]
loc_1220:
imul eax, r8d, 0CCCCCCCDh
add eax, 19999998h
ror... | long long func0(int a1)
{
int v1; // ecx
int v2; // r8d
int v3; // eax
v1 = 2;
v2 = 2;
if ( a1 <= 1 )
return 1LL;
while ( ++v1 != a1 + 1 )
{
for ( v2 *= v1; __ROR4__(-858993459 * v2 + 429496728, 1) <= 0x19999998u; v2 /= 10 )
;
}
if ( v2 > 9 )
{
do
{
v3 = v2;
v2 ... | func0:
ENDBR64
LEA ESI,[RDI + 0x1]
MOV ECX,0x2
MOV R8D,0x2
CMP EDI,0x1
JLE 0x00101277
NOP word ptr [RAX + RAX*0x1]
LAB_00101210:
ADD ECX,0x1
CMP ECX,ESI
JZ 0x00101250
IMUL R8D,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101220:
IMUL EAX,R8D,-0x33333333
ADD EAX,0x19999998
ROR EAX,0x1
CMP EAX,0x19999998
JA 0x00101210
MOVSXD ... | uint func0(int param_1)
{
bool bVar1;
uint uVar2;
int iVar3;
uint uVar4;
iVar3 = 2;
uVar4 = 2;
if (param_1 < 2) {
return 1;
}
while (iVar3 = iVar3 + 1, iVar3 != param_1 + 1) {
uVar4 = uVar4 * iVar3;
while (uVar2 = uVar4 * -0x33333333 + 0x19999998,
(uVar2 >> 1 | (uint)((uVar2 ... |
6,523 | func0 | #include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
int fact = 1;
for (int i = 2; i <= n; i++) {
fact = fact * i;
while (fact % 10 == 0) {
fact = fact / 10;
}
}
while (fact >= 10) {
fact = fact / 10;
}
return floor(fact);
}
| int main() {
assert(func0(5) == 1);
assert(func0(10) == 3);
assert(func0(7) == 5);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%edi
jle 138c <func0+0x7c>
lea 0x1(%rdi),%esi
mov $0x2,%eax
mov $0x3,%ecx
cmp $0x2,%edi
je 138b <func0+0x7b>
nopl 0x0(%rax,%rax,1)
imul %ecx,%eax
jmp 134d <func0+0x3d>
nopl (%rax)
movslq %eax,%rdx
sar $0x1f,%eax
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sub... | func0:
endbr64
cmp edi, 1
jle short loc_1393
add edi, 1
mov esi, 2
mov eax, 1
nop word ptr [rax+rax+00000000h]
loc_1330:
imul eax, esi
jmp short loc_134F
loc_1338:
movsxd rdx, eax
sar eax, 1Fh
imul rdx, 66666667h
mov ecx, eax
sar rdx, 22h
mov eax, edx
sub eax, ecx
... | unsigned long long func0(int a1)
{
int v1; // edi
int v2; // esi
unsigned long long result; // rax
int v4; // edx
if ( a1 <= 1 )
return 1LL;
v1 = a1 + 1;
v2 = 2;
LODWORD(result) = 1;
do
{
for ( result = (unsigned int)(v2 * result);
__ROR4__(-858993459 * result + 429496728, 1) <= ... | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101393
ADD EDI,0x1
MOV ESI,0x2
MOV EAX,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101330:
IMUL EAX,ESI
JMP 0x0010134f
LAB_00101338:
MOVSXD RDX,EAX
SAR EAX,0x1f
IMUL RDX,RDX,0x66666667
MOV ECX,EAX
SAR RDX,0x22
MOV EAX,EDX
SUB EAX,ECX
LAB_0010134f:
IMUL EDX,EAX,-0x33333333
ADD EDX,0x1999... | ulong func0(int param_1)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
uint uVar4;
int iVar5;
if (param_1 < 2) {
uVar2 = 1;
}
else {
iVar5 = 2;
uVar2 = 1;
do {
uVar1 = (int)uVar2 * iVar5;
while (uVar2 = (ulong)uVar1, uVar4 = uVar1 * -0x33333333 + 0x19999998,
(uVar4 ... |
6,524 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int list1[], int length) {
int max_val = 0;
int result = list1[0];
for (int i = 0; i < length; i++) {
int occu = 0;
for (int j = 0; j < length; j++) {
if (list1[j] == list1[i]) {
occu++;
}
}
if (occu > max_val) {
... | int main() {
int list1[] = {2, 3, 8, 4, 7, 9, 8, 2, 6, 5, 1, 6, 1, 2, 3, 4, 6, 9, 1, 2};
int list2[] = {1, 3, 5, 7, 1, 3, 13, 15, 17, 5, 7, 9, 1, 11};
int list3[] = {1, 2, 3, 2, 4, 5, 1, 1, 1};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 2);
assert(func0(list2, sizeof(list2)/sizeof... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 122c <func0+0xa3>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f9 <func0+0x70>
mov -0x4(%rbp),... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_10], eax
mov [rbp+var_C], 0
jmp short loc_122C
loc_11B1:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11F9
loc_... | long long func0(unsigned int *a1, int a2)
{
int v3; // [rsp+18h] [rbp-14h]
unsigned int v4; // [rsp+1Ch] [rbp-10h]
int i; // [rsp+20h] [rbp-Ch]
int v6; // [rsp+24h] [rbp-8h]
int j; // [rsp+28h] [rbp-4h]
v3 = 0;
v4 = *a1;
for ( i = 0; i < a2; ++i )
{
v6 = 0;
for ( j = 0; j < a2; ++j )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010122c
LAB_001011b1:
MOV dword ptr [RBP + -0x8],0x0
MOV dword... | int4 func0(int4 *param_1,int param_2)
{
int local_1c;
int4 local_18;
int local_14;
int local_10;
int local_c;
local_1c = 0;
local_18 = *param_1;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
... |
6,525 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int list1[], int length) {
int max_val = 0;
int result = list1[0];
for (int i = 0; i < length; i++) {
int occu = 0;
for (int j = 0; j < length; j++) {
if (list1[j] == list1[i]) {
occu++;
}
}
if (occu > max_val) {
... | int main() {
int list1[] = {2, 3, 8, 4, 7, 9, 8, 2, 6, 5, 1, 6, 1, 2, 3, 4, 6, 9, 1, 2};
int list2[] = {1, 3, 5, 7, 1, 3, 13, 15, 17, 5, 7, 9, 1, 11};
int list3[] = {1, 2, 3, 2, 4, 5, 1, 1, 1};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 2);
assert(func0(list2, sizeof(list2)/sizeof... | O1 | c | func0:
endbr64
mov (%rdi),%r11d
test %esi,%esi
jle 11da <func0+0x51>
mov %rdi,%r10
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r8
mov $0x0,%r9d
jmp 11b0 <func0+0x27>
add $0x4,%rdi
cmp %r8,%rdi
je 11da <func0+0x51>
mov (%rdi),%esi
mov %r10,%rax
mov $0x0,%edx
cmp %esi,(%rax)
set... | func0:
endbr64
mov r11d, [rdi]
test esi, esi
jle short loc_11DB
lea eax, [rsi-1]
lea r8, [rdi+rax*4+4]
mov r9, rdi
mov r10d, 0
jmp short loc_11B0
loc_11A7:
add r9, 4
cmp r9, r8
jz short loc_11DB
loc_11B0:
mov esi, [r9]
mov rax, rdi
mov edx, 0
loc_11BB:
cmp [ra... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r11d
long long v3; // r8
unsigned int *v4; // r9
int v5; // r10d
unsigned int *v6; // rax
int v7; // edx
v2 = *a1;
if ( a2 > 0 )
{
v3 = (long long)&a1[a2 - 1 + 1];
v4 = a1;
v5 = 0;
do
{
v6 = a1;
v7 = 0;
... | func0:
ENDBR64
MOV R11D,dword ptr [RDI]
TEST ESI,ESI
JLE 0x001011db
LEA EAX,[RSI + -0x1]
LEA R8,[RDI + RAX*0x4 + 0x4]
MOV R9,RDI
MOV R10D,0x0
JMP 0x001011b0
LAB_001011a7:
ADD R9,0x4
CMP R9,R8
JZ 0x001011db
LAB_001011b0:
MOV ESI,dword ptr [R9]
MOV RAX,RDI
MOV EDX,0x0
LAB_001011bb:
CMP dword ptr [RAX],ESI
SETZ CL
MOVZX E... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int iVar4;
int iVar5;
iVar5 = *param_1;
if (0 < param_2) {
iVar4 = 0;
piVar3 = param_1;
do {
iVar2 = 0;
piVar1 = param_1;
do {
iVar2 = iVar2 + (uint)(*piVar1 == *piVar3);
piVar1 = p... |
6,526 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int list1[], int length) {
int max_val = 0;
int result = list1[0];
for (int i = 0; i < length; i++) {
int occu = 0;
for (int j = 0; j < length; j++) {
if (list1[j] == list1[i]) {
occu++;
}
}
if (occu > max_val) {
... | int main() {
int list1[] = {2, 3, 8, 4, 7, 9, 8, 2, 6, 5, 1, 6, 1, 2, 3, 4, 6, 9, 1, 2};
int list2[] = {1, 3, 5, 7, 1, 3, 13, 15, 17, 5, 7, 9, 1, 11};
int list3[] = {1, 2, 3, 2, 4, 5, 1, 1, 1};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 2);
assert(func0(list2, sizeof(list2)/sizeof... | O2 | c | func0:
endbr64
push %r12
mov (%rdi),%r11d
test %esi,%esi
jle 1406 <func0+0x66>
lea 0x4(%rdi),%r9
lea -0x1(%rsi),%eax
mov %r11d,%r12d
mov %r11d,%esi
lea (%r9,%rax,4),%rdi
mov %r9,%r8
xor %r10d,%r10d
nopl 0x0(%rax)
mov %r9,%rax
mov %r11d,%ecx
xor %edx,%edx
jmp 13de <func0+0x3e... | func0:
endbr64
push r12
mov r11d, [rdi]
test esi, esi
jle short loc_1406
lea r9, [rdi+4]
lea eax, [rsi-1]
mov r12d, r11d
mov esi, r11d
lea rdi, [r9+rax*4]
mov r8, r9
xor r10d, r10d
nop dword ptr [rax+00h]
loc_13C8:
mov rax, r9
mov ecx, r11d
xor edx, edx
jmp ... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r11d
unsigned int *v3; // r9
long long v4; // rax
unsigned int v5; // r12d
unsigned int v6; // esi
long long v7; // rdi
unsigned int *v8; // r8
int v9; // r10d
unsigned int *v10; // rax
unsigned int v11; // ecx
int v12; // edx
v2 ... | func0:
ENDBR64
PUSH R12
MOV R11D,dword ptr [RDI]
TEST ESI,ESI
JLE 0x00101406
LEA R9,[RDI + 0x4]
LEA EAX,[RSI + -0x1]
MOV R12D,R11D
MOV ESI,R11D
LEA RDI,[R9 + RAX*0x4]
MOV R8,R9
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_001013c8:
MOV RAX,R9
MOV ECX,R11D
XOR EDX,EDX
JMP 0x001013de
LAB_001013d8:
MOV ECX,dword ptr [RAX]
ADD RA... | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int *piVar6;
int iVar7;
int iVar8;
iVar1 = *param_1;
iVar8 = iVar1;
if (0 < param_2) {
param_1 = param_1 + 1;
iVar7 = 0;
piVar6 = param_1;
iVar5 = iVar1;
while( true ) {
iVa... |
6,527 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int list1[], int length) {
int max_val = 0;
int result = list1[0];
for (int i = 0; i < length; i++) {
int occu = 0;
for (int j = 0; j < length; j++) {
if (list1[j] == list1[i]) {
occu++;
}
}
if (occu > max_val) {
... | int main() {
int list1[] = {2, 3, 8, 4, 7, 9, 8, 2, 6, 5, 1, 6, 1, 2, 3, 4, 6, 9, 1, 2};
int list2[] = {1, 3, 5, 7, 1, 3, 13, 15, 17, 5, 7, 9, 1, 11};
int list3[] = {1, 2, 3, 2, 4, 5, 1, 1, 1};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 2);
assert(func0(list2, sizeof(list2)/sizeof... | O3 | c | func0:
endbr64
push %r14
push %r13
mov (%rdi),%r13d
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 1426 <func0+0x106>
mov %esi,%edx
lea -0x1(%rsi),%eax
mov %esi,%r11d
mov %rdi,%r9
shr $0x2,%edx
mov %rax,%rbp
lea 0x4(%rdi,%rax,4),%r12
and $0xfffffffc,%r11d
shl $0x4,%rdx
xor... | func0:
endbr64
push r14
push r13
mov r13d, [rdi]
push r12
push rbp
push rbx
test esi, esi
jle loc_140A
mov edx, esi
movsxd rax, esi
mov r11d, esi
mov r8, rdi
shr edx, 2
mov r9d, esi
lea r12, [rdi+rax*4]
and r11d, 0FFFFFFFCh
shl rdx, 4
lea ebp, [rsi-1]
xor ... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r13d
const __m128i *v3; // r8
unsigned int *v5; // r12
unsigned int v6; // r11d
unsigned int v7; // ebp
int v8; // ebx
const __m128i *v9; // rdx
unsigned int v10; // esi
const __m128i *v11; // rax
__m128i v12; // xmm1
__m128i v13; //... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13D,dword ptr [RDI]
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x0010140a
MOV EDX,ESI
MOVSXD RAX,ESI
MOV R11D,ESI
MOV R8,RDI
SHR EDX,0x2
MOV R9D,ESI
LEA R12,[RDI + RAX*0x4]
AND R11D,0xfffffffc
SHL RDX,0x4
LEA EBP,[RSI + -0x1]
XOR EBX,EBX
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_0010136... | int func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
int iVar8;
int *piVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
iVar10 = *param_1;
if (0 < (int)param_2) {
iVar8 = 0;
piVar9 = para... |
6,528 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
void assertArrayEquals(int *expected, int expectedSize, int *actual, int actualSize) {
assert(expectedSize == actualSize);
for (int i = 0; i < expectedSize; i++) {
assert(expected[i] == actual[i]);
}
}
| int* func0(int x[], int size, int *returnSize) {
int *repeated = malloc(sizeof(int) * size);
int count = 0;
bool found;
for (int i = 0; i < size; i++) {
found = false;
for (int j = i + 1; j < size; j++) {
if (x[i] == x[j]) {
found = true;
... | int main() {
int arr1[] = {10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20};
int expected1[] = {20, 30, -20, 60};
int size1;
int *result1 = func0(arr1, 13, &size1);
assertArrayEquals(expected1, 4, result1, size1);
free(result1);
int arr2[] = {-1, 1, -1, 8};
int expect... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 1375 <func0+0x123>
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_1387
loc_12... | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
char v6; // [rsp+27h] [rbp-19h]
int v7; // [rsp+28h] [rbp-18h]
int i; // [rsp+2Ch] [rbp-14h]
int j; // [rsp+30h] [rbp-10h]
int k; // [rsp+34h] [rbp-Ch]
_DWORD *v11; // [rsp+38h] [rbp-8h]
v11 = malloc(4LL * a2);
v7 = 0;
for ( i = 0; i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP... | void * func0(long param_1,int param_2,int *param_3)
{
bool bVar1;
void *pvVar2;
int local_20;
int local_1c;
int local_18;
int local_14;
pvVar2 = malloc((long)param_2 << 2);
local_20 = 0;
local_1c = 0;
do {
local_18 = local_1c;
if (param_2 <= local_1c) {
*param_3 = local_20;
r... |
6,529 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
void assertArrayEquals(int *expected, int expectedSize, int *actual, int actualSize) {
assert(expectedSize == actualSize);
for (int i = 0; i < expectedSize; i++) {
assert(expected[i] == actual[i]);
}
}
| int* func0(int x[], int size, int *returnSize) {
int *repeated = malloc(sizeof(int) * size);
int count = 0;
bool found;
for (int i = 0; i < size; i++) {
found = false;
for (int j = i + 1; j < size; j++) {
if (x[i] == x[j]) {
found = true;
... | int main() {
int arr1[] = {10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20};
int expected1[] = {20, 30, -20, 60};
int size1;
int *result1 = func0(arr1, 13, &size1);
assertArrayEquals(expected1, 4, result1, size1);
free(result1);
int arr2[] = {-1, 1, -1, 8};
int expect... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
mov %rdx,%r12
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r13
test %ebp,%ebp
jle 12a8 <func0+0x8d>
lea -0x1(%rbp),%r10d
add $0x1,%r10
mov $0x1,%edi
mov $0x0,%... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov ebp, esi
mov r12, rdx
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebp, ebp
jle short loc_1297
mov r10d, ebp
mov r8d, 1
mov r9d, 0
lea r11, [rax+4]
jmp short loc_1280
loc_1250:
add rcx, 1
cmp ebp, ... | long long func0(long long a1, int a2, int *a3)
{
long long result; // rax
long long v6; // r8
int v7; // r9d
long long v8; // rcx
_DWORD *v9; // rdx
int v10; // esi
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v6 = 1LL;
v7 = 0;
while ( 1 )
{
if ( v6 == a2 )
goto LABEL_14;... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV EBP,ESI
MOV R12,RDX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBP,EBP
JLE 0x00101297
MOV R10D,EBP
MOV R8D,0x1
MOV R9D,0x0
LEA R11,[RAX + 0x4]
JMP 0x00101280
LAB_00101250:
ADD RCX,0x1
CMP EBP,ECX
JLE 0x0010127c
LAB_00101258:
CMP ESI,dword ptr [RBX + RCX*0x4... | void func0(long param_1,uint param_2,int *param_3)
{
int iVar1;
int *piVar2;
ulong uVar3;
int *piVar4;
ulong uVar5;
int iVar6;
piVar2 = (int *)malloc((long)(int)param_2 << 2);
if ((int)param_2 < 1) {
iVar6 = 0;
}
else {
iVar6 = 0;
for (uVar5 = 1; uVar5 != param_2; uVar5 = uVar5 + 1) ... |
6,530 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
void assertArrayEquals(int *expected, int expectedSize, int *actual, int actualSize) {
assert(expectedSize == actualSize);
for (int i = 0; i < expectedSize; i++) {
assert(expected[i] == actual[i]);
}
}
| int* func0(int x[], int size, int *returnSize) {
int *repeated = malloc(sizeof(int) * size);
int count = 0;
bool found;
for (int i = 0; i < size; i++) {
found = false;
for (int j = i + 1; j < size; j++) {
if (x[i] == x[j]) {
found = true;
... | int main() {
int arr1[] = {10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20};
int expected1[] = {20, 30, -20, 60};
int size1;
int *result1 = func0(arr1, 13, &size1);
assertArrayEquals(expected1, 4, result1, size1);
free(result1);
int arr2[] = {-1, 1, -1, 8};
int expect... | O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r9
test %ebp,%ebp
jle 1485 <func0+0xa5>
lea -0x1(%rbp),%r10d
mov $0x1,%edi
lea 0x4(%rax),%r11
xor %r8d,%r8d
add $0x1,%r10
cmp ... | func0:
endbr64
push r13
mov r13, rdx
push r12
movsxd r12, esi
push rbp
push rbx
mov rbx, rdi
lea rdi, ds:0[r12*4]
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_1468
mov r8d, 1
mov rbp, r12
lea r10, [rax+4]
xor r9d, r9d
cmp r8, r12
jz short loc_1459... | long long func0(long long a1, int a2, _DWORD *a3)
{
long long v4; // r12
long long result; // rax
long long v6; // r8
int v7; // r9d
int v8; // esi
long long v9; // rcx
_DWORD *v10; // rdx
long long v11; // rdx
v4 = a2;
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v6 = 1LL;
v7 = 0;
i... | func0:
ENDBR64
PUSH R13
MOV R13,RDX
PUSH R12
MOVSXD R12,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
LEA RDI,[R12*0x4]
SUB RSP,0x8
CALL 0x001010b0
TEST R12D,R12D
JLE 0x00101468
MOV R8D,0x1
MOV RBP,R12
LEA R10,[RAX + 0x4]
XOR R9D,R9D
CMP R8,R12
JZ 0x00101459
NOP
LAB_00101400:
LEA EDX,[R9 + -0x1]
MOV ESI,dword ptr [RBX + R8*0x4 + -... | void func0(long param_1,int param_2,int *param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
long lVar4;
long lVar5;
int iVar6;
long lVar7;
lVar7 = (long)param_2;
piVar2 = (int *)malloc(lVar7 * 4);
if (param_2 < 1) {
*param_3 = 0;
return;
}
lVar5 = 1;
iVar6 = 0;
if (lVar7 != 1) {
... |
6,531 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
void assertArrayEquals(int *expected, int expectedSize, int *actual, int actualSize) {
assert(expectedSize == actualSize);
for (int i = 0; i < expectedSize; i++) {
assert(expected[i] == actual[i]);
}
}
| int* func0(int x[], int size, int *returnSize) {
int *repeated = malloc(sizeof(int) * size);
int count = 0;
bool found;
for (int i = 0; i < size; i++) {
found = false;
for (int j = i + 1; j < size; j++) {
if (x[i] == x[j]) {
found = true;
... | int main() {
int arr1[] = {10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20};
int expected1[] = {20, 30, -20, 60};
int size1;
int *result1 = func0(arr1, 13, &size1);
assertArrayEquals(expected1, 4, result1, size1);
free(result1);
int arr2[] = {-1, 1, -1, 8};
int expect... | O3 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r9
test %ebp,%ebp
jle 1435 <func0+0xa5>
cmp $0x1,%ebp
je 1435 <func0+0xa5>
lea -0x2(%rbp),%r10d
mov $0x1,%edi
lea 0x4(%rax),%... | func0:
endbr64
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 2; size
call _malloc
test ebp, ebp
jle loc_1457
mov r11d, ebp
mov r8d, 1
xor r9d, r9d
cmp ebp, 1
jz short loc_1431
nop word ptr [rax+rax+00000000h]
loc_1... | _DWORD * func0(long long a1, int a2, int *a3)
{
_DWORD *result; // rax
long long v6; // r8
int v7; // r9d
int v8; // esi
long long v9; // rcx
_DWORD *v10; // rdx
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = 1LL;
v7 = 0;
if ( a2 != 1 )
{
while ( 2 ... | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBP,EBP
JLE 0x00101457
MOV R11D,EBP
MOV R8D,0x1
XOR R9D,R9D
CMP EBP,0x1
JZ 0x00101431
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013d0:
MOVSXD R10,R9D
MOV ESI,dword ptr [RBX + R8*0x4 + -0x4]
MOV RCX... | void func0(long param_1,uint param_2,int *param_3)
{
int iVar1;
int *piVar2;
ulong uVar3;
ulong uVar4;
int *piVar5;
ulong uVar6;
int iVar7;
piVar2 = (int *)malloc((long)(int)param_2 << 2);
if ((int)param_2 < 1) {
*param_3 = 0;
return;
}
uVar6 = 1;
iVar7 = 0;
if (param_2 != 1) {
LAB... |
6,532 | func0 | #include <assert.h>
| int func0(int l1, int r1, int l2, int r2, int *x, int *y) {
*x = (l1 != l2) ? ((l1 < l2) ? l1 : l2) : -1;
*y = (r1 != r2) ? ((r1 > r2) ? r1 : r2) : -1;
return 0;
}
| int main() {
int x, y;
func0(5, 10, 1, 5, &x, &y);
assert(x == 1 && y == 10);
func0(3, 5, 7, 9, &x, &y);
assert(x == 3 && y == 9);
func0(1, 5, 2, 8, &x, &y);
assert(x == 1 && y == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov %ecx,-0x10(%rbp)
mov %r8,-0x18(%rbp)
mov %r9,-0x20(%rbp)
mov -0x4(%rbp),%eax
cmp -0xc(%rbp),%eax
je 1199 <func0+0x30>
mov -0x4(%rbp),%eax
cmp %eax,-0xc(%rbp)
cmovle -0xc(%rbp),%e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov [rbp+var_10], ecx
mov [rbp+var_18], r8
mov [rbp+var_20], r9
mov eax, [rbp+var_4]
cmp eax, [rbp+var_C]
jz short loc_119A
mov edx, [rbp+var_C]
mov eax, [rbp+var_4]
cm... | long long func0(int a1, int a2, int a3, int a4, int *a5, int *a6)
{
int v6; // eax
int v7; // eax
if ( a1 == a3 )
{
v6 = -1;
}
else
{
v6 = a1;
if ( a3 <= a1 )
v6 = a3;
}
*a5 = v6;
if ( a2 == a4 )
{
v7 = -1;
}
else
{
v7 = a2;
if ( a4 >= a2 )
v7 = a4;
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x10],ECX
MOV qword ptr [RBP + -0x18],R8
MOV qword ptr [RBP + -0x20],R9
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0xc]
JZ 0x0010119a
MOV EDX,dword ptr [RB... | int8 func0(int param_1,int param_2,int param_3,int param_4,int *param_5,int *param_6)
{
if (param_1 == param_3) {
param_1 = -1;
}
else if (param_3 <= param_1) {
param_1 = param_3;
}
*param_5 = param_1;
if (param_2 == param_4) {
param_2 = -1;
}
else if (param_2 <= param_4) {
param_2 = pa... |
6,533 | func0 | #include <assert.h>
| int func0(int l1, int r1, int l2, int r2, int *x, int *y) {
*x = (l1 != l2) ? ((l1 < l2) ? l1 : l2) : -1;
*y = (r1 != r2) ? ((r1 > r2) ? r1 : r2) : -1;
return 0;
}
| int main() {
int x, y;
func0(5, 10, 1, 5, &x, &y);
assert(x == 1 && y == 10);
func0(3, 5, 7, 9, &x, &y);
assert(x == 3 && y == 9);
func0(1, 5, 2, 8, &x, &y);
assert(x == 1 && y == 8);
return 0;
}
| O1 | c | func0:
endbr64
mov $0xffffffff,%eax
cmp %edx,%edi
je 113b <func0+0x12>
mov %edx,%eax
cmovle %edi,%eax
mov %eax,(%r8)
mov $0xffffffff,%eax
cmp %ecx,%esi
je 114c <func0+0x23>
mov %ecx,%eax
cmovge %esi,%eax
mov %eax,(%r9)
mov $0x0,%eax
retq
| func0:
endbr64
mov eax, esi
cmp edi, edx
mov esi, edx
cmovle esi, edi
mov edx, 0FFFFFFFFh
cmovnz edx, esi
mov [r8], edx
cmp eax, ecx
mov edx, ecx
cmovge edx, eax
mov eax, 0FFFFFFFFh
cmovnz eax, edx
mov [r9], eax
mov eax, 0
retn | long long func0(int a1, int a2, int a3, int a4, int *a5, int *a6)
{
bool v7; // zf
int v8; // esi
int v9; // edx
bool v10; // zf
int v11; // edx
int v12; // eax
v7 = a1 == a3;
v8 = a3;
if ( a1 <= a3 )
v8 = a1;
v9 = -1;
if ( !v7 )
v9 = v8;
*a5 = v9;
v10 = a2 == a4;
v11 = a4;
if ( ... | func0:
ENDBR64
MOV EAX,ESI
CMP EDI,EDX
MOV ESI,EDX
CMOVLE ESI,EDI
MOV EDX,0xffffffff
CMOVNZ EDX,ESI
MOV dword ptr [R8],EDX
CMP EAX,ECX
MOV EDX,ECX
CMOVGE EDX,EAX
MOV EAX,0xffffffff
CMOVNZ EAX,EDX
MOV dword ptr [R9],EAX
MOV EAX,0x0
RET | int8 func0(int param_1,int param_2,int param_3,int param_4,int *param_5,int *param_6)
{
int iVar1;
int iVar2;
iVar2 = param_3;
if (param_1 == param_3 || param_1 < param_3) {
iVar2 = param_1;
}
iVar1 = -1;
if (param_1 != param_3) {
iVar1 = iVar2;
}
*param_5 = iVar1;
iVar2 = param_4;
if ... |
6,534 | func0 | #include <assert.h>
| int func0(int l1, int r1, int l2, int r2, int *x, int *y) {
*x = (l1 != l2) ? ((l1 < l2) ? l1 : l2) : -1;
*y = (r1 != r2) ? ((r1 > r2) ? r1 : r2) : -1;
return 0;
}
| int main() {
int x, y;
func0(5, 10, 1, 5, &x, &y);
assert(x == 1 && y == 10);
func0(3, 5, 7, 9, &x, &y);
assert(x == 3 && y == 9);
func0(1, 5, 2, 8, &x, &y);
assert(x == 1 && y == 8);
return 0;
}
| O2 | c | func0:
endbr64
mov $0xffffffff,%eax
cmp %edx,%edi
je 1152 <func0+0x12>
mov %edx,%eax
cmovle %edi,%eax
mov %eax,(%r8)
mov $0xffffffff,%eax
cmp %ecx,%esi
je 1163 <func0+0x23>
mov %ecx,%eax
cmovge %esi,%eax
mov %eax,(%r9)
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, edx
mov eax, esi
mov esi, edx
mov r10d, 0FFFFFFFFh
cmovle esi, edi
mov edx, ecx
cmovz esi, r10d
cmp eax, ecx
cmovge edx, eax
mov eax, r10d
mov [r8], esi
cmovnz eax, edx
mov [r9], eax
xor eax, eax
retn | long long func0(int a1, int a2, int a3, int a4, int *a5, int *a6)
{
bool v6; // zf
int v8; // esi
int v9; // edx
bool v10; // zf
int v11; // eax
v6 = a1 == a3;
v8 = a3;
if ( a1 <= a3 )
v8 = a1;
v9 = a4;
if ( v6 )
v8 = -1;
v10 = a2 == a4;
if ( a2 >= a4 )
v9 = a2;
v11 = -1;
*a5 =... | func0:
ENDBR64
CMP EDI,EDX
MOV EAX,ESI
MOV ESI,EDX
MOV R10D,0xffffffff
CMOVLE ESI,EDI
MOV EDX,ECX
CMOVZ ESI,R10D
CMP EAX,ECX
CMOVGE EDX,EAX
MOV EAX,R10D
MOV dword ptr [R8],ESI
CMOVNZ EAX,EDX
MOV dword ptr [R9],EAX
XOR EAX,EAX
RET | int8 func0(int param_1,int param_2,int param_3,int param_4,int *param_5,int *param_6)
{
int iVar1;
int iVar2;
iVar2 = param_3;
if (param_1 <= param_3) {
iVar2 = param_1;
}
if (param_1 == param_3) {
iVar2 = -1;
}
iVar1 = param_4;
if (param_4 <= param_2) {
iVar1 = param_2;
}
*param_5... |
6,535 | func0 | #include <assert.h>
| int func0(int l1, int r1, int l2, int r2, int *x, int *y) {
*x = (l1 != l2) ? ((l1 < l2) ? l1 : l2) : -1;
*y = (r1 != r2) ? ((r1 > r2) ? r1 : r2) : -1;
return 0;
}
| int main() {
int x, y;
func0(5, 10, 1, 5, &x, &y);
assert(x == 1 && y == 10);
func0(3, 5, 7, 9, &x, &y);
assert(x == 3 && y == 9);
func0(1, 5, 2, 8, &x, &y);
assert(x == 1 && y == 8);
return 0;
}
| O3 | c | func0:
endbr64
mov $0xffffffff,%eax
cmp %edx,%edi
je 1152 <func0+0x12>
mov %edx,%eax
cmovle %edi,%eax
mov %eax,(%r8)
mov $0xffffffff,%eax
cmp %ecx,%esi
je 1163 <func0+0x23>
mov %ecx,%eax
cmovge %esi,%eax
mov %eax,(%r9)
xor %eax,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, edx
mov eax, esi
mov esi, edx
mov r10d, 0FFFFFFFFh
cmovle esi, edi
mov edx, ecx
cmovz esi, r10d
cmp eax, ecx
cmovge edx, eax
mov eax, r10d
mov [r8], esi
cmovnz eax, edx
mov [r9], eax
xor eax, eax
retn | long long func0(int a1, int a2, int a3, int a4, int *a5, int *a6)
{
bool v6; // zf
int v8; // esi
int v9; // edx
bool v10; // zf
int v11; // eax
v6 = a1 == a3;
v8 = a3;
if ( a1 <= a3 )
v8 = a1;
v9 = a4;
if ( v6 )
v8 = -1;
v10 = a2 == a4;
if ( a2 >= a4 )
v9 = a2;
v11 = -1;
*a5 =... | func0:
ENDBR64
CMP EDI,EDX
MOV EAX,ESI
MOV ESI,EDX
MOV R10D,0xffffffff
CMOVLE ESI,EDI
MOV EDX,ECX
CMOVZ ESI,R10D
CMP EAX,ECX
CMOVGE EDX,EAX
MOV EAX,R10D
MOV dword ptr [R8],ESI
CMOVNZ EAX,EDX
MOV dword ptr [R9],EAX
XOR EAX,EAX
RET | int8 func0(int param_1,int param_2,int param_3,int param_4,int *param_5,int *param_6)
{
int iVar1;
int iVar2;
iVar2 = param_3;
if (param_1 <= param_3) {
iVar2 = param_1;
}
if (param_1 == param_3) {
iVar2 = -1;
}
iVar1 = param_4;
if (param_4 <= param_2) {
iVar1 = param_2;
}
*param_5... |
6,536 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int sum[n];
if (n >= 1)
sum[0] = arr[0];
if (n >= 2)
sum[1] = arr[0] + arr[1];
if (n > 2)
sum[2] = (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) > (arr[0] + arr[2]) ? (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) : (... | int main() {
assert(func0((int[]){100, 1000, 100, 1000, 1}, 5) == 2101);
assert(func0((int[]){3000, 2000, 1000, 3, 10}, 5) == 5013);
assert(func0((int[]){1, 2, 3, 4, 5, 6, 7, 8}, 8) == 27);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x4c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*... | long long func0(_DWORD *a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
int v4; // edx
int v5; // eax
int v6; // edx
int v7; // eax
_BYTE v9[4]; // [rsp+8h] [rbp-40h] BYREF
int v10; // [rsp+Ch] [rbp-3Ch]
_DWORD *v11; // [rsp+10h] [rbp-38h]
int i; // [rsp+20h] [rbp-28h]
int v13; // [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4... | int4 func0(int *param_1,int param_2)
{
long lVar1;
int iVar2;
int iVar3;
ulong uVar4;
int *puVar5;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
int *local_40;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_40 = par... |
6,537 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int sum[n];
if (n >= 1)
sum[0] = arr[0];
if (n >= 2)
sum[1] = arr[0] + arr[1];
if (n > 2)
sum[2] = (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) > (arr[0] + arr[2]) ? (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) : (... | int main() {
assert(func0((int[]){100, 1000, 100, 1000, 1}, 5) == 2101);
assert(func0((int[]){3000, 2000, 1000, 3, 10}, 5) == 5013);
assert(func0((int[]){1, 2, 3, 4, 5, 6, 7, 8}, 8) == 27);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rcx
sub %rax,%rcx
mov %rcx,%rax
cmp %rax,%rsp
je ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov rax, rdi
mov r8d, esi
mov rdx, fs:28h
mov [rbp+var_8], rdx
xor edx, edx
movsxd rdx, esi
lea rdx, ds:0Fh[rdx*4]
mov rsi, rdx
and rsi, 0FFFFFFFFFFFFFFF0h
and rdx, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rdx
loc_... | long long func0(int *a1, int a2)
{
long long v3; // rdx
__int16 v4; // si
signed long long v5; // rdx
void *v6; // rsp
int v7; // edx
int *v8; // rcx
_DWORD *v9; // rsi
int v10; // eax
long long v12; // [rsp+0h] [rbp-18h]
int v13; // [rsp+8h] [rbp-10h] BYREF
int v14; // [rsp+Ch] [rbp-Ch]
unsign... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,RDI
MOV R8D,ESI
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RDX
XOR EDX,EDX
MOVSXD RDX,ESI
LEA RDX,[0xf + RDX*0x4]
MOV RSI,RDX
AND RSI,-0x10
AND RDX,-0x1000
MOV RCX,RSP
SUB RCX,RDX
LAB_001011c9:
CMP RSP,RCX
JZ 0x001011e0
SUB RSP,0x1000
OR qword ptr [RS... | int4 func0(int *param_1,int param_2)
{
long lVar1;
int iVar2;
int *piVar3;
int iVar4;
int1 *puVar5;
ulong uVar6;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)param_2 * 4 + 0xf;
for (puVar5 = auStack_18; puVar5 != auStack_18 +... |
6,538 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int sum[n];
if (n >= 1)
sum[0] = arr[0];
if (n >= 2)
sum[1] = arr[0] + arr[1];
if (n > 2)
sum[2] = (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) > (arr[0] + arr[2]) ? (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) : (... | int main() {
assert(func0((int[]){100, 1000, 100, 1000, 1}, 5) == 2101);
assert(func0((int[]){3000, 2000, 1000, 3, 10}, 5) == 5013);
assert(func0((int[]){1, 2, 3, 4, 5, 6, 7, 8}, 8) == 27);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je ... | func0:
endbr64
push rbp
mov r8d, esi
mov rax, rdi
mov rbp, rsp
sub rsp, 10h
mov rdx, fs:28h
mov [rbp+var_8], rdx
xor edx, edx
movsxd rdx, esi
mov rsi, rsp
lea rdx, ds:0Fh[rdx*4]
mov rcx, rdx
and rdx, 0FFFFFFFFFFFFF000h
sub rsi, rdx
and rcx, 0FFFFFFFFFFFFFFF0h
cmp ... | long long func0(int *a1, int a2)
{
long long v3; // rcx
_DWORD *v4; // rsi
__int16 v5; // cx
signed long long v6; // rcx
void *v7; // rsp
int v8; // edx
int v9; // ecx
int v10; // esi
int v11; // edx
int v12; // ecx
_DWORD *v13; // rsi
_DWORD *v14; // rcx
int v15; // edx
int v16; // eax
i... | func0:
ENDBR64
PUSH RBP
MOV R8D,ESI
MOV RAX,RDI
MOV RBP,RSP
SUB RSP,0x10
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RDX
XOR EDX,EDX
MOVSXD RDX,ESI
MOV RSI,RSP
LEA RDX,[0xf + RDX*0x4]
MOV RCX,RDX
AND RDX,-0x1000
SUB RSI,RDX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x0010134a
LAB_00101335:
SUB RSP,0x1000
OR qword ptr [RS... | int4 func0(int *param_1,int param_2)
{
long lVar1;
int1 *puVar2;
int iVar3;
int iVar4;
int *piVar5;
int *piVar6;
int iVar7;
int1 *puVar8;
int iVar10;
ulong uVar11;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar9;
puVar8 = auStack_18;
local_10 = *(long *)(in_FS_OFF... |
6,539 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int sum[n];
if (n >= 1)
sum[0] = arr[0];
if (n >= 2)
sum[1] = arr[0] + arr[1];
if (n > 2)
sum[2] = (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) > (arr[0] + arr[2]) ? (sum[1] > (arr[1] + arr[2]) ? sum[1] : (arr[1] + arr[2])) : (... | int main() {
assert(func0((int[]){100, 1000, 100, 1000, 1}, 5) == 2101);
assert(func0((int[]){3000, 2000, 1000, 3, 10}, 5) == 5013);
assert(func0((int[]){1, 2, 3, 4, 5, 6, 7, 8}, 8) == 27);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffff... | func0:
endbr64
push rbp
mov r9, rdi
mov r8d, esi
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub ... | long long func0(int *a1, int a2)
{
long long v3; // rdx
_DWORD *v4; // rcx
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
int v8; // ecx
int v9; // eax
int v10; // edi
int v11; // r10d
int v12; // edx
int v13; // eax
int *v14; // rbx
int *v15; // r11
long long v16; // rax
... | func0:
ENDBR64
PUSH RBP
MOV R9,RDI
MOV R8D,ESI
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101320
LAB_00101... | int4 func0(int *param_1,int param_2)
{
long lVar1;
int *puVar2;
int iVar3;
long lVar4;
int iVar5;
int *piVar6;
int *puVar7;
int iVar9;
int iVar10;
ulong uVar11;
int *piVar12;
int iVar13;
int iVar14;
int iVar15;
long in_FS_OFFSET;
int auStack_38 [8];
long local_30;
int *puVar8;
... |
6,540 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* key;
int* values;
int size;
} Item;
typedef struct {
Item* items;
int size;
} Dict;
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
void sortArray(int arr[],... | Dict func0(Dict dict) {
for (int i = 0; i < dict.size; i++) {
sortArray(dict.items[i].values, dict.items[i].size);
}
return dict;
}
| int main() {
Item items1[3] = {{ "n1", (int[]){2, 3, 1}, 3 }, { "n2", (int[]){5, 1, 2}, 3 }, { "n3", (int[]){3, 2, 4}, 3 }};
Dict dict1 = { items1, 3 };
Dict expected1 = { (Item[]){ {"n1", (int[]){1, 2, 3}, 3}, {"n2", (int[]){1, 2, 5}, 3}, {"n3", (int[]){2, 3, 4}, 3} }, 3 };
Item items2[3] = {{ "n1", (i... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,%rax
mov %rsi,%rcx
mov %rcx,%rdx
mov %rax,-0x20(%rbp)
mov %rdx,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 147a <func0+0x6f>
mov -0x20(%rbp),%rcx
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov rax, rdi
mov rcx, rsi
mov rdx, rcx
mov [rbp+var_20], rax
mov [rbp+var_18], rdx
mov [rbp+var_4], 0
jmp short loc_147A
loc_1431:
mov rcx, [rbp+var_20]
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, rdx
add rax, ra... | long long func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
sortArray(*(_QWORD *)(a1 + 24LL * i + 8), *(unsigned int *)(a1 + 24LL * i + 16));
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV RAX,RDI
MOV RCX,RSI
MOV RDX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010147a
LAB_00101431:
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,R... | int [16] func0(long param_1,int8 param_2)
{
int auVar1 [16];
int4 local_20;
int4 uStack_1c;
int4 local_c;
local_20 = (int)param_2;
uStack_1c = (int4)((ulong)param_2 >> 0x20);
for (local_c = 0; local_c < local_20; local_c = local_c + 1) {
sortArray(*(int8 *)((long)local_c * 0x18 + param_1 + 8),
... |
6,541 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* key;
int* values;
int size;
} Item;
typedef struct {
Item* items;
int size;
} Dict;
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
void sortArray(int arr[],... | Dict func0(Dict dict) {
for (int i = 0; i < dict.size; i++) {
sortArray(dict.items[i].values, dict.items[i].size);
}
return dict;
}
| int main() {
Item items1[3] = {{ "n1", (int[]){2, 3, 1}, 3 }, { "n2", (int[]){5, 1, 2}, 3 }, { "n3", (int[]){3, 2, 4}, 3 }};
Dict dict1 = { items1, 3 };
Dict expected1 = { (Item[]){ {"n1", (int[]){1, 2, 3}, 3}, {"n2", (int[]){1, 2, 5}, 3}, {"n3", (int[]){2, 3, 4}, 3} }, 3 };
Item items2[3] = {{ "n1", (i... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r13
mov %rsi,%r12
test %esi,%esi
jle 12be <func0+0x38>
lea 0x8(%rdi),%rbx
lea -0x1(%rsi),%eax
lea (%rax,%rax,2),%rax
lea 0x20(%rdi,%rax,8),%rbp
mov 0x8(%rbx),%esi
mov (%rbx),%rdi
callq 1196 <sortArray>
add $0x18,%r... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov r12, rsi
test esi, esi
jle short loc_12CD
lea rbx, [rdi+8]
lea eax, [rsi-1]
lea rax, [rax+rax*2]
lea rbp, [rdi+rax*8+20h]
loc_12B9:
mov esi, [rbx+8]
mov rdi, [rbx]
call sortArray
add ... | long long func0(long long a1, int a2)
{
long long v2; // rbx
if ( a2 > 0 )
{
v2 = a1 + 8;
do
{
sortArray(*(_QWORD *)v2, *(unsigned int *)(v2 + 8));
v2 += 24LL;
}
while ( v2 != a1 + 24LL * (unsigned int)(a2 - 1) + 32 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV R12,RSI
TEST ESI,ESI
JLE 0x001012cd
LEA RBX,[RDI + 0x8]
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x2]
LEA RBP,[RDI + RAX*0x8 + 0x20]
LAB_001012b9:
MOV ESI,dword ptr [RBX + 0x8]
MOV RDI,qword ptr [RBX]
CALL 0x00101196
ADD RBX,0x18
CMP RBX,RBP
... | int1 [16] func0(long param_1,int8 param_2)
{
int8 *puVar1;
int1 auVar2 [16];
if (0 < (int)param_2) {
puVar1 = (int8 *)(param_1 + 8);
do {
sortArray(*puVar1,*(int4 *)(puVar1 + 1));
puVar1 = puVar1 + 3;
} while (puVar1 != (int8 *)(param_1 + 0x20 + (ulong)((int)param_2 - 1) * 0x18));
}... |
6,542 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* key;
int* values;
int size;
} Item;
typedef struct {
Item* items;
int size;
} Dict;
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
void sortArray(int arr[],... | Dict func0(Dict dict) {
for (int i = 0; i < dict.size; i++) {
sortArray(dict.items[i].values, dict.items[i].size);
}
return dict;
}
| int main() {
Item items1[3] = {{ "n1", (int[]){2, 3, 1}, 3 }, { "n2", (int[]){5, 1, 2}, 3 }, { "n3", (int[]){3, 2, 4}, 3 }};
Dict dict1 = { items1, 3 };
Dict expected1 = { (Item[]){ {"n1", (int[]){1, 2, 3}, 3}, {"n2", (int[]){1, 2, 5}, 3}, {"n3", (int[]){2, 3, 4}, 3} }, 3 };
Item items2[3] = {{ "n1", (i... | O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
push %r12
mov %rsi,%r12
test %esi,%esi
jle 181d <func0+0x3d>
lea -0x1(%rsi),%eax
lea 0x8(%rdi),%r10
lea (%rax,%rax,2),%rax
lea 0x20(%rdi,%rax,8),%r11
nopw 0x0(%rax,%rax,1)
mov 0x8(%r10),%esi
mov (%r10),%rdi
callq 1700 <sortArray>
add $0x18,%r... | func0:
endbr64
push r13
mov r13, rdi
push r12
mov r12, rsi
sub rsp, 8
test esi, esi
jle short loc_1825
lea eax, [rsi-1]
lea r10, [rdi+8]
lea rax, [rax+rax*2]
lea r11, [rdi+rax*8+20h]
nop word ptr [rax+rax+00000000h]
loc_1810:
mov esi, [r10+8]
mov rdi, [r10]
add r... | long long func0(long long a1, int a2)
{
long long v2; // r10
long long v3; // r11
if ( a2 > 0 )
{
v2 = a1 + 8;
do
sortArray(*(_QWORD *)v2, *(unsigned int *)(v2 + 8));
while ( v2 != v3 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12,RSI
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101825
LEA EAX,[RSI + -0x1]
LEA R10,[RDI + 0x8]
LEA RAX,[RAX + RAX*0x2]
LEA R11,[RDI + RAX*0x8 + 0x20]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101810:
MOV ESI,dword ptr [R10 + 0x8]
MOV RDI,qword ptr [R10]
ADD R10,0x18
CALL 0x0010170... | int1 [16] func0(long param_1,int8 param_2)
{
int8 *puVar1;
int8 uVar2;
int8 *puVar3;
int8 *puVar4;
int1 auVar5 [16];
if (0 < (int)param_2) {
puVar3 = (int8 *)(param_1 + 8);
puVar4 = (int8 *)(param_1 + 0x20 + (ulong)((int)param_2 - 1) * 0x18);
do {
puVar1 = puVar3 + 1;
uVar2 = *p... |
6,543 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* key;
int* values;
int size;
} Item;
typedef struct {
Item* items;
int size;
} Dict;
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
void sortArray(int arr[],... | Dict func0(Dict dict) {
for (int i = 0; i < dict.size; i++) {
sortArray(dict.items[i].values, dict.items[i].size);
}
return dict;
}
| int main() {
Item items1[3] = {{ "n1", (int[]){2, 3, 1}, 3 }, { "n2", (int[]){5, 1, 2}, 3 }, { "n3", (int[]){3, 2, 4}, 3 }};
Dict dict1 = { items1, 3 };
Dict expected1 = { (Item[]){ {"n1", (int[]){1, 2, 3}, 3}, {"n2", (int[]){1, 2, 5}, 3}, {"n3", (int[]){2, 3, 4}, 3} }, 3 };
Item items2[3] = {{ "n1", (i... | O3 | c | func0:
endbr64
push %r13
mov %rdi,%r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
test %esi,%esi
jle 18a9 <func0+0x79>
lea -0x1(%rsi),%eax
lea 0x8(%rdi),%r9
lea (%rax,%rax,2),%rax
lea 0x20(%rdi,%rax,8),%rbp
nopl 0x0(%rax)
mov 0x8(%r9),%esi
mov (%r9),%rax
lea -0x1(%rsi),%ecx
te... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
test esi, esi
jle short loc_18B8
movsxd rax, esi
lea r10, [rdi+8]
lea rax, [rax+rax*2]
lea r11, [r10+rax*8]
nop
loc_1860:
mov edi, [r10+8]
mov r8, [r10]
cmp edi, 1
jle short loc_18AF
lea r9, [r8+4]
loc_1870:... | long long func0(long long a1, int a2)
{
long long v3; // r10
long long v4; // r11
int v5; // edi
__m128i *v6; // r8
__m128i *v7; // rax
__m128i v8; // xmm0
if ( a2 > 0 )
{
v3 = a1 + 8;
v4 = a1 + 8 + 24LL * a2;
do
{
v5 = *(_DWORD *)(v3 + 8);
v6 = *(__m128i **)v3;
if ( ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
TEST ESI,ESI
JLE 0x001018b8
MOVSXD RAX,ESI
LEA R10,[RDI + 0x8]
LEA RAX,[RAX + RAX*0x2]
LEA R11,[R10 + RAX*0x8]
NOP
LAB_00101860:
MOV EDI,dword ptr [R10 + 0x8]
MOV R8,qword ptr [R10]
CMP EDI,0x1
JLE 0x001018af
LEA R9,[R8 + 0x4]
LAB_00101870:
CMP EDI,0x1
JLE 0x0010... | int [16] func0(long param_1,int8 param_2)
{
int8 *puVar1;
int8 *puVar2;
int8 *puVar3;
int iVar4;
int8 *puVar5;
int iVar6;
int iVar7;
int auVar8 [16];
if (0 < (int)param_2) {
puVar5 = (int8 *)(param_1 + 8);
puVar1 = puVar5 + (long)(int)param_2 * 3;
do {
iVar4 = *(int *)(puVar5 + ... |
6,544 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int n, int x, int y) {
int ans = INT_MIN;
for (int k = 0; k <= n; k++) {
if (k % x == y) {
if (ans < k) {
ans = k;
}
}
}
return ((ans >= 0 && ans <= n) ? ans : -1);
}
| int main() {
assert(func0(15, 10, 5) == 15);
assert(func0(187, 10, 5) == 185);
assert(func0(16, 11, 1) == 12);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
movl $0x80000000,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 118a <func0+0x41>
mov -0x4(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %edx,%eax
cmp %eax,-0x1c(%rbp)
jne 1186 <func0+0x3d>
mov -0x8(%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_8], 80000000h
mov [rbp+var_4], 0
jmp short loc_118A
loc_116A:
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_18]
mov eax, edx
cmp [rbp+var_1C], eax
jnz short loc_... | long long func0(int a1, int a2, int a3)
{
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = 0x80000000;
for ( i = 0; i <= a1; ++i )
{
if ( a3 == i % a2 && v4 < i )
v4 = i;
}
if ( v4 < 0 || v4 > a1 )
return 0xFFFFFFFFLL;
else
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x8],0x80000000
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010118a
LAB_0010116a:
MOV EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV EAX,EDX
CMP dword ptr ... | int func0(int param_1,int param_2,int param_3)
{
int local_10;
int local_c;
local_10 = -0x80000000;
for (local_c = 0; local_c <= param_1; local_c = local_c + 1) {
if ((param_3 == local_c % param_2) && (local_10 < local_c)) {
local_10 = local_c;
}
}
if ((local_10 < 0) || (param_1 < local_10... |
6,545 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int n, int x, int y) {
int ans = INT_MIN;
for (int k = 0; k <= n; k++) {
if (k % x == y) {
if (ans < k) {
ans = k;
}
}
}
return ((ans >= 0 && ans <= n) ? ans : -1);
}
| int main() {
assert(func0(15, 10, 5) == 15);
assert(func0(187, 10, 5) == 185);
assert(func0(16, 11, 1) == 12);
return 0;
}
| O1 | c | func0:
endbr64
mov %edx,%r9d
test %edi,%edi
js 118e <func0+0x45>
lea 0x1(%rdi),%r10d
mov $0x0,%ecx
mov $0x80000000,%r8d
jmp 116d <func0+0x24>
add $0x1,%ecx
cmp %ecx,%r10d
je 1180 <func0+0x37>
mov %ecx,%eax
cltd
idiv %esi
cmp %r9d,%edx
jne 1165 <func0+0x1c>
cmp %ecx,%r8d
cmov... | func0:
endbr64
mov r9d, edx
test edi, edi
js short loc_118E
lea r10d, [rdi+1]
mov ecx, 0
mov r8d, 80000000h
loc_1163:
mov eax, ecx
cdq
idiv esi
cmp r8d, ecx
mov eax, ecx
cmovge eax, r8d
cmp edx, r9d
cmovz r8d, eax
add ecx, 1
cmp r10d, ecx
jnz short loc_1163
test... | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
int v4; // r8d
int v5; // eax
if ( a1 < 0 )
{
return (unsigned int)-1;
}
else
{
v3 = 0;
v4 = 0x80000000;
do
{
v5 = v3;
if ( v4 >= v3 )
v5 = v4;
if ( v3 % a2 == a3 )
v4 = v5;
++v3;
}... | func0:
ENDBR64
MOV R9D,EDX
TEST EDI,EDI
JS 0x0010118e
LEA R10D,[RDI + 0x1]
MOV ECX,0x0
MOV R8D,0x80000000
LAB_00101163:
MOV EAX,ECX
CDQ
IDIV ESI
CMP R8D,ECX
MOV EAX,ECX
CMOVGE EAX,R8D
CMP EDX,R9D
CMOVZ R8D,EAX
ADD ECX,0x1
CMP R10D,ECX
JNZ 0x00101163
TEST R8D,R8D
JS 0x00101196
CMP R8D,EDI
JG 0x00101196
LAB_0010118a:
MOV... | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
if (param_1 < 0) {
iVar3 = -1;
}
else {
iVar2 = 0;
iVar3 = -0x80000000;
do {
iVar1 = iVar2;
if (iVar2 <= iVar3) {
iVar1 = iVar3;
}
if (iVar2 % param_2 == param_3) {
i... |
6,546 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int n, int x, int y) {
int ans = INT_MIN;
for (int k = 0; k <= n; k++) {
if (k % x == y) {
if (ans < k) {
ans = k;
}
}
}
return ((ans >= 0 && ans <= n) ? ans : -1);
}
| int main() {
assert(func0(15, 10, 5) == 15);
assert(func0(187, 10, 5) == 185);
assert(func0(16, 11, 1) == 12);
return 0;
}
| O2 | c | func0:
endbr64
mov %edx,%r9d
test %edi,%edi
js 12c0 <func0+0x50>
lea 0x1(%rdi),%r10d
xor %ecx,%ecx
mov $0x80000000,%r8d
nopw 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %esi
cmp %r9d,%edx
jne 12a1 <func0+0x31>
cmp %ecx,%r8d
cmovl %ecx,%r8d
add $0x1,%ecx
cmp %ecx,%r10d
jne 1290 <... | func0:
endbr64
mov r9d, edx
test edi, edi
js short loc_1260
lea r10d, [rdi+1]
xor ecx, ecx
mov r8d, 80000000h
nop word ptr [rax+rax+00000000h]
loc_1230:
mov eax, ecx
cdq
idiv esi
cmp r8d, ecx
mov eax, ecx
cmovge eax, r8d
cmp edx, r9d
cmovz r8d, eax
add ecx, 1
cmp ... | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
int v4; // r8d
int v5; // eax
if ( a1 < 0 )
return 0xFFFFFFFFLL;
v3 = 0;
v4 = 0x80000000;
do
{
v5 = v3;
if ( v4 >= v3 )
v5 = v4;
if ( v3 % a2 == a3 )
v4 = v5;
++v3;
}
while ( a1 + 1 != v3 );
if ( v4 < 0 || v... | func0:
ENDBR64
MOV R9D,EDX
TEST EDI,EDI
JS 0x00101260
LEA R10D,[RDI + 0x1]
XOR ECX,ECX
MOV R8D,0x80000000
NOP word ptr [RAX + RAX*0x1]
LAB_00101230:
MOV EAX,ECX
CDQ
IDIV ESI
CMP R8D,ECX
MOV EAX,ECX
CMOVGE EAX,R8D
CMP EDX,R9D
CMOVZ R8D,EAX
ADD ECX,0x1
CMP R10D,ECX
JNZ 0x00101230
TEST R8D,R8D
JS 0x00101260
CMP R8D,EDI
JG... | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
if (-1 < param_1) {
iVar2 = 0;
iVar3 = -0x80000000;
do {
iVar1 = iVar2;
if (iVar2 <= iVar3) {
iVar1 = iVar3;
}
if (iVar2 % param_2 == param_3) {
iVar3 = iVar1;
}
... |
6,547 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int n, int x, int y) {
int ans = INT_MIN;
for (int k = 0; k <= n; k++) {
if (k % x == y) {
if (ans < k) {
ans = k;
}
}
}
return ((ans >= 0 && ans <= n) ? ans : -1);
}
| int main() {
assert(func0(15, 10, 5) == 15);
assert(func0(187, 10, 5) == 185);
assert(func0(16, 11, 1) == 12);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%r9d
test %edi,%edi
js 1200 <func0+0x50>
lea 0x1(%rdi),%r10d
xor %ecx,%ecx
mov $0x80000000,%r8d
nopw 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %esi
cmp %edx,%r9d
jne 11e1 <func0+0x31>
cmp %ecx,%r8d
cmovl %ecx,%r8d
add $0x1,%ecx
cmp %r10d,%ecx
jne 11d0 <... | func0:
endbr64
mov r9d, edx
test edi, edi
js short loc_1200
lea r10d, [rdi+1]
xor ecx, ecx
mov r8d, 80000000h
nop word ptr [rax+rax+00000000h]
loc_11D0:
mov eax, ecx
cdq
idiv esi
cmp r8d, ecx
mov eax, ecx
cmovge eax, r8d
cmp edx, r9d
cmovz r8d, eax
add ecx, 1
cmp ... | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
int v4; // r8d
int v5; // eax
if ( a1 < 0 )
return 0xFFFFFFFFLL;
v3 = 0;
v4 = 0x80000000;
do
{
v5 = v3;
if ( v4 >= v3 )
v5 = v4;
if ( v3 % a2 == a3 )
v4 = v5;
++v3;
}
while ( a1 + 1 != v3 );
if ( v4 < 0 || v... | func0:
ENDBR64
MOV R9D,EDX
TEST EDI,EDI
JS 0x00101200
LEA R10D,[RDI + 0x1]
XOR ECX,ECX
MOV R8D,0x80000000
NOP word ptr [RAX + RAX*0x1]
LAB_001011d0:
MOV EAX,ECX
CDQ
IDIV ESI
CMP R8D,ECX
MOV EAX,ECX
CMOVGE EAX,R8D
CMP EDX,R9D
CMOVZ R8D,EAX
ADD ECX,0x1
CMP R10D,ECX
JNZ 0x001011d0
TEST R8D,R8D
JS 0x00101200
CMP R8D,EDI
JG... | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
if (-1 < param_1) {
iVar2 = 0;
iVar3 = -0x80000000;
do {
iVar1 = iVar2;
if (iVar2 <= iVar3) {
iVar1 = iVar3;
}
if (iVar2 % param_2 == param_3) {
iVar3 = iVar1;
}
... |
6,548 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0, count = 0;
while (n >= 2) {
count += 1;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(2) == 2);
assert(func0(4) == 3);
assert(func0(100) == 51);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 1195 <func0+0x2c>
lea 0xe7f(%rip),%rdi
callq 1060 <puts@plt>
mov $0xffffffff,%eax
jmp 11c0 <func0+0x57>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jz short loc_1198
lea rax, s; "Invalid Input"
mov rdi, rax; s
call _puts
mov eax, 0FFFFFFFFh
jmp short locret_11C3
loc_1198:
mov [rbp+var_8], 0
mov... | long long func0(int a1)
{
int v2; // [rsp+Ch] [rbp-14h]
int v3; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
v2 = a1;
if ( (a1 & 1) != 0 )
{
puts("Invalid Input");
return 0xFFFFFFFFLL;
}
else
{
v3 = 0;
v4 = 0;
while ( v2 > 1 )
{
++v4;
v3 += v2;
v2 -= ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JZ 0x00101198
LEA RAX,[0x102004]
MOV RDI,RAX
CALL 0x00101060
MOV EAX,0xffffffff
JMP 0x001011c3
LAB_00101198:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101... | ulong func0(uint param_1)
{
ulong uVar1;
uint local_1c;
int local_10;
int local_c;
if ((param_1 & 1) == 0) {
local_10 = 0;
local_c = 0;
for (local_1c = param_1; 1 < (int)local_1c; local_1c = local_1c - 2) {
local_c = local_c + 1;
local_10 = local_10 + local_1c;
}
uVar1 = (l... |
6,549 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0, count = 0;
while (n >= 2) {
count += 1;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(2) == 2);
assert(func0(4) == 3);
assert(func0(100) == 51);
return 0;
}
| O1 | c | func0:
endbr64
test $0x1,%dil
jne 119c <func0+0x33>
mov %edi,%ecx
mov $0x0,%eax
cmp $0x1,%edi
jle 1195 <func0+0x2c>
add %edi,%eax
sub $0x2,%edi
cmp $0x1,%edi
jg 117f <func0+0x16>
sub $0x2,%ecx
shr %ecx
add $0x1,%ecx
cltd
idiv %ecx
retq
mov $0x0,%ecx
jmp 1191 <func0+0x28>
s... | func0:
endbr64
test dil, 1
jnz short loc_119C
mov ecx, edi
mov eax, 0
cmp edi, 1
jle short loc_1195
loc_117F:
add eax, edi
sub edi, 2
cmp edi, 1
jg short loc_117F
sub ecx, 2
shr ecx, 1
add ecx, 1
loc_1191:
cdq
idiv ecx
retn
loc_1195:
mov ecx, 0
jmp short lo... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
signed int v3; // ecx
if ( (a1 & 1) != 0 )
{
puts("Invalid Input");
return 0xFFFFFFFFLL;
}
else
{
v1 = a1;
v2 = 0;
if ( a1 <= 1 )
{
v3 = 0;
}
else
{
do
{
v2 += a1;
a1 -= 2;
... | func0:
ENDBR64
TEST DIL,0x1
JNZ 0x0010119c
MOV ECX,EDI
MOV EAX,0x0
CMP EDI,0x1
JLE 0x00101195
LAB_0010117f:
ADD EAX,EDI
SUB EDI,0x2
CMP EDI,0x1
JG 0x0010117f
SUB ECX,0x2
SHR ECX,0x1
ADD ECX,0x1
LAB_00101191:
CDQ
IDIV ECX
RET
LAB_00101195:
MOV ECX,0x0
JMP 0x00101191
LAB_0010119c:
SUB RSP,0x8
LEA RDI,[0x102004]
CALL 0x00... | int1 [16] func0(uint param_1)
{
int iVar1;
int iVar2;
int8 extraout_RDX;
uint uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
if ((param_1 & 1) == 0) {
iVar1 = 0;
uVar3 = param_1;
if ((int)param_1 < 2) {
iVar2 = 0;
}
else {
do {
iVar1 = iVar1 + uVar3;
uVar3 ... |
6,550 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0, count = 0;
while (n >= 2) {
count += 1;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(2) == 2);
assert(func0(4) == 3);
assert(func0(100) == 51);
return 0;
}
| O2 | c | func0:
endbr64
test $0x1,%dil
jne 119e <func0+0x2e>
cmp $0x1,%edi
jle 11b8 <func0+0x48>
mov %edi,%ecx
xor %eax,%eax
nopl 0x0(%rax,%rax,1)
add %edi,%eax
sub $0x2,%edi
cmp $0x1,%edi
jg 1188 <func0+0x18>
sub $0x2,%ecx
cltd
shr %ecx
add $0x1,%ecx
idiv %ecx
retq
sub $0x8,%rsp
le... | func0:
endbr64
test dil, 1
jnz short loc_119E
cmp edi, 1
jle short loc_11B8
mov ecx, edi
xor eax, eax
nop dword ptr [rax+rax+00h]
loc_1188:
add eax, edi
sub edi, 2
cmp edi, 1
jg short loc_1188
sub ecx, 2
cdq
shr ecx, 1
add ecx, 1
idiv ecx
retn
loc_119E:
sub ... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
if ( (a1 & 1) != 0 )
{
puts("Invalid Input");
return 0xFFFFFFFFLL;
}
else
{
if ( a1 <= 1 )
func0_cold();
v1 = a1;
v2 = 0;
do
{
v2 += a1;
a1 -= 2;
}
while ( a1 > 1 );
return (unsigned int)(v2... | func0:
ENDBR64
TEST DIL,0x1
JNZ 0x0010119e
CMP EDI,0x1
JLE 0x001011b8
MOV ECX,EDI
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101188:
ADD EAX,EDI
SUB EDI,0x2
CMP EDI,0x1
JG 0x00101188
SUB ECX,0x2
CDQ
SHR ECX,0x1
ADD ECX,0x1
IDIV ECX
RET
LAB_0010119e:
SUB RSP,0x8
LEA RDI,[0x102004]
CALL 0x00101050
MOV EAX,0xffffffff... | int1 [16] func0(uint param_1)
{
long lVar1;
int iVar2;
int8 extraout_RDX;
uint uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
if ((param_1 & 1) != 0) {
puts("Invalid Input");
auVar5._8_8_ = extraout_RDX;
auVar5._0_8_ = 0xffffffff;
return auVar5;
}
if (1 < (int)param_1) {
iVar2 = 0... |
6,551 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
printf("Invalid Input\n");
return -1;
}
int sm = 0, count = 0;
while (n >= 2) {
count += 1;
sm += n;
n -= 2;
}
return sm / count;
}
| int main() {
assert(func0(2) == 2);
assert(func0(4) == 3);
assert(func0(100) == 51);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
and $0x1,%eax
jne 1224 <func0+0xb4>
cmp $0x1,%edi
jle 123e <func0+0xce>
lea -0x2(%rdi),%edx
mov %edx,%ecx
shr %ecx
add $0x1,%ecx
cmp $0x23,%edx
jbe 1220 <func0+0xb0>
movd %edi,%xmm4
mov %ecx,%edx
movdqa 0xe87(%rip),%xmm3
pxor %xmm0,%xmm0
pshufd $0x0,%... | func0:
endbr64
mov eax, edi
and eax, 1
jnz loc_1263
mov edx, edi
cmp edi, 1
jle loc_127D
lea ecx, [rdi-2]
mov esi, ecx
shr esi, 1
add esi, 1
cmp ecx, 13h
jbe short loc_1204
movd xmm4, edi
mov ecx, esi
movdqa xmm3, cs:xmmword_2030
xor eax, eax
pshufd xmm0, xmm... | long long func0(long long a1, long long a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
signed int v5; // esi
__m128i si128; // xmm3
int v7; // eax
__m128i v8; // xmm0
__m128i v9; // xmm1
__m128i v10; // xmm2
__m128i v11; // xmm1
int v12; // edx
v2 = a1 & 1;
if ( (a1 & 1) == 0 )
{
v... | func0:
ENDBR64
MOV EAX,EDI
AND EAX,0x1
JNZ 0x00101263
MOV EDX,EDI
CMP EDI,0x1
JLE 0x0010127d
LEA ECX,[RDI + -0x2]
MOV ESI,ECX
SHR ESI,0x1
ADD ESI,0x1
CMP ECX,0x13
JBE 0x00101204
MOVD XMM4,EDI
MOV ECX,ESI
MOVDQA XMM3,xmmword ptr [0x00102030]
XOR EAX,EAX
PSHUFD XMM0,XMM4,0x0
PADDD XMM0,xmmword ptr [0x00102020]
SHR ECX,0x... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int [16] func0(uint param_1)
{
uint uVar1;
uint uVar2;
uint uVar3;
int8 extraout_RDX;
uint uVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int auVar13 [16... |
6,552 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *num_list, int n, int *output) {
int first_element = num_list[0];
int count_first = 0;
int output_index = 0;
// count occurrences of the first element
for (int i = 0; i < n; i++) {
if (num_list[i] == first_element) {
count_first++;
}
}
... | int main() {
int test1[] = {1, 2, 3, 4};
int result1[4];
func0(test1, 4, result1);
assert(result1[0] == 2 && result1[1] == 3 && result1[2] == 4 && result1[3] == 1);
int test2[] = {2, 3, 4, 1, 5, 0};
int result2[6];
func0(test2, 6, result2);
assert(result2[0] == 3 && result2[1] ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11bf <func0+0x56>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_11BF
loc_119C:
mov eax, [rbp+var_1... | long long func0(int *a1, int a2, long long a3)
{
int v3; // eax
int v4; // eax
long long result; // rax
int v6; // [rsp+20h] [rbp-18h]
int v7; // [rsp+24h] [rbp-14h]
int i; // [rsp+28h] [rbp-10h]
int j; // [rsp+2Ch] [rbp-Ch]
unsigned int k; // [rsp+30h] [rbp-8h]
int v11; // [rsp+34h] [rbp-4h]
v11 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0... | void func0(int *param_1,int param_2,long param_3)
{
int iVar1;
int local_20;
int local_1c;
int local_18;
int local_14;
int local_10;
iVar1 = *param_1;
local_20 = 0;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
if (iVar1 == param_1[local_18]) {
local_2... |
6,553 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *num_list, int n, int *output) {
int first_element = num_list[0];
int count_first = 0;
int output_index = 0;
// count occurrences of the first element
for (int i = 0; i < n; i++) {
if (num_list[i] == first_element) {
count_first++;
}
}
... | int main() {
int test1[] = {1, 2, 3, 4};
int result1[4];
func0(test1, 4, result1);
assert(result1[0] == 2 && result1[1] == 3 && result1[2] == 4 && result1[3] == 1);
int test2[] = {2, 3, 4, 1, 5, 0};
int result2[6];
func0(test2, 6, result2);
assert(result2[0] == 3 && result2[1] ... | O1 | c | func0:
endbr64
mov (%rdi),%ecx
test %esi,%esi
jle 11df <func0+0x76>
mov %rdi,%rax
lea -0x1(%rsi),%esi
lea 0x4(%rdi,%rsi,4),%r9
mov $0x0,%r8d
cmp %ecx,(%rdi)
sete %sil
movzbl %sil,%esi
add %esi,%r8d
add $0x4,%rdi
cmp %r9,%rdi
jne 1184 <func0+0x1b>
mov $0x0,%edi
jmp 11b4 <func0+... | func0:
endbr64
mov r10, rdx
mov edx, [rdi]
test esi, esi
jle short locret_11E0
mov rax, rdi
lea ecx, [rsi-1]
lea r9, [rdi+rcx*4+4]
mov r8d, 0
loc_1187:
cmp [rdi], edx
setz cl
movzx ecx, cl
add r8d, ecx
add rdi, 4
cmp rdi, r9
jnz short loc_1187
mov esi, 0
jmp ... | void func0(_DWORD *a1, int a2, long long a3)
{
int v4; // edx
_DWORD *v5; // rax
long long v6; // r9
int v7; // r8d
int v8; // esi
_DWORD *v9; // rax
v4 = *a1;
if ( a2 > 0 )
{
v5 = a1;
v6 = (long long)&a1[a2 - 1 + 1];
v7 = 0;
do
v7 += *a1++ == v4;
while ( a1 != (_DWORD *)v6... | func0:
ENDBR64
MOV R10,RDX
MOV EDX,dword ptr [RDI]
TEST ESI,ESI
JLE 0x001011e0
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA R9,[RDI + RCX*0x4 + 0x4]
MOV R8D,0x0
LAB_00101187:
CMP dword ptr [RDI],EDX
SETZ CL
MOVZX ECX,CL
ADD R8D,ECX
ADD RDI,0x4
CMP RDI,R9
JNZ 0x00101187
MOV ESI,0x0
JMP 0x001011ab
LAB_001011a2:
ADD RAX,0x4
CMP R... | void func0(int *param_1,int param_2,long param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
iVar1 = *param_1;
if (0 < param_2) {
piVar2 = param_1 + (ulong)(param_2 - 1) + 1;
iVar5 = 0;
piVar4 = param_1;
do {
iVar5 = iVar5 + (uint)(*piVar4 == iVar1);
piVar... |
6,554 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *num_list, int n, int *output) {
int first_element = num_list[0];
int count_first = 0;
int output_index = 0;
// count occurrences of the first element
for (int i = 0; i < n; i++) {
if (num_list[i] == first_element) {
count_first++;
}
}
... | int main() {
int test1[] = {1, 2, 3, 4};
int result1[4];
func0(test1, 4, result1);
assert(result1[0] == 2 && result1[1] == 3 && result1[2] == 4 && result1[3] == 1);
int test2[] = {2, 3, 4, 1, 5, 0};
int result2[6];
func0(test2, 6, result2);
assert(result2[0] == 3 && result2[1] ... | O2 | c | func0:
endbr64
mov (%rdi),%ecx
test %esi,%esi
jle 13e3 <func0+0x83>
lea -0x1(%rsi),%eax
add $0x4,%rdi
mov %ecx,%esi
xor %r9d,%r9d
lea (%rdi,%rax,4),%r8
mov %rdi,%rax
jmp 1386 <func0+0x26>
mov (%rax),%esi
add $0x4,%rax
cmp %ecx,%esi
sete %sil
movzbl %sil,%esi
add %esi,%r9d
cmp ... | func0:
endbr64
mov r10, rdx
mov edx, [rdi]
test esi, esi
jle short locret_13EB
lea eax, [rsi-1]
add rdi, 4
mov ecx, edx
xor esi, esi
lea r8, [rdi+rax*4]
mov rax, rdi
jmp short loc_138E
loc_1388:
mov ecx, [rax]
add rax, 4
loc_138E:
cmp ecx, edx
setz cl
movzx ec... | void func0(int *a1, int a2, long long a3)
{
int v4; // edx
long long v5; // rax
int *v6; // rdi
int v7; // ecx
int v8; // esi
int *v9; // r8
int *i; // rax
int v11; // eax
long long v12; // r9
long long v13; // rcx
_DWORD *v14; // rax
long long v15; // rcx
v4 = *a1;
if ( a2 > 0 )
{
v... | func0:
ENDBR64
MOV R10,RDX
MOV EDX,dword ptr [RDI]
TEST ESI,ESI
JLE 0x001013eb
LEA EAX,[RSI + -0x1]
ADD RDI,0x4
MOV ECX,EDX
XOR ESI,ESI
LEA R8,[RDI + RAX*0x4]
MOV RAX,RDI
JMP 0x0010138e
LAB_00101388:
MOV ECX,dword ptr [RAX]
ADD RAX,0x4
LAB_0010138e:
CMP ECX,EDX
SETZ CL
MOVZX ECX,CL
ADD ESI,ECX
CMP RAX,R8
JNZ 0x00101388... | void func0(int *param_1,int param_2,long param_3)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int iVar5;
long lVar6;
iVar1 = *param_1;
if (0 < param_2) {
param_1 = param_1 + 1;
iVar5 = 0;
piVar4 = param_1 + (param_2 - 1);
iVar2 = iVar1;
for (piVar3 = param_1; iVar5 = iVar5 ... |
6,555 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *num_list, int n, int *output) {
int first_element = num_list[0];
int count_first = 0;
int output_index = 0;
// count occurrences of the first element
for (int i = 0; i < n; i++) {
if (num_list[i] == first_element) {
count_first++;
}
}
... | int main() {
int test1[] = {1, 2, 3, 4};
int result1[4];
func0(test1, 4, result1);
assert(result1[0] == 2 && result1[1] == 3 && result1[2] == 4 && result1[3] == 1);
int test2[] = {2, 3, 4, 1, 5, 0};
int result2[6];
func0(test2, 6, result2);
assert(result2[0] == 3 && result2[1] ... | O3 | c | func0:
endbr64
mov (%rdi),%r9d
test %esi,%esi
jle 1497 <func0+0x177>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 14a9 <func0+0x189>
mov %esi,%ecx
movd %r9d,%xmm3
pxor %xmm1,%xmm1
mov %rdi,%rax
shr $0x2,%ecx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu ... | func0:
endbr64
mov rax, rdi
mov r8d, esi
mov edi, [rdi]
mov r9, rdx
test esi, esi
jle locret_1484
lea edx, [rsi-1]
cmp edx, 2
jbe loc_1490
mov ecx, esi
movd xmm3, edi
pxor xmm1, xmm1
mov rdx, rax
shr ecx, 2
pshufd xmm2, xmm3, 0
shl rcx, 4
add rcx, rax
nop
lo... | const __m128i * func0(unsigned int *a1, int a2, long long a3)
{
const __m128i *result; // rax
unsigned int v5; // edi
__m128i v7; // xmm1
const __m128i *v8; // rdx
__m128i v9; // xmm2
__m128i v10; // xmm0
signed int v11; // ecx
__m128i v12; // xmm1
int v13; // esi
long long v14; // rdx
const __m12... | func0:
ENDBR64
MOV RAX,RDI
MOV R8D,ESI
MOV EDI,dword ptr [RDI]
MOV R9,RDX
TEST ESI,ESI
JLE 0x00101484
LEA EDX,[RSI + -0x1]
CMP EDX,0x2
JBE 0x00101490
MOV ECX,ESI
MOVD XMM3,EDI
PXOR XMM1,XMM1
MOV RDX,RAX
SHR ECX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RCX,0x4
ADD RCX,RAX
NOP
LAB_00101360:
MOVDQU XMM0,xmmword ptr [RDX]
ADD RDX,0x10... | void func0(int *param_1,uint param_2,long param_3)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
long lVar8;
int iVar9;
uint uVar10;
int iVar11;
int iVar12;
int iVar13;
iVar1 = *param_1;
if ((int)param_2 < 1) {
return;
}
if (param_2 - 1... |
6,556 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int count = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == c) {
count++;
}
}
return count;
}
| int main() {
assert(func0("Python", 'o') == 1);
assert(func0("little", 't') == 2);
assert(func0("assert", 's') == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,%eax
mov %al,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11ac <func0+0x43>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov eax, esi
mov [rbp+var_2C], al
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_11AC
loc_118F:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr ... | long long func0(const char *a1, char a2)
{
unsigned int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a2 == a1[i] )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x2c],AL
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011ac
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZ... | int func0(char *param_1,char param_2)
{
size_t sVar1;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= (ulong)(long)local_1c) break;
if (param_2 == param_1[local_1c]) {
local_20 = local_20 + 1;
}
local_1c = local_1c +... |
6,557 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int count = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == c) {
count++;
}
}
return count;
}
| int main() {
assert(func0("Python", 'o') == 1);
assert(func0("little", 't') == 2);
assert(func0("assert", 's') == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %r8,%rdx
lea -0x1(%r8,%rcx,1),%rdi
mov $0x0,%eax
cmp %rdi,%rdx
je 1184 <func0+0x3b>
cmp %sil,(%rdx)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
add $0x1,%rdx
jmp 116e <func0... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
call _strlen
mov rdi, rax
mov rax, rbx
add rdi, rbx
mov edx, 0
jmp short loc_119C
loc_118D:
cmp [rax], bpl
setz cl
movzx ecx, cl
add edx, ecx
add rax, 1
loc_119C:
cmp rax, rdi
jnz shor... | long long func0(_BYTE *a1, unsigned __int8 a2)
{
long long v3; // rdi
_BYTE *v4; // rax
_BYTE *v5; // rdi
unsigned int v6; // edx
v3 = strlen();
v4 = a1;
v5 = &a1[v3];
v6 = 0;
while ( v4 != v5 )
v6 += *v4++ == a2;
return v6;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
CALL 0x00101060
MOV RDI,RAX
MOV RAX,RBX
ADD RDI,RBX
MOV EDX,0x0
JMP 0x0010119c
LAB_0010118d:
CMP byte ptr [RAX],BPL
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
LAB_0010119c:
CMP RAX,RDI
JNZ 0x0010118d
MOV EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET | int func0(char *param_1,char param_2)
{
size_t sVar1;
int iVar2;
char *pcVar3;
sVar1 = strlen(param_1);
pcVar3 = param_1 + sVar1;
iVar2 = 0;
for (; param_1 != pcVar3; param_1 = param_1 + 1) {
iVar2 = iVar2 + (uint)(*param_1 == param_2);
}
return iVar2;
} |
6,558 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int count = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == c) {
count++;
}
}
return count;
}
| int main() {
assert(func0("Python", 'o') == 1);
assert(func0("little", 't') == 2);
assert(func0("assert", 's') == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %rbx,%rdi
lea (%rbx,%rax,1),%rcx
xor %eax,%eax
jmp 129e <func0+0x2e>
xor %edx,%edx
cmp %bpl,(%rdi)
sete %dl
add $0x1,%rdi
add %edx,%eax
cmp %rcx,%rdi
jne 1290 <func0+0x2... | func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov rdi, rbx
lea rcx, [rbx+rax]
xor eax, eax
jmp short loc_124E
loc_1240:
xor edx, edx
cmp [rdi], bpl
setz dl
add rdi, 1
add eax, edx
loc_124E:
cmp rdi, rcx
jnz short loc_12... | long long func0(_BYTE *a1, unsigned __int8 a2)
{
_BYTE *v2; // rcx
long long result; // rax
BOOL v4; // edx
v2 = &a1[strlen()];
result = 0LL;
while ( a1 != v2 )
{
v4 = *a1++ == a2;
result = (unsigned int)(v4 + result);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
MOV RDI,RBX
LEA RCX,[RBX + RAX*0x1]
XOR EAX,EAX
JMP 0x0010124e
LAB_00101240:
XOR EDX,EDX
CMP byte ptr [RDI],BPL
SETZ DL
ADD RDI,0x1
ADD EAX,EDX
LAB_0010124e:
CMP RDI,RCX
JNZ 0x00101240
ADD RSP,0x8
POP RBX
POP RBP
RET | int func0(char *param_1,char param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
sVar3 = strlen(param_1);
pcVar1 = param_1 + sVar3;
iVar2 = 0;
for (; param_1 != pcVar1; param_1 = param_1 + 1) {
iVar2 = iVar2 + (uint)(*param_1 == param_2);
}
return iVar2;
} |
6,559 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *string, char c) {
int count = 0;
for (int i = 0; i < strlen(string); i++) {
if (string[i] == c) {
count++;
}
}
return count;
}
| int main() {
assert(func0("Python", 'o') == 1);
assert(func0("little", 't') == 2);
assert(func0("assert", 's') == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1050 <strlen@plt>
test %rax,%rax
je 13f0 <func0+0x290>
mov %rax,%rcx
lea -0x1(%rax),%rax
cmp $0xe,%rax
jbe 13f9 <func0+0x299>
movd %ebp,%xmm4
mov %rcx,%rax
pxor %xmm1,%xmm1
mov %rbx,%rdx
punpcklb... | func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test rax, rax
jz loc_13D0
mov rdx, rax
lea rax, [rax-1]
cmp rax, 0Eh
jbe loc_13D9
movd xmm4, ebp
mov rcx, rdx
pxor xmm1, xmm1
mov rax, rbx
punpcklbw xmm4, xmm4
pxor xmm6, xmm6... | long long func0(const char *a1, unsigned __int8 a2)
{
size_t v4; // rax
size_t v5; // rdx
__m128i v6; // xmm4
__m128i v7; // xmm1
const __m128i *v8; // rax
__m128i v9; // xmm4
unsigned long long v10; // rcx
__m128i v11; // xmm4
__m128i v12; // xmm0
__m128i v13; // xmm0
__m128i v14; // xmm3
__m1... | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101050
TEST RAX,RAX
JZ 0x001013d0
MOV RDX,RAX
LEA RAX,[RAX + -0x1]
CMP RAX,0xe
JBE 0x001013d9
MOVD XMM4,EBP
MOV RCX,RDX
PXOR XMM1,XMM1
MOV RAX,RBX
PUNPCKLBW XMM4,XMM4
PXOR XMM6,XMM6
PXOR XMM5,XMM5
AND RCX,-0x10
PUNPCKLWD XMM4,XMM4
LEA RSI,[RC... | int func0(char *param_1,char 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... |
6,560 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(const char *string, const char *vowels) {
int count = 0;
const char *s = string;
const char *v;
while (*s) {
v = vowels;
while (*v) {
if (*s == *v) {
count++;
break;
}
v++;
}
... | int main() {
assert(func0("corner", "AaEeIiOoUu") == 2);
assert(func0("valid", "AaEeIiOoUu") == 2);
assert(func0("true", "AaEeIiOoUu") == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,-0x10(%rbp)
jmp 11a1 <func0+0x58>
mov -0x30(%rbp),%rax
mov %rax,-0x8(%rbp)
jmp 1191 <func0+0x48>
mov -0x10(%rbp),%rax
movzbl (%rax),%edx
mov -0x8(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_14], 0
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
jmp short loc_11A1
loc_116A:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_1191
loc_1174:
mov rax, [rbp+var_10]
movzx... | long long func0(_BYTE *a1, _BYTE *a2)
{
unsigned int v3; // [rsp+1Ch] [rbp-14h]
_BYTE *i; // [rsp+28h] [rbp-8h]
v3 = 0;
while ( *a1 )
{
for ( i = a2; *i; ++i )
{
if ( *a1 == *i )
{
++v3;
break;
}
}
++a1;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001011a1
LAB_0010116a:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101191
LAB_00101174:
MOV... | int func0(char *param_1,char *param_2)
{
int local_1c;
char *local_18;
char *local_10;
local_1c = 0;
local_18 = param_1;
do {
local_10 = param_2;
if (*local_18 == '\0') {
return local_1c;
}
for (; *local_10 != '\0'; local_10 = local_10 + 1) {
if (*local_18 == *local_10) {
... |
6,561 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(const char *string, const char *vowels) {
int count = 0;
const char *s = string;
const char *v;
while (*s) {
v = vowels;
while (*v) {
if (*s == *v) {
count++;
break;
}
v++;
}
... | int main() {
assert(func0("corner", "AaEeIiOoUu") == 2);
assert(func0("valid", "AaEeIiOoUu") == 2);
assert(func0("true", "AaEeIiOoUu") == 2);
return 0;
}
| O1 | c | func0:
endbr64
movzbl (%rdi),%ecx
test %cl,%cl
je 118e <func0+0x45>
movzbl (%rsi),%r9d
mov $0x0,%r8d
mov %r9d,%r10d
jmp 1172 <func0+0x29>
add $0x1,%r8d
add $0x1,%rdi
movzbl (%rdi),%ecx
test %cl,%cl
je 1194 <func0+0x4b>
mov %rsi,%rdx
mov %r10d,%eax
test %r9b,%r9b
je 1167 <func0+0x1... | func0:
endbr64
movzx ecx, byte ptr [rdi]
test cl, cl
jz short loc_118B
movzx r8d, byte ptr [rsi]
mov r9d, 0
jmp short loc_116F
loc_1160:
add r9d, 1
loc_1164:
add rdi, 1
movzx ecx, byte ptr [rdi]
test cl, cl
jz short loc_1191
loc_116F:
mov rdx, rsi
mov eax, r8d
test r8b, ... | long long func0(char *a1, _BYTE *a2)
{
char v2; // cl
unsigned int v3; // r9d
_BYTE *v4; // rdx
char v5; // al
v2 = *a1;
if ( *a1 )
{
v3 = 0;
do
{
v4 = a2;
v5 = *a2;
if ( *a2 )
{
while ( v5 != v2 )
{
v5 = *++v4;
if ( !*v4 )
... | func0:
ENDBR64
MOVZX ECX,byte ptr [RDI]
TEST CL,CL
JZ 0x0010118b
MOVZX R8D,byte ptr [RSI]
MOV R9D,0x0
JMP 0x0010116f
LAB_00101160:
ADD R9D,0x1
LAB_00101164:
ADD RDI,0x1
MOVZX ECX,byte ptr [RDI]
TEST CL,CL
JZ 0x00101191
LAB_0010116f:
MOV RDX,RSI
MOV EAX,R8D
TEST R8B,R8B
JZ 0x00101164
LAB_0010117a:
CMP AL,CL
JZ 0x0010116... | int func0(char *param_1,char *param_2)
{
char cVar1;
char *pcVar2;
char cVar3;
int iVar4;
cVar3 = *param_1;
if (cVar3 == '\0') {
iVar4 = 0;
}
else {
iVar4 = 0;
cVar1 = *param_2;
pcVar2 = param_2;
joined_r0x00101178:
do {
if (cVar1 != '\0') {
if (cVar1 != cVar3) {
... |
6,562 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(const char *string, const char *vowels) {
int count = 0;
const char *s = string;
const char *v;
while (*s) {
v = vowels;
while (*v) {
if (*s == *v) {
count++;
break;
}
v++;
}
... | int main() {
assert(func0("corner", "AaEeIiOoUu") == 2);
assert(func0("valid", "AaEeIiOoUu") == 2);
assert(func0("true", "AaEeIiOoUu") == 2);
return 0;
}
| O2 | c | func0:
endbr64
movzbl (%rdi),%ecx
test %cl,%cl
je 132c <func0+0x4c>
movzbl (%rsi),%r8d
xor %r9d,%r9d
nopw 0x0(%rax,%rax,1)
mov %rsi,%rdx
mov %r8d,%eax
test %r8b,%r8b
jne 1314 <func0+0x34>
jmp 131c <func0+0x3c>
nopl (%rax)
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
je 131c <func... | func0:
endbr64
movzx ecx, byte ptr [rdi]
test cl, cl
jz short loc_124C
movzx r8d, byte ptr [rsi]
xor r9d, r9d
nop word ptr [rax+rax+00h]
loc_1218:
mov rdx, rsi
mov eax, r8d
test r8b, r8b
jnz short loc_1234
jmp short loc_123C
loc_1228:
movzx eax, byte ptr [rdx+1]
add rdx, 1
t... | long long func0(char *a1, _BYTE *a2)
{
char v2; // cl
unsigned int v3; // r9d
_BYTE *v4; // rdx
char v5; // al
v2 = *a1;
if ( !*a1 )
return 0LL;
v3 = 0;
do
{
v4 = a2;
v5 = *a2;
if ( *a2 )
{
while ( v5 != v2 )
{
v5 = *++v4;
if ( !v5 )
goto LAB... | func0:
ENDBR64
MOVZX ECX,byte ptr [RDI]
TEST CL,CL
JZ 0x0010124c
MOVZX R8D,byte ptr [RSI]
XOR R9D,R9D
NOP word ptr [RAX + RAX*0x1]
LAB_00101218:
MOV RDX,RSI
MOV EAX,R8D
TEST R8B,R8B
JNZ 0x00101234
JMP 0x0010123c
LAB_00101228:
MOVZX EAX,byte ptr [RDX + 0x1]
ADD RDX,0x1
TEST AL,AL
JZ 0x0010123c
LAB_00101234:
CMP AL,CL
JN... | int func0(char *param_1,char *param_2)
{
char cVar1;
char *pcVar2;
char cVar3;
int iVar4;
cVar3 = *param_1;
if (cVar3 == '\0') {
return 0;
}
iVar4 = 0;
cVar1 = *param_2;
pcVar2 = param_2;
joined_r0x00101221:
do {
if (cVar1 != '\0') {
if (cVar1 != cVar3) {
cVar1 = pcVar2[1... |
6,563 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(const char *string, const char *vowels) {
int count = 0;
const char *s = string;
const char *v;
while (*s) {
v = vowels;
while (*v) {
if (*s == *v) {
count++;
break;
}
v++;
}
... | int main() {
assert(func0("corner", "AaEeIiOoUu") == 2);
assert(func0("valid", "AaEeIiOoUu") == 2);
assert(func0("true", "AaEeIiOoUu") == 2);
return 0;
}
| O3 | c | func0:
endbr64
movzbl (%rdi),%ecx
test %cl,%cl
je 12fc <func0+0x4c>
movzbl (%rsi),%r8d
xor %r9d,%r9d
nopw 0x0(%rax,%rax,1)
mov %rsi,%rdx
mov %r8d,%eax
test %r8b,%r8b
jne 12e4 <func0+0x34>
jmp 12ec <func0+0x3c>
nopl (%rax)
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
je 12ec <func... | func0:
endbr64
movzx ecx, byte ptr [rdi]
test cl, cl
jz short loc_12FC
movzx r8d, byte ptr [rsi]
xor r9d, r9d
nop word ptr [rax+rax+00h]
loc_12C8:
mov rdx, rsi
mov eax, r8d
test r8b, r8b
jnz short loc_12E4
jmp short loc_12EC
loc_12D8:
movzx eax, byte ptr [rdx+1]
add rdx, 1
t... | long long func0(char *a1, _BYTE *a2)
{
char v2; // cl
unsigned int v3; // r9d
_BYTE *v4; // rdx
char v5; // al
v2 = *a1;
if ( !*a1 )
return 0LL;
v3 = 0;
do
{
v4 = a2;
v5 = *a2;
if ( *a2 )
{
while ( v5 != v2 )
{
v5 = *++v4;
if ( !v5 )
goto LAB... | func0:
ENDBR64
MOVZX ECX,byte ptr [RDI]
TEST CL,CL
JZ 0x001012fc
MOVZX R8D,byte ptr [RSI]
XOR R9D,R9D
NOP word ptr [RAX + RAX*0x1]
LAB_001012c8:
MOV RDX,RSI
MOV EAX,R8D
TEST R8B,R8B
JNZ 0x001012e4
JMP 0x001012ec
LAB_001012d8:
MOVZX EAX,byte ptr [RDX + 0x1]
ADD RDX,0x1
TEST AL,AL
JZ 0x001012ec
LAB_001012e4:
CMP AL,CL
JN... | int func0(char *param_1,char *param_2)
{
char cVar1;
char *pcVar2;
char cVar3;
int iVar4;
cVar3 = *param_1;
if (cVar3 == '\0') {
return 0;
}
iVar4 = 0;
cVar1 = *param_2;
pcVar2 = param_2;
joined_r0x001012d1:
do {
if (cVar1 != '\0') {
if (cVar1 != cVar3) {
cVar1 = pcVar2[1... |
6,564 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
#include <stdlib.h>
| char* func0(char* string, const char* charToReplace) {
regex_t regex;
char pattern[10];
sprintf(pattern, "%s{2,}", charToReplace);
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return NULL; // Failed to compile regex
}
regmatch_t match;
size_t offset = 0;
... | int main() {
char* result;
result = func0("peep", "e");
assert(strcmp(result, "pep") == 0);
free(result);
result = func0("Greek", "e");
assert(strcmp(result, "Grek") == 0);
free(result);
result = func0("Moon", "o");
assert(strcmp(result, "Mon") == 0);
free(result)... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x90(%rbp),%rdx
lea -0x12(%rbp),%rax
lea 0xd41(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1180 <sprintf@plt>
lea -0x12(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rdx, [rbp+var_90]
lea rax, [rbp+s]
lea rcx, format; "%s{2,}"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call ... | const char * func0(const char *a1, const char *a2)
{
size_t v3; // rax
long long v4; // [rsp+10h] [rbp-80h]
const char *v5; // [rsp+18h] [rbp-78h]
long long v6; // [rsp+20h] [rbp-70h]
regmatch_t pmatch; // [rsp+28h] [rbp-68h] BYREF
regex_t preg; // [rsp+30h] [rbp-60h] BYREF
char s[10]; // [rsp+7Eh] [rbp-1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0x90]
LEA RAX,[RBP + -0x12]
LEA RCX,[0x102004]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101180
LEA RCX,[RB... | char * func0(char *param_1,int8 param_2)
{
int iVar1;
char *__s;
size_t sVar2;
long in_FS_OFFSET;
long local_88;
regmatch_t local_70;
regex_t local_68;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sprintf(local_1a,"%s{2,}",param_2);
iVar1 = regcomp(&local_68,... |
6,565 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
#include <stdlib.h>
| char* func0(char* string, const char* charToReplace) {
regex_t regex;
char pattern[10];
sprintf(pattern, "%s{2,}", charToReplace);
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return NULL; // Failed to compile regex
}
regmatch_t match;
size_t offset = 0;
... | int main() {
char* result;
result = func0("peep", "e");
assert(strcmp(result, "pep") == 0);
free(result);
result = func0("Greek", "e");
assert(strcmp(result, "Grek") == 0);
free(result);
result = func0("Moon", "o");
assert(strcmp(result, "Mon") == 0);
free(result)... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%rbx
mov %rsi,%r8
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x5e(%rsp),%rbp
lea 0xd8d(%rip),%rcx
mov $0xa,%edx
mov $0x1,%esi
mov %rbp,%rdi
callq 1150 <__sprintf_chk@plt>
lea 0x10(%rsp),%rdi
mov ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 70h
mov rbx, rdi
mov r8, rsi
mov rax, fs:28h
mov [rsp+98h+var_30], rax
xor eax, eax
lea rbp, [rsp+98h+var_3A]
lea rcx, aS2; "%s{2,}"
mov edx, 0Ah
mov esi, 1
mov rdi, rbp
call ___sprintf_chk... | long long func0(long long a1, const char *a2)
{
long long v2; // r12
long long v3; // rbp
long long v4; // rbx
long long v5; // r14
long long v6; // rax
long long v7; // rsi
int v9; // [rsp+8h] [rbp-90h] BYREF
int v10; // [rsp+Ch] [rbp-8Ch]
_BYTE v11[78]; // [rsp+10h] [rbp-88h] BYREF
_BYTE v12[10];... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
MOV R8,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x5e]
LEA RCX,[0x102004]
MOV EDX,0xa
MOV ESI,0x1
MOV RDI,RBP
CALL 0x00101190
LEA RDI,[RSP + 0x10]
MOV EDX,0x1
MOV RSI,RBP
CALL 0x00101140
... | char * func0(char *param_1,int8 param_2)
{
long lVar1;
long lVar2;
int iVar3;
size_t sVar4;
long lVar5;
long lVar6;
char *__s;
long in_FS_OFFSET;
regmatch_t local_90;
regex_t local_88;
char local_3a [10];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(local_3a,1,... |
6,566 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
#include <stdlib.h>
| char* func0(char* string, const char* charToReplace) {
regex_t regex;
char pattern[10];
sprintf(pattern, "%s{2,}", charToReplace);
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return NULL; // Failed to compile regex
}
regmatch_t match;
size_t offset = 0;
... | int main() {
char* result;
result = func0("peep", "e");
assert(strcmp(result, "pep") == 0);
free(result);
result = func0("Greek", "e");
assert(strcmp(result, "Grek") == 0);
free(result);
result = func0("Moon", "o");
assert(strcmp(result, "Mon") == 0);
free(result)... | O2 | c | func0:
endbr64
push %r13
mov %rsi,%r8
mov $0xa,%edx
mov %rdi,%r13
push %r12
lea 0xc7a(%rip),%rcx
mov $0x1,%esi
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x5e(%rsp),%r12
lea 0x10(%rsp),%rbp
mov %r12,%rdi
callq 1150 <__sprintf_c... | func0:
endbr64
push r15
mov r8, rsi
mov edx, 0Ah
lea rcx, aS2; "%s{2,}"
push r14
mov esi, 1
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea r12, [rsp+0A8h+var_4A]
lea r13, [rsp+0A8h+va... | long long func0(long long a1, const char *a2)
{
long long v2; // r12
long long v3; // rbp
long long i; // r9
long long v5; // rbx
long long v6; // rax
long long v7; // r15
long long v8; // rsi
int v10; // [rsp+8h] [rbp-A0h] BYREF
int v11; // [rsp+Ch] [rbp-9Ch]
_BYTE v12[78]; // [rsp+10h] [rbp-98h] ... | func0:
ENDBR64
PUSH R15
MOV R8,RSI
MOV EDX,0xa
LEA RCX,[0x102004]
PUSH R14
MOV ESI,0x1
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA R12,[RSP + 0x5e]
LEA R13,[RSP + 0x10]
MOV RDI,R12
CALL 0x00101190
MOV RSI,R12
MOV EDX,0x1
MOV RDI... | char * func0(char *param_1)
{
long lVar1;
long lVar2;
int iVar3;
char *__s;
size_t sVar4;
char *__string;
long lVar5;
long lVar6;
long in_FS_OFFSET;
regmatch_t local_a0;
regex_t local_98;
char local_4a [10];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(local_... |
6,567 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
#include <stdlib.h>
| char* func0(char* string, const char* charToReplace) {
regex_t regex;
char pattern[10];
sprintf(pattern, "%s{2,}", charToReplace);
if (regcomp(®ex, pattern, REG_EXTENDED) != 0) {
return NULL; // Failed to compile regex
}
regmatch_t match;
size_t offset = 0;
... | int main() {
char* result;
result = func0("peep", "e");
assert(strcmp(result, "pep") == 0);
free(result);
result = func0("Greek", "e");
assert(strcmp(result, "Grek") == 0);
free(result);
result = func0("Moon", "o");
assert(strcmp(result, "Mon") == 0);
free(result)... | O3 | c | func0:
endbr64
push %r13
mov %rsi,%r8
mov $0xa,%edx
mov %rdi,%r13
push %r12
lea 0xc7a(%rip),%rcx
mov $0x1,%esi
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x5e(%rsp),%r12
lea 0x10(%rsp),%rbp
mov %r12,%rdi
callq 1150 <__sprintf_c... | func0:
endbr64
push r15
mov r8, rsi
mov edx, 0Ah
lea rcx, aS2; "%s{2,}"
push r14
mov esi, 2
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rbp, [rsp+0B8h+pattern]
lea r13, [rsp+0B8h+p... | char * func0(char *s, const char *a2)
{
char *v2; // rbp
size_t v3; // r15
size_t v4; // r12
int i; // eax
long long rm_so; // rbx
size_t v7; // rax
size_t v8; // rcx
size_t v9; // r14
size_t v10; // rsi
char *v11; // rsi
const char *v12; // rdi
regmatch_t v14; // [rsp+18h] [rbp-A0h] BYREF
reg... | func0:
ENDBR64
PUSH R15
MOV R8,RSI
MOV EDX,0xa
LEA RCX,[0x102004]
PUSH R14
MOV ESI,0x2
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x6e]
LEA R13,[RSP + 0x20]
MOV RDI,RBP
CALL 0x00101190
MOV RSI,RBP
MOV EDX,0x1
MOV RDI... | char * func0(char *param_1)
{
long lVar1;
long lVar2;
int iVar3;
size_t sVar4;
char *__s;
size_t sVar5;
char *__string;
ulong uVar6;
long lVar7;
ulong uVar8;
long in_FS_OFFSET;
regmatch_t local_a0;
regex_t local_98;
char local_4a [10];
long local_40;
local_40 = *(long *)(in_FS_OFFSET... |
6,568 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *Ip) {
regex_t regex;
int reti;
char msgbuf[100];
const char *pattern = "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
... | int main() {
assert(func0("192.168.0.1") == 1); // Valid IP address
assert(func0("110.234.52.124") == 1); // Valid IP address
assert(func0("366.1.2.2") == 0); // Invalid IP address
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %rdi,-0xc8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdd3(%rip),%rax
mov %rax,-0xb8(%rbp)
mov -0xb8(%rbp),%rcx
lea -0xb0(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10d0 <regcomp@plt>
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, a25052040901090; "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?"...
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; c... | long long func0(const char *a1)
{
int errcode; // [rsp+14h] [rbp-BCh]
regex_t preg; // [rsp+20h] [rbp-B0h] BYREF
char errbuf[104]; // [rsp+60h] [rbp-70h] BYREF
unsigned long long v5; // [rsp+C8h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( regcomp(
&preg,
"^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xc8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0xb8],RAX
MOV RCX,qword ptr [RBP + -0xb8]
LEA RAX,[RBP + -0xb0]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV dword p... | int8 func0(char *param_1)
{
int iVar1;
int8 uVar2;
long in_FS_OFFSET;
regex_t local_b8;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_b8,
"^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.(2... |
6,569 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *Ip) {
regex_t regex;
int reti;
char msgbuf[100];
const char *pattern = "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
... | int main() {
assert(func0("192.168.0.1") == 1); // Valid IP address
assert(func0("110.234.52.124") == 1); // Valid IP address
assert(func0("366.1.2.2") == 0); // Invalid IP address
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xdcd(%rip),%rsi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 12ac <func0+0xa3>
mov %eax,%ebx
mov %rsp,%rdi
mov $0x0,%r8d
mov $... | func0:
endbr64
push rbp
push rbx
sub rsp, 0B8h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, a25052040901090; "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?"...
call _regcomp
test eax, eax
jnz short loc_12AC
mov ebx, e... | long long func0(long long a1)
{
unsigned int v1; // ebx
unsigned int v2; // eax
_BYTE v4[64]; // [rsp+0h] [rbp-C8h] BYREF
char v5[104]; // [rsp+40h] [rbp-88h] BYREF
unsigned long long v6; // [rsp+A8h] [rbp-20h]
v6 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(
v4,
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102008]
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x001012ac
MOV EBX,EAX
MOV RDI,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBP
CALL 0x001010f0
TEST EAX,EAX
JZ ... | int4 func0(char *param_1)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,
"^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.... |
6,570 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *Ip) {
regex_t regex;
int reti;
char msgbuf[100];
const char *pattern = "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
... | int main() {
assert(func0("192.168.0.1") == 1); // Valid IP address
assert(func0("110.234.52.124") == 1); // Valid IP address
assert(func0("366.1.2.2") == 0); // Invalid IP address
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov $0x1,%edx
lea 0xd46(%rip),%rsi
push %r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%r13
mov %r13,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1380 <func0+0xd0>
xor %r8d,%r8d
xor %ecx,%... | func0:
endbr64
push r13
mov edx, 1
lea rsi, a25052040901090; "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?"...
push r12
push rbp
mov rbp, rdi
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
mov r13, rsp
mov rdi, r13
call _regcomp
test eax, eax
jnz ... | long long func0(long long a1)
{
unsigned int v1; // r12d
unsigned int v2; // eax
_BYTE v4[64]; // [rsp+0h] [rbp-C8h] BYREF
char v5[104]; // [rsp+40h] [rbp-88h] BYREF
unsigned long long v6; // [rsp+A8h] [rbp-20h]
v6 = __readfsqword(0x28u);
if ( (unsigned int)regcomp(
v4,
... | func0:
ENDBR64
PUSH R13
MOV EDX,0x1
LEA RSI,[0x102008]
PUSH R12
PUSH RBP
MOV RBP,RDI
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV R13,RSP
MOV RDI,R13
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x00101380
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBP
MOV RDI,R13
MOV R12D,EAX
CALL 0x001... | int4 func0(char *param_1)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,
"^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.... |
6,571 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *Ip) {
regex_t regex;
int reti;
char msgbuf[100];
const char *pattern = "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\."
... | int main() {
assert(func0("192.168.0.1") == 1); // Valid IP address
assert(func0("110.234.52.124") == 1); // Valid IP address
assert(func0("366.1.2.2") == 0); // Invalid IP address
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov $0x1,%edx
lea 0xd46(%rip),%rsi
push %r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
mov %rsp,%r13
mov %r13,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1380 <func0+0xd0>
xor %r8d,%r8d
xor %ecx,%... | func0:
endbr64
push r12
mov edx, 1; cflags
lea rsi, pattern; "^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?"...
push rbp
mov rbp, rdi
push rbx
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12; preg
call _regcomp
test eax, eax
jn... | long long func0(char *string)
{
unsigned int v1; // ebx
int v2; // eax
regex_t v4; // [rsp+0h] [rbp-C8h] BYREF
char errbuf[104]; // [rsp+40h] [rbp-88h] BYREF
unsigned long long v6; // [rsp+A8h] [rbp-20h]
v6 = __readfsqword(0x28u);
if ( regcomp(
&v4,
"^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0... | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
LEA RSI,[0x102008]
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x00101380
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBP
MOV RDI,R12
MOV EBX,EAX
CALL 0x0010... | int4 func0(char *param_1)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_c8,
"^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.... |
6,572 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for(int i = 0; i < size - 1; i++) {
if(nums[i] >= nums[i+1])
return false;
}
return true;
}
| int main() {
int arr1[] = {-4, -3, -2, -1};
int size1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, size1) == true);
int arr2[] = {1, 2, 3};
int size2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, size2) == true);
int arr3[] = {3, 2, 1};
int size3 = sizeof(arr3)/siz... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c0 <func0+0x57>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%r... | 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_11C0
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
add rax, 1
lea ... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) >= *(_DWORD *)(4 * (i + 1LL) + 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 0x001011c0
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
AD... | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 + -1 <= local_c) {
return 1;
}
if (*(int *)(param_1 + ((long)local_c + 1) * 4) <= *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
6,573 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for(int i = 0; i < size - 1; i++) {
if(nums[i] >= nums[i+1])
return false;
}
return true;
}
| int main() {
int arr1[] = {-4, -3, -2, -1};
int size1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, size1) == true);
int arr2[] = {1, 2, 3};
int size2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, size2) == true);
int arr3[] = {3, 2, 1};
int size3 = sizeof(arr3)/siz... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 1193 <func0+0x2a>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
mov 0x4(%rax),%ecx
cmp %ecx,(%rax)
jge 1199 <func0+0x30>
add $0x4,%rax
cmp %rdx,%rax
jne 117d <func0+0x14>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_1193
mov rax, rdi
lea edx, [rsi-2]
lea rdx, [rdi+rdx*4+4]
loc_117D:
mov ecx, [rax+4]
cmp [rax], ecx
jge short loc_1199
add rax, 4
cmp rax, rdx
jnz short loc_117D
mov eax, 1
retn
loc_1193:
mov eax, 1
retn
loc_1199:
mov eax, 0... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 <= 1 )
return 1LL;
v2 = a1;
while ( *v2 < v2[1] )
{
if ( ++v2 == &a1[a2 - 2 + 1] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101193
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA RDX,[RDI + RDX*0x4 + 0x4]
LAB_0010117d:
MOV ECX,dword ptr [RAX + 0x4]
CMP dword ptr [RAX],ECX
JGE 0x00101199
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010117d
MOV EAX,0x1
RET
LAB_00101193:
MOV EAX,0x1
RET
LAB_00101199:
MOV EAX,0x0
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (param_2 < 2) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
do {
if (param_1[1] <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 1;
} |
6,574 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for(int i = 0; i < size - 1; i++) {
if(nums[i] >= nums[i+1])
return false;
}
return true;
}
| int main() {
int arr1[] = {-4, -3, -2, -1};
int size1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, size1) == true);
int arr2[] = {1, 2, 3};
int size2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, size2) == true);
int arr3[] = {3, 2, 1};
int size3 = sizeof(arr3)/siz... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1170 <func0+0x30>
lea -0x2(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopl 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
mov 0x4(%rdi),%edx
cmp %edx,(%rdi)
jl 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax... | func0:
endbr64
cmp esi, 1
jle short loc_12C0
lea eax, [rsi-2]
lea rax, [rdi+rax*4+4]
jmp short loc_12B1
loc_12A8:
add rdi, 4
cmp rdi, rax
jz short loc_12C0
loc_12B1:
mov edx, [rdi+4]
cmp [rdi], edx
jl short loc_12A8
xor eax, eax
retn
loc_12C0:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rax
if ( a2 <= 1 )
return 1LL;
v2 = (long long)&a1[a2 - 2 + 1];
while ( *a1 < a1[1] )
{
if ( ++a1 == (_DWORD *)v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012c0
LEA EAX,[RSI + -0x2]
LEA RAX,[RDI + RAX*0x4 + 0x4]
JMP 0x001012b1
LAB_001012a8:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x001012c0
LAB_001012b1:
MOV EDX,dword ptr [RDI + 0x4]
CMP dword ptr [RDI],EDX
JL 0x001012a8
XOR EAX,EAX
RET
LAB_001012c0:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (1 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
do {
if (param_1[1] <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
} |
6,575 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for(int i = 0; i < size - 1; i++) {
if(nums[i] >= nums[i+1])
return false;
}
return true;
}
| int main() {
int arr1[] = {-4, -3, -2, -1};
int size1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, size1) == true);
int arr2[] = {1, 2, 3};
int size2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, size2) == true);
int arr3[] = {3, 2, 1};
int size3 = sizeof(arr3)/siz... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1178 <func0+0x38>
lea -0x2(%rsi),%ecx
mov (%rdi),%edx
lea 0x4(%rdi),%rax
lea 0x8(%rdi,%rcx,4),%rsi
jmp 1169 <func0+0x29>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rsi,%rax
je 1178 <func0+0x38>
mov %edx,%ecx
mov (%rax),%edx
cmp %ecx,%edx
jg 1160 <fun... | func0:
endbr64
cmp esi, 1
jle short loc_1178
lea ecx, [rsi-2]
mov edx, [rdi]
lea rax, [rdi+4]
lea rsi, [rdi+rcx*4+8]
jmp short loc_1169
loc_1160:
add rax, 4
cmp rax, rsi
jz short loc_1178
loc_1169:
mov ecx, edx
mov edx, [rax]
cmp edx, ecx
jg short loc_1160
xor ... | long long func0(int *a1, int a2)
{
int v2; // edx
int *v3; // rax
long long v4; // rsi
int v5; // ecx
if ( a2 <= 1 )
return 1LL;
v2 = *a1;
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 2 + 2];
while ( 1 )
{
v5 = v2;
v2 = *v3;
if ( *v3 <= v5 )
break;
if ( ++v3 == (int *)v4 )
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101178
LEA ECX,[RSI + -0x2]
MOV EDX,dword ptr [RDI]
LEA RAX,[RDI + 0x4]
LEA RSI,[RDI + RCX*0x4 + 0x8]
JMP 0x00101169
LAB_00101160:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x00101178
LAB_00101169:
MOV ECX,EDX
MOV EDX,dword ptr [RAX]
CMP EDX,ECX
JG 0x00101160
XOR EAX,EAX
RET
LAB_00101178:
MOV EAX,0x... | int8 func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
if (1 < param_2) {
piVar2 = param_1 + 1;
iVar3 = *param_1;
do {
iVar1 = *piVar2;
if (iVar1 <= iVar3) {
return 0;
}
piVar2 = piVar2 + 1;
iVar3 = iVar1;
} while (piVar2 != param_1 + ... |
6,576 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 1;
}
if ((n & (n + 1)) == 0) {
return n;
}
int pos = (int)(log2((~n) & -(~n)) + 1);
return ((1 << (pos - 1)) | n);
}
| int main() {
assert(func0(21) == 23);
assert(func0(11) == 15);
assert(func0(15) == 15);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 1185 <func0+0x1c>
mov $0x1,%eax
jmp 11d6 <func0+0x6d>
mov -0x14(%rbp),%eax
add $0x1,%eax
and -0x14(%rbp),%eax
test %eax,%eax
jne 1197 <func0+0x2e>
mov -0x14(%rbp),%eax
jmp 11d6 ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jnz short loc_1185
mov eax, 1
jmp short locret_11E4
loc_1185:
mov eax, [rbp+var_14]
add eax, 1
and eax, [rbp+var_14]
test eax, eax
jnz short loc_1197
mov eax, [rbp+var_14]
jm... | long long func0(unsigned int a1)
{
if ( !a1 )
return 1LL;
if ( (a1 & (a1 + 1)) != 0 )
return a1 | (1 << ((int)(log2((double)(int)(~a1 & (a1 + 1))) + 1.0) - 1));
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101185
MOV EAX,0x1
JMP 0x001011e4
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
AND EAX,dword ptr [RBP + -0x14]
TEST EAX,EAX
JNZ 0x00101197
MOV EAX,dword ptr [RBP + -0x14]
JMP 0x001011e4
... | uint func0(uint param_1)
{
double dVar1;
if (param_1 == 0) {
param_1 = 1;
}
else if ((param_1 + 1 & param_1) != 0) {
dVar1 = log2((double)(int)(param_1 + 1 & ~param_1));
param_1 = 1 << ((char)(int)(dVar1 + DAT_00102060) - 1U & 0x1f) | param_1;
}
return param_1;
} |
6,577 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 1;
}
if ((n & (n + 1)) == 0) {
return n;
}
int pos = (int)(log2((~n) & -(~n)) + 1);
return ((1 << (pos - 1)) | n);
}
| int main() {
assert(func0(21) == 23);
assert(func0(11) == 15);
assert(func0(15) == 15);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
test %edi,%edi
je 11ab <func0+0x42>
push %rbx
mov %edi,%ebx
lea 0x1(%rdi),%edx
mov %edi,%eax
test %edi,%edx
jne 1184 <func0+0x1b>
pop %rbx
retq
not %eax
and %edx,%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
callq 1060 <log2@plt>
addsd 0xee3(%rip),%xmm0
cvt... | func0:
endbr64
mov eax, 1
test edi, edi
jz short locret_11AB
push rbx
mov ebx, edi
lea edx, [rdi+1]
mov eax, edi
test edx, edi
jnz short loc_1184
loc_1182:
pop rbx
retn
loc_1184:
not eax
and eax, edx
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
call _log2
addsd xmm0, cs:qword... | int func0(int a1)
{
int result; // eax
double v2; // xmm0_8
result = 1;
if ( a1 )
{
result = a1;
if ( (a1 & (a1 + 1)) != 0 )
{
v2 = log2((double)((a1 + 1) & ~a1));
result = a1;
_bittestandset(&result, (int)(v2 + 1.0) - 1);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST EDI,EDI
JZ 0x001011ab
PUSH RBX
MOV EBX,EDI
LEA EDX,[RDI + 0x1]
MOV EAX,EDI
TEST EDX,EDI
JNZ 0x00101184
LAB_00101182:
POP RBX
RET
LAB_00101184:
NOT EAX
AND EAX,EDX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
CALL 0x00101060
ADDSD XMM0,qword ptr [0x00102058]
CVTTSD2SI EDX,XMM0
SUB EDX,0x1
MOV EAX,EBX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(uint param_1)
{
double dVar1;
if (param_1 != 0) {
if ((param_1 + 1 & param_1) != 0) {
dVar1 = log2((double)(int)(~param_1 & param_1 + 1));
param_1 = param_1 | 1 << ((int)(dVar1 + _DAT_00102058) - 1U ... |
6,578 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 1;
}
if ((n & (n + 1)) == 0) {
return n;
}
int pos = (int)(log2((~n) & -(~n)) + 1);
return ((1 << (pos - 1)) | n);
}
| int main() {
assert(func0(21) == 23);
assert(func0(11) == 15);
assert(func0(15) == 15);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
je 1260 <func0+0x10>
jmp 1210 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12d, 1
test edi, edi
jz short loc_117A
lea eax, [rdi+1]
mov r12d, edi
test edi, eax
jnz short loc_1180
loc_117A:
mov eax, r12d
pop r12
retn
loc_1180:
mov edx, edi
pxor xmm0, xmm0
not edx
and eax, edx
cvtsi2sd xmm0, eax
call _log2
addsd... | long long func0(unsigned int a1)
{
unsigned int v1; // r12d
v1 = 1;
if ( a1 && (v1 = a1, ((a1 + 1) & a1) != 0) )
return (1 << ((int)(log2((double)(int)(~a1 & (a1 + 1))) + 1.0) - 1)) | a1;
else
return v1;
} | func0:
ENDBR64
PUSH R12
MOV R12D,0x1
TEST EDI,EDI
JZ 0x0010117a
LEA EAX,[RDI + 0x1]
MOV R12D,EDI
TEST EDI,EAX
JNZ 0x00101180
LAB_0010117a:
MOV EAX,R12D
POP R12
RET
LAB_00101180:
MOV EDX,EDI
PXOR XMM0,XMM0
NOT EDX
AND EAX,EDX
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
MOV EAX,0x1
CVTTSD2SI ECX,X... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(uint param_1)
{
uint uVar1;
double dVar2;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = param_1, (param_1 & param_1 + 1) != 0)) {
dVar2 = log2((double)(int)(param_1 + 1 & ~param_1));
return param_1 | 1 << ((... |
6,579 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 1;
}
if ((n & (n + 1)) == 0) {
return n;
}
int pos = (int)(log2((~n) & -(~n)) + 1);
return ((1 << (pos - 1)) | n);
}
| int main() {
assert(func0(21) == 23);
assert(func0(11) == 15);
assert(func0(15) == 15);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%r12d
test %edi,%edi
je 117a <func0+0x1a>
lea 0x1(%rdi),%edx
mov %edi,%r12d
test %edx,%edi
jne 1180 <func0+0x20>
mov %r12d,%eax
pop %r12
retq
mov %edi,%eax
pxor %xmm0,%xmm0
not %eax
and %edx,%eax
cvtsi2sd %eax,%xmm0
callq 1050 <log2@plt>
addsd 0... | func0:
endbr64
push rbx
mov ebx, 1
test edi, edi
jz short loc_1177
lea eax, [rdi+1]
mov ebx, edi
test edi, eax
jnz short loc_1180
loc_1177:
mov eax, ebx
pop rbx
retn
loc_1180:
mov edx, edi
pxor xmm0, xmm0
not edx
and eax, edx
cvtsi2sd xmm0, eax; x
call _log2
addsd... | long long func0(unsigned int a1)
{
unsigned int v1; // ebx
v1 = 1;
if ( a1 && (v1 = a1, ((a1 + 1) & a1) != 0) )
return (1 << ((int)(log2((double)(int)(~a1 & (a1 + 1))) + 1.0) - 1)) | a1;
else
return v1;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,0x1
TEST EDI,EDI
JZ 0x00101177
LEA EAX,[RDI + 0x1]
MOV EBX,EDI
TEST EDI,EAX
JNZ 0x00101180
LAB_00101177:
MOV EAX,EBX
POP RBX
RET
LAB_00101180:
MOV EDX,EDI
PXOR XMM0,XMM0
NOT EDX
AND EAX,EDX
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
MOV EAX,0x1
CVTTSD2SI ECX,XMM0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(uint param_1)
{
uint uVar1;
double dVar2;
uVar1 = 1;
if ((param_1 != 0) && (uVar1 = param_1, (param_1 & param_1 + 1) != 0)) {
dVar2 = log2((double)(int)(param_1 + 1 & ~param_1));
return param_1 | 1 << ((... |
6,580 | func0 | #include <assert.h>
| int func0(int num1, int num2, int num3) {
int lnum;
if ((num1 >= num2) && (num1 >= num3)) {
lnum = num1;
} else if ((num2 >= num1) && (num2 >= num3)) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jl 1172 <func0+0x29>
mov -0x14(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1172 <func0+0x29>
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1190... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jl short loc_1172
mov eax, [rbp+var_14]
cmp eax, [rbp+var_1C]
jl short loc_1172
mov eax, [rbp+var_14]
mov [rbp+var_4], e... | long long func0(signed int a1, signed int a2, signed int a3)
{
if ( a1 < a2 || a1 < a3 )
{
if ( a2 < a1 || a2 < a3 )
return (unsigned int)a3;
else
return (unsigned int)a2;
}
else
{
return (unsigned int)a1;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JL 0x00101172
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101172
MOV EAX,dword ptr [RBP + -0x14]
... | int func0(int param_1,int param_2,int param_3)
{
int local_c;
if ((((param_1 < param_2) || (local_c = param_1, param_1 < param_3)) &&
(local_c = param_3, param_1 <= param_2)) && (param_3 <= param_2)) {
local_c = param_2;
}
return local_c;
} |
6,581 | func0 | #include <assert.h>
| int func0(int num1, int num2, int num3) {
int lnum;
if ((num1 >= num2) && (num1 >= num3)) {
lnum = num1;
} else if ((num2 >= num1) && (num2 >= num3)) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp %edx,%esi
mov %edx,%ecx
cmovge %esi,%ecx
cmp %ecx,%edi
jge 1146 <func0+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
| func0:
endbr64
mov eax, edi
cmp esi, edx
mov ecx, edx
cmovge ecx, esi
cmp edi, ecx
jge short locret_1146
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, edx
cmovge eax, esi
locret_1146:
retn | long long func0(int a1, int a2, int a3)
{
long long result; // rax
int v4; // ecx
bool v5; // cc
result = (unsigned int)a1;
v4 = a3;
if ( a2 >= a3 )
v4 = a2;
if ( a1 < v4 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a3;
if ( !v5 )
... | func0:
ENDBR64
MOV EAX,EDI
CMP ESI,EDX
MOV ECX,EDX
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x00101146
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,EDX
CMOVGE EAX,ESI
LAB_00101146:
RET | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = param_3;
if (param_3 <= param_2) {
iVar1 = param_2;
}
if (param_1 < iVar1) {
iVar1 = param_1;
if (param_1 < param_3) {
iVar1 = param_3;
}
param_1 = param_3;
if (iVar1 <= param_2) {
param_1 = param_2;
... |
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.