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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
994 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int N) {
char str[6];
sprintf(str, "%d", N);
int sum = 0;
for (int i = 0; str[i] != '\0'; i++)
sum += str[i] - '0';
char* bi = malloc(33);
int index = 0;
if (sum == 0) {
bi[index++] = '0';
} else {
while (sum > 0) {
bi[index++] = (sum % 2)... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0(1000);
assert(strcmp(result, "1") == 0);
free(result);
result = func0(150);
assert(strcmp(result, "110") == 0);
free(result);
result = func0(147);
assert(strcmp(result, "1100") == 0);
free(resul... | O2 | c | func0:
endbr64
push %rbx
mov %edi,%r8d
lea 0xc95(%rip),%rcx
mov $0x6,%edx
mov $0x1,%esi
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rbx
mov %rbx,%rdi
callq 10d0 <__sprintf_chk@plt>
movsbl 0x2(%rsp),%eax
test %al,%al
je 1450 <func0+0xf0>
mov ... | func0:
endbr64
push rbx
mov r8d, edi
lea rcx, unk_2004
mov edx, 6
mov esi, 2
sub rsp, 10h
mov rax, fs:28h
mov [rsp+18h+var_10], rax
xor eax, eax
lea rbx, [rsp+18h+var_16]
mov rdi, rbx
call ___sprintf_chk
movsx eax, [rsp+18h+var_16]
test al, al
jz loc_1438
mov ... | _WORD * func0(unsigned int a1)
{
int v1; // eax
_BYTE *v2; // rdx
int v3; // ebx
_WORD *result; // rax
long long v5; // rdx
int v6; // r8d
long long v7; // rcx
int v8; // r8d
char *v9; // rdx
char *v10; // rcx
char *v11; // r8
char v12; // di
char v13; // si
_BYTE v14[6]; // [rsp+2h] [rbp-16... | func0:
ENDBR64
PUSH RBX
MOV R8D,EDI
LEA RCX,[0x102004]
MOV EDX,0x6
MOV ESI,0x2
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RBX,[RSP + 0x2]
MOV RDI,RBX
CALL 0x001010f0
MOVSX EAX,byte ptr [RSP + 0x2]
TEST AL,AL
JZ 0x00101438
MOV RDX,RBX
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_001013... | void func0(int4 param_1)
{
int uVar1;
long lVar2;
int2 *puVar3;
int *puVar4;
char *pcVar5;
long lVar6;
int2 *puVar7;
int2 *puVar8;
int iVar9;
long in_FS_OFFSET;
char local_16;
char local_15 [5];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = &local_16;
__sprintf_c... |
995 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int N) {
char str[6];
sprintf(str, "%d", N);
int sum = 0;
for (int i = 0; str[i] != '\0'; i++)
sum += str[i] - '0';
char* bi = malloc(33);
int index = 0;
if (sum == 0) {
bi[index++] = '0';
} else {
while (sum > 0) {
bi[index++] = (sum % 2)... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0(1000);
assert(strcmp(result, "1") == 0);
free(result);
result = func0(150);
assert(strcmp(result, "110") == 0);
free(result);
result = func0(147);
assert(strcmp(result, "1100") == 0);
free(resul... | O3 | c | func0:
endbr64
push %rbx
mov %edi,%r8d
lea 0xc95(%rip),%rcx
mov $0x6,%edx
mov $0x1,%esi
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rdi
callq 10d0 <__sprintf_chk@plt>
movsbl 0x2(%rsp),%ebx
test %bl,%bl
je 1470 <func0+0x110>
movsbl 0x3(%rsp),%eax
s... | func0:
endbr64
push rbx
mov r8d, edi
lea rcx, unk_2004
mov edx, 6
mov esi, 2
sub rsp, 10h
mov rax, fs:28h
mov [rsp+18h+var_10], rax
xor eax, eax
lea rdi, [rsp+18h+var_16]
call ___sprintf_chk
movsx ebx, [rsp+18h+var_16]
test bl, bl
jz loc_1450
movsx eax, [rsp+18h+var... | _WORD * func0(unsigned int a1)
{
int v1; // ebx
_WORD *result; // rax
long long v3; // rdx
int v4; // r8d
long long v5; // rcx
int v6; // r8d
char *v7; // rdx
char *v8; // rcx
char *v9; // r8
char v10; // di
char v11; // si
char v12; // [rsp+2h] [rbp-16h] BYREF
char v13; // [rsp+3h] [rbp-15h]
... | func0:
ENDBR64
PUSH RBX
MOV R8D,EDI
LEA RCX,[0x102004]
MOV EDX,0x6
MOV ESI,0x2
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x2]
CALL 0x001010f0
MOVSX EBX,byte ptr [RSP + 0x2]
TEST BL,BL
JZ 0x00101450
MOVSX EAX,byte ptr [RSP + 0x3]
SUB EBX,0x30
TEST AL,AL
JZ 0x001013... | void func0(int4 param_1)
{
int uVar1;
long lVar2;
int2 *puVar3;
int *puVar4;
long lVar5;
int2 *puVar6;
int2 *puVar7;
int iVar8;
long in_FS_OFFSET;
char local_16;
char local_15;
char local_14;
char local_13;
char local_12;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__... |
996 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
} | #include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / s... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ce <func0+0x65>
mov -0x4(%rbp),%eax
add %eax,%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11CE
loc_1188:
mov eax, [rbp+var_4]
add eax, eax
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [r... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; a2 > 2 * i + 1; ++i )
{
if ( (*(_DWORD *)(4 * (2 * i + 1LL) + a1) & 1) == 0 )
v3 += *(_DWORD *)(4 * (2 * i + 1LL) + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ce
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c * 2 + 1 < param_2; local_c = local_c + 1) {
if ((*(uint *)(param_1 + ((long)(local_c * 2) + 1) * 4) & 1) == 0) {
local_10 = local_10 + *(int *)(param_1 + ((long)(local_c * 2) + 1) * 4);
}... |
997 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
} | #include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / s... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 119e <func0+0x35>
lea 0x4(%rdi),%rax
sub $0x2,%esi
shr %esi
mov %esi,%esi
lea 0xc(%rdi,%rsi,8),%rdi
mov $0x0,%edx
mov (%rax),%ecx
lea (%rdx,%rcx,1),%esi
test $0x1,%cl
cmove %esi,%edx
add $0x8,%rax
cmp %rdi,%rax
jne 1187 <func0+0x1e>
mov %edx,... | func0:
endbr64
cmp esi, 1
jle short loc_119E
lea rax, [rdi+4]
sub esi, 2
shr esi, 1
mov esi, esi
lea rdi, [rdi+rsi*8+0Ch]
mov edx, 0
loc_1187:
mov ecx, [rax]
lea esi, [rdx+rcx]
test cl, 1
cmovz edx, esi
add rax, 8
cmp rax, rdi
jnz short loc_1187
loc_119B:
mov ... | long long func0(long long a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rdi
unsigned int v4; // edx
if ( a2 <= 1 )
{
return 0;
}
else
{
v2 = (_DWORD *)(a1 + 4);
v3 = a1 + 8LL * ((unsigned int)(a2 - 2) >> 1) + 12;
v4 = 0;
do
{
if ( (*v2 & 1) == 0 )
v4 += *v2;
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010119e
LEA RAX,[RDI + 0x4]
SUB ESI,0x2
SHR ESI,0x1
MOV ESI,ESI
LEA RDI,[RDI + RSI*0x8 + 0xc]
MOV EDX,0x0
LAB_00101187:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
TEST CL,0x1
CMOVZ EDX,ESI
ADD RAX,0x8
CMP RAX,RDI
JNZ 0x00101187
LAB_0010119b:
MOV EAX,EDX
RET
LAB_0010119e:
MOV EDX,0... | int func0(long param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (param_2 < 2) {
iVar2 = 0;
}
else {
puVar1 = (uint *)(param_1 + 4);
iVar2 = 0;
do {
if ((*puVar1 & 1) == 0) {
iVar2 = iVar2 + *puVar1;
}
puVar1 = puVar1 + 2;
} while (puVar1 != (uint *)(param_1 ... |
998 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
} | #include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / s... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1180 <func0+0x40>
sub $0x2,%esi
lea 0x4(%rdi),%rax
xor %r8d,%r8d
shr %esi
lea 0xc(%rdi,%rsi,8),%rsi
nopw 0x0(%rax,%rax,1)
mov (%rax),%edx
lea (%r8,%rdx,1),%ecx
and $0x1,%edx
cmove %ecx,%r8d
add $0x8,%rax
cmp %rsi,%rax
jne 1160 <func0+0x20>
mov ... | func0:
endbr64
cmp esi, 1
jle short loc_1300
sub esi, 2
lea rax, [rdi+4]
xor edx, edx
shr esi, 1
lea rdi, [rdi+rsi*8+0Ch]
nop dword ptr [rax+00000000h]
loc_12E0:
mov ecx, [rax]
lea esi, [rdx+rcx]
and ecx, 1
cmovz edx, esi
add rax, 8
cmp rdi, rax
jnz short loc_12... | long long func0(long long a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
long long v4; // rdi
if ( a2 <= 1 )
return 0LL;
v2 = (_DWORD *)(a1 + 4);
v3 = 0;
v4 = a1 + 8LL * ((unsigned int)(a2 - 2) >> 1) + 12;
do
{
if ( (*v2 & 1) == 0 )
v3 += *v2;
v2 += 2;
}
while ( (_DWO... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101300
SUB ESI,0x2
LEA RAX,[RDI + 0x4]
XOR EDX,EDX
SHR ESI,0x1
LEA RDI,[RDI + RSI*0x8 + 0xc]
NOP dword ptr [RAX]
LAB_001012e0:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
AND ECX,0x1
CMOVZ EDX,ESI
ADD RAX,0x8
CMP RDI,RAX
JNZ 0x001012e0
MOV EAX,EDX
RET
LAB_00101300:
XOR EDX,EDX
MOV... | int func0(long param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (1 < param_2) {
puVar1 = (uint *)(param_1 + 4);
iVar2 = 0;
do {
if ((*puVar1 & 1) == 0) {
iVar2 = iVar2 + *puVar1;
}
puVar1 = puVar1 + 2;
} while ((uint *)(param_1 + 0xc + (ulong)(param_2 - 2U >> 1) * 8... |
999 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int sum = 0;
for (int i = 0; i * 2 + 1 < size; i++)
if (lst[i * 2 + 1] % 2 == 0) sum += lst[i * 2 + 1];
return sum;
} | #include <assert.h>
int main() {
int array1[] = {4, 88};
assert(func0(array1, sizeof(array1) / sizeof(array1[0])) == 88);
int array2[] = {4, 5, 6, 7, 2, 122};
assert(func0(array2, sizeof(array2) / sizeof(array2[0])) == 122);
int array3[] = {4, 0, 6, 7};
assert(func0(array3, sizeof(array3) / s... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1240 <func0+0x100>
lea -0x2(%rsi),%edx
cmp $0x7,%edx
jbe 1243 <func0+0x103>
shr $0x3,%edx
pxor %xmm2,%xmm2
movdqa 0xea8(%rip),%xmm4
mov %rdi,%rax
mov %edx,%ecx
movdqa %xmm2,%xmm3
shl $0x5,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu 0x4(%rax),%xmm1
m... | func0:
endbr64
mov rcx, rdi
cmp esi, 1
jle loc_1238
lea edi, [rsi-2]
cmp edi, 7
jbe loc_123B
shr edi, 3
pxor xmm2, xmm2
movdqa xmm4, cs:xmmword_2010
mov rax, rcx
mov edx, edi
movdqa xmm3, xmm2
shl rdx, 5
add rdx, rcx
nop dword ptr [rax+rax+00h]
loc_1180:
movdqu xmm1... | long long func0(long long a1, int a2)
{
unsigned int v3; // edi
__m128i v4; // xmm2
__m128i si128; // xmm4
long long v6; // rax
__m128 v7; // xmm1
__m128 v8; // xmm5
__m128i v9; // xmm1
int v10; // r8d
int v11; // edx
__m128i v12; // xmm2
long long result; // rax
int v14; // edx
unsigned int ... | func0:
ENDBR64
MOV RCX,RDI
CMP ESI,0x1
JLE 0x00101238
LEA EDI,[RSI + -0x2]
CMP EDI,0x7
JBE 0x0010123b
SHR EDI,0x3
PXOR XMM2,XMM2
MOVDQA XMM4,xmmword ptr [0x00102010]
MOV RAX,RCX
MOV EDX,EDI
MOVDQA XMM3,XMM2
SHL RDX,0x5
ADD RDX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM1,xmmword ptr [RAX + 0x4]
MOVDQU XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(long param_1,int param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
long lVar5;
int iVar6;
uint uVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if (param_2 < 2) ... |
1,000 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = ... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x4c(%rbp)
mov -0x4c(%rbp),%eax
add $0x2,%eax
cltq
mov %rax,%rdi
callq ... | func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4C], eax
mov eax, [rbp+var_4C]
add eax, 2
cdqe
mov rdi, rax; size
call _... | _BYTE * func0(const char *a1)
{
int v1; // eax
int v2; // eax
int v3; // eax
char v5; // [rsp+1Bh] [rbp-65h]
int v6; // [rsp+1Ch] [rbp-64h]
int v7; // [rsp+20h] [rbp-60h]
int i; // [rsp+24h] [rbp-5Ch]
int j; // [rsp+28h] [rbp-58h]
int k; // [rsp+2Ch] [rbp-54h]
int m; // [rsp+30h] [rbp-50h]
int v12... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x78],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x4c],EAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x2
CDQE
MOV RDI,RAX
CALL 0x001010f... | void * func0(char *param_1)
{
char cVar1;
size_t sVar2;
void *pvVar3;
long in_FS_OFFSET;
int local_6c;
int local_68;
int local_64;
int local_60;
int local_5c;
int local_58;
char acStack_48 [56];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar2 = strlen(param_1);
pvVar3 =... |
1,001 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = ... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
lea 0x1(%rcx),%edi
movslq %edi,%rdi
callq... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 40h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
call _strlen
mov rbx, rax
lea edi, [rax+2]
movsxd rdi, edi; size
call _malloc
mov r11, rax
test ebx, ebx
js loc_12AD
... | _BYTE * func0(const char *a1)
{
int v1; // ebx
_BYTE *v2; // r11
const char *v3; // r10
long long v4; // rbp
int v5; // r9d
int v6; // ebx
char *v7; // rsi
int v8; // r14d
int v9; // r8d
char *v10; // rax
char v11; // dl
char v12; // cl
long long v14; // rax
_BYTE v15[56]; // [rsp+0h] [rbp-6... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x001010b0
MOV RBX,RAX
LEA EDI,[RAX + 0x2]
MOVSXD RDI,EDI
CALL 0x001010f0
MOV R11,RAX
TEST EBX,EBX
JS 0x001012ad
MOV R10,RBP
MOV EBX,EBX
LEA RBP,[RBP + RBX*0x1... | void * func0(byte *param_1)
{
byte *pbVar1;
char cVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
long lVar6;
long lVar7;
int iVar8;
byte *pbVar9;
int iVar10;
int iVar11;
long in_FS_OFFSET;
byte local_68 [56];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen((... |
1,002 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = ... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
callq 10a0 <strlen@plt>
lea 0x2(%rax),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r10
test %ebx,%ebx
js 15... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
call _strlen
lea edi, [rax+2]
mov rbx, rax
movsxd rdi, edi; size
call _malloc
mov r14, rax
test ebx, ebx
js ... | _BYTE * func0(const char *a1)
{
const char *v1; // rbp
int v2; // ebx
_BYTE *v3; // rax
_BYTE *v4; // r14
int v5; // r12d
long long v6; // r13
int v7; // ebx
long long v8; // rdx
char *v9; // rsi
int v10; // r11d
int v11; // r8d
char *v12; // rax
char v13; // dl
char v14; // cl
long long v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x001010c0
LEA EDI,[RAX + 0x2]
MOV RBX,RAX
MOVSXD RDI,EDI
CALL 0x00101110
MOV R14,RAX
TEST EBX,EBX
JS 0x0010153a
MOV EBX,EBX
XOR R12D,R12D
MOV R15,RSP... | int * func0(byte *param_1)
{
int iVar1;
byte *pbVar2;
char cVar3;
size_t sVar4;
int *puVar5;
char *pcVar6;
long lVar7;
int *puVar8;
ulong __n;
uint uVar9;
byte *pbVar10;
int iVar11;
int iVar12;
long in_FS_OFFSET;
byte local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET ... |
1,003 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char* func0(const char* s) {
int len = strlen(s);
char* out = malloc(len + 2);
char current[51];
int out_index = 0, current_index = 0;
for (int i = 0; i <= len; i++) {
if (s[i] == ' ' || s[i] == '\0') {
for (int j = 0; j < current_index - 1; j++) {
for (int k = ... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0("Hi");
assert(strcmp(result, "Hi") == 0);
free(result);
result = func0("hello");
assert(strcmp(result, "ehllo") == 0);
free(result);
result = func0("number");
assert(strcmp(result, "bemnru") == 0);
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
callq 10b0 <strlen@plt>
lea 0x2(%rax),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r14
test %ebx,%e... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
call _strlen
lea edi, [rax+2]
mov rbx, rax
movsxd rdi, edi; size
call _malloc
mov r14, rax
test ebx, ebx
js ... | _BYTE * func0(const char *a1)
{
const char *v1; // rbp
int v2; // ebx
_BYTE *v3; // rax
_BYTE *v4; // r14
int v5; // r12d
long long v6; // r13
int v7; // ebx
long long v8; // rdx
char *v9; // rsi
int v10; // r11d
int v11; // r8d
char *v12; // rax
char v13; // dl
char v14; // cl
long long v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x001010c0
LEA EDI,[RAX + 0x2]
MOV RBX,RAX
MOVSXD RDI,EDI
CALL 0x00101110
MOV R14,RAX
TEST EBX,EBX
JS 0x0010153a
MOV EBX,EBX
XOR R12D,R12D
MOV R15,RSP... | int * func0(byte *param_1)
{
int iVar1;
byte *pbVar2;
char cVar3;
size_t sVar4;
int *puVar5;
char *pcVar6;
long lVar7;
int *puVar8;
ulong __n;
uint uVar9;
byte *pbVar10;
int iVar11;
int iVar12;
long in_FS_OFFSET;
byte local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET ... |
1,004 | func0 | #include <stdio.h>
#include <stdlib.h>
| int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)mal... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %ecx,-0x40(%rbp)
mov %r8,-0x50(%rbp)
mov $0x320,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 12a9... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_40], ecx
mov [rbp+var_50], r8
mov edi, 320h; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp ... | _QWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v9; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int j; // [rsp+34h] [rbp-1Ch]
_QWORD *v12; // [rsp+38h] [rbp-18h]
v12 = malloc(0x320uLL);
v9 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = *(_DWORD *)(4LL * i + a3) - ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x40],ECX
MOV qword ptr [RBP + -0x50],R8
MOV EDI,0x320
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword... | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
void *pvVar1;
void *pvVar2;
int4 local_2c;
int4 local_28;
int4 local_24;
pvVar1 = malloc(800);
local_2c = 0;
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
local_24 = *(int *)(param_3 + (long)local_... |
1,005 | func0 | #include <stdio.h>
#include <stdlib.h>
| int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)mal... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r12
mov %esi,%ebx
mov %rdx,0x18(%rsp)
mov %ecx,%r13d
mov %r8,0x28(%rsp)
mov $0x320,%edi
callq 10b0 <malloc@plt>
mov %rax,0x10(%rsp)
test %ebx,%ebx
jle 1269 <func0+0xc0>
lea -0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r12, rdi
mov ebx, esi
mov [rsp+68h+var_50], rdx
mov r13d, ecx
mov [rsp+68h+var_40], r8
mov edi, 320h; size
call _malloc
mov [rsp+68h+var_58], rax
test ebx, ebx
jle loc_1269
m... | _QWORD * func0(_QWORD *a1, int a2, long long a3, int a4, _DWORD *a5)
{
long long v7; // r15
int v8; // r14d
_DWORD *v9; // rax
int v10; // ebx
long long v11; // rbp
_QWORD *v13; // [rsp+10h] [rbp-58h]
v13 = malloc(0x320uLL);
if ( a2 <= 0 )
{
v8 = 0;
}
else
{
v7 = 0LL;
v8 = 0;
do... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R12,RDI
MOV EBX,ESI
MOV qword ptr [RSP + 0x18],RDX
MOV R13D,ECX
MOV qword ptr [RSP + 0x28],R8
MOV EDI,0x320
CALL 0x001010b0
MOV qword ptr [RSP + 0x10],RAX
TEST EBX,EBX
JLE 0x00101269
MOVSXD RAX,EBX
MOV qword ptr [RSP + 0x20],RAX
MOV R... | void * func0(long *param_1,int param_2,long param_3,int param_4,int *param_5)
{
void *pvVar1;
int4 *puVar2;
int iVar3;
long lVar4;
int iVar5;
long lVar6;
pvVar1 = malloc(800);
if (param_2 < 1) {
iVar5 = 0;
}
else {
lVar6 = 0;
iVar5 = 0;
do {
iVar3 = *(int *)(param_3 + lVar6... |
1,006 | func0 | #include <stdio.h>
#include <stdlib.h>
| int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)mal... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %ecx,%r13d
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x38,%rsp
mov %rdi,0x20(%rsp)
mov $0x320,%edi
mov %rdx,0x10(%rsp)
mov %r8,0x28(%rsp)
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 1498 <func0+0xc8>
lea ... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, ecx
push rbp
push rbx
mov ebx, esi
sub rsp, 38h
mov [rsp+68h+var_48], rdi
mov edi, 320h; size
mov [rsp+68h+var_58], rdx
mov [rsp+68h+var_40], r8
call _malloc
mov [rsp+68h+var_60], rax
test ebx, ebx
jle ... | _QWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
long long v6; // r14
int v7; // r15d
int v8; // edx
long long v9; // rbp
long long v10; // r13
_DWORD *v11; // rax
long long v12; // rdi
_QWORD *v14; // [rsp+8h] [rbp-60h]
v14 = malloc(0x320uLL);
if ( a2 <= 0 )
{
v7 = 0;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ECX
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV EDI,0x320
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x28],R8
CALL 0x001010b0
MOV qword ptr [RSP + 0x8],RAX
TEST EBX,EBX
JLE 0x0010145a
MOVSXD RAX,EBX
XOR R14D,R14D
XOR ... | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
void *pvVar2;
int4 *puVar3;
int iVar4;
long lVar5;
long lVar6;
long lVar7;
int iVar8;
pvVar2 = malloc(800);
if (param_2 < 1) {
iVar8 = 0;
}
else {
lVar7 = 0;
iVar8 = 0;
do {
iVar4... |
1,007 | func0 | #include <stdio.h>
#include <stdlib.h>
| int **func0(int **lst, int lst_size, int *row_sizes, int x, int *return_size) {
int **out = (int **)malloc(100 * sizeof(int *));
int count = 0;
for (int i = 0; i < lst_size; i++) {
for (int j = row_sizes[i] - 1; j >= 0; j--) {
if (lst[i][j] == x) {
out[count] = (int *)mal... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int **a, int aSize, int **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i][0] != b[i][0] || a[i][1] != b[i][1]) return 0;
}
return 1;
}
void free_result(int **result, int size) {
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %ecx,%r13d
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x38,%rsp
mov %rdi,0x20(%rsp)
mov $0x320,%edi
mov %rdx,0x10(%rsp)
mov %r8,0x28(%rsp)
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebx,%ebx
jle 14a8 <func0+0xc8>
lea ... | func0:
endbr64
push r15
push r14
mov r14d, ecx
push r13
push r12
mov r12d, esi
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_48], rdi
mov edi, 320h; size
mov [rsp+68h+var_58], rdx
mov [rsp+68h+var_40], r8
call _malloc
mov [rsp+68h+var_60], rax
test r12d, r12d
jl... | _QWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v6; // r15d
long long i; // r12
int v8; // edx
long long v9; // rbp
long long v10; // r13
_DWORD *v11; // rax
long long v12; // rdi
_QWORD *v14; // [rsp+8h] [rbp-60h]
v14 = malloc(0x320uLL);
if ( a2 <= 0 )
{
v6 = 0;
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ECX
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV EDI,0x320
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x28],R8
CALL 0x001010b0
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x001013e7
MOVSXD RAX,R12D
XOR R15D,R15D
... | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
void *pvVar2;
int4 *puVar3;
int iVar4;
long lVar5;
long lVar6;
long lVar7;
int iVar8;
pvVar2 = malloc(800);
if (param_2 < 1) {
iVar8 = 0;
}
else {
iVar8 = 0;
lVar7 = 0;
do {
iVar4... |
1,008 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_arr... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &res... | 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 %rcx,-0x40(%rbp)
mov -0x40(%rbp),%rax
mov -0x2c(%rbp),%edx
mov %edx,(%rax)
cmpl $0x0,-0x2c(%rbp)
jne 1203 <func0+0x3a>
mov -0x38(%rbp),%rax
movq $0x0,(%rax)
jmp... | 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 [rbp+var_40], rcx
mov rax, [rbp+var_40]
mov edx, [rbp+var_2C]
mov [rax], edx
cmp [rbp+var_2C], 0
jnz short loc_1203
mov rax, [rbp+var_38]
mov qwo... | void ** func0(_DWORD *a1, int a2, void **a3, int *a4)
{
void **result; // rax
int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
int k; // [rsp+30h] [rbp-10h]
_BOOL4 v9; // [rsp+34h] [rbp-Ch]
int v10; // [rsp+38h] [rbp-8h]
int v11; // [rsp+3Ch] [rbp-4h]
*a4 = a2;
if ( a2 )
{
*a3 = mall... | 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 qword ptr [RBP + -0x40],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],EDX
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00101203
MOV RAX,... | void func0(int *param_1,int param_2,long *param_3,int *param_4)
{
int iVar1;
int iVar2;
int4 uVar3;
void *pvVar4;
int local_20;
int local_1c;
int local_18;
*param_4 = param_2;
if (param_2 == 0) {
*param_3 = 0;
}
else {
pvVar4 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar4;
... |
1,009 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_arr... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &res... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdx,%rbx
mov %esi,(%rcx)
test %esi,%esi
jne 11f2 <func0+0x29>
movq $0x0,(%rdx)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %rdi,%r12
mov %esi,%ebp
movslq %esi,%r13
shl $0x2,%r13
mov ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdx
mov [rcx], esi
test esi, esi
jnz short loc_11F2
mov qword ptr [rdx], 0
loc_11E7:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_11F2:
mov r12, rdi
mov ebp, esi
movsxd r13, esi
... | void func0(_DWORD *a1, int a2, _QWORD *a3, int *a4)
{
size_t v6; // r13
void *v7; // rax
unsigned long long v8; // rax
int v9; // r9d
int v10; // r12d
long long v11; // rdi
long long v12; // r11
int v13; // r10d
int *v14; // rsi
int v15; // ecx
int v16; // edx
long long v17; // rax
int *v18; ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDX
MOV dword ptr [RCX],ESI
TEST ESI,ESI
JNZ 0x001011f2
MOV qword ptr [RDX],0x0
LAB_001011e7:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001011f2:
MOV R12,RDI
MOV EBP,ESI
MOVSXD R13,ESI
SHL R13,0x2
MOV RDI,R13
CALL 0x001010c0
MOV qword ptr ... | void func0(int *param_1,int param_2,long *param_3,int *param_4)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
void *pvVar6;
size_t sVar7;
long lVar8;
long lVar9;
int iVar10;
long lVar11;
size_t __size;
*param_4 = param_2;
if (param_2 == 0) {
*param_3 = 0;
}
else {
... |
1,010 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_arr... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &res... | O2 | c | func0:
endbr64
mov %esi,(%rcx)
test %esi,%esi
jne 1718 <func0+0x18>
movq $0x0,(%rdx)
retq
nopw 0x0(%rax,%rax,1)
jmpq 15d0 <func0.part.0>
nopl (%rax)
| func0_part_0:
push r14
mov r14, rdi
push r13
movsxd r13, esi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, r13
shl r13, 2
mov rdi, r13; size
call _malloc
mov [rbp+0], rax
test rax, rax
jz loc_165D
test ebx, ebx
jle loc_1627
mov ebp, ebx
mov rsi, r14; ... | int * func0_part_0(char *src, int a2, int **a3)
{
size_t v5; // r13
int *result; // rax
int v7; // r12d
char *v8; // r11
int v9; // r10d
int *v10; // rsi
long long v11; // r9
char *v12; // r11
int v13; // edx
int v14; // ecx
int *v15; // rdi
char *v16; // r8
v5 = 4LL * a2;
result = (int *)m... | func0.part.0:
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ESI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,R13
SHL R13,0x2
MOV RDI,R13
CALL 0x001010e0
MOV qword ptr [RBP],RAX
TEST RAX,RAX
JZ 0x0010165d
TEST EBX,EBX
JLE 0x00101627
MOV EBP,EBX
MOV RSI,R14
LEA R12D,[RBX + -0x1]
MOV RDI,RAX
LEA RDX,[RBP*0x4]
CALL 0x001010d0... | void func0_part_0(int *param_1,uint param_2,int8 *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
void *pvVar4;
int *piVar5;
int iVar6;
int iVar7;
ulong uVar8;
int *piVar9;
ulong uVar10;
pvVar4 = malloc((long)(int)param_2 * 4);
*param_3 = pvVar4;
if (pvVar4 == (void *)0x0) {
... |
1,011 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *array, int size, int **out_array, int *out_size) {
*out_size = size;
if (size == 0) {
*out_array = NULL;
return;
}
*out_array = (int *)malloc(sizeof(int) * size);
if (*out_array == NULL) {
exit(1);
}
for (int i = 0; i < size; i++) {
(*out_arr... | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int *a, int aSize, int *b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result, result_size;
func0((const int[]){}, 0, &res... | O3 | c | func0:
endbr64
mov %esi,(%rcx)
test %esi,%esi
jne 16b8 <func0+0x18>
movq $0x0,(%rdx)
retq
nopw 0x0(%rax,%rax,1)
jmpq 1570 <func0.part.0>
nopl (%rax)
| func0_part_0:
push r14
mov r14, rdi
push r13
movsxd r13, esi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, r13
shl r13, 2
mov rdi, r13; size
call _malloc
mov [rbp+0], rax
test rax, rax
jz loc_1676
test ebx, ebx
jle loc_1614
mov ebp, ebx
mov rsi, r14; ... | long long func0_part_0(_DWORD *src, int a2, _QWORD *a3)
{
long long result; // rax
int v6; // r12d
char *v7; // rcx
long long v8; // rsi
long long v9; // r8
char *v10; // r9
int v11; // edx
int v12; // edx
result = (long long)malloc(4LL * a2);
*a3 = result;
if ( !result )
exit(1);
if ( a2 ... | func0.part.0:
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ESI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,R13
SHL R13,0x2
MOV RDI,R13
CALL 0x001010e0
MOV qword ptr [RBP],RAX
TEST RAX,RAX
JZ 0x00101676
TEST EBX,EBX
JLE 0x00101614
MOV EBP,EBX
MOV RSI,R14
LEA R12D,[RBX + -0x1]
MOV RDI,RAX
LEA RDX,[RBP*0x4]
CALL 0x001010d0... | void func0_part_0(int *param_1,uint param_2,int8 *param_3)
{
int iVar1;
void *pvVar2;
int *piVar3;
ulong uVar4;
int *piVar5;
ulong uVar6;
pvVar2 = malloc((long)(int)param_2 * 4);
*param_3 = pvVar2;
if (pvVar2 == (void *)0x0) {
/* WARNING: Subroutine does not return */
exit(... |
1,012 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
} | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f7 <func0+0x6e>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
lea -0x5d(%rax),%edx
movslq %edx,%rax
imul $0x4ec4ec4f,%rax... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_8], 0
jmp short loc_11F3
loc_11A2:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
lea edx, [rax-5Dh]
movsxd rax, edx... | _BYTE * func0(long long a1, long long a2)
{
_BYTE *result; // rax
int i; // [rsp+18h] [rbp-8h]
for ( i = 0; *(_BYTE *)(i + a1); ++i )
*(_BYTE *)(i + a2) = (*(char *)(i + a1) - 93) % 26 + 97;
result = (_BYTE *)(i + a2);
*result = 0;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f3
LAB_001011a2:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
LEA EDX,[RAX + -0x5d]
MOVSXD RAX... | void func0(long param_1,long param_2)
{
int iVar1;
int4 local_10;
for (local_10 = 0; *(char *)(param_1 + local_10) != '\0'; local_10 = local_10 + 1) {
iVar1 = *(char *)(param_1 + local_10) + -0x5d;
*(char *)(param_2 + local_10) = (char)iVar1 + (char)(iVar1 / 0x1a) * -0x1a + 'a';
}
*(int *)(param_2... |
1,013 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
} | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
... | O1 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 11b3 <func0+0x4a>
mov $0x0,%ecx
movsbl %al,%eax
sub $0x5d,%eax
movslq %eax,%rdx
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x23,%rdx
mov %eax,%r8d
sar $0x1f,%r8d
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%eax
add $0x61,%eax
mov %al,(%rsi,%rcx... | func0:
endbr64
mov r8, rdi
movzx eax, byte ptr [rdi]
test al, al
jz short loc_11D4
mov ecx, 0
loc_119C:
movsx eax, al
sub eax, 5Dh ; ']'
movsxd rdx, eax
imul rdx, 4EC4EC4Fh
sar rdx, 23h
mov edi, eax
sar edi, 1Fh
sub edx, edi
imul edx, 1Ah
sub eax, edx
add eax, 61h ... | long long func0(unsigned __int8 *a1, long long a2)
{
long long result; // rax
long long v3; // rcx
result = *a1;
if ( (_BYTE)result )
{
v3 = 0LL;
do
{
*(_BYTE *)(a2 + v3++) = ((char)result - 93) % 26 + 97;
result = a1[v3];
}
while ( (_BYTE)result );
}
else
{
v3 = 0L... | func0:
ENDBR64
MOV R8,RDI
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001011d4
MOV ECX,0x0
LAB_0010119c:
MOVSX EAX,AL
SUB EAX,0x5d
MOVSXD RDX,EAX
IMUL RDX,RDX,0x4ec4ec4f
SAR RDX,0x23
MOV EDI,EAX
SAR EDI,0x1f
SUB EDX,EDI
IMUL EDX,EDX,0x1a
SUB EAX,EDX
ADD EAX,0x61
MOV byte ptr [RSI + RCX*0x1],AL
ADD RCX,0x1
MOVZX EAX,byte p... | void func0(char *param_1,long param_2)
{
char cVar1;
long lVar2;
cVar1 = *param_1;
if (cVar1 == '\0') {
lVar2 = 0;
}
else {
lVar2 = 0;
do {
*(char *)(param_2 + lVar2) =
(char)(cVar1 + -0x5d) + (char)((cVar1 + -0x5d) / 0x1a) * -0x1a + 'a';
lVar2 = lVar2 + 1;
cVar1... |
1,014 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
} | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
... | O2 | c | func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 1575 <func0+0x45>
xor %ecx,%ecx
nopl (%rax)
sub $0x5d,%eax
movslq %eax,%rdx
mov %eax,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%eax
add $0x61,%eax
mov %al,(%rsi,%rcx,1... | func0:
endbr64
movsx eax, byte ptr [rdi]
mov r8, rdi
test al, al
jz short loc_1423
xor ecx, ecx
loc_13F0:
sub eax, 5Dh ; ']'
movsxd rdx, eax
mov edi, eax
imul rdx, 4EC4EC4Fh
sar edi, 1Fh
sar rdx, 23h
sub edx, edi
imul edx, 1Ah
sub eax, edx
add eax, 61h ; 'a'
mov ... | long long func0(_BYTE *a1, _BYTE *a2)
{
long long result; // rax
long long v3; // rcx
result = (unsigned int)(char)*a1;
if ( *a1 )
{
v3 = 0LL;
do
{
a2[v3++] = ((int)result - 93) % 26 + 97;
result = (unsigned int)(char)a1[v3];
}
while ( a1[v3] );
a2 += v3;
}
*a2 = 0;
... | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
MOV R8,RDI
TEST AL,AL
JZ 0x00101423
XOR ECX,ECX
LAB_001013f0:
SUB EAX,0x5d
MOVSXD RDX,EAX
MOV EDI,EAX
IMUL RDX,RDX,0x4ec4ec4f
SAR EDI,0x1f
SAR RDX,0x23
SUB EDX,EDI
IMUL EDX,EDX,0x1a
SUB EAX,EDX
ADD EAX,0x61
MOV byte ptr [RSI + RCX*0x1],AL
ADD RCX,0x1
MOVSX EAX,byte ptr [R8 + RCX*... | void func0(char *param_1,int *param_2)
{
char cVar1;
long lVar2;
cVar1 = *param_1;
if (cVar1 != '\0') {
lVar2 = 0;
do {
param_2[lVar2] = (char)(cVar1 + -0x5d) + (char)((cVar1 + -0x5d) / 0x1a) * -0x1a + 'a';
lVar2 = lVar2 + 1;
cVar1 = param_1[lVar2];
} while (cVar1 != '\0');
... |
1,015 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *s, char *out) {
int i;
for (i = 0; s[i] != '\0'; i++) {
int w = ((int)s[i] - 'a' + 4) % 26 + 'a';
out[i] = (char)w;
}
out[i] = '\0';
} | #include <stdio.h>
#include <string.h>
#include <assert.h>
int main() {
char encrypted[100]; // Buffer should be large enough to hold the encrypted string
func0("hi", encrypted);
assert(strcmp(encrypted, "lm") == 0);
func0("asdfghjkl", encrypted);
assert(strcmp(encrypted, "ewhjklnop") == 0);
... | O3 | c | func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 1575 <func0+0x45>
xor %ecx,%ecx
nopl (%rax)
sub $0x5d,%eax
movslq %eax,%rdx
mov %eax,%r8d
imul $0x4ec4ec4f,%rdx,%rdx
sar $0x1f,%r8d
sar $0x23,%rdx
sub %r8d,%edx
imul $0x1a,%edx,%edx
sub %edx,%eax
add $0x61,%eax
mov %al,(%rsi,%rcx,1... | func0:
endbr64
movsx eax, byte ptr [rdi]
mov r8, rdi
test al, al
jz short loc_1573
xor ecx, ecx
loc_1540:
sub eax, 5Dh ; ']'
movsxd rdx, eax
mov edi, eax
imul rdx, 4EC4EC4Fh
sar edi, 1Fh
sar rdx, 23h
sub edx, edi
imul edx, 1Ah
sub eax, edx
add eax, 61h ; 'a'
mov ... | long long func0(_BYTE *a1, _BYTE *a2)
{
long long result; // rax
long long v3; // rcx
result = (unsigned int)(char)*a1;
if ( *a1 )
{
v3 = 0LL;
do
{
a2[v3++] = ((int)result - 93) % 26 + 97;
result = (unsigned int)(char)a1[v3];
}
while ( a1[v3] );
a2 += v3;
}
*a2 = 0;
... | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
MOV R8,RDI
TEST AL,AL
JZ 0x00101573
XOR ECX,ECX
LAB_00101540:
SUB EAX,0x5d
MOVSXD RDX,EAX
MOV EDI,EAX
IMUL RDX,RDX,0x4ec4ec4f
SAR EDI,0x1f
SAR RDX,0x23
SUB EDX,EDI
IMUL EDX,EDX,0x1a
SUB EAX,EDX
ADD EAX,0x61
MOV byte ptr [RSI + RCX*0x1],AL
ADD RCX,0x1
MOVSX EAX,byte ptr [R8 + RCX*... | void func0(char *param_1,int *param_2)
{
char cVar1;
long lVar2;
cVar1 = *param_1;
if (cVar1 != '\0') {
lVar2 = 0;
do {
param_2[lVar2] = (char)(cVar1 + -0x5d) + (char)((cVar1 + -0x5d) / 0x1a) * -0x1a + 'a';
lVar2 = lVar2 + 1;
cVar1 = param_1[lVar2];
} while (cVar1 != '\0');
... |
1,016 | func0 | #include <stdio.h>
#include <limits.h>
| int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
... | #include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x1,-0x1c(%rbp)
jg 1188 <func0+0x1f>
mov $0xffffffff,%eax
jmpq 1250 <func0+0xe7>
movl $0x7fffffff,-0xc(%rbp)
movl $0x7fffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1231 <func0+0xc8>
mov -0x4(%rbp),%eax... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 1
jg short loc_1188
mov eax, 0FFFFFFFFh
jmp loc_1250
loc_1188:
mov [rbp+var_C], 7FFFFFFFh
mov [rbp+var_8], 7FFFFFFFh
mov [rbp+var_4], 0
jmp loc_1231
loc_11A2:
mov eax, [... | long long func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
if ( a2 <= 1 )
return 0xFFFFFFFFLL;
v3 = 0x7FFFFFFF;
v4 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( v3 <= *(_DWORD *)(4LL * i + a1) )
{
if ( v4 > *(_DW... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x1
JG 0x00101188
MOV EAX,0xffffffff
JMP 0x00101250
LAB_00101188:
MOV dword ptr [RBP + -0xc],0x7fffffff
MOV dword ptr [RBP + -0x8],0x7fffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101231
LAB_... | int func0(long param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
if (param_2 < 2) {
local_10 = -1;
}
else {
local_14 = 0x7fffffff;
local_10 = 0x7fffffff;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < local_14... |
1,017 | func0 | #include <stdio.h>
#include <limits.h>
| int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
... | #include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11b7 <func0+0x4e>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdi
mov $0x7fffffff,%esi
mov $0x7fffffff,%ecx
jmp 1196 <func0+0x2d>
mov %ecx,%esi
mov %edx,%ecx
add $0x4,%rax
cmp %rdi,%rax
je 11a5 <func0+0x3c>
mov (%rax),%edx
cmp %e... | func0:
endbr64
cmp esi, 1
jle short loc_11B3
mov rcx, rdi
movsxd rsi, esi
lea rdi, [rdi+rsi*4]
mov eax, 7FFFFFFFh
mov esi, 7FFFFFFFh
jmp short loc_1195
loc_1188:
mov eax, esi
mov esi, edx
loc_118C:
add rcx, 4
cmp rcx, rdi
jz short loc_11AB
loc_1195:
mov edx, [rcx]
c... | long long func0(int *a1, int a2)
{
int *v2; // rcx
int *v3; // rdi
long long result; // rax
int v5; // esi
int v6; // edx
unsigned int v7; // r8d
if ( a2 <= 1 )
return 0xFFFFFFFFLL;
v2 = a1;
v3 = &a1[a2];
result = 0x7FFFFFFFLL;
v5 = 0x7FFFFFFF;
do
{
v6 = *v2;
if ( *v2 < v5 )
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011b3
MOV RCX,RDI
MOVSXD RSI,ESI
LEA RDI,[RDI + RSI*0x4]
MOV EAX,0x7fffffff
MOV ESI,0x7fffffff
JMP 0x00101195
LAB_00101188:
MOV EAX,ESI
MOV ESI,EDX
LAB_0010118c:
ADD RCX,0x4
CMP RCX,RDI
JZ 0x001011ab
LAB_00101195:
MOV EDX,dword ptr [RCX]
CMP EDX,ESI
JL 0x00101188
MOV R8D,EAX
CMP EDX,... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 2) {
return -1;
}
piVar1 = param_1 + param_2;
iVar6 = 0x7fffffff;
iVar4 = 0x7fffffff;
do {
iVar2 = *param_1;
iVar5 = iVar2;
iVar3 = iVar6;
if (iVar6 <= ... |
1,018 | func0 | #include <stdio.h>
#include <limits.h>
| int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
... | #include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 13cb <func0+0xb>
jmp 1350 <func0.part.0>
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0_part_0:
test esi, esi
jle short loc_1360
movsxd rsi, esi
mov ecx, 7FFFFFFFh
mov edx, 7FFFFFFFh
lea rsi, [rdi+rsi*4]
jmp short loc_1340
loc_1330:
jz short loc_1337
cmp ecx, eax
cmovg ecx, eax
loc_1337:
add rdi, 4
cmp rsi, rdi
jz short loc_1353
loc_1340:
mov eax, ... | long long func0_part_0(int *a1, int a2)
{
int v2; // ecx
int v3; // edx
int *v4; // rsi
int v5; // eax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = 0x7FFFFFFF;
v3 = 0x7FFFFFFF;
v4 = &a1[a2];
do
{
while ( 1 )
{
v5 = *a1;
if ( v3 <= *a1 )
break;
++a1;
v2 = v3;... | func0.part.0:
TEST ESI,ESI
JLE 0x00101360
MOVSXD RSI,ESI
MOV ECX,0x7fffffff
MOV EDX,0x7fffffff
LEA RSI,[RDI + RSI*0x4]
JMP 0x00101340
LAB_00101330:
JZ 0x00101337
CMP ECX,EAX
CMOVG ECX,EAX
LAB_00101337:
ADD RDI,0x4
CMP RSI,RDI
JZ 0x00101353
LAB_00101340:
MOV EAX,dword ptr [RDI]
CMP EDX,EAX
JLE 0x00101330
ADD RDI,0x4
MOV... | int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar3 = 0x7fffffff;
iVar4 = 0x7fffffff;
do {
while( true ) {
iVar2 = *param_1;
if (iVar4 <= iVar2) break;
param_1 = param_... |
1,019 | func0 | #include <stdio.h>
#include <limits.h>
| int func0(int *lst, int size) {
if (size < 2) return -1;
int first = INT_MAX, second = INT_MAX;
for (int i = 0; i < size; ++i) {
if (lst[i] < first) {
second = first;
first = lst[i];
} else if (lst[i] < second && lst[i] != first) {
second = lst[i];
... | #include <assert.h>
int main() {
int test1[] = {1, 2, 3, 4, 5};
assert(func0(test1, 5) == 2);
int test2[] = {5, 1, 4, 3, 2};
assert(func0(test2, 5) == 2);
assert(func0((const int[]){}, 0) == -1);
int test4[] = {1, 1};
assert(func0(test4, 2) == -1);
int test5[] = {1, 1, 1, 1, 0};
... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 13d5 <func0+0x55>
lea -0x1(%rsi),%eax
mov $0x7fffffff,%r8d
mov $0x7fffffff,%edx
lea 0x4(%rdi,%rax,4),%rcx
jmp 13b4 <func0+0x34>
xchg %ax,%ax
cmp %r8d,%eax
jge 13ab <func0+0x2b>
cmp %edx,%eax
cmovne %eax,%r8d
add $0x4,%rdi
cmp %rdi,%rcx
je 13c8 <... | func0_part_0:
test esi, esi
jle short loc_1360
movsxd rsi, esi
mov ecx, 7FFFFFFFh
mov edx, 7FFFFFFFh
lea rsi, [rdi+rsi*4]
jmp short loc_1340
loc_1330:
jz short loc_1337
cmp ecx, eax
cmovg ecx, eax
loc_1337:
add rdi, 4
cmp rsi, rdi
jz short loc_1353
loc_1340:
mov eax, ... | long long func0_part_0(int *a1, int a2)
{
int v2; // ecx
int v3; // edx
int *v4; // rsi
int v5; // eax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = 0x7FFFFFFF;
v3 = 0x7FFFFFFF;
v4 = &a1[a2];
do
{
while ( 1 )
{
v5 = *a1;
if ( v3 <= *a1 )
break;
++a1;
v2 = v3;... | func0.part.0:
TEST ESI,ESI
JLE 0x00101360
MOVSXD RSI,ESI
MOV ECX,0x7fffffff
MOV EDX,0x7fffffff
LEA RSI,[RDI + RSI*0x4]
JMP 0x00101340
LAB_00101330:
JZ 0x00101337
CMP ECX,EAX
CMOVG ECX,EAX
LAB_00101337:
ADD RDI,0x4
CMP RSI,RDI
JZ 0x00101353
LAB_00101340:
MOV EAX,dword ptr [RDI]
CMP EDX,EAX
JLE 0x00101330
ADD RDI,0x4
MOV... | int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar3 = 0x7fffffff;
iVar4 = 0x7fffffff;
do {
while( true ) {
iVar2 = *param_1;
if (iVar4 <= iVar2) break;
param_1 = param_... |
1,020 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
... | #include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") =... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x1,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 12b6 <func0+0x14d>
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_10], 1
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_12B6
loc_119A:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add... | long long func0(long long a1)
{
int v2; // [rsp+10h] [rbp-10h]
int v3; // [rsp+14h] [rbp-Ch]
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v2 = 1;
v3 = 0;
v4 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x2000) != 0 && v3 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012b6
LAB_0010119a:
CALL 0x00101070
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX... | int func0(long param_1)
{
bool bVar1;
bool bVar2;
ushort **ppuVar3;
int local_10;
int local_c;
bVar2 = true;
bVar1 = false;
local_10 = 0;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
ppuVar3 = __ctype_b_loc();
if ((((*ppuVar3)[*(char *)(param_1 + local_c... |
1,021 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
... | #include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") =... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
mov $0x0,%ebp
test %bl,%bl
je 1226 <func0+0xbd>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%r9
movsbq %bl,%rax
movzwl (%r9,%rax,2),%eax
and $0x2000,%ax
lea 0x1(%rbp),%rdi
mov $0x1,%edx
mov $0x0,%ebp
mov ... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1219
mov rbp, rdi
call ___ctype_b_loc
mov r8, [rax]
lea rdi, [rbp+1]
mov r11d, 0
mov ecx, 0
mov edx, 1
mov esi, 0
mov r10, 8000400200000000h
mov r9d, 1
jmp short loc_11... | long long func0(unsigned __int8 *a1)
{
unsigned long long v1; // rbx
const unsigned __int16 *v2; // r8
unsigned __int8 *v3; // rdi
unsigned int v4; // r11d
int v5; // ecx
int v6; // edx
unsigned long long v7; // r10
__int16 v8; // ax
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = *__ctype_b_loc();
v3... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101219
MOV RBP,RDI
CALL 0x00101070
MOV R8,qword ptr [RAX]
LEA RDI,[RBP + 0x1]
MOV R11D,0x0
MOV ECX,0x0
MOV EDX,0x1
MOV ESI,0x0
MOV R10,-0x7fffbffe00000000
MOV R9D,0x1
JMP 0x001011ed
LAB_001011b4:
ADD R11D,0x1
TEST EDX,EDX
JZ 0x00101... | int func0(byte *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
ushort uVar4;
ushort **ppuVar5;
byte *pbVar6;
int iVar7;
bVar1 = *param_1;
if (bVar1 == 0) {
iVar7 = 0;
}
else {
ppuVar5 = __ctype_b_loc();
iVar7 = 0;
bVar3 = false;
bVar2 = true;
pbVar6 = param_1 + 1;
d... |
1,022 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
... | #include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") =... | O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1360 <func0+0xb0>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %r8d,%r8d
xor %esi,%esi
mov (%rax),%r9
mov $0x1,%edx
mov $0x1,%r11d
movabs $0x8000400200000000,%r10
jmp 131b <fu... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1370
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor r11d, r11d
xor esi, esi
mov r8, [rax]
mov ecx, 1
mov r10, 8000400200000000h
mov r9d, 1
jmp short loc_1310
loc_12F... | long long func0(unsigned __int8 *a1)
{
unsigned long long v1; // rbx
const unsigned __int16 **v2; // rax
unsigned __int8 *v3; // rdi
unsigned int v4; // r11d
int v5; // esi
const unsigned __int16 *v6; // r8
bool v7; // cl
unsigned long long v8; // r10
bool v9; // dl
__int16 v10; // ax
v1 = *a1;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101370
MOV RBP,RDI
CALL 0x00101070
LEA RDI,[RBP + 0x1]
XOR R11D,R11D
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV ECX,0x1
MOV R10,-0x7fffbffe00000000
MOV R9D,0x1
JMP 0x00101310
LAB_001012f0:
TEST DL,DL
JNZ 0x00101333
XOR ECX,ECX
LAB_00101... | int func0(byte *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
ushort **ppuVar5;
int iVar6;
bVar1 = *param_1;
if (bVar1 == 0) {
return 0;
}
ppuVar5 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar6 = 0;
bVar3 = false;
bVar2 = true;
do {
bVar4 = (bool)(bVar1 == 0x49 & ... |
1,023 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *S) {
int isstart = 1;
int isi = 0;
int sum = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (isspace(S[i]) && isi) {
isi = 0;
sum += 1;
}
if (S[i] == 'I' && isstart) {
isi = 1;
} else if (!isspace(S[i])) {
... | #include <assert.h>
int main() {
assert(func0("Hello world") == 0);
assert(func0("Is the sky blue?") == 0);
assert(func0("I love It !") == 1);
assert(func0("bIt") == 0);
assert(func0("I feel good today. I will be productive. will kill It") == 2);
assert(func0("You and I are going for a walk") =... | O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1360 <func0+0xb0>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %r8d,%r8d
xor %esi,%esi
mov (%rax),%r9
mov $0x1,%edx
movabs $0x8000400200000000,%r11
mov $0x1,%r10d
jmp 131b <fu... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1370
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor r11d, r11d
xor esi, esi
mov r8, [rax]
mov ecx, 1
mov r10, 8000400200000000h
mov r9d, 1
jmp short loc_1310
loc_12F... | long long func0(unsigned __int8 *a1)
{
unsigned long long v1; // rbx
const unsigned __int16 **v2; // rax
unsigned __int8 *v3; // rdi
unsigned int v4; // r11d
int v5; // esi
const unsigned __int16 *v6; // r8
bool v7; // cl
unsigned long long v8; // r10
bool v9; // dl
__int16 v10; // ax
v1 = *a1;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101370
MOV RBP,RDI
CALL 0x00101070
LEA RDI,[RBP + 0x1]
XOR R11D,R11D
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV ECX,0x1
MOV R10,-0x7fffbffe00000000
MOV R9D,0x1
JMP 0x00101310
LAB_001012f0:
TEST DL,DL
JNZ 0x00101333
XOR ECX,ECX
LAB_00101... | int func0(byte *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
ushort **ppuVar5;
int iVar6;
bVar1 = *param_1;
if (bVar1 == 0) {
return 0;
}
ppuVar5 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar6 = 0;
bVar3 = false;
bVar2 = true;
do {
bVar4 = (bool)(bVar1 == 0x49 & ... |
1,024 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
asser... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss %xmm2,-0xc(%rbp)
mov -0x4(%rbp),%eax
movd %eax,%xmm0
callq 1060 <roundf@plt>
ucomiss -0x4(%rbp),%xmm0
jp 119c <func0+0x33>
ucomiss -0x4(%rbp),%xmm0
je 11a6 <func0+0x3d>
mov $0x0,%eax
jmp... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
movss [rbp+x], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
mov eax, [rbp+x]
movd xmm0, eax; x
call _roundf
movd eax, xmm0
movd xmm3, eax
ucomiss xmm3, [rbp+x]
jp short loc_11A8
movd xmm4, eax
ucomiss xmm4, [rbp+x]
jz ... | _BOOL8 func0(float a1, float a2, float a3)
{
__m128i v3; // xmm0
__m128i v5; // xmm0
__m128i v6; // xmm0
v3 = _mm_cvtsi32_si128(LODWORD(a1));
*(float *)v3.m128i_i32 = roundf(*(float *)v3.m128i_i32);
if ( COERCE_FLOAT(_mm_cvtsi128_si32(v3)) != a1 )
return 0LL;
v5 = _mm_cvtsi32_si128(LODWORD(a2));
*... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOV EAX,dword ptr [RBP + -0x4]
MOVD XMM0,EAX
CALL 0x00101060
MOVD EAX,XMM0
MOVD XMM3,EAX
UCOMISS XMM3,dword ptr [RBP + -0x4]
JP 0x001011a8
MOVD XMM4,EAX
UCOMISS XMM4,dwo... | int8 func0(float param_1,float param_2,float param_3)
{
int8 uVar1;
float fVar2;
fVar2 = roundf(param_1);
if (fVar2 == param_1) {
fVar2 = roundf(param_2);
if (fVar2 == param_2) {
fVar2 = roundf(param_3);
if (fVar2 == param_3) {
if (((param_1 + param_2 == param_3) || (param_1 + pa... |
1,025 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
asser... | O1 | c | func0:
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0xc(%rsp)
movss %xmm0,0x8(%rsp)
callq 1060 <roundf@plt>
movss 0x8(%rsp),%xmm3
ucomiss %xmm3,%xmm0
jp 1228 <func0+0xbf>
jne 1228 <func0+0xbf>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0x4(%rsp),%xmm4
ucomiss %xmm4,%xmm0
jp 12... | func0:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_14], xmm0
call _roundf
movss xmm3, [rsp+18h+var_14]
ucomiss xmm0, xmm3
jp loc_1224
jnz loc_1224
movss xmm0, [rsp+18h+x]; x
call _roundf
movss xmm4, [rsp+18h+x]
ucomiss xmm0, xmm4
jp sho... | _BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
if ( roundf(a1) != a1 )
return 0LL;
if ( roundf(a2) != a2 )
return 0LL;
if ( roundf(a3) != a3 )
return 0LL;
result = 1LL;
if ( (float)(a1 + a2) != a3 )
{
result = 1LL;
if ( (float)(a1 + a3) != a2 )
return (float... | func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x8],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x4],XMM0
CALL 0x00101060
MOVSS XMM3,dword ptr [RSP + 0x4]
UCOMISS XMM0,XMM3
JP 0x00101224
JNZ 0x00101224
MOVSS XMM0,dword ptr [RSP + 0x8]
CALL 0x00101060
MOVSS XMM4,dword ptr [RSP + 0x8]
UCOMISS XMM0,XM... | bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (fVar2 == param_1) {
fVar2 = roundf(param_2);
if (fVar2 == param_2) {
fVar2 = roundf(param_3);
if (fVar2 == param_3) {
bVar1 = true;
if ((param_1 + param_2 != para... |
1,026 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
asser... | O2 | c | func0:
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0xc(%rsp)
movss %xmm0,0x8(%rsp)
callq 1060 <roundf@plt>
ucomiss 0x8(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
ucomiss 0x4(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb... | func0:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_10], xmm0
call _roundf
ucomiss xmm0, [rsp+18h+var_10]
jp loc_14C8
jnz loc_14C8
movss xmm0, [rsp+18h+x]; x
call _roundf
ucomiss xmm0, [rsp+18h+x]
jp short loc_14C8
jnz short loc_14C8
mov... | _BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
if ( roundf(a1) != a1 || roundf(a2) != a2 || roundf(a3) != a3 )
return 0LL;
result = 1LL;
if ( a3 != (float)(a1 + a2) )
{
result = 1LL;
if ( a2 != (float)(a1 + a3) )
return (float)(a2 + a3) == a1;
}
return result;
} | func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x8],XMM0
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x8]
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x4]
JP 0x001014c8
JNZ 0x001014c8
... | bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (((fVar2 == param_1) && (fVar2 = roundf(param_2), fVar2 == param_2)) &&
(fVar2 = roundf(param_3), fVar2 == param_3)) {
bVar1 = true;
if ((param_3 != param_1 + param_2) && (bVar1 = true, ... |
1,027 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (roundf(a) != a) return 0;
if (roundf(b) != b) return 0;
if (roundf(c) != c) return 0;
if ((a + b == c) || (a + c == b) || (b + c == a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(2, 3, 1) == 1);
assert(func0(2.5, 2, 3) == 0);
assert(func0(1.5, 5, 3.5) == 0);
assert(func0(2, 6, 2) == 0);
assert(func0(4, 2, 2) == 1);
assert(func0(2.2, 2.2, 2.2) == 0);
assert(func0(-4, 6, 2) == 1);
assert(func0(2, 1, 1) == 1);
asser... | O3 | c | func0:
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0xc(%rsp)
movss %xmm0,0x8(%rsp)
callq 1060 <roundf@plt>
ucomiss 0x8(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb0>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
ucomiss 0x4(%rsp),%xmm0
jp 14c0 <func0+0xb0>
jne 14c0 <func0+0xb... | func0:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_10], xmm0
call _roundf
ucomiss xmm0, [rsp+18h+var_10]
jp loc_14C8
jnz loc_14C8
movss xmm0, [rsp+18h+x]; x
call _roundf
ucomiss xmm0, [rsp+18h+x]
jp short loc_14C8
jnz short loc_14C8
mov... | _BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
if ( roundf(a1) != a1 || roundf(a2) != a2 || roundf(a3) != a3 )
return 0LL;
result = 1LL;
if ( a3 != (float)(a1 + a2) )
{
result = 1LL;
if ( a2 != (float)(a1 + a3) )
return (float)(a2 + a3) == a1;
}
return result;
} | func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x8],XMM0
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x8]
JP 0x001014c8
JNZ 0x001014c8
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00101060
UCOMISS XMM0,dword ptr [RSP + 0x4]
JP 0x001014c8
JNZ 0x001014c8
... | bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (((fVar2 == param_1) && (fVar2 = roundf(param_2), fVar2 == param_2)) &&
(fVar2 = roundf(param_3), fVar2 == param_3)) {
bVar1 = true;
if ((param_3 != param_1 + param_2) && (bVar1 = true, ... |
1,028 | func0 | #include <stdio.h>
#include <ctype.h>
#include <string.h>
| void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", o... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
lea 0xe04(%rip),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 12eb <func0+0x102>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
lea rax, aAeiouaeiou; "aeiouAEIOU"
mov [rbp+var_8], rax
mov [rbp+var_10], 0
jmp loc_12EB
loc_1214:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
movzx ... | _BYTE * func0(long long a1, long long a2)
{
_BYTE *result; // rax
char v3; // [rsp+1Fh] [rbp-11h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
v3 = *(_BYTE *)(i + a1);
if ( ((*__ctype_b_loc())[v3] & 0x200) != 0 )
{
v3 = toupper(v3);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012eb
LAB_00101214:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX... | void func0(long param_1,long param_2)
{
int iVar1;
ushort **ppuVar2;
char local_19;
int local_18;
int local_14;
local_18 = 0;
do {
if (*(char *)(param_1 + local_18) == '\0') {
*(int *)(param_2 + local_18) = 0;
return;
}
local_19 = *(char *)(param_1 + local_18);
ppuVar2 = __... |
1,029 | func0 | #include <stdio.h>
#include <ctype.h>
#include <string.h>
| void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", o... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
movzbl (%rdi),%ebx
test %bl,%bl
je 1275 <func0+0xac>
mov %rdi,%r14
callq 10d0 <__ctype_b_loc@plt>
mov %rax,%r15
mov $0x0,%r12d
lea 0xe01(%rip),%rbp
jmp 1238 <func0+0x6f>
t... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz loc_1293
mov r14, rdi
call ___ctype_b_loc
mov r15, rax
mov r12d, 0
lea rbp, aAeiouaeiou; "aeiouAEIOU"
jmp short ... | long long func0(char *a1, long long a2)
{
char v2; // bl
const unsigned __int16 **v3; // r15
long long v4; // r12
unsigned __int16 v5; // ax
long long v6; // rax
char v7; // dl
long long result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = __ctype_b_loc();
v4 = 0LL;
do
{
v5 = (*v3)[v2]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101293
MOV R14,RDI
CALL 0x001010f0
MOV R15,RAX
MOV R12D,0x0
LEA RBP,[0x102004]
JMP 0x00101258
LAB_00101225:
TEST AH,0x1
JZ 0x00101276
CALL 0x001010e0
MOV RAX,qword p... | void func0(char *param_1,long param_2)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
long lVar3;
char cVar4;
char cVar5;
long lVar6;
cVar5 = *param_1;
if (cVar5 == '\0') {
lVar6 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
lVar6 = 0;
do {
if (((*ppuVar1)[cVar5] & 0x200) == 0) {
... |
1,030 | func0 | #include <stdio.h>
#include <ctype.h>
#include <string.h>
| void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", o... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
movzbl (%rdi),%ebx
mov %rdi,0x8(%rsp)
test %bl,%bl
je 1417 <func0+0x97>
callq 10d0 <__ctype_b_loc@plt>
xor %r14d,%r14d
lea 0xc54(%rip),%r13
mov %rax,%r12
nopl 0x0(%rax,%rax,1)
m... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov [rsp+48h+var_40], rdi
test bl, bl
jz short loc_1423
call ___ctype_b_loc
xor r14d, r14d
lea rbp, aAeiouaeiou; "aeiouAEIOU"
mov r13, rax
nop ... | void func0(char *a1, _BYTE *a2)
{
_BYTE *v2; // r12
char v3; // bl
long long v4; // r14
const unsigned __int16 **v5; // r13
unsigned __int16 v6; // ax
long long v7; // rax
char v8; // dl
v2 = a2;
v3 = *a1;
if ( *a1 )
{
v4 = 0LL;
v5 = __ctype_b_loc();
do
{
v6 = (*v5)[v3];
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV qword ptr [RSP + 0x8],RDI
TEST BL,BL
JZ 0x00101423
CALL 0x001010d0
XOR R14D,R14D
LEA RBP,[0x102004]
MOV R13,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c8:
MOV RAX,qword ptr [R13]
MOVSX R15,BL
MOVZ... | void func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
long lVar3;
char cVar4;
char cVar5;
long lVar6;
cVar5 = *param_1;
if (cVar5 != '\0') {
ppuVar1 = __ctype_b_loc();
lVar6 = 0;
do {
if (((*ppuVar1)[cVar5] & 0x200) == 0) {
if (((*ppuVar1)[cVar5] &... |
1,031 | func0 | #include <stdio.h>
#include <ctype.h>
#include <string.h>
| void func0(const char* message, char* out) {
const char* vowels = "aeiouAEIOU";
int i, j;
for (i = 0; message[i] != '\0'; ++i) {
char w = message[i];
if (islower(w)) {
w = toupper(w);
} else if (isupper(w)) {
w = tolower(w);
}
for... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("TEST", output);
assert(strcmp(output, "tgst") == 0);
func0("Mudasir", output);
assert(strcmp(output, "mWDCSKR") == 0);
func0("YES", output);
assert(strcmp(output, "ygs") == 0);
func0("This is a message", o... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
movzbl (%rdi),%ebx
mov %rdi,0x8(%rsp)
test %bl,%bl
je 1417 <func0+0x97>
callq 10d0 <__ctype_b_loc@plt>
xor %r14d,%r14d
lea 0xc54(%rip),%r13
mov %rax,%r12
nopl 0x0(%rax,%rax,1)
m... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 18h
movzx ebx, byte ptr [rdi]
mov [rsp+48h+var_40], rdi
test bl, bl
jz short loc_1423
call ___ctype_b_loc
xor r14d, r14d
lea rbp, aAeiouaeiou; "aeiouAEIOU"
mov r13, rax
nop ... | void func0(char *a1, _BYTE *a2)
{
_BYTE *v2; // r12
char v3; // bl
long long v4; // r14
const unsigned __int16 **v5; // r13
unsigned __int16 v6; // ax
long long v7; // rax
char v8; // dl
v2 = a2;
v3 = *a1;
if ( *a1 )
{
v4 = 0LL;
v5 = __ctype_b_loc();
do
{
v6 = (*v5)[v3];
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVZX EBX,byte ptr [RDI]
MOV qword ptr [RSP + 0x8],RDI
TEST BL,BL
JZ 0x00101423
CALL 0x001010d0
XOR R14D,R14D
LEA RBP,[0x102004]
MOV R13,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c8:
MOV RAX,qword ptr [R13]
MOVSX R15,BL
MOVZ... | void func0(char *param_1,int *param_2)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
long lVar3;
char cVar4;
char cVar5;
long lVar6;
cVar5 = *param_1;
if (cVar5 != '\0') {
ppuVar1 = __ctype_b_loc();
lVar6 = 0;
do {
if (((*ppuVar1)[cVar5] & 0x200) == 0) {
if (((*ppuVar1)[cVar5] &... |
1,032 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
... | #include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11fa <func0+0x91>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_11FB
loc_118F:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
m... | long long func0(long long a1, int a2)
{
int v2; // eax
int v4; // [rsp+14h] [rbp-18h]
unsigned int v5; // [rsp+18h] [rbp-14h]
int i; // [rsp+1Ch] [rbp-10h]
int v7; // [rsp+20h] [rbp-Ch]
int j; // [rsp+24h] [rbp-8h]
int v9; // [rsp+28h] [rbp-4h]
v4 = 0;
v5 = 0;
for ( i = 0; i < a2; ++i )
{
v9... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011fb
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,... | int func0(long param_1,int param_2)
{
int iVar1;
bool bVar2;
int iVar3;
int local_20;
int local_1c;
int local_18;
int local_10;
local_20 = 0;
local_1c = 0;
local_18 = 0;
do {
if (param_2 <= local_18) {
for (; 0 < local_20; local_20 = local_20 / 10) {
local_1c = local_1c + loc... |
1,033 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
... | #include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11b8 <func0+0x4f>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%edi
jmp 11d4 <func0+0x6b>
test %edi,%edi
jle 11bf <func0+0x56>
mov $0x0,%ecx
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%... | func0:
endbr64
test esi, esi
jle loc_11F8
mov r8, rdi
movsxd rsi, esi
lea r9, [rdi+rsi*4]
mov edi, 0
jmp short loc_1194
loc_1186:
cmp edi, esi
cmovl edi, esi
loc_118B:
add r8, 4
cmp r9, r8
jz short loc_11C3
loc_1194:
mov esi, [r8]
cmp esi, 1
jle short loc_118B
cmp ... | long long func0(int *a1, int a2)
{
int *v2; // r8
int *v3; // r9
int v4; // edi
int v5; // esi
int v6; // ecx
unsigned int v7; // ecx
int v8; // edx
if ( a2 <= 0 )
return 0;
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
v5 = *v2;
if ( *v2 <= 1 )
goto LABEL_5;
if ( v5 > 3 )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011f8
MOV R8,RDI
MOVSXD RSI,ESI
LEA R9,[RDI + RSI*0x4]
MOV EDI,0x0
JMP 0x00101194
LAB_00101186:
CMP EDI,ESI
CMOVL EDI,ESI
LAB_0010118b:
ADD R8,0x4
CMP R9,R8
JZ 0x001011c3
LAB_00101194:
MOV ESI,dword ptr [R8]
CMP ESI,0x1
JLE 0x0010118b
CMP ESI,0x3
JLE 0x00101186
TEST SIL,0x1
JZ 0x001... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
bool bVar3;
int iVar4;
uint uVar5;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar1 = param_1 + param_2;
uVar5 = 0;
do {
uVar2 = *param_1;
if (1 < (int)uVar2) {
if ((int)uVar2 < 4) {
LAB_00101186:
... |
1,034 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
... | #include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1711 <func0+0xa1>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%r9
jmp 1699 <func0+0x29>
nopl 0x0(%rax)
add $0x4,%rdi
cmp %r9,%rdi
je 16e0 <func0+0x70>
mov (%rdi),%esi
cmp $0x1,%esi
jle 1690 <func0+0x20>
cmp $0x3,%esi
jle 16cd <func... | func0:
endbr64
test esi, esi
jle loc_15D5
movsxd rsi, esi
xor r8d, r8d
lea r9, [rdi+rsi*4]
jmp short loc_1559
loc_1550:
add rdi, 4
cmp r9, rdi
jz short loc_15A0
loc_1559:
mov esi, [rdi]
cmp esi, 1
jle short loc_1550
cmp esi, 3
jle short loc_158D
test sil, 1
jz ... | long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // r9
int v4; // esi
int v5; // ecx
unsigned int v6; // ecx
unsigned int v7; // esi
int v8; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
v4 = *a1;
if ( *a1 > 1 )
{
if ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001015d5
MOVSXD RSI,ESI
XOR R8D,R8D
LEA R9,[RDI + RSI*0x4]
JMP 0x00101559
LAB_00101550:
ADD RDI,0x4
CMP R9,RDI
JZ 0x001015a0
LAB_00101559:
MOV ESI,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101550
CMP ESI,0x3
JLE 0x0010158d
TEST SIL,0x1
JZ 0x00101550
MOV ECX,0x2
JMP 0x00101581
LAB_00101578:
M... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
bool bVar3;
int iVar4;
uint uVar5;
if (param_2 < 1) {
return 0;
}
uVar5 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (1 < (int)uVar2) {
if ((int)uVar2 < 4) {
LAB_0010158d:
if ((int)uVar5 < (i... |
1,035 | func0 | #include <stdio.h>
| int func0(int lst[], int size) {
int largest = 0, sum = 0, num, temp;
for (int i = 0; i < size; ++i) {
num = lst[i];
if (num > 1) {
int prime = 1;
for (int j = 2; j * j <= num; ++j) {
if (num % j == 0) {
prime = 0;
... | #include <assert.h>
int main() {
int lst1[] = {0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3};
assert(func0(lst1, sizeof(lst1)/sizeof(lst1[0])) == 10);
int lst2[] = {1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1};
assert(func0(lst2, sizeof(lst2)/sizeof(lst2[0])) == 25);
int lst3[] = {1,3,1,32,5107... | O3 | c | func0:
endbr64
test %esi,%esi
jle 15e1 <func0+0xa1>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%r9
jmp 1569 <func0+0x29>
nopl 0x0(%rax)
add $0x4,%rdi
cmp %r9,%rdi
je 15b0 <func0+0x70>
mov (%rdi),%esi
cmp $0x1,%esi
jle 1560 <func0+0x20>
cmp $0x3,%esi
jle 159d <func... | func0:
endbr64
test esi, esi
jle loc_15D5
movsxd rsi, esi
xor r8d, r8d
lea r9, [rdi+rsi*4]
jmp short loc_1559
loc_1550:
add rdi, 4
cmp r9, rdi
jz short loc_15A0
loc_1559:
mov esi, [rdi]
cmp esi, 1
jle short loc_1550
cmp esi, 3
jle short loc_158D
test sil, 1
jz ... | long long func0(int *a1, int a2)
{
int v2; // r8d
int *v3; // r9
int v4; // esi
int v5; // ecx
unsigned int v6; // ecx
unsigned int v7; // esi
int v8; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
v4 = *a1;
if ( *a1 > 1 )
{
if ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001015d5
MOVSXD RSI,ESI
XOR R8D,R8D
LEA R9,[RDI + RSI*0x4]
JMP 0x00101559
LAB_00101550:
ADD RDI,0x4
CMP R9,RDI
JZ 0x001015a0
LAB_00101559:
MOV ESI,dword ptr [RDI]
CMP ESI,0x1
JLE 0x00101550
CMP ESI,0x3
JLE 0x0010158d
TEST SIL,0x1
JZ 0x00101550
MOV ECX,0x2
JMP 0x00101581
LAB_00101578:
M... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
bool bVar3;
int iVar4;
uint uVar5;
if (param_2 < 1) {
return 0;
}
uVar5 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (1 < (int)uVar2) {
if ((int)uVar2 < 4) {
LAB_0010158d:
if ((int)uVar5 < (i... |
1,036 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j]))... | #include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
a... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
cmpl $0x0,-0x2c(%rbp)
jne 11ac <func0+0x23>
mov $0x0,%eax
jmpq 12d9 <func0+0x150>
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 12c8 <func0+0x13f>
mov -0x10(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
cmp [rbp+var_2C], 0
jnz short loc_11AC
mov eax, 0
jmp locret_12D9
loc_11AC:
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp loc_12C8
loc_11C6:
mov eax, [rb... | long long func0(long long a1, int a2)
{
int v3; // [rsp+18h] [rbp-18h]
int v4; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
long long v7; // [rsp+28h] [rbp-8h]
if ( !a2 )
return 0LL;
v3 = 0;
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v7 = *(_QWORD *)(16LL * i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x001011ac
MOV EAX,0x0
JMP 0x001012d9
LAB_001011ac:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012c8
LAB_0010... | int8 func0(long param_1,int param_2)
{
long lVar1;
int8 uVar2;
ushort **ppuVar3;
int local_20;
int local_1c;
int local_18;
int local_14;
if (param_2 == 0) {
uVar2 = 0;
}
else {
local_20 = 0;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
lVa... |
1,037 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j]))... | #include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
a... | O1 | c | func0:
endbr64
mov %esi,%eax
test %esi,%esi
je 1264 <func0+0xdb>
jle 1205 <func0+0x7c>
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,(%rsp)
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%rax
mov %rax,0x8(%rsp)
mov $0x0,%r13d
mo... | func0:
endbr64
mov eax, esi
test esi, esi
jz locret_1259
jle short loc_11FA
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r15, rdi
movsxd rsi, esi
shl rsi, 4
lea rax, [rdi+rsi]
mov [rsp+48h+var_40], rax
mov r13d, 0
mov r12d, 0
mov ... | long long func0(unsigned __int8 **a1, int a2)
{
long long result; // rax
unsigned __int8 **v3; // r15
int v4; // r13d
int v5; // r12d
unsigned __int8 *v6; // rbp
unsigned __int8 v7; // bl
const unsigned __int16 *v8; // rdx
unsigned __int8 *v9; // rbp
unsigned __int16 v10; // ax
result = (unsigned ... | func0:
ENDBR64
MOV EAX,ESI
TEST ESI,ESI
JZ 0x00101259
JLE 0x001011fa
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R15,RDI
MOVSXD RSI,ESI
SHL RSI,0x4
LEA RAX,[RDI + RSI*0x1]
MOV qword ptr [RSP + 0x8],RAX
MOV R13D,0x0
MOV R12D,0x0
MOV R14D,0x1
LAB_001011cc:
MOV RBP,qword ptr [R15]
MOVZX EBX,byte... | int func0(int8 *param_1,int param_2)
{
int8 *puVar1;
ushort uVar2;
ushort **ppuVar3;
byte bVar4;
byte *pbVar5;
int iVar6;
int iVar7;
if (param_2 == 0) {
return param_2;
}
if (param_2 < 1) {
return 1;
}
puVar1 = param_1 + (long)param_2 * 2;
iVar7 = 0;
iVar6 = 0;
do {
pbVar5 ... |
1,038 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j]))... | #include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
a... | O2 | c | func0:
endbr64
test %esi,%esi
je 1550 <func0+0x10>
jmpq 1480 <func0.part.0>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
test esi, esi
jle loc_15CA
push r15
movsxd rsi, esi
mov r15, rdi
push r14
shl rsi, 4
xor r14d, r14d
push r13
lea rax, [rdi+rsi]
xor r13d, r13d
push r12
mov r12d, 1
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rax
loc_1545:
mov rbp, [r15... | long long func0_part_0(unsigned __int8 **a1, int a2)
{
unsigned __int8 **v2; // r15
int v3; // r14d
int v4; // r13d
unsigned __int8 *v5; // rbp
long long v6; // rbx
const unsigned __int16 **v7; // rax
unsigned __int8 *v8; // rdx
const unsigned __int16 *v9; // rsi
unsigned __int16 v10; // ax
__int16... | func0.part.0:
TEST ESI,ESI
JLE 0x001015ca
PUSH R15
MOVSXD RSI,ESI
MOV R15,RDI
PUSH R14
SHL RSI,0x4
XOR R14D,R14D
PUSH R13
LEA RAX,[RDI + RSI*0x1]
XOR R13D,R13D
PUSH R12
MOV R12D,0x1
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RAX
LAB_00101545:
MOV RBP,qword ptr [R15]
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ ... | int8 func0_part_0(int8 *param_1,int param_2)
{
int8 *puVar1;
byte bVar2;
ushort uVar3;
ushort **ppuVar4;
byte *pbVar5;
int iVar6;
int iVar7;
if (param_2 < 1) {
return 1;
}
iVar7 = 0;
puVar1 = param_1 + (long)param_2 * 2;
iVar6 = 0;
do {
pbVar5 = (byte *)*param_1;
bVar2 = *pbVar... |
1,039 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| int func0(char* dict[][2], int size) {
if (size == 0) return 0;
int has_lower = 0, has_upper = 0;
for (int i = 0; i < size; ++i) {
char* key = dict[i][0];
for (int j = 0; key[j]; ++j) {
if (!isalpha((unsigned char)key[j])) return 0;
if (isupper((unsigned char)key[j]))... | #include <assert.h>
int main() {
char* test1[][2] = {{"p","pineapple"}, {"b","banana"}};
assert(func0(test1, 2) == 1);
char* test2[][2] = {{"p","pineapple"}, {"A","banana"}, {"B","banana"}};
assert(func0(test2, 3) == 0);
char* test3[][2] = {{"p","pineapple"}, {"5","banana"}, {"a","apple"}};
a... | O3 | c | func0:
endbr64
xor %eax,%eax
test %esi,%esi
je 1670 <func0+0xd0>
jle 1671 <func0+0xd1>
push %r15
lea -0x1(%rsi),%eax
mov %rdi,%r15
push %r14
shl $0x4,%rax
xor %r14d,%r14d
push %r13
lea 0x10(%rdi,%rax,1),%rax
xor %r13d,%r13d
push %r12
mov $0x1,%r12d
push %rbp
push %rbx
sub ... | func0_part_0:
test esi, esi
jle loc_15CA
push r15
movsxd rsi, esi
mov r15, rdi
push r14
shl rsi, 4
xor r14d, r14d
push r13
lea rax, [rdi+rsi]
xor r13d, r13d
push r12
mov r12d, 1
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rax
loc_1545:
mov rbp, [r15... | long long func0_part_0(unsigned __int8 **a1, int a2)
{
unsigned __int8 **v2; // r15
int v3; // r14d
int v4; // r13d
unsigned __int8 *v5; // rbp
long long v6; // rbx
const unsigned __int16 **v7; // rax
unsigned __int8 *v8; // rdx
const unsigned __int16 *v9; // rsi
unsigned __int16 v10; // ax
__int16... | func0.part.0:
TEST ESI,ESI
JLE 0x001015ca
PUSH R15
MOVSXD RSI,ESI
MOV R15,RDI
PUSH R14
SHL RSI,0x4
XOR R14D,R14D
PUSH R13
LEA RAX,[RDI + RSI*0x1]
XOR R13D,R13D
PUSH R12
MOV R12D,0x1
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RAX
LAB_00101545:
MOV RBP,qword ptr [R15]
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ ... | int8 func0_part_0(int8 *param_1,int param_2)
{
int8 *puVar1;
byte bVar2;
ushort uVar3;
ushort **ppuVar4;
byte *pbVar5;
int iVar6;
int iVar7;
if (param_2 < 1) {
return 1;
}
iVar7 = 0;
puVar1 = param_1 + (long)param_2 * 2;
iVar6 = 0;
do {
pbVar5 = (byte *)*param_1;
bVar2 = *pbVar... |
1,040 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
... | #include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 3... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x30(%rbp),%rax
movl $0x0,(%rax)
movl $0x2,-0x18(%rbp)
jmpq 1278 <func0+0xcf>
movl ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_30], rsi
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov [rbp+var_18], 2
jmp loc_1278
loc... | _DWORD * func0(int a1, _DWORD *a2)
{
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int v5; // [rsp+20h] [rbp-10h]
int v6; // [rsp+24h] [rbp-Ch]
_DWORD *v7; // [rsp+28h] [rbp-8h]
v7 = malloc(4LL * a1);
*a2 = 0;
for ( i = 2; i < a1; ++i )
{
v5 = 1;
for ( j = 0; j < *a2; ++j )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x30],RSI
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x18],0x2
JMP 0x00101... | void * func0(int param_1,int *param_2)
{
int iVar1;
bool bVar2;
void *pvVar3;
int local_20;
int local_1c;
pvVar3 = malloc((long)param_1 << 2);
*param_2 = 0;
local_20 = 2;
do {
if (param_1 <= local_20) {
return pvVar3;
}
bVar2 = true;
local_1c = 0;
while( true ) {
if... |
1,041 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
... | #include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 3... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebp
mov %rsi,%rbx
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r10
movl $0x0,(%rbx)
mov $0x2,%edi
cmp $0x2,%ebp
jg 11f6 <func0+0x4d>
mov %r10,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
movslq %r9d,%... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebp, edi
mov rbx, rsi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov r10, rax
mov dword ptr [rbx], 0
mov edi, 2
cmp ebp, 2
jg short loc_11F6
loc_11D7:
mov rax, r10
add rsp, 8
pop rbx
pop rbp
retn
loc_11E1:
... | int * func0(int a1, int *a2)
{
int *v4; // r10
int v5; // edi
int v7; // r9d
int *v8; // rsi
int v9; // ecx
v4 = (int *)malloc(4LL * a1);
*a2 = 0;
v5 = 2;
if ( a1 > 2 )
{
do
{
v7 = *a2;
if ( *a2 > 0 )
{
v8 = v4;
do
{
v9 = *v8;
if... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDI
MOV RBX,RSI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R10,RAX
MOV dword ptr [RBX],0x0
MOV EDI,0x2
CMP EBP,0x2
JG 0x001011f6
LAB_001011d7:
MOV RAX,R10
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011e1:
MOVSXD RAX,R9D
MOV dword ptr [R10 + RAX*0x4],EDI
ADD R9D,0x1
M... | int * func0(int param_1,int *param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int iVar5;
piVar3 = (int *)malloc((long)param_1 << 2);
*param_2 = 0;
iVar5 = 2;
if (2 < param_1) {
do {
iVar1 = *param_2;
if (0 < iVar1) {
piVar4 = piVar3;
do {
iVar2 =... |
1,042 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
... | #include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 3... | O2 | c | func0:
endbr64
push %rbp
movslq %edi,%rdi
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
xor %r10d,%r10d
mov $0x2,%r8d
mov %rax,%r11
lea 0x4(%rax),%rsi
cmp $0x2,%ebx
jle 1798 <func0+0x98>
nopl 0x0(%rax,%rax,1)
test %... | func0:
endbr64
push rbp
movsxd rdi, edi
mov rbp, rsi
push rbx
mov rbx, rdi
shl rdi, 2; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
xor r9d, r9d
mov edi, 2
mov r10, rax
cmp ebx, 2
jle short loc_1700
nop dword ptr [rax+rax+00h]
loc_16A8:
movsxd r11, r9d
tes... | int * func0(int a1, int *a2)
{
int *result; // rax
int v5; // r9d
int v6; // edi
long long v7; // r11
int *v8; // rsi
int v9; // ecx
result = (int *)malloc(4LL * a1);
*a2 = 0;
v5 = 0;
v6 = 2;
if ( a1 > 2 )
{
while ( 1 )
{
v7 = v5;
if ( v5 > 0 )
{
v7 = v5;
... | func0:
ENDBR64
PUSH RBP
MOVSXD RDI,EDI
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
XOR R9D,R9D
MOV EDI,0x2
MOV R10,RAX
CMP EBX,0x2
JLE 0x00101700
NOP dword ptr [RAX + RAX*0x1]
LAB_001016a8:
MOVSXD R11,R9D
TEST R9D,R9D
JLE 0x001016dd
MOVSXD R11,R9D
MOV RSI,R10
LEA R8,... | int * func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
piVar2 = (int *)malloc((long)param_1 << 2);
*param_2 = 0;
iVar5 = 0;
iVar4 = 2;
if (param_1 < 3) {
return piVar2;
}
do {
if (0 < iVar5) {
piVar3 = piVar2;
do {
iVar1... |
1,043 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int n, int *count) {
int *out = malloc(n * sizeof(int));
*count = 0;
int i, j, isp, k;
for (i = 2; i < n; i++) {
isp = 1;
for (j = 0; j < *count; j++) {
k = out[j];
if (k * k > i) break;
if (i % k == 0) {
isp = 0;
... | #include <assert.h>
#include <string.h>
int issame(int *a, int a_count, int *b, int b_count) {
if (a_count != b_count) return 0;
for (int i = 0; i < a_count; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int count;
int expected[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 3... | O3 | c | func0:
endbr64
push %rbp
movslq %edi,%rdi
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,0x0(%rbp)
xor %r10d,%r10d
mov $0x2,%r8d
mov %rax,%r11
lea 0x4(%rax),%rsi
cmp $0x2,%ebx
jle 16ff <func0+0x8f>
nopl 0x0(%rax,%rax,1)
test %... | func0:
endbr64
push rbp
movsxd rdi, edi
mov rbp, rsi
push rbx
mov rbx, rdi
shl rdi, 2; size
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
xor r9d, r9d
mov edi, 2
mov r10, rax
cmp ebx, 2
jle short loc_16F0
nop dword ptr [rax+rax+00h]
loc_16A8:
movsxd r11, r9d
lea... | int * func0(int a1, int *a2)
{
int *result; // rax
int v5; // r9d
int v6; // edi
int *i; // rsi
int v8; // ecx
result = (int *)malloc(4LL * a1);
*a2 = 0;
v5 = 0;
v6 = 2;
if ( a1 > 2 )
{
do
{
if ( v5 > 0 )
{
LABEL_3:
for ( i = result; &result[v5] != i; ++i )
{
... | func0:
ENDBR64
PUSH RBP
MOVSXD RDI,EDI
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
MOV dword ptr [RBP],0x0
XOR R9D,R9D
MOV EDI,0x2
MOV R10,RAX
CMP EBX,0x2
JLE 0x001016f0
NOP dword ptr [RAX + RAX*0x1]
LAB_001016a8:
MOVSXD R11,R9D
LEA R8,[R10 + R11*0x4]
TEST R9D,R9D
JLE 0x001016dd
LAB_001016b... | int * func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
piVar2 = (int *)malloc((long)param_1 << 2);
*param_2 = 0;
iVar5 = 0;
iVar4 = 2;
if (2 < param_1) {
do {
piVar3 = piVar2;
if (0 < iVar5) {
do {
while( true ) {
... |
1,044 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
} | #include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
sar $0x1f,%eax
mov %eax,%edx
xor -0x4(%rbp),%edx
sub %eax,%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
mov edx, eax
neg edx
cmovs edx, eax
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ec... | long long func0(int a1, int a2)
{
int v2; // edx
int v3; // eax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = a2;
if ( a2 <= 0 )
v3 = -a2;
return (unsigned int)(v3 % 10 * (v2 % 10));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,... | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = -param_1;
if (0 < param_1) {
iVar1 = param_1;
}
if (param_2 < 1) {
param_2 = -param_2;
}
return (iVar1 % 10) * (param_2 % 10);
} |
1,045 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
} | #include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
} | O1 | c | func0:
endbr64
mov %edi,%eax
cltd
xor %edx,%eax
sub %edx,%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %eax,%ecx
sar $0x1f,%ecx
sub %ecx,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
mov %esi,%edx
sar $0x1f,%edx
xor %edx,%esi
sub %edx,%esi
movs... | func0:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
mov ecx, eax
sar ecx, 1Fh
sub edx, ecx
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov ecx, esi
neg ecx
cmovs ecx, esi
movsxd rdx, ecx
imul rdx, 66666667h
sar ... | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // eax
int v4; // ecx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 10;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return (unsigned int)(v4 % 10 * v3);
} | func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV ECX,EAX
SAR ECX,0x1f
SUB EDX,ECX
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV ECX,ESI
NEG ECX
CMOVS ECX,ESI
MOVSXD RDX,ECX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV ESI,ECX
SAR ESI,0x1f
SUB EDX,ESI
LEA EDX,[RD... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
iVar1 = -param_1;
if (0 < param_1) {
iVar1 = param_1;
}
iVar2 = -param_2;
if (0 < param_2) {
iVar2 = param_2;
}
return (iVar1 % 10) * (iVar2 % 10);
} |
1,046 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
} | #include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
} | O2 | c | func0:
endbr64
mov %edi,%edx
mov %esi,%eax
mov $0xcccccccd,%esi
sar $0x1f,%edx
xor %edx,%edi
sub %edx,%edi
cltd
xor %edx,%eax
mov %edi,%ecx
sub %edx,%eax
imul %rsi,%rcx
mov %eax,%edx
imul %rsi,%rdx
shr $0x23,%rcx
lea (%rcx,%rcx,4),%ecx
shr $0x23,%rdx
add %ecx,%ecx
lea (%... | func0:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
mov edi, 0CCCCCCCDh
mov edx, eax
imul rdx, rdi
shr rdx, 23h
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov edx, esi
neg edx
cmovs edx, esi
mov ecx, edx
imul rcx, rdi
shr rcx, 23h
lea ecx, [rcx+rcx*4]
add... | long long func0(int a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // edx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 0xA;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return v4 % 0xA * v3;
} | func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOV EDI,0xcccccccd
MOV EDX,EAX
IMUL RDX,RDI
SHR RDX,0x23
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV EDX,ESI
NEG EDX
CMOVS EDX,ESI
MOV ECX,EDX
IMUL RCX,RDI
SHR RCX,0x23
LEA ECX,[RCX + RCX*0x4]
ADD ECX,ECX
SUB EDX,ECX
IMUL EAX,EDX
RET | int func0(uint param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = -param_1;
if (0 < (int)param_1) {
uVar1 = param_1;
}
uVar2 = (ulong)-param_2;
if (0 < (int)param_2) {
uVar2 = (ulong)param_2;
}
return (uVar1 % 10) * ((int)uVar2 + (int)(uVar2 / 10) * -10);
} |
1,047 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a, int b) {
return (abs(a) % 10) * (abs(b) % 10);
} | #include <assert.h>
int main() {
assert(func0(148, 412) == 16);
assert(func0(19, 28) == 72);
assert(func0(2020, 1851) == 0);
assert(func0(14, -15) == 20);
assert(func0(76, 67) == 42);
assert(func0(17, 27) == 49);
assert(func0(0, 1) == 0);
assert(func0(0, 0) == 0);
return 0;
} | O3 | c | func0:
endbr64
mov %edi,%edx
mov %esi,%eax
mov $0xcccccccd,%esi
sar $0x1f,%edx
xor %edx,%edi
sub %edx,%edi
cltd
xor %edx,%eax
mov %edi,%ecx
sub %edx,%eax
imul %rsi,%rcx
mov %eax,%edx
imul %rsi,%rdx
shr $0x23,%rcx
lea (%rcx,%rcx,4),%ecx
shr $0x23,%rdx
add %ecx,%ecx
lea (%... | func0:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
mov edi, 0CCCCCCCDh
mov edx, eax
imul rdx, rdi
shr rdx, 23h
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov edx, esi
neg edx
cmovs edx, esi
mov ecx, edx
imul rcx, rdi
shr rcx, 23h
lea ecx, [rcx+rcx*4]
add... | long long func0(int a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // edx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 0xA;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return v4 % 0xA * v3;
} | func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOV EDI,0xcccccccd
MOV EDX,EAX
IMUL RDX,RDI
SHR RDX,0x23
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV EDX,ESI
NEG EDX
CMOVS EDX,ESI
MOV ECX,EDX
IMUL RCX,RDI
SHR RCX,0x23
LEA ECX,[RCX + RCX*0x4]
ADD ECX,ECX
SUB EDX,ECX
IMUL EAX,EDX
RET | int func0(uint param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = -param_1;
if (0 < (int)param_1) {
uVar1 = param_1;
}
uVar2 = (ulong)-param_2;
if (0 < (int)param_2) {
uVar2 = (ulong)param_2;
}
return (uVar1 % 10) * ((int)uVar2 + (int)(uVar2 / 10) * -10);
} |
1,048 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
} | #include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
lea 0xe67(%rip),%rax
mov %rax,-0x18(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 11e5 <func0+0x5c>
mov -0x1c(%rbp),%eax
add %eax,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mo... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
lea rax, aAeiou; "AEIOU"
mov [rbp+s], rax
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp short loc_11E5
loc_11B5:
mov eax, [rbp+var_1C]
add eax, eax
movsxd rdx, eax
mov rax, [rbp+var_28]
add ... | long long func0(const char *a1)
{
unsigned int v2; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
v2 = 0;
for ( i = 0; a1[i] && 2 * i < strlen(a1); ++i )
{
if ( strchr("AEIOU", a1[2 * i]) )
++v2;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001011e5
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EAX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0... | int func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
int local_28;
int local_24;
local_28 = 0;
local_24 = 0;
while( true ) {
if (param_1[local_24] == '\0') {
return local_28;
}
sVar2 = strlen(param_1);
if (sVar2 <= (ulong)(long)(local_24 * 2)) break;
pcVar1 = strchr("AEIOU"... |
1,049 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
} | #include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
} | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
cmpb $0x0,(%rdi)
je 11d7 <func0+0x6e>
mov %rdi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
shr %rcx
mov %rcx,%r13
mov $0x0,%ebx
mov $0x0,%r12d
lea 0xe5e(%rip),%r14
cmp %r... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
cmp byte ptr [rdi], 0
jz short loc_11EC
mov rbp, rdi
call _strlen
lea r13, [rax+1]
shr r13, 1
mov ebx, 0
mov r12d, 0
lea r14, s; "AEIOU"
loc_11BB:
cmp rbx, r13
jz short loc_11E0
movsx esi, byte ptr ... | long long func0(const char *a1)
{
size_t v1; // r13
long long v2; // rbx
unsigned int v3; // r12d
if ( *a1 )
{
v1 = (strlen(a1) + 1) >> 1;
v2 = 0LL;
v3 = 0;
do
{
if ( v2 == v1 )
break;
v3 -= (strchr("AEIOU", a1[2 * v2++]) == 0LL) - 1;
}
while ( a1[v2] );
}
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
CMP byte ptr [RDI],0x0
JZ 0x001011ec
MOV RBP,RDI
CALL 0x00101070
LEA R13,[RAX + 0x1]
SHR R13,0x1
MOV EBX,0x0
MOV R12D,0x0
LEA R14,[0x102004]
LAB_001011bb:
CMP RBX,R13
JZ 0x001011e0
MOVSX ESI,byte ptr [RBP + RBX*0x2]
MOV RDI,R14
CALL 0x00101080
CMP RAX,0x1
SBB ... | int func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
int iVar4;
if (*param_1 == '\0') {
iVar4 = 0;
}
else {
sVar1 = strlen(param_1);
uVar3 = 0;
iVar4 = 0;
do {
if (uVar3 == sVar1 + 1 >> 1) {
return iVar4;
}
pcVar2 = strchr("AEIOU",(int)param... |
1,050 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
} | #include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
} | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
cmpb $0x0,(%rdi)
je 1361 <func0+0x61>
mov %rdi,%r14
xor %ebx,%ebx
lea 0xce7(%rip),%r13
xor %r12d,%r12d
callq 1070 <strlen@plt>
lea 0x1(%rax),%rbp
shr %rbp
jmp 1350 <func0+0x50>
xchg %ax,%ax
movsbl (%r14,%rbx,2),%esi... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
cmp byte ptr [rdi], 0
jz short loc_1361
mov rbp, rdi
xor ebx, ebx
lea r14, s; "AEIOU"
xor r12d, r12d
call _strlen
lea r13, [rax+1]
shr r13, 1
jmp short loc_1350
loc_1330:
movsx esi, byte ptr [rbp+rbx*2+0... | long long func0(const char *a1)
{
long long v1; // rbx
unsigned int v2; // r12d
size_t v3; // r13
if ( *a1 )
{
v1 = 0LL;
v2 = 0;
v3 = (strlen(a1) + 1) >> 1;
do
{
if ( v1 == v3 )
break;
v2 -= (strchr("AEIOU", a1[2 * v1++]) == 0LL) - 1;
}
while ( a1[v1] );
}
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
CMP byte ptr [RDI],0x0
JZ 0x00101361
MOV RBP,RDI
XOR EBX,EBX
LEA R14,[0x102004]
XOR R12D,R12D
CALL 0x00101070
LEA R13,[RAX + 0x1]
SHR R13,0x1
JMP 0x00101350
LAB_00101330:
MOVSX ESI,byte ptr [RBP + RBX*0x2]
MOV RDI,R14
CALL 0x00101080
CMP RAX,0x1
SBB R12D,-0x1
... | int func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
int iVar4;
if (*param_1 == '\0') {
iVar4 = 0;
}
else {
uVar3 = 0;
iVar4 = 0;
sVar1 = strlen(param_1);
do {
if (uVar3 == sVar1 + 1 >> 1) {
return iVar4;
}
pcVar2 = strchr("AEIOU",(int)param... |
1,051 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
const char *uvowel = "AEIOU";
int count = 0;
for (int i = 0; s[i] != '\0' && i * 2 < strlen(s); i++) {
if (strchr(uvowel, s[i * 2]) != NULL) {
count += 1;
}
}
return count;
} | #include <assert.h>
int main() {
assert(func0("aBCdEf") == 1);
assert(func0("abcdefg") == 0);
assert(func0("dBBE") == 0);
assert(func0("B") == 0);
assert(func0("U") == 1);
assert(func0("") == 0);
assert(func0("EEEE") == 2);
return 0;
} | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
cmpb $0x0,(%rdi)
je 1361 <func0+0x61>
mov %rdi,%r14
xor %ebx,%ebx
lea 0xce7(%rip),%r13
xor %r12d,%r12d
callq 1070 <strlen@plt>
lea 0x1(%rax),%rbp
shr %rbp
jmp 1350 <func0+0x50>
xchg %ax,%ax
movsbl (%r14,%rbx,2),%esi... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
cmp byte ptr [rdi], 0
jz short loc_1361
mov rbp, rdi
xor ebx, ebx
lea r14, s; "AEIOU"
xor r12d, r12d
call _strlen
lea r13, [rax+1]
shr r13, 1
jmp short loc_1350
loc_1330:
movsx esi, byte ptr [rbp+rbx*2+0... | long long func0(const char *a1)
{
long long v1; // rbx
unsigned int v2; // r12d
size_t v3; // r13
if ( *a1 )
{
v1 = 0LL;
v2 = 0;
v3 = (strlen(a1) + 1) >> 1;
do
{
if ( v3 == v1 )
break;
v2 -= (strchr("AEIOU", a1[2 * v1++]) == 0LL) - 1;
}
while ( a1[v1] );
}
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
CMP byte ptr [RDI],0x0
JZ 0x00101361
MOV RBP,RDI
XOR EBX,EBX
LEA R14,[0x102004]
XOR R12D,R12D
CALL 0x00101070
LEA R13,[RAX + 0x1]
SHR R13,0x1
JMP 0x00101350
LAB_00101330:
MOVSX ESI,byte ptr [RBP + RBX*0x2]
MOV RDI,R14
CALL 0x00101080
CMP RAX,0x1
SBB R12D,-0x1
... | int func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
ulong uVar3;
int iVar4;
if (*param_1 == '\0') {
iVar4 = 0;
}
else {
uVar3 = 0;
iVar4 = 0;
sVar1 = strlen(param_1);
do {
if (sVar1 + 1 >> 1 == uVar3) {
return iVar4;
}
pcVar2 = strchr("AEIOU",(int)param... |
1,052 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
} | #include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <atof@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
pxor %xmm0,%xmm0
comisd -0x8(%rbp),%xmm0
jbe 11f5 <func0+0x4c>
movsd -0x8(%rbp),%xmm0
movsd 0xee2(%rip),%xmm1
subsd %xmm1... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+nptr], rdi
mov rax, [rbp+nptr]
mov rdi, rax; nptr
call _atof
movq rax, xmm0
mov [rbp+var_8], rax
pxor xmm0, xmm0
comisd xmm0, [rbp+var_8]
jbe short loc_11FF
movsd xmm0, [rbp+var_8]
movsd xmm1, cs:qword_20A8
subsd x... | long long func0(const char *a1)
{
double v2; // [rsp+18h] [rbp-8h]
v2 = atof(a1);
if ( v2 >= 0.0 )
return (unsigned int)(int)floor(v2 + 0.5);
else
return (unsigned int)(int)ceil(v2 - 0.5);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x8],RAX
PXOR XMM0,XMM0
COMISD XMM0,qword ptr [RBP + -0x8]
JBE 0x001011ff
MOVSD XMM0,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [0x001020a8]
S... | int func0(char *param_1)
{
double dVar1;
dVar1 = atof(param_1);
if (0.0 <= dVar1) {
dVar1 = floor(dVar1 + DAT_001020a8);
}
else {
dVar1 = ceil(dVar1 - DAT_001020a8);
}
return (int)dVar1;
} |
1,053 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
} | #include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
} | O1 | c | func0:
endbr64
sub $0x8,%rsp
mov $0x0,%esi
callq 1060 <strtod@plt>
pxor %xmm1,%xmm1
comisd %xmm0,%xmm1
ja 11eb <func0+0x82>
addsd 0xf33(%rip),%xmm0
movapd %xmm0,%xmm1
movsd 0xf47(%rip),%xmm3
movapd %xmm0,%xmm2
andpd %xmm3,%xmm2
movsd 0xf1f(%rip),%xmm4
ucomisd %xmm2,%xmm4
jbe 11e2 <func0+0x79>
cvttsd... | func0:
endbr64
sub rsp, 8
mov esi, 0; endptr
call _strtod
pxor xmm1, xmm1
comisd xmm1, xmm0
ja short loc_11EB
addsd xmm0, cs:qword_20A0
movapd xmm3, xmm0
movsd xmm2, cs:qword_20B8
movapd xmm1, xmm0
andpd xmm1, xmm2
movsd xmm4, cs:qword_20A8
ucomisd xmm4, xmm1
jbe short loc_11E2
cvttsd2... | long long func0(const char *a1, __m128d a2)
{
double v2; // xmm0_8
__m128d v3; // xmm0
double v4; // xmm3_8
__m128d v5; // xmm1
unsigned long long v7; // xmm3_8
__m128d v8; // xmm1
v2 = strtod(a1, 0LL);
if ( v2 < 0.0 )
{
a2.m128d_f64[0] = v2 - 0.5;
v7 = *(unsigned long long *)&a2.m128d_f64[0... | func0:
ENDBR64
SUB RSP,0x8
MOV ESI,0x0
CALL 0x00101060
PXOR XMM1,XMM1
COMISD XMM1,XMM0
JA 0x001011eb
ADDSD XMM0,qword ptr [0x001020a0]
MOVAPD XMM3,XMM0
MOVSD XMM2,qword ptr [0x001020b8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVSD XMM4,qword ptr [0x001020a8]
UCOMISD XMM4,XMM1
JBE 0x001011e2
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(char *param_1)
{
double dVar1;
dVar1 = strtod(param_1,(char **)0x0);
if (dVar1 < 0.0) {
dVar1 = dVar1 - _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
dVar1 = (double)((ulo... |
1,054 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
} | #include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
} | O2 | c | func0:
endbr64
sub $0x8,%rsp
xor %esi,%esi
callq 1060 <strtod@plt>
pxor %xmm1,%xmm1
comisd %xmm0,%xmm1
ja 1310 <func0+0x90>
addsd 0xe1f(%rip),%xmm0
movsd 0xe37(%rip),%xmm2
movsd 0xe17(%rip),%xmm3
movapd %xmm0,%xmm1
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
ja 12d0 <func0+0x50>
cvttsd2si %xmm0,%eax
add ... | func0:
endbr64
sub rsp, 8
xor esi, esi; endptr
call _strtod
pxor xmm1, xmm1
comisd xmm1, xmm0
ja short loc_1310
addsd xmm0, cs:qword_20A0
movsd xmm2, cs:qword_20B8
movsd xmm3, cs:qword_20A8
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
ja short loc_12D0
loc_12BF:
cvttsd2si eax,... | long long func0(const char *a1, __m128d a2)
{
double v2; // xmm0_8
__m128d v4; // xmm1
__m128d v5; // xmm1
v2 = strtod(a1, 0LL);
if ( v2 < 0.0 )
{
a2.m128d_f64[0] = v2 - 0.5;
if ( fabs(a2.m128d_f64[0]) >= 4.503599627370496e15 )
return (unsigned int)(int)a2.m128d_f64[0];
v5.m128d_f64[0] =... | func0:
ENDBR64
SUB RSP,0x8
XOR ESI,ESI
CALL 0x00101060
PXOR XMM1,XMM1
COMISD XMM1,XMM0
JA 0x00101310
ADDSD XMM0,qword ptr [0x001020a0]
MOVSD XMM2,qword ptr [0x001020b8]
MOVSD XMM3,qword ptr [0x001020a8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JA 0x001012d0
LAB_001012bf:
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET
LAB... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(char *param_1)
{
double dVar1;
dVar1 = strtod(param_1,(char **)0x0);
if (dVar1 < 0.0) {
dVar1 = dVar1 - _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
return (int)(double)(... |
1,055 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(const char *value) {
double w;
w = atof(value);
return (int)(w < 0 ? ceil(w - 0.5) : floor(w + 0.5));
} | #include <assert.h>
int main() {
assert(func0("10") == 10);
assert(func0("14.5") == 15);
assert(func0("-15.5") == -16);
assert(func0("15.3") == 15);
assert(func0("0") == 0);
return 0;
} | O3 | c | func0:
endbr64
sub $0x8,%rsp
xor %esi,%esi
callq 1060 <strtod@plt>
pxor %xmm1,%xmm1
comisd %xmm0,%xmm1
ja 1310 <func0+0x90>
addsd 0xe1f(%rip),%xmm0
movsd 0xe37(%rip),%xmm2
movsd 0xe17(%rip),%xmm3
movapd %xmm0,%xmm1
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
ja 12d0 <func0+0x50>
cvttsd2si %xmm0,%eax
add ... | func0:
endbr64
sub rsp, 8
xor esi, esi; endptr
call _strtod
pxor xmm1, xmm1
comisd xmm1, xmm0
ja short loc_1310
addsd xmm0, cs:qword_20A0
movsd xmm2, cs:qword_20B8
movsd xmm3, cs:qword_20A8
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
ja short loc_12D0
loc_12BF:
cvttsd2si eax,... | long long func0(const char *a1, __m128d a2)
{
double v2; // xmm0_8
__m128d v4; // xmm1
__m128d v5; // xmm1
v2 = strtod(a1, 0LL);
if ( v2 < 0.0 )
{
a2.m128d_f64[0] = v2 - 0.5;
if ( fabs(a2.m128d_f64[0]) >= 4.503599627370496e15 )
return (unsigned int)(int)a2.m128d_f64[0];
v5.m128d_f64[0] =... | func0:
ENDBR64
SUB RSP,0x8
XOR ESI,ESI
CALL 0x00101060
PXOR XMM1,XMM1
COMISD XMM1,XMM0
JA 0x00101310
ADDSD XMM0,qword ptr [0x001020a0]
MOVSD XMM2,qword ptr [0x001020b8]
MOVSD XMM3,qword ptr [0x001020a8]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JA 0x001012d0
LAB_001012bf:
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET
LAB... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(char *param_1)
{
double dVar1;
dVar1 = strtod(param_1,(char **)0x0);
if (dVar1 < 0.0) {
dVar1 = dVar1 - _DAT_001020a0;
if ((double)((ulong)dVar1 & DAT_001020b8) < DAT_001020a8) {
return (int)(double)(... |
1,056 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
} | #include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
mov -0x14(%rbp),%edx
mov %edx,(%rax)
movl $0x1,-0xc(%rbp)
jmp 1212 <func0+0x69>
mov -0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov edx, [rbp+var_14]
mov [rax], edx
mov [rbp+var_C], 1
jmp short loc_1212
loc_11D... | _DWORD * func0(int a1)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v3; // [rsp+18h] [rbp-8h]
v3 = malloc(4LL * a1);
*v3 = a1;
for ( i = 1; i < a1; ++i )
v3[i] = v3[i - 1] + 2;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x14]
MOV dword ptr [RAX],EDX
MOV dword ptr [RBP + -0xc],0x1
JMP 0x0010121... | int * func0(int param_1)
{
int *piVar1;
int local_14;
piVar1 = (int *)malloc((long)param_1 << 2);
*piVar1 = param_1;
for (local_14 = 1; local_14 < param_1; local_14 = local_14 + 1) {
piVar1[local_14] = piVar1[(long)local_14 + -1] + 2;
}
return piVar1;
} |
1,057 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
} | #include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) ... | O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %ebx,(%rax)
cmp $0x1,%ebx
jle 11df <func0+0x36>
mov %rax,%rdx
lea -0x2(%rbx),%ecx
lea 0x4(%rax,%rcx,4),%rsi
mov (%rdx),%ebx
lea 0x2(%rbx),%ecx
mov %ecx,0x4(%rdx)
add $0x4,%rdx
cmp ... | func0:
endbr64
push rbx
mov ebx, edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov [rax], ebx
cmp ebx, 1
jle short loc_11DE
mov rdx, rax
lea ecx, [rbx-1]
lea rsi, [rax+rcx*4]
loc_11CD:
mov ebx, [rdx]
lea ecx, [rbx+2]
mov [rdx+4], ecx
add rdx, 4
cmp rdx, rsi... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
_DWORD *v2; // rdx
result = malloc(4LL * a1);
*result = a1;
if ( a1 > 1 )
{
v2 = result;
do
{
v2[1] = *v2 + 2;
++v2;
}
while ( v2 != &result[a1 - 1] );
}
return result;
} | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],EBX
CMP EBX,0x1
JLE 0x001011de
MOV RDX,RAX
LEA ECX,[RBX + -0x1]
LEA RSI,[RAX + RCX*0x4]
LAB_001011cd:
MOV EBX,dword ptr [RDX]
LEA ECX,[RBX + 0x2]
MOV dword ptr [RDX + 0x4],ECX
ADD RDX,0x4
CMP RDX,RSI
JNZ 0x001011cd
LAB_00... | void func0(int param_1)
{
int *piVar1;
int *piVar2;
piVar2 = (int *)malloc((long)param_1 << 2);
*piVar2 = param_1;
if (1 < param_1) {
piVar1 = piVar2 + (param_1 - 1);
do {
piVar2[1] = *piVar2 + 2;
piVar2 = piVar2 + 1;
} while (piVar2 != piVar1);
}
return;
} |
1,058 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
} | #include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) ... | O2 | c | func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %ebx,(%rax)
cmp $0x1,%ebx
jle 145e <func0+0x3e>
lea -0x2(%rbx),%ecx
lea 0x4(%rax),%rdx
lea 0x4(%rax,%rcx,4),%rcx
jmp 1454 <func0+0x34>
nopl 0x0(%rax)
add $0x4,%rdx
add $0x2,%ebx
mov ... | func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
mov [rax], ebx
cmp ebx, 1
jle short loc_140F
lea ecx, [rbx-2]
lea rdx, [rax+4]
lea rcx, [rax+rcx*4+8]
nop word ptr [rax+rax+00000000h]
loc_1400:
add ebx, 2
add rdx, 4
mov [rdx-4], eb... | _DWORD * func0(int a1)
{
int v1; // ebx
_DWORD *result; // rax
_DWORD *v3; // rdx
v1 = a1;
result = malloc(4LL * a1);
*result = a1;
if ( a1 > 1 )
{
v3 = result + 1;
do
{
v1 += 2;
*v3++ = v1;
}
while ( v3 != &result[a1 - 2 + 2] );
}
return result;
} | func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],EBX
CMP EBX,0x1
JLE 0x0010140f
LEA ECX,[RBX + -0x2]
LEA RDX,[RAX + 0x4]
LEA RCX,[RAX + RCX*0x4 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101400:
ADD EBX,0x2
ADD RDX,0x4
MOV dword ptr [RDX + -0x4],EBX
CMP RDX,RCX
JNZ 0x001... | void func0(int param_1)
{
int *piVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
ulong uVar5;
uVar5 = (ulong)param_1;
piVar1 = (int *)malloc(uVar5 << 2);
*piVar1 = param_1;
if (1 < param_1) {
puVar2 = (uint *)(piVar1 + 1);
do {
uVar4 = (int)uVar5 + 2;
uVar5 = (ulong)uVar4;
... |
1,059 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
*out = n;
for (int i = 1; i < n; i++)
*(out + i) = *(out + i - 1) + 2;
return out;
} | #include <assert.h>
#include <stdbool.h>
int main() {
int* result;
int test1[] = {3, 5, 7};
int test2[] = {4, 6, 8, 10};
int test3[] = {5, 7, 9, 11, 13};
int test4[] = {6, 8, 10, 12, 14, 16};
int test5[] = {8, 10, 12, 14, 16, 18, 20, 22};
result = func0(3);
for (int i = 0; i < 3; i++) ... | O3 | c | func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %ebx,(%rax)
cmp $0x1,%ebx
jle 1455 <func0+0x35>
lea 0x2(%rbx),%edx
lea 0x4(%rax),%rcx
lea (%rbx,%rbx,2),%esi
nopl (%rax)
mov %edx,(%rcx)
add $0x2,%edx
add $0x4,%rcx
cmp %esi,%edx
jn... | func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
mov [rax], ebx
cmp ebx, 1
jle short loc_13AF
lea ecx, [rbx-2]
lea rdx, [rax+4]
lea rcx, [rax+rcx*4+8]
nop word ptr [rax+rax+00000000h]
loc_13A0:
add ebx, 2
add rdx, 4
mov [rdx-4], eb... | _DWORD * func0(int a1)
{
int v1; // ebx
_DWORD *result; // rax
_DWORD *v3; // rdx
v1 = a1;
result = malloc(4LL * a1);
*result = a1;
if ( a1 > 1 )
{
v3 = result + 1;
do
{
v1 += 2;
*v3++ = v1;
}
while ( v3 != &result[a1 - 2 + 2] );
}
return result;
} | func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x00101090
MOV dword ptr [RAX],EBX
CMP EBX,0x1
JLE 0x001013af
LEA ECX,[RBX + -0x2]
LEA RDX,[RAX + 0x4]
LEA RCX,[RAX + RCX*0x4 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001013a0:
ADD EBX,0x2
ADD RDX,0x4
MOV dword ptr [RDX + -0x4],EBX
CMP RDX,RCX
JNZ 0x001... | void func0(int param_1)
{
int *piVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
ulong uVar5;
uVar5 = (ulong)param_1;
piVar1 = (int *)malloc(uVar5 << 2);
*piVar1 = param_1;
if (1 < param_1) {
puVar2 = (uint *)(piVar1 + 1);
do {
uVar4 = (int)uVar5 + 2;
uVar5 = (ulong)uVar4;
... |
1,060 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > ... | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
movl $0xa,-0x30(%rbp)
mov -0x30(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@p... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov [rbp+var_30], 0Ah
mov eax, [rbp+var_30]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
add r... | _QWORD * func0(const char *a1, int *a2)
{
size_t v2; // rax
int v3; // eax
int v4; // eax
int v5; // eax
int v7; // [rsp+10h] [rbp-30h]
int v8; // [rsp+14h] [rbp-2Ch]
int v9; // [rsp+18h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-24h]
_QWORD *ptr; // [rsp+20h] [rbp-20h]
char *v12; // [rsp+28h] [rbp-18h]
... | 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 dword ptr [RBP + -0x30],0xa
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010... | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
char *__s;
char *pcVar3;
int local_38;
int local_34;
int local_30;
int local_2c;
void *local_28;
local_38 = 10;
local_28 = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
local_34 = 0;
local_30 ... |
1,061 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > ... | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %rsi,0x8(%rsp)
mov $0x50,%edi
callq 10f0 <malloc@plt>
mov %rax,%r13
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov [rsp+48h+var_40], rsi
mov edi, 50h ; 'P'; size
call _malloc
mov r13, rax
mov rdi, rbx; s
call _strlen
lea rdi, [rax+1]; size
call _malloc
mov r12, rax
movzx eax... | _QWORD * func0(char *s, int *a2)
{
_QWORD *v2; // r13
size_t v3; // rax
char *v4; // r12
char v5; // al
char *v6; // rbx
int v7; // edx
int v8; // ebp
int v9; // r15d
v2 = malloc(0x50uLL);
v3 = strlen(s);
v4 = (char *)malloc(v3 + 1);
v5 = *s;
if ( *s )
{
v6 = s + 1;
v7 = 0;
v8 =... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV EDI,0x50
CALL 0x00101110
MOV R13,RAX
MOV RDI,RBX
CALL 0x001010d0
LEA RDI,[RAX + 0x1]
CALL 0x00101110
MOV R12,RAX
MOVZX EAX,byte ptr [RBX]
TEST AL,AL
JZ 0x00101330
ADD RBX,0x1
MOV EDX,0x0
MOV E... | void * func0(char *param_1,int *param_2)
{
char cVar1;
void *__ptr;
size_t sVar2;
char *__s;
char *pcVar3;
char *pcVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
__ptr = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
cVar1 = *param_1;
if (cVar1 == '\0') {
... |
1,062 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > ... | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov $0x50,%edi
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
callq 1110 <malloc@plt>
mov %rbx,%rdi
mov %rax,%r12
callq 10d0 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1110 <malloc@plt>
mov %rax,%r14
movzbl (%r... | func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 50h ; 'P'; size
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
mov rdi, r14; s
mov rbp, rax
call _strlen
lea rdi, [rax+1]; size
call _malloc
mov r12, rax
movzx eax... | _QWORD * func0(char *s, _DWORD *a2)
{
_QWORD *v2; // rbp
size_t v3; // rax
char *v4; // r12
char v5; // al
char *v6; // r14
int v7; // ebx
long long v8; // r15
int v9; // r13d
long long v10; // rcx
v2 = malloc(0x50uLL);
v3 = strlen(s);
v4 = (char *)malloc(v3 + 1);
v5 = *s;
if ( !*s )
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x50
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x00101110
MOV RDI,R14
MOV RBP,RAX
CALL 0x001010d0
LEA RDI,[RAX + 0x1]
CALL 0x00101110
MOV R12,RAX
MOVZX EAX,byte ptr [R14]
TEST AL,AL
JZ 0x001017a0
ADD R14,0x1
XOR EBX,EBX
XOR R... | void * func0(char *param_1,int4 *param_2)
{
char cVar1;
void *__ptr;
size_t sVar2;
char *__s;
char *pcVar3;
char *pcVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
ulong uVar9;
__ptr = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
cVar1 = *param_1;
if (cV... |
1,063 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* s, int* count) {
int capacity = 10;
char** out = malloc(capacity * sizeof(char*));
char* current = malloc(strlen(s) + 1);
int word_count = 0;
int current_length = 0;
for (int i = 0; s[i]; i++) {
if (s[i] == ' ' || s[i] == ',') {
if (current_length > ... | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
bool issame(char** a, int a_count, char** b, int b_count) {
if (a_count != b_count) return false;
for (int i = 0; i < a_count; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
void free_words(char... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov $0x50,%edi
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
callq 1110 <malloc@plt>
mov %rbx,%rdi
mov %rax,%r12
callq 10d0 <strlen@plt>
lea 0x1(%rax),%rdi
callq 1110 <malloc@plt>
mov %rax,%r14
movzbl (%r... | func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 50h ; 'P'; size
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _malloc
mov rdi, r14; s
mov rbp, rax
call _strlen
lea rdi, [rax+1]; size
call _malloc
mov r12, rax
movzx eax... | _QWORD * func0(char *s, _DWORD *a2)
{
_QWORD *v2; // rbp
size_t v3; // rax
char *v4; // r12
char v5; // al
char *v6; // r14
int v7; // ebx
long long v8; // r15
int v9; // r13d
long long v10; // rcx
v2 = malloc(0x50uLL);
v3 = strlen(s);
v4 = (char *)malloc(v3 + 1);
v5 = *s;
if ( !*s )
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x50
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x00101110
MOV RDI,R14
MOV RBP,RAX
CALL 0x001010d0
LEA RDI,[RAX + 0x1]
CALL 0x00101110
MOV R12,RAX
MOVZX EAX,byte ptr [R14]
TEST AL,AL
JZ 0x001017a0
ADD R14,0x1
XOR EBX,EBX
XOR R... | void * func0(char *param_1,int4 *param_2)
{
char cVar1;
void *__ptr;
size_t sVar2;
char *__s;
char *pcVar3;
char *pcVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
ulong uVar9;
__ptr = malloc(0x50);
sVar2 = strlen(param_1);
__s = (char *)malloc(sVar2 + 1);
cVar1 = *param_1;
if (cV... |
1,064 | func0 | #include <stdio.h>
| int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
} | #include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jge 1166 <func0+0x1d>
mov $0xffffffff,%eax
jmp 11a6 <func0+0x5d>
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jne 1188 <func0+0x3f>
mov -0x8(%rbp),%eax
cltd
shr $0x1... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jge short loc_1166
mov eax, 0FFFFFFFFh
jmp short loc_11B2
loc_1166:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jnz short loc_118E
mov edx, [rbp+var_8... | long long func0(int a1, signed int a2)
{
if ( a2 < a1 )
return 0xFFFFFFFFLL;
if ( a2 == a1 && a2 % 2 == 1 )
return 0xFFFFFFFFLL;
if ( a2 % 2 == 1 )
return (unsigned int)(a2 - 1);
return (unsigned int)a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JGE 0x00101166
MOV EAX,0xffffffff
JMP 0x001011b2
LAB_00101166:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JNZ 0x0010118e
MOV EDX,dword ptr [R... | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
param_2 = -1;
}
else if ((param_2 == param_1) && (param_2 % 2 == 1)) {
param_2 = -1;
}
else if (param_2 % 2 == 1) {
param_2 = param_2 + -1;
}
return param_2;
} |
1,065 | func0 | #include <stdio.h>
| int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
} | #include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return ... | O1 | c | func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1167 <func0+0x3e>
je 114e <func0+0x25>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx... | func0:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1167
jz short loc_114E
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_114E:
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and ... | long long func0(int a1, signed int a2)
{
long long result; // rax
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
if ( a2 != a1 )
return a2 - (unsigned int)(a2 % 2 == 1);
if ( a2 % 2 == 1 )
return 0xFFFFFFFFLL;
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101167
JZ 0x0010114e
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_0010114e:
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX... | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
} |
1,066 | func0 | #include <stdio.h>
| int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
} | #include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return ... | O2 | c | func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1180 <func0+0x40>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp %edi,%esi
je 1170 <func0+0x30>
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
cmp $0x1,%edx
mo... | func0:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1180
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp esi, edi
jz short loc_1170
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_1170:
cmp edx, 1
mov edx, 0FFFFFFFFh
cmovz ... | long long func0(int a1, signed int a2)
{
long long result; // rax
int v3; // edx
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
v3 = a2 % 2;
if ( a2 != a1 )
return a2 - (unsigned int)(v3 == 1);
if ( v3 == 1 )
return 0xFFFFFFFFLL;
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101180
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP ESI,EDI
JZ 0x00101170
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_00101170:
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
} |
1,067 | func0 | #include <stdio.h>
| int func0(int x, int y) {
if (y < x) return -1;
if (y == x && y % 2 == 1) return -1;
if (y % 2 == 1) return y - 1;
return y;
} | #include <assert.h>
int main() {
assert(func0(12, 15) == 14);
assert(func0(13, 12) == -1);
assert(func0(33, 12354) == 12354);
assert(func0(5234, 5233) == -1);
assert(func0(6, 29) == 28);
assert(func0(27, 10) == -1);
assert(func0(7, 7) == -1);
assert(func0(546, 546) == 546);
return ... | O3 | c | func0:
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1180 <func0+0x40>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp %edi,%esi
je 1170 <func0+0x30>
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
cmp $0x1,%edx
mo... | func0:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1180
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp esi, edi
jz short loc_1170
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_1170:
cmp edx, 1
mov edx, 0FFFFFFFFh
cmovz ... | long long func0(int a1, signed int a2)
{
long long result; // rax
int v3; // edx
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
v3 = a2 % 2;
if ( a2 != a1 )
return a2 - (unsigned int)(v3 == 1);
if ( v3 == 1 )
return 0xFFFFFFFFLL;
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101180
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP ESI,EDI
JZ 0x00101170
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_00101170:
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
} |
1,068 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
ass... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 11af <func0+0x26>
lea 0xe5e(%rip),%rax
jmpq 1242 <func0+0xb9>
mov -0x18(%rbp),%edx
mov -0x14(%rbp),%eax
add %edx,%eax
mov %eax,%edx
shr ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jle short loc_11AF
lea rax, a1; "-1"
jmp locret_1248
loc_11AF:
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
add eax, edx
mov edx... | const char * func0(int a1, int a2)
{
int v3; // eax
int v4; // [rsp+10h] [rbp-10h]
int v5; // [rsp+14h] [rbp-Ch]
_BYTE *v6; // [rsp+18h] [rbp-8h]
if ( a1 > a2 )
return "-1";
v4 = (a2 + a1) / 2;
v6 = malloc(0x21uLL);
*v6 = 0;
v5 = 31;
v6[32] = 0;
do
{
v3 = v5--;
v6[v3] = v4 % 2 + 48;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x001011af
LEA RAX,[0x102008]
JMP 0x00101248
LAB_001011af:
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
MOV ... | int * func0(int param_1,int param_2)
{
int iVar1;
char cVar2;
int *puVar3;
int local_18;
int local_14;
if (param_2 < param_1) {
puVar3 = &DAT_00102008;
}
else {
local_18 = (param_1 + param_2) / 2;
puVar3 = (int *)malloc(0x21);
*puVar3 = 0;
puVar3[0x20] = 0;
local_14 = 0x1f;
... |
1,069 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
ass... | O1 | c | func0:
endbr64
lea 0xe90(%rip),%rax
cmp %esi,%edi
jle 1179 <func0+0x10>
retq
push %rbx
add %esi,%edi
mov %edi,%ebx
shr $0x1f,%ebx
add %edi,%ebx
sar %ebx
mov $0x21,%edi
callq 1070 <malloc@plt>
movb $0x0,(%rax)
movb $0x0,0x20(%rax)
mov $0x1e,%ecx
mov %ecx,%edi
mov %ebx,%esi
shr ... | func0:
endbr64
lea r8, a1; "-1"
cmp edi, esi
jle short loc_119C
mov rax, r8
retn
loc_119C:
push rbx
add edi, esi
mov ebx, edi
shr ebx, 1Fh
add ebx, edi
sar ebx, 1
mov edi, 21h ; '!'; size
call _malloc
mov byte ptr [rax], 0
mov byte ptr [rax+20h], 0
add rax, 1Fh
... | const char * func0(int a1, int a2)
{
int v3; // ebx
_BYTE *v4; // rax
_BYTE *v5; // rax
_BYTE *v6; // r8
int v7; // ecx
if ( a1 > a2 )
return "-1";
v3 = (a2 + a1) / 2;
v4 = malloc(0x21uLL);
*v4 = 0;
v4[32] = 0;
v5 = v4 + 31;
do
{
v6 = v5;
*v5 = v3 % 2 + 48;
v7 = v3;
v3 /= ... | func0:
ENDBR64
LEA R8,[0x102004]
CMP EDI,ESI
JLE 0x0010119c
MOV RAX,R8
RET
LAB_0010119c:
PUSH RBX
ADD EDI,ESI
MOV EBX,EDI
SHR EBX,0x1f
ADD EBX,EDI
SAR EBX,0x1
MOV EDI,0x21
CALL 0x00101090
MOV byte ptr [RAX],0x0
MOV byte ptr [RAX + 0x20],0x0
ADD RAX,0x1f
LAB_001011bd:
MOV R8,RAX
MOV ECX,EBX
SHR ECX,0x1f
LEA EDX,[RBX + R... | char * func0(int param_1,int param_2)
{
char cVar1;
char *pcVar2;
int *puVar3;
char *pcVar4;
int iVar5;
int iVar6;
if (param_2 < param_1) {
return "-1";
}
iVar5 = (param_1 + param_2) - (param_1 + param_2 >> 0x1f);
puVar3 = (int *)malloc(0x21);
*puVar3 = 0;
puVar3[0x20] = 0;
pcVar2 = pu... |
1,070 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
ass... | O2 | c | func0:
endbr64
cmp %esi,%edi
jle 14e0 <func0+0x10>
lea 0xb25(%rip),%rax
retq
jmp 1470 <func0.part.0>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0_part_0:
add edi, esi
push rbx
mov ebx, edi
shr ebx, 1Fh
add ebx, edi
mov edi, 21h ; '!'; size
call _malloc
sar ebx, 1
mov byte ptr [rax], 0
add rax, 1Fh
mov byte ptr [rax+1], 0
nop dword ptr [rax+00000000h]
loc_1478:
mov ecx, ebx
mov rsi, rax
sub rax, 1
sh... | _BYTE * func0_part_0(int a1, int a2)
{
_BYTE *v2; // rax
int v3; // ebx
_BYTE *v4; // rax
_BYTE *v5; // rsi
int v6; // edx
v2 = malloc(0x21uLL);
v3 = (a2 + a1) / 2;
*v2 = 0;
v4 = v2 + 31;
v4[1] = 0;
do
{
v5 = v4--;
v4[1] = v3 % 2 + 48;
v6 = v3;
v3 /= 2;
}
while ( v6 > 1 );
... | func0.part.0:
ADD EDI,ESI
PUSH RBX
MOV EBX,EDI
SHR EBX,0x1f
ADD EBX,EDI
MOV EDI,0x21
CALL 0x00101090
SAR EBX,0x1
MOV byte ptr [RAX],0x0
ADD RAX,0x1f
MOV byte ptr [RAX + 0x1],0x0
NOP dword ptr [RAX]
LAB_00101478:
MOV ECX,EBX
MOV RSI,RAX
SUB RAX,0x1
SHR ECX,0x1f
LEA EDX,[RBX + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
ADD EDX,0x3... | char * func0_part_0(int param_1,int param_2)
{
char *pcVar1;
int *puVar2;
char *pcVar3;
int iVar4;
int iVar5;
iVar4 = (param_1 + param_2) - (param_1 + param_2 >> 0x1f);
puVar2 = (int *)malloc(0x21);
*puVar2 = 0;
puVar2[0x20] = 0;
pcVar1 = puVar2 + 0x1f;
do {
pcVar3 = pcVar1;
iVar5 = iV... |
1,071 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int n, int m) {
if (n > m) return "-1";
int num = (m + n) / 2;
char* out = (char*)malloc(33);
out[0] = '\0';
int index = 32;
out[index--] = '\0';
do {
out[index--] = '0' + num % 2;
num /= 2;
} while (num > 0);
return &out[index + 1];
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 5), "11") == 0);
assert(strcmp(func0(7, 13), "1010") == 0);
assert(strcmp(func0(964, 977), "1111001010") == 0);
assert(strcmp(func0(996, 997), "1111100100") == 0);
assert(strcmp(func0(560, 851), "1011000001") == 0);
ass... | O3 | c | func0:
endbr64
cmp %esi,%edi
jle 14e0 <func0+0x10>
lea 0xb25(%rip),%rax
retq
add %esi,%edi
push %rbx
mov %edi,%ebx
shr $0x1f,%ebx
add %edi,%ebx
mov $0x21,%edi
callq 1070 <malloc@plt>
sar %ebx
mov $0x1e,%ecx
movb $0x0,(%rax)
movb $0x0,0x20(%rax)
nopw 0x0(%rax,%rax,1)
mov %ebx,%e... | func0_part_0:
add edi, esi
push rbx
mov ebx, edi
shr ebx, 1Fh
add ebx, edi
mov edi, 21h ; '!'; size
call _malloc
sar ebx, 1
mov byte ptr [rax], 0
add rax, 1Fh
mov byte ptr [rax+1], 0
nop dword ptr [rax+00000000h]
loc_1478:
mov ecx, ebx
mov rsi, rax
sub rax, 1
sh... | _BYTE * func0_part_0(int a1, int a2)
{
_BYTE *v2; // rax
int v3; // ebx
_BYTE *v4; // rax
_BYTE *v5; // rsi
int v6; // edx
v2 = malloc(0x21uLL);
v3 = (a2 + a1) / 2;
*v2 = 0;
v4 = v2 + 31;
v4[1] = 0;
do
{
v5 = v4--;
v4[1] = v3 % 2 + 48;
v6 = v3;
v3 /= 2;
}
while ( v6 > 1 );
... | func0.part.0:
ADD EDI,ESI
PUSH RBX
MOV EBX,EDI
SHR EBX,0x1f
ADD EBX,EDI
MOV EDI,0x21
CALL 0x00101090
SAR EBX,0x1
MOV byte ptr [RAX],0x0
ADD RAX,0x1f
MOV byte ptr [RAX + 0x1],0x0
NOP dword ptr [RAX]
LAB_00101478:
MOV ECX,EBX
MOV RSI,RAX
SUB RAX,0x1
SHR ECX,0x1f
LEA EDX,[RBX + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
ADD EDX,0x3... | char * func0_part_0(int param_1,int param_2)
{
char *pcVar1;
int *puVar2;
char *pcVar3;
int iVar4;
int iVar5;
iVar4 = (param_1 + param_2) - (param_1 + param_2 >> 0x1f);
puVar2 = (int *)malloc(0x21);
*puVar2 = 0;
puVar2[0x20] = 0;
pcVar1 = puVar2 + 0x1f;
do {
pcVar3 = pcVar1;
iVar5 = iV... |
1,072 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
| void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if ... | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int t... | 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 %rcx,-0x40(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdx
mov -0x38(%rbp),%rax
mov %rdx,(%rax)
mov -0x40(%... | 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 [rbp+var_40], rcx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_38]
mov [rax], rdx
mov ... | long long func0(long long a1, int a2, void **a3, _DWORD *a4)
{
long long result; // rax
bool v7; // [rsp+2Bh] [rbp-15h]
int i; // [rsp+2Ch] [rbp-14h]
int v9; // [rsp+30h] [rbp-10h]
int j; // [rsp+34h] [rbp-Ch]
int k; // [rsp+38h] [rbp-8h]
int v12; // [rsp+3Ch] [rbp-4h]
*a3 = malloc(4LL * a2);
*a4 = ... | 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 qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RD... | void func0(long param_1,int param_2,long *param_3,int *param_4)
{
int4 uVar1;
bool bVar2;
void *pvVar3;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
pvVar3 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar3;
*param_4 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = loca... |
1,073 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
| void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if ... | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int t... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %rdx,%rbx
mov %rcx,%rbp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 1298 <func0+0xef>
mov %r13,%rsi
lea -0x... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13d, esi
mov rbx, rdx
mov rbp, rcx
movsxd r14, esi
shl r14, 2
mov rdi, r14; size
call _malloc
mov [rbx], rax
mov dword ptr [rbp+0], 0
test r13d, r13d
jle loc_1293
mov rsi, r12
lea ... | unsigned long long func0(int *a1, int a2, void **a3, int *a4)
{
size_t v7; // r14
unsigned long long result; // rax
int *v9; // rsi
int i; // edx
int v11; // edi
int v12; // r8d
int v13; // ecx
int *v14; // rdi
int v15; // esi
long long v16; // rax
int v17; // edx
v7 = a2;
result = (unsigned... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13D,ESI
MOV RBX,RDX
MOV RBP,RCX
MOVSXD R14,ESI
SHL R14,0x2
MOV RDI,R14
CALL 0x001010b0
MOV qword ptr [RBX],RAX
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101293
MOV RSI,R12
LEA R8,[R12 + R14*0x1]
JMP 0x00101216
LAB_001011ec:
MOVSXD RAX,EDX... | void func0(uint *param_1,int param_2,long *param_3,int *param_4)
{
uint *puVar1;
int *piVar2;
int iVar3;
int iVar4;
bool bVar5;
void *pvVar6;
long lVar7;
int iVar8;
uint uVar9;
uint uVar10;
pvVar6 = malloc((long)param_2 * 4);
*param_3 = (long)pvVar6;
*param_4 = 0;
if (0 < param_2) {
... |
1,074 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
| void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if ... | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int t... | O2 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 153f <func0+0xcf>
lea -0x1(%r12),%edx
mo... | func0:
endbr64
push r14
movsxd r11, esi
mov r14, rdx
push r13
mov r13, r11
push r12
lea r12, ds:0[r11*4]
push rbp
mov rbp, rcx
push rbx
mov rbx, rdi
mov rdi, r12; size
call _malloc
mov [r14], rax
mov dword ptr [rbp+0], 0
test r13d, r13d
jle loc_1507
mov r8, ... | unsigned long long func0(int *a1, int a2, unsigned long long *a3, int *a4)
{
unsigned long long result; // rax
unsigned long long v7; // r8
int *v8; // r9
int *v9; // r11
int v10; // edi
int v11; // r10d
int v12; // ecx
bool v13; // dl
__m128i v14; // xmm0
result = (unsigned long long)malloc(4LL *... | func0:
ENDBR64
PUSH R14
MOVSXD R11,ESI
MOV R14,RDX
PUSH R13
MOV R13,R11
PUSH R12
LEA R12,[R11*0x4]
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
CALL 0x001010b0
MOV qword ptr [R14],RAX
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101507
MOV R8,RAX
MOV R9,RBX
LEA R11,[RBX + R12*0x1]
XOR EDI,EDI
MOV ESI,0xccccc... | void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
uint uVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
int8 *puVar6;
long lVar7;
byte bVar8;
int iVar9;
int iVar10;
puVar4 = (int8 *)malloc((long)param_2 * 4);
*param_3 = puVar4;
*param_4 = 0;
if (0 < param_2) {
... |
1,075 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
| void func0(int *x, int size, int **out, int *out_size) {
*out = malloc(size * sizeof(int));
*out_size = 0;
for (int i = 0; i < size; i++) {
int num = x[i];
bool has_even_digit = false;
if (num == 0) has_even_digit = true;
while (num > 0 && !has_even_digit) {
if ... | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
bool issame(int *a, int a_size, int *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
// Test cases
int t... | O3 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
movl $0x0,0x0(%rbp)
test %r12d,%r12d
jle 150f <func0+0xcf>
lea -0x1(%r12),%edx
mo... | func0:
endbr64
push r14
movsxd r11, esi
mov r14, rdx
push r13
mov r13, r11
push r12
lea r12, ds:0[r11*4]
push rbp
mov rbp, rcx
push rbx
mov rbx, rdi
mov rdi, r12; size
call _malloc
mov [r14], rax
mov dword ptr [rbp+0], 0
test r13d, r13d
jle loc_1507
mov r8, ... | unsigned long long func0(int *a1, int a2, unsigned long long *a3, int *a4)
{
unsigned long long result; // rax
unsigned long long v7; // r8
int *v8; // r9
int *v9; // r11
int v10; // edi
int v11; // r10d
int v12; // ecx
bool v13; // dl
__m128i v14; // xmm0
result = (unsigned long long)malloc(4LL *... | func0:
ENDBR64
PUSH R14
MOVSXD R11,ESI
MOV R14,RDX
PUSH R13
MOV R13,R11
PUSH R12
LEA R12,[R11*0x4]
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
CALL 0x001010b0
MOV qword ptr [R14],RAX
MOV dword ptr [RBP],0x0
TEST R13D,R13D
JLE 0x00101507
MOV R8,RAX
MOV R9,RBX
LEA R11,[RBX + R12*0x1]
XOR EDI,EDI
MOV ESI,0xccccc... | void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
uint uVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
int8 *puVar6;
long lVar7;
byte bVar8;
int iVar9;
int iVar10;
puVar4 = (int8 *)malloc((long)param_2 * 4);
*param_3 = puVar4;
*param_4 = 0;
if (0 < param_2) {
... |
1,076 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp ... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.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;
}
int main() {
char **out;
int o... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %rdx,-0x88(%rbp)
mov %rcx,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe05(%rip),%rax
mov %rax,-0x60(%rbp)
lea 0xdfb(%rip),%rax
mov %rax,-0x58(%rbp)
lea ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov [rbp+var_88], rdx
mov [rbp+var_90], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, unk_2008
mov [rbp+var_60], rax
lea rax, unk_2009
mov [rbp+var_58], r... | unsigned long long func0(long long a1, int a2, void **a3, int *a4)
{
int v4; // eax
int i; // [rsp+24h] [rbp-6Ch]
int k; // [rsp+24h] [rbp-6Ch]
int v10; // [rsp+24h] [rbp-6Ch]
int j; // [rsp+28h] [rbp-68h]
int v12; // [rsp+28h] [rbp-68h]
int v13; // [rsp+2Ch] [rbp-64h]
_QWORD v14[11]; // [rsp+30h] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV qword ptr [RBP + -0x88],RDX
MOV qword ptr [RBP + -0x90],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[0x102009]
MO... | void func0(long param_1,int param_2,long *param_3,int *param_4)
{
int4 uVar1;
void *pvVar2;
long in_FS_OFFSET;
int local_74;
int local_70;
char *local_68 [4];
int *local_48;
int *local_40;
int *local_38;
char *local_30;
char *local_28;
int *local_20;
long local_10;
local_10 = *(long *)(i... |
1,077 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp ... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.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;
}
int main() {
char **out;
int o... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%rbx
mov %rdx,%r12
mov %rcx,%rbp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xe1a(%rip),%rax
mov %rax,(%rsp)
lea 0xe02(%rip),%rax
mov %rax,0x8(%rsp)
lea 0xdfa(%rip),%rax
mov %rax,0x... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rbx, rdi
mov r12, rdx
mov rbp, rcx
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea rax, aThree+5; ""
mov [rsp+88h+var_88], rax
lea rax, unk_2004
mov [rsp+88h+var_80], rax
lea rax, u... | unsigned long long func0(int *a1, int a2, void **a3, int *a4)
{
long long v6; // r13
int *v7; // rax
int v8; // edx
int v9; // ecx
long long v11; // rax
int v12; // edx
int v13; // eax
_QWORD v14[11]; // [rsp+0h] [rbp-88h]
unsigned long long v15; // [rsp+58h] [rbp-30h]
v15 = __readfsqword(0x28u);
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
MOV R12,RDX
MOV RBP,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[0x102011]
MOV qword ptr [RSP],RAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[0x102008]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX... | void func0(int *param_1,int param_2,long *param_3,int *param_4)
{
int iVar1;
int *piVar2;
long lVar3;
void *pvVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
char *local_88 [11];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "";
local_88[1] = "One";
local_88[2] = ... |
1,078 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp ... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.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;
}
int main() {
char **out;
int o... | O2 | c | func0:
endbr64
push %r13
mov %rcx,%r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
push %rbx
lea -0x1(%rsi),%ebx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x9f0(%rip),%rax
mov %rax,(%rsp)
lea 0x9d8(%rip),%rax
mov %rax,0x8(%rsp)
lea 0x9d0(%r... | func0:
endbr64
push r13
mov r13, rcx
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
lea rbx, aThree+5; ""
movq xmm0, rbx
lea rbx, unk_2008
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
lea rax, unk_2004
movq xmm2, rax
lea rax, aThree; "Three"
punp... | unsigned long long func0(__m128i *a1, int a2, void **a3, int *a4)
{
long long v7; // rbx
int v8; // edi
__m128i *v9; // rax
__m128i v10; // xmm0
int v11; // ecx
long long v12; // rax
_QWORD *v13; // rax
int v14; // edi
int v15; // ecx
long long v16; // rdx
long long v17; // rsi
_OWORD v19[5]; /... | func0:
ENDBR64
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[0x102011]
MOVQ XMM0,RBX
LEA RBX,[0x102008]
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x102004]
MOVQ XMM2,RAX
LEA RAX,[0x10200c]
PUNPCKLQDQ XMM0,XMM2
MOVQ XMM3,RAX
LEA RAX,[0x102017]
MOV... | void func0(int8 *param_1,int param_2,int8 *param_3,int *param_4)
{
int8 *puVar1;
long lVar2;
void *pvVar3;
int iVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
int iVar7;
char *local_88 [4];
int *local_68;
int *puStack_60;
int *local_58;
char *pcStack_50;
char *local_48;
int *puStack_40;
... |
1,079 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int *arr, int size, char ***out, int *out_size) {
char *names[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
int i, j;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp ... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.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;
}
int main() {
char **out;
int o... | O3 | c | func0:
endbr64
push %r13
mov %rcx,%r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
push %rbx
lea 0xa47(%rip),%rbx
movq %rbx,%xmm0
lea 0xa32(%rip),%rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xa13(%rip),%rax
movq %rax,%xmm1
lea 0xa0f(%rip),... | func0:
endbr64
push r13
mov r13, rcx
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
lea rbx, aThree+5; ""
movq xmm0, rbx
lea rbx, unk_2008
sub rsp, 68h
mov rax, fs:28h
mov [rsp+88h+var_30], rax
lea rax, unk_2004
movq xmm2, rax
lea rax, aThree; "Three"
punp... | unsigned long long func0(__m128i *a1, int a2, void **a3, int *a4)
{
long long v7; // rbx
int v8; // edi
__m128i *v9; // rax
__m128i v10; // xmm0
int v11; // ecx
long long v12; // rax
_QWORD *v13; // rax
int v14; // edi
int v15; // ecx
long long v16; // rdx
long long v17; // rsi
_OWORD v19[5]; /... | func0:
ENDBR64
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[0x102011]
MOVQ XMM0,RBX
LEA RBX,[0x102008]
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x102004]
MOVQ XMM2,RAX
LEA RAX,[0x10200c]
PUNPCKLQDQ XMM0,XMM2
MOVQ XMM3,RAX
LEA RAX,[0x102017]
MOV... | void func0(int8 *param_1,int param_2,int8 *param_3,int *param_4)
{
int8 *puVar1;
long lVar2;
void *pvVar3;
int iVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
int iVar7;
char *local_88 [4];
int *local_68;
int *puStack_60;
int *local_58;
char *pcStack_50;
char *local_48;
int *puStack_40;
... |
1,080 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.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 *result;
int expected1[] = {1, 2, 6, 24, 15};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x1,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 1236 <func0+0x8d>
mov -0xc(%rbp),%eax
add ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov [rbp+var_10], 1
mov [rbp+var_C], 1
jmp short loc_1236
loc_11E4:
mov eax, [rbp+v... | _DWORD * func0(int a1)
{
int v2; // [rsp+1Ch] [rbp-14h]
int v3; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v5; // [rsp+28h] [rbp-8h]
v5 = malloc(4LL * a1);
v2 = 0;
v3 = 1;
for ( i = 1; i <= a1; ++i )
{
v2 += i;
v3 *= i;
if ( (i & 1) != 0 )
v5[i - 1] = v2;
else
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101236
LAB_001011e4:
MOV EAX... | void * func0(int param_1)
{
void *pvVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)param_1 << 2);
local_1c = 0;
local_18 = 1;
for (local_14 = 1; (int)local_14 <= param_1; local_14 = local_14 + 1) {
local_1c = local_1c + local_14;
local_18 = local_18 * local_14;
... |
1,081 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.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 *result;
int expected1[] = {1, 2, 6, 24, 15};
... | O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 11f1 <func0+0x48>
lea -0x1(%rbx),%r8d
add $0x2,%r8
mov $0x1,%edx
mov $0x1,%esi
mov $0x0,%ecx
add %edx,%ecx
imul %edx,%esi
test $0x1,%dl
mov %esi,%edi
cmovne %ecx,%edi
m... | func0:
endbr64
push rbx
mov ebx, edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
test ebx, ebx
jle short loc_11ED
lea r8d, [rbx+1]
mov edx, 1
mov esi, 1
mov ecx, 0
loc_11D3:
add ecx, edx
imul esi, edx
test dl, 1
mov edi, esi
cmovnz edi, ecx
mov [rax+rdx*4-4], e... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v3; // rdx
int v4; // esi
int v5; // ecx
int v6; // edi
result = malloc(4LL * a1);
if ( a1 > 0 )
{
v3 = 1LL;
v4 = 1;
v5 = 0;
do
{
v5 += v3;
v4 *= (_DWORD)v3;
v6 = v4;
if ( (v3 & 1) != 0 )
v6 = ... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001011ed
LEA R8D,[RBX + 0x1]
MOV EDX,0x1
MOV ESI,0x1
MOV ECX,0x0
LAB_001011d3:
ADD ECX,EDX
IMUL ESI,EDX
TEST DL,0x1
MOV EDI,ESI
CMOVNZ EDI,ECX
MOV dword ptr [RAX + RDX*0x4 + -0x4],EDI
ADD RDX,0x1
CMP RDX,R8
JNZ 0x001011d3
... | void func0(int param_1)
{
void *pvVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
pvVar1 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
iVar4 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (int)uVar3;
iVar4 = iVar4 * (int)uVar3;
iVar5 = iVar4;
if ((uVar3 ... |
1,082 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.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 *result;
int expected1[] = {1, 2, 6, 24, 15};
... | O2 | c | func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 13ea <func0+0x4a>
lea -0x1(%rbx),%r8d
mov $0x1,%edx
mov $0x1,%esi
xor %ecx,%ecx
add $0x2,%r8
nopl 0x0(%rax)
imul %edx,%esi
add %edx,%ecx
test $0x1,%dl
mov %esi,%edi
c... | func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
test ebx, ebx
jle short loc_13EA
lea r8d, [rbx+1]
mov edx, 1
mov esi, 1
xor ecx, ecx
nop dword ptr [rax+rax+00000000h]
loc_13D0:
imul esi, edx
add ecx, edx
test dl, 1
mov edi, ecx
c... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v3; // rdx
int v4; // esi
int v5; // ecx
int v6; // edi
result = malloc(4LL * a1);
if ( a1 > 0 )
{
v3 = 1LL;
v4 = 1;
v5 = 0;
do
{
v4 *= (_DWORD)v3;
v5 += v3;
v6 = v5;
if ( (v3 & 1) == 0 )
v6 = ... | func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001013ea
LEA R8D,[RBX + 0x1]
MOV EDX,0x1
MOV ESI,0x1
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013d0:
IMUL ESI,EDX
ADD ECX,EDX
TEST DL,0x1
MOV EDI,ECX
CMOVZ EDI,ESI
MOV dword ptr [RAX + RDX*0x4 + -0x4],EDI
ADD RDX,0... | void func0(int param_1)
{
void *pvVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
pvVar1 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
iVar4 = 1;
iVar2 = 0;
do {
iVar4 = iVar4 * (int)uVar3;
iVar2 = iVar2 + (int)uVar3;
iVar5 = iVar2;
if ((uVar3 ... |
1,083 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc(n * sizeof(int));
int sum = 0, prod = 1;
for (int i = 1; i <= n; i++) {
sum += i;
prod *= i;
if (i % 2 == 0) out[i - 1] = prod;
else out[i - 1] = sum;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.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 *result;
int expected1[] = {1, 2, 6, 24, 15};
... | O3 | c | func0:
endbr64
push %rbx
movslq %edi,%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 13ea <func0+0x4a>
lea -0x1(%rbx),%r8d
mov $0x1,%edx
mov $0x1,%esi
xor %ecx,%ecx
add $0x2,%r8
nopl 0x0(%rax)
imul %edx,%esi
add %edx,%ecx
test $0x1,%dl
mov %esi,%edi
c... | func0:
endbr64
push rbx
movsxd rdi, edi
mov rbx, rdi
shl rdi, 2; size
call _malloc
test ebx, ebx
jle short loc_13E7
lea edi, [rbx+1]
mov edx, 1
mov esi, 1
xor ecx, ecx
nop word ptr [rax+rax+00000000h]
loc_13D0:
imul esi, edx
add ecx, edx
test dl, 1
jz short loc_1... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v2; // rdi
long long v3; // rdx
int v4; // esi
int v5; // ecx
result = malloc(4LL * a1);
if ( a1 > 0 )
{
v2 = (unsigned int)(a1 + 1);
v3 = 1LL;
v4 = 1;
v5 = 0;
do
{
while ( 1 )
{
v4 *= (_DWORD)v3;
... | func0:
ENDBR64
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001013e7
LEA EDI,[RBX + 0x1]
MOV EDX,0x1
MOV ESI,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_001013d0:
IMUL ESI,EDX
ADD ECX,EDX
TEST DL,0x1
JZ 0x001013f0
MOV dword ptr [RAX + RDX*0x4 + -0x4],ECX
ADD RDX,0x1
CMP RDX,RD... | void func0(int param_1)
{
void *pvVar1;
int iVar2;
ulong uVar3;
int iVar4;
pvVar1 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar3 = 1;
iVar4 = 1;
iVar2 = 0;
do {
while( true ) {
iVar4 = iVar4 * (int)uVar3;
iVar2 = iVar2 + (int)uVar3;
if ((uVar3 & 1) !... |
1,084 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
... | #include <stdio.h>
#include <stdlib.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* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov $0x8,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movl $0x0,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
movl $0x0,(%rax)
movl $0x1,-0x18(%rbp)
jmpq 1297 <func0+0xee>
movl $0x0,-0x14(%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov edi, 8; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov dword ptr [rax], 0
mov rax, [rbp+var_8]
add rax, 4
mov dword ptr [rax], 0
mov [rbp+var_18], 1
jmp loc_1297
loc_11EA:
m... | _DWORD * func0(int a1)
{
int i; // [rsp+18h] [rbp-18h]
int v3; // [rsp+1Ch] [rbp-14h]
int j; // [rsp+20h] [rbp-10h]
_DWORD *v5; // [rsp+28h] [rbp-8h]
v5 = malloc(8uLL);
*v5 = 0;
v5[1] = 0;
for ( i = 1; i <= a1; ++i )
{
v3 = 0;
for ( j = i; j; j /= 10 )
v3 = 10 * v3 + j % 10;
if ( i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV EDI,0x8
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x4
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x18],0x1
JMP 0x00101297
LAB_001011e... | int * func0(int param_1)
{
int *piVar1;
uint local_20;
uint local_1c;
uint local_18;
piVar1 = (int *)malloc(8);
*piVar1 = 0;
piVar1[1] = 0;
for (local_20 = 1; (int)local_20 <= param_1; local_20 = local_20 + 1) {
local_1c = 0;
for (local_18 = local_20; local_18 != 0; local_18 = (int)local_18 ... |
1,085 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
... | #include <stdio.h>
#include <stdlib.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* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2... | O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
mov $0x8,%edi
callq 10b0 <malloc@plt>
movl $0x0,(%rax)
movl $0x0,0x4(%rax)
test %ebx,%ebx
jle 122d <func0+0x84>
lea 0x1(%rbx),%r9d
mov $0x1,%r8d
mov $0x0,%r10d
jmp 11e9 <func0+0x40>
addl $0x1,(%rax)
add $0x1,%r8d
cmp %r8d,%r9d
je 122d <fun... | func0:
endbr64
push rbx
mov ebx, edi
mov edi, 8; size
call _malloc
mov r9, rax
mov dword ptr [rax], 0
mov dword ptr [rax+4], 0
test ebx, ebx
jle short loc_122D
lea r8d, [rbx+1]
mov edi, 1
mov r10d, 0
jmp short loc_11EB
loc_11DF:
add dword ptr [r9], 1
loc_11E3:
add ... | _DWORD * func0(int a1)
{
_DWORD *v1; // r9
int v2; // r8d
int i; // edi
int v4; // edx
int v5; // ecx
v1 = malloc(8uLL);
*v1 = 0;
v1[1] = 0;
if ( a1 > 0 )
{
v2 = a1 + 1;
for ( i = 1; v2 != i; ++i )
{
v4 = i;
v5 = 0;
if ( !i )
goto LABEL_3;
do
{
... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOV EDI,0x8
CALL 0x001010b0
MOV R9,RAX
MOV dword ptr [RAX],0x0
MOV dword ptr [RAX + 0x4],0x0
TEST EBX,EBX
JLE 0x0010122d
LEA R8D,[RBX + 0x1]
MOV EDI,0x1
MOV R10D,0x0
JMP 0x001011eb
LAB_001011df:
ADD dword ptr [R9],0x1
LAB_001011e3:
ADD EDI,0x1
CMP R8D,EDI
JZ 0x0010122d
LAB_001011eb:
... | int * func0(int param_1)
{
uint uVar1;
uint uVar2;
int *piVar3;
uint uVar4;
uint uVar5;
piVar3 = (int *)malloc(8);
*piVar3 = 0;
piVar3[1] = 0;
if (0 < param_1) {
uVar5 = 1;
do {
uVar4 = 0;
uVar2 = uVar5;
if (uVar5 == 0) {
LAB_001011df:
*piVar3 = *piVar3 + 1;
... |
1,086 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
... | #include <stdio.h>
#include <stdlib.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* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2... | O2 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
mov $0x8,%edi
callq 1090 <malloc@plt>
movq $0x0,(%rax)
test %ebx,%ebx
jle 1413 <func0+0x63>
lea 0x1(%rbx),%r10d
mov $0x1,%r9d
mov $0xcccccccd,%r8d
nopl 0x0(%rax)
mov %r9d,%ecx
xor %esi,%esi
nopl (%rax)
mov %ecx,%edx
lea (%rsi,%rsi,4),%edi
i... | func0:
endbr64
push rbx
mov ebx, edi
mov edi, 8; size
call _malloc
mov qword ptr [rax], 0
test ebx, ebx
jle short loc_141E
lea r9d, [rbx+1]
mov r8d, 1
nop word ptr [rax+rax+00000000h]
loc_13E0:
mov ecx, r8d
xor esi, esi
nop dword ptr [rax]
loc_13E8:
movsxd rdx, ecx
lea ... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
int v2; // r8d
int v3; // ecx
int v4; // esi
result = malloc(8uLL);
*(_QWORD *)result = 0LL;
if ( a1 > 0 )
{
v2 = 1;
do
{
v3 = v2;
v4 = 0;
do
{
v4 = v3 % 10 + 10 * v4;
v3 /= 10;
}
while ( v3 ... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOV EDI,0x8
CALL 0x00101090
MOV qword ptr [RAX],0x0
TEST EBX,EBX
JLE 0x0010141e
LEA R9D,[RBX + 0x1]
MOV R8D,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013e0:
MOV ECX,R8D
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_001013e8:
MOVSXD RDX,ECX
LEA EDI,[RSI + RSI*0x4]
MOV ESI,ECX
IMUL RDX,RDX,0x66... | void func0(int param_1)
{
uint uVar1;
int *piVar2;
uint uVar3;
uint uVar4;
uint uVar5;
piVar2 = (int *)malloc(8);
piVar2[0] = 0;
piVar2[1] = 0;
if (0 < param_1) {
uVar5 = 1;
do {
uVar4 = 0;
uVar3 = uVar5;
do {
uVar1 = (int)uVar3 / 10;
uVar4 = (int)uVar3 % ... |
1,087 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* counts = (int*)malloc(2 * sizeof(int));
counts[0] = 0;
counts[1] = 0;
for (int i = 1; i <= n; i++) {
int reversed = 0, original = i;
int number = i;
while (number != 0) {
reversed = reversed * 10 + number % 10;
number /= 10;
... | #include <stdio.h>
#include <stdlib.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* result;
result = func0(123);
int expected1[] = {8, 13};
assert(issame(result, expected1, 2... | O3 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
mov $0x8,%edi
callq 1090 <malloc@plt>
movq $0x0,(%rax)
test %ebx,%ebx
jle 1413 <func0+0x63>
lea 0x1(%rbx),%r10d
mov $0x1,%r9d
mov $0xcccccccd,%r8d
nopl 0x0(%rax)
mov %r9d,%ecx
xor %esi,%esi
nopl (%rax)
mov %ecx,%edx
lea (%rsi,%rsi,4),%edi
i... | func0:
endbr64
push rbx
mov ebx, edi
mov edi, 8; size
call _malloc
mov qword ptr [rax], 0
test ebx, ebx
jle short loc_141E
lea r9d, [rbx+1]
mov r8d, 1
nop word ptr [rax+rax+00000000h]
loc_13E0:
mov ecx, r8d
xor esi, esi
nop dword ptr [rax]
loc_13E8:
movsxd rdx, ecx
lea ... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
int v2; // r8d
int v3; // ecx
int v4; // esi
result = malloc(8uLL);
*(_QWORD *)result = 0LL;
if ( a1 > 0 )
{
v2 = 1;
do
{
v3 = v2;
v4 = 0;
do
{
v4 = v3 % 10 + 10 * v4;
v3 /= 10;
}
while ( v3 ... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
MOV EDI,0x8
CALL 0x00101090
MOV qword ptr [RAX],0x0
TEST EBX,EBX
JLE 0x0010141e
LEA R9D,[RBX + 0x1]
MOV R8D,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013e0:
MOV ECX,R8D
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_001013e8:
MOVSXD RDX,ECX
LEA EDI,[RSI + RSI*0x4]
MOV ESI,ECX
IMUL RDX,RDX,0x66... | void func0(int param_1)
{
uint uVar1;
int *piVar2;
uint uVar3;
uint uVar4;
uint uVar5;
piVar2 = (int *)malloc(8);
piVar2[0] = 0;
piVar2[1] = 0;
if (0 < param_1) {
uVar5 = 1;
do {
uVar4 = 0;
uVar3 = uVar5;
do {
uVar1 = (int)uVar3 / 10;
uVar4 = (int)uVar3 % ... |
1,088 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
su... | #include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 123f <func0+0xd6>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 11ae <func0+0x45>
a... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_123C
loc_118B:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short lo... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-10h]
int i; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) <= 0 )
{
v5 = 0;
for ( j = -*(_DWORD *)(4LL * i + a1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010123c
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST E... | int func0(long param_1,int param_2)
{
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) < 1) {
local_10 = 0;
local_c = *(int *)(param_1 + (long)local_14 * 4... |
1,089 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
su... | #include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == ... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11e3 <func0+0x7a>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%edi
jmp 11d7 <func0+0x6e>
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
sub %eax,%edx
cmp $0x9,%edx
jle 11ce <func0+0x65>
mov $0x0,%esi
movslq %edx,%rax
imul $0... | func0:
endbr64
test esi, esi
jle short loc_11DE
mov r8, rdi
movsxd rsi, esi
lea r10, [rdi+rsi*4]
mov r9d, 0
jmp short loc_11D1
loc_1183:
mov edx, eax
neg edx
cmovs edx, eax
cmp edx, 9
jle short loc_11C8
mov esi, 0
loc_1194:
movsxd rax, edx
imul rax, 66666667h
sar ra... | long long func0(int *a1, int a2)
{
int *v2; // r8
int *v3; // r10
unsigned int v4; // r9d
int v5; // edx
int v6; // esi
int v7; // eax
int v8; // ecx
int v9; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
v9 = *v2;
if ( *v2 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011de
MOV R8,RDI
MOVSXD RSI,ESI
LEA R10,[RDI + RSI*0x4]
MOV R9D,0x0
JMP 0x001011d1
LAB_00101183:
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
CMP EDX,0x9
JLE 0x001011c8
MOV ESI,0x0
LAB_00101194:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LEA ECX,[R... | int func0(int *param_1,int param_2)
{
int *piVar1;
bool bVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar6 = 0;
do {
iVar5 = *param_1;
if (iVar5 < 1) {
iVar3 = -iVar5;
if (0 < iVar5... |
1,090 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
su... | #include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == ... | O2 | c | func0:
endbr64
test %esi,%esi
jle 149a <func0+0x7a>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%r9d
lea 0x4(%rdi,%rax,4),%r10
jmp 144d <func0+0x2d>
nopl 0x0(%rax,%rax,1)
add $0x1,%r8d
add $0x4,%rdi
cmp %r10,%rdi
je 1496 <func0+0x76>
mov (%rdi),%eax
test %eax,%eax
jg 14... | func0:
endbr64
test esi, esi
jle short loc_1448
movsxd rsi, esi
xor r9d, r9d
mov r10d, 0CCCCCCCDh
lea r11, [rdi+rsi*4]
jmp short loc_13FD
loc_13F0:
add r9d, 1
loc_13F4:
add rdi, 4
cmp rdi, r11
jz short loc_1444
loc_13FD:
mov eax, [rdi]
test eax, eax
jg short loc_13F0... | long long func0(int *a1, int a2)
{
unsigned int v2; // r9d
int *v3; // r11
int v4; // eax
unsigned int v5; // edx
int v6; // esi
unsigned int v7; // r8d
int v8; // ecx
if ( a2 > 0 )
{
v2 = 0;
v3 = &a1[a2];
while ( 1 )
{
while ( 1 )
{
v4 = *a1;
if ( *a1 <= ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101448
MOVSXD RSI,ESI
XOR R9D,R9D
MOV R10D,0xcccccccd
LEA R11,[RDI + RSI*0x4]
JMP 0x001013fd
LAB_001013f0:
ADD R9D,0x1
LAB_001013f4:
ADD RDI,0x4
CMP RDI,R11
JZ 0x00101444
LAB_001013fd:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JG 0x001013f0
MOV EDX,EAX
NEG EDX
CMP EAX,-0x9
JGE 0x001013f4
... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
uint uVar4;
uint uVar5;
int iVar6;
int iVar7;
if (0 < param_2) {
iVar7 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
if (iVar2 < 1) {
if (iVar2 < -9) {
iVar6 = 0;
u... |
1,091 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *n, int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (n[i] > 0) {
num += 1;
} else {
int sum = 0;
int w = abs(n[i]);
while (w >= 10) {
sum += w % 10;
w = w / 10;
}
su... | #include <assert.h>
int main() {
assert(func0((const int[]){}, 0) == 0);
assert(func0((const int[]){-1, -2, 0}, 3) == 0);
assert(func0((const int[]){1, 1, 2, -2, 3, 4, 5}, 7) == 6);
assert(func0((const int[]){1, 6, 9, -6, 0, 1, 5}, 7) == 5);
assert(func0((const int[]){1, 100, 98, -7, 1, -1}, 6) == ... | O3 | c | func0:
endbr64
test %esi,%esi
jle 145a <func0+0x7a>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xcccccccd,%r9d
lea 0x4(%rdi,%rax,4),%r10
jmp 140d <func0+0x2d>
nopl 0x0(%rax,%rax,1)
add $0x1,%r8d
add $0x4,%rdi
cmp %rdi,%r10
je 1456 <func0+0x76>
mov (%rdi),%eax
test %eax,%eax
jg 14... | func0:
endbr64
test esi, esi
jle short loc_1448
movsxd rsi, esi
xor r9d, r9d
mov r10d, 0CCCCCCCDh
lea r11, [rdi+rsi*4]
jmp short loc_13FD
loc_13F0:
add r9d, 1
loc_13F4:
add rdi, 4
cmp r11, rdi
jz short loc_1444
loc_13FD:
mov eax, [rdi]
test eax, eax
jg short loc_13F0... | long long func0(int *a1, int a2)
{
unsigned int v2; // r9d
int *v3; // r11
int v4; // eax
unsigned int v5; // edx
int v6; // esi
unsigned int v7; // r8d
int v8; // ecx
if ( a2 > 0 )
{
v2 = 0;
v3 = &a1[a2];
while ( 1 )
{
while ( 1 )
{
v4 = *a1;
if ( *a1 <= ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101448
MOVSXD RSI,ESI
XOR R9D,R9D
MOV R10D,0xcccccccd
LEA R11,[RDI + RSI*0x4]
JMP 0x001013fd
LAB_001013f0:
ADD R9D,0x1
LAB_001013f4:
ADD RDI,0x4
CMP R11,RDI
JZ 0x00101444
LAB_001013fd:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JG 0x001013f0
MOV EDX,EAX
NEG EDX
CMP EAX,-0x9
JGE 0x001013f4
... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
uint uVar4;
uint uVar5;
int iVar6;
int iVar7;
if (0 < param_2) {
iVar7 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
if (iVar2 < 1) {
if (iVar2 < -9) {
iVar6 = 0;
u... |
1,092 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *arr, int size) {
int num = 0;
if (size == 0) return true;
for (int i = 1; i < size; i++)
if (arr[i] < arr[i - 1]) num += 1;
if (arr[size - 1] > arr[0]) num += 1;
if (num < 2) return true;
return false;
} | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0((const int[]){3, 4, 5, 1, 2}, 5) == true);
assert(func0((const int[]){3, 5, 10, 1, 2}, 5) == true);
assert(func0((const int[]){4, 3, 1, 2}, 4) == false);
assert(func0((const int[]){3, 5, 4, 1, 2}, 5) == false);
assert(func0((const i... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 118c <func0+0x23>
mov $0x1,%eax
jmp 120b <func0+0xa2>
movl $0x1,-0x4(%rbp)
jmp 11cd <func0+0x64>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
cmp [rbp+var_1C], 0
jnz short loc_118C
mov eax, 1
jmp short loc_120B
loc_118C:
mov [rbp+var_4], 1
jmp short loc_11CD
loc_1195:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[ra... | _BOOL8 func0(_DWORD *a1, int a2)
{
int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
if ( !a2 )
return 1LL;
for ( i = 1; i < a2; ++i )
{
if ( a1[i] < a1[i - 1] )
++v3;
}
if ( a1[a2 - 1] > *a1 )
++v3;
return v3 <= 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x0010118c
MOV EAX,0x1
JMP 0x0010120b
LAB_0010118c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011cd
LAB_00101195:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA R... | int8 func0(int *param_1,int param_2)
{
int8 uVar1;
int local_10;
int local_c;
local_10 = 0;
if (param_2 == 0) {
uVar1 = 1;
}
else {
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (param_1[local_c] < param_1[(long)local_c + -1]) {
local_10 = local_10 + 1;
}... |
1,093 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *arr, int size) {
int num = 0;
if (size == 0) return true;
for (int i = 1; i < size; i++)
if (arr[i] < arr[i - 1]) num += 1;
if (arr[size - 1] > arr[0]) num += 1;
if (num < 2) return true;
return false;
} | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0((const int[]){3, 4, 5, 1, 2}, 5) == true);
assert(func0((const int[]){3, 5, 10, 1, 2}, 5) == true);
assert(func0((const int[]){4, 3, 1, 2}, 4) == false);
assert(func0((const int[]){3, 5, 4, 1, 2}, 5) == false);
assert(func0((const i... | O1 | c | func0:
endbr64
mov $0x1,%eax
test %esi,%esi
je 11b8 <func0+0x4f>
cmp $0x1,%esi
jle 11b9 <func0+0x50>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%r8
mov $0x0,%edx
mov (%rax),%ecx
cmp %ecx,0x4(%rax)
setl %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x4,%rax
cmp %r8,%rax
j... | func0:
endbr64
mov eax, 1
test esi, esi
jz short locret_11B8
cmp esi, 1
jle short loc_11B9
mov rax, rdi
lea edx, [rsi-2]
lea r8, [rdi+rdx*4+4]
mov edx, 0
loc_118B:
mov ecx, [rax]
cmp [rax+4], ecx
setl cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, r8
jnz ... | bool func0(_DWORD *a1, int a2)
{
bool result; // al
_DWORD *v3; // rax
int v4; // edx
result = 1;
if ( a2 )
{
if ( a2 <= 1 )
{
v4 = 0;
}
else
{
v3 = a1;
v4 = 0;
do
{
v4 += v3[1] < *v3;
++v3;
}
while ( v3 != &a1[a2 - 2 + 1] );
... | func0:
ENDBR64
MOV EAX,0x1
TEST ESI,ESI
JZ 0x001011b8
CMP ESI,0x1
JLE 0x001011b9
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA R8,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_0010118b:
MOV ECX,dword ptr [RAX]
CMP dword ptr [RAX + 0x4],ECX
SETL CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x0010118b
LAB_001011a1:
MOVSXD RSI,E... | bool func0(int *param_1,int param_2)
{
bool bVar1;
int *piVar2;
int iVar3;
bVar1 = true;
if (param_2 != 0) {
if (param_2 < 2) {
iVar3 = 0;
}
else {
iVar3 = 0;
piVar2 = param_1;
do {
iVar3 = iVar3 + (uint)(piVar2[1] < *piVar2);
piVar2 = piVar2 + 1;
... |
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.