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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
694 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *numbers, int size) {
if (size <= 0) {
return NULL;
}
int *out = malloc(size * sizeof(int));
if (!out) {
return NULL;
}
int max = numbers[0];
for (int i = 0; i < size; i++) {
if (numbers[i] > max) max = numbers[i];
out[i] = max;
}
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
// First test case
result = func0((const int[]){}, 0);
assert(result == NULL);
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 13e0 <func0+0x60>
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %rax,%rax
je 13d4 <func0+0x54>
mov (%rbx),%ecx
lea -0x1(%rbp),%edi
xor %edx,%edx
shl $0x2,%rdi
mov %ecx... | func0:
endbr64
test esi, esi
jle short loc_13A8
push rbp
movsxd rsi, esi
mov rbp, rdi
push rbx
lea rbx, ds:0[rsi*4]
mov rdi, rbx; size
sub rsp, 8
call _malloc
test rax, rax
jz short loc_139C
mov ecx, [rbp+0]
xor edx, edx
xchg ax, ax
loc_1380:
mov esi, [rbp+rdx+0]
... | char * func0(int *a1, int a2)
{
char *result; // rax
int v3; // ecx
long long i; // rdx
if ( a2 <= 0 )
return 0LL;
result = (char *)malloc(4LL * a2);
if ( !result )
return 0LL;
v3 = *a1;
for ( i = 0LL; i != a2; ++i )
{
if ( v3 < a1[i] )
v3 = a1[i];
*(_DWORD *)&result[i * 4] = v3... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013a8
PUSH RBP
MOVSXD RSI,ESI
MOV RBP,RDI
PUSH RBX
LEA RBX,[RSI*0x4]
MOV RDI,RBX
SUB RSP,0x8
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010139c
MOV ECX,dword ptr [RBP]
XOR EDX,EDX
NOP
LAB_00101380:
MOV ESI,dword ptr [RBP + RDX*0x1]
CMP ECX,ESI
CMOVL ECX,ESI
MOV dword ptr [RAX + RDX*0x1],ECX... | void * func0(int *param_1,int param_2)
{
void *pvVar1;
int iVar2;
long lVar3;
if (param_2 < 1) {
return (void *)0x0;
}
pvVar1 = malloc((long)param_2 * 4);
if (pvVar1 != (void *)0x0) {
iVar2 = *param_1;
lVar3 = 0;
do {
if (iVar2 < *(int *)((long)param_1 + lVar3)) {
iVar2 =... |
695 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *numbers, int size) {
if (size <= 0) {
return NULL;
}
int *out = malloc(size * sizeof(int));
if (!out) {
return NULL;
}
int max = numbers[0];
for (int i = 0; i < size; i++) {
if (numbers[i] > max) max = numbers[i];
out[i] = max;
}
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
// First test case
result = func0((const int[]){}, 0);
assert(result == NULL);
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 13c0 <func0+0x60>
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %rax,%rax
je 13ae <func0+0x4e>
mov (%rbx),%ecx
lea -0x1(%rbp),%edi
xor %edx,%edx
nopl 0x0(%rax,%rax,1)
mov ... | func0:
endbr64
test esi, esi
jle short loc_1378
push rbp
movsxd rsi, esi
mov rbp, rdi
push rbx
lea rbx, ds:0[rsi*4]
mov rdi, rbx; size
sub rsp, 8
call _malloc
test rax, rax
jz short loc_136C
mov ecx, [rbp+0]
xor edx, edx
xchg ax, ax
loc_1350:
mov esi, [rbp+rdx+0]
... | char * func0(int *a1, int a2)
{
char *result; // rax
int v3; // ecx
long long i; // rdx
if ( a2 <= 0 )
return 0LL;
result = (char *)malloc(4LL * a2);
if ( !result )
return 0LL;
v3 = *a1;
for ( i = 0LL; i != a2; ++i )
{
if ( v3 < a1[i] )
v3 = a1[i];
*(_DWORD *)&result[i * 4] = v3... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101378
PUSH RBP
MOVSXD RSI,ESI
MOV RBP,RDI
PUSH RBX
LEA RBX,[RSI*0x4]
MOV RDI,RBX
SUB RSP,0x8
CALL 0x001010b0
TEST RAX,RAX
JZ 0x0010136c
MOV ECX,dword ptr [RBP]
XOR EDX,EDX
NOP
LAB_00101350:
MOV ESI,dword ptr [RBP + RDX*0x1]
CMP ECX,ESI
CMOVL ECX,ESI
MOV dword ptr [RAX + RDX*0x1],ECX... | void * func0(int *param_1,int param_2)
{
void *pvVar1;
int iVar2;
long lVar3;
if (param_2 < 1) {
return (void *)0x0;
}
pvVar1 = malloc((long)param_2 * 4);
if (pvVar1 != (void *)0x0) {
iVar2 = *param_1;
lVar3 = 0;
do {
if (iVar2 < *(int *)((long)param_1 + lVar3)) {
iVar2 =... |
696 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
... | #include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Thi... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
add %eax,%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%... | 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_C], eax
mov eax, [rbp+var_C]
add eax, eax
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
cmp [rbp+dest], 0
jnz s... | char * func0(const char *a1)
{
int i; // [rsp+18h] [rbp-18h]
int k; // [rsp+1Ch] [rbp-14h]
int m; // [rsp+1Ch] [rbp-14h]
int j; // [rsp+1Ch] [rbp-14h]
int v6; // [rsp+20h] [rbp-10h]
int v7; // [rsp+24h] [rbp-Ch]
char *dest; // [rsp+28h] [rbp-8h]
v7 = strlen(a1);
dest = (char *)malloc(2 * v7 + 1);
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 0x001010c0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EAX
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x... | char * func0(char *param_1)
{
bool bVar1;
int iVar2;
size_t sVar3;
char *__dest;
int local_20;
int local_1c;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
__dest = (char *)malloc((long)(iVar2 * 2 + 1));
if (__dest == (char *)0x0) {
__dest = (char *)0x0;
}
else {
for (local_20 = 0; loc... |
697 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
... | #include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Thi... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%r12
lea (%r12,%r12,1),%r15d
lea 0x1(%r15),%edi
movslq %edi,%rdi
callq... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
call _strlen
mov r13, rax
mov r14d, eax
lea eax, [rax+rax]
mov [rsp+48h+var_3C], eax
add eax, 1
cdqe
mov [rsp+48h+var_48], rax
mov rdi, rax; size
call _malloc
mov ... | _BYTE * func0(const char *a1)
{
int v1; // r13d
_BYTE *v2; // rax
_BYTE *v3; // r15
int v4; // r12d
const char *v5; // rsi
int v6; // ebx
const char *v7; // rdx
long long v8; // rax
const char *v9; // rax
char *v10; // r12
const char *v11; // rdx
const char *v12; // rax
_BYTE *v13; // rdx
si... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
CALL 0x001010b0
MOV R13,RAX
MOV R14D,EAX
LEA EAX,[RAX + RAX*0x1]
MOV dword ptr [RSP + 0xc],EAX
ADD EAX,0x1
CDQE
MOV qword ptr [RSP],RAX
MOV RDI,RAX
CALL 0x001010e0
MOV R15,RAX
TEST RAX,RAX
JZ 0x00101323
TEST R13D,R13D
JLE 0x00... | void * func0(char *param_1)
{
uint uVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
char *pcVar5;
uint uVar6;
uint uVar7;
char *pcVar8;
uint uVar9;
bool bVar10;
sVar2 = strlen(param_1);
uVar1 = (uint)sVar2;
sVar2 = (size_t)(int)(uVar1 * 2 + 1);
pvVar3 = malloc(sVar2);
if (pvVar3 != (void... |
698 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
... | #include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Thi... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%ebx
mov %rax,%r12
mov %eax,%r15d
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 1460 <fu... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
call _strlen
lea ebx, [rax+rax]
mov r13, rax
mov r15d, eax
lea r8d, [rbx+1]
movsxd r8, r8d
mov rdi, r8; size
mov [rsp+48h+var_40], r8
call _malloc
mov rdi, rax
test... | _BYTE * func0(const char *a1)
{
int v2; // eax
int v3; // ebx
int v4; // r13d
int v5; // r15d
_BYTE *v6; // rdi
const char *v7; // rsi
int v8; // ebp
const char *v9; // rdx
const char *v10; // rax
const char *v11; // rax
_BYTE *v12; // rdx
char v13; // cl
long long v15; // rax
char *v16; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1]
MOV R13,RAX
MOV R15D,EAX
LEA R8D,[RBX + 0x1]
MOVSXD R8,R8D
MOV RDI,R8
MOV qword ptr [RSP + 0x8],R8
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010145a
TEST R13D,R13D
MOV R8,qword ptr ... | void * func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
int iVar8;
char *pcVar9;
long lVar10;
bool bVar11;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
pvVar4 = malloc(sVar3);
if (pvVar4 ... |
699 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *str) {
int len = strlen(str), i, j;
char *result = (char *)malloc(2 * len + 1);
if (!result) {
return NULL;
}
for (i = 0; i < len; i++) {
int is_palindrome = 1;
for (j = 0; j < (len - i) / 2; j++) {
if (str[i + j] != str[len - 1 - j]) {
... | #include <assert.h>
#include <string.h>
int main() {
char *palindrome;
// First test case
palindrome = func0("");
assert(strcmp(palindrome, "") == 0);
free(palindrome);
// Second test case
palindrome = func0("x");
assert(strcmp(palindrome, "x") == 0);
free(palindrome);
// Thi... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%ebx
mov %rax,%r12
mov %eax,%r15d
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r8
test %rax,%rax
je 1460 <fu... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
call _strlen
lea ebx, [rax+rax]
mov r13, rax
mov r15d, eax
lea r8d, [rbx+1]
movsxd r8, r8d
mov rdi, r8; size
mov [rsp+48h+var_40], r8
call _malloc
mov rdi, rax
test... | _BYTE * func0(const char *a1)
{
int v2; // eax
int v3; // ebx
int v4; // r13d
int v5; // r15d
_BYTE *v6; // rdi
const char *v7; // rsi
int v8; // ebp
const char *v9; // rdx
const char *v10; // rax
const char *v11; // rax
_BYTE *v12; // rdx
char v13; // cl
long long v15; // rax
char *v16; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1]
MOV R13,RAX
MOV R15D,EAX
LEA R8D,[RBX + 0x1]
MOVSXD R8,R8D
MOV RDI,R8
MOV qword ptr [RSP + 0x8],R8
CALL 0x001010e0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010145a
TEST R13D,R13D
MOV R8,qword ptr ... | void * func0(char *param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
int iVar8;
char *pcVar9;
long lVar10;
bool bVar11;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
pvVar4 = malloc(sVar3);
if (pvVar4 ... |
700 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0(... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %eax,-0x14(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %eax,-0x10(%rbp)
mov -0x14(%rbp),%eax
cmp ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_14], eax
mov rax, [rbp+var_30]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], eax
mov edx, [rbp+var_10]
mov eax, [r... | _BYTE * func0(const char *a1, const char *a2)
{
int v2; // edx
int v3; // eax
char v5; // cl
int i; // [rsp+18h] [rbp-18h]
int v7; // [rsp+1Ch] [rbp-14h]
int v8; // [rsp+24h] [rbp-Ch]
_BYTE *v9; // [rsp+28h] [rbp-8h]
v7 = strlen(a1);
v2 = strlen(a2);
v3 = v7;
if ( v2 <= v7 )
v3 = v2;
v8 = v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RBP + -0x10],EAX
MOV EDX,dword ptr [RBP ... | void * func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
int uVar5;
int local_20;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
iVar1 = (int)sVar2;
if ((int)sVar3 <= (int)sVar2) {
iVar1 = (int)sVar3;
}
pvVar4 = malloc((long)(iVar1 + 1));
if (... |
701 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0(... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%r12
mov $0xffffffffffffffff,%rbx
mov $0x0,%eax
mov %rbx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rdx
mov %rbx,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rsi
call _strlen
mov r12, rax
mov rdi, rbp; s
call _strlen
cmp r12d, eax
cmovg r12d, eax
lea edi, [r12+1]
movsxd rdi, edi; size
call _malloc
test rax, rax
jz short loc_1230
test r12d, r12d
jle sho... | _BYTE * func0(const char *a1, const char *a2)
{
int v2; // r12d
int v3; // eax
_BYTE *result; // rax
long long i; // rdx
v2 = strlen(a1);
v3 = strlen(a2);
if ( v2 > v3 )
v2 = v3;
result = malloc(v2 + 1);
if ( result )
{
if ( v2 > 0 )
{
for ( i = 0LL; i != v2; ++i )
result[... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RBP,RSI
CALL 0x001010a0
MOV R12,RAX
MOV RDI,RBP
CALL 0x001010a0
CMP R12D,EAX
CMOVG R12D,EAX
LEA EDI,[R12 + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101230
TEST R12D,R12D
JLE 0x00101228
MOVSXD RSI,R12D
MOV EDX,0x0
LAB_0010120d:
MOVZX EDI,byte ptr [... | void func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
long lVar5;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
iVar1 = (int)sVar2;
if ((int)sVar3 < (int)sVar2) {
iVar1 = (int)sVar3;
}
pvVar4 = malloc((long)(iVar1 + 1));
if (pvVar4 != (void *)... |
702 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0(... | O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
callq 1090 <strlen@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 1090 <strlen@plt>
cmp %r12d,%eax
cmovl %eax,%r12d
lea 0x1(%r12),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 132e <func0+0x6e>
test %r... | func0:
endbr64
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
call _strlen
mov rdi, r12; s
mov rbx, rax
call _strlen
cmp ebx, eax
cmovg ebx, eax
lea edi, [rbx+1]
movsxd rdi, edi; size
call _malloc
test rax, rax
jz short loc_132F
movsxd rsi, ebx
xor edx, ed... | _BYTE * func0(const char *a1, const char *a2)
{
int v2; // ebx
int v3; // eax
_BYTE *result; // rax
long long v5; // rdx
v2 = strlen(a1);
v3 = strlen(a2);
if ( v2 > v3 )
v2 = v3;
result = malloc(v2 + 1);
if ( result )
{
v5 = 0LL;
if ( v2 > 0 )
{
do
{
result[v5] =... | func0:
ENDBR64
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x001010a0
MOV RDI,R12
MOV RBX,RAX
CALL 0x001010a0
CMP EBX,EAX
CMOVG EBX,EAX
LEA EDI,[RBX + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
TEST RAX,RAX
JZ 0x0010132f
MOVSXD RSI,EBX
XOR EDX,EDX
TEST EBX,EBX
JLE 0x0010132b
NOP dword ptr [RAX]
LAB_00101310:
MOVZX... | void func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
long lVar5;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
iVar1 = (int)sVar2;
if ((int)sVar3 < (int)sVar2) {
iVar1 = (int)sVar3;
}
pvVar4 = malloc((long)(iVar1 + 1));
if (pvVar4 != (void *)... |
703 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char *func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
int min_len = len_a < len_b ? len_a : len_b;
char *output = malloc((min_len + 1) * sizeof(char));
if (!output) return NULL;
for (int i = 0; i < min_len; i++) {
output[i] = (a[i] == b[i]) ? '0' : '1... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
char *result;
result = func0("111000", "101010");
assert(strcmp(result, "010010") == 0);
free(result);
result = func0("1", "1");
assert(strcmp(result, "0") == 0);
free(result);
result = func0(... | O3 | c | func0:
endbr64
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
callq 1090 <strlen@plt>
mov %rbp,%rdi
mov %rax,%rbx
callq 1090 <strlen@plt>
cmp %ebx,%eax
cmovl %eax,%ebx
lea 0x1(%rbx),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 1557 <func0+0x297>
test %eb... | func0:
endbr64
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
call _strlen
mov rdi, rbp; s
mov rbx, rax
call _strlen
cmp ebx, eax
cmovg ebx, eax
lea edi, [rbx+1]
movsxd rdi, edi; size
call _malloc
mov rdx, rax
test rax, rax
jz loc_14A0
test ebx, ebx
jle ... | _BYTE * func0(const char *a1, const char *a2)
{
int v3; // ebx
int v4; // eax
_BYTE *v5; // rdx
__m128i si128; // xmm3
__m128i v7; // xmm2
long long v8; // rax
__m128i v9; // xmm0
int v10; // eax
long long v11; // rcx
int v12; // esi
__m128i v13; // xmm0
int v14; // ecx
int v15; // eax
v3 =... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
CALL 0x001010a0
MOV RDI,RBP
MOV RBX,RAX
CALL 0x001010a0
CMP EBX,EAX
CMOVG EBX,EAX
LEA EDI,[RBX + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
MOV RDX,RAX
TEST RAX,RAX
JZ 0x001014a0
TEST EBX,EBX
JLE 0x00101499
LEA EAX,[RBX + -0x1]
CMP EAX,0xe
JBE 0x001014a8
MOV EC... | void * func0(char *param_1,char *param_2)
{
char *pcVar1;
byte *pbVar2;
char *pcVar3;
int8 uVar4;
int8 uVar5;
char cVar6;
char cVar7;
char cVar8;
char cVar9;
char cVar10;
char cVar11;
char cVar12;
char cVar13;
char cVar14;
char cVar15;
char cVar16;
char cVar17;
char cVar18;
char c... |
704 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
re... | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
lea 0xe45(%rip),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1226 <func0+0x7d>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
lea rax, unk_2008
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_1226
loc_11D7:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_2... | void * func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v5; // [rsp+24h] [rbp-Ch]
void *v6; // [rsp+28h] [rbp-8h]
v6 = &unk_2008;
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v5 = strlen(*(const char **)(8LL * i + a1));
if ( v5 > v3 )
{
v6 = *(voi... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101226
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,q... | int * func0(long param_1,int param_2)
{
size_t sVar1;
int local_1c;
int local_18;
int *local_10;
local_10 = &DAT_00102008;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
sVar1 = strlen(*(char **)(param_1 + (long)local_18 * 8));
if (local_1c < (int)sVar1) {
... |
705 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
re... | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(... | O1 | c | func0:
endbr64
lea 0xea7(%rip),%r11
test %esi,%esi
jle 11bf <func0+0x56>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r10
mov $0x0,%r8d
mov $0xffffffffffffffff,%r9
mov $0x0,%eax
jmp 11a0 <func0+0x37>
add $0x8,%rdx
cmp %r10,%rdx
je 11bf <func0+0x56>
mov (%rdx),%rsi
mo... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
lea r13, aAbc+3; ""
test esi, esi
jle short loc_11EC
mov rbx, rdi
movsxd rsi, esi
lea r14, [rdi+rsi*8]
mov ebp, 0
loc_11CF:
mov r12, [rbx]
mov rdi, r12; s
call _strlen
cmp eax, ebp
cmovg ebp, eax
cmovg ... | char * func0(const char **a1, int a2)
{
char *v2; // r13
const char **v3; // rbx
int v4; // ebp
const char *v5; // r12
int v6; // eax
v2 = "";
if ( a2 > 0 )
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = strlen(*v3);
if ( v6 > v4 )
{
v4 = v6;
v2 = (char *... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA R13,[0x10201b]
TEST ESI,ESI
JLE 0x001011ec
MOV RBX,RDI
MOVSXD RSI,ESI
LEA R14,[RDI + RSI*0x8]
MOV EBP,0x0
LAB_001011cf:
MOV R12,qword ptr [RBX]
MOV RDI,R12
CALL 0x00101080
CMP EAX,EBP
CMOVG EBP,EAX
CMOVG R13,R12
ADD RBX,0x8
CMP RBX,R14
JNZ 0x001011cf
LAB_0... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
size_t sVar2;
int iVar3;
char *pcVar4;
pcVar4 = "";
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar3 = 0;
do {
__s = (char *)*param_1;
sVar2 = strlen(__s);
if (iVar3 < (int)sVar2) {
pcVar4 = __... |
706 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
re... | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
lea 0xd7a(%rip),%r12
push %rbp
push %rbx
test %esi,%esi
jle 12d5 <func0+0x45>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %ebp,%ebp
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax)
mov (%rbx),%r14
mov %r14,%rdi
callq 1070 <strlen@plt>
cmp %ebp,%ea... | func0:
endbr64
push r14
lea r14, aAbc+3; ""
push r13
push r12
push rbp
push rbx
test esi, esi
jle short loc_1365
movsxd rsi, esi
mov rbx, rdi
xor ebp, ebp
lea r13, [rdi+rsi*8]
nop dword ptr [rax+rax+00h]
loc_1348:
mov r12, [rbx]
mov rdi, r12; s
call _strlen
cmp ... | char * func0(const char **a1, int a2)
{
char *v2; // r14
const char **v3; // rbx
int v4; // ebp
const char *v5; // r12
int v6; // eax
v2 = "";
if ( a2 > 0 )
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = strlen(*v3);
if ( v6 > v4 )
{
v4 = v6;
v2 = (char *... | func0:
ENDBR64
PUSH R14
LEA R14,[0x10201b]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x00101365
MOVSXD RSI,ESI
MOV RBX,RDI
XOR EBP,EBP
LEA R13,[RDI + RSI*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101348:
MOV R12,qword ptr [RBX]
MOV RDI,R12
CALL 0x00101080
CMP EAX,EBP
CMOVG EBP,EAX
CMOVG R14,R12
ADD RBX,0x8
CM... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
size_t sVar2;
int iVar3;
char *pcVar4;
pcVar4 = "";
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + param_2;
do {
__s = (char *)*param_1;
sVar2 = strlen(__s);
if (iVar3 < (int)sVar2) {
pcVar4 = __... |
707 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char **strings, int count) {
char *out = "";
int longest_length = 0;
for (int i = 0; i < count; i++) {
int current_length = strlen(strings[i]);
if (current_length > longest_length) {
out = strings[i];
longest_length = current_length;
}
}
re... | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char *empty_array[] = {""};
char *array1[] = {"x", "y", "z"};
char *array2[] = {"x", "yyy", "zzzz", "www", "kkkk", "abc"};
assert(strcmp(func0(empty_array, 0), "") == 0);
assert(strcmp(func0(array1, 3), "x") == 0);
assert(... | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
lea 0xd2a(%rip),%r12
push %rbp
push %rbx
test %esi,%esi
jle 1325 <func0+0x45>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %ebp,%ebp
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax)
mov (%rbx),%r14
mov %r14,%rdi
callq 1070 <strlen@plt>
cmp %ebp,%ea... | func0:
endbr64
push r14
lea r14, unk_2004
push r13
push r12
push rbp
push rbx
test esi, esi
jle short loc_11A5
movsxd rsi, esi
mov rbx, rdi
xor ebp, ebp
lea r13, [rdi+rsi*8]
nop dword ptr [rax+rax+00h]
loc_1188:
mov r12, [rbx]
mov rdi, r12; s
call _strlen
cmp ea... | const char * func0(const char **a1, int a2)
{
const char *v2; // r14
const char **v3; // rbx
int v4; // ebp
const char *v5; // r12
int v6; // eax
v2 = (const char *)&unk_2004;
if ( a2 > 0 )
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
v6 = strlen(*v3);
if ( v6 > v4 )
{
... | func0:
ENDBR64
PUSH R14
LEA R14,[0x102004]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001011a5
MOVSXD RSI,ESI
MOV RBX,RDI
XOR EBP,EBP
LEA R13,[RDI + RSI*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101188:
MOV R12,qword ptr [RBX]
MOV RDI,R12
CALL 0x00101050
CMP EAX,EBP
CMOVG EBP,EAX
CMOVG R14,R12
ADD RBX,0x8
CM... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
size_t sVar2;
int iVar3;
char *pcVar4;
pcVar4 = "";
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + param_2;
do {
__s = (char *)*param_1;
sVar2 = strlen(__s);
if (iVar3 < (int)sVar2) {
pcVar4 = __... |
708 | func0 | #include <stdio.h>
| int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
} | #include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
jmp 116f <func0+0x26>
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x4(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
jne 1159 <... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
jmp short loc_116F
loc_1159:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov [rbp+var_4], edx
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
mov eax, [rbp+var_4]
mov [rbp+var_18], eax
loc_116F:
cm... | long long func0(int a1, int a2)
{
int v5; // [rsp+14h] [rbp-4h]
while ( a2 )
{
v5 = a1 % a2;
a1 = a2;
a2 = v5;
}
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
JMP 0x0010116f
LAB_00101159:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EDX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x4]
... | int func0(int param_1,int param_2)
{
int iVar1;
int4 local_20;
int4 local_1c;
local_20 = param_2;
local_1c = param_1;
while (local_20 != 0) {
iVar1 = local_1c % local_20;
local_1c = local_20;
local_20 = iVar1;
}
return local_1c;
} |
709 | func0 | #include <stdio.h>
| int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
} | #include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
} | O1 | c | func0:
endbr64
mov %edi,%eax
test %esi,%esi
je 1163 <func0+0x1a>
mov %esi,%ecx
cltd
idiv %esi
mov %edx,%esi
mov %ecx,%eax
test %edx,%edx
jne 1153 <func0+0xa>
mov %ecx,%eax
retq
mov %edi,%ecx
jmp 1160 <func0+0x17>
| func0:
endbr64
mov eax, edi
test esi, esi
jz short loc_1163
loc_1153:
mov ecx, esi
cdq
idiv esi
mov esi, edx
mov eax, ecx
test edx, edx
jnz short loc_1153
loc_1160:
mov eax, ecx
retn
loc_1163:
mov ecx, edi
jmp short loc_1160 | long long func0(unsigned int a1, int a2)
{
signed int v2; // eax
unsigned int v3; // ecx
v2 = a1;
if ( a2 )
{
do
{
v3 = a2;
a2 = v2 % a2;
v2 = v3;
}
while ( a2 );
}
else
{
return a1;
}
return v3;
} | func0:
ENDBR64
MOV EAX,EDI
TEST ESI,ESI
JZ 0x00101163
LAB_00101153:
MOV ECX,ESI
CDQ
IDIV ESI
MOV ESI,EDX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101153
LAB_00101160:
MOV EAX,ECX
RET
LAB_00101163:
MOV ECX,EDI
JMP 0x00101160 | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_1;
if (param_2 != 0) {
do {
param_1 = param_2;
param_2 = iVar1 % param_1;
iVar1 = param_1;
} while (param_2 != 0);
}
return param_1;
} |
710 | func0 | #include <stdio.h>
| int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
} | #include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
} | O2 | c | func0:
endbr64
mov %edi,%eax
mov %esi,%edx
test %esi,%esi
je 1298 <func0+0x28>
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 1280 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov %edi,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
mov eax, edi
mov edx, esi
test esi, esi
jz short loc_1290
nop dword ptr [rax+00h]
loc_1280:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1280
mov eax, ecx
retn
loc_1290:
mov ecx, edi
mov eax, ecx
retn | long long func0(unsigned int a1, int a2)
{
signed int v2; // eax
int v3; // edx
unsigned int v4; // ecx
v2 = a1;
v3 = a2;
if ( !a2 )
return a1;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return v4;
} | func0:
ENDBR64
MOV EAX,EDI
MOV EDX,ESI
TEST ESI,ESI
JZ 0x00101290
NOP dword ptr [RAX]
LAB_00101280:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101280
MOV EAX,ECX
RET
LAB_00101290:
MOV ECX,EDI
MOV EAX,ECX
RET | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 != 0) {
do {
iVar1 = param_2;
param_2 = param_1 % iVar1;
param_1 = iVar1;
} while (param_2 != 0);
return iVar1;
}
return param_1;
} |
711 | func0 | #include <stdio.h>
| int func0(int a, int b) {
while (b != 0) {
int m = a % b;
a = b;
b = m;
}
return a;
} | #include <assert.h>
int main() {
assert(func0(3, 7) == 1);
assert(func0(10, 15) == 5);
assert(func0(49, 14) == 7);
assert(func0(144, 60) == 12);
return 0;
} | O3 | c | func0:
endbr64
mov %edi,%eax
mov %esi,%edx
test %esi,%esi
je 1298 <func0+0x28>
nopl 0x0(%rax)
mov %edx,%r8d
cltd
idiv %r8d
mov %r8d,%eax
test %edx,%edx
jne 1280 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov %edi,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
mov eax, edi
mov edx, esi
test esi, esi
jz short loc_1290
nop dword ptr [rax+00h]
loc_1280:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1280
mov eax, ecx
retn
loc_1290:
mov ecx, edi
mov eax, ecx
retn | long long func0(unsigned int a1, int a2)
{
signed int v2; // eax
int v3; // edx
unsigned int v4; // ecx
v2 = a1;
v3 = a2;
if ( !a2 )
return a1;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return v4;
} | func0:
ENDBR64
MOV EAX,EDI
MOV EDX,ESI
TEST ESI,ESI
JZ 0x00101290
NOP dword ptr [RAX]
LAB_00101280:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101280
MOV EAX,ECX
RET
LAB_00101290:
MOV ECX,EDI
MOV EAX,ECX
RET | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 != 0) {
do {
iVar1 = param_2;
param_2 = param_1 % iVar1;
param_1 = iVar1;
} while (param_2 != 0);
return iVar1;
}
return param_1;
} |
712 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
... | #include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < coun... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
mov %eax,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x20(%r... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov ... | _QWORD * func0(const char *a1, _DWORD *a2)
{
size_t v2; // rax
int i; // [rsp+10h] [rbp-30h]
int v5; // [rsp+14h] [rbp-2Ch]
char *src; // [rsp+18h] [rbp-28h]
_QWORD *v7; // [rsp+20h] [rbp-20h]
size_t v8; // [rsp+28h] [rbp-18h]
v5 = strlen(a1);
v7 = malloc(8LL * v5);
src = (char *)malloc(v5 + 1);
*s... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010e0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x20],R... | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
void *pvVar3;
void *pvVar4;
int local_38;
char *local_30;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pvVar3 = malloc((long)iVar1 << 3);
local_30 = (char *)malloc((long)(iVar1 + 1));
*local_30 = '\0';
for (local_38 = 0; loc... |
713 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
... | #include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < coun... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r15
mov %rsi,0x18(%rsp)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r14
mov %r14,0x10(%rsp)
movslq %r14d,%rdi
shl $0x3,%rdi
callq ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r14, rdi
mov [rsp+48h+var_48], rsi
call _strlen
mov r15, rax
mov [rsp+48h+var_40], rax
movsxd rdi, eax
shl rdi, 3; size
call _malloc
mov r13, rax
lea edi, [r15+1]
movsxd rdi, e... | _QWORD * func0(const char *a1, int *a2)
{
int v2; // r15d
_QWORD *v3; // r13
char *v4; // rbx
long long v5; // r15
long long v6; // r12
size_t v7; // rbp
size_t v8; // rbp
void *v9; // rax
long long v10; // rax
int v12; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
v12 = v2;
v3 = malloc(8LL * v2);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV qword ptr [RSP],RSI
CALL 0x001010d0
MOV R15,RAX
MOV qword ptr [RSP + 0x8],RAX
MOVSXD RDI,EAX
SHL RDI,0x3
CALL 0x00101110
MOV R13,RAX
LEA EDI,[R15 + 0x1]
MOVSXD RDI,EDI
CALL 0x00101110
MOV RBX,RAX
MOV byte ptr [RAX],0x0
TES... | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
void *pvVar3;
char *__s;
void *pvVar4;
ulong uVar5;
bool bVar6;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pvVar3 = malloc((long)iVar1 << 3);
__s = (char *)malloc((long)(iVar1 + 1));
*__s = '\0';
if (0 < iVar1) {
uVa... |
714 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
... | #include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < coun... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
mov %rsi,(%rsp)
callq 10d0 <strlen@plt>
movslq %eax,%rdi
mov %rax,%rbx
mov %rax,0x8(%rsp)
shl $0x3,%rdi
callq 1120 <malloc@plt>
lea 0x1(%rbx),%edi
movslq %edi,%rdi
mov %rax,%r12
... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rsi
call _strlen
movsxd rdi, eax
mov r14, rax
mov [rsp+48h+var_40], rax
shl rdi, 3; size
call _malloc
lea edi, [r14+1]
movsxd rdi, edi; size
mov ... | _QWORD * func0(const char *a1, int *a2)
{
int v2; // r14d
_QWORD *v3; // r12
char *v4; // rax
char *v5; // rbx
long long v6; // r14
long long v7; // rbp
size_t v8; // r15
char v9; // al
size_t v10; // r15
void *v11; // rax
long long v12; // rax
int v14; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RSI
CALL 0x001010d0
MOVSXD RDI,EAX
MOV R14,RAX
MOV qword ptr [RSP + 0x8],RAX
SHL RDI,0x3
CALL 0x00101120
LEA EDI,[R14 + 0x1]
MOVSXD RDI,EDI
MOV R12,RAX
CALL 0x00101120
MOV byte ptr [RAX],0x0
MOV RBX,RAX
TES... | void * func0(char *param_1,int *param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *__s;
void *pvVar5;
ulong uVar6;
bool bVar7;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
__s = (char *)malloc((long)(iVar2 + 1));
*__s = '\0';
if (0 < iV... |
715 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(const char *str, int *count) {
int len = strlen(str);
char **out = malloc(len * sizeof(char *));
char *current = malloc(len + 1);
current[0] = '\0';
for (int i = 0; i < len; ++i) {
size_t current_len = strlen(current);
current = realloc(current, current_len + 2);
... | #include <assert.h>
#include <string.h>
int issame(char **a, int a_size, char **b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_prefixes(char **prefixes, int count) {
for (int i = 0; i < coun... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
mov %rsi,(%rsp)
callq 10d0 <strlen@plt>
movslq %eax,%rdi
mov %rax,%rbx
mov %rax,0x8(%rsp)
shl $0x3,%rdi
callq 1120 <malloc@plt>
lea 0x1(%rbx),%edi
movslq %edi,%rdi
mov %rax,%r12
... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rsi
call _strlen
movsxd rdi, eax
mov r14, rax
mov [rsp+48h+var_40], rax
shl rdi, 3; size
call _malloc
lea edi, [r14+1]
movsxd rdi, edi; size
mov ... | _QWORD * func0(const char *a1, int *a2)
{
int v2; // r14d
_QWORD *v3; // r12
char *v4; // rax
char *v5; // rbx
long long v6; // r14
long long v7; // rbp
size_t v8; // r15
char v9; // al
size_t v10; // r15
void *v11; // rax
long long v12; // rax
int v14; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RSI
CALL 0x001010d0
MOVSXD RDI,EAX
MOV R14,RAX
MOV qword ptr [RSP + 0x8],RAX
SHL RDI,0x3
CALL 0x00101120
LEA EDI,[R14 + 0x1]
MOVSXD RDI,EDI
MOV R12,RAX
CALL 0x00101120
MOV byte ptr [RAX],0x0
MOV RBX,RAX
TES... | void * func0(char *param_1,int *param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
char *__s;
void *pvVar5;
ulong uVar6;
bool bVar7;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
__s = (char *)malloc((long)(iVar2 + 1));
*__s = '\0';
if (0 < iV... |
716 | func0 | #include <stdio.h>
#include <stdlib.h>
| char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d... | #include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0)... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
movl $0x2,-0x1c(%rbp)
movl $0x1,-0x18(%rbp)
jmp 122f <func0+0x46>
mov -0x18(%rbp),%eax
mov %eax,%ecx
lea 0xdf4(%rip),%rdx
mov $0x0,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 10b0 <snprintf@plt>
add %eax,-0x1c(... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_1C], 2
mov [rbp+var_18], 1
jmp short loc_1232
loc_1208:
mov eax, [rbp+var_18]
mov ecx, eax
lea rax, format; " %d"
mov rdx, rax; format
mov esi, 0; maxlen
mov edi, 0; s
mov eax, 0
c... | char * func0(int a1)
{
int v2; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
char *s; // [rsp+20h] [rbp-10h]
char *v6; // [rsp+28h] [rbp-8h]
v2 = 2;
for ( i = 1; i <= a1; ++i )
v2 += snprintf(0LL, 0LL, " %d", i);
v6 = (char *)malloc(v2);
if ( !v6 )
return ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x1c],0x2
MOV dword ptr [RBP + -0x18],0x1
JMP 0x00101232
LAB_00101208:
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,EAX
LEA RAX,[0x102008]
MOV RDX,RAX
MOV ESI,0x0
MOV EDI,0x0
MOV EAX,0x0
CALL 0x001010b0
ADD dword ptr [RBP ... | char * func0(int param_1)
{
int iVar1;
char *__s;
int local_24;
uint local_20;
uint local_1c;
char *local_18;
local_24 = 2;
for (local_20 = 1; (int)local_20 <= param_1; local_20 = local_20 + 1) {
iVar1 = snprintf((char *)0x0,0," %d",(ulong)local_20);
local_24 = local_24 + iVar1;
}
__s = ... |
717 | func0 | #include <stdio.h>
#include <stdlib.h>
| char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d... | #include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0)... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %edi,%edi
jle 1283 <func0+0xba>
mov %edi,%r12d
lea 0x1(%rdi),%r14d
mov $0x1,%ebx
mov $0x2,%ebp
lea 0xe0f(%rip),%r13
mov %ebx,%r9d
mov %r13,%r8
mov $0xffffffffffffffff,%rcx
mov $0x1,%edx
mov $0x0,%esi
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r14d, edi
test edi, edi
jle loc_1328
lea r13d, [rdi+1]
mov ebx, 1
mov ebp, 2
lea r12, unk_2004
loc_123B:
mov r9d, ebx
mov r8, r12
mov rcx, 0FFFFFFFFFFFFFFFFh
mov edx, 2
... | char * func0(int a1)
{
unsigned int v2; // ebx
unsigned long long v3; // rbp
long long v4; // rbx
unsigned long long v5; // rbx
char *v6; // r13
int v7; // r14d
int v8; // r12d
int v9; // eax
unsigned long long v10; // rcx
unsigned long long v11; // rdx
char *v13; // rdi
char *v14; // [rsp+8h] [... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R14D,EDI
TEST EDI,EDI
JLE 0x00101328
LEA R13D,[RDI + 0x1]
MOV EBX,0x1
MOV EBP,0x2
LEA R12,[0x102004]
LAB_0010123b:
MOV R9D,EBX
MOV R8,R12
MOV RCX,-0x1
MOV EDX,0x2
MOV ESI,0x0
MOV EDI,0x0
MOV EAX,0x0
CALL 0x001010b0
ADD EBP,EAX
ADD EBX... | char * func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int iVar8;
ulong __size;
char *pcVar9;
char *local_40;
size_t sVar7;
if (param_1 < 1) {
local_40 = (char *)malloc(2);
if (local_40 == (char *)0x0) {
return (char *)0x0;
}
... |
718 | func0 | #include <stdio.h>
#include <stdlib.h>
| char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d... | #include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0)... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %edi,%edi
jle 1380 <func0+0xc0>
lea 0x1(%rdi),%r12d
mov $0x1,%ebx
mov $0x2,%ebp
lea 0xd1b(%rip),%r13
nopl 0x0(%rax)
mov %ebx,%r9d
mov %r13,%r8
mov $0xffffffffffffffff,%rcx
xor %esi,%esi
mov $0x1,%edx
xor ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test edi, edi
jle loc_13F0
lea r12d, [rdi+1]
mov ebx, 1
mov ebp, 2
lea r13, unk_2004
nop
loc_1310:
mov r9d, ebx
mov r8, r13
mov rcx, 0FFFFFFFFFFFFFFFFh
xor esi, esi
mov edx,... | char * func0(int a1)
{
int v1; // r12d
unsigned int v2; // ebx
int v3; // ebp
long long v4; // r9
long long v5; // rbx
int v6; // r15d
char *v7; // r14
unsigned long long v8; // rbx
int v9; // eax
unsigned long long v10; // rcx
unsigned long long v11; // rdx
char *v13; // [rsp+8h] [rbp-40h]
i... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x001013f0
LEA R12D,[RDI + 0x1]
MOV EBX,0x1
MOV EBP,0x2
LEA R13,[0x102004]
NOP
LAB_00101310:
MOV R9D,EBX
MOV R8,R13
MOV RCX,-0x1
XOR ESI,ESI
MOV EDX,0x2
XOR EDI,EDI
XOR EAX,EAX
ADD EBX,0x1
CALL 0x001010b0
ADD EBP,EAX
CMP ... | char * func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
size_t sVar6;
ulong uVar7;
int iVar8;
size_t __size;
char *pcVar9;
char *local_40;
if (param_1 < 1) {
local_40 = (char *)malloc(2);
if (local_40 != (char *)0x0) {
sprintf(local_40,"0");
... |
719 | func0 | #include <stdio.h>
#include <stdlib.h>
| char *func0(int n) {
int len = 2;
for (int i = 1; i <= n; ++i) {
len += snprintf(NULL, 0, " %d", i);
}
char *out = malloc(len);
if (!out) {
return NULL;
}
char *ptr = out;
ptr += sprintf(ptr, "0");
for (int i = 1; i <= n; ++i) {
ptr += sprintf(ptr, " %d... | #include <assert.h>
#include <string.h>
int main() {
char *result;
result = func0(0);
assert(strcmp(result, "0") == 0);
free(result);
result = func0(3);
assert(strcmp(result, "0 1 2 3") == 0);
free(result);
result = func0(10);
assert(strcmp(result, "0 1 2 3 4 5 6 7 8 9 10") == 0)... | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
test %edi,%edi
jle 1380 <func0+0xc0>
lea 0x1(%rdi),%r12d
mov $0x1,%ebx
mov $0x2,%ebp
lea 0xd1b(%rip),%r13
nopl 0x0(%rax)
mov %ebx,%r9d
mov %r13,%r8
mov $0xffffffffffffffff,%rcx
xor %esi,%esi
mov $0x1,%edx
xor ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test edi, edi
jle loc_13F0
lea r12d, [rdi+1]
mov ebx, 1
mov ebp, 2
lea r13, unk_2004
nop
loc_1310:
mov r9d, ebx
mov r8, r13
mov rcx, 0FFFFFFFFFFFFFFFFh
xor esi, esi
mov edx,... | char * func0(int a1)
{
int v1; // r12d
unsigned int v2; // ebx
int v3; // ebp
long long v4; // r9
char *v5; // rax
char *v6; // r14
long long v7; // rbx
int v8; // r15d
char *v9; // r14
unsigned long long v10; // rbx
int v11; // eax
unsigned long long v12; // rcx
unsigned long long v13; // rdx... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x001013f0
LEA R12D,[RDI + 0x1]
MOV EBX,0x1
MOV EBP,0x2
LEA R13,[0x102004]
NOP
LAB_00101310:
MOV R9D,EBX
MOV R8,R13
MOV RCX,-0x1
XOR ESI,ESI
MOV EDX,0x2
XOR EDI,EDI
XOR EAX,EAX
ADD EBX,0x1
CALL 0x001010b0
ADD EBP,EAX
CMP ... | char * func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
size_t sVar6;
ulong uVar7;
int iVar8;
size_t __size;
char *pcVar9;
char *local_40;
if (param_1 < 1) {
local_40 = (char *)malloc(2);
if (local_40 != (char *)0x0) {
sprintf(local_40,"0");
... |
720 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
... | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x418(%rbp)
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x414(%rbp)
jmpq 1281 <func0+... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+var_428], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_418], 0
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_414], 0
jmp loc_1281
loc_11FE:
mov ... | long long func0(long long a1)
{
unsigned __int8 v2; // [rsp+17h] [rbp-419h]
unsigned int v3; // [rsp+18h] [rbp-418h]
int i; // [rsp+1Ch] [rbp-414h]
_DWORD v5[258]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v6; // [rsp+428h] [rbp-8h]
v6 = __readfsqword(0x28u);
v3 = 0;
memset(v5, 0, 0x400uLL);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x418],0x0
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x414],0x0
JMP 0x00101281
LAB_001011f... | int func0(long param_1)
{
byte bVar1;
int iVar2;
ushort **ppuVar3;
long lVar4;
int *piVar5;
long in_FS_OFFSET;
int local_420;
int local_41c;
int local_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_420 = 0;
piVar5 = local_418;
for (lVar4 = 0x80; lVar4 != 0; lV... |
721 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
... | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
} | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x410,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
movzbl 0x0(%rbp),%ebx
test %bl,%bl
je 123d <func0+0x94>
callq 10a0 <__ctype_tolo... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 410h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+438h+var_30], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_123D
call ___ctype_tolower_loc
m... | long long func0(unsigned __int8 *a1)
{
unsigned __int8 v1; // bl
const __int32_t *v2; // r12
unsigned __int8 *v3; // rbp
unsigned int v4; // r13d
__int32_t v5; // ebx
_DWORD v7[258]; // [rsp+0h] [rbp-438h] BYREF
unsigned long long v8; // [rsp+408h] [rbp-30h]
v8 = __readfsqword(0x28u);
memset(v7, 0, ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x410
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x0010123d
CALL 0x001010a0
MOV R12,qword ptr [RAX]
ADD RBP,0x1
MOV R13D,0x0
JMP 0x00... | int func0(byte *param_1)
{
uint uVar1;
__int32_t *p_Var2;
__int32_t **pp_Var3;
ushort **ppuVar4;
long lVar5;
byte bVar6;
char cVar7;
byte *pbVar8;
int *piVar9;
int iVar10;
long in_FS_OFFSET;
int aiStack_438 [258];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar9 = aiSta... |
722 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
... | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
} | O2 | c | func0:
endbr64
push %r14
mov $0x80,%ecx
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x410,%rsp
movzbl 0x0(%rbp),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %bl,%bl
je 1370 <func0+0xb0>
callq 10a0 <__ctype_tolo... | func0:
endbr64
push r14
mov ecx, 80h
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 410h
movzx ebx, byte ptr [rbp+0]
mov rax, fs:28h
mov [rsp+438h+var_30], rax
xor eax, eax
mov rdi, rsp
rep stosq
test bl, bl
jz short loc_1370
call ___ctype_tolower_loc
a... | long long func0(unsigned __int8 *a1)
{
long long v1; // rbx
unsigned __int8 *v2; // rbp
unsigned int v3; // r12d
const __int32_t *v4; // r14
__int32_t v5; // ebx
_DWORD v7[258]; // [rsp+0h] [rbp-438h] BYREF
unsigned long long v8; // [rsp+408h] [rbp-30h]
v1 = *a1;
v8 = __readfsqword(0x28u);
memset(... | func0:
ENDBR64
PUSH R14
MOV ECX,0x80
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x410
MOVZX EBX,byte ptr [RBP]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
TEST BL,BL
JZ 0x00101370
CALL 0x001010a0
ADD RBP,0x1
XOR R12D,R12D
MOV R14,qword ptr [RAX]
NOP dwo... | int func0(byte *param_1)
{
byte bVar1;
uint uVar2;
__int32_t *p_Var3;
__int32_t **pp_Var4;
ushort **ppuVar5;
long lVar6;
char cVar7;
int *piVar8;
int iVar9;
long in_FS_OFFSET;
int aiStack_438 [258];
long local_30;
bVar1 = *param_1;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = ai... |
723 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *str) {
int count = 0;
int char_map[256] = {0};
int index;
for (index = 0; str[index]; index++) {
char ch = tolower((unsigned char)str[index]);
if (char_map[ch] == 0 && isalpha((unsigned char)ch)) {
char_map[ch] = 1;
count++;
}
... | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abcde") == 5);
assert(func0("abcdecadeCADE") == 5);
assert(func0("aaaaAAAAaaaa") == 1);
assert(func0("Jerry jERRY JeRRRY") == 4);
return 0;
} | O3 | c | func0:
endbr64
push %r14
mov $0x80,%ecx
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x410,%rsp
movzbl 0x0(%rbp),%ebx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %bl,%bl
je 1370 <func0+0xb0>
callq 10a0 <__ctype_tolo... | func0:
endbr64
push r14
mov ecx, 80h
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 410h
movzx ebx, byte ptr [rbp+0]
mov rax, fs:28h
mov [rsp+438h+var_30], rax
xor eax, eax
mov rdi, rsp
rep stosq
test bl, bl
jz short loc_1370
call ___ctype_tolower_loc
a... | long long func0(unsigned __int8 *a1)
{
long long v1; // rbx
unsigned __int8 *v2; // rbp
unsigned int v3; // r12d
const __int32_t *v4; // r14
__int32_t v5; // ebx
_DWORD v7[258]; // [rsp+0h] [rbp-438h] BYREF
unsigned long long v8; // [rsp+408h] [rbp-30h]
v1 = *a1;
v8 = __readfsqword(0x28u);
memset(... | func0:
ENDBR64
PUSH R14
MOV ECX,0x80
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x410
MOVZX EBX,byte ptr [RBP]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
TEST BL,BL
JZ 0x00101370
CALL 0x001010a0
ADD RBP,0x1
XOR R12D,R12D
MOV R14,qword ptr [RAX]
NOP dwo... | int func0(byte *param_1)
{
byte bVar1;
uint uVar2;
__int32_t *p_Var3;
__int32_t **pp_Var4;
ushort **ppuVar5;
long lVar6;
char cVar7;
int *piVar8;
int iVar9;
long in_FS_OFFSET;
int aiStack_438 [258];
long local_30;
bVar1 = *param_1;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = ai... |
724 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_m... | #include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movq $0x0,-0x28(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
movw $0x0,-0xb(%rbp)
movb $0x0,-0x9(%rbp)
mov -0x48(%rbp),%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+s], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+ptr], 0
mov [rbp+var_38], 0
mov [rbp+var_34], 0
mov word ptr [rbp+s1], 0
mov [rbp+var_9], 0
mov rax, [rbp+s]
mov ... | long long func0(const char *a1, _DWORD *a2)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
int v10; // [rsp+18h] [rbp-38h]
int v11; // [rsp+1Ch] [rbp-34h]
int i; // [rsp+20h] [rbp-30h]
_BYTE v13[12]; // [rsp+24h] [rbp-2Ch]
char *dest; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x34],0x0
MOV word ptr [RBP + -0xb],0x0
MOV byte p... | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
char *__dest;
size_t sVar3;
long in_FS_OFFSET;
int local_40;
int local_3c;
int local_38;
void *local_30;
int2 local_13;
int local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = (void *)0x0;
lo... |
725 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_m... | #include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %rsi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movw $0x0,0x15(%rsp)
movb $0x0,0x17(%rsp)
mov $0xffffffffffffffff,%r13
mov $0x0,%ebx
mov %r13,%rcx
mov... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r12, rdi
mov [rsp+68h+var_50], rsi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov word ptr [rsp+68h+s1], 0
mov [rsp+68h+var_41], 0
call _strlen
mov rbp, rax
lea ... | void * func0(const char *a1, _DWORD *a2)
{
unsigned int v2; // ebp
size_t v3; // rbx
void *v4; // r15
char *v5; // rbx
long long v6; // r15
int v7; // r14d
int v8; // ebp
char v9; // r12
size_t v10; // rax
int v11; // eax
bool v12; // cc
int v13; // eax
int v14; // eax
void *ptr; // [rsp+8h]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R12,RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV word ptr [RSP + 0x25],0x0
MOV byte ptr [RSP + 0x27],0x0
CALL 0x001010f0
MOV RBP,RAX
LEA EBX,[RAX + 0x2]
MOVSXD RBX,EBX
M... | void * func0(char *param_1,int *param_2)
{
char cVar1;
bool bVar2;
int iVar3;
size_t sVar4;
char *__ptr;
size_t sVar5;
char *pcVar6;
int iVar7;
int iVar8;
long in_FS_OFFSET;
void *local_60;
int2 local_43;
int local_41;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_4... |
726 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_m... | #include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rsi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
xor %eax,%eax
movb $0x0,0x27(%rsp)
mov %ax,0x25(%rsp)
callq 10c0 <strlen@plt>
lea 0x2(%rax),%edi
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_50], rsi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
xor eax, eax
mov [rsp+68h+var_41], 0
mov word ptr [rsp+68h+s], ax
call _strlen
lea ... | void * func0(const char *a1, int *a2)
{
size_t v2; // rbp
size_t v3; // rbx
char *v4; // r15
char *v5; // rbx
long long v6; // r12
int v7; // r15d
void *v8; // rbp
size_t v9; // rax
char v10; // r14
long long v11; // rax
long long v12; // rax
long long v13; // rax
size_t v15; // rsi
size_t v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
XOR EAX,EAX
MOV byte ptr [RSP + 0x27],0x0
MOV word ptr [RSP + 0x25],AX
CALL 0x001010c0
LEA EBX,[RAX + 0x2]
MOV RBP,RAX
MOVSX... | void * func0(char *param_1,int *param_2)
{
char cVar1;
size_t sVar2;
char *__ptr;
long lVar3;
void *__ptr_00;
size_t sVar4;
char *pcVar5;
int iVar6;
long in_FS_OFFSET;
int local_5c;
char local_43 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_43[2] = '\0';
local_4... |
727 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int *func0(const char *music_string, int *count) {
int *out = NULL;
int size = 0;
int capacity = 0;
char current[3] = "";
int music_string_length = strlen(music_string) + 1;
char *temp_music_string = malloc(music_string_length + 1);
strcpy(temp_music_string, music_string);
strcat(temp_m... | #include <assert.h>
#include <stdlib.h>
int issame(const int *a, int a_size, const int *b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int *result;
result = func0("", &count);
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rsi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
xor %eax,%eax
movb $0x0,0x27(%rsp)
mov %ax,0x25(%rsp)
callq 10c0 <strlen@plt>
lea 0x2(%rax),%edi
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_50], rsi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
xor eax, eax
mov [rsp+68h+var_41], 0
mov word ptr [rsp+68h+s], ax
call _strlen
lea ... | void * func0(const char *a1, int *a2)
{
size_t v2; // rbp
size_t v3; // rbx
char *v4; // r15
char *v5; // rbx
long long v6; // r12
int v7; // r15d
void *v8; // rbp
size_t v9; // rax
char v10; // r14
long long v11; // rax
long long v12; // rax
long long v13; // rax
size_t v15; // rsi
size_t v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
XOR EAX,EAX
MOV byte ptr [RSP + 0x27],0x0
MOV word ptr [RSP + 0x25],AX
CALL 0x001010c0
LEA EBX,[RAX + 0x2]
MOV RBP,RAX
MOVSX... | void * func0(char *param_1,int *param_2)
{
char cVar1;
size_t sVar2;
char *__ptr;
long lVar3;
void *__ptr_00;
size_t sVar4;
char *pcVar5;
int iVar6;
long in_FS_OFFSET;
int local_5c;
char local_43 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_43[2] = '\0';
local_4... |
728 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x8(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
cmpl $... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+s2], rsi
mov [rbp+var_10], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov rax, [rbp+s2]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
cmp [rbp+var_8], 0
jnz ... | long long func0(const char *a1, const char *a2)
{
unsigned int v3; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
int v5; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
v3 = 0;
v5 = strlen(a1);
v6 = strlen(a2);
if ( !v5 )
return 0LL;
for ( i = 0; i <= v5 - v6; ++i )
{
if ( !strnc... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x... | int func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
int local_18;
int local_14;
local_18 = 0;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
if ((int)sVar2 == 0) {
local_18 = 0;
}
else {
for (local_14 = 0; local_14 <= (int)sVar2 - (int)sVar3; local_14 = l... |
729 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
} | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rdx
mov %edx,%ebp
test %edx,%edx
je 11dc <func0+0x73>
mov %rsi,%r12
mov $0xffffffffffffffff,%rcx
mov %rsi... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r12, rsi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_11E3
mov rdi, r12; s
call _strlen
mov edx, ebp
sub edx, eax
js short loc_11EE
mov rbx, r14
mov edx, edx
lea r14... | long long func0(char *s1, char *s2)
{
unsigned int v2; // ebp
int v3; // eax
const char *v4; // rbx
char *v5; // r14
size_t v6; // r13
v2 = strlen(s1);
if ( v2 )
{
v3 = strlen(s2);
if ( (int)(v2 - v3) < 0 )
{
return 0;
}
else
{
v4 = s1;
v5 = &s1[v2 - v3 + 1];
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R12,RSI
CALL 0x00101080
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001011e3
MOV RDI,R12
CALL 0x00101080
MOV EDX,EBP
SUB EDX,EAX
JS 0x001011ee
MOV RBX,R14
MOV EDX,EDX
LEA R14,[R14 + RDX*0x1 + 0x1]
MOV EBP,0x0
MOVSXD R13,EAX
LAB_001011c6:
MOV RDX,R13
MOV RSI,... | ulong func0(char *param_1,char *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
uint uVar5;
ulong uVar6;
sVar3 = strlen(param_1);
uVar6 = sVar3 & 0xffffffff;
if ((int)sVar3 != 0) {
sVar4 = strlen(param_2);
uVar5 = (int)sVar3 - (int)sVar4;
if ((int)uVar5 < 0) {
uVa... |
730 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
} | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 1080 <strlen@plt>
mov %eax,%r14d
test %eax,%eax
je 12de <func0+0x5e>
mov %r12,%rdi
mov %rax,%r13
callq 1080 <strlen@plt>
sub %eax,%r13d
js 12f0 <func0+0x70>
movslq %r13d,%r13
movslq... | func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_12DD
mov rdi, r13; s
mov r14, rax
call _strlen
sub r14d, eax
js short loc_12F0
movsxd r14, r14d
movsxd r12, eax
xor e... | long long func0(char *s1, char *s2)
{
const char *v2; // rbx
unsigned int v3; // eax
unsigned int v4; // ebp
unsigned int v5; // r14d
int v6; // eax
int v7; // r14d
size_t v8; // r12
char *v9; // r14
v2 = s1;
v3 = strlen(s1);
v4 = v3;
if ( v3 )
{
v5 = v3;
v6 = strlen(s2);
v7 = v5... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001012dd
MOV RDI,R13
MOV R14,RAX
CALL 0x00101080
SUB R14D,EAX
JS 0x001012f0
MOVSXD R14,R14D
MOVSXD R12,EAX
XOR EBP,EBP
LEA R14,[RBX + R14*0x1 + 0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_001012c0... | ulong func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
size_t sVar3;
ulong uVar4;
int iVar5;
sVar2 = strlen(param_1);
uVar4 = sVar2 & 0xffffffff;
if ((int)sVar2 != 0) {
sVar3 = strlen(param_2);
iVar5 = (int)sVar2 - (int)sVar3;
if (iVar5 < 0) {
uVar4 = 0;
}
e... |
731 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str, const char *substring) {
int out = 0;
int str_len = strlen(str);
int sub_len = strlen(substring);
if (str_len == 0) return 0;
for (int i = 0; i <= str_len - sub_len; i++) {
if (strncmp(&str[i], substring, sub_len) == 0)
out++;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("", "x") == 0);
assert(func0("xyxyxyx", "x") == 4);
assert(func0("cacacacac", "cac") == 4);
assert(func0("john doe", "john") == 1);
return 0;
} | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 1080 <strlen@plt>
mov %eax,%r14d
test %eax,%eax
je 12de <func0+0x5e>
mov %r12,%rdi
mov %rax,%r13
callq 1080 <strlen@plt>
sub %eax,%r13d
js 12f0 <func0+0x70>
movslq %r13d,%r13
movslq... | func0:
endbr64
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_12DD
mov rdi, r13; s
mov r14, rax
call _strlen
sub r14d, eax
js short loc_12F0
movsxd r14, r14d
movsxd r12, eax
xor e... | long long func0(char *s1, char *s2)
{
const char *v2; // rbx
unsigned int v3; // eax
unsigned int v4; // ebp
unsigned int v5; // r14d
int v6; // eax
int v7; // r14d
size_t v8; // r12
char *v9; // r14
v2 = s1;
v3 = strlen(s1);
v4 = v3;
if ( v3 )
{
v5 = v3;
v6 = strlen(s2);
v7 = v5... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001012dd
MOV RDI,R13
MOV R14,RAX
CALL 0x00101080
SUB R14D,EAX
JS 0x001012f0
MOVSXD R14,R14D
MOVSXD R12,EAX
XOR EBP,EBP
LEA R14,[RBX + R14*0x1 + 0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_001012c0... | ulong func0(char *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
size_t sVar3;
ulong uVar4;
int iVar5;
sVar2 = strlen(param_1);
uVar4 = sVar2 & 0xffffffff;
if ((int)sVar2 != 0) {
sVar3 = strlen(param_2);
iVar5 = (int)sVar2 - (int)sVar3;
if (iVar5 < 0) {
uVar4 = 0;
}
e... |
732 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = ... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xb0,%rsp
mov %rdi,-0xa8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movq $0x0,-0x90(%rbp)
movq $0x0,-0x88(%rbp)
movq $0x0,-0x80(%rbp)
movq $0x0,-0x78(%rbp)
movq $0x0,-0x70(%rbp)
lea 0xe25(%rip),%rax
mov %rax,-0x60(%rbp)
lea ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_A8], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rbp+var_90], xmm0
movaps [rbp+var_80], xmm0
movq [rbp+var_70], xmm0
lea rax, aZero; "zero"
mov [rbp+s2], rax
lea rax, aOne; "o... | char * func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v3; // [rsp+8h] [rbp-A8h]
int v4; // [rsp+10h] [rbp-A0h]
int i; // [rsp+14h] [rbp-9Ch]
int k; // [rsp+14h] [rbp-9Ch]
int j; // [rsp+18h] [rbp-98h]
int m; // [rsp+18h] [rbp-98h]
int n; // [rsp+1Ch] [rbp-94h]
_OWORD v10[2]; // [rsp+20h] [rbp-90h] BYREF
l... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0xa8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM0
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVQ qword ptr [RBP + -0x70],XMM0
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x... | int1 * func0(char *param_1)
{
char cVar1;
int iVar2;
long in_FS_OFFSET;
int local_a8;
int local_a4;
int local_a0;
int local_9c;
int local_98 [16];
int local_88 [16];
int8 local_78;
char *local_68 [10];
char local_16 [6];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_9... |
733 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = ... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
lea 0xe20(%rip),%rax
mov %rax,0x30(%rs... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rsp+0C8h+var_C8], xmm0
movaps [rsp+0C8h+var_B8], xmm0
mov [rsp+0C8h+var_A8], 0
lea rax, aZero; "zero"
mov [... | char * func0(char *a1)
{
char *v1; // rbp
int v2; // eax
long long v3; // r12
char v4; // dl
long long v5; // rax
long long v6; // rbx
long long v7; // r12
int v8; // r8d
int j; // ecx
long long v10; // rax
char v11; // dl
int i; // r9d
int v13; // r11d
char *v14; // rbx
char v15; // r10
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x30],RAX
LEA ... | int1 * func0(byte *param_1)
{
char cVar1;
char cVar2;
char *pcVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int iVar7;
byte bVar8;
long lVar9;
ulong uVar10;
int iVar11;
long lVar12;
long in_FS_OFFSET;
int local_c8 [16];
int local_b8 [16];
int8 local_a8;
char *local_98 [10];
byte loca... |
734 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = ... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
... | O2 | c | func0:
endbr64
push %r15
pxor %xmm0,%xmm0
xor %r10d,%r10d
push %r14
lea 0xcfe(%rip),%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
movzbl (%rdi),%edx
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0xcd9(%rip),%rax
mov %r14,0x40(%rsp)
mov %rax,0x48(%rsp)
lea... | func0:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
lea rbx, aZero; "zero"
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
lea rax, aOne; "one"
movaps [rsp+0C8h+var_C8], xmm0
movq xmm1, rax
movaps [rsp+0C8h+var_B8], ... | char * func0(char *a1)
{
char v1; // al
char *v2; // r12
long long v3; // rbx
int v4; // edx
long long v5; // rbp
long long v6; // rbp
int v7; // esi
int v8; // r10d
char *v9; // r11
int v10; // r8d
char v11; // r9
int v12; // ecx
char v13; // dl
long long v14; // rax
char *v15; // rsi
_... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA RBX,[0x102004]
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RAX,[0x102009]
MOVAPS xmmword ptr [RSP],XMM0
MOVQ XMM1,RAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVQ XMM0,RBX
LEA RAX,[0x102011]
... | int1 * func0(byte *param_1)
{
char cVar1;
int iVar2;
char *pcVar3;
byte bVar4;
int iVar5;
long lVar6;
int iVar7;
char cVar8;
long lVar9;
long lVar10;
int iVar11;
long in_FS_OFFSET;
int local_c8 [16];
int local_b8 [16];
int8 local_a8;
char *local_98 [10];
byte local_47 [7];
long loca... |
735 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* numbers) {
int count[10] = {0};
const char* numto[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
int index, i, j, k;
static char out[1000];
char current[6];
index = 0;
if (*numbers) {
do {
for (i = ... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(""), "") == 0);
assert(strcmp(func0("three"), "three") == 0);
assert(strcmp(func0("three five nine"), "three five nine") == 0);
assert(strcmp(func0("five zero four seven nine eight"), "zero four five seven eight nine") == 0);
... | O3 | c | func0:
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
lea 0xcfb(%rip),%rbx
sub $0xd8,%rsp
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
lea 0xcdf(%rip),%rax
movaps %xmm0,0x40(%rsp)
movq %rax,%xmm1
movaps %xmm0,0x50(%rsp)
movq %rbx,%xmm0
lea... | func0:
endbr64
push r15
pxor xmm0, xmm0
lea r15, aSix; "six"
push r14
lea r14, aTwo; "two"
push r13
lea r13, aZero; "zero"
push r12
push rbp
push rbx
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
movaps [rsp+0C8h+var_C8], xmm0
movzx eax, byte pt... | char * func0(char *a1)
{
char v1; // al
char *i; // rbp
long long v3; // r12
long long v4; // rax
long long v5; // r12
int v6; // eax
long long v7; // rbp
int v8; // esi
int v9; // r10d
char *v10; // r11
int v11; // r8d
char v12; // r9
int v13; // ecx
char v14; // dl
long long v15; // rax
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
LEA R15,[0x102021]
PUSH R14
LEA R14,[0x10200d]
PUSH R13
LEA R13,[0x102004]
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
MOVZX EAX,byte ptr [RDI]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV... | int1 * func0(byte *param_1)
{
byte bVar1;
byte bVar2;
byte bVar3;
char cVar4;
int iVar5;
char *pcVar6;
int iVar7;
int iVar8;
long lVar9;
char cVar10;
long lVar11;
int iVar12;
long lVar13;
long in_FS_OFFSET;
int local_c8 [16];
int local_b8 [16];
int8 local_a8;
int *local_98 [10];
b... |
736 | func0 | #include <stdio.h>
#include <math.h>
#include <float.h>
| void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
... | #include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
fl... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
movss 0xf64(%rip),%xmm0
movss %xmm0,-0x14(%rbp)
mov -0x28(%rbp),%rax
movss (%rax),%xmm0
mov -0x38(%rbp),%rax
movss %xmm0,(%rax)
mov -0x38(%rbp),%rax
lea 0x4(%rax),%rdx
mov -0x28(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
movss xmm0, cs:dword_20C8
movss [rbp+var_14], xmm0
mov rax, [rbp+var_28]
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_38]
movss dword ptr [rax], xmm0
mov rax, [rbp+var_38]
lea ... | _DWORD * func0(float *a1, int a2, float *a3)
{
_DWORD *result; // rax
float v4; // [rsp+24h] [rbp-14h]
int i; // [rsp+28h] [rbp-10h]
int j; // [rsp+2Ch] [rbp-Ch]
float v7; // [rsp+30h] [rbp-8h]
float v8; // [rsp+34h] [rbp-4h]
v4 = 3.4028235e38;
*a3 = *a1;
a3[1] = a1[1];
for ( i = 0; i < a2; ++i )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOVSS XMM0,dword ptr [0x001020c8]
MOVSS dword ptr [RBP + -0x14],XMM0
MOV RAX,qword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOVSS dword ptr [RAX],XMM0
M... | void func0(float *param_1,int param_2,float *param_3)
{
float fVar1;
float local_1c;
int local_18;
int local_14;
local_1c = DAT_001020c8;
*param_3 = *param_1;
param_3[1] = param_1[1];
for (local_18 = 0; local_14 = local_18, local_18 < param_2; local_18 = local_18 + 1) {
while (local_14 = local_1... |
737 | func0 | #include <stdio.h>
#include <math.h>
#include <float.h>
| void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
... | #include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
fl... | O1 | c | func0:
endbr64
movss (%rdi),%xmm0
movss %xmm0,(%rdx)
movss 0x4(%rdi),%xmm0
movss %xmm0,0x4(%rdx)
test %esi,%esi
jle 11e7 <func0+0x7e>
mov %rdi,%rcx
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
movss 0xf44(%rip),%xmm2
movss 0xf6c(%rip),%xmm3
jmp 11dd <func0+0x74>
add $0x1,%rax
cmp %eax,... | func0:
endbr64
mov rcx, rdx
movss xmm0, dword ptr [rdi]
movss dword ptr [rdx], xmm0
movss xmm0, dword ptr [rdi+4]
movss dword ptr [rdx+4], xmm0
test esi, esi
jle loc_120C
lea rdx, [rdi+4]
lea r11d, [rsi-1]
mov r10d, esi
movsxd r9, esi
mov r8d, 1
movss xmm2, cs:dword_2004
add rd... | void func0(_DWORD *a1, int a2, float *a3)
{
float *v4; // rdx
long long v5; // r8
float v6; // xmm2_4
_DWORD *v7; // rdi
float *v8; // rax
float v9; // xmm0_4
float v10; // xmm0_4
float v11; // xmm1_4
*a3 = *(float *)a1;
a3[1] = *((float *)a1 + 1);
if ( a2 > 0 )
{
v4 = (float *)(a1 + 1);
... | func0:
ENDBR64
MOV RCX,RDX
MOVSS XMM0,dword ptr [RDI]
MOVSS dword ptr [RDX],XMM0
MOVSS XMM0,dword ptr [RDI + 0x4]
MOVSS dword ptr [RDX + 0x4],XMM0
TEST ESI,ESI
JLE 0x0010120c
LEA RDX,[RDI + 0x4]
LEA R11D,[RSI + -0x1]
MOV R10D,ESI
MOVSXD R9,ESI
MOV R8D,0x1
MOVSS XMM2,dword ptr [0x00102004]
ADD RDI,0x8
MOVSS XMM3,dword p... | void func0(float *param_1,uint param_2,float *param_3)
{
uint uVar1;
float *pfVar2;
float *pfVar3;
ulong uVar4;
bool bVar5;
float fVar6;
float fVar7;
*param_3 = *param_1;
param_3[1] = param_1[1];
uVar1 = DAT_001020e0;
if (0 < (int)param_2) {
pfVar3 = param_1 + 1;
uVar4 = 1;
fVar7 =... |
738 | func0 | #include <stdio.h>
#include <math.h>
#include <float.h>
| void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
... | #include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
fl... | O2 | c | func0:
endbr64
movss (%rdi),%xmm0
movss %xmm0,(%rdx)
movss 0x4(%rdi),%xmm1
movss %xmm1,0x4(%rdx)
test %esi,%esi
jle 150b <func0+0x8b>
lea -0x1(%rsi),%r9d
mov $0x1,%r8d
mov %rdi,%rcx
movss 0xc31(%rip),%xmm2
add $0x1,%r9
movss 0xc55(%rip),%xmm3
cmp %r8,%r9
je 1502 <func0+0x82>
mov %r8,%ra... | func0:
endbr64
movss xmm0, dword ptr [rdi]
movss dword ptr [rdx], xmm0
movss xmm1, dword ptr [rdi+4]
movss dword ptr [rdx+4], xmm1
test esi, esi
jle short loc_146B
cmp esi, 1
jz short loc_1462
movss xmm2, cs:dword_2004
mov rcx, rdi
mov r9d, esi
mov r8d, 1
movss xmm3, cs:dword_20D... | void func0(float *a1, int a2, float *a3)
{
float v3; // xmm0_4
float v4; // xmm1_4
float v5; // xmm2_4
float *v6; // rcx
long long i; // r8
long long v8; // rax
float v9; // xmm0_4
v3 = *a1;
*a3 = *a1;
v4 = a1[1];
a3[1] = v4;
if ( a2 > 0 )
{
if ( a2 != 1 )
{
v5 = 3.4028235e38;
... | func0:
ENDBR64
MOVSS XMM0,dword ptr [RDI]
MOVSS dword ptr [RDX],XMM0
MOVSS XMM1,dword ptr [RDI + 0x4]
MOVSS dword ptr [RDX + 0x4],XMM1
TEST ESI,ESI
JLE 0x0010146b
CMP ESI,0x1
JZ 0x00101462
MOVSS XMM2,dword ptr [0x00102004]
MOV RCX,RDI
MOV R9D,ESI
MOV R8D,0x1
MOVSS XMM3,dword ptr [0x001020d0]
NOP dword ptr [RAX + RAX*0x... | void func0(float *param_1,uint param_2,float *param_3)
{
uint uVar1;
float *pfVar2;
ulong uVar3;
ulong uVar4;
float fVar5;
float fVar6;
fVar6 = *param_1;
*param_3 = fVar6;
fVar5 = param_1[1];
param_3[1] = fVar5;
uVar1 = DAT_001020d0;
if (0 < (int)param_2) {
if (param_2 != 1) {
uVar... |
739 | func0 | #include <stdio.h>
#include <math.h>
#include <float.h>
| void func0(float numbers[], int size, float out[2]) {
float min_diff = FLT_MAX;
int i, j;
out[0] = numbers[0];
out[1] = numbers[1];
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
float diff = fabs(numbers[i] - numbers[j]);
if (diff < min_diff) {
... | #include <assert.h>
#include <math.h>
int issame(float a[], float b[], int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float result[2];
float test1[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
fl... | O3 | c | func0:
endbr64
movss (%rdi),%xmm0
movss %xmm0,(%rdx)
movss 0x4(%rdi),%xmm1
movss %xmm1,0x4(%rdx)
test %esi,%esi
jle 14cb <func0+0x8b>
cmp $0x1,%esi
je 14c2 <func0+0x82>
lea -0x2(%rsi),%r9d
mov %rdi,%rcx
movss 0xc72(%rip),%xmm2
mov $0x1,%r8d
add $0x2,%r9
movss 0xc90(%rip),%xmm3
mov %r8,%... | func0:
endbr64
movss xmm0, dword ptr [rdi]
movss dword ptr [rdx], xmm0
movss xmm1, dword ptr [rdi+4]
movss dword ptr [rdx+4], xmm1
test esi, esi
jle short loc_14CB
cmp esi, 1
jz short loc_14C2
movss xmm2, cs:dword_2004
mov rcx, rdi
mov r9d, esi
mov r8d, 1
movss xmm3, cs:dword_20D... | void func0(float *a1, int a2, float *a3)
{
float v3; // xmm0_4
float v4; // xmm1_4
float v5; // xmm2_4
float *v6; // rcx
long long i; // r8
long long v8; // rax
float v9; // xmm0_4
v3 = *a1;
*a3 = *a1;
v4 = a1[1];
a3[1] = v4;
if ( a2 > 0 )
{
if ( a2 != 1 )
{
v5 = 3.4028235e38;
... | func0:
ENDBR64
MOVSS XMM0,dword ptr [RDI]
MOVSS dword ptr [RDX],XMM0
MOVSS XMM1,dword ptr [RDI + 0x4]
MOVSS dword ptr [RDX + 0x4],XMM1
TEST ESI,ESI
JLE 0x001014cb
CMP ESI,0x1
JZ 0x001014c2
MOVSS XMM2,dword ptr [0x00102004]
MOV RCX,RDI
MOV R9D,ESI
MOV R8D,0x1
MOVSS XMM3,dword ptr [0x001020d0]
NOP dword ptr [RAX + RAX*0x... | void func0(float *param_1,uint param_2,float *param_3)
{
uint uVar1;
float *pfVar2;
ulong uVar3;
ulong uVar4;
float fVar5;
float fVar6;
fVar6 = *param_1;
*param_3 = fVar6;
fVar5 = param_1[1];
param_3[1] = fVar5;
uVar1 = DAT_001020d0;
if (0 < (int)param_2) {
if (param_2 != 1) {
uVar... |
740 | func0 | #include <stdio.h>
#include <math.h>
| void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
... | #include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
movss (%rax),%xmm0
movss %xmm0,-0x10(%rbp)
mov -0x18(%rbp),%rax
movss (%rax),%xmm0
movss %xmm0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 1219 <func0+0xb0>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%ra... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax]
movss [rbp+var_10], xmm0
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax]
movss [rbp+var_C], xmm0
mov [rbp+var_8], 1
jmp short loc_1219
loc_119B:
mov... | long long func0(float *a1, int a2)
{
long long result; // rax
float v3; // [rsp+Ch] [rbp-10h]
float v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = *a1;
v4 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v3 > a1[i] )
v3 = a1[i];
if ( a1[i] > v4 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0x10],XMM0
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0xc],XMM0
MOV dword ptr [RBP + -0x8],0x1
JM... | void func0(float *param_1,int param_2)
{
float local_18;
float local_14;
int local_10;
int local_c;
local_18 = *param_1;
local_14 = *param_1;
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
if (param_1[local_10] < local_18) {
local_18 = param_1[local_10];
}
if (loca... |
741 | func0 | #include <stdio.h>
#include <math.h>
| void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
... | #include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert... | O1 | c | func0:
endbr64
movss (%rdi),%xmm1
cmp $0x1,%esi
jle 11c7 <func0+0x5e>
lea 0x4(%rdi),%rax
lea -0x2(%rsi),%edx
lea 0x8(%rdi,%rdx,4),%rdx
movaps %xmm1,%xmm0
movss (%rax),%xmm2
movaps %xmm2,%xmm3
minss %xmm1,%xmm3
movaps %xmm3,%xmm1
maxss %xmm0,%xmm2
movaps %xmm2,%xmm0
add $0x4,%rax
cmp %rdx,%rax
j... | func0:
endbr64
movss xmm1, dword ptr [rdi]
cmp esi, 1
jle short loc_11CE
lea rax, [rdi+4]
lea edx, [rsi-2]
lea rdx, [rdi+rdx*4+8]
movaps xmm0, xmm1
loc_1185:
movss xmm2, dword ptr [rax]
movaps xmm3, xmm2
minss xmm3, xmm1
movaps xmm1, xmm3
maxss xmm2, xmm0
movaps xmm0, xmm2
add rax, 4... | void func0(float *a1, int a2)
{
float v2; // xmm1_4
float *v3; // rax
float v4; // xmm0_4
float *v5; // rax
v2 = *a1;
if ( a2 <= 1 )
{
if ( a2 <= 0 )
return;
v4 = *a1;
}
else
{
v3 = a1 + 1;
v4 = *a1;
do
{
v2 = fminf(*v3, v2);
v4 = fmaxf(*v3++, v4);
}
... | func0:
ENDBR64
MOVSS XMM1,dword ptr [RDI]
CMP ESI,0x1
JLE 0x001011ce
LEA RAX,[RDI + 0x4]
LEA EDX,[RSI + -0x2]
LEA RDX,[RDI + RDX*0x4 + 0x8]
MOVAPS XMM0,XMM1
LAB_00101185:
MOVSS XMM2,dword ptr [RAX]
MOVAPS XMM3,XMM2
MINSS XMM3,XMM1
MOVAPS XMM1,XMM3
MAXSS XMM2,XMM0
MOVAPS XMM0,XMM2
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101185
... | void func0(float *param_1,int param_2)
{
float fVar1;
float fVar2;
float *pfVar3;
float fVar4;
float fVar5;
fVar4 = *param_1;
fVar5 = fVar4;
if (param_2 < 2) {
if (param_2 < 1) {
return;
}
}
else {
pfVar3 = param_1 + 1;
do {
fVar1 = *pfVar3;
fVar2 = fVar1;
... |
742 | func0 | #include <stdio.h>
#include <math.h>
| void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
... | #include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert... | O2 | c | func0:
endbr64
movss (%rdi),%xmm0
cmp $0x1,%esi
jle 1540 <func0+0x70>
lea -0x2(%rsi),%edx
lea 0x4(%rdi),%rax
movaps %xmm0,%xmm1
lea 0x8(%rdi,%rdx,4),%rdx
movaps %xmm0,%xmm2
movss (%rax),%xmm3
add $0x4,%rax
movaps %xmm3,%xmm4
maxss %xmm1,%xmm3
minss %xmm2,%xmm4
movaps %xmm3,%xmm1
movaps %xmm4,%xmm2... | func0:
endbr64
movss xmm1, dword ptr [rdi]
cmp esi, 1
jle short loc_1450
lea edx, [rsi-2]
lea rax, [rdi+4]
movaps xmm0, xmm1
lea rdx, [rdi+rdx*4+8]
nop dword ptr [rax+00h]
loc_1400:
movss xmm2, dword ptr [rax]
add rax, 4
movaps xmm3, xmm2
maxss xmm2, xmm0
minss xmm3, xmm1
movaps x... | void func0(float *a1, int a2)
{
float v2; // xmm1_4
float *v3; // rax
float v4; // xmm0_4
float v5; // xmm2_4
float v6; // xmm2_4
float *v7; // rax
float v8; // xmm0_4
v2 = *a1;
if ( a2 <= 1 )
{
if ( a2 != 1 )
return;
v4 = *a1;
}
else
{
v3 = a1 + 1;
v4 = *a1;
do
... | func0:
ENDBR64
MOVSS XMM1,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101450
LEA EDX,[RSI + -0x2]
LEA RAX,[RDI + 0x4]
MOVAPS XMM0,XMM1
LEA RDX,[RDI + RDX*0x4 + 0x8]
NOP dword ptr [RAX]
LAB_00101400:
MOVSS XMM2,dword ptr [RAX]
ADD RAX,0x4
MOVAPS XMM3,XMM2
MAXSS XMM2,XMM0
MINSS XMM3,XMM1
MOVAPS XMM0,XMM2
MOVAPS XMM1,XMM3
CMP RAX... | void func0(float *param_1,int param_2)
{
float fVar1;
float fVar2;
float *pfVar3;
float *pfVar4;
float fVar5;
float fVar6;
fVar5 = *param_1;
fVar6 = fVar5;
if (param_2 < 2) {
if (param_2 != 1) {
return;
}
}
else {
pfVar3 = param_1 + 1;
do {
fVar1 = *pfVar3;
pf... |
743 | func0 | #include <stdio.h>
#include <math.h>
| void func0(float *numbers, int size) {
float min = numbers[0], max = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] < min) min = numbers[i];
if (numbers[i] > max) max = numbers[i];
}
for (int i = 0; i < size; i++) {
numbers[i] = (numbers[i] - min) / (max - min);
... | #include <assert.h>
int issame(float *a, float *b, int size) {
const float EPSILON = 1e-4;
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > EPSILON) return 0;
}
return 1;
}
int main() {
float test1[] = {2.0, 49.9};
float expected1[] = {0.0, 1.0};
func0(test1, 2);
assert... | O3 | c | func0:
endbr64
movss (%rdi),%xmm1
cmp $0x1,%esi
jle 1650 <func0+0xf0>
lea -0x2(%rsi),%edx
lea 0x4(%rdi),%rax
movaps %xmm1,%xmm2
lea 0x8(%rdi,%rdx,4),%rdx
movss (%rax),%xmm0
add $0x4,%rax
movaps %xmm0,%xmm5
maxss %xmm2,%xmm0
minss %xmm1,%xmm5
movaps %xmm0,%xmm2
movaps %xmm5,%xmm1
cmp %rdx,%rax
j... | func0:
endbr64
movss xmm1, dword ptr [rdi]
mov rcx, rdi
cmp esi, 1
jle loc_15D8
lea rax, [rdi+4]
mov rdx, rdi
lea edi, [rsi-2]
mov r8d, esi
lea rdi, [rcx+rdi*4+8]
movaps xmm0, xmm1
nop dword ptr [rax+00000000h]
loc_1510:
movss xmm2, dword ptr [rax]
add rax, 4
movaps xmm5, x... | void func0(float *a1, int a2)
{
float v2; // xmm1_4
unsigned int *v4; // rax
__m128 *v5; // rdx
int v6; // r8d
long long v7; // rdi
float v8; // xmm0_4
__m128 v9; // xmm2
__m128 v10; // xmm5
__m128 v11; // xmm4
__m128 v12; // xmm3
__m128 v13; // xmm0
signed int v14; // eax
long long v15; // r... | func0:
ENDBR64
MOVSS XMM1,dword ptr [RDI]
MOV RCX,RDI
CMP ESI,0x1
JLE 0x001015d8
LEA RAX,[RDI + 0x4]
MOV RDX,RDI
LEA EDI,[RSI + -0x2]
MOV R8D,ESI
LEA RDI,[RCX + RDI*0x4 + 0x8]
MOVAPS XMM0,XMM1
NOP dword ptr [RAX]
LAB_00101510:
MOVSS XMM2,dword ptr [RAX]
ADD RAX,0x4
MOVAPS XMM5,XMM2
MAXSS XMM2,XMM0
MINSS XMM5,XMM1
MOVAP... | void func0(int (*param_1) [16],uint param_2)
{
float fVar1;
int8 uVar2;
int auVar3 [16];
float fVar4;
uint uVar5;
float *pfVar6;
int (*pauVar7) [16];
int (*pauVar8) [16];
ulong uVar9;
int auVar10 [16];
int auVar11 [16];
int auVar12 [16];
float fVar13;
float fVar14;
fVar13 = *(float *)*... |
744 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
//... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x20(%rbp)
mov -0x28(%rbp),%rax
mov %rax,-0x10(%rbp)
jmpq 12d9 <func0+0x110>
addq $0x1,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_20], 0
mov rax, [rbp+var_28]
mov [rbp+nptr], rax
jmp loc_12D9
loc_1200:
add [rbp+nptr], 1
loc_1205:
mov rax,... | _DWORD * func0(char *a1, _DWORD *a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-20h]
int v5; // [rsp+14h] [rbp-1Ch]
char *endptr; // [rsp+18h] [rbp-18h] BYREF
char *nptr; // [rsp+20h] [rbp-10h]
unsigned long long v8; // [rsp+28h] [rbp-8h]
v8 = __readfsqword(0x28u);
v4 = 0;
for ( nptr = a1; *nptr; npt... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001012d9
LAB_00101200:
ADD qword p... | int1 * func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
long lVar2;
long in_FS_OFFSET;
int local_28;
char *local_20;
char *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = 0;
local_18 = param_1;
while (*local_18 != '\0') {
while (((*local_18 != '\0' && (p... |
745 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
//... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,%r15
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movzbl (%rdi),%ebx
mov $0x0,%r13d
test %bl,%bl
je 1277 <func0+0xae>
mov %rdi,%rbp
callq 10d0 <__ctype_b_loc@plt>
mov %rax,... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r14, rsi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov r12d, 0
lea r13, out_1
cmp byte ptr [rdi], 0
jnz short loc_123F
jmp short loc_126B
loc_1203:
mov rs... | _DWORD * func0(char *nptr, _DWORD *a2)
{
char *v2; // rbp
int v3; // r12d
int v4; // eax
char v5; // bl
const unsigned __int16 *v6; // rdx
char *v8; // rax
char v9; // dl
char *v10[7]; // [rsp+0h] [rbp-38h] BYREF
v2 = nptr;
v10[1] = (char *)__readfsqword(0x28u);
v3 = 0;
if ( *nptr )
{
do
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV R12D,0x0
LEA R13,[0x104040]
CMP byte ptr [RDI],0x0
JNZ 0x0010123f
JMP 0x0010126b
LAB_00101203:
MOV RSI,RSP
MOV EDX,0xa
MOV RDI,RBP
CALL 0x001010c0
MO... | int4 * func0(char *param_1,int *param_2)
{
long lVar1;
ushort **ppuVar2;
char cVar3;
int iVar4;
long in_FS_OFFSET;
char *local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar4 = 0;
cVar3 = *param_1;
do {
if ((cVar3 == '\0') || (cVar3 = *param_1, cVar3 == '\0')) {
LAB_001... |
746 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
//... | O2 | c | func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movzbl (%rdi),%ebx
mov %rsi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
test %bl,%bl
je 1458 <func0+0xe8>
mov %rdi,%rbp
xor %r15d,%r15d
lea 0x10(%rsp),... | func0:
endbr64
push r15
mov r15, rsi
push r14
lea r14, out_1
push r13
push r12
xor r12d, r12d
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov r13, rsp
test bl, bl
jz short loc... | _DWORD * func0(char *nptr, _DWORD *a2)
{
int v2; // r12d
const char *v3; // rbp
char v4; // bl
const unsigned __int16 *v5; // rdx
int v6; // eax
char *v7; // rdx
long long v8; // rcx
char *v10; // rax
char *v11[9]; // [rsp+0h] [rbp-48h] BYREF
v2 = 0;
v3 = nptr;
v4 = *nptr;
v11[1] = (char *)__... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[0x104040]
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV R13,RSP
TEST BL,BL
JZ 0x00101420
NOP dword ptr [RAX]
LAB_001013b0:
CALL 0x001010d0... | int4 * func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
long lVar2;
long lVar3;
char cVar4;
int iVar5;
long in_FS_OFFSET;
char *local_48;
long local_40;
iVar5 = 0;
cVar4 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
do {
if (cVar4 == '\0') {
LAB_00101420:
*param_2 = i... |
747 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int *func0(const char *values, int *size) {
static int out[256];
int count = 0;
const char *start = values;
char *end;
while (*start) {
while (*start && !isdigit(*start) && *start != '-') {
start++;
}
if (!*start) {
break;
}
int val = (... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
//... | O3 | c | func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movzbl (%rdi),%ebx
mov %rsi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
test %bl,%bl
je 1458 <func0+0xe8>
mov %rdi,%rbp
xor %r15d,%r15d
lea 0x10(%rsp),... | func0:
endbr64
push r15
mov r15, rsi
push r14
lea r14, out_1
push r13
push r12
xor r12d, r12d
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov r13, rsp
test bl, bl
jz short loc... | _DWORD * func0(char *nptr, _DWORD *a2)
{
int v2; // r12d
const char *v3; // rbp
char v4; // bl
const unsigned __int16 *v5; // rdx
int v6; // eax
char *v7; // rdx
long long v8; // rcx
char *v10; // rax
char *v11[9]; // [rsp+0h] [rbp-48h] BYREF
v2 = 0;
v3 = nptr;
v4 = *nptr;
v11[1] = (char *)__... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[0x104040]
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV R13,RSP
TEST BL,BL
JZ 0x00101420
NOP dword ptr [RAX]
LAB_001013b0:
CALL 0x001010d0... | int4 * func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
long lVar2;
long lVar3;
char cVar4;
int iVar5;
long in_FS_OFFSET;
char *local_48;
long local_40;
iVar5 = 0;
cVar4 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
do {
if (cVar4 == '\0') {
LAB_00101420:
*param_2 = i... |
748 | func0 | #include <stdio.h>
| int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1162 <func0+0x19>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 115e <func0+0x15>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_1162
loc_115E:
add [rbp+var_4], 1
loc_1162:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_115E
mov ea... | long long func0(long long a1)
{
unsigned int i; // [rsp+14h] [rbp-4h]
for ( i = 0; *(_BYTE *)((int)i + a1); ++i )
;
return i;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101162
LAB_0010115e:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101162:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010115e
MOV EA... | int func0(long param_1)
{
int4 local_c;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
}
return local_c;
} |
749 | func0 | #include <stdio.h>
| int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
} | O1 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 1167 <func0+0x1e>
mov $0x1,%eax
mov %eax,%edx
add $0x1,%rax
cmpb $0x0,-0x1(%rdi,%rax,1)
jne 1157 <func0+0xe>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1164 <func0+0x1b>
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1166
mov edx, 1
loc_1157:
mov rax, rdx
add rdx, 1
cmp byte ptr [rdi+rdx-1], 0
jnz short loc_1157
retn
loc_1166:
mov eax, 0
retn | long long func0(_BYTE *a1)
{
long long v1; // rdx
long long result; // rax
if ( !*a1 )
return 0LL;
v1 = 1LL;
do
result = v1++;
while ( a1[v1 - 1] );
return result;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101166
MOV EDX,0x1
LAB_00101157:
MOV RAX,RDX
ADD RDX,0x1
CMP byte ptr [RDI + RDX*0x1 + -0x1],0x0
JNZ 0x00101157
RET
LAB_00101166:
MOV EAX,0x0
RET | long func0(char *param_1)
{
char *pcVar1;
long lVar2;
long lVar3;
if (*param_1 != '\0') {
lVar3 = 1;
do {
lVar2 = lVar3;
pcVar1 = param_1 + lVar3;
lVar3 = lVar3 + 1;
} while (*pcVar1 != '\0');
return lVar2;
}
return 0;
} |
750 | func0 | #include <stdio.h>
| int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
} | O2 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 11c8 <func0+0x28>
mov $0x1,%eax
xchg %ax,%ax
mov %eax,%r8d
add $0x1,%rax
cmpb $0x0,-0x1(%rdi,%rax,1)
jne 11b0 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1180
sub rsp, 8
add rdi, 1; s
call _strlen
add rsp, 8
add eax, 1
retn
loc_1180:
xor eax, eax
retn | long long func0(long long a1)
{
if ( *(_BYTE *)a1 )
return (unsigned int)strlen((const char *)(a1 + 1)) + 1;
else
return 0LL;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101180
SUB RSP,0x8
ADD RDI,0x1
CALL 0x00101050
ADD RSP,0x8
ADD EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
RET | int func0(char *param_1)
{
size_t sVar1;
if (*param_1 != '\0') {
sVar1 = strlen(param_1 + 1);
return (int)sVar1 + 1;
}
return 0;
} |
751 | func0 | #include <stdio.h>
| int func0(const char *str) {
int length = 0;
while (str[length] != '\0') {
length++;
}
return length;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("x") == 1);
assert(func0("asdasnakj") == 9);
return 0;
} | O3 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 11c8 <func0+0x28>
mov $0x1,%eax
xchg %ax,%ax
mov %eax,%r8d
add $0x1,%rax
cmpb $0x0,-0x1(%rdi,%rax,1)
jne 11b0 <func0+0x10>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1180
sub rsp, 8
add rdi, 1; s
call _strlen
add rsp, 8
add eax, 1
retn
loc_1180:
xor eax, eax
retn | long long func0(long long a1)
{
if ( *(_BYTE *)a1 )
return (unsigned int)strlen((const char *)(a1 + 1)) + 1;
else
return 0LL;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101180
SUB RSP,0x8
ADD RDI,0x1
CALL 0x00101050
ADD RSP,0x8
ADD EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
RET | int func0(char *param_1)
{
size_t sVar1;
if (*param_1 != '\0') {
sVar1 = strlen(param_1 + 1);
return (int)sVar1 + 1;
}
return 0;
} |
752 | func0 | #include <stdio.h>
| int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
} | #include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x2,-0x4(%rbp)
jmp 1177 <func0+0x2e>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1173 <func0+0x2a>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
jmp 1187 <func0+0x3e>
addl $0x1,-0x4(%rbp)
mov... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 2
jmp short loc_1177
loc_115D:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1173
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
jmp short loc_1187
loc_1173:
add ... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
for ( i = 2; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
return (unsigned int)(a1 / i);
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101177
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101173
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
JMP 0x00101187
LAB_00101... | int [16] func0(int param_1,int8 param_2,ulong param_3)
{
ulong uVar1;
int auVar2 [16];
int4 local_c;
local_c = 2;
do {
if (param_1 < local_c * local_c) {
uVar1 = 1;
LAB_00101187:
auVar2._8_8_ = param_3;
auVar2._0_8_ = uVar1;
return auVar2;
}
param_3 = (long)param_1 % (... |
753 | func0 | #include <stdio.h>
| int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
} | #include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
} | O1 | c | func0:
endbr64
cmp $0x3,%edi
jle 1185 <func0+0x3c>
test $0x1,%dil
je 1178 <func0+0x2f>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 117f <func0+0x36>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 115d <func0+0x14>
mov %edi,%eax
cltd
idiv %ecx
r... | func0:
endbr64
cmp edi, 3
jle short loc_1184
mov esi, edi
and esi, 1
jz short loc_117D
mov ecx, 2
loc_115E:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_117A
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_115E
loc_1173:
mov eax, ed... | long long func0(int a1)
{
unsigned int v1; // esi
int v2; // ecx
if ( a1 <= 3 )
{
return 1;
}
else
{
v1 = a1 & 1;
if ( (a1 & 1) != 0 )
{
v2 = 2;
while ( 1 )
{
++v2;
if ( v2 * v2 > a1 )
break;
if ( !(a1 % v2) )
return (unsigned... | func0:
ENDBR64
CMP EDI,0x3
JLE 0x00101184
MOV ESI,EDI
AND ESI,0x1
JZ 0x0010117d
MOV ECX,0x2
LAB_0010115e:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x0010117a
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010115e
LAB_00101173:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
LAB_0010117a:
MOV EAX,ESI
RET
LAB_0010117d:
MOV... | int [16] func0(uint param_1,int8 param_2,ulong param_3)
{
int iVar1;
uint uVar2;
int auVar3 [16];
if ((int)param_1 < 4) {
uVar2 = 1;
}
else {
uVar2 = param_1 & 1;
if (uVar2 == 0) {
iVar1 = 2;
}
else {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if ((int)para... |
754 | func0 | #include <stdio.h>
| int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
} | #include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
} | O2 | c | func0:
endbr64
cmp $0x3,%edi
jle 1175 <func0+0x35>
mov $0x2,%ecx
test $0x1,%dil
jne 1169 <func0+0x29>
jmp 1180 <func0+0x40>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <func0+0x40>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle ... | func0:
endbr64
cmp edi, 3
jle short loc_118A
mov esi, edi
mov ecx, 2
and esi, 1
jnz short loc_1169
jmp short loc_1180
loc_1160:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1169:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short l... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 3 )
return 1;
v1 = 2;
v2 = a1 & 1;
if ( (a1 & 1) != 0 )
{
while ( 1 )
{
++v1;
if ( v1 * v1 > a1 )
break;
if ( !(a1 % v1) )
return (unsigned int)(a1 / v1);
}
return v2;
}
... | func0:
ENDBR64
CMP EDI,0x3
JLE 0x0010118a
MOV ESI,EDI
MOV ECX,0x2
AND ESI,0x1
JNZ 0x00101169
JMP 0x00101180
LAB_00101160:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101169:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101160
LAB_00101175:
MOV EAX,ESI
RET
LAB_00101180:
MOV EAX,EDI
CDQ
IDIV ECX... | int [16] func0(uint param_1,int8 param_2,ulong param_3)
{
int iVar1;
uint uVar2;
uint uVar3;
int auVar4 [16];
int auVar5 [16];
if ((int)param_1 < 4) {
uVar3 = 1;
}
else {
iVar1 = 2;
uVar3 = param_1 & 1;
uVar2 = uVar3;
while( true ) {
if (uVar2 == 0) {
auVar5._8_8_ ... |
755 | func0 | #include <stdio.h>
| int func0(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return n / i;
return 1;
} | #include <assert.h>
int main() {
assert(func0(3) == 1);
assert(func0(7) == 1);
assert(func0(10) == 5);
assert(func0(100) == 50);
assert(func0(49) == 7);
return 0;
} | O3 | c | func0:
endbr64
cmp $0x3,%edi
jle 1175 <func0+0x35>
mov $0x2,%ecx
test $0x1,%dil
jne 1169 <func0+0x29>
jmp 1180 <func0+0x40>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <func0+0x40>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle ... | func0:
endbr64
cmp edi, 3
jle short loc_118A
mov esi, edi
mov ecx, 2
and esi, 1
jnz short loc_1169
jmp short loc_1180
loc_1160:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1169:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short l... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 3 )
return 1;
v1 = 2;
v2 = a1 & 1;
if ( (a1 & 1) != 0 )
{
while ( 1 )
{
++v1;
if ( v1 * v1 > a1 )
break;
if ( !(a1 % v1) )
return (unsigned int)(a1 / v1);
}
return v2;
}
... | func0:
ENDBR64
CMP EDI,0x3
JLE 0x0010118a
MOV ESI,EDI
MOV ECX,0x2
AND ESI,0x1
JNZ 0x00101169
JMP 0x00101180
LAB_00101160:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101169:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101160
LAB_00101175:
MOV EAX,ESI
RET
LAB_00101180:
MOV EAX,EDI
CDQ
IDIV ECX... | int [16] func0(uint param_1,int8 param_2,ulong param_3)
{
int iVar1;
uint uVar2;
uint uVar3;
int auVar4 [16];
int auVar5 [16];
if ((int)param_1 < 4) {
uVar3 = 1;
}
else {
iVar1 = 2;
uVar3 = param_1 & 1;
uVar2 = uVar3;
while( true ) {
if (uVar2 == 0) {
auVar5._8_8_ ... |
756 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
} | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov $0x100,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x20(%rbp),%rax
movl $0x0,(%rax)
movl $0x2,-0xc(%rbp)
jmp 121d <func0+0x74>
mov -0x14(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
mov edi, 100h; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
mov [rbp+var_C], 2
jmp short loc_121D
loc_11DD:
mov eax, [rbp+var_14]
cdq
idi... | _DWORD * func0(int a1, _DWORD *a2)
{
int v2; // eax
int v3; // eax
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v7; // [rsp+18h] [rbp-8h]
v7 = malloc(0x100uLL);
*a2 = 0;
for ( i = 2; a1 >= i * i; ++i )
{
while ( !(a1 % i) )
{
a1 /= i;
v2 = (*a2)++;
v7[v2] = i;
}
}
if ( a1 > 1 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV EDI,0x100
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0xc],0x2
JMP 0x0010121d
LAB_001011dd:
MOV EAX,dword ptr [RBP + -0x14... | void * func0(int param_1,int *param_2)
{
int iVar1;
void *pvVar2;
int4 local_1c;
int4 local_14;
pvVar2 = malloc(0x100);
*param_2 = 0;
local_1c = param_1;
for (local_14 = 2; local_14 * local_14 <= local_1c; local_14 = local_14 + 1) {
while (local_1c % local_14 == 0) {
local_1c = local_1c / ... |
757 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
} | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
mov %rsi,%rbp
mov $0x100,%edi
callq 10b0 <malloc@plt>
mov %rax,%r8
movl $0x0,0x0(%rbp)
mov $0x2,%ecx
cmp $0x3,%ebx
jg 1225 <func0+0x7c>
cmp $0x1,%ebx
jle 11ea <func0+0x41>
mov 0x0(%rbp),%eax
lea 0x1(%rax),%edx
mov... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebx, edi
mov rbp, rsi
mov edi, 100h; size
call _malloc
mov r10, rax
mov dword ptr [rbp+0], 0
mov ecx, 2
cmp ebx, 3
jg short loc_122E
loc_11D6:
cmp ebx, 1
jle short loc_11EA
mov eax, [rbp+0]
lea edx, [rax+1]
mov... | _DWORD * func0(int a1, int *a2)
{
int v2; // ebx
_DWORD *v4; // r10
int v5; // ecx
int v6; // eax
long long v8; // rdi
int *v9; // rsi
int v10; // r9d
v2 = a1;
v4 = malloc(0x100uLL);
*a2 = 0;
v5 = 2;
if ( a1 > 3 )
{
do
{
if ( !(v2 % v5) )
{
v8 = *a2 + 1;
v9... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV RBP,RSI
MOV EDI,0x100
CALL 0x001010b0
MOV R10,RAX
MOV dword ptr [RBP],0x0
MOV ECX,0x2
CMP EBX,0x3
JG 0x0010122e
LAB_001011d6:
CMP EBX,0x1
JLE 0x001011ea
MOV EAX,dword ptr [RBP]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP],EDX
CDQE
MOV dword ptr [R10 + RAX*0x4],EBX... | void * func0(int param_1,int *param_2)
{
long lVar1;
void *pvVar2;
int iVar3;
int *piVar4;
int iVar5;
pvVar2 = malloc(0x100);
*param_2 = 0;
iVar3 = 2;
if (3 < param_1) {
do {
if (param_1 % iVar3 == 0) {
iVar5 = *param_2;
piVar4 = (int *)((long)pvVar2 + (long)iVar5 * 4);
... |
758 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
} | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size... | O2 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %edi,%ebx
mov $0x100,%edi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
mov $0x2,%ecx
mov %rax,%r9
cmp $0x3,%ebx
jle 15f2 <func0+0x72>
nopl (%rax)
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 15e6 <func0+0x66>... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov ebx, edi
mov edi, 100h; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
mov ecx, 2
mov r8, rax
cmp ebx, 3
jle short loc_15C1
nop dword ptr [rax]
loc_1580:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz sh... | _DWORD * func0(int a1, int *a2)
{
int v3; // ebx
_DWORD *v4; // rax
int v5; // ecx
_DWORD *v6; // r8
long long v7; // rsi
int v8; // edi
int v9; // edx
long long v10; // rax
v3 = a1;
v4 = malloc(0x100uLL);
*a2 = 0;
v5 = 2;
v6 = v4;
if ( a1 > 3 )
{
do
{
if ( !(v3 % v5) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV EBX,EDI
MOV EDI,0x100
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
MOV ECX,0x2
MOV R8,RAX
CMP EBX,0x3
JLE 0x001015c1
NOP dword ptr [RAX]
LAB_00101580:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001015b5
MOV EAX,dword ptr [RBP]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
N... | void * func0(int param_1,int *param_2)
{
long lVar1;
long lVar2;
void *pvVar3;
int iVar4;
long lVar5;
pvVar3 = malloc(0x100);
*param_2 = 0;
iVar4 = 2;
if (3 < param_1) {
do {
if (param_1 % iVar4 == 0) {
lVar2 = (long)(*param_2 + 1);
do {
lVar5 = lVar2;
... |
759 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n, int* size) {
int* out = malloc(sizeof(int) * 64);
*size = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
out[(*size)++] = i;
}
}
if (n > 1) {
out[(*size)++] = n;
}
return out;
} | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int* result;
result = func0(2, &size... | O3 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %edi,%ebx
mov $0x100,%edi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
mov $0x2,%ecx
mov %rax,%r9
cmp $0x3,%ebx
jle 15d2 <func0+0x72>
nopl (%rax)
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 15c6 <func0+0x66>... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov ebx, edi
mov edi, 100h; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
mov ecx, 2
mov r8, rax
cmp ebx, 3
jle short loc_15C1
nop dword ptr [rax]
loc_1580:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz sh... | _DWORD * func0(int a1, int *a2)
{
int v3; // ebx
_DWORD *v4; // rax
int v5; // ecx
_DWORD *v6; // r8
long long v7; // rsi
int v8; // edi
int v9; // edx
long long v10; // rax
v3 = a1;
v4 = malloc(0x100uLL);
*a2 = 0;
v5 = 2;
v6 = v4;
if ( a1 > 3 )
{
do
{
if ( !(v3 % v5) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV EBX,EDI
MOV EDI,0x100
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
MOV ECX,0x2
MOV R8,RAX
CMP EBX,0x3
JLE 0x001015c1
NOP dword ptr [RAX]
LAB_00101580:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001015b5
MOV EAX,dword ptr [RBP]
LEA ESI,[RAX + 0x1]
MOVSXD RSI,ESI
N... | void * func0(int param_1,int *param_2)
{
long lVar1;
long lVar2;
void *pvVar3;
int iVar4;
long lVar5;
pvVar3 = malloc(0x100);
*param_2 = 0;
iVar4 = 2;
if (3 < param_1) {
do {
if (param_1 % iVar4 == 0) {
lVar2 = (long)(*param_2 + 1);
do {
lVar5 = lVar2;
... |
760 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int ... | #include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %rdx,-0x68(%rbp)
mov -0x5c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x18(%rbp)
mov -0x5c(%rbp),%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 10c0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov [rbp+var_68], rdx
mov eax, [rbp+var_5C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov eax, [rbp+var_5C]
cdqe
mov esi, 4; size
mov rdi, rax; ... | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
_DWORD *v4; // rdx
int v5; // eax
int v6; // eax
int v9; // [rsp+24h] [rbp-4Ch]
int v10; // [rsp+28h] [rbp-48h]
int v11; // [rsp+2Ch] [rbp-44h]
int i; // [rsp+30h] [rbp-40h]
int v13; // [rsp+34h] [rbp-3Ch]
int j; // [rsp+38h] [rbp-38h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV qword ptr [RBP + -0x68],RDX
MOV EAX,dword ptr [RBP + -0x5c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x5c]
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL ... | void * func0(long param_1,int param_2,int *param_3)
{
int iVar1;
bool bVar2;
void *pvVar3;
void *__ptr;
void *__ptr_00;
int4 local_54;
int4 local_50;
int4 local_4c;
int4 local_48;
int4 local_40;
int4 local_38;
int4 local_34;
int4 local_2c;
pvVar3 = malloc((long)param_2 << 2);
__ptr = c... |
761 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int ... | #include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r14
mov %esi,%r15d
mov %rdx,%r13
movslq %esi,%rbx
lea 0x0(,%rbx,4),%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
mov $0x4,%esi
mov %rbx,%rdi
callq 10c0 <calloc@plt>
mov %rax,%rbp
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov r15d, esi
mov [rsp+48h+var_40], rdx
movsxd rbp, esi
lea r12, ds:0[rbp*4]
mov rdi, r12; size
call _malloc
mov r14, rax
mov esi, 4; size
mov rdi, rbp; nmemb
call ... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int *v3; // rbx
size_t v4; // r12
_DWORD *v5; // r14
_DWORD *v6; // r13
_DWORD *v7; // rbp
int *v8; // rsi
int *v9; // r12
int v10; // edi
int v11; // r8d
int v12; // edx
_DWORD *v13; // rax
_DWORD *v14; // rax
int v15; // r8d
int v16; // edx
_... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R15D,ESI
MOV qword ptr [RSP + 0x8],RDX
MOVSXD RBP,ESI
LEA R12,[RBP*0x4]
MOV RDI,R12
CALL 0x001010d0
MOV R14,RAX
MOV ESI,0x4
MOV RDI,RBP
CALL 0x001010c0
MOV R13,RAX
MOV ESI,0x4
MOV RDI,RBP
CALL 0x001010c0
MOV RBP,RAX
TEST R... | void * func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
int *__ptr;
int *__ptr_00;
int *piVar3;
int *piVar4;
size_t __nmemb;
int iVar5;
int iVar6;
int *piVar7;
__nmemb = (size_t)param_2;
pvVar2 = malloc(__nmemb * 4);
__ptr = (int *)calloc(__nmemb,4);
__ptr_00 = (in... |
762 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int ... | #include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new... | O2 | c | func0:
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
movslq %esi,%r13
push %r12
lea 0x0(,%r13,4),%rdi
mov %r13,%r14
push %rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %r13,%rdi
mov $0x4,%esi
mov %rax,%r12
callq 10c0 <calloc@plt>
mov %r13,%rdi
mov ... | func0:
endbr64
push r15
push r14
push r13
movsxd r13, esi
push r12
lea r15, ds:0[r13*4]
mov r12, rdx
mov r14, r13
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
mov rdi, r15; size
call _malloc
mov rdi, r13; nmemb
mov esi, 4; size
mov rbp, rax
call _... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
size_t v3; // r15
_DWORD *v5; // rbp
_DWORD *v6; // rbx
_DWORD *v7; // r13
int *v8; // rsi
int v9; // r9d
int v10; // r10d
long long v11; // r11
int *v12; // r8
int v13; // edx
_DWORD *v14; // rax
long long v15; // r14
_DWORD *v16; // rax
long lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
LEA R15,[R13*0x4]
MOV R12,RDX
MOV R14,R13
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,R15
CALL 0x001010d0
MOV RDI,R13
MOV ESI,0x4
MOV RBP,RAX
CALL 0x001010c0
MOV RDI,R13
MOV ESI,0x4
MOV RBX,RAX
CALL 0x001010c0
MOV R13,RAX
TEST R1... | void * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
void *pvVar3;
int *__ptr;
int *__ptr_00;
int *piVar4;
int *piVar5;
int iVar6;
long lVar7;
int iVar8;
long lVar9;
size_t __nmemb;
__nmemb = (size_t)param_2;
pvVar3 = malloc(__nmemb * 4);
__ptr = (int *)calloc(... |
763 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int* numbers, int size, int* new_size) {
int* out = (int*)malloc(size * sizeof(int));
int* has1 = (int*)calloc(size, sizeof(int));
int* has2 = (int*)calloc(size, sizeof(int));
int has1_count = 0;
int has2_count = 0;
int out_count = 0;
for (int i = 0; i < size; i++) {
int ... | #include <assert.h>
#include <string.h>
int issame(int* a, int a_size, int* b, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int new_size;
int* result;
result = func0((const int[]){}, 0, &new... | O3 | c | func0:
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
movslq %esi,%r13
push %r12
lea 0x0(,%r13,4),%rdi
mov %r13,%r14
push %rbp
push %rbx
mov %rdx,%rbx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %r13,%rdi
mov $0x4,%esi
mov %rax,%r12
callq 10c0 <calloc@plt>
mov %r13,%rdi
mov ... | func0:
endbr64
push r15
push r14
push r13
movsxd r13, esi
push r12
lea r15, ds:0[r13*4]
mov r12, rdx
mov r14, r13
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
mov rdi, r15; size
call _malloc
mov rdi, r13; nmemb
mov esi, 4; size
mov rbp, rax
call _... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
size_t v3; // r15
_DWORD *v5; // rbp
_DWORD *v6; // rbx
_DWORD *v7; // r13
int *v8; // rsi
int v9; // r9d
int v10; // r10d
long long v11; // r11
int *v12; // r8
int v13; // edx
_DWORD *v14; // rax
long long v15; // r14
_DWORD *v16; // rax
long lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
LEA R15,[R13*0x4]
MOV R12,RDX
MOV R14,R13
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,R15
CALL 0x001010d0
MOV RDI,R13
MOV ESI,0x4
MOV RBP,RAX
CALL 0x001010c0
MOV RDI,R13
MOV ESI,0x4
MOV RBX,RAX
CALL 0x001010c0
MOV R13,RAX
TEST R1... | void * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
void *pvVar3;
int *__ptr;
int *__ptr_00;
int *piVar4;
int *piVar5;
int iVar6;
long lVar7;
int iVar8;
long lVar9;
size_t __nmemb;
__nmemb = (size_t)param_2;
pvVar3 = malloc(__nmemb * 4);
__ptr = (int *)calloc(... |
764 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
} | #include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
asse... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 122d <func0+0x84>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_122D
loc_11D5:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax... | _BYTE * func0(const char *a1, long long a2)
{
_BYTE *result; // rax
char v3; // [rsp+17h] [rbp-9h]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
v3 = a1[i];
if ( v3 <= 96 || v3 > 122 )
{
if ( v3 > 64 && v3 <= 90 )
v3 += ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010122d
LAB_001011d5:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qw... | void func0(char *param_1,long param_2)
{
size_t sVar1;
char local_11;
int local_10;
sVar1 = strlen(param_1);
for (local_10 = 0; local_10 < (int)sVar1; local_10 = local_10 + 1) {
local_11 = param_1[local_10];
if ((local_11 < 'a') || ('z' < local_11)) {
if (('@' < local_11) && (local_11 < '[')... |
765 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
} | #include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
asse... | O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r9
test %r9d,%r9d
jle 11c6 <func0+0x5d>
lea -0x1(%r9),%r10d
mov $0x0,%edx
jmp 11b1 <func0+0x48>
lea -0x41(%rax),%edi
add $0x20,%ecx
cmp $0x1a,%dil
cmovb %ecx,%... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
call _strlen
test eax, eax
jle short loc_11FE
lea r8d, [rax-1]
mov ecx, 0
jmp short loc_11E9
loc_11CD:
lea edi, [rdx-41h]
add esi, 20h ; ' '
cmp dil, 1Ah
cmovb edx, esi
loc_11DA:
mov [rbx+rcx]... | long long func0(const char *a1, long long a2)
{
long long result; // rax
long long i; // rcx
char v4; // dl
LODWORD(result) = strlen(a1);
if ( (int)result > 0 )
{
for ( i = 0LL; ; ++i )
{
v4 = a1[i];
if ( (unsigned __int8)(v4 - 97) > 0x19u )
{
if ( (unsigned __int8)(v4 - ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001011fe
LEA R8D,[RAX + -0x1]
MOV ECX,0x0
JMP 0x001011e9
LAB_001011cd:
LEA EDI,[RDX + -0x41]
ADD ESI,0x20
CMP DIL,0x1a
CMOVC EDX,ESI
LAB_001011da:
MOV byte ptr [RBX + RCX*0x1],DL
LEA RDX,[RCX + 0x1]
CMP RCX,R8
JZ 0x0... | void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
char cVar4;
bool bVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar3 = 0;
do {
cVar4 = param_1[uVar3];
if ((byte)(cVar4 + 0x9fU) < 0x1a) {
cVar4 = cVar4 + -0x20;
}
... |
766 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
} | #include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
asse... | O2 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 133b <func0+0x5b>
lea -0x1(%rax),%esi
xor %ecx,%ecx
jmp 1312 <func0+0x32>
sub $0x20,%edx
mov %dl,(%rbx,%rcx,1)
lea 0x1(%rcx),%rdx
cmp %rcx,%rsi
je 133b <fun... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_133B
lea esi, [rax-1]
xor ecx, ecx
jmp short loc_1312
loc_1300:
sub edx, 20h ; ' '
mov [rbx+rcx], dl
lea rdx, [rcx+1]
cmp rsi, rcx
jz short loc_133B... | long long func0(const char *a1, long long a2)
{
long long result; // rax
long long v4; // rsi
long long i; // rcx
long long v6; // rdx
char v7; // dl
LODWORD(result) = strlen(a1);
if ( (int)result > 0 )
{
v4 = (unsigned int)(result - 1);
for ( i = 0LL; ; i = v6 )
{
v7 = a1[i];
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
TEST EAX,EAX
JLE 0x0010133b
LEA ESI,[RAX + -0x1]
XOR ECX,ECX
JMP 0x00101312
LAB_00101300:
SUB EDX,0x20
MOV byte ptr [RBX + RCX*0x1],DL
LEA RDX,[RCX + 0x1]
CMP RSI,RCX
JZ 0x0010133b
LAB_0010130f:
MOV RCX,RDX
LAB_00101312:
MOVZX EDX,byte... | void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
char cVar3;
ulong uVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar4 = 0;
while( true ) {
cVar3 = param_1[uVar4];
if ((byte)(cVar3 + 0x9fU) < 0x1a) {
*(char *)(param_2 + uVar4) = cVar3... |
767 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* str, char* out) {
int length = strlen(str);
for (int i = 0; i < length; i++) {
char w = str[i];
if (w >= 'a' && w <= 'z') {
w -= 32;
} else if (w >= 'A' && w <= 'Z') {
w += 32;
}
out[i] = w;
}
out[length] = '\0';
} | #include <assert.h>
#include <string.h>
int main() {
char result[100]; // Buffer large enough for test cases
func0("", result);
assert(strcmp(result, "") == 0);
func0("Hello!", result);
assert(strcmp(result, "hELLO!") == 0);
func0("These violent delights have violent ends", result);
asse... | O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 1657 <func0+0x377>
lea 0xf(%rbp),%rcx
lea -0x1(%rax),%edx
sub %rbx,%rcx
cmp $0x1e,%rcx
jbe 16e0 <func0+0x400>
cmp $0xe,%edx
jbe 16e0 <func0+0x400>
mov %eax,%... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
mov rcx, rax
test eax, eax
jle short loc_135A
lea edi, [rax-1]
mov esi, eax
cmp edi, 6
jbe short loc_1316
lea rdx, [rbp+1]
mov rax, rbx
sub rax, rdx
cmp rax, 0Eh
ja sho... | size_t func0(const char *a1, long long a2)
{
size_t result; // rax
int v5; // ecx
long long v6; // rdi
int v7; // esi
size_t i; // rdx
char v9; // al
__m128i si128; // xmm7
long long v11; // rax
__m128i v12; // xmm4
__m128i v13; // xmm8
__m128i v14; // xmm6
__m128i v15; // xmm5
__m128i v16; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
MOV RCX,RAX
TEST EAX,EAX
JLE 0x0010135a
LEA EDI,[RAX + -0x1]
MOV ESI,EAX
CMP EDI,0x6
JBE 0x00101316
LEA RDX,[RBP + 0x1]
MOV RAX,RBX
SUB RAX,RDX
CMP RAX,0xe
JA 0x00101370
LAB_00101316:
XOR EDX,EDX
JMP 0x00101332
LAB_00101320:
SUB EAX,0x... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(char *param_1,long param_2)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
byte bVar4;
byte bVar5;
byte bVar6;
byte bVar7;
byte bVar8;
byte bVar9;
char cVar10;
char cVar11;
char cVar12;
char cVar13;
ch... |
768 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, st... | #include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1259 <func0+0x50>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_1259
loc_122C:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov ... | char * func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
char *dest; // [rsp+28h] [rbp-8h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += strlen(*(const char **)(8LL * i + a1));
dest = (char *)malloc(v3 + 1);
if ( !dest )
return 0L... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101259
LAB_0010122c:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword p... | char * func0(long param_1,int param_2)
{
size_t sVar1;
char *__dest;
int4 local_1c;
int4 local_18;
int4 local_14;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
sVar1 = strlen(*(char **)(param_1 + (long)local_18 * 8));
local_1c = local_1c + (int)sVar1;
}
__... |
769 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, st... | #include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1253 <func0+0x8a>
mov %rdi,%r12
mov %esi,%ebp
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r9
mov $0x0,%esi
mov $0xffffffffffffffff,%r8
mov $0x0,%eax
mov (%rdx),%rdi
mov %r8,%... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r13d, esi
test esi, esi
jle short loc_128C
mov rbx, rdi
movsxd rax, esi
lea r12, [rdi+rax*8]
mov ebp, 0
loc_122E:
mov rdi, [rbx]; s
call _strlen
add eax, ebp
mov ebp, eax
add rbx, 8... | _BYTE * func0(const char **a1, int a2)
{
const char **v2; // rbx
int v3; // ebp
int v4; // eax
size_t v5; // rbx
_BYTE *v6; // rax
_BYTE *v7; // r12
const char **v8; // rbp
_BYTE *v10; // rax
if ( a2 <= 0 )
{
v10 = malloc(1uLL);
v7 = v10;
if ( v10 )
*v10 = 0;
}
else
{
v2... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R13D,ESI
TEST ESI,ESI
JLE 0x0010128c
MOV RBX,RDI
MOVSXD RAX,ESI
LEA R12,[RDI + RAX*0x8]
MOV EBP,0x0
LAB_0010122e:
MOV RDI,qword ptr [RBX]
CALL 0x001010d0
ADD EAX,EBP
MOV EBP,EAX
ADD RBX,0x8
CMP RBX,R12
JNZ 0x0010122e
ADD EAX,0x1
MOVSXD RBX,EAX
... | int * func0(int8 *param_1,int param_2)
{
int iVar1;
size_t sVar2;
int *puVar3;
int8 *puVar4;
if (param_2 < 1) {
puVar3 = (int *)malloc(1);
if (puVar3 == (int *)0x0) {
return (int *)0x0;
}
*puVar3 = 0;
if (param_2 < 1) {
return puVar3;
}
sVar2 = 1;
}
else {
i... |
770 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, st... | #include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(... | O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 13e8 <func0+0x88>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov %rdi,%rbp
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%rdi
add $0x8,%rbp
callq 10b0 <strlen@plt>
add ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1420
movsxd rsi, esi
mov rbx, rdi
mov rbp, rdi
xor r12d, r12d
lea r13, [rdi+rsi*8]
nop word ptr [rax+rax+00h]
loc_13B8:
mov rdi, [rbp+0]; s
add rbp, 8
call _strlen
add r12... | _BYTE * func0(const char **a1, int a2)
{
const char **v2; // rbx
const char **v3; // rbp
int v4; // r12d
const char **v5; // r13
const char *v6; // rdi
size_t v7; // r12
_BYTE *v8; // rax
long long v9; // rcx
long long v10; // rsi
_BYTE *result; // rax
if ( a2 > 0 )
{
v2 = a1;
v3 = a1;
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101420
MOVSXD RSI,ESI
MOV RBX,RDI
MOV RBP,RDI
XOR R12D,R12D
LEA R13,[RDI + RSI*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV RDI,qword ptr [RBP]
ADD RBP,0x8
CALL 0x001010d0
ADD R12D,EAX
CMP R13,RBP
JNZ 0x001013b8
ADD R12D,0x1
MOVS... | int * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
int8 uVar2;
size_t sVar3;
int *puVar4;
int8 *puVar5;
int iVar6;
if (param_2 < 1) {
puVar4 = (int *)malloc(1);
if (puVar4 != (int *)0x0) {
*puVar4 = 0;
return puVar4;
}
}
else {
iVar6 = 0;
puVar1 = p... |
771 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char** strings, int count) {
int length = 0;
for (int i = 0; i < count; i++) {
length += strlen(strings[i]);
}
char* out = (char*)malloc(length + 1);
if (!out) {
return NULL;
}
out[0] = '\0';
for (int i = 0; i < count; i++) {
strcat(out, st... | #include <assert.h>
#include <string.h>
int main() {
char* result;
char* empty_strings[] = {};
result = func0(empty_strings, 0);
assert(strcmp(result, "") == 0);
free(result);
char* strings1[] = {"x", "y", "z"};
result = func0(strings1, 3);
assert(strcmp(result, "xyz") == 0);
free(... | O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1408 <func0+0x88>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
mov %rdi,%rbp
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%r13
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%rdi
add $0x8,%rbp
callq 10b0 <strlen@plt>
add ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1420
movsxd rsi, esi
mov rbx, rdi
mov rbp, rdi
xor r12d, r12d
lea r13, [rdi+rsi*8]
nop word ptr [rax+rax+00h]
loc_13B8:
mov rdi, [rbp+0]; s
add rbp, 8
call _strlen
add r12... | _BYTE * func0(const char **a1, int a2)
{
const char **v2; // rbx
const char **v3; // rbp
int v4; // r12d
const char **v5; // r13
const char *v6; // rdi
size_t v7; // r12
_BYTE *v8; // rax
long long v9; // rcx
long long v10; // rsi
_BYTE *result; // rax
if ( a2 > 0 )
{
v2 = a1;
v3 = a1;
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101420
MOVSXD RSI,ESI
MOV RBX,RDI
MOV RBP,RDI
XOR R12D,R12D
LEA R13,[RDI + RSI*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV RDI,qword ptr [RBP]
ADD RBP,0x8
CALL 0x001010d0
ADD R12D,EAX
CMP R13,RBP
JNZ 0x001013b8
ADD R12D,0x1
MOVS... | int * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
int8 uVar2;
size_t sVar3;
int *puVar4;
int8 *puVar5;
int iVar6;
if (param_2 < 1) {
puVar4 = (int *)malloc(1);
if (puVar4 != (int *)0x0) {
*puVar4 = 0;
return puVar4;
}
}
else {
iVar6 = 0;
puVar1 = p... |
772 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] =... | #include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char... | 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 %rcx,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %eax,-0x4(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 111... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+s], rdx
mov [rbp+var_30], rcx
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov eax, [rbp+var_1C]
cdqe
shl rax, 3
mov rdi, rax; size
call _... | long long func0(long long a1, int a2, const char *a3, void **a4)
{
int v4; // eax
unsigned int v8; // [rsp+24h] [rbp-Ch]
int i; // [rsp+28h] [rbp-8h]
int v10; // [rsp+2Ch] [rbp-4h]
v10 = strlen(a3);
*a4 = malloc(8LL * a2);
v8 = 0;
for ( i = 0; i < a2; ++i )
{
if ( !strncmp(*(const char **)(8LL *... | 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 qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x3
MOV... | int func0(long param_1,int param_2,char *param_3,long *param_4)
{
int iVar1;
size_t sVar2;
void *pvVar3;
int4 local_14;
int4 local_10;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 << 3);
*param_4 = (long)pvVar3;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 +... |
773 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] =... | #include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r14
mov %esi,%r12d
mov %rdx,%r13
mov %rcx,%r15
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%ebp
movslq %esi,%rdi
sh... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13, rdi
mov ebx, esi
mov rdi, rdx; s
mov [rsp+48h+s2], rdx
mov r15, rcx
call _strlen
mov r14d, eax
movsxd rbp, ebx
shl rbp, 3
mov rdi, rbp; size
call _malloc
mov [r15],... | long long func0(const char **a1, int a2, const char *a3, void **a4)
{
int v5; // r14d
const char **v6; // rbx
unsigned int v7; // r12d
const char *v8; // rbp
v5 = strlen(a3);
*a4 = malloc(8LL * a2);
if ( a2 <= 0 )
{
return 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
v8 = *v6;
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,RDI
MOV EBX,ESI
MOV RDI,RDX
MOV qword ptr [RSP + 0x8],RDX
MOV R15,RCX
CALL 0x001010d0
MOV R14D,EAX
MOVSXD RBP,EBX
SHL RBP,0x3
MOV RDI,RBP
CALL 0x00101110
MOV qword ptr [R15],RAX
TEST EBX,EBX
JLE 0x0010128b
MOV RBX,R13
ADD R13,RBP
... | int func0(int8 *param_1,int param_2,char *param_3,long *param_4)
{
char *__s1;
int iVar1;
size_t sVar2;
void *pvVar3;
int iVar4;
int8 *puVar5;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 * 8);
*param_4 = (long)pvVar3;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar5 = param_1... |
774 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] =... | #include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char... | O2 | c | func0:
endbr64
push %r15
mov %rcx,%r15
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
mov %rdx,%rdi
sub $0x18,%rsp
callq 10d0 <strlen@plt>
movslq %r12d,%rdi
shl $0x3,%rdi
mov %rax,%rbp
callq 1110 <malloc@plt>
mov %rax,0x8(%rsp)
mov ... | func0:
endbr64
push r15
movsxd r15, esi
push r14
push r13
mov r13, rdx
push r12
push rbp
mov rbp, r15
shl r15, 3
push rbx
mov rbx, rdi
mov rdi, rdx; s
sub rsp, 18h
mov [rsp+48h+var_40], rcx
call _strlen
mov rdi, r15; size
mov r12, rax
call _malloc
mov rcx... | long long func0(const char **a1, int a2, const char *a3, _QWORD *a4)
{
const char **v5; // rbx
int v6; // r12d
unsigned int v7; // ebp
const char *v8; // r14
long long v9; // rax
_QWORD *v11; // [rsp+0h] [rbp-48h]
v5 = a1;
v6 = strlen(a3);
v11 = malloc(8LL * a2);
*a4 = v11;
if ( a2 <= 0 )
{
... | func0:
ENDBR64
PUSH R15
MOVSXD R15,ESI
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,R15
SHL R15,0x3
PUSH RBX
MOV RBX,RDI
MOV RDI,RDX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001010d0
MOV RDI,R15
MOV R12,RAX
CALL 0x00101110
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
MOV qword ptr [RCX],RAX... | int func0(int8 *param_1,int param_2,char *param_3,int8 *param_4)
{
char *__s1;
int iVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
int iVar5;
int8 *puVar6;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 * 8);
*param_4 = pvVar3;
if (param_2 < 1) {
iVar5 = 0;
}
else {
puVar6 =... |
775 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(char** strings, int count, const char* prefix, char*** out) {
int prefix_length = strlen(prefix);
*out = (char**)malloc(count * sizeof(char*));
int out_count = 0;
for (int i = 0; i < count; i++) {
if (strncmp(strings[i], prefix, prefix_length) == 0) {
(*out)[out_count++] =... | #include <assert.h>
#include <stdio.h>
// Helper function to compare two arrays of strings
int issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
char... | O3 | c | func0:
endbr64
push %r15
mov %rcx,%r15
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
mov %rdx,%rdi
sub $0x18,%rsp
callq 10d0 <strlen@plt>
movslq %r12d,%rdi
shl $0x3,%rdi
mov %rax,%rbp
callq 1110 <malloc@plt>
mov %rax,0x8(%rsp)
mov ... | func0:
endbr64
push r15
movsxd r15, esi
push r14
push r13
mov r13, rdx
push r12
push rbp
mov rbp, r15
shl r15, 3
push rbx
mov rbx, rdi
mov rdi, rdx; s
sub rsp, 18h
mov [rsp+48h+var_40], rcx
call _strlen
mov rdi, r15; size
mov r12, rax
call _malloc
mov rcx... | long long func0(const char **a1, int a2, const char *a3, _QWORD *a4)
{
const char **v5; // rbx
int v6; // r12d
unsigned int v7; // ebp
const char *v8; // r14
long long v9; // rax
_QWORD *v11; // [rsp+0h] [rbp-48h]
v5 = a1;
v6 = strlen(a3);
v11 = malloc(8LL * a2);
*a4 = v11;
if ( a2 <= 0 )
{
... | func0:
ENDBR64
PUSH R15
MOVSXD R15,ESI
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,R15
SHL R15,0x3
PUSH RBX
MOV RBX,RDI
MOV RDI,RDX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001010d0
MOV RDI,R15
MOV R12,RAX
CALL 0x00101110
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
MOV qword ptr [RCX],RAX... | int func0(int8 *param_1,int param_2,char *param_3,int8 *param_4)
{
char *__s1;
int iVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
int iVar5;
int8 *puVar6;
sVar2 = strlen(param_3);
pvVar3 = malloc((long)param_2 * 8);
*param_4 = pvVar3;
if (param_2 < 1) {
iVar5 = 0;
}
else {
puVar6 =... |
776 | func0 | #include <stdio.h>
#include <stdlib.h>
| float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
} | #include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main()... | 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
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x28(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0xc(%rbp)
jmp 12... | 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]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_28]
mov dword ptr [rax], 0
mov [rbp+var_C... | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v7; // [rsp+28h] [rbp-8h]
v7 = malloc(4LL * a2);
*a3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(float *)(4LL * i + a1) > 0.0 )
{
v3 = (*a3)++;
v7[v3] = *(_DWORD *)(4LL * i + a1);
}... | 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]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x0
MOV dword p... | void * func0(long param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
int4 local_14;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (0.0 < *(float *)(param_1 + (long)local_14 * 4)) {
iVar1 = *param_3;
*para... |
777 | func0 | #include <stdio.h>
#include <stdlib.h>
| float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
} | #include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main()... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x0,(%rbx)
test %ebp,%ebp
jle 1207 <func0+0x5e>
mov %r12,%rdx
lea -0x1(%rbp),%ecx
lea 0x4(%r12,%rcx,4),%rdi
pxor %xmm1,%xmm1
jmp 11e... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13d, esi
mov rbp, rdx
movsxd r12, esi
shl r12, 2
mov rdi, r12; size
call _malloc
mov dword ptr [rbp+0], 0
test r13d, r13d
jle short loc_1211
mov rdx, rbx
lea rsi, [rbx+r12]
pxor ... | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *result; // rax
_DWORD *v5; // rdx
int v6; // ecx
result = malloc(4LL * a2);
*a3 = 0;
if ( a2 > 0 )
{
v5 = a1;
do
{
if ( *(float *)v5 > 0.0 )
{
v6 = (*a3)++;
result[v6] = *v5;
}
++v5;
}
whi... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13D,ESI
MOV RBP,RDX
MOVSXD R12,ESI
SHL R12,0x2
MOV RDI,R12
CALL 0x001010b0
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101211
MOV RDX,RBX
LEA RSI,[RBX + R12*0x1]
PXOR XMM1,XMM1
JMP 0x00101206
LAB_001011e8:
MOV ECX,dword ptr [RBP]
LEA EDI... | void func0(float *param_1,int param_2,int *param_3)
{
float *pfVar1;
int iVar2;
void *pvVar3;
pvVar3 = malloc((long)param_2 * 4);
*param_3 = 0;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
do {
if (0.0 < *param_1) {
iVar2 = *param_3;
*param_3 = iVar2 + 1;
*(float ... |
778 | func0 | #include <stdio.h>
#include <stdlib.h>
| float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
} | #include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main()... | O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 14e1 <func0+0x61>
lea -0x1(%r12),%edx
mov %rbx,%rdi
pxor %xmm1,%xmm1
lea 0x4(%rbx,%rdx,4),%rsi
nopw ... | func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
lea rbp, ds:0[rdi*4]
mov r13, rdi
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov dword ptr [r12], 0
test r13d, r13d
jle short loc_14AA
mov rcx, rbx
lea rdi, [rbx+rbp]
p... | _DWORD * func0(_DWORD *a1, int a2, int *a3)
{
size_t v4; // rbp
_DWORD *result; // rax
_DWORD *v6; // rcx
long long v7; // rsi
v4 = a2;
result = malloc(v4 * 4);
*a3 = 0;
if ( a2 > 0 )
{
v6 = a1;
do
{
if ( *(float *)v6 > 0.0 )
{
v7 = *a3;
result[v7] = *v6;
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA RBP,[RDI*0x4]
MOV R13,RDI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [R12],0x0
TEST R13D,R13D
JLE 0x001014aa
MOV RCX,RBX
LEA RDI,[RBX + RBP*0x1]
PXOR XMM1,XMM1
NOP word ptr [RAX + RAX*0x1]
LAB_00101488:
MOVSS XMM0,d... | void func0(float *param_1,int param_2,int *param_3)
{
float *pfVar1;
int iVar2;
void *pvVar3;
pvVar3 = malloc((long)param_2 * 4);
*param_3 = 0;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
do {
if (0.0 < *param_1) {
iVar2 = *param_3;
*(float *)((long)pvVar3 + (long)iVar2 ... |
779 | func0 | #include <stdio.h>
#include <stdlib.h>
| float* func0(const float* l, int count, int* out_count) {
float* out = (float*)malloc(count * sizeof(float));
*out_count = 0;
for (int i = 0; i < count; i++) {
if (l[i] > 0) {
out[(*out_count)++] = l[i];
}
}
return out;
} | #include <assert.h>
#include <math.h>
// Helper function to compare two arrays of floats
int issame(const float* a, int a_count, const float* b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return 0;
}
return 1;
}
int main()... | O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 14b1 <func0+0x61>
lea -0x1(%r12),%edx
mov %rbx,%rdi
pxor %xmm1,%xmm1
lea 0x4(%rbx,%rdx,4),%rsi
nopw ... | func0:
endbr64
push r13
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
lea rbp, ds:0[rdi*4]
mov r13, rdi
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov dword ptr [r12], 0
test r13d, r13d
jle short loc_14AA
mov rcx, rbx
lea rdi, [rbx+rbp]
p... | _DWORD * func0(_DWORD *a1, int a2, int *a3)
{
size_t v4; // rbp
_DWORD *result; // rax
_DWORD *v6; // rcx
long long v7; // rsi
v4 = a2;
result = malloc(v4 * 4);
*a3 = 0;
if ( a2 > 0 )
{
v6 = a1;
do
{
if ( *(float *)v6 > 0.0 )
{
v7 = *a3;
result[v7] = *v6;
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA RBP,[RDI*0x4]
MOV R13,RDI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [R12],0x0
TEST R13D,R13D
JLE 0x001014aa
MOV RCX,RBX
LEA RDI,[RBX + RBP*0x1]
PXOR XMM1,XMM1
NOP word ptr [RAX + RAX*0x1]
LAB_00101488:
MOVSS XMM0,d... | void func0(float *param_1,int param_2,int *param_3)
{
float *pfVar1;
int iVar2;
void *pvVar3;
pvVar3 = malloc((long)param_2 * 4);
*param_3 = 0;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
do {
if (0.0 < *param_1) {
iVar2 = *param_3;
*(float *)((long)pvVar3 + (long)iVar2 ... |
780 | func0 | #include <stdbool.h>
| bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
cmpq $0x1,-0x18(%rbp)
jg 1163 <func0+0x1a>
mov $0x0,%eax
jmp 119e <func0+0x55>
movq $0x2,-0x8(%rbp)
jmp 118b <func0+0x42>
mov -0x18(%rbp),%rax
cqto
idivq -0x8(%rbp)
mov %rdx,%rax
test %rax,%rax
jne 1186 <func0+0x3d>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
cmp [rbp+var_18], 1
jg short loc_1163
mov eax, 0
jmp short loc_119E
loc_1163:
mov [rbp+var_8], 2
jmp short loc_118B
loc_116D:
mov rax, [rbp+var_18]
cqo
idiv [rbp+var_8]
mov rax, rdx
test rax, rax
jnz short l... | long long func0(long long a1)
{
long long i; // [rsp+10h] [rbp-8h]
if ( a1 <= 1 )
return 0LL;
for ( i = 2LL; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
CMP qword ptr [RBP + -0x18],0x1
JG 0x00101163
MOV EAX,0x0
JMP 0x0010119e
LAB_00101163:
MOV qword ptr [RBP + -0x8],0x2
JMP 0x0010118b
LAB_0010116d:
MOV RAX,qword ptr [RBP + -0x18]
CQO
IDIV qword ptr [RBP + -0x8]
MOV RAX,RDX
TEST RAX,RAX
JNZ 0x00101186
M... | int8 func0(long param_1)
{
int8 uVar1;
long local_10;
if (param_1 < 2) {
uVar1 = 0;
}
else {
for (local_10 = 2; local_10 * local_10 <= param_1; local_10 = local_10 + 1) {
if (param_1 % local_10 == 0) {
return 0;
}
}
uVar1 = 1;
}
return uVar1;
} |
781 | func0 | #include <stdbool.h>
| bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
... | O1 | c | func0:
endbr64
mov $0x0,%eax
cmp $0x1,%rdi
jle 118b <func0+0x42>
cmp $0x3,%rdi
jle 1192 <func0+0x49>
test $0x1,%dil
je 1198 <func0+0x4f>
mov $0x2,%ecx
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rdi,%rax
jg 118c <func0+0x43>
mov %rdi,%rax
cqto
idiv %rcx
test %rdx,%rdx
j... | func0:
endbr64
mov eax, 0
cmp rdi, 1
jle short locret_118B
cmp rdi, 3
jle short loc_1192
test dil, 1
jz short loc_1198
mov ecx, 2
loc_1169:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rdi
jg short loc_118C
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jnz s... | long long func0(long long a1)
{
long long result; // rax
long long v2; // rcx
result = 0LL;
if ( a1 > 1 )
{
if ( a1 <= 3 )
{
return 1LL;
}
else if ( (a1 & 1) != 0 )
{
v2 = 2LL;
while ( 1 )
{
++v2;
if ( v2 * v2 > a1 )
break;
if ( !... | func0:
ENDBR64
MOV EAX,0x0
CMP RDI,0x1
JLE 0x0010118b
CMP RDI,0x3
JLE 0x00101192
TEST DIL,0x1
JZ 0x00101198
MOV ECX,0x2
LAB_00101169:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RDI
JG 0x0010118c
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JNZ 0x00101169
MOV EAX,0x0
LAB_0010118b:
RET
LAB_0010118c:
MOV EAX,0x1
RET
LAB_001011... | int8 func0(ulong param_1)
{
int auVar1 [16];
long lVar2;
if (1 < (long)param_1) {
if ((long)param_1 < 4) {
return 1;
}
if ((param_1 & 1) == 0) {
return 0;
}
lVar2 = 2;
do {
lVar2 = lVar2 + 1;
if (lVar2 * lVar2 - param_1 != 0 && (long)param_1 <= lVar2 * lVar2) {
... |
782 | func0 | #include <stdbool.h>
| bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
... | O2 | c | func0:
endbr64
cmp $0x1,%rdi
jle 13e0 <func0+0x10>
jmp 1380 <func0.part.0>
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
cmp rdi, 3
jle short loc_13B5
test dil, 1
jz short loc_13C0
mov ecx, 2
jmp short loc_13A5
loc_1398:
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jz short loc_13C0
loc_13A5:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rdi, rax
jge short loc_1398
loc_13B5:
... | long long func0_part_0(long long a1)
{
long long v1; // rcx
if ( a1 <= 3 )
return 1LL;
if ( (a1 & 1) != 0 )
{
v1 = 2LL;
while ( 1 )
{
++v1;
if ( a1 < v1 * v1 )
break;
if ( !(a1 % v1) )
return 0LL;
}
return 1LL;
}
return 0LL;
} | func0.part.0:
CMP RDI,0x3
JLE 0x001013b5
TEST DIL,0x1
JZ 0x001013c0
MOV ECX,0x2
JMP 0x001013a5
LAB_00101398:
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JZ 0x001013c0
LAB_001013a5:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RDI,RAX
JGE 0x00101398
LAB_001013b5:
MOV EAX,0x1
RET
LAB_001013c0:
XOR EAX,EAX
RET | int8 func0_part_0(ulong param_1)
{
int auVar1 [16];
long lVar2;
if ((long)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
lVar2 = 2;
do {
lVar2 = lVar2 + 1;
if ((long)param_1 < lVar2 * lVar2) {
return 1;
}
auVar1._8_8_ = (long)(int7)(param_1 >> 8) >> 0x37;
... |
783 | func0 | #include <stdbool.h>
| bool func0(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0(6) == false);
assert(func0(101) == true);
assert(func0(11) == true);
assert(func0(13441) == true);
assert(func0(61) == true);
assert(func0(4) == false);
assert(func0(1) == false);
assert(func0(5) == true);
assert(func0(11) == true);
... | O3 | c | func0:
endbr64
xor %eax,%eax
cmp $0x1,%rdi
jle 141a <func0+0x4a>
cmp $0x3,%rdi
jle 140d <func0+0x3d>
test $0x1,%dil
je 141a <func0+0x4a>
mov $0x2,%ecx
jmp 13fd <func0+0x2d>
mov %rdi,%rax
cqto
idiv %rcx
test %rdx,%rdx
je 1418 <func0+0x48>
add $0x1,%rcx
mov %rcx,%rax
imul %rc... | func0_part_0:
cmp rdi, 3
jle short loc_13B5
test dil, 1
jz short loc_13C0
mov ecx, 2
jmp short loc_13A5
loc_1398:
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jz short loc_13C0
loc_13A5:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rdi, rax
jge short loc_1398
loc_13B5:
... | long long func0_part_0(long long a1)
{
long long v1; // rcx
if ( a1 <= 3 )
return 1LL;
if ( (a1 & 1) != 0 )
{
v1 = 2LL;
while ( 1 )
{
++v1;
if ( a1 < v1 * v1 )
break;
if ( !(a1 % v1) )
return 0LL;
}
return 1LL;
}
return 0LL;
} | func0.part.0:
CMP RDI,0x3
JLE 0x001013b5
TEST DIL,0x1
JZ 0x001013c0
MOV ECX,0x2
JMP 0x001013a5
LAB_00101398:
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JZ 0x001013c0
LAB_001013a5:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RDI,RAX
JGE 0x00101398
LAB_001013b5:
MOV EAX,0x1
RET
LAB_001013c0:
XOR EAX,EAX
RET | int8 func0_part_0(ulong param_1)
{
int auVar1 [16];
long lVar2;
if ((long)param_1 < 4) {
return 1;
}
if ((param_1 & 1) != 0) {
lVar2 = 2;
do {
lVar2 = lVar2 + 1;
if ((long)param_1 < lVar2 * lVar2) {
return 1;
}
auVar1._8_8_ = (long)(int7)(param_1 >> 8) >> 0x37;
... |
784 | func0 | #include <stdio.h>
#include <math.h>
| double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] *... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
pxor %xmm0,%xmm0
movsd %xmm0,-0x20(%rbp)
mov -0x38(%rbp),%rax
movsd (%rax),%xmm0
movsd %xmm0,-0x18(%rbp)
movl $0x1,-0x30(%rbp)
jmp 1217 <func0+0x8e>
movsd 0xed1(%rip),%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x0,-0x2c... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
pxor xmm0, xmm0
movsd [rbp+var_20], xmm0
mov rax, [rbp+var_38]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_18], xmm0
mov [rbp+var_30], 1
jmp short loc_1217
loc_11B7:
movsd xmm0, cs:qword_2070
movsd [r... | double func0(double *a1, int a2)
{
int i; // [rsp+Ch] [rbp-30h]
int k; // [rsp+Ch] [rbp-30h]
int n; // [rsp+Ch] [rbp-30h]
int j; // [rsp+10h] [rbp-2Ch]
int m; // [rsp+14h] [rbp-28h]
int ii; // [rsp+18h] [rbp-24h]
double v9; // [rsp+1Ch] [rbp-20h]
double v10; // [rsp+24h] [rbp-18h]
double v11; // [rsp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x20],XMM0
MOV RAX,qword ptr [RBP + -0x38]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x18],XMM0
MOV dword ptr [RBP + -0x30],0x1
JMP 0x00101217
LAB_001011b7:
MOVSD XMM0,qwor... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double *param_1,int param_2)
{
int local_38;
int local_34;
int local_30;
int local_2c;
double local_28;
double local_20;
double local_18;
double local_10;
local_28 = 0.0;
local_20 = *param_1;
for... |
785 | func0 | #include <stdio.h>
#include <math.h>
| double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] *... | O1 | c | func0:
endbr64
mov %rdi,%r8
mov %esi,%r9d
movsd (%rdi),%xmm5
cmp $0x1,%esi
jle 11e5 <func0+0x5c>
lea -0x2(%rsi),%esi
add $0x2,%rsi
movapd %xmm5,%xmm3
mov $0x1,%ecx
pxor %xmm1,%xmm1
jmp 11d0 <func0+0x47>
mulsd %xmm1,%xmm0
add $0x1,%eax
cmp %edx,%eax
jne 11b2 <func0+0x29>
mulsd (%r8,... | func0:
endbr64
mov r9d, esi
movsd xmm5, qword ptr [rdi]
cmp esi, 1
jle short loc_1213
mov esi, esi
movapd xmm3, xmm5
mov ecx, 1
pxor xmm1, xmm1
loc_11A8:
mov edx, ecx
mov eax, 0
movsd xmm0, cs:qword_2068
test ecx, ecx
jle loc_12E1
loc_11BF:
mulsd xmm0, xmm1
add eax, 1
cm... | __int128 __usercall func0@<xmm0>(double *a1@<rdi>, int a2@<esi>)
{
double v2; // xmm3_8
long long i; // rcx
int v4; // eax
double v5; // xmm0_8
__int128 v6; // xmm1
double v8; // xmm0_8
int v9; // eax
double v10; // xmm4_8
long long v11; // rcx
long long j; // rcx
int v13; // eax
double v14; // ... | func0:
ENDBR64
MOV R9D,ESI
MOVSD XMM5,qword ptr [RDI]
CMP ESI,0x1
JLE 0x00101213
MOV ESI,ESI
MOVAPD XMM3,XMM5
MOV ECX,0x1
PXOR XMM1,XMM1
LAB_001011a8:
MOV EDX,ECX
MOV EAX,0x0
MOVSD XMM0,qword ptr [0x00102068]
TEST ECX,ECX
JLE 0x001012e1
LAB_001011bf:
MULSD XMM0,XMM1
ADD EAX,0x1
CMP EAX,EDX
JNZ 0x001011bf
MULSD XMM0,qwo... | double func0(double *param_1,uint param_2)
{
double dVar1;
int iVar2;
int iVar3;
ulong uVar4;
double dVar5;
double dVar6;
double dVar7;
double dVar8;
dVar1 = *param_1;
dVar7 = dVar1;
if (1 < (int)param_2) {
uVar4 = 1;
do {
while( true ) {
iVar2 = 0;
dVar5 = DAT_00... |
786 | func0 | #include <stdio.h>
#include <math.h>
| double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] *... | O2 | c | func0:
endbr64
movsd (%rdi),%xmm7
mov %rdi,%r9
mov %esi,%r8d
cmp $0x1,%esi
jle 14c9 <func0+0x179>
lea -0x2(%rsi),%ecx
movapd %xmm7,%xmm3
pxor %xmm6,%xmm6
mov $0x1,%edx
movsd 0xd09(%rip),%xmm1
add $0x2,%rcx
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
movapd %xmm1,%xmm0
xchg %ax,%ax
mulsd %xmm6,%... | func0:
endbr64
movsd xmm6, qword ptr [rdi]
mov ecx, esi
cmp esi, 1
jle loc_14C9
mov r8d, esi
movapd xmm3, xmm6
pxor xmm1, xmm1
mov edx, 1
movsd xmm5, cs:qword_2068
nop dword ptr [rax+rax+00h]
loc_1370:
xor eax, eax
movapd xmm0, xmm5
test dl, 1
jz short loc_1390
mov eax, ... | __int128 __usercall func0@<xmm0>(double *a1@<rdi>, int a2@<esi>)
{
double v2; // xmm3_8
long long v3; // rdx
int v4; // eax
double v5; // xmm0_8
double v6; // xmm0_8
__int128 v7; // xmm1
long long v8; // rdx
double v9; // xmm4_8
double v10; // xmm0_8
int v11; // eax
double v12; // xmm2_8
long lo... | func0:
ENDBR64
MOVSD XMM6,qword ptr [RDI]
MOV ECX,ESI
CMP ESI,0x1
JLE 0x001014c9
MOV R8D,ESI
MOVAPD XMM3,XMM6
PXOR XMM1,XMM1
MOV EDX,0x1
MOVSD XMM5,qword ptr [0x00102068]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101370:
XOR EAX,EAX
MOVAPD XMM0,XMM5
TEST DL,0x1
JZ 0x00101390
MOV EAX,0x1
PXOR XMM0,XMM0
CMP EAX,EDX
JZ 0x001013... | double func0(double *param_1,uint param_2)
{
double *pdVar1;
double dVar2;
int iVar3;
int iVar4;
ulong uVar5;
double dVar6;
double dVar7;
double dVar8;
double dVar9;
dVar2 = *param_1;
dVar8 = dVar2;
if (1 < (int)param_2) {
uVar5 = 1;
do {
iVar3 = 0;
dVar6 = DAT_00102068;
... |
787 | func0 | #include <stdio.h>
#include <math.h>
| double func0(const double *xs, int size) {
double ans = 0.0;
double value, driv, x_pow;
int i;
value = xs[0];
for (i = 1; i < size; i++) {
x_pow = 1.0;
for (int j = 0; j < i; j++) {
x_pow *= ans;
}
value += xs[i] * x_pow;
}
while (fabs(value) > 1... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
double evaluate_polynomial(const double *coeffs, int size, double x) {
double result = 0.0;
double term = 1.0;
for (int i = 0; i < size; i++) {
if (i > 0) {
term *= x;
}
result += coeffs[i] *... | O3 | c | func0:
endbr64
movsd (%rdi),%xmm8
mov %esi,%r10d
cmp $0x1,%esi
jle 1589 <func0+0x189>
lea -0x2(%rsi),%ecx
movapd %xmm8,%xmm3
mov $0x1,%edx
movsd 0xc5e(%rip),%xmm5
add $0x2,%rcx
pxor %xmm6,%xmm6
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
movapd %xmm5,%xmm0
xchg %ax,%ax
mulsd %xmm6,%xmm0
add $0x... | func0:
endbr64
mov rcx, rdi
mov edi, esi
movsd xmm7, qword ptr [rcx]
cmp esi, 1
jle loc_15A9
mov esi, esi
movapd xmm2, xmm7
pxor xmm1, xmm1
mov edx, 1
movsd xmm5, cs:qword_2068
nop dword ptr [rax]
loc_1440:
xor eax, eax
movapd xmm0, xmm5
test dl, 1
jz short loc_1460
mov ... | __int128 __usercall func0@<xmm0>(double *a1@<rdi>, int a2@<esi>)
{
double v2; // xmm2_8
long long v3; // rdx
int v4; // eax
double v5; // xmm0_8
double v6; // xmm0_8
__int128 v7; // xmm1
long long v8; // rdx
double v9; // xmm4_8
int v10; // eax
double v11; // xmm0_8
double v12; // xmm3_8
long lo... | func0:
ENDBR64
MOV RCX,RDI
MOV EDI,ESI
MOVSD XMM7,qword ptr [RCX]
CMP ESI,0x1
JLE 0x001015a9
MOV ESI,ESI
MOVAPD XMM2,XMM7
PXOR XMM1,XMM1
MOV EDX,0x1
MOVSD XMM5,qword ptr [0x00102068]
NOP dword ptr [RAX]
LAB_00101440:
XOR EAX,EAX
MOVAPD XMM0,XMM5
TEST DL,0x1
JZ 0x00101460
MOV EAX,0x1
PXOR XMM0,XMM0
CMP EAX,EDX
JZ 0x0010... | double func0(double *param_1,uint param_2)
{
double *pdVar1;
double dVar2;
int iVar3;
int iVar4;
ulong uVar5;
double dVar6;
double dVar7;
double dVar8;
double dVar9;
dVar2 = *param_1;
dVar8 = dVar2;
if (1 < (int)param_2) {
uVar5 = 1;
do {
iVar3 = 0;
dVar6 = DAT_00102068;
... |
788 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k ... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int te... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov %edx,%esi
sub %eax,%esi
mov %esi,%eax
add $0x1,%eax
cltq
shl ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov eax, [rbp+var_2C]
movsxd rdx, eax
imul rdx, 55555556h
shr rdx, 20h
sar eax, 1Fh
sub edx, eax
lea eax, [rdx+1]
cdqe
shl rax, 2
mov rdi, rax; size
... | void func0(long long a1, int a2, long long a3)
{
int v3; // eax
int i; // [rsp+24h] [rbp-1Ch]
int j; // [rsp+24h] [rbp-1Ch]
int m; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+28h] [rbp-18h]
int v9; // [rsp+2Ch] [rbp-14h]
int v10; // [rsp+30h] [rbp-10h]
int v11; // [rsp+34h] [rbp-Ch]
_DWORD *ptr; // [rsp+38... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
SHR RDX,0x20
SAR EAX,0x1f
SUB EDX,EAX
LEA EAX,[RDX + 0x1]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
M... | void func0(long param_1,int param_2,long param_3)
{
int4 uVar1;
void *__ptr;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
__ptr = malloc((long)(param_2 / 3 + 1) << 2);
local_1c = 0;
for (local_24 = 0; local_24 * 3 < param_2; local_24 = local_24 + 1) {
*(int4 *)((long)__ptr + (lo... |
789 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k ... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int te... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
mov %rdx,%r12
movslq %esi,%rdi
imul $0x55555556,%rdi,%rdi
shr $0x20,%rdi
mov %esi,%eax
sar $0x1f,%eax
sub %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@pl... | func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
mov r12, rdx
movsxd rdi, esi
imul rdi, 55555556h
shr rdi, 20h
mov eax, esi
sar eax, 1Fh
sub edi, eax
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jl... | void func0(long long a1, int a2, long long a3)
{
_DWORD *v5; // rax
_DWORD *v6; // rdi
_DWORD *v7; // rcx
long long v8; // rax
int v9; // edx
int v10; // r9d
long long v11; // r8
int v12; // edx
long long v13; // rax
int v14; // ecx
_DWORD *v15; // rax
int v16; // eax
long long i; // rdx
v... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
MOV R12,RDX
MOVSXD RDI,ESI
IMUL RDI,RDI,0x55555556
SHR RDI,0x20
MOV EAX,ESI
SAR EAX,0x1f
SUB EDI,EAX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x001012db
MOV RCX,RAX
MOV EAX,0x0
MOV EDX,0x0
LAB_00101215:
MOV ESI,... | void func0(long param_1,int param_2,long param_3)
{
int4 uVar1;
int4 *__ptr;
long lVar2;
ulong uVar3;
int4 *puVar4;
int iVar5;
int iVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
__ptr = (int4 *)malloc((long)(param_2 / 3 + 1) << 2);
if (0 < param_2) {
lVar2 = 0;
puVar4 = __ptr;
iVa... |
790 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k ... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int te... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
imul $0x55555556,%rdi,%rdi
mov %r12d,%eax
sar $0x1f,%eax
shr $0x20,%rdi
sub %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
m... | func0:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov eax, r12d
mov rbp, rdx
push rbx
mov rbx, rdi
imul rdi, r12, 55555556h
sar eax, 1Fh
shr rdi, 20h
sub rsp, 8
sub edi, eax
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
tes... | void func0(long long a1, int a2, long long a3)
{
long long v3; // r12
_DWORD *v6; // rax
_DWORD *v7; // rdi
_DWORD *v8; // rdx
long long v9; // rax
int v10; // ecx
int v11; // esi
int v12; // r9d
long long v13; // r8
int v14; // edx
long long v15; // r10
long long v16; // rax
int v17; // ecx
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV EAX,R12D
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
IMUL RDI,R12,0x55555556
SAR EAX,0x1f
SHR RDI,0x20
SUB RSP,0x8
SUB EDI,EAX
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV RDI,RAX
TEST R12D,R12D
JLE 0x00101698
MOV RDX,RAX
MOV R13,R12
XOR EAX,EAX
XOR ECX,EC... | void func0(long param_1,int param_2,long param_3)
{
ulong uVar1;
long lVar2;
int4 uVar3;
int4 *__ptr;
long lVar4;
ulong uVar5;
ulong uVar6;
int iVar7;
int4 *puVar8;
ulong uVar9;
int iVar10;
__ptr = (int4 *)malloc((long)(param_2 / 3 + 1) << 2);
if (0 < param_2) {
lVar4 = 0;
puVar8 =... |
791 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *l, int size, int *out) {
int *third = malloc((size / 3 + 1) * sizeof(int));
int i, k = 0, third_size = 0;
for (i = 0; i * 3 < size; i++) {
third[i] = l[i * 3];
third_size++;
}
for (i = 0; i < third_size - 1; i++) {
int min_idx = i;
for (k = i + 1; k ... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 2, 3};
int result1[3];
func0(test1, 3, result1);
assert(issame(result1, result1, 3));
int te... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdx,%r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
imul $0x55555556,%rdi,%rdi
mov %r12d,%eax
sar $0x1f,%eax
sub $0x8,%rsp
shr $0x20,%rdi
sub %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%r... | func0:
endbr64
push r15
push r14
push r13
movsxd r13, esi
push r12
mov eax, r13d
mov r12, rdx
push rbp
mov rbp, rdi
imul rdi, r13, 55555556h
sar eax, 1Fh
push rbx
shr rdi, 20h
sub edi, eax
sub rsp, 8
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
m... | void func0(const __m128i *a1, int a2, long long a3)
{
long long v3; // r13
__m128 *v6; // r10
long long v7; // rdx
unsigned long long v8; // rcx
unsigned int v9; // esi
const __m128i *v10; // rax
__m128 *v11; // rdx
__m128 *v12; // rcx
__m128 v13; // xmm2
__m128 v14; // xmm1
__m128 v15; // xmm0
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV EAX,R13D
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
IMUL RDI,R13,0x55555556
SAR EAX,0x1f
PUSH RBX
SHR RDI,0x20
SUB EDI,EAX
SUB RSP,0x8
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R10,RAX
TEST R13D,R13D
JLE 0x00101789
LEA EAX,[R13 + -0x1]
MOV ECX... | void func0(int *param_1,int param_2,long param_3)
{
int iVar1;
uint uVar2;
uint uVar3;
int *__ptr;
int *piVar4;
int *piVar5;
ulong uVar6;
uint uVar7;
int iVar8;
int *piVar9;
int iVar10;
uint uVar11;
uint uVar12;
uint uVar13;
__ptr = (int *)malloc((long)(param_2 / 3 + 1) << 2);
if (pa... |
792 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l, int size, int *out_size) {
int *out = malloc(size * sizeof(int));
int found, out_count = 0, i, j;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < out_count; j++) {
if (l[i] == out[j]) {
found = 1;
break;
}
... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int main() {
int test_array[] = {5, 3, 5, 2, 3, 3, 9, 0, 123};
int expected_array[] = {0, 2, 3, 5, 9, 123};
int unique_size;
int *unique_array = func0(test_array, sizeof(test_array) / sizeof(test_array[0]), &unique_size);
assert(unique_siz... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 129a <func0+0xd1>
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_129A
loc_12... | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+24h] [rbp-1Ch]
int v7; // [rsp+28h] [rbp-18h]
int i; // [rsp+2Ch] [rbp-14h]
int k; // [rsp+2Ch] [rbp-14h]
int j; // [rsp+30h] [rbp-10h]
int m; // [rsp+30h] [rbp-10h]
int v12; // [rsp+34h] [rbp-Ch]
_DWORD *v13; // [rsp+38... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP... | void * func0(long param_1,int param_2,int *param_3)
{
int4 uVar1;
bool bVar2;
void *pvVar3;
int4 local_20;
int4 local_1c;
int4 local_18;
pvVar3 = malloc((long)param_2 << 2);
local_20 = 0;
local_1c = 0;
do {
if (param_2 <= local_1c) {
for (local_1c = 0; local_18 = local_1c, local_1c < l... |
793 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l, int size, int *out_size) {
int *out = malloc(size * sizeof(int));
int found, out_count = 0, i, j;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < out_count; j++) {
if (l[i] == out[j]) {
found = 1;
break;
}
... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int main() {
int test_array[] = {5, 3, 5, 2, 3, 3, 9, 0, 123};
int expected_array[] = {0, 2, 3, 5, 9, 123};
int unique_size;
int *unique_array = func0(test_array, sizeof(test_array) / sizeof(test_array[0]), &unique_size);
assert(unique_siz... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 1249 <func0+0x80>
mov %r12,%rdi
lea -0x1(%rbp),%edx
lea 0x4(%r12,%rdx,4),%r9
mov $0x0,%r8d
lea 0x4(%rax),%r10
jmp 126... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12d, esi
mov rbx, rdx
movsxd r13, esi
shl r13, 2
mov rdi, r13; size
call _malloc
mov r10, rax
test r12d, r12d
jle loc_129E
mov rsi, rbp
lea rdi, [rbp+r13+0]
mov r9d, 0
jmp s... | _DWORD * func0(_DWORD *a1, int a2, int *a3)
{
size_t v4; // r13
_DWORD *v5; // r10
_DWORD *v6; // rsi
int v7; // r9d
_DWORD *v8; // rax
_DWORD *v9; // rsi
long long i; // r8
_DWORD *v11; // rax
int v12; // edx
v4 = a2;
v5 = malloc(v4 * 4);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v6 = ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12D,ESI
MOV RBX,RDX
MOVSXD R13,ESI
SHL R13,0x2
MOV RDI,R13
CALL 0x001010d0
MOV R10,RAX
TEST R12D,R12D
JLE 0x0010129e
MOV RSI,RBP
LEA RDI,[RBP + R13*0x1]
MOV R9D,0x0
JMP 0x00101221
LAB_0010120b:
MOVSXD RAX,R9D
MOV EDX,dword ptr [RSI]
MOV dwo... | int * func0(int *param_1,int param_2,uint *param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
uint uVar6;
piVar3 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
uVar6 = 0;
}
else {
piVar2 = param_1 + param_2;
uVar6 = 0;
do {
if (0 < (int)uVar6)... |
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.