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,582 | 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;
}
| O2 | c | func0:
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovge %esi,%ecx
cmp %ecx,%edi
jge 115d <func0+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovge ecx, esi
cmp edi, ecx
jge short locret_115D
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, edx
cmovge eax, esi
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 >= a3 )
v3 = a2;
if ( a1 < v3 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a3;
if ( !v5 )
... | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x0010115d
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,EDX
CMOVGE EAX,ESI
LAB_0010115d:
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;
... |
6,583 | 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;
}
| O3 | c | func0:
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovge %esi,%ecx
cmp %ecx,%edi
jge 115d <func0+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovge ecx, esi
cmp edi, ecx
jge short locret_115D
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, esi
cmovl eax, edx
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 >= a3 )
v3 = a2;
if ( a1 < v3 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a2;
if ( v5 )
... | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x0010115d
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,ESI
CMOVL EAX,EDX
LAB_0010115d:
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_2;
if (param_2 < iVar1) {
param_1 = param_3;
... |
6,584 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = size... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b5 <func0+0x4c>
mov -0x8(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11B5
loc_1188:
mov edx, [rbp+var_8]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov ecx, eax
mov eax, [rbp+var_4]
cdqe
lea ... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 = 10 * v3 + *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b5
LAB_00101188:
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LE... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = *(int *)(param_1 + (long)local_c * 4) + local_10 * 10;
}
return local_10;
} |
6,585 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = size... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1195 <func0+0x2c>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%edx
lea (%rdx,%rdx,4),%ecx
mov (%rax),%edx
lea (%rdx,%rcx,2),%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1... | func0:
endbr64
test esi, esi
jle short loc_1195
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
lea ecx, [rdx+rdx*4]
mov edx, [rax]
lea edx, [rdx+rcx*2]
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1192:
mov eax, edx
retn
loc_1195:
mov e... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 = *v2++ + 10 * v4;
while ( v2 != (_DWORD *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101195
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
LEA ECX,[RDX + RDX*0x4]
MOV EDX,dword ptr [RAX]
LEA EDX,[RDX + RCX*0x2]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101192:
MOV EAX,EDX
RET
LAB_00101195:
MOV EDX,0x0
JMP 0x00101192 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = *param_1 + iVar2 * 10;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
6,586 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = size... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rcx,%rdi
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax... | func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rdi, rcx
jnz short loc_1158
retn
loc_1170:
xor eax, eax
ret... | long long func0(int *a1, int a2)
{
long long v2; // rcx
long long result; // rax
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( a1 != ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RDI,RCX
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (param_1 != piVar1);
return iVar3;
}
... |
6,587 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = size... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rdi,%rcx
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
xor eax, eax
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rcx, rdi
jnz short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rcx
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
LODWORD(result) = 0;
v3 = &a1[a2];
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RCX,RDI
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (piVar1 != param_1);
return iVar3;
}
return 0;
} |
6,588 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != ... | int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x370,%rsp
mov %rdi,-0x368(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x368(%rbp),%rax
mov %rax,%rdi
callq 1150 <strdup@plt>
mov %rax,-0x340(%rbp)
cmpq $0x0,-0x340(%rbp)
jne 1298 <func0+0x4f>
mov $0x0,%eax
jmpq 14a8 ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 370h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+var_340], rax
cmp [rbp+var_340], 0
jnz short loc_1298
mov eax, 0
jmp loc_149B
loc_1298:
m... | char * func0(const char *a1)
{
int v2; // eax
int v3; // [rsp+10h] [rbp-360h]
int v4; // [rsp+14h] [rbp-35Ch]
int i; // [rsp+18h] [rbp-358h]
int v6; // [rsp+1Ch] [rbp-354h]
int j; // [rsp+20h] [rbp-350h]
int k; // [rsp+24h] [rbp-34Ch]
const char *s1; // [rsp+28h] [rbp-348h]
char *v10; // [rsp+30h] [rb... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x370
MOV qword ptr [RBP + -0x368],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x368]
MOV RDI,RAX
CALL 0x00101150
MOV qword ptr [RBP + -0x340],RAX
CMP qword ptr [RBP + -0x340],0x0
JNZ 0x00101298
MOV EAX,0x0
JMP 0x001014... | char * func0(char *param_1)
{
bool bVar1;
int iVar2;
char *__s;
char *__dest;
size_t sVar3;
long in_FS_OFFSET;
int local_368;
int local_360;
int local_35c;
int local_358;
int local_354;
char *local_350;
int8 auStack_338 [101];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
... |
6,589 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != ... | int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x338,%rsp
mov %fs:0x28,%rax
mov %rax,0x328(%rsp)
xor %eax,%eax
callq 1130 <strdup@plt>
mov %rax,%r15
test %rax,%rax
je 1382 <func0+0x159>
lea 0xd9b(%rip),%rsi
mov %rax,%rdi
callq 1110 <strtok@plt>
m... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 338h
mov rax, fs:28h
mov [rsp+368h+var_40], rax
xor eax, eax
call _strdup
mov r15, rax
test rax, rax
jz loc_1389
lea rsi, unk_2004
mov rdi, rax
call _strtok
mov rbp, rax
mov ... | _BYTE *func0()
{
long long v0; // rax
long long v1; // r15
long long v2; // rbp
int v3; // r13d
_BYTE *v4; // rax
_BYTE *v5; // rbp
_QWORD *v7; // rbx
int v8; // r12d
int v9; // ebp
_BYTE *v10; // rax
long long v11; // rbx
int v12; // r13d
_QWORD *v13; // rbx
_QWORD v14[109]; // [rsp+0h] [rb... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x338
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x328],RAX
XOR EAX,EAX
CALL 0x00101150
MOV R15,RAX
TEST RAX,RAX
JZ 0x00101389
LEA RSI,[0x102004]
MOV RDI,RAX
CALL 0x00101130
MOV RBP,RAX
MOV R13D,0x0
LEA R14,[0x102004]
TEST RAX,RAX
JNZ 0x... | char * func0(char *param_1)
{
int iVar1;
char *__s;
char *pcVar2;
size_t sVar3;
int8 *puVar4;
ulong uVar5;
int8 *puVar6;
uint uVar7;
long in_FS_OFFSET;
int8 local_368 [101];
long local_40;
puVar4 = local_368;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = strdup(param_1);
if (__s == ... |
6,590 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != ... | int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), ... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x348,%rsp
mov %fs:0x28,%rax
mov %rax,0x338(%rsp)
xor %eax,%eax
callq 1150 <strdup@plt>
mov %rax,0x8(%rsp)
test %rax,%rax
je 1505 <func0+0x1d5>
lea 0xc92(%rip),%rsi
mov %rax,%rdi
lea 0x10(%rsp),%r1... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 348h
mov rax, fs:28h
mov [rsp+378h+var_40], rax
xor eax, eax
call _strdup
mov [rsp+378h+var_370], rax
test rax, rax
jz loc_14B5
lea r14, unk_2004
mov rdi, rax
lea r13, [rsp+378h+var... | _BYTE *func0()
{
long long v0; // rax
int v1; // r12d
long long v2; // rbx
_QWORD *v3; // r15
long long *v4; // rbx
int v5; // r15d
long long v6; // rbp
long long v7; // rdi
_BYTE *v8; // rax
_BYTE *v9; // r14
long long v10; // rbx
long long v11; // rax
_WORD *v12; // rax
long long v14; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x348
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x338],RAX
XOR EAX,EAX
CALL 0x00101150
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x001014b5
LEA R14,[0x102004]
MOV RDI,RAX
LEA R13,[RSP + 0x10]
XOR R12D,R12D
MOV RSI,R14
CALL 0x0010114... | char * func0(char *param_1)
{
int iVar1;
char *__s;
char *pcVar2;
size_t sVar3;
char *pcVar4;
long lVar5;
int8 *puVar6;
ulong uVar7;
uint uVar8;
long in_FS_OFFSET;
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = strdup(param_1);
if (__s == (char *)... |
6,591 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != ... | int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), ... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x348,%rsp
mov %fs:0x28,%rax
mov %rax,0x338(%rsp)
xor %eax,%eax
callq 1170 <strdup@plt>
mov %rax,0x8(%rsp)
test %rax,%rax
je 155c <func0+0x20c>
lea 0xc72(%rip),%rsi
mov %rax,%rdi
lea 0x10(%rsp),%r1... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 348h
mov rax, fs:28h
mov [rsp+378h+var_40], rax
xor eax, eax
call _strdup
mov [rsp+378h+ptr], rax
test rax, rax
jz loc_155B
lea rsi, delim; " "
mov rdi, rax; s
lea r13, [rsp+378h+va... | const char * func0(const char *a1)
{
char *v1; // rax
int v2; // ebx
char *v3; // rbp
const char **v4; // r15
int v5; // ebp
const char **v6; // r12
const char *v7; // rdi
const char *v8; // rax
const char *v9; // r14
long long i; // r12
long long v11; // rsi
size_t v13; // rax
long long v14; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x348
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x338],RAX
XOR EAX,EAX
CALL 0x00101190
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x0010155b
LEA RSI,[0x102004]
MOV RDI,RAX
LEA R13,[RSP + 0x10]
XOR EBX,EBX
CALL 0x00101180
MOV RBP,RAX
... | char * func0(char *param_1)
{
int iVar1;
char *__s;
char *pcVar2;
size_t sVar3;
size_t sVar4;
int iVar5;
int8 *puVar6;
long lVar7;
long lVar8;
long in_FS_OFFSET;
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = strdup(param_1);
if (__s == (char *)0x... |
6,592 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 117f <func0+0x36>
mov -0x4(%rbp),%e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_117F
mov ... | long long func0(int a1, int a2, int a3, int a4)
{
unsigned int v5; // [rsp+1Ch] [rbp-4h]
v5 = a1 + a2;
if ( a1 + a2 < a3 || (int)v5 > a4 )
return v5;
else
return 20LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr ... | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_2 = param_2 + param_1;
if ((param_3 <= param_2) && (param_2 <= param_4)) {
param_2 = 0x14;
}
return param_2;
} |
6,593 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O1 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 113e <func0+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovle %edx,%eax
retq
| func0:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_113E
cmp eax, ecx
mov edx, 14h
cmovle eax, edx
locret_113E:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result <= a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x0010113e
CMP EAX,ECX
MOV EDX,0x14
CMOVLE EAX,EDX
LAB_0010113e:
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_1 = param_1 + param_2;
if ((param_3 <= param_1) && (param_1 <= param_4)) {
param_1 = 0x14;
}
return param_1;
} |
6,594 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O2 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 1155 <func0+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovle %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_1155
cmp eax, ecx
mov edx, 14h
cmovle eax, edx
locret_1155:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result <= a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x00101155
CMP EAX,ECX
MOV EDX,0x14
CMOVLE EAX,EDX
LAB_00101155:
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_1 = param_1 + param_2;
if ((param_3 <= param_1) && (param_1 <= param_4)) {
param_1 = 0x14;
}
return param_1;
} |
6,595 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O3 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 1155 <func0+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovle %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_1155
cmp eax, ecx
mov edx, 14h
cmovle eax, edx
locret_1155:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result <= a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x00101155
CMP EAX,ECX
MOV EDX,0x14
CMOVLE EAX,EDX
LAB_00101155:
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_1 = param_1 + param_2;
if ((param_3 <= param_1) && (param_1 <= param_4)) {
param_1 = 0x14;
}
return param_1;
} |
6,596 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] =... | int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(r... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
add $0x1,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 122e <fu... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_122E
mov ... | _BYTE * func0(const char *a1)
{
long long v2; // rax
long long v3; // [rsp+10h] [rbp-20h]
size_t i; // [rsp+18h] [rbp-18h]
size_t v5; // [rsp+20h] [rbp-10h]
_BYTE *v6; // [rsp+28h] [rbp-8h]
v5 = strlen(a1);
v6 = malloc(v5 + 1);
if ( !v6 )
return 0LL;
v3 = 0LL;
for ( i = 0LL; i < v5; ++i )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010122... | void * func0(char *param_1)
{
size_t sVar1;
void *pvVar2;
ushort **ppuVar3;
long local_28;
ulong local_20;
sVar1 = strlen(param_1);
pvVar2 = malloc(sVar1 + 1);
if (pvVar2 == (void *)0x0) {
pvVar2 = (void *)0x0;
}
else {
local_28 = 0;
for (local_20 = 0; local_20 < sVar1; local_20 = lo... |
6,597 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] =... | int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(r... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
lea -0x1(%rdi),%rbx
callq 10a0 <malloc@plt>
mov %rax,%rbp
test %rax,%rax
je 1218 <func0+0x6f>
test %rbx,%rbx
je 1213 <func0+0x6a>... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
call _strlen
mov r13, rax
mov rbx, rax
lea rdi, [rax+1]
call _malloc
mov rbp, rax
test rax, rax
jz short loc_1255
test r13, r13
jz short loc_1250
call ___ctype_b_loc
mov rdi, [rax]... | long long func0(_BYTE *a1)
{
long long v2; // r13
long long v3; // rbx
long long v4; // rbp
long long v5; // rdi
_BYTE *v6; // rax
v2 = strlen();
v3 = v2;
v4 = malloc(v2 + 1);
if ( v4 )
{
if ( v2 )
{
v5 = *(_QWORD *)__ctype_b_loc();
v6 = a1;
v3 = 0LL;
do
{
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
CALL 0x001010b0
MOV R13,RAX
MOV RBX,RAX
LEA RDI,[RAX + 0x1]
CALL 0x001010e0
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101255
TEST R13,R13
JZ 0x00101250
CALL 0x001010f0
MOV RDI,qword ptr [RAX]
MOV RAX,R12
LEA RSI,[R12 + R13*0x1]
MOV EBX,0x0
JMP 0x0010123a
... | void * func0(byte *param_1)
{
byte *pbVar1;
ushort *puVar2;
size_t sVar3;
void *pvVar4;
ushort **ppuVar5;
sVar3 = strlen((char *)param_1);
pvVar4 = malloc(sVar3 + 1);
if (pvVar4 != (void *)0x0) {
if (sVar3 != 0) {
ppuVar5 = __ctype_b_loc();
puVar2 = *ppuVar5;
pbVar1 = param_1 +... |
6,598 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] =... | int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(r... | O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 10a0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbp
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 13b6 <func0+0x66>
test %rbp,%rbp
je 13c0 <func0+0x70>
callq 10d0 <__ctype_b_loc@plt>
mov %rbx,%rdi
lea (%rbx,... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]
mov rbp, rax
call _malloc
mov r12, rax
test rax, rax
jz short loc_13B1
test rbp, rbp
jz short loc_13C0
call ___ctype_b_loc
lea rdi, [rbx+rbp]
xor esi, esi
mov r8, [rax]
mov ... | long long func0(unsigned __int8 *a1)
{
long long v2; // rbp
long long v3; // rax
long long v4; // r12
unsigned __int8 *v5; // rdi
long long v6; // rsi
long long v7; // r8
unsigned __int8 *v8; // rax
long long v9; // rcx
_BYTE *v10; // rsi
v2 = strlen();
v3 = malloc(v2 + 1);
v4 = v3;
if ( v3 ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x001010b0
LEA RDI,[RAX + 0x1]
MOV RBP,RAX
CALL 0x001010e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001013b1
TEST RBP,RBP
JZ 0x001013c0
CALL 0x001010f0
LEA RDI,[RBX + RBP*0x1]
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101390:
MOVZX ... | int1 * func0(byte *param_1)
{
byte *pbVar1;
ushort *puVar2;
size_t sVar3;
int1 *puVar4;
ushort **ppuVar5;
long lVar6;
int1 *puVar7;
sVar3 = strlen((char *)param_1);
puVar4 = (int1 *)malloc(sVar3 + 1);
if (puVar4 != (int1 *)0x0) {
puVar7 = puVar4;
if (sVar3 != 0) {
ppuVar5 = __ctype... |
6,599 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] =... | int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(r... | O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 10a0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbp
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 13b6 <func0+0x66>
test %rbp,%rbp
je 13c0 <func0+0x70>
callq 10d0 <__ctype_b_loc@plt>
mov %rbx,%rdi
lea (%rbx,... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]; size
mov rbp, rax
call _malloc
mov r12, rax
test rax, rax
jz short loc_13B1
test rbp, rbp
jz short loc_13C0
call ___ctype_b_loc
lea rdi, [rbx+rbp]
xor esi, esi
mov r8, [rax... | _BYTE * func0(const char *a1)
{
size_t v2; // rbp
_BYTE *v3; // rax
_BYTE *v4; // r12
unsigned __int8 *v5; // rdi
long long v6; // rsi
const unsigned __int16 *v7; // r8
const char *v8; // rax
long long v9; // rcx
_BYTE *v10; // rsi
v2 = strlen(a1);
v3 = malloc(v2 + 1);
v4 = v3;
if ( v3 )
{
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x001010b0
LEA RDI,[RAX + 0x1]
MOV RBP,RAX
CALL 0x001010e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001013b1
TEST RBP,RBP
JZ 0x001013c0
CALL 0x001010f0
LEA RDI,[RBX + RBP*0x1]
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101390:
MOVZX ... | int * func0(byte *param_1)
{
byte *pbVar1;
ushort *puVar2;
size_t sVar3;
int *puVar4;
ushort **ppuVar5;
long lVar6;
int *puVar7;
sVar3 = strlen((char *)param_1);
puVar4 = (int *)malloc(sVar3 + 1);
if (puVar4 != (int *)0x0) {
puVar7 = puVar4;
if (sVar3 != 0) {
ppuVar5 = __ctype_b_lo... |
6,600 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
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),%edx
mov -0x18(%rbp),%eax
add %eax,%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
cmpl $0xb4,-0x4(%rbp)
jne 117a <func0+0x31>
mov $0x1,%eax
jmp 11... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add edx, eax
mov eax, [rbp+var_1C]
add eax, edx
mov [rbp+var_4], eax
cmp [rbp+var_4], 0B4h
jnz short loc_117A
mov eax,... | _BOOL8 func0(int a1, int a2, int a3)
{
return a2 + a1 + a3 == 180;
} | 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 EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0xb4
JNZ 0... | bool func0(int param_1,int param_2,int param_3)
{
return param_3 + param_1 + param_2 == 0xb4;
} |
6,601 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
| func0:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
6,602 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
6,603 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
6,604 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1216 <func0+0x6d>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_8], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_C], 0
jmp short loc_1216
loc_11D8:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, r... | const char * func0(const char *a1)
{
int v1; // eax
int i; // [rsp+14h] [rbp-Ch]
int v4; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
if ( a1[i] != 32 )
{
v1 = v4++;
a1[v1] = a1[i];
}
}
a1[v4] = 0;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x8],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101216
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qwo... | char * func0(char *param_1)
{
size_t sVar1;
int local_14;
int local_10;
local_10 = 0;
sVar1 = strlen(param_1);
for (local_14 = 0; local_14 < (int)sVar1; local_14 = local_14 + 1) {
if (param_1[local_14] != ' ') {
param_1[local_10] = param_1[local_14];
local_10 = local_10 + 1;
}
}
... |
6,605 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11b7 <func0+0x4e>
mov %rsi,%rax
lea -0x1(%rcx),%edx
lea 0x1(%rsi,%rdx,1),%r8
mov $0x0,%ecx
jmp 11ad <func0+0x44>
movslq %ecx,%rdi
mov %dl,(%rs... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_11E7
mov rdx, rbx
lea eax, [rax-1]
lea rdi, [rbx+rax+1]
mov ecx, 0
jmp short loc_11D5
loc_11CC:
add rdx, 1
cmp rdx, rdi
jz short loc_11EC
loc_11D5:
movzx eax, byte ptr [rdx]
cmp al, 20h ... | _BYTE * func0(_BYTE *a1)
{
int v2; // eax
_BYTE *v3; // rdx
long long v4; // rdi
int v5; // ecx
v2 = strlen();
if ( v2 <= 0 )
{
v5 = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[v2 - 1 + 1];
v5 = 0;
do
{
if ( *v3 != 32 )
a1[v5++] = *v3;
++v3;
}
while ... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001011e7
MOV RDX,RBX
LEA EAX,[RAX + -0x1]
LEA RDI,[RBX + RAX*0x1 + 0x1]
MOV ECX,0x0
JMP 0x001011d5
LAB_001011cc:
ADD RDX,0x1
CMP RDX,RDI
JZ 0x001011ec
LAB_001011d5:
MOVZX EAX,byte ptr [RDX]
CMP AL,0x20
JZ 0x001011cc
MOVSXD RSI,ECX
MOV byte ptr [RBX ... | char * func0(char *param_1)
{
size_t sVar1;
int iVar2;
char *pcVar3;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
pcVar3 = param_1;
do {
if (*pcVar3 != ' ') {
param_1[iVar2] = *pcVar3;
iVar2 = iVar2 + 1;
}
pcVar3 = pcVa... |
6,606 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdi,%r12
callq 1070 <strlen@plt>
test %eax,%eax
jle 13c8 <func0+0x58>
sub $0x1,%eax
mov %r12,%rdx
xor %edi,%edi
xor %esi,%esi
lea 0x1(%r12,%rax,1),%r8
nopl 0x0(%rax)
movzbl (%rdx),%eax
lea (%r12,%rsi,1),%rcx
cmp $0x20,%al
je 13af <func0+0x3f>
add $0... | func0:
endbr64
push r12
mov r12, rdi
call _strlen
test eax, eax
jle short loc_13D0
sub eax, 1
mov rdx, r12
lea rdi, [r12+rax+1]
xor eax, eax
nop
loc_13A0:
movzx ecx, byte ptr [rdx]
cmp cl, 20h ; ' '
jz short loc_13B2
movsxd rsi, eax
add eax, 1
mov [r12+rsi], cl
loc_1... | _BYTE * func0(_BYTE *a1)
{
int v2; // eax
_BYTE *v3; // rdx
long long v4; // rdi
int v5; // eax
long long v6; // rsi
v2 = strlen();
if ( v2 <= 0 )
{
*a1 = 0;
return a1;
}
else
{
v3 = a1;
v4 = (long long)&a1[v2 - 1 + 1];
v5 = 0;
do
{
if ( *v3 != 32 )
{
... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001013d0
SUB EAX,0x1
MOV RDX,R12
LEA RDI,[R12 + RAX*0x1 + 0x1]
XOR EAX,EAX
NOP
LAB_001013a0:
MOVZX ECX,byte ptr [RDX]
CMP CL,0x20
JZ 0x001013b2
MOVSXD RSI,EAX
ADD EAX,0x1
MOV byte ptr [R12 + RSI*0x1],CL
LAB_001013b2:
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x00... | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
iVar1 = 0;
pcVar3 = param_1;
do {
if (*pcVar3 != ' ') {
lVar4 = (long)iVar1;
iVar1 = iVar1 + 1;
param_1[lVar4] = *pcVar3;
}
... |
6,607 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdi,%r12
callq 1070 <strlen@plt>
test %eax,%eax
jle 13c8 <func0+0x58>
sub $0x1,%eax
mov %r12,%rdx
xor %edi,%edi
xor %esi,%esi
lea 0x1(%r12,%rax,1),%r8
nopl 0x0(%rax)
movzbl (%rdx),%eax
lea (%r12,%rsi,1),%rcx
cmp $0x20,%al
je 13af <func0+0x3f>
add $0... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_13D0
sub eax, 1
mov rdx, rbx
lea rdi, [rbx+rax+1]
xor eax, eax
xchg ax, ax
loc_13A0:
movzx ecx, byte ptr [rdx]
cmp cl, 20h ; ' '
jz short loc_13B1
movsxd rsi, eax
add eax, 1
mov [rbx+rsi... | const char * func0(const char *a1)
{
int v2; // eax
const char *v3; // rdx
long long v4; // rdi
int v5; // eax
long long v6; // rsi
v2 = strlen(a1);
if ( v2 <= 0 )
{
*a1 = 0;
return a1;
}
else
{
v3 = a1;
v4 = (long long)&a1[v2 - 1 + 1];
v5 = 0;
do
{
if ( *v3 != 3... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001013d0
SUB EAX,0x1
MOV RDX,RBX
LEA RDI,[RBX + RAX*0x1 + 0x1]
XOR EAX,EAX
NOP
LAB_001013a0:
MOVZX ECX,byte ptr [RDX]
CMP CL,0x20
JZ 0x001013b1
MOVSXD RSI,EAX
ADD EAX,0x1
MOV byte ptr [RBX + RSI*0x1],CL
LAB_001013b1:
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x00... | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
iVar1 = 0;
pcVar3 = param_1;
do {
if (*pcVar3 != ' ') {
lVar4 = (long)iVar1;
iVar1 = iVar1 + 1;
param_1[lVar4] = *pcVar3;
}
... |
6,608 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer"... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
mov rax, [rax]
pop rbp
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(8LL * a2 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
POP RBP
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,609 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer"... | O1 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi,%rsi,8),%rax
retq
| func0:
endbr64
movsxd rsi, esi
mov rax, [rdi+rsi*8]
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(a1 + 8LL * a2);
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV RAX,qword ptr [RDI + RSI*0x8]
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,610 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer"... | O2 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi,%rsi,8),%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
movsxd rsi, esi
mov rax, [rdi+rsi*8]
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(a1 + 8LL * a2);
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV RAX,qword ptr [RDI + RSI*0x8]
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,611 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer"... | O3 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi,%rsi,8),%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
movsxd rsi, esi
mov rax, [rdi+rsi*8]
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(a1 + 8LL * a2);
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV RAX,qword ptr [RDI + RSI*0x8]
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,612 | func0 |
#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 array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| 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,613 | func0 |
#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 array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| 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)
jg 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
jg 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
JG 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,614 | func0 |
#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 array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| 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)
jle 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
jle 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
JLE 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,615 | func0 |
#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 array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| 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
jge 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
jge 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
JGE 0x00101160
XOR EAX,EAX
RET
LAB_00101178:
MOV EAX,0... | 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,616 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1165 <func0+0x1c>
mov $0x2,%eax
jmp 1192 <func0+0x49>
movl $0x3,-0x4(%rbp)
jmp 1184 <func0+0x3b>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%ea... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jnz short loc_1165
mov eax, 2
jmp short loc_1192
loc_1165:
mov [rbp+var_4], 3
jmp short loc_1184
loc_116E:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, ed... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
if ( (a1 & 1) == 0 )
return 2LL;
for ( i = 3; a1 >= i * i; i += 2 )
{
if ( !(a1 % i) )
return (unsigned int)i;
}
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101165
MOV EAX,0x2
JMP 0x00101192
LAB_00101165:
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00101184
LAB_0010116e:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TES... | uint func0(uint param_1)
{
uint uVar1;
uint local_c;
if ((param_1 & 1) == 0) {
uVar1 = 2;
}
else {
for (local_c = 3;
(uVar1 = param_1, (int)(local_c * local_c) <= (int)param_1 &&
(uVar1 = local_c, (int)param_1 % (int)local_c != 0)); local_c = local_c + 2) {
}
}
return uVar1... |
6,617 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x2,%ecx
test $0x1,%dil
je 1197 <func0+0x4e>
cmp $0x8,%edi
jle 119a <func0+0x51>
movslq %edi,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,2),%eax
cmp %eax,%edi
je 119e <func0+0x55>
mov $0x3,%ecx
add... | func0:
endbr64
mov ecx, 2
test dil, 1
jz short loc_1197
cmp edi, 8
jle short loc_119A
movsxd rax, edi
imul rax, 55555556h
shr rax, 20h
mov edx, edi
sar edx, 1Fh
sub eax, edx
lea eax, [rax+rax*2]
cmp edi, eax
jz short loc_119E
mov ecx, 3
loc_117E:
add ecx, 2
m... | long long func0(int a1)
{
unsigned int v1; // ecx
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 <= 8 )
{
return (unsigned int)a1;
}
else if ( a1 == 3 * (a1 / 3) )
{
return 3;
}
else
{
v1 = 3;
while ( 1 )
{
v1 += 2;
if ( (int)(v1 * v1) > a1... | func0:
ENDBR64
MOV ECX,0x2
TEST DIL,0x1
JZ 0x00101197
CMP EDI,0x8
JLE 0x0010119a
MOVSXD RAX,EDI
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
LEA EAX,[RAX + RAX*0x2]
CMP EDI,EAX
JZ 0x0010119e
MOV ECX,0x3
LAB_0010117e:
ADD ECX,0x2
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x00101195
MOV EAX,EDI... | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 2;
if (((param_1 & 1) != 0) && (uVar1 = param_1, 8 < (int)param_1)) {
if (param_1 == ((int)param_1 / 3) * 3) {
uVar1 = 3;
}
else {
uVar1 = 3;
do {
uVar1 = uVar1 + 2;
if ((int)param_1 < (int)(uVar1 * uVar1)) {
... |
6,618 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O2 | c | func0:
endbr64
test $0x1,%dil
je 1230 <func0+0x10>
jmp 11c0 <func0.part.0>
nopl 0x0(%rax)
mov $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r8d, 2
test dil, 1
jz short loc_118C
cmp edi, 8
jle short loc_1189
imul eax, edi, 0AAAAAAABh
mov r8d, 3
add eax, 2AAAAAAAh
cmp eax, 55555554h
ja short loc_117A
jmp short loc_118C
loc_1170:
mov eax, edi
cdq
idiv r8d
test edx, edx
jz short loc_... | long long func0(int a1)
{
unsigned int v1; // r8d
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 > 8 )
{
v1 = 3;
if ( (unsigned int)(-1431655765 * a1 + 715827882) <= 0x55555554 )
return v1;
while ( 1 )
{
v1 += 2;
if ( a1 < (int)(v1 * v1) )
break;
... | func0:
ENDBR64
MOV R8D,0x2
TEST DIL,0x1
JZ 0x0010118c
CMP EDI,0x8
JLE 0x00101189
IMUL EAX,EDI,-0x55555555
MOV R8D,0x3
ADD EAX,0x2aaaaaaa
CMP EAX,0x55555554
JA 0x0010117a
JMP 0x0010118c
LAB_00101170:
MOV EAX,EDI
CDQ
IDIV R8D
TEST EDX,EDX
JZ 0x0010118c
LAB_0010117a:
ADD R8D,0x2
MOV EAX,R8D
IMUL EAX,R8D
CMP EDI,EAX
JGE 0x... | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 2;
if ((((param_1 & 1) != 0) && (uVar1 = param_1, 8 < (int)param_1)) &&
(uVar1 = 3, 0x55555554 < param_1 * -0x55555555 + 0x2aaaaaaa)) {
do {
uVar1 = uVar1 + 2;
if ((int)param_1 < (int)(uVar1 * uVar1)) {
return param_1;
}
} w... |
6,619 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x2,%r8d
test $0x1,%dil
je 118c <func0+0x4c>
cmp $0x8,%edi
jle 1189 <func0+0x49>
imul $0xaaaaaaab,%edi,%eax
mov $0x3,%r8d
add $0x2aaaaaaa,%eax
cmp $0x55555554,%eax
ja 117a <func0+0x3a>
jmp 118c <func0+0x4c>
mov %edi,%eax
cltd
idiv %r8d
test %edx,%edx
je 11... | func0:
endbr64
mov ecx, 2
test dil, 1
jz short loc_1187
cmp edi, 8
jle short loc_1185
imul eax, edi, 0AAAAAAABh
mov ecx, 3
add eax, 2AAAAAAAh
cmp eax, 55555554h
ja short loc_1179
jmp short loc_1187
loc_1170:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_... | long long func0(int a1)
{
unsigned int v1; // ecx
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 > 8 )
{
v1 = 3;
if ( (unsigned int)(-1431655765 * a1 + 715827882) <= 0x55555554 )
return v1;
while ( 1 )
{
v1 += 2;
if ( a1 < (int)(v1 * v1) )
break;
... | func0:
ENDBR64
MOV ECX,0x2
TEST DIL,0x1
JZ 0x00101187
CMP EDI,0x8
JLE 0x00101185
IMUL EAX,EDI,-0x55555555
MOV ECX,0x3
ADD EAX,0x2aaaaaaa
CMP EAX,0x55555554
JA 0x00101179
JMP 0x00101187
LAB_00101170:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101187
LAB_00101179:
ADD ECX,0x2
MOV EAX,ECX
IMUL EAX,ECX
CMP EDI,EAX
JGE 0x... | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 2;
if ((((param_1 & 1) != 0) && (uVar1 = param_1, 8 < (int)param_1)) &&
(uVar1 = 3, 0x55555554 < param_1 * -0x55555555 + 0x2aaaaaaa)) {
do {
uVar1 = uVar1 + 2;
if ((int)param_1 < (int)(uVar1 * uVar1)) {
return param_1;
}
} w... |
6,620 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d3 <func0+0x6a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
mov [rbp+var_4], 0
jmp short loc_11D3
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]... | long long func0(long long a1, long long a2, int a3, long long a4)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a3; ++i )
*(_DWORD *)(4LL * i + a4) = *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4LL * i + a2);
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d3
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | long func0(long param_1,long param_2,int param_3,long param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int *)(param_4 + (long)local_c * 4) =
*(int *)(param_2 + (long)local_c * 4) * *(int *)(param_1 + (long)local_c * 4);
}
return param_4;
} |
6,621 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
... | O1 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1195 <func0+0x2c>
lea -0x1(%rdx),%ecx
mov $0x0,%edx
mov (%rdi,%rdx,4),%r8d
imul (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 117c <func0+0x13>
retq
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_1192
mov edx, edx
mov r8d, 0
loc_117C:
mov r9d, [rdi+r8*4]
imul r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp r8, rdx
jnz short loc_117C
locret_1192:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a2 + 4 * i) * *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x00101192
MOV EDX,EDX
MOV R8D,0x0
LAB_0010117c:
MOV R9D,dword ptr [RDI + R8*0x4]
IMUL R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP R8,RDX
JNZ 0x0010117c
LAB_00101192:
RET | void func0(long param_1,long param_2,uint param_3,long param_4)
{
ulong uVar1;
if (0 < (int)param_3) {
uVar1 = 0;
do {
*(int *)(param_4 + uVar1 * 4) = *(int *)(param_1 + uVar1 * 4) * *(int *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
return;
} |
6,622 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
... | O2 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1169 <func0+0x29>
lea -0x1(%rdx),%ecx
xor %edx,%edx
mov (%rdi,%rdx,4),%r8d
imul (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 1150 <func0+0x10>
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_116E
movsxd rdx, edx
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_1158:
mov r9d, [rdi+r8*4]
imul r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp rdx, r8
jnz short loc_1158
locret_116E:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a2 + 4 * i) * *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x0010116e
MOVSXD RDX,EDX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101158:
MOV R9D,dword ptr [RDI + R8*0x4]
IMUL R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP RDX,R8
JNZ 0x00101158
LAB_0010116e:
RET | void func0(long param_1,long param_2,int param_3,long param_4)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
*(int *)(param_4 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) * *(int *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_3 != lVar1);
}
return;
} |
6,623 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
... | O3 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 123e <func0+0xfe>
lea 0xf(%rcx),%rcx
lea -0x1(%rdx),%r8d
mov %rcx,%r9
sub %rdi,%r9
cmp $0x1e,%r9
seta %r10b
cmp $0x2,%r8d
seta %r9b
test %r9b,%r10b
je 1220 <func0+0xe0>
sub %rsi,%rcx
cmp $0x1e,%rcx
jbe 1220 <func0+0xe0>
mov ... | func0:
endbr64
mov r8, rsi
test edx, edx
jle loc_1223
lea eax, [rdx-1]
cmp eax, 2
jbe loc_1230
lea rsi, [rdi+4]
mov rax, rcx
sub rax, rsi
cmp rax, 8
jbe loc_1230
lea rsi, [r8+4]
mov rax, rcx
sub rax, rsi
cmp rax, 8
jbe loc_1230
mov esi, edx
xor eax,... | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long v5; // rax
unsigned int v6; // esi
long long v7; // rax
long long v9; // rax
if ( a3 <= 0 )
return a4;
if ( (unsigned int)(a3 - 1) > 2 && (unsigned long long)(a4 - (a1 + 4)) > 8 && (unsigned long long)(a4 - (a2 + 4)) > 8 )
... | func0:
ENDBR64
MOV R8,RSI
TEST EDX,EDX
JLE 0x00101223
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x00101230
LEA RSI,[RDI + 0x4]
MOV RAX,RCX
SUB RAX,RSI
CMP RAX,0x8
JBE 0x00101230
LEA RSI,[R8 + 0x4]
MOV RAX,RCX
SUB RAX,RSI
CMP RAX,0x8
JBE 0x00101230
MOV ESI,EDX
XOR EAX,EAX
SHR ESI,0x2
SHL RSI,0x4
NOP
LAB_00101190:
MOVDQU XMM0... | long func0(long param_1,long param_2,uint param_3,long param_4)
{
int8 *puVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
uint uVar5;
ulong uVar6;
if (0 < (int)param_3) {
if (((param_3 - 1 < 3) || ((ulong)(param_4 - (param_1 + 4)) < 9)) ||
((ulong)(param_4 - (param_2 + 4)) < 9)) {
lVar4 =... |
6,624 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
jmp 1195 <func0+0x4c>
movl $0x1,-0x4(%rbp)
jmp 1186 <func0+0x3d>
mov -0x8(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov -0x4(%rbp),%eax
imul %eax,%eax
add %edx,%eax
cmp %eax,-0x14(%rbp)
jne 1182 <func0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
jmp short loc_1195
loc_115D:
mov [rbp+var_4], 1
jmp short loc_1186
loc_1166:
mov eax, [rbp+var_8]
imul eax, eax
mov edx, eax
mov eax, [rbp+var_4]
imul eax, eax
add eax, edx
cmp [rbp+var_14]... | long long func0(int a1)
{
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
for ( i = 1; a1 >= i * i; ++i )
{
for ( j = 1; a1 >= j * j; ++j )
{
if ( a1 == i * i + j * j )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101195
LAB_0010115d:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101186
LAB_00101166:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
ADD EAX,EDX
CMP dword ptr [RBP +... | int8 func0(int param_1)
{
int local_10;
int local_c;
local_10 = 1;
do {
if (param_1 < local_10 * local_10) {
return 0;
}
for (local_c = 1; local_c * local_c <= param_1; local_c = local_c + 1) {
if (param_1 == local_c * local_c + local_10 * local_10) {
return 1;
}
}
... |
6,625 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%esi
mov $0x1,%ecx
test %edi,%edi
jle 117f <func0+0x36>
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 1197 <func0+0x4e>
mov $0x1,%edx
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
cmp %edi,%eax
jg 1185 <func0+0x3c>
add %ecx,%eax
cmp %edi,%eax
jne 1167 <func0+0x... | func0:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_117F
loc_115B:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_1197
mov edx, 1
loc_1167:
add edx, 1
mov eax, edx
imul eax, edx
cmp eax, edi
jg short loc_1185
add eax, ecx
cmp eax, edi
jnz short lo... | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
... | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x0010117f
LAB_0010115b:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x00101197
MOV EDX,0x1
LAB_00101167:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JG 0x00101185
ADD EAX,ECX
CMP EAX,EDI
JNZ 0x00101167
MOV EAX,0x1
RET
LAB_0010117f:
MOV EAX,0x0
RET
LAB_00101185:
ADD E... | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (param_1 < 1) {
return 0;
}
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
if (iVar2 * iVar2... |
6,626 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%esi
mov $0x1,%ecx
test %edi,%edi
jle 12ce <func0+0x3e>
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 12d8 <func0+0x48>
mov $0x1,%edx
jmp 12b6 <func0+0x26>
add %ecx,%eax
cmp %edi,%eax
je 12d8 <func0+0x48>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
cmp %edi,%... | func0:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_122E
loc_1202:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_1238
mov edx, 1
jmp short loc_1216
loc_1210:
add eax, ecx
cmp eax, edi
jz short loc_1238
loc_1216:
add edx, 1
mov eax, edx
imul eax, edx
... | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
... | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x0010122e
LAB_00101202:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x00101238
MOV EDX,0x1
JMP 0x00101216
LAB_00101210:
ADD EAX,ECX
CMP EAX,EDI
JZ 0x00101238
LAB_00101216:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JLE 0x00101210
ADD ESI,0x1
MOV ECX,ESI
IMUL ECX,ESI... | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (0 < param_1) {
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
if (iVar2 * iVar2... |
6,627 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%esi
mov $0x1,%ecx
test %edi,%edi
jle 12ce <func0+0x3e>
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 12d8 <func0+0x48>
mov $0x1,%edx
jmp 12b6 <func0+0x26>
add %ecx,%eax
cmp %edi,%eax
je 12d8 <func0+0x48>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
cmp %edi,%... | func0:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_12DE
loc_12B2:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_12E8
mov edx, 1
jmp short loc_12C6
loc_12C0:
add eax, ecx
cmp eax, edi
jz short loc_12E8
loc_12C6:
add edx, 1
mov eax, edx
imul eax, edx
... | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
... | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x001012de
LAB_001012b2:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x001012e8
MOV EDX,0x1
JMP 0x001012c6
LAB_001012c0:
ADD EAX,ECX
CMP EAX,EDI
JZ 0x001012e8
LAB_001012c6:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JLE 0x001012c0
ADD ESI,0x1
MOV ECX,ESI
IMUL ECX,ESI... | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (0 < param_1) {
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
if (iVar2 * iVar2... |
6,628 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
f... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,%eax
mov %al,-0x2c(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x10(%rbp)
movl $0x0,-0x18(%rbp)
jmp 11ba <func0+0x51>
mov -0x18(%rbp),%eax
movslq ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov eax, esi
mov [rbp+var_2C], al
mov [rbp+var_1C], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], eax
mov [rbp+var_18], 0
jmp short loc_11BA
loc_119D:
mov eax, [rbp+var_18]
movsxd... | long long func0(const char *a1, char a2)
{
int v3; // [rsp+14h] [rbp-1Ch]
unsigned int v4; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int v7; // [rsp+20h] [rbp-10h]
v3 = 0;
v7 = strlen(a1);
for ( i = 0; i < v7; ++i )
{
if ( a2 == a1[i] )
++v3;
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x2c],AL
MOV dword ptr [RBP + -0x1c],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001011ba
LAB_0010119d:
MOV EAX,dwor... | int func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
for (local_20 = 0; local_20 < iVar1; local_20 = local_20 + 1) {
if (param_2 == param_1[local_20]) {
local_24 = local_24 + ... |
6,629 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
f... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
mov %ecx,%r9d
test %ecx,%ecx
jle 11c0 <func0+0x77>
mov %r8,%rax
lea -0x1(%rcx),%edx
lea 0x1(%r8,%rdx,1),%rdi
mov $0x0,%ecx
cmp %sil,(%rax)
sete %dl
movzbl %dl,%... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
call _strlen
mov edi, eax
test eax, eax
jle short loc_11DA
mov rdx, rbp
lea eax, [rax-1]
lea rsi, [rbp+rax+1]
mov ecx, 0
loc_1193:
cmp [rdx], bl
setz al
movzx eax, al
add ecx, eax
add r... | long long func0(_BYTE *a1, unsigned __int8 a2)
{
int v3; // eax
int v4; // edi
_BYTE *v5; // rdx
int v6; // ecx
long long result; // rax
_BYTE *v8; // rcx
v3 = strlen();
v4 = v3;
if ( v3 <= 0 )
{
v6 = 0;
}
else
{
v5 = a1;
v6 = 0;
do
v6 += *v5++ == a2;
while ( v5 != ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
CALL 0x00101060
MOV EDI,EAX
TEST EAX,EAX
JLE 0x001011da
MOV RDX,RBP
LEA EAX,[RAX + -0x1]
LEA RSI,[RBP + RAX*0x1 + 0x1]
MOV ECX,0x0
LAB_00101193:
CMP byte ptr [RDX],BL
SETZ AL
MOVZX EAX,AL
ADD ECX,EAX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x00101193
LAB_001011a6... | int func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
int iVar3;
char *pcVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
iVar3 = 0;
}
else {
iVar3 = 0;
pcVar4 = param_1;
do {
iVar3 = iVar3 + (uint)(*pcVar4 == param_2);
pcVar4 = pcVar4 + 1;... |
6,630 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
f... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %eax,%esi
test %eax,%eax
jle 12b0 <func0+0x90>
sub $0x1,%eax
mov %rbx,%rdx
xor %r8d,%r8d
lea 0x1(%rbx,%rax,1),%rcx
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
cmp %bpl,(%rdx)
sete ... | func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov edi, eax
test eax, eax
jle short loc_12B0
sub eax, 1
mov rdx, rbx
xor ecx, ecx
lea rsi, [rbx+rax+1]
nop word ptr [rax+rax+00000000h]
loc_1250:
xor eax, eax
cmp [rdx], bpl
se... | long long func0(_BYTE *a1, unsigned __int8 a2)
{
int v4; // eax
int v5; // edi
_BYTE *v6; // rdx
int v7; // ecx
long long v8; // rsi
int v9; // eax
unsigned int v10; // r8d
_BYTE *v11; // rcx
int v12; // eax
v4 = strlen();
v5 = v4;
if ( v4 <= 0 )
{
v10 = 0;
}
else
{
v6 = a1;
... | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
MOV EDI,EAX
TEST EAX,EAX
JLE 0x001012b0
SUB EAX,0x1
MOV RDX,RBX
XOR ECX,ECX
LEA RSI,[RBX + RAX*0x1 + 0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_00101250:
XOR EAX,EAX
CMP byte ptr [RDX],BPL
SETZ AL
ADD RDX,0x1
ADD ECX,EAX
CMP RDX,RSI
JNZ 0x0... | int func0(char *param_1,char param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
int iVar4;
char *pcVar5;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (iVar2 < 1) {
iVar4 = 0;
}
else {
iVar4 = 0;
pcVar5 = param_1;
do {
cVar1 = *pcVar5;
pcVar5 = pcVar5 + 1;
iVar4 ... |
6,631 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
f... | int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %eax,%esi
test %eax,%eax
jle 1570 <func0+0x350>
lea -0x1(%rax),%edx
cmp $0xe,%edx
jbe 1578 <func0+0x358>
movd %ebp,%xmm4
mov %eax,%ecx
movdqa 0xe58(%rip),%xmm7
mov %rbx,%rdx
pu... | func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
xor edx, edx
mov rdi, rax
mov esi, eax
mov eax, 0Ah
idiv edi
test edi, edi
jle loc_15E0
lea edx, [rdi-1]
cmp edx, 0Eh
jbe loc_15E7
movd xmm4, ebp
mov ecx, edi
pxor xmm1... | long long func0(const __m128i *a1, unsigned __int8 a2)
{
int v3; // edi
__m128i v4; // xmm4
__m128i v5; // xmm1
const __m128i *v6; // rdx
__m128i v7; // xmm4
__m128i v8; // xmm4
__m128i v9; // xmm0
__m128i v10; // xmm0
__m128i v11; // xmm3
__m128i v12; // xmm2
__m128i v13; // xmm0
__m128i v14; ... | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
XOR EDX,EDX
MOV RDI,RAX
MOV ESI,EAX
MOV EAX,0xa
IDIV EDI
TEST EDI,EDI
JLE 0x001015e0
LEA EDX,[RDI + -0x1]
CMP EDX,0xe
JBE 0x001015e7
MOVD XMM4,EBP
MOV ECX,EDI
PXOR XMM1,XMM1
MOV RDX,RBX
PUNPCKLBW XMM4,XMM4
SHR ECX,0x4
PXOR XMM6,XMM6
PX... | 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,632 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rcx
mov -0x34(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x18(%rbp)
movslq %eax,%rdx
mov %rdx,%r10
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
mov edx, 10h
sub rdx, 1
a... | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
_BYTE v4[12]; // [rsp+8h] [rbp-40h] BYREF
int v5; // [rsp+14h] [rbp-34h]
int i; // [rsp+1Ch] [rbp-2Ch]
int j; // [rsp+20h] [rbp-28h]
int k; // [rsp+24h] [rbp-24h]
unsigned int v9; // [rsp+28h] [rbp-20h]
int m; // [rsp+2Ch] [rbp-... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
MOV EDX,0x10
SUB RDX,0x1
ADD RAX,RDX... | int func0(int param_1)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [12];
int local_3c;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_3c = param_1;
local_10 = *(long *)(in_FS_OFFSE... |
6,633 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
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
lea 0x1(%rdi),%eax
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov esi, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
add rax, 0Fh
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11C2:
cmp rsp,... | long long func0(int a1)
{
signed long long v1; // rax
void *v2; // rsp
_BYTE *v3; // rax
int v4; // r8d
long long v5; // rcx
int v6; // edx
long long v7; // rax
unsigned int v8; // edx
long long v10; // rax
_BYTE v12[8]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v13; // [rsp+10h] [rbp-8h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
ADD RAX,0xf
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011c2:
CMP RSP,RDX
JZ 0x001011d9
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0... | int func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
int1 *puVar4;
long lVar5;
long lVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_1 + 1) + 0xf;
for (puVar7 = auStack_18; puVar... |
6,634 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
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
lea 0x1(%rdi),%eax
mov %rsp,%rsi
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je ... | func0:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
mov ebx, edi
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea eax, [rdi+1]
mov rcx, rsp
cdqe
add rax, 0Fh
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF... | long long func0(int a1)
{
_BYTE *v1; // rcx
signed long long v2; // rdx
void *v3; // rsp
int v4; // esi
long long v5; // rcx
int v6; // edx
long long v7; // rax
long long v8; // rax
unsigned int v9; // r8d
_BYTE v12[4088]; // [rsp+8h] [rbp-1020h] BYREF
_QWORD v13[4]; // [rsp+1008h] [rbp-20h] BYRE... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
MOV EBX,EDI
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
MOV RCX,RSP
CDQE
ADD RAX,0xf
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012b6
LAB_001012a1:
SUB RSP,0x1000
OR qword pt... | int func0(int param_1)
{
long lVar1;
int1 *puVar2;
int iVar3;
ulong uVar4;
long lVar5;
long lVar6;
int1 *puVar7;
int iVar9;
long in_FS_OFFSET;
int1 auStack_28 [8];
long local_20;
int1 *puVar8;
puVar7 = auStack_28;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(param_1 + 1) +... |
6,635 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
... | int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
mov %edi,%ebx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rsi
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
lea r13d, [rdi+1]
push r12
mov r12d, edi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, r13d
mov rcx, rsp
add rax, 0Fh
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
an... | long long func0(int a1)
{
_BYTE *v1; // rcx
signed long long v2; // rdx
void *v3; // rsp
int v4; // esi
long long v5; // rcx
int v6; // edx
long long v7; // rax
long long v8; // rax
unsigned int v9; // ecx
_BYTE v12[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v13[6]; // [rsp+1008h] [rbp-30h] BYRE... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
LEA R13D,[RDI + 0x1]
PUSH R12
MOV R12D,EDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,R13D
MOV RCX,RSP
ADD RAX,0xf
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012bb
LAB_001012a6:
SUB ... | int func0(int param_1)
{
long lVar1;
int *puVar2;
int iVar3;
ulong uVar4;
long lVar5;
int *puVar6;
uint uVar8;
long in_FS_OFFSET;
int auStack_38 [8];
long local_30;
int *puVar7;
puVar6 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)(param_1 + 1U) + 0xf;
puV... |
6,636 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
fr... | int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x390,%rsp
mov %rdi,-0x388(%rbp)
mov %esi,-0x38c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x37c(%rbp)
movl $0x0,-0x378(%rbp)
jmpq 1329 <func0+0x120>
movl $0x0,-0x374(%rbp)
movl $0x0,-0x370(%rbp)
jmp 12c6 <func0+0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 390h
mov [rbp+var_388], rdi
mov [rbp+var_38C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_37C], 0
mov [rbp+var_378], 0
jmp loc_1349
loc_126D:
mov [rbp+var_374], 0
mov [rbp+var_370], 0
jmp short l... | char * func0(long long a1, int a2)
{
int v3; // [rsp+14h] [rbp-37Ch]
int i; // [rsp+18h] [rbp-378h]
int v5; // [rsp+1Ch] [rbp-374h]
int j; // [rsp+20h] [rbp-370h]
int k; // [rsp+24h] [rbp-36Ch]
char *s; // [rsp+28h] [rbp-368h]
_DWORD v9[200]; // [rsp+30h] [rbp-360h]
char src[56]; // [rsp+350h] [rbp-40h]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x390
MOV qword ptr [RBP + -0x388],RDI
MOV dword ptr [RBP + -0x38c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x37c],0x0
MOV dword ptr [RBP + -0x378],0x0
JMP 0x00101349
LAB_0010126d:
MOV dword ptr [RBP + -0x374],0x0
MOV d... | char * func0(long param_1,int param_2)
{
bool bVar1;
char *__s;
size_t sVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_384;
int local_380;
int local_378;
int local_374;
uint auStack_368 [200];
char local_48 [56];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_384 = 0;
... |
6,637 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
fr... | int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x360,%rsp
mov %fs:0x28,%rax
mov %rax,0x358(%rsp)
xor %eax,%eax
test %esi,%esi
jle 1318 <func0+0x12f>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%ebx
mov $0x0,%r10d
mov %rsp,%rdi
jm... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 368h
mov rax, fs:28h
mov [rsp+398h+var_40], rax
xor eax, eax
test esi, esi
jle loc_1331
mov r8, rdi
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
mov ebp, 0
mov rdi, rsp
jmp short loc_... | _BYTE * func0(_DWORD *a1, int a2)
{
_DWORD *v2; // r8
int v3; // ebp
long long v4; // rax
_BYTE *v5; // r12
long long v6; // r15
long long v7; // rbx
int v8; // ebp
_DWORD v10[200]; // [rsp+0h] [rbp-398h]
_BYTE v11[56]; // [rsp+320h] [rbp-78h] BYREF
unsigned long long v12; // [rsp+358h] [rbp-40h]
... | ||
6,638 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
fr... | int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x378,%rsp
mov %fs:0x28,%rax
mov %rax,0x368(%rsp)
xor %eax,%eax
test %esi,%esi
jle 15e7 <func0+0x1a7>
lea -0x1(%rsi),%eax
xor %ebx,%ebx
lea 0x10(%rsp),%r15
lea 0x4(%rdi,%rax,4),%r8
mov (%rdi),%ecx... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 368h
mov rax, fs:28h
mov [rsp+398h+var_40], rax
xor eax, eax
test esi, esi
jle loc_15C6
lea eax, [rsi-1]
xor ebp, ebp
xor ebx, ebx
mov r14, rsp
lea rsi, [rdi+rax*4+4]
nop
loc_14A0:
... | _WORD * func0(int *a1, int a2)
{
int v2; // ebp
long long v3; // rbx
long long v4; // rsi
int v5; // ecx
long long v6; // rax
int v7; // ebp
long long v8; // r15
_WORD *v9; // rax
_WORD *v10; // r12
long long v11; // rax
long long v12; // rax
_DWORD v14[200]; // [rsp+0h] [rbp-398h] BYREF
_BYTE... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x368
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x358],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001015c6
LEA EAX,[RSI + -0x1]
XOR EBP,EBP
XOR EBX,EBX
MOV R14,RSP
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP
LAB_001014a0:
MOV ECX,dword ptr [RDI]
XOR EAX,... | char * func0(int *param_1,int param_2)
{
int *piVar1;
char *__s;
size_t sVar2;
long lVar3;
long lVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
int local_398 [200];
int1 local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
__s = (char *)malloc(10... |
6,639 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
fr... | int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x378,%rsp
mov %fs:0x28,%rax
mov %rax,0x368(%rsp)
xor %eax,%eax
test %esi,%esi
jle 15f8 <func0+0x218>
lea -0x1(%rsi),%eax
xor %r12d,%r12d
lea 0x10(%rsp),%r15
lea 0x4(%rdi,%rax,4),%r8
mov (%rdi),%e... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 378h
mov rax, fs:28h
mov [rsp+3A8h+var_40], rax
xor eax, eax
test esi, esi
jle loc_1602
movsxd rsi, esi
xor r15d, r15d
lea rbx, [rsp+3A8h+var_398]
lea r8, [rdi+rsi*4]
nop
loc_1450:
mov ... | char * func0(int *a1, int a2)
{
int v2; // r15d
int *v3; // r8
int v4; // edx
long long v5; // rcx
long long v6; // rax
char *v7; // rax
char *v8; // r12
int v9; // edx
long long v10; // rbp
int v11; // r9d
int v12; // r8d
int v14; // r15d
_DWORD *v15; // rbp
int v16; // ebx
size_t v17; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x378
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x368],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101602
MOVSXD RSI,ESI
XOR R15D,R15D
LEA RBX,[RSP + 0x10]
LEA R8,[RDI + RSI*0x4]
NOP
LAB_00101450:
MOV EDX,dword ptr [RDI]
MOVSXD RCX,R15D
TEST R... | char * func0(int *param_1,int param_2)
{
long lVar1;
long lVar2;
char *__s;
size_t sVar3;
long lVar4;
int *piVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
int local_398 [200];
int local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
__s = (char... |
6,640 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovle -0x18(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovge -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x8(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_8], eax
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
cmp edx, eax
cmovge eax, edx
mov [r... | long long func0(int a1, int a2)
{
unsigned int v2; // eax
long long result; // rax
unsigned int v4; // [rsp+18h] [rbp-8h]
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
v4 = v2;
LODWORD(result) = a1;
if ( a2 >= a1 )
LODWORD(result) = a2;
if ( !v4 )
return (unsigned int)result;
if ( v4 == 1 )
re... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVGE EA... | ulong func0(uint param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = param_1;
if ((int)param_2 <= (int)param_1) {
uVar1 = param_2;
}
if ((int)param_1 <= (int)param_2) {
param_1 = param_2;
}
if (uVar1 == 0) {
uVar2 = (ulong)param_1;
}
else if (uVar1 == 1) {
uVar2 = 1;
}
e... |
6,641 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp %edi,%esi
cmovle %esi,%edi
cmovge %esi,%eax
test %edi,%edi
je 1176 <func0+0x2d>
cmp $0x1,%edi
jne 1163 <func0+0x1a>
mov %edi,%eax
retq
sub $0x8,%rsp
cltd
idiv %edi
mov %edx,%esi
callq 1149 <func0>
add $0x8,%rsp
retq
retq
| func0:
endbr64
cmp esi, edi
mov ecx, edi
cmovle ecx, esi
mov eax, edi
cmovge eax, esi
test ecx, ecx
jz short locret_117A
cmp ecx, 1
jnz short loc_1165
mov eax, ecx
retn
loc_1165:
sub rsp, 8
cdq
idiv ecx
mov esi, edx
mov edi, ecx
call func0
add rsp, 8
retn
locret_1... | long long func0(signed int a1, signed int a2)
{
unsigned int v2; // ecx
long long result; // rax
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
result = (unsigned int)a1;
if ( a2 >= a1 )
result = (unsigned int)a2;
if ( v2 )
{
if ( v2 == 1 )
return 1LL;
else
return func0(v2, (unsigned in... | func0:
ENDBR64
CMP ESI,EDI
MOV ECX,EDI
CMOVLE ECX,ESI
MOV EAX,EDI
CMOVGE EAX,ESI
TEST ECX,ECX
JZ 0x0010117a
CMP ECX,0x1
JNZ 0x00101165
MOV EAX,ECX
RET
LAB_00101165:
SUB RSP,0x8
CDQ
IDIV ECX
MOV ESI,EDX
MOV EDI,ECX
CALL 0x00101149
ADD RSP,0x8
RET
LAB_0010117a:
RET | ulong func0(uint param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
int iVar3;
uVar2 = (ulong)param_1;
if ((int)param_2 <= (int)param_1) {
uVar2 = (ulong)param_2;
}
uVar1 = (ulong)param_1;
if ((int)param_1 <= (int)param_2) {
uVar1 = (ulong)param_2;
}
iVar3 = (int)uVar2;
if (iVar3 != 0) ... |
6,642 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
mov %esi,%eax
cmovle %edi,%ecx
cmovge %edi,%eax
test %ecx,%ecx
jne 1173 <func0+0x33>
jmp 117d <func0+0x3d>
nopw %cs:0x0(%rax,%rax,1)
cltd
idiv %ecx
mov %ecx,%eax
cmp %edx,%ecx
cmovg %edx,%ecx
cmp %eax,%edx
cmovge %edx,%eax
test %ecx,%ecx
je ... | func0:
endbr64
cmp edi, esi
mov ecx, esi
mov eax, esi
cmovle ecx, edi
cmovge eax, edi
test ecx, ecx
jnz short loc_1173
jmp short locret_117D
loc_1160:
cdq
idiv ecx
mov eax, ecx
cmp ecx, edx
cmovg ecx, edx
cmp edx, eax
cmovge eax, edx
test ecx, ecx
jz short locret_1180
... | long long func0(int a1, int a2)
{
int v2; // ecx
long long result; // rax
int v4; // edx
v2 = a2;
result = (unsigned int)a2;
if ( a1 <= a2 )
v2 = a1;
if ( a1 >= a2 )
result = (unsigned int)a1;
if ( v2 )
{
while ( v2 != 1 )
{
v4 = (int)result % v2;
result = (unsigned int)v... | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
MOV EAX,ESI
CMOVLE ECX,EDI
CMOVGE EAX,EDI
TEST ECX,ECX
JNZ 0x00101173
JMP 0x0010117d
LAB_00101160:
CDQ
IDIV ECX
MOV EAX,ECX
CMP ECX,EDX
CMOVG ECX,EDX
CMP EDX,EAX
CMOVGE EAX,EDX
TEST ECX,ECX
JZ 0x00101180
LAB_00101173:
CMP ECX,0x1
JNZ 0x00101160
MOV EAX,0x1
LAB_0010117d:
RET
LAB_00... | ulong func0(uint param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
uVar5 = (ulong)param_2;
if ((int)param_1 <= (int)param_2) {
uVar5 = (ulong)param_1;
}
uVar3 = (ulong)param_2;
if ((int)param_2 <= (int)param_1) {
uVar3 = (ulong)param_1;
}
if ((int... |
6,643 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
mov %esi,%eax
cmovle %edi,%ecx
cmovge %edi,%eax
test %ecx,%ecx
jne 1173 <func0+0x33>
jmp 117d <func0+0x3d>
nopw %cs:0x0(%rax,%rax,1)
cltd
idiv %ecx
mov %ecx,%eax
cmp %edx,%ecx
cmovg %edx,%ecx
cmp %eax,%edx
cmovge %edx,%eax
test %ecx,%ecx
je ... | func0:
endbr64
cmp edi, esi
mov ecx, esi
mov eax, esi
cmovle ecx, edi
cmovge eax, edi
test ecx, ecx
jnz short loc_122B
retn
loc_1218:
cdq
idiv ecx
mov eax, ecx
cmp ecx, edx
cmovg ecx, edx
cmp edx, eax
cmovge eax, edx
test ecx, ecx
jz short locret_1240
loc_122B:
cmp ecx... | long long func0(int a1, int a2)
{
int v2; // ecx
long long result; // rax
int v4; // edx
v2 = a2;
result = (unsigned int)a2;
if ( a1 <= a2 )
v2 = a1;
if ( a1 >= a2 )
result = (unsigned int)a1;
if ( v2 )
{
while ( v2 != 1 )
{
v4 = (int)result % v2;
result = (unsigned int)v... | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
MOV EAX,ESI
CMOVLE ECX,EDI
CMOVGE EAX,EDI
TEST ECX,ECX
JNZ 0x0010122b
RET
LAB_00101218:
CDQ
IDIV ECX
MOV EAX,ECX
CMP ECX,EDX
CMOVG ECX,EDX
CMP EDX,EAX
CMOVGE EAX,EDX
TEST ECX,ECX
JZ 0x00101240
LAB_0010122b:
CMP ECX,0x1
JNZ 0x00101218
MOV EAX,0x1
RET
LAB_00101240:
RET | ulong func0(uint param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
uVar5 = (ulong)param_2;
if ((int)param_1 <= (int)param_2) {
uVar5 = (ulong)param_1;
}
uVar3 = (ulong)param_2;
if ((int)param_2 <= (int)param_1) {
uVar3 = (ulong)param_1;
}
if ((int... |
6,644 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
movsd %xmm0,-0x8(%rbp)
movsd %xmm1,-0x10(%rbp)
movsd -0x8(%rbp),%xmm0
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm1
movsd -0x10(%rbp),%xmm0
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
callq 1070 <sqrt@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
movsd [rbp+var_8], xmm0
movsd [rbp+var_10], xmm1
movsd xmm0, [rbp+var_8]
movapd xmm1, xmm0
mulsd xmm1, xmm0
movsd xmm0, [rbp+var_10]
mulsd xmm0, xmm0
addsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _sqrt
leave
retn | double func0(double a1, double a2)
{
return sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD qword ptr [RBP + -0x10],XMM1
MOVSD XMM0,qword ptr [RBP + -0x8]
MOVAPD XMM1,XMM0
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x10]
MULSD XMM0,XMM0
ADDSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
LEAVE
RET | void func0(double param_1,double param_2)
{
sqrt(param_1 * param_1 + param_2 * param_2);
return;
} |
6,645 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x18,%rsp
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm1
addsd %xmm1,%xmm0
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 1180 <func0+0x37>
movsd 0x8(%rsp),%xmm0
add $0x18,%rsp
retq
callq 1050 <sqrt@plt>
jmp 1175 <func0+0x2c>
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm1, xmm1
addsd xmm0, xmm1
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_1168
sqrtsd xmm0, xmm0
retn
loc_1168:
sub rsp, 8
call _sqrt
add rsp, 8
retn | double func0(double a1, double a2)
{
double v2; // xmm0_8
v2 = a1 * a1 + a2 * a2;
if ( v2 < 0.0 )
return sqrt(v2);
else
return sqrt(v2);
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM1,XMM1
ADDSD XMM0,XMM1
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x00101168
SQRTSD XMM0,XMM0
RET
LAB_00101168:
SUB RSP,0x8
CALL 0x00101050
ADD RSP,0x8
RET | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_1 * param_1 + param_2 * param_2;
if (0.0 <= dVar1) {
return SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return dVar1;
} |
6,646 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O2 | c | func0:
endbr64
mulsd %xmm1,%xmm1
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
ja 1187 <func0+0x27>
movapd %xmm2,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm... | func0:
endbr64
mulsd xmm1, xmm1
mulsd xmm0, xmm0
addsd xmm0, xmm1
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_117F
sqrtsd xmm0, xmm0
retn
loc_117F:
jmp _sqrt | double func0(double a1, double a2)
{
double v2; // xmm0_8
v2 = a1 * a1 + a2 * a2;
if ( v2 < 0.0 )
return sqrt(v2);
else
return sqrt(v2);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MULSD XMM0,XMM0
ADDSD XMM0,XMM1
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x0010117f
SQRTSD XMM0,XMM0
RET
LAB_0010117f:
JMP 0x00101050 | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_1 * param_1 + param_2 * param_2;
if (0.0 <= dVar1) {
return SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return dVar1;
} |
6,647 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O3 | c | func0:
endbr64
mulsd %xmm1,%xmm1
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
ja 1187 <func0+0x27>
movapd %xmm2,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm... | func0:
endbr64
mulsd xmm1, xmm1
mulsd xmm0, xmm0
addsd xmm0, xmm1
sqrtsd xmm0, xmm0
retn | double func0(double a1, double a2)
{
return sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MULSD XMM0,XMM0
ADDSD XMM0,XMM1
SQRTSD XMM0,XMM0
RET | double func0(double param_1,double param_2)
{
return SQRT(param_1 * param_1 + param_2 * param_2);
} |
6,648 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i... | int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x3c(%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, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_2C]
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 v5; // eax
_BYTE v6[4]; // [rsp+8h] [rbp-30h] BYREF
int v7; // [rsp+Ch] [rbp-2Ch]
_DWORD *v8; // [rsp+10h] [rbp-28h]
int i; // [rsp+18h] [rbp-20h]
int j; // [rsp+1Ch] [rbp-1Ch]
long long v11; // [rsp+20h] [rbp-18... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],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 + -0x2c]
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;
int4 uVar3;
ulong uVar4;
int *puVar5;
long in_FS_OFFSET;
int auStack_38 [4];
int local_34;
int *local_30;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_30 = param_1;
local_34 = param_2;
l... |
6,649 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i... | int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
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 r9d, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A5:
cmp rsp... | long long func0(_DWORD *a1, int a2)
{
signed long long v2; // rax
void *v3; // rsp
long long result; // rax
long long i; // rcx
long long v6; // rax
int v7; // edx
_DWORD v9[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v10; // [rsp+10h] [rbp-8h]
v10 = __readfsqword(0x28u);
while ( v9 != (_DW... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a5:
CMP RSP,RDX
JZ 0x001011bc
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0... | int4 func0(int *param_1,uint param_2)
{
long lVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
int1 *puVar5;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)param_2 * 4 + 0xf;
for (puVar5 = auStack_18; puVar5 != auStack_18 + -(uVa... |
6,650 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i... | int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
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
movsxd r10, esi
mov r8, r10
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, ds:0Fh[r10*4]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz ... | long long func0(int *a1, int a2)
{
long long v2; // rdx
_DWORD *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
long long result; // rax
int v8; // r9d
long long v9; // rcx
int v10; // edx
long long i; // rax
int v12; // edx
_DWORD v14[1022]; // [rsp+8h] [rbp-1010h] BY... | func0:
ENDBR64
PUSH RBP
MOVSXD R10,ESI
MOV R8,R10
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0xf + R10*0x4]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101346
LAB_00101331:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x... | int4 func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
int1 *puVar3;
int4 uVar4;
long lVar5;
long lVar6;
int iVar7;
ulong uVar8;
int1 *puVar9;
long lVar11;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar10;
lVar11 = (long)param_2;
puVar9 = auStack_18;
loca... |
6,651 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i... | int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
return 0;
}
| O3 | 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 rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz ... | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
_DWORD *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
long long result; // rax
long long v8; // rdx
long long v9; // rax
int v10; // ecx
_DWORD v12[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v13[2]; // [rsp+10... | func0:
ENDBR64
PUSH RBP
MOV R8D,ESI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],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 0x00101316
LAB_00101301:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0... | int4 func0(int *param_1,uint param_2)
{
long lVar1;
int *puVar2;
int4 uVar3;
ulong uVar4;
ulong uVar5;
int *puVar6;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar7;
puVar6 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(int)param_2 * 4 + 0xf;
puV... |
6,652 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x28(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov rax, [rbp+var_28]
mov [rax], edx
mov rax, [rbp+var_28]
mov eax, [rax]
cdqe
shl rax, 2
mov rdi, rax; size
c... | _DWORD * func0(long long a1, int a2, int *a3)
{
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v6; // [rsp+28h] [rbp-8h]
*a3 = a2 - 1;
v6 = malloc(4LL * *a3);
for ( i = 0; i < *a3; ++i )
v6[i] = *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4 * (i + 1LL) + a1);
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CDQE
SHL R... | void * func0(long param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_14;
*param_3 = param_2 + -1;
pvVar1 = malloc((long)*param_3 << 2);
for (local_14 = 0; local_14 < *param_3; local_14 = local_14 + 1) {
*(int *)((long)pvVar1 + (long)local_14 * 4) =
*(int *)(param_1 + ((long)local_14... |
6,653 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %rdx,%rbp
sub $0x1,%esi
mov %esi,(%rdx)
movslq %esi,%rsi
lea 0x0(,%rsi,4),%rdi
callq 10b0 <malloc@plt>
mov 0x0(%rbp),%edx
test %edx,%edx
jle 11f4 <func0+0x4b>
lea -0x1(%rdx),%esi
mov $0x0,%edx
mov (%rbx,%rdx,4),%e... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rbp, rdx
sub esi, 1
mov [rdx], esi
movsxd rsi, esi
lea rdi, ds:0[rsi*4]
call _malloc
mov esi, [rbp+0]
test esi, esi
jle short loc_11F0
mov esi, esi
mov edx, 0
loc_11DC:
mov ecx, [rbx+rdx*4]
imul ecx,... | long long func0(long long a1, int a2, int *a3)
{
int v4; // esi
long long result; // rax
int v6; // esi
long long v7; // rdx
v4 = a2 - 1;
*a3 = v4;
result = malloc(4LL * v4);
v6 = *a3;
if ( *a3 > 0 )
{
v7 = 0LL;
do
{
*(_DWORD *)(result + 4 * v7) = *(_DWORD *)(a1 + 4 * v7 + 4) * *... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RBP,RDX
SUB ESI,0x1
MOV dword ptr [RDX],ESI
MOVSXD RSI,ESI
LEA RDI,[RSI*0x4]
CALL 0x001010b0
MOV ESI,dword ptr [RBP]
TEST ESI,ESI
JLE 0x001011f0
MOV ESI,ESI
MOV EDX,0x0
LAB_001011dc:
MOV ECX,dword ptr [RBX + RDX*0x4]
IMUL ECX,dword ptr [RBX + RDX*0x4 + 0x4]
M... | void func0(long param_1,int param_2,uint *param_3)
{
uint uVar1;
void *pvVar2;
ulong uVar3;
*param_3 = param_2 - 1U;
pvVar2 = malloc((long)(int)(param_2 - 1U) * 4);
uVar1 = *param_3;
if (0 < (int)uVar1) {
uVar3 = 0;
do {
*(int *)((long)pvVar2 + uVar3 * 4) =
*(int *)(param_1 + ... |
6,654 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[... | O2 | c | func0:
endbr64
push %rbp
sub $0x1,%esi
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
mov %esi,(%rdx)
movslq %esi,%rsi
lea 0x0(,%rsi,4),%rdi
callq 10b0 <malloc@plt>
mov 0x0(%rbp),%edx
test %edx,%edx
jle 14df <func0+0x4f>
lea -0x1(%rdx),%esi
xor %edx,%edx
nopl 0x0(%rax)
mov ... | func0:
endbr64
push rbp
sub esi, 1
mov rbp, rdx
push rbx
mov rbx, rdi
sub rsp, 8
mov [rdx], esi
movsxd rsi, esi
lea rdi, ds:0[rsi*4]
call _malloc
movsxd rsi, dword ptr [rbp+0]
test esi, esi
jle short loc_14D4
xor edx, edx
nop
loc_14C0:
mov ecx, [rbx+rdx*4]
imul ecx, ... | long long func0(long long a1, int a2, int *a3)
{
int v3; // esi
long long result; // rax
long long v6; // rsi
long long i; // rdx
v3 = a2 - 1;
*a3 = v3;
result = malloc(4LL * v3);
v6 = *a3;
if ( (int)v6 > 0 )
{
for ( i = 0LL; i != v6; ++i )
*(_DWORD *)(result + 4 * i) = *(_DWORD *)(a1 + ... | func0:
ENDBR64
PUSH RBP
SUB ESI,0x1
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV dword ptr [RDX],ESI
MOVSXD RSI,ESI
LEA RDI,[RSI*0x4]
CALL 0x001010b0
MOVSXD RSI,dword ptr [RBP]
TEST ESI,ESI
JLE 0x001014d4
XOR EDX,EDX
NOP
LAB_001014c0:
MOV ECX,dword ptr [RBX + RDX*0x4]
IMUL ECX,dword ptr [RBX + RDX*0x4 + 0x4]
MOV dw... | void func0(long param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
long lVar3;
*param_3 = param_2 + -1;
pvVar2 = malloc((long)(param_2 + -1) * 4);
iVar1 = *param_3;
if (0 < iVar1) {
lVar3 = 0;
do {
*(int *)((long)pvVar2 + lVar3 * 4) =
*(int *)(param_1 + lVar3 * 4) * ... |
6,655 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[... | O3 | c | func0:
endbr64
push %rbp
sub $0x1,%esi
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
mov %esi,(%rdx)
movslq %esi,%rsi
lea 0x0(,%rsi,4),%rdi
callq 10b0 <malloc@plt>
mov 0x0(%rbp),%esi
test %esi,%esi
jle 15bb <func0+0xdb>
lea -0x1(%rsi),%edx
cmp $0x2,%edx
jbe 15c2 <func0+0xe2... | func0:
endbr64
push rbp
sub esi, 1
mov rbp, rdx
push rbx
mov rbx, rdi
sub rsp, 8
mov [rdx], esi
movsxd rsi, esi
lea rdi, ds:0[rsi*4]; size
call _malloc
mov esi, [rbp+0]
mov rcx, rax
test esi, esi
jle loc_1501
lea eax, [rsi-1]
cmp eax, 2
jbe loc_150B
mov e... | char * func0(long long a1, int a2, int *a3)
{
int v3; // esi
char *v6; // rax
int v7; // esi
char *v8; // rcx
long long v9; // rax
signed int v10; // eax
long long v11; // rdx
int v12; // edi
int v13; // r8d
v3 = a2 - 1;
*a3 = v3;
v6 = (char *)malloc(4LL * v3);
v7 = *a3;
v8 = v6;
if ( *a3... | func0:
ENDBR64
PUSH RBP
SUB ESI,0x1
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV dword ptr [RDX],ESI
MOVSXD RSI,ESI
LEA RDI,[RSI*0x4]
CALL 0x001010b0
MOV ESI,dword ptr [RBP]
MOV RCX,RAX
TEST ESI,ESI
JLE 0x00101501
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x0010150b
MOV EDX,ESI
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
NOP wo... | void * func0(long param_1,int param_2,uint *param_3)
{
int8 *puVar1;
ulong *puVar2;
uint *puVar3;
uint uVar4;
int iVar5;
int iVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
uint uVar10;
void *pvVar11;
long lVar12;
long lVar13;
*param_3 = param_2 - 1U;
pvVar11 = malloc((long)(int)(param_2... |
6,656 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const v... | Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x2c(%rbp),%eax
movslq %eax,%rsi
mov -0x28(%rbp),%rax
lea -0x1e1(%rip),%rcx
mov $0x8,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+base], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_2C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare_pairs
mov rcx, rdx; compar
mov edx, 8; size
... | long long func0(unsigned int *a1, int a2)
{
int i; // [rsp+1Ch] [rbp-14h]
_QWORD v4[2]; // [rsp+20h] [rbp-10h] BYREF
v4[1] = __readfsqword(0x28u);
qsort(a1, a2, 8uLL, compare_pairs);
v4[0] = 0LL;
for ( i = 0; i < a2; ++i )
add_to_map(v4, a1[2 * i + 1], a1[2 * i]);
return v4[0];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x8
MOV RDI,RAX
CA... | int8 func0(void *param_1,int param_2)
{
long in_FS_OFFSET;
int local_1c;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,8,compare_pairs);
local_18 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
add_to_map(&local_18,*(i... |
6,657 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const v... | Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%r12
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rsi
lea -0x13f(%rip),%rcx
mov $0x8,%edx
callq 10a0 <qsort@plt>
movq $0x0,(%rsp)
test %ebp,%ebp
jle 1342 <func0+0x65>
mov %r12,%... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov r12, rdi
mov ebp, esi
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
movsxd rsi, esi
lea rcx, compare_pairs
mov edx, 8
call _qsort
mov [rsp+28h+var_28], 0
test ebp, ebp
jle short loc_1342
mov r... | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rbx
_QWORD v4[5]; // [rsp+0h] [rbp-28h] BYREF
v4[1] = __readfsqword(0x28u);
qsort(a1, a2, 8LL, compare_pairs);
v4[0] = 0LL;
if ( a2 > 0 )
{
v2 = a1;
do
{
add_to_map(v4, v2[1], *v2);
v2 += 2;
}
while ( v2 != ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV R12,RDI
MOV EBP,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVSXD RSI,ESI
LEA RCX,[0x1011c9]
MOV EDX,0x8
CALL 0x001010a0
MOV qword ptr [RSP],0x0
TEST EBP,EBP
JLE 0x00101342
MOV RBX,R12
LEA EAX,[RBP + -0x1]
LEA R12,[R12 + RAX*0x8 +... | int8 func0(int4 *param_1,int param_2)
{
int4 *puVar1;
long in_FS_OFFSET;
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,8,compare_pairs);
local_28 = 0;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
add_to_... |
6,658 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const v... | Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_... | O2 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov $0x8,%edx
lea -0x165(%rip),%rcx
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
callq 10a0 <qsort@plt>
movq $0x0,(%rsp)
test %ebp,%ebp
jle 15e8 <func0+0x88>
lea -0x1(%... | func0:
endbr64
push r12
movsxd rsi, esi
mov edx, 8
lea rcx, compare_pairs
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
call _qsort
mov [rsp+28h+var_28], 0
test ebp, ebp
jle short loc_15E8
lea e... | long long func0(unsigned int *a1, int a2)
{
unsigned int *v3; // rbx
long long v4; // rsi
long long v5; // rdx
_QWORD v7[5]; // [rsp+0h] [rbp-28h] BYREF
v3 = a1;
v7[1] = __readfsqword(0x28u);
qsort(a1, a2, 8LL, compare_pairs);
v7[0] = 0LL;
if ( a2 <= 0 )
return 0LL;
do
{
v4 = v3[1];
... | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV EDX,0x8
LEA RCX,[0x101410]
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CALL 0x001010a0
MOV qword ptr [RSP],0x0
TEST EBP,EBP
JLE 0x001015e8
LEA EAX,[RBP + -0x1]
MOV RBP,RSP
LEA R12,[RBX + RAX*0x8 +... | int8 func0(int4 *param_1,int param_2)
{
int4 *puVar1;
int4 *puVar2;
int4 uVar3;
long in_FS_OFFSET;
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,8,compare_pairs);
local_28 = 0;
if (param_2 < 1) {
local_28 = 0;
}
else {
puVar2 = p... |
6,659 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const v... | Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_... | O3 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov $0x8,%edx
lea -0x165(%rip),%rcx
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x18,%rsp
callq 10a0 <qsort@plt>
test %ebp,%ebp
jle 1620 <func0+0x130>
lea -0x1(%rbp),%eax
xor %r15d,%r15d
lea 0x8(%r... | func0:
endbr64
push r15
lea rcx, compare_pairs; compar
mov edx, 8; size
push r14
push r13
push r12
movsxd r12, esi
push rbp
mov rsi, r12; nmemb
push rbx
mov rbx, rdi
sub rsp, 18h
call _qsort
test r12d, r12d
jle loc_1624
mov r14d, [rbx+4]
mov edi, 18h; size
mov ... | _DWORD * func0(int *a1, int a2)
{
int v2; // r14d
int v3; // ebp
long long v4; // r12
_DWORD *v5; // rax
_DWORD *v6; // r13
_QWORD *v7; // rax
int *v8; // rax
int v9; // ebp
int v10; // r12d
int *v11; // r15
_DWORD *i; // rbx
_QWORD *v13; // rax
long long v14; // rdx
_DWORD *v15; // rax
_D... | func0:
ENDBR64
PUSH R15
LEA RCX,[0x1013a0]
MOV EDX,0x8
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RSI,R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
CALL 0x001010a0
TEST R12D,R12D
JLE 0x00101624
MOV R14D,dword ptr [RBX + 0x4]
MOV EDI,0x18
MOV EBP,dword ptr [RBX]
SHL R12,0x3
CALL 0x001010d0
MOV EDI,0x10
MOV dword ptr... | int * func0(int4 *param_1,int param_2)
{
int8 uVar1;
int *piVar2;
int4 *puVar3;
int4 *puVar4;
int *piVar5;
int *piVar6;
int iVar7;
int4 uVar8;
size_t __nmemb;
__nmemb = (size_t)param_2;
qsort(param_1,__nmemb,8,compare_pairs);
if (param_2 < 1) {
piVar2 = (int *)0x0;
}
else {
iVar7... |
6,660 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x9,-0x14(%rbp)
jle 1161 <func0+0x18>
mov $0x0,%eax
jmp 11ad <func0+0x64>
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11a2 <func0+0x59>
mov -0x8(%rbp),%eax
imul -0x4(%rbp),%eax
movslq %eax,%rdx
imul $0x51eb851f,%rdx,%rd... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 9
jle short loc_1161
mov eax, 0
jmp short loc_11AD
loc_1161:
mov [rbp+var_8], 1
mov [rbp+var_4], 1
jmp short loc_11A2
loc_1171:
mov eax, [rbp+var_8]
imul eax, [rbp+var_4]
movsxd rdx, eax
imul r... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
if ( a1 > 9 )
return 0LL;
v2 = 1;
for ( i = 1; i <= a1; ++i )
v2 = (int)(i * v2) % 100;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x9
JLE 0x00101161
MOV EAX,0x0
JMP 0x001011ad
LAB_00101161:
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011a2
LAB_00101171:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RBP + -0x4]
MOVSXD RDX... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
if (param_1 < 10) {
local_10 = 1;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = (local_10 * local_c) % 100;
}
}
else {
local_10 = 0;
}
return local_10;
} |
6,661 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp $0x9,%edi
jg 1195 <func0+0x4c>
test %edi,%edi
jle 1190 <func0+0x47>
add $0x1,%edi
mov $0x1,%edx
mov $0x1,%eax
imul %edx,%eax
mov %eax,%ecx
cltq
imul $0x51eb851f,%rax,%rax
sar $0x25,%rax
mov %ecx,%esi
sar $0x1f,%esi
sub %esi,%eax
imul $0x64,%e... | func0:
endbr64
mov eax, 0
cmp edi, 9
jg short locret_1195
test edi, edi
jle short loc_1190
add edi, 1
mov edx, 1
mov eax, 1
loc_1168:
imul eax, edx
mov ecx, eax
cdqe
imul rax, 51EB851Fh
sar rax, 25h
mov esi, ecx
sar esi, 1Fh
sub eax, esi
imul esi, eax, 64h ; ... | long long func0(int a1)
{
long long result; // rax
int v2; // edi
int v3; // edx
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 <= 0 )
{
return 1LL;
}
else
{
v2 = a1 + 1;
v3 = 1;
LODWORD(result) = 1;
do
{
result = (unsigned int)(v3 * (int)result % 10... | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,0x9
JG 0x00101195
TEST EDI,EDI
JLE 0x00101190
ADD EDI,0x1
MOV EDX,0x1
MOV EAX,0x1
LAB_00101168:
IMUL EAX,EDX
MOV ECX,EAX
CDQE
IMUL RAX,RAX,0x51eb851f
SAR RAX,0x25
MOV ESI,ECX
SAR ESI,0x1f
SUB EAX,ESI
IMUL ESI,EAX,0x64
MOV EAX,ECX
SUB EAX,ESI
ADD EDX,0x1
CMP EDX,EDI
JNZ 0x00101168
RET
... | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if (param_1 < 10) {
if (0 < param_1) {
iVar2 = 1;
iVar1 = 1;
do {
iVar1 = (iVar1 * iVar2) % 100;
iVar2 = iVar2 + 1;
} while (iVar2 != param_1 + 1);
return iVar1;
}
iVar1 = 1;
}
return iVar... |
6,662 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
cmp $0x9,%edi
jg 1205 <func0+0x55>
test %edi,%edi
jle 1200 <func0+0x50>
add $0x1,%edi
mov $0x1,%edx
mov $0x1,%eax
nopl 0x0(%rax)
imul %edx,%eax
add $0x1,%edx
mov %eax,%ecx
cltq
imul $0x51eb851f,%rax,%rax
mov %ecx,%esi
sar $0x1f,%esi
sar $0x25,%ra... | func0:
endbr64
xor eax, eax
cmp edi, 9
jg short locret_1205
test edi, edi
jle short loc_1200
add edi, 1
mov edx, 1
mov eax, 1
nop dword ptr [rax+00h]
loc_11D0:
imul eax, edx
add edx, 1
mov ecx, eax
cdqe
imul rax, 51EB851Fh
mov esi, ecx
sar esi, 1Fh
sar rax, ... | long long func0(int a1)
{
long long result; // rax
int v2; // edi
int v3; // edx
int v4; // eax
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 <= 0 )
{
return 1LL;
}
else
{
v2 = a1 + 1;
v3 = 1;
LODWORD(result) = 1;
do
{
v4 = v3 * result;
++... | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x9
JG 0x00101205
TEST EDI,EDI
JLE 0x00101200
ADD EDI,0x1
MOV EDX,0x1
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_001011d0:
IMUL EAX,EDX
ADD EDX,0x1
MOV ECX,EAX
CDQE
IMUL RAX,RAX,0x51eb851f
MOV ESI,ECX
SAR ESI,0x1f
SAR RAX,0x25
SUB EAX,ESI
IMUL ESI,EAX,0x64
MOV EAX,ECX
SUB EAX,ESI
CMP EDI,EDX... | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if (param_1 < 10) {
if (0 < param_1) {
iVar2 = 1;
iVar1 = 1;
do {
iVar1 = iVar1 * iVar2;
iVar2 = iVar2 + 1;
iVar1 = iVar1 % 100;
} while (param_1 + 1 != iVar2);
return iVar1;
}
iVar1 =... |
6,663 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp $0x9,%edi
jg 118d <func0+0x4d>
test %edi,%edi
jle 1188 <func0+0x48>
cmp $0x1,%edi
je 1188 <func0+0x48>
cmp $0x2,%edi
je 118e <func0+0x4e>
cmp $0x3,%edi
je 119e <func0+0x5e>
cmp $0x4,%edi
je 11a4 <func0+0x64>
cmp $0x5,%edi
je 1198 <func0+... | func0:
endbr64
xor eax, eax
cmp edi, 9
jg short locret_1185
test edi, edi
jle short loc_1180
cmp edi, 1
jz short loc_1180
cmp edi, 2
jz short loc_1186
cmp edi, 3
jz short loc_118C
cmp edi, 4
jz short loc_1192
cmp edi, 6
jle short loc_1198
cmp edi, 7
jz... | long long func0(int a1)
{
long long result; // rax
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 < 2 )
{
return 1LL;
}
else
{
switch ( a1 )
{
case 2:
return 2LL;
case 3:
return 6LL;
case 4:
return 24LL;
default:
... | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x9
JG 0x00101185
TEST EDI,EDI
JLE 0x00101180
CMP EDI,0x1
JZ 0x00101180
CMP EDI,0x2
JZ 0x00101186
CMP EDI,0x3
JZ 0x0010118c
CMP EDI,0x4
JZ 0x00101192
CMP EDI,0x6
JLE 0x00101198
CMP EDI,0x7
JZ 0x0010119e
CMP EDI,0x9
MOV EDX,0x14
MOV EAX,0x50
CMOVNZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0x1... | int8 func0(int param_1)
{
int8 uVar1;
uVar1 = 0;
if (param_1 < 10) {
if ((0 < param_1) && (param_1 != 1)) {
if (param_1 == 2) {
return 2;
}
if (param_1 == 3) {
return 6;
}
if (param_1 == 4) {
return 0x18;
}
if (6 < param_1) {
if (pa... |
6,664 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (tex... | int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
cmpq $0x0,-0x38(%rbp)
jne 11ea <func0+0x21>
mov $0x0,%eax
jmpq 12c3 <func0+0xfa>
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
add $0x1,%rax
mov %rax,... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+s], rdi
cmp [rbp+s], 0
jnz short loc_11EA
mov eax, 0
jmp locret_12C3
loc_11EA:
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rax, 1
mov rdi, rax; size
call... | _BYTE * func0(const char *a1)
{
long long v2; // rax
long long v3; // rax
int v4; // [rsp+1Ch] [rbp-24h]
long long v5; // [rsp+20h] [rbp-20h]
long long v6; // [rsp+28h] [rbp-18h]
size_t v7; // [rsp+30h] [rbp-10h]
_BYTE *v8; // [rsp+38h] [rbp-8h]
if ( !a1 )
return 0LL;
v7 = strlen(a1);
v8 = mall... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001011ea
MOV EAX,0x0
JMP 0x001012c3
LAB_001011ea:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010a0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV RDI,RAX
CAL... | void * func0(char *param_1)
{
bool bVar1;
void *pvVar2;
size_t sVar3;
long local_28;
long local_20;
if (param_1 == (char *)0x0) {
pvVar2 = (void *)0x0;
}
else {
sVar3 = strlen(param_1);
pvVar2 = malloc(sVar3 + 1);
if (pvVar2 == (void *)0x0) {
pvVar2 = (void *)0x0;
}
els... |
6,665 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (tex... | int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
... | O1 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
test %rdi,%rdi
je 120e <func0+0x85>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
callq 1090 <malloc@plt>
test %rax,%rax
je 120c <func0+0x83>
movzbl (%rbx),%edx
test %dl,%dl
je 1203 <func0+0x7a>
lea ... | func0:
endbr64
push rbx
mov rbx, rdi
test rdi, rdi
jz short loc_1243
call _strlen
lea rdi, [rax+1]
call _malloc
test rax, rax
jz short loc_1241
movzx edx, byte ptr [rbx]
test dl, dl
jz short loc_1238
lea rdi, [rbx+1]
mov esi, 0
mov ecx, 0
mov r9d, 1
mov r8d... | long long func0(char *a1)
{
long long v1; // rax
long long result; // rax
char v3; // dl
char *v4; // rdi
int v5; // esi
long long v6; // rcx
if ( !a1 )
return 0LL;
v1 = strlen();
result = malloc(v1 + 1);
if ( result )
{
v3 = *a1;
if ( *a1 )
{
v4 = a1 + 1;
v5 = 0;
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
TEST RDI,RDI
JZ 0x00101243
CALL 0x001010a0
LEA RDI,[RAX + 0x1]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101241
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x00101238
LEA RDI,[RBX + 0x1]
MOV ESI,0x0
MOV ECX,0x0
MOV R9D,0x1
MOV R8D,0x0
JMP 0x00101227
LAB_0010120c:
TEST ESI,ESI
JNZ 0x0010121b
MOV... | void * func0(char *param_1)
{
bool bVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
char cVar5;
char *pcVar6;
if (param_1 == (char *)0x0) {
pvVar3 = (void *)0x0;
}
else {
sVar2 = strlen(param_1);
pvVar3 = malloc(sVar2 + 1);
if (pvVar3 != (void *)0x0) {
cVar5 = *param_1;
i... |
6,666 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (tex... | int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
... | O2 | c | func0:
endbr64
test %rdi,%rdi
je 13d0 <func0+0xa0>
push %rbx
mov %rdi,%rbx
callq 1090 <strlen@plt>
lea 0x1(%rax),%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 13bd <func0+0x8d>
movzbl (%rbx),%edx
test %dl,%dl
je 13c8 <func0+0x98>
lea 0x1(%rbx),%rdi
xor %r9d,%r9d
xor %esi,%esi
mov ... | func0:
endbr64
test rdi, rdi
jz short loc_13B8
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]
call _malloc
test rax, rax
jz short loc_13AB
movzx edx, byte ptr [rbx]
test dl, dl
jz short loc_13B0
lea rdi, [rbx+1]
xor r8d, r8d
xor ecx, ecx
mov rsi, rax
jmp ... | long long func0(char *a1)
{
long long v1; // rax
long long result; // rax
char v3; // dl
char *v4; // rdi
int v5; // r8d
long long v6; // rcx
_BYTE *v7; // rsi
if ( !a1 )
return 0LL;
v1 = strlen();
result = malloc(v1 + 1);
if ( !result )
return 0LL;
v3 = *a1;
if ( *a1 )
{
v4 = ... | func0:
ENDBR64
TEST RDI,RDI
JZ 0x001013b8
PUSH RBX
MOV RBX,RDI
CALL 0x001010a0
LEA RDI,[RAX + 0x1]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x001013ab
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x001013b0
LEA RDI,[RBX + 0x1]
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RAX
JMP 0x00101380
LAB_00101368:
ADD RCX,0x1
MOV byte ptr [RSI],DL
XOR R8D,R... | char * func0(char *param_1)
{
bool bVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
char cVar5;
char *pcVar6;
if (param_1 == (char *)0x0) {
return (char *)0x0;
}
sVar2 = strlen(param_1);
pcVar3 = (char *)malloc(sVar2 + 1);
if (pcVar3 == (char *)0x0) {
return (char *)0x0;
}
cVar5 = *p... |
6,667 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (tex... | int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
... | O3 | c | func0:
endbr64
test %rdi,%rdi
je 13d0 <func0+0xa0>
push %rbx
mov %rdi,%rbx
callq 1090 <strlen@plt>
lea 0x1(%rax),%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 13bd <func0+0x8d>
movzbl (%rbx),%edx
test %dl,%dl
je 13c8 <func0+0x98>
lea 0x1(%rbx),%rdi
xor %r9d,%r9d
xor %esi,%esi
mov ... | func0:
endbr64
test rdi, rdi
jz short loc_13B8
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]; size
call _malloc
test rax, rax
jz short loc_13AB
movzx edx, byte ptr [rbx]
test dl, dl
jz short loc_13B0
lea rdi, [rbx+1]
xor r8d, r8d
xor ecx, ecx
mov rsi, rax... | char * func0(const char *a1)
{
size_t v1; // rax
char *result; // rax
char v3; // dl
char *v4; // rdi
int v5; // r8d
long long v6; // rcx
char *v7; // rsi
if ( !a1 )
return 0LL;
v1 = strlen(a1);
result = (char *)malloc(v1 + 1);
if ( !result )
return 0LL;
v3 = *a1;
if ( *a1 )
{
v... | func0:
ENDBR64
TEST RDI,RDI
JZ 0x001013b8
PUSH RBX
MOV RBX,RDI
CALL 0x001010a0
LEA RDI,[RAX + 0x1]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x001013ab
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x001013b0
LEA RDI,[RBX + 0x1]
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RAX
JMP 0x00101380
LAB_00101368:
ADD RCX,0x1
MOV byte ptr [RSI],DL
XOR R8D,R... | char * func0(char *param_1)
{
bool bVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
char cVar5;
char *pcVar6;
if (param_1 == (char *)0x0) {
return (char *)0x0;
}
sVar2 = strlen(param_1);
pcVar3 = (char *)malloc(sVar2 + 1);
if (pcVar3 == (char *)0x0) {
return (char *)0x0;
}
cVar5 = *p... |
6,668 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < size... | int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
... | 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 %rcx,-0x50(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmp 1233 <func0+0x48>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov [rbp+var_50], rcx
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp short loc_1233
loc_1216:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+... | _DWORD * func0(long long a1, long long a2, int a3, _DWORD *a4)
{
int v4; // eax
int v8; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int v10; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+38h] [rbp-18h]
int k; // [rsp+3Ch] [rbp-14h]
int v13; // [rsp+40h] [rbp-10h]
int m; // [rsp+44h] [rbp-Ch]
_DWORD *... | 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 qword ptr [RBP + -0x50],RCX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101233
LAB_00101216:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*... | void * func0(long param_1,long param_2,int param_3,int *param_4)
{
bool bVar1;
void *__base;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int local_14;
local_2c = 0;
for (local_28 = 0; local_28 < param_3; local_28 = local_28 + 1) {
local_2c = local_2c + *(int *)(para... |
6,669 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < size... | int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rcx,%r14
test %edx,%edx
jle 1294 <func0+0xc2>
mov %rdi,%rbx
mov %rsi,%rax
mov %rsi,%r12
lea -0x1(%rdx),%r13d
lea 0x4(%rsi,%r13,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1200 ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rcx
test edx, edx
jle loc_1293
mov r12, rdi
mov r13, rsi
mov ebx, edx
mov rax, rsi
lea edx, [rdx-1]
lea rcx, [rsi+rdx*4+4]
mov edx, 0
loc_1201:
add edx, [rax]
add rax, 4
cmp rax, rcx
jn... | long long func0(long long a1, _DWORD *a2, int a3, int *a4)
{
_DWORD *v8; // rax
long long v9; // rcx
int v10; // edx
long long v11; // rbp
long long v12; // r8
long long v13; // r10
long long v14; // rdi
int v15; // ebx
long long v16; // r9
int v17; // eax
long long v18; // rsi
_DWORD *v19; // ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RCX
TEST EDX,EDX
JLE 0x00101293
MOV R12,RDI
MOV R13,RSI
MOV EBX,EDX
MOV RAX,RSI
LEA EDX,[RDX + -0x1]
LEA RCX,[RSI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101201:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101201
MOVSXD RDX,EDX
LEA RDI,[RDX*0x4]... | int * func0(long param_1,int *param_2,uint param_3,int *param_4)
{
uint uVar1;
int *piVar2;
int *piVar3;
int iVar4;
long lVar5;
ulong uVar6;
if ((int)param_3 < 1) {
piVar2 = (int *)malloc(0);
iVar4 = 0;
}
else {
iVar4 = 0;
piVar2 = param_2;
do {
iVar4 = iVar4 + *piVar2;
... |
6,670 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < size... | int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
test %edx,%edx
jle 1890 <func0+0x100>
mov %edx,%eax
mov %rdi,%rbx
mov %rsi,%r13
xor %edx,%edx
sub $0x1,%eax
lea 0x4(%rsi,%rax,4),%r14
mov %rsi,%rax
nopl 0x0(%rax)
add (%rax),%edx
add $0x4,%rax
c... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rcx
push rbx
test edx, edx
jle loc_1889
mov ebx, edx
lea edx, [rdx-1]
mov r12, rdi
mov r13, rsi
lea rcx, [rsi+rdx*4+4]
mov rax, rsi
xor edx, edx
nop dword ptr [rax+00h]
loc_17C0:
add edx, [rax]
add ... | long long func0(long long a1, _DWORD *a2, int a3, _DWORD *a4)
{
long long v8; // rcx
_DWORD *v9; // rax
int v10; // edx
long long v11; // rax
long long v12; // r8
long long v13; // r11
long long v14; // r10
int v15; // ebx
long long v16; // r14
long long v17; // r9
long long v18; // rax
long lo... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x00101889
MOV EBX,EDX
LEA EDX,[RDX + -0x1]
MOV R12,RDI
MOV R13,RSI
LEA RCX,[RSI + RDX*0x4 + 0x4]
MOV RAX,RSI
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001017c0:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001017c0
MOVSXD RDX,E... | int * func0(long param_1,int *param_2,uint param_3,int *param_4)
{
int iVar1;
long lVar2;
int *piVar3;
int *piVar4;
int iVar5;
long lVar6;
long lVar7;
size_t __nmemb;
ulong uVar8;
if ((int)param_3 < 1) {
iVar5 = 0;
piVar3 = (int *)malloc(0);
__nmemb = 0;
}
else {
iVar5 = 0;
... |
6,671 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < size... | int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
... | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
test %edx,%edx
jle 1940 <func0+0x170>
lea -0x1(%rdx),%r14d
mov %rsi,%r13
mov %rdi,%rbx
mov %edx,%esi
cmp $0x3,%r14d
jbe 1950 <func0+0x180>
shr $0x2,%edx
mov %r13,%rax
pxor %xmm0,%xmm0
shl $0x4,%... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rcx
push rbx
test edx, edx
jle loc_17FF
lea eax, [rdx-1]
mov r13, rdi
mov r14, rsi
mov ebx, edx
cmp eax, 2
jbe loc_180F
shr edx, 2
mov rax, rsi
pxor xmm0, xmm0
shl rdx, 4
add rdx, rsi
loc_16E... | _DWORD * func0(long long a1, const __m128i *a2, int a3, int *a4)
{
const __m128i *v8; // rax
__m128i v9; // xmm0
const __m128i *v10; // rdx
__m128i v11; // xmm2
int v12; // edx
__m128i v13; // xmm0
int v14; // eax
long long v15; // rcx
_DWORD *v16; // rax
long long v17; // r10
long long v18; // r9... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x001017ff
LEA EAX,[RDX + -0x1]
MOV R13,RDI
MOV R14,RSI
MOV EBX,EDX
CMP EAX,0x2
JBE 0x0010180f
SHR EDX,0x2
MOV RAX,RSI
PXOR XMM0,XMM0
SHL RDX,0x4
ADD RDX,RSI
LAB_001016ec:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
... | int * func0(long param_1,int *param_2,uint param_3,int *param_4)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
uint uVar5;
int *piVar6;
size_t __nmemb;
long lVar7;
long lVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if ((int)param_3 < 1) {
iVar9 = 0;
piVar3 = (int *)... |
6,672 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%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
lea 0x0(,%ra... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_4], 0
jmp short loc_11C0
loc_1185:
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]
... | long long func0(long long a1, long long a2, int a3)
{
int i; // [rsp+20h] [rbp-4h]
for ( i = 0; i < a3; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) >= *(_DWORD *)(4LL * i + a2) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c0
LAB_00101185:
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 EA... | int8 func0(long param_1,long param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_3 <= local_c) {
return 1;
}
if (*(int *)(param_2 + (long)local_c * 4) <= *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
6,673 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};... | O1 | c | func0:
endbr64
test %edx,%edx
jle 1195 <func0+0x2c>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
jmp 117e <func0+0x15>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jge 119b <func0+0x32>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 117b <func0+0x12>
mov $0x1,%eax
retq
mov $0x1,%eax
r... | func0:
endbr64
test edx, edx
jle short loc_118F
mov edx, edx
mov eax, 0
loc_1178:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jge short loc_1195
add rax, 1
cmp rax, rdx
jnz short loc_1178
mov eax, 1
retn
loc_118F:
mov eax, 1
retn
loc_1195:
mov eax, 0
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) < *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x0010118f
MOV EDX,EDX
MOV EAX,0x0
LAB_00101178:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JGE 0x00101195
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101178
MOV EAX,0x1
RET
LAB_0010118f:
MOV EAX,0x1
RET
LAB_00101195:
MOV EAX,0x0
RET | int8 func0(long param_1,long param_2,uint param_3)
{
ulong uVar1;
if ((int)param_3 < 1) {
return 1;
}
uVar1 = 0;
do {
if (*(int *)(param_2 + uVar1 * 4) <= *(int *)(param_1 + uVar1 * 4)) {
return 0;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
return 1;
} |
6,674 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};... | O2 | c | func0:
endbr64
test %edx,%edx
jle 1170 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 115c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1170 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jl 1150 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%r... | func0:
endbr64
test edx, edx
jle short loc_1168
movsxd rdx, edx
xor eax, eax
jmp short loc_1159
loc_1150:
add rax, 1
cmp rax, rdx
jz short loc_1168
loc_1159:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jl short loc_1150
xor eax, eax
retn
loc_1168:
mov eax, 1
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) < *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101168
MOVSXD RDX,EDX
XOR EAX,EAX
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x00101168
LAB_00101159:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JL 0x00101150
XOR EAX,EAX
RET
LAB_00101168:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_2 + lVar1 * 4) <= *(int *)(param_1 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_3);
}
return 1;
} |
6,675 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};... | O3 | c | func0:
endbr64
test %edx,%edx
jle 1170 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 115c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1170 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jl 1150 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%r... | func0:
endbr64
test edx, edx
jle short loc_1170
movsxd rdx, edx
xor eax, eax
shl rdx, 2
jmp short loc_1161
loc_1158:
add rax, 4
cmp rdx, rax
jz short loc_1170
loc_1161:
mov ecx, [rsi+rax]
cmp [rdi+rax], ecx
jl short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
re... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
long long v4; // rdx
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
v4 = 4LL * a3;
while ( *(_DWORD *)(a1 + v3) < *(_DWORD *)(a2 + v3) )
{
v3 += 4LL;
if ( v4 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101170
MOVSXD RDX,EDX
XOR EAX,EAX
SHL RDX,0x2
JMP 0x00101161
LAB_00101158:
ADD RAX,0x4
CMP RDX,RAX
JZ 0x00101170
LAB_00101161:
MOV ECX,dword ptr [RSI + RAX*0x1]
CMP dword ptr [RDI + RAX*0x1],ECX
JL 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_2 + lVar1) <= *(int *)(param_1 + lVar1)) {
return 0;
}
lVar1 = lVar1 + 4;
} while ((long)param_3 * 4 != lVar1);
}
return 1;
} |
6,676 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + siz... | int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
i... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8d,-0x34(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 16b2 <func0+0xcb>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_34], r8d
mov [rbp+var_4], 0
jmp loc_16B0
loc_1611:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20... | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
int i; // [rsp+3Ch] [rbp-4h]
for ( i = 0; i < a5; ++i )
{
if ( *(_DWORD *)(4LL * i + a2) != *(_DWORD *)(4LL * i + a4) )
return 0LL;
if ( memcmp(*(const void **)(8LL * i + a1), *(const void **)(8LL * i + a3), 4LL * *(... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x34],R8D
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001016b0
LAB_00101611:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x... | int8 func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
int local_c;
local_c = 0;
while( true ) {
if (param_5 <= local_c) {
return 1;
}
if (*(int *)(param_2 + (long)local_c * 4) != *(int *)(param_4 + (long)local_c * 4)) break;
iVar1 = memcmp(*(void **)(... |
6,677 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + siz... | int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
i... | O1 | c | func0:
endbr64
test %r8d,%r8d
jle 1455 <func0+0x64>
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %rdx,%r14
mov %rcx,%r12
lea -0x1(%r8),%r15d
mov $0x0,%ebx
jmp 1422 <func0+0x31>
mov %rax,%rbx
mov 0x0(%rbp,%rbx,4),... | func0:
endbr64
test r8d, r8d
jle short loc_1441
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r14, rdi
mov r12, rsi
mov r15, rdx
mov r13, rcx
mov ebp, r8d
mov ebx, 0
loc_140E:
mov edx, [r12+rbx*4]
cmp edx, [r13+rbx*4+0]
jnz short lo... | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v7; // rbp
long long v8; // rbx
int v9; // edx
if ( a5 <= 0 )
return 1LL;
v7 = (unsigned int)a5;
v8 = 0LL;
while ( 1 )
{
v9 = *(_DWORD *)(a2 + 4 * v8);
if ( v9 != *(_DWORD *)(a4 + 4 * v8) )
re... | func0:
ENDBR64
TEST R8D,R8D
JLE 0x00101441
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R14,RDI
MOV R12,RSI
MOV R15,RDX
MOV R13,RCX
MOV EBP,R8D
MOV EBX,0x0
LAB_0010140e:
MOV EDX,dword ptr [R12 + RBX*0x4]
CMP EDX,dword ptr [R13 + RBX*0x4]
JNZ 0x00101447
MOVSXD RDX,EDX
SHL RDX,0x2
MOV RSI,qword p... | int8 func0(long param_1,long param_2,long param_3,long param_4,uint param_5)
{
int iVar1;
ulong uVar2;
if ((int)param_5 < 1) {
return 1;
}
uVar2 = 0;
while( true ) {
iVar1 = *(int *)(param_2 + uVar2 * 4);
if (iVar1 != *(int *)(param_4 + uVar2 * 4)) {
return 0;
}
iVar1 = memcmp(... |
6,678 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + siz... | int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
i... | O2 | c | func0:
endbr64
test %r8d,%r8d
jle 19f4 <func0+0x84>
push %r15
mov %rdx,%r15
push %r14
mov %rdi,%r14
push %r13
xor %r13d,%r13d
push %r12
lea -0x1(%r8),%r12d
push %rbp
mov %rcx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
jmp 19c1 <func0+0x51>
nopl 0x0(%rax)
mov (%r15,%r13,8),%... | func0:
endbr64
test r8d, r8d
jle short loc_19F4
push r15
mov r15, rdx
push r14
mov r14, rdi
push r13
mov r13, rcx
push r12
mov r12, rsi
push rbp
movsxd rbp, r8d
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_19BE
loc_19A0:
mov rsi, [r15+rbx*8]
mov rdi, [r14+... | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v7; // rbp
long long i; // rbx
long long v9; // rdx
if ( a5 <= 0 )
return 1LL;
v7 = a5;
for ( i = 0LL; i != v7; ++i )
{
v9 = *(int *)(a2 + 4 * i);
if ( (_DWORD)v9 != *(_DWORD *)(a4 + 4 * i)
|| (... | func0:
ENDBR64
TEST R8D,R8D
JLE 0x001019f4
PUSH R15
MOV R15,RDX
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RSI
PUSH RBP
MOVSXD RBP,R8D
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001019be
LAB_001019a0:
MOV RSI,qword ptr [R15 + RBX*0x8]
MOV RDI,qword ptr [R14 + RBX*0x8]
SHL RDX,0x2
CALL 0x001010d0
TEST EAX,EA... | int8 func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
long lVar2;
if (param_5 < 1) {
return 1;
}
lVar2 = 0;
while( true ) {
iVar1 = *(int *)(param_2 + lVar2 * 4);
if (iVar1 != *(int *)(param_4 + lVar2 * 4)) {
return 0;
}
iVar1 = memcmp(*(void ... |
6,679 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + siz... | int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
i... | O3 | c | func0:
endbr64
test %r8d,%r8d
jle 19f4 <func0+0x84>
push %r15
mov %rdx,%r15
push %r14
mov %rdi,%r14
push %r13
xor %r13d,%r13d
push %r12
lea -0x1(%r8),%r12d
push %rbp
mov %rcx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
jmp 19c1 <func0+0x51>
nopl 0x0(%rax)
mov (%r15,%r13,8),%... | func0:
endbr64
test r8d, r8d
jle loc_1AA4
push r15
movsxd r8, r8d
mov r15, rdx
push r14
mov r14, rdi
push r13
mov r13, rcx
push r12
mov r12, rsi
push rbp
lea rbp, ds:0[r8*4]
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_1A6E
loc_1A50:
mov rsi, [r15+rbx*2]; ... | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v7; // rbp
long long v8; // rbx
long long v9; // rdx
if ( a5 <= 0 )
return 1LL;
v7 = 4LL * a5;
v8 = 0LL;
do
{
v9 = *(int *)(a2 + v8);
if ( (_DWORD)v9 != *(_DWORD *)(a4 + v8)
|| memcmp(*(const ... | func0:
ENDBR64
TEST R8D,R8D
JLE 0x00101aa4
PUSH R15
MOVSXD R8,R8D
MOV R15,RDX
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RSI
PUSH RBP
LEA RBP,[R8*0x4]
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x00101a6e
LAB_00101a50:
MOV RSI,qword ptr [R15 + RBX*0x2]
MOV RDI,qword ptr [R14 + RBX*0x2]
SHL RDX,0x2
CALL 0x0010... | int8 func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
long lVar2;
if (param_5 < 1) {
return 1;
}
lVar2 = 0;
while( true ) {
if (*(int *)(param_2 + lVar2) != *(int *)(param_4 + lVar2)) {
return 0;
}
iVar1 = memcmp(*(void **)(param_1 + lVar2 * 2),*(... |
6,680 | func0 |
#include <assert.h>
| int func0(int array_nums[], int size) {
int count_even = 0;
for (int i = 0; i < size; i++) {
if (array_nums[i] % 2 == 0) {
count_even++;
}
}
return count_even;
}
| int main() {
int array1[] = {1, 2, 3, 5, 7, 8, 9, 10};
int size1 = sizeof(array1) / sizeof(array1[0]);
assert(func0(array1, size1) == 3);
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int size2 = sizeof(array2) / sizeof(array2[0]);
assert(func0(array2, size2) == 5);
int a... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ad <func0+0x44>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11a... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AD
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, ... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ad
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) == 0) {
local_10 = local_10 + 1;
}
}
return local_10;
} |
6,681 | func0 |
#include <assert.h>
| int func0(int array_nums[], int size) {
int count_even = 0;
for (int i = 0; i < size; i++) {
if (array_nums[i] % 2 == 0) {
count_even++;
}
}
return count_even;
}
| int main() {
int array1[] = {1, 2, 3, 5, 7, 8, 9, 10};
int size1 = sizeof(array1) / sizeof(array1[0]);
assert(func0(array1, size1) == 3);
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int size2 = sizeof(array2) / sizeof(array2[0]);
assert(func0(array2, size2) == 5);
int a... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1198 <func0+0x2f>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%ecx
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%ecx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 11... | func0:
endbr64
test esi, esi
jle short loc_1198
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov ecx, 0
loc_1181:
mov edx, [rax]
and edx, 1
cmp edx, 1
adc ecx, 0
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1195:
mov eax, ecx
retn
loc_1198:
mov ecx, 0... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rsi
unsigned int v4; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 += (*v2++ & 1) == 0;
while ( v2 != (_DWORD *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101198
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV ECX,0x0
LAB_00101181:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
ADC ECX,0x0
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101195:
MOV EAX,ECX
RET
LAB_00101198:
MOV ECX,0x0
JMP 0x00101195 | int func0(uint *param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((*param_1 & 1) == 0);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return ... |
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.