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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
1,094 | 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... | O2 | c | func0:
endbr64
test %esi,%esi
je 1350 <func0+0x10>
jmp 12e0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
cmp esi, 1
jle short loc_12F0
lea ecx, [rsi-2]
mov edx, [rdi]
lea rax, [rdi+4]
lea r9, [rdi+rcx*4+8]
xor ecx, ecx
nop dword ptr [rax]
loc_12B8:
mov r8d, edx
mov edx, [rax]
cmp r8d, edx
setnle r8b
add rax, 4
movzx r8d, r8b
add ecx, r8d
cmp rax, r9
... | bool func0_part_0(int *a1, int a2)
{
int v2; // edx
int *v3; // rax
int v4; // ecx
int v5; // r8d
if ( a2 <= 1 )
{
v4 = 0;
}
else
{
v2 = *a1;
v3 = a1 + 1;
v4 = 0;
do
{
v5 = v2;
v2 = *v3++;
v4 += v5 > v2;
}
while ( v3 != &a1[a2 - 2 + 2] );
}
retur... | func0.part.0:
CMP ESI,0x1
JLE 0x001012f0
LEA ECX,[RSI + -0x2]
MOV EDX,dword ptr [RDI]
LEA RAX,[RDI + 0x4]
LEA R9,[RDI + RCX*0x4 + 0x8]
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_001012b8:
MOV R8D,EDX
MOV EDX,dword ptr [RAX]
CMP R8D,EDX
SETG R8B
ADD RAX,0x4
MOVZX R8D,R8B
ADD ECX,R8D
CMP RAX,R9
JNZ 0x001012b8
LAB_001012d4:
MOVS... | bool func0_part_0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
if (param_2 < 2) {
iVar3 = 0;
}
else {
piVar2 = param_1 + 1;
iVar3 = 0;
iVar4 = *param_1;
do {
iVar1 = *piVar2;
piVar2 = piVar2 + 1;
iVar3 = iVar3 + (uint)(iVar1 < iVar4);
... |
1,095 | 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... | O3 | c | func0:
endbr64
mov $0x1,%eax
test %esi,%esi
je 15bb <func0+0x17b>
cmp $0x1,%esi
jle 15c8 <func0+0x188>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%r8d
cmp $0x2,%eax
jbe 15cc <func0+0x18c>
mov %r8d,%edx
mov %rdi,%rax
pxor %xmm1,%xmm1
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
xchg %a... | func0_part_0:
mov rdx, rdi
cmp esi, 1
jle loc_1460
lea eax, [rsi-2]
lea edi, [rsi-1]
cmp eax, 2
jbe loc_1467
mov ecx, edi
mov rax, rdx
pxor xmm1, xmm1
shr ecx, 2
shl rcx, 4
add rcx, rdx
xchg ax, ax
loc_12E0:
movdqu xmm0, xmmword ptr [rax]
movdqu xmm2, xmmword ptr ... | bool func0_part_0(_DWORD *a1, int a2)
{
int v3; // edi
_DWORD *v4; // rax
__m128i v5; // xmm1
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm1
signed int v9; // ecx
int v10; // eax
long long v11; // r8
int v12; // r10d
long long v13; // r9
_DWORD *v14; // r11
int v15; // r10d
int... | func0.part.0:
MOV RDX,RDI
CMP ESI,0x1
JLE 0x00101460
LEA EAX,[RSI + -0x2]
LEA EDI,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101467
MOV ECX,EDI
MOV RAX,RDX
PXOR XMM1,XMM1
SHR ECX,0x2
SHL RCX,0x4
ADD RCX,RDX
NOP
LAB_001012e0:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM2,xmmword ptr [RAX + 0x4]
ADD RAX,0x10
PCMPGTD XMM0,XMM2
PSUBD XM... | int4 func0_part_0(int *param_1,int param_2)
{
uint uVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int iVar10;
long lVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if (param_2 < 2) {
iVar12 = 0;
}
else {
... |
1,096 | func0 | #include <stdio.h>
| const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d4 <func0+0x4b>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D4
loc_11AF:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax,... | const char * func0(long long a1, int a2, long long a3, int a4)
{
int v5; // [rsp+1Ch] [rbp-Ch]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
++v5;
}
for ( j = 0; j < a4; ++j )
{
if ( (*(_DWORD *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d4
LAB_001011af:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qwo... | int * func0(long param_1,int param_2,long param_3,int param_4)
{
int *puVar1;
int local_14;
int local_10;
int local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(uint *)(param_1 + (long)local_10 * 4) & 1) == 0) {
local_14 = local_14 + 1;
}
}
... |
1,097 | func0 | #include <stdio.h>
| const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11cb <func0+0x62>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%eax
mov (%r8),%edi
and $0x1,%edi
cmp $0x1,%edi
adc $0x0,%eax
add $0x4,%r8
cmp %r9,%r8
jne 1181 <func0+0x18>
test %ecx,%ecx
jle 11b6 <func0+0x4d>
mov $0x0,... | func0:
endbr64
test esi, esi
jle short loc_11EA
mov r8, rdi
movsxd rax, esi
lea r9, [rdi+rax*4]
mov eax, 0
loc_11A0:
mov edi, [r8]
and edi, 1
cmp edi, 1
adc eax, 0
add r8, 4
cmp r8, r9
jnz short loc_11A0
test ecx, ecx
jle short loc_11D5
loc_11B9:
mov edi, 0
loc... | const char * func0(_DWORD *a1, int a2, long long a3, int a4)
{
_DWORD *v4; // r8
int v5; // eax
long long v6; // rdi
bool v7; // cc
const char *result; // rax
if ( a2 <= 0 )
{
v5 = 0;
if ( a4 <= 0 )
return "YES";
}
else
{
v4 = a1;
v5 = 0;
do
v5 += (*v4++ & 1) == 0;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ea
MOV R8,RDI
MOVSXD RAX,ESI
LEA R9,[RDI + RAX*0x4]
MOV EAX,0x0
LAB_001011a0:
MOV EDI,dword ptr [R8]
AND EDI,0x1
CMP EDI,0x1
ADC EAX,0x0
ADD R8,0x4
CMP R8,R9
JNZ 0x001011a0
TEST ECX,ECX
JLE 0x001011d5
LAB_001011b9:
MOV EDI,0x0
LAB_001011be:
MOV R8D,dword ptr [RDX + RDI*0x4]
AND R... | int * func0(uint *param_1,int param_2,long param_3,int param_4)
{
uint *puVar1;
int iVar2;
int *puVar3;
long lVar4;
if (param_2 < 1) {
iVar2 = 0;
if (param_4 < 1) {
return &DAT_00102004;
}
}
else {
puVar1 = param_1 + param_2;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((... |
1,098 | func0 | #include <stdio.h>
| const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1518 <func0+0x68>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%r8d
and $0x1,%r8d
cmp $0x1,%r8d
adc $0x0,%eax
add $0x4,%rdi
cmp %r9,%rdi
jne 14c8 <func0+0x18>
test %ecx,%ecx
jle 14ff <func0+0x4f>
x... | func0:
endbr64
test esi, esi
jle short loc_14D8
movsxd rax, esi
lea r9, [rdi+rax*4]
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1488:
mov r8d, [rdi]
and r8d, 1
cmp r8d, 1
adc eax, 0
add rdi, 4
cmp rdi, r9
jnz short loc_1488
test ecx, ecx
jle short loc_14BF
loc_1... | const char * func0(_DWORD *a1, int a2, long long a3, int a4)
{
_DWORD *v4; // r9
int v5; // eax
long long v6; // rdi
bool v7; // cc
const char *result; // rax
if ( a2 <= 0 )
{
v5 = 0;
if ( a4 <= 0 )
return "YES";
}
else
{
v4 = &a1[a2];
v5 = 0;
do
v5 += (*a1++ & 1) ==... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001014d8
MOVSXD RAX,ESI
LEA R9,[RDI + RAX*0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101488:
MOV R8D,dword ptr [RDI]
AND R8D,0x1
CMP R8D,0x1
ADC EAX,0x0
ADD RDI,0x4
CMP RDI,R9
JNZ 0x00101488
TEST ECX,ECX
JLE 0x001014bf
LAB_001014a3:
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_001014a8:
MOV R8D... | int * func0(uint *param_1,int param_2,long param_3,int param_4)
{
uint *puVar1;
int iVar2;
int *puVar3;
long lVar4;
if (param_2 < 1) {
iVar2 = 0;
if (param_4 < 1) {
return &DAT_00102004;
}
}
else {
puVar1 = param_1 + param_2;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((... |
1,099 | func0 | #include <stdio.h>
| const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
} | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1650 <func0+0x1e0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1662 <func0+0x1f2>
mov %esi,%r8d
pxor %xmm1,%xmm1
movdqa 0xe29(%rip),%xmm2
mov %rdi,%rax
shr $0x2,%r8d
movdqa %xmm1,%xmm3
shl $0x4,%r8
add %rdi,%r8
nopl 0x0(%rax)
movdqu (%rax),%xmm0
add $0x10,... | func0:
endbr64
mov r9, rdi
mov r8d, ecx
mov rdi, rdx
test esi, esi
jle loc_1610
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1622
mov edx, esi
pxor xmm1, xmm1
movdqa xmm2, cs:xmmword_22A0
mov rax, r9
shr edx, 2
movdqa xmm3, xmm1
shl rdx, 4
add rdx, r9
loc_14B0:
movdqu xmm... | const char * func0(const __m128i *a1, int a2, const __m128i *a3, int a4)
{
__m128i v6; // xmm1
__m128i si128; // xmm2
const __m128i *v8; // rax
__m128i v9; // xmm0
int v10; // eax
__m128i v11; // xmm1
int v12; // edx
long long v13; // r10
__m128i v14; // xmm1
__m128i v15; // xmm2
const __m128i *v1... | func0:
ENDBR64
MOV R9,RDI
MOV R8D,ECX
MOV RDI,RDX
TEST ESI,ESI
JLE 0x00101610
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101622
MOV EDX,ESI
PXOR XMM1,XMM1
MOVDQA XMM2,xmmword ptr [0x001022a0]
MOV RAX,R9
SHR EDX,0x2
MOVDQA XMM3,XMM1
SHL RDX,0x4
ADD RDX,R9
LAB_001014b0:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PAND XMM0,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int * func0(uint *param_1,uint param_2,uint *param_3,uint param_4)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
int *puVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
... |
1,100 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
... | #include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i]... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xb0,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %rdx,-0xa8(%rbp)
mov %rcx,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x70(%rbp),%rdx
mov $0x0,%eax
mov $0xd,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov [rbp+var_A8], rdx
mov [rbp+var_B0], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_70]
mov eax, 0
mov ecx, 0Dh
mov rdi, rdx
rep stosq
mov ... | unsigned long long func0(_BYTE *a1, long long a2, _DWORD *a3, long long a4)
{
int v4; // eax
int v6; // [rsp+28h] [rbp-88h]
int v7; // [rsp+2Ch] [rbp-84h]
int i; // [rsp+30h] [rbp-80h]
int v9; // [rsp+34h] [rbp-7Ch]
_DWORD v11[26]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v12; // [rsp+A8h] [rbp-8h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV qword ptr [RBP + -0xa8],RDX
MOV qword ptr [RBP + -0xb0],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x70]
MOV EAX,0x0
MOV ECX,0xd
MOV RDI,RDX
STOSQ.REP RDI
... | void func0(char *param_1,long param_2,int *param_3,long param_4)
{
int iVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
int local_90;
int local_8c;
int local_88;
char *local_80;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_78;
for (lVar2 = 0... |
1,101 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
... | #include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i]... | O1 | c | func0:
endbr64
sub $0x78,%rsp
mov %rdi,%r8
mov %rcx,%r9
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0xd,%ecx
rep stos %rax,%es:(%rdi)
movzbl (%r8),%eax
test %al,%al
je 11c9 <func0+0x60>
mov $0x0,%edi
jmp 11c3 <func0+0x5a>
movsbl %al,%eax
sub $0x61,%eax
c... | func0:
endbr64
sub rsp, 78h
mov r11, rdi
mov r8, rsi
mov r10, rdx
mov r9, rcx
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 0Dh
rep stosq
movzx eax, byte ptr [r11]
test al, al
jnz short loc_11D3
mov ecx, 0
loc_11A5:
mov eax, 0
mov ... | unsigned long long func0(_BYTE *a1, long long a2, int *a3, long long a4)
{
_BYTE *v4; // r11
int v8; // ecx
char v9; // al
long long v10; // rax
int v11; // esi
long long v12; // rax
int v13; // edx
int v14; // edx
_DWORD v16[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v17; // [rsp+68h] [rb... | func0:
ENDBR64
SUB RSP,0x78
MOV R11,RDI
MOV R8,RSI
MOV R10,RDX
MOV R9,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0xd
STOSQ.REP RDI
MOVZX EAX,byte ptr [R11]
TEST AL,AL
JNZ 0x001011d3
MOV ECX,0x0
LAB_001011a5:
MOV EAX,0x0
MOV ESI,0x0
JMP 0x001011e3
LAB_001011b1:
MOVSX E... | void func0(char *param_1,long param_2,int *param_3,long param_4)
{
int iVar1;
char cVar2;
int iVar3;
long lVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar6 = local_78;
for (lVar4 = 0xd; lVar4 != 0; lVar4 = lV... |
1,102 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
... | #include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i]... | O2 | c | func0:
endbr64
push %rbx
mov %rdi,%r8
mov %rcx,%r9
mov $0xd,%ecx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%r10
mov %r10,%rdi
rep stos %rax,%es:(%rdi)
movsbl (%r8),%eax
test %al,%al
je 161d <func0+0xbd>
xor %r11d,%r11d
nopl 0x0(%rax)
cmp $0x20... | func0:
endbr64
sub rsp, 78h
mov r9, rdi
mov r10, rcx
mov ecx, 0Dh
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov r8, rsp
mov r11, rdx
mov rdi, r8
rep stosq
movsx eax, byte ptr [r9]
test al, al
jz short loc_1623
nop word ptr [rax+rax+00000000h]
loc_15B0:
... | unsigned long long func0(_BYTE *a1, long long a2, int *a3, long long a4)
{
_BYTE *v4; // r9
int v7; // ecx
int v8; // eax
long long v9; // rax
int v10; // edx
long long v11; // rax
int v12; // edi
int v13; // edx
long long v14; // rdx
_DWORD v16[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long... | func0:
ENDBR64
SUB RSP,0x78
MOV R9,RDI
MOV R10,RCX
MOV ECX,0xd
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV R8,RSP
MOV R11,RDX
MOV RDI,R8
STOSQ.REP RDI
MOVSX EAX,byte ptr [R9]
TEST AL,AL
JZ 0x00101623
NOP word ptr [RAX + RAX*0x1]
LAB_001015b0:
CMP AL,0x20
JZ 0x001015c7
SUB EAX,0x61
CDQE
MO... | void func0(char *param_1,long param_2,int *param_3,long param_4)
{
char cVar1;
int iVar2;
int iVar3;
long lVar4;
int iVar5;
long lVar6;
int *piVar7;
long in_FS_OFFSET;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = local_78;
for (lVar4 = 0xd; lVar4 !=... |
1,103 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
... | #include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i]... | O3 | c | func0:
endbr64
push %rbx
mov %rdi,%r8
mov %rcx,%r9
mov $0xd,%ecx
xor %r11d,%r11d
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%r10
mov %r10,%rdi
rep stos %rax,%es:(%rdi)
movsbl (%r8),%eax
test %al,%al
je 15b6 <func0+0x66>
nopl 0x0(%rax,%rax,1)
cmp ... | func0:
endbr64
sub rsp, 78h
mov r9, rdi
mov r10, rcx
mov ecx, 0Dh
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov r8, rsp
mov r11, rdx
mov rdi, r8
rep stosq
movsx eax, byte ptr [r9]
test al, al
jz loc_163B
nop dword ptr [rax+rax+00h]
loc_15B0:
cmp al,... | unsigned long long func0(_BYTE *a1, long long a2, int *a3, long long a4)
{
_BYTE *v4; // r9
int v7; // ecx
int v8; // eax
long long v9; // rax
int v10; // edx
long long v11; // rax
int v12; // edi
int v13; // edx
long long v14; // rdx
_DWORD v16[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long... | func0:
ENDBR64
SUB RSP,0x78
MOV R9,RDI
MOV R10,RCX
MOV ECX,0xd
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV R8,RSP
MOV R11,RDX
MOV RDI,R8
STOSQ.REP RDI
MOVSX EAX,byte ptr [R9]
TEST AL,AL
JZ 0x0010163b
NOP dword ptr [RAX + RAX*0x1]
LAB_001015b0:
CMP AL,0x20
JZ 0x00101628
SUB EAX,0x61
CDQE
M... | void func0(char *param_1,long param_2,int *param_3,long param_4)
{
char *pcVar1;
int iVar2;
int iVar3;
long lVar4;
int iVar5;
long lVar6;
int *piVar7;
long in_FS_OFFSET;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = local_78;
for (lVar4 = 0xd; lVar4 ... |
1,104 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *... | #include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %rcx,-0x50(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 11... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov [rbp+dest], rdx
mov [rbp+var_50], rcx
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], eax
mov eax, [rbp+var_18]
add eax, 1
cdqe
mov rdi, rax; size
call _m... | void func0(const char *a1, _BYTE *a2, char *a3, char *a4)
{
int v4; // eax
const char *v5; // rax
char v8; // [rsp+2Ah] [rbp-26h]
char v9; // [rsp+2Bh] [rbp-25h]
int v10; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int j; // [rsp+34h] [rbp-1Ch]
int v13; // [rsp+38h] [rbp-18h]
int v14; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
CDQE
MO... | void func0(char *param_1,char *param_2,char *param_3,char *param_4)
{
bool bVar1;
size_t sVar2;
char *__s;
char *__src;
int local_2c;
int local_28;
int local_24;
char *local_18;
sVar2 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar2 + 1));
local_2c = 0;
for (local_28 = 0; param_1[lo... |
1,105 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *... | #include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %rsi,%rbp
mov %rdx,%r13
mov %rcx,%r12
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %ecx,%eax
not %eax
movslq %eax,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbx
movzbl (%r14),... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov rbp, rsi
mov r13, rdx
mov r12, rcx
call _strlen
lea edi, [rax+1]
movsxd rdi, edi; size
call _malloc
mov rbx, rax
movzx ecx, byte ptr [r14]
test cl, cl
jz short loc_127D
movzx edi, byte ... | void func0(const char *a1, _BYTE *a2, char *a3, char *a4)
{
int v8; // eax
char *v9; // rbx
char v10; // cl
char v11; // di
char *v12; // rsi
int v13; // r8d
_BYTE *v14; // rdx
char v15; // al
int v16; // eax
int v17; // ecx
char *v18; // rdx
long long v19; // rax
const char *v20; // rsi
v... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV RBP,RSI
MOV R13,RDX
MOV R12,RCX
CALL 0x001010d0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101110
MOV RBX,RAX
MOVZX ECX,byte ptr [R14]
TEST CL,CL
JZ 0x0010127d
MOVZX EDI,byte ptr [RBP]
LEA RSI,[R14 + 0x1]
MOV R8D,0x0
JMP 0x00101262
LAB_0010124... | void func0(char *param_1,char *param_2,char *param_3,char *param_4)
{
char cVar1;
char cVar2;
int iVar3;
size_t sVar4;
char *__s;
long lVar5;
char cVar6;
char *pcVar7;
char *pcVar8;
sVar4 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar4 + 1));
cVar6 = *param_1;
if (cVar6 == '\0') ... |
1,106 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *... | #include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(... | O2 | c | func0:
endbr64
push %r14
mov %rsi,%r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
callq 10d0 <strlen@plt>
lea 0x1(%rax),%edi
movslq %edi,%rdi
callq 1110 <malloc@plt>
movzbl (%rbx),%ecx
mov %rax,%r13
test %cl,%cl
je 15f5 <func0+0x75>
movzbl (%r14... | func0:
endbr64
push r14
mov r14, rsi
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
call _strlen
lea edi, [rax+1]
movsxd rdi, edi; size
call _malloc
movzx ecx, byte ptr [r13+0]
mov r12, rax
test cl, cl
jz short loc_1605
movzx r8d, byt... | void func0(const char *a1, _BYTE *a2, void *a3, char *a4)
{
int v7; // eax
char *v8; // rax
char v9; // cl
char *v10; // r12
char v11; // r8
char *v12; // rsi
int v13; // edi
_BYTE *v14; // rdx
char v15; // al
size_t v16; // rax
long long v17; // rdx
char *v18; // rcx
const char *v19; // rsi
... | func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
CALL 0x001010e0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101130
MOVZX ECX,byte ptr [R13]
MOV R12,RAX
TEST CL,CL
JZ 0x00101605
MOVZX R8D,byte ptr [R14]
LEA RSI,[R13 + 0x1]
XOR EDI,EDI
NOP
LAB_001015d0:
MOV RDX,... | void func0(char *param_1,char *param_2,void *param_3,char *param_4)
{
char cVar1;
char cVar2;
size_t sVar3;
char *__s;
char *pcVar4;
long lVar5;
char cVar6;
char *pcVar7;
int iVar8;
sVar3 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar3 + 1));
cVar6 = *param_1;
pcVar4 = __s;
if ... |
1,107 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *... | #include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(... | O3 | c | func0:
endbr64
push %r14
mov %rsi,%r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
callq 10d0 <strlen@plt>
lea 0x1(%rax),%edi
movslq %edi,%rdi
callq 1110 <malloc@plt>
movzbl (%rbx),%ecx
mov %rax,%r13
test %cl,%cl
je 15f5 <func0+0x75>
movzbl (%r14... | func0:
endbr64
push r14
mov r14, rsi
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
call _strlen
lea edi, [rax+1]
movsxd rdi, edi; size
call _malloc
movzx ecx, byte ptr [r13+0]
mov r12, rax
test cl, cl
jz short loc_1605
movzx r8d, byt... | void func0(const char *a1, _BYTE *a2, void *a3, char *a4)
{
int v7; // eax
char *v8; // rax
char v9; // cl
char *v10; // r12
char v11; // r8
char *v12; // rsi
int v13; // edi
_BYTE *v14; // rdx
char v15; // al
size_t v16; // rax
long long v17; // rdx
char *v18; // rcx
const char *v19; // rsi
... | func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
CALL 0x001010e0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101130
MOVZX ECX,byte ptr [R13]
MOV R12,RAX
TEST CL,CL
JZ 0x00101605
MOVZX R8D,byte ptr [R14]
LEA RSI,[R13 + 0x1]
XOR EDI,EDI
NOP
LAB_001015d0:
MOV RDX,... | void func0(char *param_1,char *param_2,void *param_3,char *param_4)
{
char cVar1;
char cVar2;
size_t sVar3;
char *__s;
char *pcVar4;
long lVar5;
char cVar6;
char *pcVar7;
int iVar8;
sVar3 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar3 + 1));
cVar6 = *param_1;
pcVar4 = __s;
if ... |
1,108 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
... | #include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number o... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
jmpq 134a <func0+0x161>
movl $0x0,-0x20(%rbp)
movl $0x0,... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_24], 0
jmp loc_134A
loc_121E:
mov [rbp+var_20], 0
mov [... | _QWORD * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-24h]
int v4; // [rsp+20h] [rbp-20h]
int j; // [rsp+24h] [rbp-1Ch]
_QWORD *v6; // [rsp+28h] [rbp-18h]
v6 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
v4 = 0;
for ( j = 0; *(_BYTE *)(*(_QWORD *)(8LL * i + a1) + j); ++j )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010134a
LAB_0010121e:
MOV dword ptr [RBP + -0x20],... | void * func0(long param_1,int param_2)
{
void *pvVar1;
void *pvVar2;
int local_2c;
uint local_28;
int local_24;
pvVar1 = malloc((long)param_2 << 3);
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
local_28 = 0;
for (local_24 = 0; *(char *)((long)local_24 + *(long *)(param_1 +... |
1,109 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
... | #include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number o... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%ebx
movslq %esi,%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 12b6 <func0+0xcd>
lea -0x1(%rbx),%r15d
mov $0x0,%ebp
lea 0xde1(%rip),%r14... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov ebx, esi
movsxd r14, esi
shl r14, 3
mov rdi, r14; size
call _malloc
mov r15, rax
test ebx, ebx
jle loc_12B9
mov rbp, r13
mov r12, rax
add r13, r14
lea r14... | _QWORD * func0(char **a1, int a2)
{
_QWORD *v2; // rax
_QWORD *v3; // r15
char **v4; // rbp
_QWORD *v5; // r12
long long v6; // rdx
char v7; // al
int i; // ebx
void *v9; // rax
v2 = malloc(8LL * a2);
v3 = v2;
if ( a2 > 0 )
{
v4 = a1;
v5 = v2;
do
{
v7 = **v4;
v6 = (l... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV EBX,ESI
MOVSXD R14,ESI
SHL R14,0x3
MOV RDI,R14
CALL 0x001010e0
MOV R15,RAX
TEST EBX,EBX
JLE 0x001012b9
MOV RBP,R13
MOV R12,RAX
ADD R13,R14
LEA R14,[0x102008]
JMP 0x001012a3
LAB_0010122c:
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX ... | int8 * func0(int8 *param_1,int param_2)
{
char cVar1;
int8 *puVar2;
void *pvVar3;
char *pcVar4;
int iVar5;
int8 *puVar6;
int8 *puVar7;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar7 = param_1 + param_2;
puVar6 = puVar2;
do {
pcVar4 = (char *)*param_1;
... |
1,110 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
... | #include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number o... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10e0 <malloc@plt>
mov %rax,%r12
test %ebp,%ebp
jle 14a8 <func0+0xb8>
lea -0x1(%rbp),%r13d
xor %r14d,%r14d
lea 0xbdb(%rip),%r... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
movsxd rbp, esi
push rbx
mov rbx, rbp
shl rbp, 3
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov r13, rax
test ebx, ebx
jle loc_14C4
mov rbx, rax
add rbp, r14
lea r12, aTheNumberOfOdd... | void * func0(char **a1, int a2)
{
char **v2; // r14
void *v3; // rax
void *v4; // r13
_QWORD *v5; // rbx
int v6; // r15d
char v7; // al
char *i; // rdx
void *v9; // rax
v2 = a1;
v3 = malloc(8LL * a2);
v4 = v3;
if ( a2 > 0 )
{
v5 = v3;
do
{
v6 = 0;
v7 = **v2;
for ... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RBP
SHL RBP,0x3
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010e0
MOV R13,RAX
TEST EBX,EBX
JLE 0x001014c4
MOV RBX,RAX
ADD RBP,R14
LEA R12,[0x102008]
NOP
LAB_00101450:
MOV RDX,qword ptr [R14]
XOR R15D,R15D
MOVZX EAX,byte ptr [R... | int8 * func0(int8 *param_1,int param_2)
{
byte bVar1;
int8 *puVar2;
void *pvVar3;
byte *pbVar4;
int8 *puVar5;
int8 *puVar6;
int iVar7;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar6 = param_1 + param_2;
puVar5 = puVar2;
do {
pbVar4 = (byte *)*param_1;
... |
1,111 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
... | #include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number o... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10e0 <malloc@plt>
mov %rax,%r12
test %ebp,%ebp
jle 14c8 <func0+0xb8>
lea -0x1(%rbp),%r13d
xor %r14d,%r14d
lea 0xbbb(%rip),%r... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
movsxd rbp, esi
push rbx
mov rbx, rbp
shl rbp, 3
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov r13, rax
test ebx, ebx
jle loc_14C4
mov rbx, rax
add rbp, r14
lea r12, aTheNumberOfOdd... | void * func0(char **a1, int a2)
{
char **v2; // r14
void *v3; // rax
void *v4; // r13
_QWORD *v5; // rbx
int v6; // r15d
char v7; // al
char *i; // rdx
void *v9; // rax
v2 = a1;
v3 = malloc(8LL * a2);
v4 = v3;
if ( a2 > 0 )
{
v5 = v3;
do
{
v6 = 0;
v7 = **v2;
for ... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RBP
SHL RBP,0x3
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010e0
MOV R13,RAX
TEST EBX,EBX
JLE 0x001014c4
MOV RBX,RAX
ADD RBP,R14
LEA R12,[0x102008]
NOP
LAB_00101450:
MOV RDX,qword ptr [R14]
XOR R15D,R15D
MOVZX EAX,byte ptr [R... | int8 * func0(int8 *param_1,int param_2)
{
byte bVar1;
int8 *puVar2;
void *pvVar3;
byte *pbVar4;
int8 *puVar5;
int8 *puVar6;
int iVar7;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar6 = param_1 + param_2;
puVar5 = puVar2;
do {
pbVar4 = (byte *)*param_1;
... |
1,112 | func0 | #include <stdio.h>
| long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
} | #include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
a... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%rax
mov %rax,-0x10(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
movl $0x1,-0x14(%rbp)
jmp 11ef <func0+0x86>
cmpq $0x0,-0x10(%rbp)
jns 11be <func0+0x5... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_8], rax
mov [rbp+var_14], 1
jmp short loc_11EF
loc_1197:
cmp [rbp+var_10], 0
jn... | long long func0(long long *a1, int a2)
{
long long v2; // rax
int i; // [rsp+18h] [rbp-14h]
long long v5; // [rsp+1Ch] [rbp-10h]
long long v6; // [rsp+24h] [rbp-8h]
v5 = *a1;
v6 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v5 >= 0 )
v2 = a1[i];
else
v2 = a1[i] + v5;
v5 = v2;
if... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001011e... | long func0(long *param_1,int param_2)
{
int local_1c;
long local_18;
long local_10;
local_18 = *param_1;
local_10 = *param_1;
for (local_1c = 1; local_1c < param_2; local_1c = local_1c + 1) {
if (local_18 < 0) {
local_18 = local_18 + param_1[local_1c];
}
else {
local_18 = param_1... |
1,113 | func0 | #include <stdio.h>
| long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
} | #include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
a... | O1 | c | func0:
endbr64
mov (%rdi),%rax
cmp $0x1,%esi
jle 11a3 <func0+0x3a>
lea 0x8(%rdi),%rdx
lea -0x2(%rsi),%ecx
lea 0x10(%rdi,%rcx,8),%rsi
mov %rax,%rcx
jmp 1199 <func0+0x30>
add (%rdx),%rax
cmp %rax,%rcx
cmovg %rax,%rcx
add $0x8,%rdx
cmp %rsi,%rdx
je 11a6 <func0+0x3d>
test %rax,%ra... | func0:
endbr64
mov rax, [rdi]
cmp esi, 1
jle short loc_11A3
lea rdx, [rdi+8]
lea ecx, [rsi-2]
lea rsi, [rdi+rcx*8+10h]
mov rcx, rax
jmp short loc_1199
loc_1186:
mov rax, [rdx]
loc_1189:
cmp rcx, rax
cmovg rcx, rax
add rdx, 8
cmp rdx, rsi
jz short loc_11A6
loc_1199:... | long long func0(long long *a1, int a2)
{
long long v2; // rax
long long *v3; // rdx
long long v4; // rsi
long long v5; // rcx
v2 = *a1;
if ( a2 <= 1 )
return *a1;
v3 = a1 + 1;
v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
v5 = *a1;
do
{
if ( v2 >= 0 )
v2 = *v3;
else
v2... | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
CMP ESI,0x1
JLE 0x001011a3
LEA RDX,[RDI + 0x8]
LEA ECX,[RSI + -0x2]
LEA RSI,[RDI + RCX*0x8 + 0x10]
MOV RCX,RAX
JMP 0x00101199
LAB_00101186:
MOV RAX,qword ptr [RDX]
LAB_00101189:
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x8
CMP RDX,RSI
JZ 0x001011a6
LAB_00101199:
TEST RAX,RAX
JNS 0x001011... | long func0(long *param_1,int param_2)
{
long lVar1;
long lVar2;
long *plVar3;
lVar1 = *param_1;
lVar2 = lVar1;
if (1 < param_2) {
plVar3 = param_1 + 1;
do {
if (lVar1 < 0) {
lVar1 = lVar1 + *plVar3;
}
else {
lVar1 = *plVar3;
}
if (lVar1 < lVar2) {
... |
1,114 | func0 | #include <stdio.h>
| long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
} | #include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
a... | O2 | c | func0:
endbr64
mov (%rdi),%rax
cmp $0x1,%esi
jle 15e8 <func0+0x48>
lea -0x2(%rsi),%ecx
lea 0x8(%rdi),%rdx
mov %rax,%r8
lea 0x10(%rdi,%rcx,8),%rdi
nopl 0x0(%rax,%rax,1)
mov (%rdx),%rcx
test %rax,%rax
lea (%rax,%rcx,1),%rsi
mov %rcx,%rax
cmovs %rsi,%rax
cmp %rax,%r8
cmovg %rax,%r8
a... | func0:
endbr64
mov rax, [rdi]
cmp esi, 1
jle short loc_1608
lea ecx, [rsi-2]
lea rdx, [rdi+8]
lea r8, [rdi+rcx*8+10h]
mov rcx, rax
nop dword ptr [rax+rax+00h]
loc_15E0:
mov rsi, [rdx]
test rax, rax
lea rdi, [rax+rsi]
mov rax, rsi
cmovs rax, rdi
cmp rcx, rax
cmovg r... | long long func0(long long *a1, int a2)
{
long long result; // rax
long long *v3; // rdx
long long v4; // r8
long long v5; // rcx
bool v6; // sf
long long v7; // rdi
result = *a1;
if ( a2 > 1 )
{
v3 = a1 + 1;
v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
v5 = *a1;
do
{
v6... | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
CMP ESI,0x1
JLE 0x00101608
LEA ECX,[RSI + -0x2]
LEA RDX,[RDI + 0x8]
LEA R8,[RDI + RCX*0x8 + 0x10]
MOV RCX,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001015e0:
MOV RSI,qword ptr [RDX]
TEST RAX,RAX
LEA RDI,[RAX + RSI*0x1]
MOV RAX,RSI
CMOVS RAX,RDI
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x8
CM... | long func0(long *param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
long *plVar4;
bool bVar5;
lVar2 = *param_1;
if (1 < param_2) {
plVar4 = param_1 + 1;
lVar3 = lVar2;
do {
bVar5 = lVar2 < 0;
lVar1 = lVar2 + *plVar4;
lVar2 = *plVar4;
if (bVar5) {
lVa... |
1,115 | func0 | #include <stdio.h>
| long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
} | #include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
a... | O3 | c | func0:
endbr64
mov (%rdi),%rcx
cmp $0x1,%esi
jle 1678 <func0+0x48>
lea -0x2(%rsi),%eax
lea 0x8(%rdi),%rdx
mov %rcx,%r8
lea 0x10(%rdi,%rax,8),%rsi
jmp 1653 <func0+0x23>
nopl (%rax)
mov %rax,%rcx
mov (%rdx),%rax
test %rcx,%rcx
jns 165e <func0+0x2e>
add %rcx,%rax
cmp %rax,%r8
cmo... | func0:
endbr64
mov r8, [rdi]
cmp esi, 1
jle short loc_1198
lea eax, [rsi-2]
lea rdx, [rdi+8]
mov rcx, r8
lea rsi, [rdi+rax*8+10h]
jmp short loc_1173
loc_1160:
cmp rcx, rax
cmovg rcx, rax
add rdx, 8
cmp rsi, rdx
jz short loc_118E
loc_1170:
mov r8, rax
loc_1173:
mov ... | long long func0(long long *a1, int a2)
{
long long v2; // r8
long long *v3; // rdx
long long v4; // rcx
long long v5; // rsi
long long v6; // rax
v2 = *a1;
if ( a2 > 1 )
{
v3 = a1 + 1;
v4 = *a1;
v5 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
while ( 1 )
{
v6 = *v3;
if... | func0:
ENDBR64
MOV R8,qword ptr [RDI]
CMP ESI,0x1
JLE 0x00101198
LEA EAX,[RSI + -0x2]
LEA RDX,[RDI + 0x8]
MOV RCX,R8
LEA RSI,[RDI + RAX*0x8 + 0x10]
JMP 0x00101173
LAB_00101160:
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x8
CMP RSI,RDX
JZ 0x0010118e
LAB_00101170:
MOV R8,RAX
LAB_00101173:
MOV RAX,qword ptr [RDX]
TEST R8,R8
JNS 0... | long func0(long *param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
long *plVar4;
lVar3 = *param_1;
if (param_2 < 2) {
return lVar3;
}
plVar4 = param_1 + 1;
lVar2 = lVar3;
while( true ) {
lVar1 = *plVar4;
if (lVar2 < 0) {
lVar2 = lVar1 + lVar2;
if (lVar2 < lVar3) ... |
1,116 | func0 | #include <stdio.h>
| int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %ecx,-0x24(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 124f <func0+0x86>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 122b <func0+0x62>
mov -0xc(%rbp),%eax
cltq
lea 0x... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_24], ecx
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_124F
loc_11EE:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_122B
loc_11FE:
mov eax, ... | long long func0(long long a1, int a2, int a3, int a4)
{
unsigned int v5; // [rsp+14h] [rbp-10h]
int i; // [rsp+18h] [rbp-Ch]
int v7; // [rsp+1Ch] [rbp-8h]
int j; // [rsp+20h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
v7 = 0;
for ( j = 0; j < a3; ++j )
v7 += *(_DWORD *)(4LL * j + *(_QWO... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010124f
LAB_001011ee:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JM... | int [16] func0(long param_1,int param_2,ulong param_3,int param_4)
{
int iVar1;
int iVar2;
int auVar3 [16];
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
iVar2 = (int)param_3;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
local_10 = 0;
for ... |
1,117 | func0 | #include <stdio.h>
| int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows... | O1 | c | func0:
endbr64
test %esi,%esi
jle 122a <func0+0x61>
push %rbx
mov %edx,%r9d
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r10
lea -0x1(%rdx),%eax
mov $0x0,%edi
lea 0x4(,%rax,4),%rbx
mov $0x0,%r11d
jmp 1201 <func0+0x38>
add $0x8,%r8
cmp %r10,%r8
je 1232 <func0+0x69>
t... | func0:
endbr64
test esi, esi
jle short loc_1229
push rbp
push rbx
mov r10d, edx
mov r9d, ecx
mov r8, rdi
movsxd rsi, esi
lea rbx, [rdi+rsi*8]
movsxd r11, edx
shl r11, 2
mov edi, 0
mov ebp, 0
jmp short loc_11FF
loc_11F6:
add r8, 8
cmp r8, rbx
jz short loc_1231
... | long long func0(_DWORD **a1, int a2, int a3, int a4)
{
_DWORD **v5; // r8
_DWORD **v6; // rbx
unsigned int v7; // edi
_DWORD *v8; // rax
int v9; // ecx
if ( a2 <= 0 )
return 0LL;
v5 = a1;
v6 = &a1[a2];
v7 = 0;
do
{
if ( a3 > 0 )
{
v8 = *v5;
v9 = 0;
do
v9 += ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101229
PUSH RBP
PUSH RBX
MOV R10D,EDX
MOV R9D,ECX
MOV R8,RDI
MOVSXD RSI,ESI
LEA RBX,[RDI + RSI*0x8]
MOVSXD R11,EDX
SHL R11,0x2
MOV EDI,0x0
MOV EBP,0x0
JMP 0x001011ff
LAB_001011f6:
ADD R8,0x8
CMP R8,RBX
JZ 0x00101231
LAB_001011ff:
TEST R10D,R10D
JLE 0x001011f6
MOV RAX,qword ptr [R8]
L... | int [16] func0(int8 *param_1,int param_2,ulong param_3,int param_4)
{
int8 *puVar1;
int *piVar2;
int auVar3 [16];
int *piVar4;
int iVar5;
int iVar6;
uint uVar7;
int auVar8 [16];
if (0 < param_2) {
iVar6 = (int)param_3;
puVar1 = param_1 + param_2;
uVar7 = 0;
do {
if (0 < iVar... |
1,118 | func0 | #include <stdio.h>
| int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows... | O2 | c | func0:
endbr64
mov %edx,%r11d
test %esi,%esi
jle 16e6 <func0+0x66>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x8(%rdi,%rax,8),%r9
lea -0x1(%rdx),%eax
lea 0x4(,%rax,4),%r10
nopl 0x0(%rax)
test %r11d,%r11d
jle 16d9 <func0+0x59>
mov (%rdi),%rax
xor %edx,%edx
lea (%r10,%rax,1),%rsi
nopw ... | func0:
endbr64
mov r8d, ecx
test esi, esi
jle short loc_159F
movsxd rsi, esi
lea r10, [rdi+rsi*8]
loc_1592:
test edx, edx
jg short loc_15A6
add rdi, 8
cmp rdi, r10
jnz short loc_1592
loc_159F:
xor r9d, r9d
mov eax, r9d
retn
loc_15A6:
movsxd rdx, edx
xor r9d, r9d
lea ... | long long func0(_DWORD **a1, int a2, int a3, int a4)
{
_DWORD **v4; // r10
unsigned int v6; // r9d
long long v7; // rsi
_DWORD *v8; // rax
int v9; // edx
if ( a2 <= 0 )
return 0LL;
v4 = &a1[a2];
while ( a3 <= 0 )
{
if ( ++a1 == v4 )
return 0LL;
}
v6 = 0;
v7 = a3;
do
{
whi... | func0:
ENDBR64
MOV R8D,ECX
TEST ESI,ESI
JLE 0x0010159f
MOVSXD RSI,ESI
LEA R10,[RDI + RSI*0x8]
LAB_00101592:
TEST EDX,EDX
JG 0x001015a6
ADD RDI,0x8
CMP RDI,R10
JNZ 0x00101592
LAB_0010159f:
XOR R9D,R9D
MOV EAX,R9D
RET
LAB_001015a6:
MOVSXD RDX,EDX
XOR R9D,R9D
LEA RSI,[RDX*0x4]
NOP dword ptr [RAX]
LAB_001015b8:
MOV RAX,qwo... | int func0(int8 *param_1,int param_2,int param_3,int param_4)
{
int8 *puVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
if (0 < param_2) {
puVar1 = param_1 + param_2;
do {
if (0 < param_3) {
iVar5 = 0;
do {
while( true ) {
piVar3 = (int *)*param_1... |
1,119 | func0 | #include <stdio.h>
| int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
} | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows... | O3 | c | func0:
endbr64
test %esi,%esi
jle 171a <func0+0xfa>
mov %edx,%r11d
lea -0x1(%rsi),%eax
mov %edx,%r9d
push %r13
shr $0x2,%r11d
push %r12
mov %edx,%r8d
and $0xfffffffc,%r9d
push %rbp
shl $0x4,%r11
lea -0x1(%rdx),%ebp
xor %r10d,%r10d
push %rbx
lea 0x8(%rdi,%rax,8),%rbx
nopl (%r... | func0:
endbr64
test esi, esi
jle loc_1547
movsxd rsi, esi
push r13
mov r9d, ecx
mov r8d, edx
push r12
mov rcx, rdi
push rbp
push rbx
lea rbx, [rdi+rsi*8]
loc_1452:
test r8d, r8d
jg short loc_146D
add rcx, 8
cmp rcx, rbx
jnz short loc_1452
xor r10d, r10d
loc_14... | long long func0(const __m128i **a1, int a2, int a3, int a4)
{
const __m128i **v6; // rcx
const __m128i **v7; // rbx
unsigned int v8; // r10d
unsigned int v10; // ebp
const __m128i *v11; // rsi
const __m128i *v12; // rax
__m128i v13; // xmm0
__m128i v14; // xmm2
int v15; // edx
__m128i v16; // xmm0
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101547
MOVSXD RSI,ESI
PUSH R13
MOV R9D,ECX
MOV R8D,EDX
PUSH R12
MOV RCX,RDI
PUSH RBP
PUSH RBX
LEA RBX,[RDI + RSI*0x8]
LAB_00101452:
TEST R8D,R8D
JG 0x0010146d
ADD RCX,0x8
CMP RCX,RBX
JNZ 0x00101452
XOR R10D,R10D
LAB_00101463:
POP RBX
MOV EAX,R10D
POP RBP
POP R12
POP R13
RET
LAB_00101... | int func0(int8 *param_1,int param_2,uint param_3,int param_4)
{
int8 *puVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
int *piVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
if (param_2 < 1) {
return 0;
}
puVar1 = param_1 + param... |
1,120 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
fu... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 12dd <func0+0x154>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 12cd <func0+0x144>
movl $0x0,-0x18(%rbp)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_C], 0
jmp loc_12DD
loc_11A4:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp loc_12CD
loc_11B2:
mov [rbp+var_18], 0
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov... | long long func0(long long a1, int a2)
{
long long result; // rax
int v3; // [rsp+14h] [rbp-18h]
int v4; // [rsp+14h] [rbp-18h]
int v5; // [rsp+18h] [rbp-14h]
int v6; // [rsp+18h] [rbp-14h]
int v7; // [rsp+1Ch] [rbp-10h]
unsigned int i; // [rsp+20h] [rbp-Ch]
int j; // [rsp+24h] [rbp-8h]
int v10; // [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012dd
LAB_001011a4:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012cd
LAB_001011b2:
MOV dword ptr [RBP + -0x18],0x0
MOV EAX,dword ptr [RBP + ... | void func0(long param_1,int param_2)
{
int4 uVar1;
int iVar2;
int local_20;
uint local_1c;
uint local_18;
int local_14;
int local_10;
for (local_14 = 0; local_10 = local_14, local_14 < param_2; local_14 = local_14 + 1) {
while (local_10 = local_10 + 1, local_10 < param_2) {
local_20 = 0;
... |
1,121 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
fu... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1240 <func0+0xb7>
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r11
mov %esi,%ebp
mov %rdi,%r10
lea -0x1(%rsi),%r13d
add $0x1,%r13
mov $0x1,%r12d
jmp 121e <func0+0x95>
mov $0x0,%ecx
jmp 1207 <func0+0x7e>
mov %r9d,(%rbx)
mov %r8d,(%r11,%... | func0:
endbr64
test esi, esi
jle locret_128D
mov edx, esi
lea r10, [rdi+4]
lea r8d, [rsi-1]
mov esi, esi
movsxd rdx, edx
mov eax, 1
lea r9, [rdi+8]
mov edi, r8d
mov rcx, rsi
cmp rax, rsi
jz locret_128D
push r15
push r14
push r13
push r12
push rbp
push r... | void func0(long long a1, int a2)
{
int *v2; // r10
long long v3; // rdx
long long v4; // rax
long long v5; // r9
int v6; // edi
long long v7; // rcx
int v8; // r11d
int *v9; // rbx
int v10; // r12d
int v11; // r13d
int v12; // eax
int v13; // r8d
int v14; // eax
int *v15; // rsi
long long... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010128d
MOV EDX,ESI
LEA R10,[RDI + 0x4]
LEA R8D,[RSI + -0x1]
MOV ESI,ESI
MOVSXD RDX,EDX
MOV EAX,0x1
LEA R9,[RDI + 0x8]
MOV EDI,R8D
MOV RCX,RSI
CMP RAX,RSI
JZ 0x0010128d
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
JMP 0x00101255
LAB_001011cb:
MOV R11D,0x0
JMP 0x0010122a
LAB_0... | void func0(long param_1,uint param_2)
{
ulong uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
uint *puVar6;
int iVar7;
uint *puVar8;
int iVar9;
if (0 < (int)param_2) {
puVar8 = (uint *)(param_1 + 4);
uVar5 = 1;
if ((ulong)param_2 != 1) {
do {
puVar6 = puVar8;
... |
1,122 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
fu... | O2 | c | func0:
endbr64
test %esi,%esi
jle 164e <func0+0xbe>
push %r12
lea -0x1(%rsi),%r12d
mov %rdi,%r11
mov %rdi,%r10
push %rbp
add $0x1,%r12
mov $0x1,%ebp
push %rbx
mov %esi,%ebx
cmp %rbp,%r12
je 1628 <func0+0x98>
nopw 0x0(%rax,%rax,1)
mov %rbp,%rdi
nopl 0x0(%rax,%rax,1)
mov (%r1... | func0:
endbr64
test esi, esi
jle locret_158E
push rbp
mov r10, rdi
mov ebp, esi
mov r11d, 1
push rbx
mov ebx, esi
cmp esi, 1
jz short loc_1564
loc_1500:
mov rdi, r11
nop dword ptr [rax+rax+00h]
loc_1508:
mov r8d, [r10+r11*4-4]
mov r9d, [r10+rdi*4]
test r8d, r8d
j... | void func0(long long a1, int a2)
{
long long v3; // r11
long long v4; // rdi
int v5; // r8d
int v6; // r9d
int v7; // eax
int v8; // ecx
int v9; // edx
bool v10; // al
if ( a2 > 0 )
{
v3 = 1LL;
if ( a2 != 1 )
{
do
{
v4 = v3;
do
{
v5 = *(_DW... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010158e
PUSH RBP
MOV R10,RDI
MOV EBP,ESI
MOV R11D,0x1
PUSH RBX
MOV EBX,ESI
CMP ESI,0x1
JZ 0x00101564
LAB_00101500:
MOV RDI,R11
NOP dword ptr [RAX + RAX*0x1]
LAB_00101508:
MOV R8D,dword ptr [R10 + R11*0x4 + -0x4]
MOV R9D,dword ptr [R10 + RDI*0x4]
TEST R8D,R8D
JLE 0x00101580
MOV EAX,R8D... | void func0(long param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
int iVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
if ((int)param_2 < 1) {
return;
}
uVar6 = 1;
uVar7 = uVar6;
if (param_2 != 1) {
do {
uVar1 = *(uint *)(param_1 + -4 + uVar7 * 4);
uVar... |
1,123 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
fu... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 159e <func0+0xbe>
push %r12
lea -0x2(%rsi),%r12d
mov %rdi,%r11
mov %rdi,%r10
push %rbp
add $0x2,%r12
mov $0x1,%ebp
push %rbx
mov %esi,%ebx
nopw %cs:0x0(%rax,%rax,1)
mov %rbp,%rdi
nopl 0x0(%rax,%rax,1)
mov (%r10),%r8d
mov (%r11,%rdi,4),%r9d
test... | func0:
endbr64
test esi, esi
jle locret_158E
push rbp
mov r10, rdi
mov ebp, esi
mov r11d, 1
push rbx
mov ebx, esi
cmp esi, 1
jz short loc_1564
loc_1500:
mov rdi, r11
nop dword ptr [rax+rax+00h]
loc_1508:
mov r8d, [r10+r11*4-4]
mov r9d, [r10+rdi*4]
test r8d, r8d
j... | void func0(long long a1, int a2)
{
long long v3; // r11
long long v4; // rdi
int v5; // r8d
int v6; // r9d
int v7; // eax
int v8; // ecx
int v9; // edx
bool v10; // al
if ( a2 > 0 )
{
v3 = 1LL;
if ( a2 != 1 )
{
do
{
v4 = v3;
do
{
v5 = *(_DW... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010158e
PUSH RBP
MOV R10,RDI
MOV EBP,ESI
MOV R11D,0x1
PUSH RBX
MOV EBX,ESI
CMP ESI,0x1
JZ 0x00101564
LAB_00101500:
MOV RDI,R11
NOP dword ptr [RAX + RAX*0x1]
LAB_00101508:
MOV R8D,dword ptr [R10 + R11*0x4 + -0x4]
MOV R9D,dword ptr [R10 + RDI*0x4]
TEST R8D,R8D
JLE 0x00101580
MOV EAX,R8D... | void func0(long param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
int iVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
if ((int)param_2 < 1) {
return;
}
uVar6 = 1;
uVar7 = uVar6;
if (param_2 != 1) {
do {
uVar1 = *(uint *)(param_1 + -4 + uVar7 * 4);
uVar... |
1,124 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %rdx,-0x58(%rbp)
lea 0xd80(%rip),%rax
mov %rax,-0x28(%rbp)
movq $0x0,-0x30(%rbp)
movl $0x0,-0x40(%rbp)
movl $0x0,-0x3c(%rbp)
movl $0x0,-0x38(%rbp)
mov -0x48(%rbp),%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+s], rdi
mov [rbp+var_4C], esi
mov [rbp+var_58], rdx
lea rax, aAeiouaeiou; "aeiouAEIOU"
mov [rbp+var_28], rax
mov [rbp+ptr], 0
mov [rbp+var_40], 0
mov [rbp+var_3C], 0
mov [rbp+var_38], 0
mov rax, [rb... | void * func0(const char *a1, int a2, _DWORD *a3)
{
size_t v3; // rax
int v6; // [rsp+20h] [rbp-40h]
int v7; // [rsp+24h] [rbp-3Ch]
int v8; // [rsp+28h] [rbp-38h]
int i; // [rsp+2Ch] [rbp-34h]
void *ptr; // [rsp+30h] [rbp-30h]
size_t v11; // [rsp+40h] [rbp-20h]
char *src; // [rsp+48h] [rbp-18h]
ptr = ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV qword ptr [RBP + -0x58],RDX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0x0
MOV dword ptr [RBP ... | void * func0(char *param_1,int param_2,int *param_3)
{
size_t sVar1;
char *__s;
ushort **ppuVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
int local_48;
int local_44;
int local_40;
int local_3c;
void *local_38;
local_38 = (void *)0x0;
local_48 = 0;
local_44 = 0;
local_40 = 0;
sVar1 ... |
1,125 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r14
mov %esi,0x18(%rsp)
mov %rdx,0x28(%rsp)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
lea -0x1(%rdi),%rax
mov %rax,0x8(%rsp)
cal... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r15, rdi
mov [rsp+68h+var_58], esi
mov rbp, rdx
call _strlen
mov r14, rax
lea rdi, [rax+1]; size
call _malloc
mov [rsp+68h+s], rax
call ___ctype_b_loc
mov [rsp+68h+var_60], ra... | void * func0(const char *a1, int a2, _DWORD *a3)
{
size_t v4; // r14
long long v5; // rbx
int v6; // r13d
const unsigned __int16 *v7; // r12
char v8; // bp
size_t v9; // rbp
void *v10; // rax
int v12; // [rsp+4h] [rbp-64h]
const unsigned __int16 **v13; // [rsp+8h] [rbp-60h]
int v14; // [rsp+14h] [rb... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R15,RDI
MOV dword ptr [RSP + 0x10],ESI
MOV RBP,RDX
CALL 0x001010f0
MOV R14,RAX
LEA RDI,[RAX + 0x1]
CALL 0x00101140
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00101170
MOV qword ptr [RSP + 0x8],RAX
MOV EBX,0x0
MOV R13D,0x0
MOV dword ptr [RS... | void * func0(char *param_1,int param_2,int *param_3)
{
byte bVar1;
ushort *puVar2;
size_t sVar3;
char *__s;
ushort **ppuVar4;
char *pcVar5;
size_t sVar6;
void *pvVar7;
int iVar8;
int iVar10;
bool bVar11;
int local_64;
int local_54;
void *local_50;
size_t sVar9;
sVar3 = strlen(param_1... |
1,126 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
... | O2 | c | func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
xor %r14d,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %esi,0xc(%rsp)
mov %rdx,0x28(%rsp)
callq 10f0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbx
callq 1150 <malloc@plt>
add $0x1,%ebx
mov %r... | func0:
endbr64
push r15
xor r15d, r15d
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_5C], esi
mov [rsp+68h+var_40], rdx
call _strlen
lea rdi, [rax+1]; size
mov rbx, rax
call _malloc
lea r13d, [rbx+1]
xor ebx, ebx
mov ... | char * func0(const char *a1, int a2, _DWORD *a3)
{
int v3; // r15d
const char *v4; // r14
size_t v5; // rax
int v6; // r13d
int v7; // ebx
char *v8; // rbp
const unsigned __int16 **v9; // rax
int v10; // r11d
const unsigned __int16 *v11; // r12
long long v12; // rsi
int v13; // eax
char *v14; //... | func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0xc],ESI
MOV qword ptr [RSP + 0x28],RDX
CALL 0x001010f0
LEA RDI,[RAX + 0x1]
MOV RBX,RAX
CALL 0x00101150
LEA R13D,[RBX + 0x1]
XOR EBX,EBX
MOV RBP,RAX
CALL 0x00101170
MOV dword ptr [RSP + 0x20]... | void * func0(byte *param_1,int param_2,int *param_3)
{
byte bVar1;
ushort *puVar2;
size_t sVar3;
char *__s;
ushort **ppuVar4;
char *pcVar5;
size_t sVar6;
void *pvVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
void *local_58;
int local_48;
iVar11 = 0;
sVar3 = strlen((char *)param... |
1,127 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
... | O3 | c | func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
xor %r14d,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %esi,0xc(%rsp)
mov %rdx,0x28(%rsp)
callq 10f0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbx
callq 1150 <malloc@plt>
add $0x1,%ebx
mov %r... | func0:
endbr64
push r15
xor r15d, r15d
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_5C], esi
mov [rsp+68h+var_40], rdx
call _strlen
lea rdi, [rax+1]; size
mov rbx, rax
call _malloc
lea r13d, [rbx+1]
xor ebx, ebx
mov ... | char * func0(const char *a1, int a2, _DWORD *a3)
{
int v3; // r15d
const char *v4; // r14
size_t v5; // rax
int v6; // r13d
int v7; // ebx
char *v8; // rbp
const unsigned __int16 **v9; // rax
int v10; // r11d
const unsigned __int16 *v11; // r12
long long v12; // rsi
int v13; // eax
char *v14; //... | func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0xc],ESI
MOV qword ptr [RSP + 0x28],RDX
CALL 0x001010f0
LEA RDI,[RAX + 0x1]
MOV RBX,RAX
CALL 0x00101150
LEA R13D,[RBX + 0x1]
XOR EBX,EBX
MOV RBP,RAX
CALL 0x00101170
MOV dword ptr [RSP + 0x20]... | void * func0(byte *param_1,int param_2,int *param_3)
{
byte bVar1;
ushort *puVar2;
size_t sVar3;
char *__s;
ushort **ppuVar4;
char *pcVar5;
size_t sVar6;
void *pvVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
void *local_58;
int local_48;
iVar11 = 0;
sVar3 = strlen((char *)param... |
1,128 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0(... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
lea 0xe48(%rip),%rax
mov %rax,-0x10(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
sub $0x2,%eax
mov %eax,-0x14(%rbp)
jmpq 127e <func0+0xd5>
mov -... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
lea rax, aAeiouaeiou; "AEIOUaeiou"
mov [rbp+var_10], rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
sub eax, 2
mov [rbp+var_14], eax
jmp loc_127E
loc_11E3... | char * func0(const char *a1)
{
int i; // [rsp+1Ch] [rbp-14h]
for ( i = strlen(a1) - 2; i > 0; --i )
{
if ( strchr("AEIOUaeiou", a1[i]) && !strchr("AEIOUaeiou", a1[i + 1]) && !strchr("AEIOUaeiou", a1[i - 1]) )
{
out_1 = a1[i];
return &out_1;
}
}
out_1 = 0;
return &out_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101080
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
SUB EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0010127e
LAB_001... | int2 * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int local_1c;
sVar1 = strlen(param_1);
local_1c = (int)sVar1 + -2;
while( true ) {
if (local_1c < 1) {
out_1._0_1_ = 0;
return &out_1;
}
pcVar2 = strchr("AEIOUaeiou",(int)param_1[local_1c]);
if (((pcVar2 != (char *)0x0... |
1,129 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0(... | O1 | c | func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x3(%rcx),%eax
test %eax,%eax
jle 1211 <func0+0xa8>
push %r14
push %r13
push %r12
push %rbp
push %rbx
lea -0x1(%rcx),%rsi
cltq
lea (%rdx,%rax,1),%rbx
lea -0x1(%rdx,%rax,... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
call _strlen
lea edx, [rax-2]
test edx, edx
jle short loc_123D
movsxd rdx, edx
lea rbx, [rbp+rdx+0]
lea r14, [rbp+rdx-1]
lea eax, [rax-3]
sub r14, rax
lea r12, s; "AEIOUaeiou"
jmp short loc... | char * func0(const char *a1)
{
int v1; // eax
char *v2; // rbx
long long v3; // r14
char v4; // bp
v1 = strlen(a1);
if ( v1 - 2 <= 0 )
{
v4 = 0;
}
else
{
v2 = (char *)&a1[v1 - 2];
v3 = (long long)&v2[-(v1 - 3) - 1];
while ( 1 )
{
v4 = *v2;
if ( strchr("AEIOUaeiou", *... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
CALL 0x00101080
LEA EDX,[RAX + -0x2]
TEST EDX,EDX
JLE 0x0010123d
MOVSXD RDX,EDX
LEA RBX,[RBP + RDX*0x1]
LEA R14,[RBP + RDX*0x1 + -0x1]
LEA EAX,[RAX + -0x3]
SUB R14,RAX
LEA R12,[0x102004]
JMP 0x001011e9
LAB_001011e0:
SUB RBX,0x1
CMP RBX,R14
JZ 0x001... | int2 * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
char cVar5;
sVar1 = strlen(param_1);
iVar3 = (int)sVar1 + -2;
if (iVar3 < 1) {
cVar5 = '\0';
}
else {
pcVar4 = param_1 + iVar3;
do {
cVar5 = *pcVar4;
pcVar2 = strchr("AEIOUaeiou",(int)cVar5... |
1,130 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0(... | O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x2(%rax),%edx
test %edx,%edx
jle 14f0 <func0+0x90>
movslq %edx,%rdx
sub $0x3,%eax
lea 0xb7a(%rip),%r12
lea -0x1(%rbp,%rdx,1),%r13
lea 0x0(%rbp,%rdx,1),%rbx
sub %rax,%r13... | func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-2]
test edx, edx
jle loc_1500
lea r13, [rbp+rdx-1]
sub eax, 3
lea rbx, [rbp+rdx+0]
sub r13, rax
lea r12, s; "AEIOUaeiou"
jmp short loc_14A9
loc_14A0:
sub rb... | char * func0(const char *a1)
{
int v1; // eax
long long v2; // rdx
char *v3; // rbx
long long v4; // r13
char v5; // bp
v1 = strlen(a1);
v2 = (unsigned int)(v1 - 2);
if ( v1 - 2 <= 0 )
{
LABEL_8:
v5 = 0;
}
else
{
v3 = (char *)&a1[v2];
v4 = (long long)&a1[v2 - 1 - (unsigned int)(v1 -... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x2]
TEST EDX,EDX
JLE 0x00101500
LEA R13,[RBP + RDX*0x1 + -0x1]
SUB EAX,0x3
LEA RBX,[RBP + RDX*0x1]
SUB R13,RAX
LEA R12,[0x102004]
JMP 0x001014a9
LAB_001014a0:
SUB RBX,0x1
CMP RBX,R13
JZ 0x00101500
LAB_001014a9:
M... | int2 * func0(char *param_1)
{
char cVar1;
size_t sVar2;
char *pcVar3;
uint uVar4;
char *pcVar5;
sVar2 = strlen(param_1);
uVar4 = (int)sVar2 - 2;
if (0 < (int)uVar4) {
pcVar5 = param_1 + uVar4;
do {
cVar1 = *pcVar5;
pcVar3 = strchr("AEIOUaeiou",(int)cVar1);
if (((pcVar3 != (... |
1,131 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0(... | O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x2(%rax),%edx
test %edx,%edx
jle 14f0 <func0+0x90>
movslq %edx,%rdx
sub $0x3,%eax
lea 0xb7a(%rip),%r12
lea -0x1(%rbp,%rdx,1),%r13
lea 0x0(%rbp,%rdx,1),%rbx
sub %rax,%r13... | func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-2]
test edx, edx
jle loc_1500
lea r13, [rbp+rdx-1]
sub eax, 3
lea rbx, [rbp+rdx+0]
sub r13, rax
lea r12, s; "AEIOUaeiou"
jmp short loc_14A9
loc_14A0:
sub rb... | char * func0(const char *a1)
{
int v1; // eax
long long v2; // rdx
char *v3; // rbx
long long v4; // r13
char v5; // bp
v1 = strlen(a1);
v2 = (unsigned int)(v1 - 2);
if ( v1 - 2 <= 0 )
{
LABEL_8:
v5 = 0;
}
else
{
v3 = (char *)&a1[v2];
v4 = (long long)&a1[v2 - 1 - (unsigned int)(v1 -... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x2]
TEST EDX,EDX
JLE 0x00101500
LEA R13,[RBP + RDX*0x1 + -0x1]
SUB EAX,0x3
LEA RBX,[RBP + RDX*0x1]
SUB R13,RAX
LEA R12,[0x102004]
JMP 0x001014a9
LAB_001014a0:
SUB RBX,0x1
CMP RBX,R13
JZ 0x00101500
LAB_001014a9:
M... | int2 * func0(char *param_1)
{
char cVar1;
size_t sVar2;
char *pcVar3;
uint uVar4;
char *pcVar5;
sVar2 = strlen(param_1);
uVar4 = (int)sVar2 - 2;
if (0 < (int)uVar4) {
pcVar5 = param_1 + uVar4;
do {
cVar1 = *pcVar5;
pcVar3 = strchr("AEIOUaeiou",(int)cVar1);
if (((pcVar3 != (... |
1,132 | func0 | #include <stdio.h>
#include <string.h>
| const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2;... | #include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes"... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x8(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_14], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov rax, [rbp+var_30]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_C]... | const char * func0(const char *a1, const char *a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+20h] [rbp-10h]
int k; // [rsp+20h] [rbp-10h]
int m; // [rsp+20h] [rbp-10h]
int v9; // [rsp+24h] [rbp-Ch]
int v10; // [rsp+24h] [rbp-Ch]
int v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x... | int * func0(char *param_1,char *param_2)
{
bool bVar1;
size_t sVar2;
size_t sVar3;
int *puVar4;
int local_1c;
int local_18;
local_1c = 0;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
bVar1 = true;
for (local_18 = 0; local_18 < (int)sVar2; local_18 = local_18 + 1) {
if (param_1[local_1... |
1,133 | func0 | #include <stdio.h>
#include <string.h>
| const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2;... | #include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes"... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r8
mov $0xffffffffffffffff,%rbx
mov $0x0,%eax
mov %rbx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r10
mov %r10d,%r9d
mov %rbx,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13, rsi
call _strlen
mov rbp, rax
mov r12d, eax
mov rdi, r13; s
call _strlen
mov r8, rax
mov edi, eax
test ebp, ebp
jle loc_12D5
mov rcx, rbx
lea eax, [rbp-1]
lea r10, [rb... | const char * func0(const char *a1, const char *a2)
{
int v3; // ebp
int v4; // r8d
const char *v5; // rcx
int v6; // edx
int v7; // eax
long long v8; // rcx
char v9; // si
int v10; // eax
int v11; // edx
const char *v12; // rcx
long long v13; // rcx
char v14; // si
const char *v15; // rcx
lo... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13,RSI
CALL 0x00101070
MOV RBP,RAX
MOV R12D,EAX
MOV RDI,R13
CALL 0x00101070
MOV R8,RAX
MOV EDI,EAX
TEST EBP,EBP
JLE 0x001012d5
MOV RCX,RBX
LEA EAX,[RBP + -0x1]
LEA R10,[RBX + RAX*0x1 + 0x1]
MOV EDX,0x1
MOV EAX,0x0
MOV R9D,0x0
JMP 0x001011f7... | int * func0(char *param_1,char *param_2)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
size_t sVar5;
char *pcVar6;
long lVar7;
int *puVar8;
sVar5 = strlen(param_1);
iVar2 = (int)sVar5;
sVar5 = strlen(param_2);
iVar4 = (int)sVar5;
if (iVar2 < 1) {
bVar1 = true;
iVar3 = 0;
if (i... |
1,134 | func0 | #include <stdio.h>
#include <string.h>
| const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2;... | #include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes"... | O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %rbx,%rdi
mov %rax,%r13
mov %eax,%r12d
callq 1060 <strlen@plt>
test %r13d,%r13d
jle 16a0 <func0+0x1c0>
lea -0x1(%r13),%edx
mov %rbp,%rsi
mov $0x1,%ecx
xo... | func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
mov rdi, rbx; s
mov r13, rax
mov r12d, eax
call _strlen
mov r8d, eax
test r13d, r13d
jle loc_1680
lea edx, [r13-1]
mov rsi, rbp
mov ecx, 1
xor r9d, r9... | const char * func0(const char *a1, const char *a2)
{
int v3; // r13d
int v4; // eax
int v5; // r8d
const char *v6; // rsi
char v7; // cl
long long v8; // r10
int v9; // edx
long long v10; // rax
char v11; // si
const char *result; // rax
long long v13; // rcx
char v14; // dl
int v15; // eax
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
MOV RDI,RBX
MOV R13,RAX
MOV R12D,EAX
CALL 0x00101070
MOV R8D,EAX
TEST R13D,R13D
JLE 0x00101680
LEA EDX,[R13 + -0x1]
MOV RSI,RBP
MOV ECX,0x1
XOR R9D,R9D
LEA R10,[RBP + RDX*0x1 + 0x1]
XOR EDX,EDX
JMP 0x0010153d
LAB_0010... | int * func0(char *param_1,char *param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
long lVar4;
bool bVar5;
int iVar6;
char *pcVar7;
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
if (iVar1 < 1) {
bVar5 = true;
iVar6 = 0;
if (iVar2 < 1) goto ... |
1,135 | func0 | #include <stdio.h>
#include <string.h>
| const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2;... | #include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes"... | O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %rbx,%rdi
mov %rax,%r13
mov %eax,%r12d
callq 1060 <strlen@plt>
test %r13d,%r13d
jle 16a0 <func0+0x1c0>
lea -0x1(%r13),%edx
mov %rbp,%rsi
mov $0x1,%ecx
xo... | func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
mov rdi, rbx; s
mov r13, rax
mov r12d, eax
call _strlen
mov r8d, eax
test r13d, r13d
jle loc_1680
lea edx, [r13-1]
mov rsi, rbp
mov ecx, 1
xor r9d, r9... | const char * func0(const char *a1, const char *a2)
{
int v3; // r13d
int v4; // eax
int v5; // r8d
const char *v6; // rsi
char v7; // cl
long long v8; // r10
int v9; // edx
long long v10; // rax
char v11; // si
const char *result; // rax
long long v13; // rcx
char v14; // dl
int v15; // eax
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
MOV RDI,RBX
MOV R13,RAX
MOV R12D,EAX
CALL 0x00101070
MOV R8D,EAX
TEST R13D,R13D
JLE 0x00101680
LEA EDX,[R13 + -0x1]
MOV RSI,RBP
MOV ECX,0x1
XOR R9D,R9D
LEA R10,[RBP + RDX*0x1 + 0x1]
XOR EDX,EDX
JMP 0x0010153d
LAB_0010... | int * func0(char *param_1,char *param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
long lVar4;
bool bVar5;
int iVar6;
char *pcVar7;
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
if (iVar1 < 1) {
bVar5 = true;
iVar6 = 0;
if (iVar2 < 1) goto ... |
1,136 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
... | #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 arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 124c <func0+0xe3>
movl $0x0,-0xc(%rbp)
jmpq 1236 <func0+0xcd>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_10], 0
jmp loc_124C
loc_118B:
mov [rbp+var_C], 0
jmp loc_1236
loc_1197:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rb... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
int i; // [rsp+18h] [rbp-10h]
int j; // [rsp+1Ch] [rbp-Ch]
unsigned int k; // [rsp+20h] [rbp-8h]
int v8; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010124c
LAB_0010118b:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101236
LAB_00101197:
MOV EAX,dword ptr [RBP + -0xc]
CDQE... | void func0(long param_1,int param_2,int param_3,long param_4)
{
int4 uVar1;
int4 local_18;
int4 local_14;
int4 local_10;
for (local_18 = 0; local_18 < param_2 + -1; local_18 = local_18 + 1) {
for (local_14 = 0; local_14 < (param_2 - local_18) + -1; local_14 = local_14 + 1) {
if (*(int *)(param_1... |
1,137 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
... | #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 arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
... | O1 | c | func0:
endbr64
push %rbx
mov %edx,%ebx
lea -0x1(%rsi),%r11d
test %r11d,%r11d
jle 11b5 <func0+0x4c>
lea 0x4(%rdi),%rdx
jmp 11a3 <func0+0x3a>
add $0x4,%rax
cmp %r10,%rax
je 119d <func0+0x34>
mov (%rax),%r8d
mov 0x4(%rax),%r9d
cmp %r9d,%r8d
jle 117f <func0+0x16>
mov %r9d,(%rax)
... | func0:
endbr64
push rbx
mov r9, rdi
mov r11d, esi
mov ebx, edx
mov r10, rcx
cmp esi, 1
jle short loc_11BD
mov r8d, esi
lea rdx, [rdi+4]
jmp short loc_11AA
loc_1187:
add rax, 4
cmp rax, rdi
jz short loc_11A0
loc_1190:
mov ecx, [rax]
mov esi, [rax+4]
cmp ecx... | void func0(int *a1, int a2, int a3, long long a4)
{
int i; // r8d
int *v7; // rax
int v8; // ecx
int v9; // esi
long long v10; // r11
long long j; // rax
if ( a2 > 1 )
{
for ( i = a2; i != 1; --i )
{
while ( i <= 1 )
--i;
v7 = a1;
do
{
v8 = *v7;
... | func0:
ENDBR64
PUSH RBX
MOV R9,RDI
MOV R11D,ESI
MOV EBX,EDX
MOV R10,RCX
CMP ESI,0x1
JLE 0x001011bd
MOV R8D,ESI
LEA RDX,[RDI + 0x4]
JMP 0x001011aa
LAB_00101187:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011a0
LAB_00101190:
MOV ECX,dword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x4]
CMP ECX,ESI
JLE 0x00101187
MOV dword ptr [RAX],ESI
MOV... | void func0(int *param_1,int param_2,int param_3,long param_4)
{
int iVar1;
int *piVar2;
long lVar3;
int iVar4;
iVar4 = param_2;
if (1 < param_2) {
do {
for (; iVar4 < 2; iVar4 = iVar4 + -1) {
}
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
... |
1,138 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
... | #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 arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
... | O2 | c | func0:
endbr64
lea -0x1(%rsi),%r8d
push %rbx
mov %edx,%ebx
test %r8d,%r8d
jle 1764 <func0+0x54>
lea 0x4(%rdi),%rdx
nopl 0x0(%rax)
sub $0x1,%r8d
mov %rdi,%rax
mov %r8,%r11
lea (%rdx,%r8,4),%r10
nopw %cs:0x0(%rax,%rax,1)
mov (%rax),%r8d
mov 0x4(%rax),%r9d
cmp %r9d,%r8d
jle 1753... | func0:
endbr64
push rbx
mov r8, rdi
mov r10d, esi
mov ebx, edx
mov r9, rcx
cmp esi, 1
jle short loc_172F
mov edi, esi
lea r11, [r8+4]
nop dword ptr [rax+rax+00h]
loc_16F0:
cmp edi, 1
jle short loc_1768
lea edx, [rdi-2]
mov rax, r8
lea rsi, [r11+rdx*4]
nop
loc_1... | void func0(__m128i *a1, int a2, int a3, long long a4)
{
int i; // edi
__m128i *v6; // rax
__m128i v7; // xmm0
long long j; // rax
if ( a2 > 1 )
{
for ( i = a2; i != 1; --i )
{
while ( i <= 1 )
--i;
v6 = a1;
do
{
v7 = _mm_loadl_epi64(v6);
if ( _mm_cvt... | func0:
ENDBR64
PUSH RBX
MOV R8,RDI
MOV R10D,ESI
MOV EBX,EDX
MOV R9,RCX
CMP ESI,0x1
JLE 0x0010172f
MOV EDI,ESI
LEA R11,[R8 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001016f0:
CMP EDI,0x1
JLE 0x00101768
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R11 + RDX*0x4]
NOP
LAB_00101700:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe... | void func0(int8 *param_1,int param_2,int param_3,long param_4)
{
int8 *puVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
iVar3 = param_2;
if (1 < param_2) {
do {
for (; iVar3 < 2; iVar3 = iVar3 + -1) {
}
puVar1 = param_1;
do {
iVar4 = (int)*puVar1;
iVar5 ... |
1,139 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
... | #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 arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
... | O3 | c | func0:
endbr64
lea -0x1(%rsi),%r8d
push %rbx
mov %edx,%ebx
test %r8d,%r8d
jle 1734 <func0+0x54>
lea 0x4(%rdi),%rdx
nopl 0x0(%rax)
sub $0x1,%r8d
mov %rdi,%rax
mov %r8,%r11
lea (%rdx,%r8,4),%r10
nopw %cs:0x0(%rax,%rax,1)
mov (%rax),%r8d
mov 0x4(%rax),%r9d
cmp %r9d,%r8d
jle 1723... | func0:
endbr64
movsxd r10, esi
push rbx
mov r8, rdi
mov r11d, edx
mov r9, rcx
cmp r10d, 1
jle short loc_16F7
mov edi, r10d
lea rbx, [r8+4]
xchg ax, ax
loc_16B0:
cmp edi, 1
jle loc_1758
lea edx, [rdi-2]
mov rax, r8
lea rsi, [rbx+rdx*4]
nop dword ptr [rax+rax+00h... | void func0(__m128i *a1, int a2, int a3, long long a4)
{
long long v4; // r10
int i; // edi
__m128i *v8; // rax
__m128i v9; // xmm0
int v10; // esi
long long v11; // r10
long long v12; // rax
__int8 *v13; // rsi
long long v14; // rax
unsigned int v15; // eax
long long v16; // rdi
unsigned int v1... | func0:
ENDBR64
MOVSXD R10,ESI
PUSH RBX
MOV R8,RDI
MOV R11D,EDX
MOV R9,RCX
CMP R10D,0x1
JLE 0x001016f7
MOV EDI,R10D
LEA RBX,[R8 + 0x4]
NOP
LAB_001016b0:
CMP EDI,0x1
JLE 0x00101758
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[RBX + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001016c8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM... | void func0(int8 *param_1,int param_2,uint param_3,long param_4)
{
int8 uVar1;
uint uVar2;
int8 *puVar3;
long lVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
iVar6 = param_2;
if (1 < param_2) {
do {
for (; iVar6 < 2; iVar6 = iVar6 + -1) {
}
puVar3 = param_1;
do {
... |
1,140 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[]... | 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 11cf <func0+0x66>
mov -0x4(%rbp),%eax
add %eax,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
shr $0x1f,%edx
add ... | 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_11D5
loc_1188:
mov eax, [rbp+var_4]
add eax, eax
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; a2 > 2 * i; ++i )
{
if ( *(_DWORD *)(8LL * i + a1) % 2 == 1 )
v3 += *(_DWORD *)(8LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c * 2 < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)(local_c * 2) * 4) % 2 == 1) {
local_10 = local_10 + *(int *)(param_1 + (long)(local_c * 2) * 4);
}
}
return local... |
1,141 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[]... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11a8 <func0+0x3f>
mov %rdi,%rcx
sub $0x1,%esi
shr %esi
mov %esi,%esi
lea 0x8(%rdi,%rsi,8),%r8
mov $0x0,%esi
mov (%rcx),%eax
mov %eax,%edi
shr $0x1f,%edi
lea (%rax,%rdi,1),%edx
and $0x1,%edx
sub %edi,%edx
add %esi,%eax
cmp $0x1,%edx
cmove ... | func0:
endbr64
test esi, esi
jle short loc_11A8
mov rcx, rdi
sub esi, 1
shr esi, 1
mov esi, esi
lea r8, [rdi+rsi*8+8]
mov esi, 0
loc_1185:
mov eax, [rcx]
mov edi, eax
shr edi, 1Fh
lea edx, [rax+rdi]
and edx, 1
sub edx, edi
add eax, esi
cmp edx, 1
cmovz es... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rcx
long long v3; // r8
unsigned int v4; // esi
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2];
v4 = 0;
do
{
if ( *v2 % 2 == 1 )
v4 += *v2;
v2 += 2;... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a8
MOV RCX,RDI
SUB ESI,0x1
SHR ESI,0x1
MOV ESI,ESI
LEA R8,[RDI + RSI*0x8 + 0x8]
MOV ESI,0x0
LAB_00101185:
MOV EAX,dword ptr [RCX]
MOV EDI,EAX
SHR EDI,0x1f
LEA EDX,[RAX + RDI*0x1]
AND EDX,0x1
SUB EDX,EDI
ADD EAX,ESI
CMP EDX,0x1
CMOVZ ESI,EAX
ADD RCX,0x8
CMP RCX,R8
JNZ 0x00101185
L... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2;
iVar2 = 0;
do {
if (*param_1 % 2 == 1) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 2;
} while (par... |
1,142 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[]... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
sub $0x1,%esi
xor %r8d,%r8d
shr %esi
lea 0x8(%rdi,%rsi,8),%rsi
nopl (%rax)
mov (%rdi),%eax
mov %eax,%ecx
shr $0x1f,%ecx
lea (%rax,%rcx,1),%edx
add %r8d,%eax
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
cmove %eax,%r8d
add $0... | func0:
endbr64
test esi, esi
jle short loc_13D0
sub esi, 1
xor ecx, ecx
shr esi, 1
lea r8, [rdi+rsi*8+8]
nop dword ptr [rax+00h]
loc_13A8:
mov eax, [rdi]
mov esi, eax
shr esi, 1Fh
lea edx, [rax+rsi]
add eax, ecx
and edx, 1
sub edx, esi
cmp edx, 1
cmovz ecx, e... | long long func0(_DWORD *a1, int a2)
{
unsigned int v2; // ecx
long long v3; // r8
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2];
do
{
if ( *a1 % 2 == 1 )
v2 += *a1;
a1 += 2;
}
while ( a1 != (_DWORD *)v3 );
return v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013d0
SUB ESI,0x1
XOR ECX,ECX
SHR ESI,0x1
LEA R8,[RDI + RSI*0x8 + 0x8]
NOP dword ptr [RAX]
LAB_001013a8:
MOV EAX,dword ptr [RDI]
MOV ESI,EAX
SHR ESI,0x1f
LEA EDX,[RAX + RSI*0x1]
ADD EAX,ECX
AND EDX,0x1
SUB EDX,ESI
CMP EDX,0x1
CMOVZ ECX,EAX
ADD RDI,0x8
CMP RDI,R8
JNZ 0x001013a8
MOV E... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2;
do {
if (*param_1 % 2 == 1) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
return ... |
1,143 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[]... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1270 <func0+0x130>
lea -0x1(%rsi),%edx
cmp $0x7,%edx
jbe 1273 <func0+0x133>
shr $0x3,%edx
movdqa 0xead(%rip),%xmm4
mov %rdi,%rax
pxor %xmm2,%xmm2
mov %edx,%ecx
shl $0x5,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
movdqu 0x10(%rax),%xmm5... | func0:
endbr64
test esi, esi
jle loc_1298
lea edx, [rsi-1]
mov r9d, edx
shr r9d, 1
cmp edx, 7
jbe loc_129B
shr edx, 3
movdqa xmm4, cs:xmmword_2010
mov rax, rdi
pxor xmm2, xmm2
mov ecx, edx
shl rcx, 5
add rcx, rdi
nop dword ptr [rax+00000000h]
loc_1180:
movdqu xmm1... | long long func0(const __m128i *a1, int a2)
{
unsigned int v2; // edx
__m128i si128; // xmm4
const __m128i *v4; // rax
__m128 v5; // xmm2
__m128 v6; // xmm1
__m128 v7; // xmm5
__m128i v8; // xmm1
__m128i v9; // xmm3
long long v10; // rcx
int v11; // edx
int v12; // r8d
__m128i v13; // xmm0
__m... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101298
LEA EDX,[RSI + -0x1]
MOV R9D,EDX
SHR R9D,0x1
CMP EDX,0x7
JBE 0x0010129b
SHR EDX,0x3
MOVDQA XMM4,xmmword ptr [0x00102010]
MOV RAX,RDI
PXOR XMM2,XMM2
MOV ECX,EDX
SHL RCX,0x5
ADD RCX,RDI
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM1,xmmword ptr [RAX]
MOVDQU XMM5,xmmword ptr [RAX ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,int param_2)
{
int8 uVar1;
int8 uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint *puVar6;
ulong uVar7;
uint uVar8;
int iVar9;
uint uVar10;
uint uVar11;
int iVar12;
int auVar13 [16];
... |
1,144 | func0 | #include <stdio.h>
| int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, ... | 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 11db <func0+0x72>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0xffffff9d,%eax
jl 11d7 <func0+0... | 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_11DB
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp eax, 0FFFFFF9Dh
jl ... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) >= -99 && *(int *)(4LL * i + a1) <= 99 )
v3 += *(_DWORD *)(4LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011db
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((-100 < *(int *)(param_1 + (long)local_c * 4)) &&
(*(int *)(param_1 + (long)local_c * 4) < 100)) {
local_10 = local_10 + *(int *)(param_1 + (lon... |
1,145 | func0 | #include <stdio.h>
| int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, ... | O1 | c | func0:
endbr64
test %esi,%esi
jle 119d <func0+0x34>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%ecx
mov (%rdx),%eax
lea 0x63(%rax),%esi
add %ecx,%eax
cmp $0xc7,%esi
cmovb %eax,%ecx
add $0x4,%rdx
cmp %rdi,%rdx
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mo... | func0:
endbr64
test esi, esi
jle short loc_119C
mov rdx, rdi
movsxd rsi, esi
lea rdi, [rdi+rsi*4]
mov ecx, 0
loc_1180:
mov eax, [rdx]
lea esi, [rax+63h]
add eax, ecx
cmp esi, 0C7h
cmovb ecx, eax
add rdx, 4
cmp rdx, rdi
jnz short loc_1180
loc_1199:
mov eax, ecx
retn
... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rdx
_DWORD *v3; // rdi
unsigned int v4; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
if ( (unsigned int)(*v2 + 99) < 0xC7 )
v4 += *v2;
++v2;
}
while ( v2 != v3 );
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119c
MOV RDX,RDI
MOVSXD RSI,ESI
LEA RDI,[RDI + RSI*0x4]
MOV ECX,0x0
LAB_00101180:
MOV EAX,dword ptr [RDX]
LEA ESI,[RAX + 0x63]
ADD EAX,ECX
CMP ESI,0xc7
CMOVC ECX,EAX
ADD RDX,0x4
CMP RDX,RDI
JNZ 0x00101180
LAB_00101199:
MOV EAX,ECX
RET
LAB_0010119c:
MOV ECX,0x0
JMP 0x00101199 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar2 = 0;
do {
if (*param_1 + 99U < 199) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
r... |
1,146 | func0 | #include <stdio.h>
| int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, ... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
lea 0x63(%rax),%edx
add %r8d,%eax
cmp $0xc7,%edx
cmovb %eax,%r8d
add $0x4,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
mov %r8d,%eax
... | func0:
endbr64
test esi, esi
jle short loc_1258
movsxd rsi, esi
xor edx, edx
lea rsi, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1238:
mov eax, [rdi]
lea ecx, [rax+63h]
add eax, edx
cmp ecx, 0C7h
cmovb edx, eax
add rdi, 4
cmp rsi, rdi
jnz short loc_1238
mov eax, ... | long long func0(_DWORD *a1, int a2)
{
unsigned int v2; // edx
_DWORD *v3; // rsi
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
if ( (unsigned int)(*a1 + 99) < 0xC7 )
v2 += *a1;
++a1;
}
while ( v3 != a1 );
return v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101258
MOVSXD RSI,ESI
XOR EDX,EDX
LEA RSI,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101238:
MOV EAX,dword ptr [RDI]
LEA ECX,[RAX + 0x63]
ADD EAX,EDX
CMP ECX,0xc7
CMOVC EDX,EAX
ADD RDI,0x4
CMP RSI,RDI
JNZ 0x00101238
MOV EAX,EDX
RET
LAB_00101258:
XOR EDX,EDX
MOV EAX,EDX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
piVar1 = param_1 + param_2;
do {
if (*param_1 + 99U < 199) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
return iVar2;
}
return 0;
} |
1,147 | func0 | #include <stdio.h>
| int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
} | #include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, ... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1340 <func0+0x110>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1349 <func0+0x119>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm1,%xmm1
movdqa 0xe37(%rip),%xmm3
movdqa 0xe1f(%rip),%xmm2
shr $0x2,%edx
movdqa 0xe04(%rip),%xmm4
shl $0x4,%rdx
add %rdi,%rdx
psubd %xmm3,%xmm... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1230
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1239
mov edx, esi
mov rax, rdi
pxor xmm1, xmm1
movdqa xmm4, cs:xmmword_2010
shr edx, 2
movdqa xmm3, cs:xmmword_2020
movdqa xmm2, cs:xmmword_2030
shl rdx, 4
add rdx, rdi
nop dwo... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v3; // rax
__m128i v4; // xmm1
__m128i si128; // xmm4
__m128i v6; // xmm3
__m128i v7; // xmm2
__m128i v8; // xmm0
int v9; // edx
__m128i v10; // xmm1
long long result; // rax
long long v12; // r8
__int32 v13; // esi
unsigned int v14; /... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101230
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101239
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM1,XMM1
MOVDQA XMM4,xmmword ptr [0x00102010]
SHR EDX,0x2
MOVDQA XMM3,xmmword ptr [0x00102020]
MOVDQA XMM2,xmmword ptr [0x00102030]
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_0010118... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar1... |
1,148 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++... | #include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 1... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
movl $0xa,-0x10(%rbp)
mov -0x28(%rbp),%rax
movl $0x1,(%rax)
mov -0x20(%rbp),%rax
movl $0x1,(%rax)
jmpq 1286 <func0+0xbd>
mov -0x14(%rbp),%eax
cltd
shr $0x1f,%edx
add ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+ptr], rsi
mov [rbp+var_28], rdx
mov [rbp+var_10], 0Ah
mov rax, [rbp+var_28]
mov dword ptr [rax], 1
mov rax, [rbp+ptr]
mov dword ptr [rax], 1
jmp loc_128C
loc_1200:
mov edx, [rbp+var_14]
mo... | long long func0(int a1, _DWORD *a2, int *a3)
{
int v3; // eax
long long result; // rax
void *ptr; // [rsp+10h] [rbp-20h]
int v8; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int j; // [rsp+28h] [rbp-8h]
int v11; // [rsp+2Ch] [rbp-4h]
ptr = a2;
v8 = 10;
*a3 = 1;
*a2 = 1;
while ( a1 != 1 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x10],0xa
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x1
JMP 0x0010128c
LAB_00101200:
MO... | void func0(int param_1,int4 *param_2,int *param_3)
{
int iVar1;
int4 *local_28;
int local_1c;
int local_18;
int local_14;
int local_10;
local_18 = 10;
*param_3 = 1;
*param_2 = 1;
local_28 = param_2;
local_1c = param_1;
while (local_1c != 1) {
if (local_1c % 2 == 1) {
if (local_18 <... |
1,149 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++... | #include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 1... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rsi,%rax
mov %rdx,%rbx
movl $0x1,(%rdx)
movl $0x1,(%rsi)
cmp $0x1,%edi
je 123f <func0+0x76>
mov %edi,%ebp
mov $0xa,%r12d
jmp 1214 <func0+0x4b>
add %r12d,%r12d
movslq %r12d,%rsi
shl $0x2,%rsi
mov %rax,%rdi
callq 10d0 <realloc@plt... | func0:
endbr64
push r12
push rbp
push rbx
mov ebp, edi
mov rdi, rsi; ptr
mov rbx, rdx
mov dword ptr [rdx], 1
mov dword ptr [rsi], 1
cmp ebp, 1
jz short loc_122A
mov r12d, 0Ah
jmp short loc_1207
loc_11F2:
cmp [rbx], r12d
jge short loc_123A
loc_11F7:
mov eax, [rbx... | void func0(int a1, _DWORD *a2, int *a3)
{
void *v4; // rdi
int v6; // r12d
int v7; // eax
_DWORD *v8; // r9
int v9; // r8d
int v10; // esi
int v11; // edx
_DWORD *v12; // rax
v4 = a2;
*a3 = 1;
*a2 = 1;
if ( a1 != 1 )
{
v6 = 10;
do
{
while ( a1 % 2 == 1 )
{
if ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBP,EDI
MOV RDI,RSI
MOV RBX,RDX
MOV dword ptr [RDX],0x1
MOV dword ptr [RSI],0x1
CMP EBP,0x1
JZ 0x0010122a
MOV R12D,0xa
JMP 0x00101207
LAB_001011f2:
CMP dword ptr [RBX],R12D
JGE 0x0010123a
LAB_001011f7:
MOV EAX,dword ptr [RBX]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBX],EDX
CDQE... | void func0(int param_1,int *param_2,int *param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
*param_3 = 1;
*param_2 = 1;
if (param_1 != 1) {
iVar5 = 10;
do {
for (; param_1 % 2 == 1; param_1 = param_1 * 3 + 1) {
if (iVar5 <= *param_3) {
iVar5 = iVar5... |
1,150 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++... | #include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 1... | O2 | c | func0:
endbr64
push %r12
mov %rsi,%r11
push %rbp
mov %rdx,%rbp
push %rbx
movl $0x1,(%rdx)
movl $0x1,(%rsi)
cmp $0x1,%edi
je 152e <func0+0xee>
movslq (%rdx),%rdx
mov %edi,%ebx
mov $0xa,%r12d
jmp 147e <func0+0x3e>
mov %ebx,%edi
shr $0x1f,%edi
add %edi,%ebx
sar %ebx
cmp $0x1,... | func0:
endbr64
push r12
push rbp
mov rbp, rdx
push rbx
mov ebx, edi
mov rdi, rsi; ptr
mov dword ptr [rdx], 1
mov dword ptr [rsi], 1
cmp ebx, 1
jz short loc_1472
mov r12d, 0Ah
nop word ptr [rax+rax+00000000h]
loc_1450:
mov edx, ebx
shr edx, 1Fh
lea eax, [rbx+rdx]... | void func0(int a1, char *a2, int *a3)
{
char *v5; // rdi
int v6; // r12d
long long v7; // rsi
int v8; // ecx
long long v9; // rax
int v10; // edx
char *v11; // rax
long long v12; // rax
v5 = a2;
*a3 = 1;
*(_DWORD *)a2 = 1;
if ( a1 != 1 )
{
v6 = 10;
do
{
while ( a1 % 2 == 1 ... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV EBX,EDI
MOV RDI,RSI
MOV dword ptr [RDX],0x1
MOV dword ptr [RSI],0x1
CMP EBX,0x1
JZ 0x00101472
MOV R12D,0xa
NOP word ptr [RAX + RAX*0x1]
LAB_00101450:
MOV EDX,EBX
SHR EDX,0x1f
LEA EAX,[RBX + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
JZ 0x001014c0
MOV EAX,EBX
S... | void func0(uint param_1,int *param_2,int *param_3)
{
int iVar1;
long lVar2;
int *piVar3;
long lVar4;
int iVar5;
*param_3 = 1;
*param_2 = 1;
if (param_1 != 1) {
iVar5 = 10;
do {
for (; (int)param_1 % 2 == 1; param_1 = (int)param_1 >> 1) {
do {
iVar1 = *param_3;
... |
1,151 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++... | #include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 1... | O3 | c | func0:
endbr64
push %r12
mov %rsi,%r11
push %rbp
mov %rdx,%rbp
push %rbx
movl $0x1,(%rdx)
movl $0x1,(%rsi)
cmp $0x1,%edi
je 152e <func0+0xee>
movslq (%rdx),%rdx
mov %edi,%ebx
mov $0xa,%r12d
jmp 147e <func0+0x3e>
mov %ebx,%edi
shr $0x1f,%edi
add %edi,%ebx
sar %ebx
cmp $0x1,... | func0:
endbr64
push r12
push rbp
mov rbp, rdx
push rbx
mov ebx, edi
mov rdi, rsi; ptr
mov dword ptr [rdx], 1
mov dword ptr [rsi], 1
cmp ebx, 1
jz short loc_1472
mov r12d, 0Ah
nop word ptr [rax+rax+00000000h]
loc_1450:
mov edx, ebx
shr edx, 1Fh
lea eax, [rbx+rdx]... | void func0(int a1, char *a2, int *a3)
{
char *v5; // rdi
int v6; // r12d
long long v7; // rsi
int v8; // ecx
long long v9; // rax
int v10; // edx
char *v11; // rax
long long v12; // rax
v5 = a2;
*a3 = 1;
*(_DWORD *)a2 = 1;
if ( a1 != 1 )
{
v6 = 10;
do
{
while ( a1 % 2 == 1 ... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV EBX,EDI
MOV RDI,RSI
MOV dword ptr [RDX],0x1
MOV dword ptr [RSI],0x1
CMP EBX,0x1
JZ 0x00101472
MOV R12D,0xa
NOP word ptr [RAX + RAX*0x1]
LAB_00101450:
MOV EDX,EBX
SHR EDX,0x1f
LEA EAX,[RBX + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
JZ 0x001014c0
MOV EAX,EBX
S... | void func0(uint param_1,int *param_2,int *param_3)
{
int iVar1;
long lVar2;
int *piVar3;
long lVar4;
int iVar5;
*param_3 = 1;
*param_2 = 1;
if (param_1 != 1) {
iVar5 = 10;
do {
for (; (int)param_1 % 2 == 1; param_1 = (int)param_1 >> 1) {
do {
iVar1 = *param_3;
... |
1,152 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[... | #include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000")... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
cmp $0xa,%rax
je 11e4 <func0+0x3b>
mov $0x0,%eax
jmpq 1346 <func0+0x19d>
movl $0x0,-0x24(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
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
cmp rax, 0Ah
jz short loc_11E4
mov eax, 0
jmp loc_135B
loc_11E4:
mov [rbp+var_24], 0
jmp short... | _BOOL8 func0(long long a1)
{
int i; // [rsp+1Ch] [rbp-24h]
int v3; // [rsp+20h] [rbp-20h]
int v4; // [rsp+24h] [rbp-1Ch]
char nptr[3]; // [rsp+2Dh] [rbp-13h] BYREF
char v6[3]; // [rsp+30h] [rbp-10h] BYREF
char v7[5]; // [rsp+33h] [rbp-Dh] BYREF
unsigned long long v8; // [rsp+38h] [rbp-8h]
v8 = __readf... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101080
CMP RAX,0xa
JZ 0x001011e4
MOV EAX,0x0
JMP 0x0010135b
LAB_001011e4:
MOV dword ptr [RBP + -0x24],0x0
JMP 0x001... | int8 func0(char *param_1)
{
int iVar1;
int iVar2;
size_t sVar3;
int8 uVar4;
long in_FS_OFFSET;
int local_2c;
char local_1b;
char local_1a;
int local_19;
char local_18;
char local_17;
int local_16;
char local_15;
char local_14;
char local_13;
char local_12;
int local_11;
long local_1... |
1,153 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[... | #include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000")... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov $0x0,%eax
cmp $0xfffffffffffffff4,%rcx
jne 12cb <func0+0x142>
mov $0x0,%eax
jmp 11d9 <func0+0x50>
cmpb $0x... | func0:
endbr64
push rbp
push rbx
sub rsp, 28h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
call _strlen
mov rdx, rax
mov eax, 0
cmp rdx, 0Ah
jnz loc_12E9
mov eax, 0
jmp short loc_11F2
loc_11E4:
cmp byte ptr [rbx+rax], 2Dh ; '-'
jnz loc_... | _BOOL8 func0(long long a1)
{
size_t v1; // rdx
_BOOL8 result; // rax
long long i; // rax
unsigned long long v4; // rbx
int v5; // ebp
long long v6; // rax
char nptr[3]; // [rsp+Dh] [rbp-2Bh] BYREF
char v8[3]; // [rsp+10h] [rbp-28h] BYREF
char v9[5]; // [rsp+13h] [rbp-25h] BYREF
unsigned long long v... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x00101080
MOV RDX,RAX
MOV EAX,0x0
CMP RDX,0xa
JNZ 0x001012e9
MOV EAX,0x0
JMP 0x001011f2
LAB_001011e4:
CMP byte ptr [RBX + RAX*0x1],0x2d
JNZ 0x00101300
ADD RAX,0x1
LAB_001011f2:
CMP EAX,... | bool func0(char *param_1)
{
uint uVar1;
int iVar2;
bool bVar3;
size_t sVar4;
long lVar5;
ulong uVar6;
long in_FS_OFFSET;
char local_2b;
char local_2a;
int local_29;
char local_28;
char local_27;
int local_26;
char local_25;
char local_24;
char local_23;
char local_22;
int local_21;
... |
1,154 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[... | #include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000")... | O2 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 1080 <strlen@plt>
mov %rax,%r8
xor %eax,%eax
cmp $0xa,%r8
jne 1550 <func0+0x60>
xor %eax,%eax
jmp 153a <func0+0x4a>
nopl 0x0(%rax)
sub $0x30,%edx
cmp $0... | func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
call _strlen
cmp rax, 0Ah
jnz short loc_1550
xor eax, eax
mov ecx, 24h ; '$'
jmp short loc_1537
loc_1528:
cmp dl, 2Dh ; '-'
jnz short loc_1550
loc_15... | _BOOL8 func0(__int16 *a1)
{
unsigned long long v1; // rax
long long v2; // rcx
char v3; // dl
__int16 v5; // ax
__int16 v6; // ax
int v7; // eax
unsigned long long v8; // rbx
int v9; // ebp
long long v10; // rax
char nptr[2]; // [rsp+8h] [rbp-30h] BYREF
char v12; // [rsp+Ah] [rbp-2Eh]
char v13[... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x00101080
CMP RAX,0xa
JNZ 0x00101550
XOR EAX,EAX
MOV ECX,0x24
JMP 0x00101537
LAB_00101528:
CMP DL,0x2d
JNZ 0x00101550
LAB_0010152d:
ADD RAX,0x1
CMP RAX,0xa
JZ 0x00101570
LAB_00101537:
B... | bool func0(char *param_1)
{
uint uVar1;
int iVar2;
size_t sVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
bool bVar6;
int2 local_30;
int local_2e;
int2 local_2c;
int local_2a;
int4 local_28;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(par... |
1,155 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[... | #include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000")... | O3 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 1080 <strlen@plt>
mov %rax,%r8
xor %eax,%eax
cmp $0xa,%r8
jne 1650 <func0+0x160>
movzbl (%rbx),%ecx
lea -0x30(%rcx),%edx
cmp $0x9,%dl
ja 1650 <func0+0x160>
... | func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
call _strlen
cmp rax, 0Ah
jnz loc_1638
movzx eax, byte ptr [rbx]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
movzx eax, byte ptr [rbx+1]
movzx edx, word ... | _BOOL8 func0(long long a1)
{
__int16 v1; // cx
int v2; // esi
unsigned long long v3; // rbx
int v4; // ebp
long long v5; // rax
char nptr[2]; // [rsp+8h] [rbp-30h] BYREF
char v8; // [rsp+Ah] [rbp-2Eh]
char v9[2]; // [rsp+Ch] [rbp-2Ch] BYREF
char v10; // [rsp+Eh] [rbp-2Ah]
char v11[4]; // [rsp+10h] ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x00101080
CMP RAX,0xa
JNZ 0x00101638
MOVZX EAX,byte ptr [RBX]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
MOVZX EAX,byte ptr [RBX + 0x1]
MOVZX EDX,word ptr [RBX]
SUB EAX,0x30
CMP AL,0x9
JA 0x... | bool func0(char *param_1)
{
uint uVar1;
int iVar2;
size_t sVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
bool bVar6;
int2 local_30;
int local_2e;
int2 local_2c;
int local_2a;
int4 local_28;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(par... |
1,156 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
| char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (tx... | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,-0xa8(%rbp)
mov %rsi,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x98(%rbp)
movl $0x0,-0x94(%rbp)
movl $0x0,-0x90(%rbp)
mov -0xa8(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+s], rdi
mov [rbp+var_B0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_98], 0
mov [rbp+var_94], 0
mov [rbp+var_90], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov ... | char ** func0(const char *a1, int *a2)
{
int v2; // eax
int i; // [rsp+14h] [rbp-9Ch]
int j; // [rsp+14h] [rbp-9Ch]
int v6; // [rsp+18h] [rbp-98h]
int v7; // [rsp+1Ch] [rbp-94h]
int v8; // [rsp+20h] [rbp-90h]
int v9; // [rsp+24h] [rbp-8Ch]
char **v10; // [rsp+28h] [rbp-88h]
char v11[8]; // [rsp+30h] [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x98],0x0
MOV dword ptr [RBP + -0x94],0x0
MOV dword ptr [RBP + -0x90],0x0
MOV RAX,qword ptr [RBP + -0xa8... | int8 * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
ushort **ppuVar4;
void *pvVar5;
long in_FS_OFFSET;
int local_a4;
int local_a0;
uint local_9c;
int local_98;
int8 *local_90;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
l... |
1,157 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
| char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (tx... | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,%r12
mov %rsi,%r14
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
movq $0x0,(%rsp)
movq $... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, rdi
mov r15, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
call _strlen
mov rbp, rax
mov [rsp+0A8h+var_A8], 0
mov [rsp+0A8h+var_A0], 0
mov [rsp+0A8h+var_9... | _QWORD * func0(char *s, int *a2)
{
int v3; // ebp
_QWORD *v4; // r14
char *v5; // rbx
char *v6; // rbp
int v7; // r12d
int v8; // edx
long long v9; // r13
unsigned int v10; // ebx
const unsigned __int16 *v11; // rdi
char *v12; // rdx
unsigned long long v13; // rax
void *v14; // rax
long long v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,RDI
MOV R15,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBP,RAX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0... | int8 * func0(byte *param_1,int *param_2)
{
byte *pbVar1;
byte bVar2;
size_t sVar3;
char *pcVar4;
int8 *puVar5;
ushort **ppuVar6;
void *pvVar7;
int iVar8;
int iVar9;
long in_FS_OFFSET;
byte local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen((char *)pa... |
1,158 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
| char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (tx... | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
pxor %xmm0,%xmm0
mov %rbx,%rdi
mov $0x20,%esi
movl $0x0,0x60(%rsp)
mov %rax,%r12
m... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
call _strlen
pxor xmm0, xmm0
mov esi, 20h ; ' '; c
mov rdi, rbx; s
movaps [rsp+0A8h+var_58], xmm0
m... | _QWORD * func0(char *s, int *a2)
{
char *v3; // rbx
int v4; // r13d
_QWORD *v5; // rbp
int v6; // r14d
int v7; // edx
long long v8; // r15
char *v9; // r13
char *v10; // rdx
long long v11; // rax
unsigned long long v12; // rax
long long v13; // rcx
const unsigned __int16 *v15; // rsi
long long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CALL 0x001010f0
PXOR XMM0,XMM0
MOV ESI,0x20
MOV RDI,RBX
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV R13,RAX
MOV qword ptr [RSP + 0x5d],0x0
MOVAPS ... | int8 * func0(byte *param_1,int *param_2)
{
byte *pbVar1;
byte bVar2;
size_t sVar3;
char *pcVar4;
int8 *puVar5;
ushort **ppuVar6;
void *pvVar7;
long lVar8;
int iVar9;
int iVar10;
long in_FS_OFFSET;
int local_a8 [16];
int local_98 [16];
int local_88 [16];
int local_78 [16];
int local_68 [... |
1,159 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
| char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (tx... | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
pxor %xmm0,%xmm0
mov %rbx,%rdi
mov $0x20,%esi
movl $0x0,0x60(%rsp)
mov %rax,%r12
m... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
mov rbx, rdi
sub rsp, 168h
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
call _strlen
pxor xmm0, xmm0
mov esi, 20h ; ' '; c
mov rdi, rbx; s
movaps [rsp+198h+var_58], xmm0
... | _QWORD * func0(__m128i *s, int *a2)
{
char *v3; // rbx
int v4; // r13d
_QWORD *v5; // rbp
int v6; // r14d
int v7; // edx
long long v8; // r15
char *v9; // r13
char *v10; // rdx
long long v11; // rax
unsigned long long v12; // rax
long long v13; // rcx
unsigned int v15; // r14d
const unsigned _... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x168
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
CALL 0x001010f0
PXOR XMM0,XMM0
MOV ESI,0x20
MOV RDI,RBX
MOVAPS xmmword ptr [RSP + 0x140],XMM0
MOV R13,RAX
MOV qword ptr [RSP + 0x14d],0x0
MOV... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * func0(int (*param_1) [16],int *param_2)
{
byte bVar1;
ushort *puVar2;
int iVar3;
int iVar4;
int iVar5;
int auVar6 [14];
int auVar7 [12];
unkbyte10 Var8;
int auVar9 [12];
int auVar10 [16];
int auVar11 [16]... |
1,160 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
} | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 1188 <func0+0x1f>
mov $0x1,%eax
jmpq 1250 <func0+0xe7>
movl $0x1,-0x4(%rbp)
jmpq 123f <func0+0xd6>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 0
jnz short loc_1188
mov eax, 1
jmp loc_1250
loc_1188:
mov [rbp+var_4], 1
jmp loc_123F
loc_1194:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add ... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
if ( !a2 )
return 1LL;
for ( i = 1; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) < *(_DWORD *)(4LL * i - 4 + a1) )
return 0LL;
if ( i > 1
&& *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * i - 4 + a1)
&& *(_DWO... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00101188
MOV EAX,0x1
JMP 0x00101250
LAB_00101188:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010123f
LAB_00101194:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr ... | int8 func0(long param_1,int param_2)
{
int local_c;
if (param_2 != 0) {
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < *(int *)(param_1 + (long)local_c * 4 + -4)) {
return 0;
}
if (((1 < local_c) &&
(*(int *)(para... |
1,161 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
} | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11ad <func0+0x44>
lea -0x2(%rsi),%esi
add $0x2,%rsi
mov $0x1,%eax
jmp 1189 <func0+0x20>
add $0x1,%rax
cmp %rsi,%rax
je 11a7 <func0+0x3e>
mov (%rdi,%rax,4),%edx
mov -0x4(%rdi,%rax,4),%ecx
cmp %ecx,%edx
jl 11b3 <func0+0x4a>
jne 1180 <func0+0x17>... | func0:
endbr64
mov eax, 1
cmp esi, 1
jle short locret_11A6
mov esi, esi
mov eax, 1
jmp short loc_1189
loc_1180:
add rax, 1
cmp rax, rsi
jz short loc_11A7
loc_1189:
mov edx, [rdi+rax*4]
mov ecx, [rdi+rax*4-4]
cmp edx, ecx
jl short loc_11AD
jnz short loc_1180
cmp ... | long long func0(long long a1, int a2)
{
long long result; // rax
long long v3; // rax
int v4; // edx
int v5; // ecx
result = 1LL;
if ( a2 > 1 )
{
v3 = 1LL;
while ( 1 )
{
v4 = *(_DWORD *)(a1 + 4 * v3);
v5 = *(_DWORD *)(a1 + 4 * v3 - 4);
if ( v4 < v5 )
break;
if... | func0:
ENDBR64
MOV EAX,0x1
CMP ESI,0x1
JLE 0x001011a6
MOV ESI,ESI
MOV EAX,0x1
JMP 0x00101189
LAB_00101180:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x001011a7
LAB_00101189:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV ECX,dword ptr [RDI + RAX*0x4 + -0x4]
CMP EDX,ECX
JL 0x001011ad
JNZ 0x00101180
CMP EAX,0x1
JLE 0x00101180
CMP EDX,dword ptr ... | int8 func0(long param_1,uint param_2)
{
int iVar1;
int iVar2;
int8 uVar3;
ulong uVar4;
uVar3 = 1;
if (1 < (int)param_2) {
uVar4 = 1;
while( true ) {
iVar1 = *(int *)(param_1 + uVar4 * 4);
iVar2 = *(int *)(param_1 + -4 + uVar4 * 4);
if (iVar1 < iVar2) {
return 0;
}... |
1,162 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
} | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
... | O2 | c | func0:
endbr64
test %esi,%esi
je 1600 <func0+0x10>
jmp 15a0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
cmp esi, 1
jle short loc_1568
mov esi, esi
mov eax, 1
jmp short loc_1549
loc_1540:
add rax, 1
cmp rsi, rax
jz short loc_1568
loc_1549:
mov edx, [rdi+rax*4]
cmp edx, [rdi+rax*4-4]
jl short loc_155F
jnz short loc_1540
cmp eax, 1
jz short loc_1540
cm... | long long func0_part_0(long long a1, int a2)
{
long long v2; // rax
int v3; // edx
if ( a2 <= 1 )
return 1LL;
v2 = 1LL;
while ( 1 )
{
v3 = *(_DWORD *)(a1 + 4 * v2);
if ( v3 < *(_DWORD *)(a1 + 4 * v2 - 4)
|| v3 == *(_DWORD *)(a1 + 4 * v2 - 4) && (_DWORD)v2 != 1 && v3 == *(_DWORD *)(a1 + 4... | func0.part.0:
CMP ESI,0x1
JLE 0x00101568
MOV ESI,ESI
MOV EAX,0x1
JMP 0x00101549
LAB_00101540:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101568
LAB_00101549:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x4]
JL 0x0010155f
JNZ 0x00101540
CMP EAX,0x1
JZ 0x00101540
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x8]
JNZ... | int8 func0_part_0(long param_1,uint param_2)
{
int iVar1;
int iVar2;
ulong uVar3;
if (1 < (int)param_2) {
uVar3 = 1;
do {
iVar2 = *(int *)(param_1 + uVar3 * 4);
iVar1 = *(int *)(param_1 + -4 + uVar3 * 4);
if ((iVar2 < iVar1) ||
(((iVar2 == iVar1 && ((int)uVar3 != 1)) && (i... |
1,163 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
} | #include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 15e0 <func0+0x50>
sub $0x2,%esi
mov $0x1,%eax
add $0x2,%rsi
jmp 15b9 <func0+0x29>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rax,%rsi
je 15e0 <func0+0x50>
mov (%rdi,%rax,4),%edx
mov -0x4(%rdi,%rax,4),%ecx
cmp %ecx,%edx
jl 15d3 <func0+0x43>
cmp ... | func0_part_0:
cmp esi, 1
jle short loc_1568
mov esi, esi
mov eax, 1
jmp short loc_1549
loc_1540:
add rax, 1
cmp rsi, rax
jz short loc_1568
loc_1549:
mov edx, [rdi+rax*4]
cmp edx, [rdi+rax*4-4]
jl short loc_155F
jnz short loc_1540
cmp eax, 1
jz short loc_1540
cm... | long long func0_part_0(long long a1, int a2)
{
long long v2; // rax
int v3; // edx
if ( a2 <= 1 )
return 1LL;
v2 = 1LL;
while ( 1 )
{
v3 = *(_DWORD *)(a1 + 4 * v2);
if ( v3 < *(_DWORD *)(a1 + 4 * v2 - 4)
|| v3 == *(_DWORD *)(a1 + 4 * v2 - 4) && (_DWORD)v2 != 1 && v3 == *(_DWORD *)(a1 + 4... | func0.part.0:
CMP ESI,0x1
JLE 0x00101568
MOV ESI,ESI
MOV EAX,0x1
JMP 0x00101549
LAB_00101540:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101568
LAB_00101549:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x4]
JL 0x0010155f
JNZ 0x00101540
CMP EAX,0x1
JZ 0x00101540
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x8]
JNZ... | int8 func0_part_0(long param_1,uint param_2)
{
int iVar1;
int iVar2;
ulong uVar3;
if (1 < (int)param_2) {
uVar3 = 1;
do {
iVar2 = *(int *)(param_1 + uVar3 * 4);
iVar1 = *(int *)(param_1 + -4 + uVar3 * 4);
if ((iVar2 < iVar1) ||
(((iVar2 == iVar1 && ((int)uVar3 != 1)) && (i... |
1,164 | func0 | #include <stdio.h>
| const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1)... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x1c(%rbp)
cmovge -0x1c(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x18(%rbp),%eax
cmp %eax,-0x20(%rbp)
cmovle -0x20(%rbp),%eax
mov %eax,-... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov edx, [rbp+var_1C]
mov eax, [rbp+var_14]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_C], eax
mov edx, [rbp+var_20]
mov eax, [rbp+var_18]
cmp e... | const char * func0(int a1, int a2, int a3, int a4)
{
int v4; // eax
int v5; // eax
int i; // [rsp+10h] [rbp-10h]
int v8; // [rsp+14h] [rbp-Ch]
int v9; // [rsp+1Ch] [rbp-4h]
v4 = a1;
if ( a3 >= a1 )
v4 = a3;
v8 = v4;
v5 = a2;
if ( a4 <= a2 )
v5 = a4;
v9 = v5 - v8;
if ( v5 - v8 <= 1 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EDX,dword ptr [RBP + -0x20]
MO... | int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
int local_18;
if (param_1 <= param_3) {
param_1 = param_3;
}
if (param_4 <= param_2) {
param_2 = param_4;
}
param_2 = param_2 - param_1;
if (param_2 < 2) {
puVar1 = &DAT_00102008;
}
else {
for (local_18 =... |
1,165 | func0 | #include <stdio.h>
| const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1)... | O1 | c | func0:
endbr64
cmp %esi,%ecx
cmovg %esi,%ecx
cmp %edi,%edx
cmovl %edi,%edx
sub %edx,%ecx
lea 0xea4(%rip),%rax
cmp $0x1,%ecx
jle 119e <func0+0x55>
lea 0xe9b(%rip),%rax
cmp $0x3,%ecx
jle 119e <func0+0x55>
lea 0xe8c(%rip),%rax
test $0x1,%cl
je 119e <func0+0x55>
mov $0x2,%edi
add ... | func0:
endbr64
cmp ecx, esi
cmovg ecx, esi
cmp edx, edi
cmovl edx, edi
sub ecx, edx
lea rax, s2; "NO"
cmp ecx, 1
jle short locret_11BE
lea rax, aYes; "YES"
cmp ecx, 3
jle short locret_11BE
lea rax, s2; "NO"
test cl, 1
jz short locret_11BE
mov esi, 2
loc_11A2:
add ... | const char * func0(int a1, int a2, int a3, int a4)
{
int v4; // ecx
const char *result; // rax
int v6; // esi
if ( a4 > a2 )
a4 = a2;
if ( a3 < a1 )
a3 = a1;
v4 = a4 - a3;
result = "NO";
if ( v4 > 1 )
{
result = "YES";
if ( v4 > 3 )
{
result = "NO";
if ( (v4 & 1) != 0 ... | func0:
ENDBR64
CMP ECX,ESI
CMOVG ECX,ESI
CMP EDX,EDI
CMOVL EDX,EDI
SUB ECX,EDX
LEA RAX,[0x102004]
CMP ECX,0x1
JLE 0x001011be
LEA RAX,[0x102007]
CMP ECX,0x3
JLE 0x001011be
LEA RAX,[0x102004]
TEST CL,0x1
JZ 0x001011be
MOV ESI,0x2
LAB_001011a2:
ADD ESI,0x1
MOV EAX,ESI
IMUL EAX,ESI
CMP EAX,ECX
JG 0x001011bf
MOV EAX,ECX
CDQ... | int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
uint uVar2;
int iVar3;
if (param_2 < param_4) {
param_4 = param_2;
}
if (param_3 < param_1) {
param_3 = param_1;
}
uVar2 = param_4 - param_3;
puVar1 = &DAT_00102004;
if (((1 < (int)uVar2) && (puVar1 = &DAT_001020... |
1,166 | func0 | #include <stdio.h>
| const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1)... | O2 | c | func0:
endbr64
cmp %esi,%ecx
lea 0xeb7(%rip),%rax
cmovg %esi,%ecx
cmp %edi,%edx
cmovl %edi,%edx
sub %edx,%ecx
cmp $0x1,%ecx
jle 11a7 <func0+0x67>
lea 0xea4(%rip),%rax
cmp $0x3,%ecx
jle 11a7 <func0+0x67>
lea 0xe95(%rip),%rax
test $0x1,%cl
je 11a7 <func0+0x67>
mov $0x2,%edi
jmp ... | func0:
endbr64
cmp ecx, esi
lea rax, unk_2008
cmovg ecx, esi
cmp edx, edi
cmovl edx, edi
sub ecx, edx
cmp ecx, 1
jle short locret_11A7
lea rax, unk_2004
cmp ecx, 3
jle short locret_11A7
lea rax, unk_2008
test cl, 1
jz short locret_11A7
mov esi, 2
jmp short loc... | void * func0(int a1, int a2, int a3, int a4)
{
void *result; // rax
int v5; // ecx
int v6; // esi
result = &unk_2008;
if ( a4 > a2 )
a4 = a2;
if ( a3 < a1 )
a3 = a1;
v5 = a4 - a3;
if ( v5 > 1 )
{
result = &unk_2004;
if ( v5 > 3 )
{
result = &unk_2008;
if ( (v5 & 1) != ... | func0:
ENDBR64
CMP ECX,ESI
LEA RAX,[0x102008]
CMOVG ECX,ESI
CMP EDX,EDI
CMOVL EDX,EDI
SUB ECX,EDX
CMP ECX,0x1
JLE 0x001011a7
LEA RAX,[0x102004]
CMP ECX,0x3
JLE 0x001011a7
LEA RAX,[0x102008]
TEST CL,0x1
JZ 0x001011a7
MOV ESI,0x2
JMP 0x00101189
LAB_00101180:
MOV EAX,ECX
CDQ
IDIV ESI
TEST EDX,EDX
JZ 0x001011a0
LAB_0010118... | int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
uint uVar2;
int iVar3;
puVar1 = &DAT_00102008;
if (param_2 < param_4) {
param_4 = param_2;
}
if (param_3 < param_1) {
param_3 = param_1;
}
uVar2 = param_4 - param_3;
if (((1 < (int)uVar2) && (puVar1 = &DAT_001020... |
1,167 | func0 | #include <stdio.h>
| const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
... | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1)... | O3 | c | func0:
endbr64
cmp %esi,%ecx
lea 0xeb7(%rip),%rax
cmovg %esi,%ecx
cmp %edi,%edx
cmovl %edi,%edx
sub %edx,%ecx
cmp $0x1,%ecx
jle 11a7 <func0+0x67>
lea 0xea4(%rip),%rax
cmp $0x3,%ecx
jle 11a7 <func0+0x67>
lea 0xe95(%rip),%rax
test $0x1,%cl
je 11a7 <func0+0x67>
mov $0x2,%edi
jmp ... | func0:
endbr64
cmp ecx, esi
lea rax, unk_2008
cmovg ecx, esi
cmp edx, edi
cmovl edx, edi
sub ecx, edx
cmp ecx, 1
jle short locret_11A7
lea rax, unk_2004
cmp ecx, 3
jle short locret_11A7
lea rax, unk_2008
test cl, 1
jz short locret_11A7
mov esi, 2
jmp short loc... | void * func0(int a1, int a2, int a3, int a4)
{
void *result; // rax
int v5; // ecx
int v6; // esi
result = &unk_2008;
if ( a4 > a2 )
a4 = a2;
if ( a3 < a1 )
a3 = a1;
v5 = a4 - a3;
if ( v5 > 1 )
{
result = &unk_2004;
if ( v5 > 3 )
{
result = &unk_2008;
if ( (v5 & 1) != ... | func0:
ENDBR64
CMP ECX,ESI
LEA RAX,[0x102008]
CMOVG ECX,ESI
CMP EDX,EDI
CMOVL EDX,EDI
SUB ECX,EDX
CMP ECX,0x1
JLE 0x001011a7
LEA RAX,[0x102004]
CMP ECX,0x3
JLE 0x001011a7
LEA RAX,[0x102008]
TEST CL,0x1
JZ 0x001011a7
MOV ESI,0x2
JMP 0x00101189
LAB_00101180:
MOV EAX,ECX
CDQ
IDIV ESI
TEST EDX,EDX
JZ 0x001011a0
LAB_0010118... | int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
uint uVar2;
int iVar3;
puVar1 = &DAT_00102008;
if (param_2 < param_4) {
param_4 = param_2;
}
if (param_3 < param_1) {
param_3 = param_1;
}
uVar2 = param_4 - param_3;
if (((1 < (int)uVar2) && (puVar1 = &DAT_001020... |
1,168 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
} | #include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 1188 <func0+0x1f>
mov $0xffff8000,%eax
jmpq 120e <func0+0xa5>
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ff <func0+0x96>
mov -0x4(%rbp),%eax
cltq
lea 0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 0
jnz short loc_1188
mov eax, 0FFFF8000h
jmp loc_1210
loc_1188:
mov [rbp+var_C], 0
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1201
loc_119F:
mov eax, [rbp+var_4]... | long long func0(long long a1, int a2)
{
int v3; // eax
int v4; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
if ( !a2 )
return 4294934528LL;
v4 = 0;
v5 = 1;
for ( i = 0; i < a2; ++i )
{
v3 = *(_DWORD *)(4LL * i + a1);
if ( v3 <= 0 )
v3 = -*(_DWORD... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00101188
MOV EAX,0xffff8000
JMP 0x00101210
LAB_00101188:
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101201
LAB_0010119f:
MOV... | int func0(long param_1,int param_2)
{
int iVar1;
int4 local_14;
int4 local_10;
int4 local_c;
if (param_2 == 0) {
local_14 = -0x8000;
}
else {
local_14 = 0;
local_10 = 1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
iVar1 = *(int *)(param_1 + (long)local_c * 4);
... |
1,169 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
} | #include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1... | O1 | c | func0:
endbr64
test %esi,%esi
je 11c7 <func0+0x5e>
jle 11b7 <func0+0x4e>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x1,%r8d
mov $0x0,%eax
jmp 1197 <func0+0x2e>
mov %edx,%r8d
add $0x4,%rcx
cmp %r9,%rcx
je 11c2 <func0+0x59>
mov (%rcx),%edx
mov %edx,%edi
... | func0:
endbr64
test esi, esi
jz short loc_11BC
jle short loc_11AE
mov rcx, rdi
movsxd rsi, esi
lea r8, [rdi+rsi*4]
mov edi, 1
mov eax, 0
jmp short loc_1194
loc_1189:
mov edi, edx
loc_118B:
add rcx, 4
cmp rcx, r8
jz short loc_11B8
loc_1194:
mov edx, [rcx]
mov esi... | long long func0(int *a1, int a2)
{
int *v2; // rcx
int *v3; // r8
int v4; // edi
int v5; // eax
int v6; // edx
int v7; // esi
if ( !a2 )
return 4294934528LL;
if ( a2 <= 0 )
{
v4 = 1;
v5 = 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 1;
v5 = 0;
do
{
v6 = *v2... | func0:
ENDBR64
TEST ESI,ESI
JZ 0x001011bc
JLE 0x001011ae
MOV RCX,RDI
MOVSXD RSI,ESI
LEA R8,[RDI + RSI*0x4]
MOV EDI,0x1
MOV EAX,0x0
JMP 0x00101194
LAB_00101189:
MOV EDI,EDX
LAB_0010118b:
ADD RCX,0x4
CMP RCX,R8
JZ 0x001011b8
LAB_00101194:
MOV EDX,dword ptr [RCX]
MOV ESI,EDX
NEG ESI
CMOVS ESI,EDX
ADD EAX,ESI
TEST EDX,EDX
... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 == 0) {
return -0x8000;
}
if (param_2 < 1) {
iVar5 = 1;
iVar3 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar5 = 1;
iVar3 = 0;
do {
iVar2 = *param_1;
... |
1,170 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
} | #include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1... | O2 | c | func0:
endbr64
test %esi,%esi
je 1460 <func0+0x10>
jmp 13e0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0xffff8000,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
test esi, esi
jle short loc_1400
movsxd rsi, esi
xor eax, eax
lea r8, [rdi+rsi*4]
mov esi, 1
jmp short loc_13DA
loc_13C8:
mov ecx, esi
neg ecx
test edx, edx
cmovs esi, ecx
add rdi, 4
cmp r8, rdi
jz short loc_13F4
loc_13DA:
mov edx, [rdi]
mov ecx, e... | long long func0_part_0(int *a1, int a2)
{
int v2; // eax
int *v3; // r8
int v4; // esi
int v5; // edx
int v6; // ecx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
v4 = 1;
do
{
while ( 1 )
{
v5 = *a1;
v6 = -*a1;
if ( *a1 > 0 )
v6 = *a1;
v2 += v6;
... | func0.part.0:
TEST ESI,ESI
JLE 0x00101400
MOVSXD RSI,ESI
XOR EAX,EAX
LEA R8,[RDI + RSI*0x4]
MOV ESI,0x1
JMP 0x001013da
LAB_001013c8:
MOV ECX,ESI
NEG ECX
TEST EDX,EDX
CMOVS ESI,ECX
ADD RDI,0x4
CMP R8,RDI
JZ 0x001013f4
LAB_001013da:
MOV EDX,dword ptr [RDI]
MOV ECX,EDX
NEG ECX
CMOVS ECX,EDX
ADD EAX,ECX
TEST EDX,EDX
JNZ 0x... | int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
return 0;
}
iVar2 = 0;
piVar1 = param_1 + param_2;
iVar4 = 1;
do {
while( true ) {
iVar5 = *param_1;
iVar3 = -iVar5;
if (0 < iVar5) {
iVar3... |
1,171 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
} | #include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1... | O3 | c | func0:
endbr64
test %esi,%esi
je 1493 <func0+0x63>
jle 1490 <func0+0x60>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%r9
mov $0x1,%eax
jmp 1462 <func0+0x32>
nopl 0x0(%rax)
mov %eax,%ecx
neg %ecx
test %edx,%edx
cmovs %ecx,%eax
add $0x4,%rdi
cmp %r9,%rdi
je 1481 <fu... | func0_part_0:
test esi, esi
jle short loc_1400
movsxd rsi, esi
xor eax, eax
lea r8, [rdi+rsi*4]
mov esi, 1
jmp short loc_13DA
loc_13C8:
mov ecx, esi
neg ecx
test edx, edx
cmovs esi, ecx
add rdi, 4
cmp r8, rdi
jz short loc_13F4
loc_13DA:
mov edx, [rdi]
mov ecx, e... | long long func0_part_0(int *a1, int a2)
{
int v2; // eax
int *v3; // r8
int v4; // esi
int v5; // edx
int v6; // ecx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
v4 = 1;
do
{
while ( 1 )
{
v5 = *a1;
v6 = -*a1;
if ( *a1 > 0 )
v6 = *a1;
v2 += v6;
... | func0.part.0:
TEST ESI,ESI
JLE 0x00101400
MOVSXD RSI,ESI
XOR EAX,EAX
LEA R8,[RDI + RSI*0x4]
MOV ESI,0x1
JMP 0x001013da
LAB_001013c8:
MOV ECX,ESI
NEG ECX
TEST EDX,EDX
CMOVS ESI,ECX
ADD RDI,0x4
CMP R8,RDI
JZ 0x001013f4
LAB_001013da:
MOV EDX,dword ptr [RDI]
MOV ECX,EDX
NEG ECX
CMOVS ECX,EDX
ADD EAX,ECX
TEST EDX,EDX
JNZ 0x... | int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
return 0;
}
iVar2 = 0;
piVar1 = param_1 + param_2;
iVar4 = 1;
do {
while( true ) {
iVar5 = *param_1;
iVar3 = -iVar5;
if (0 < iVar5) {
iVar3... |
1,172 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 121c <func0+0x73>
movl $0x0,-0x18(%rbp)
jmp 1210 <func0+0x67>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov [rbp+var_1C], 0
jmp short loc_121C
loc_11CC:
mov [rbp+var_18], 0
jmp short loc_1210
loc_11D5:
mov eax, [rbp+var_1C]
cdqe
lea rd... | _DWORD * func0(long long a1, int a2, int a3, _DWORD *a4)
{
int i; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+24h] [rbp-1Ch]
int j; // [rsp+28h] [rbp-18h]
int v9; // [rsp+2Ch] [rbp-14h]
int v10; // [rsp+30h] [rbp-10h]
int v11; // [rsp+34h] [rbp-Ch]
_DWORD *v12; // [rsp+38h] [rbp-8h]
for ( i = 0; i < a2; ++i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010121c
LAB_001011cc:
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101210
LAB_001011d5:
MOV EAX,dword ptr [RB... | void * func0(long param_1,int param_2,int param_3,int *param_4)
{
void *pvVar1;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
for (local_24 = 0; (int)local_24 < param_2; local_24 = local_24 + 1) {
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
... |
1,173 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebx
mov %rcx,%r12
test %esi,%esi
jle 1200 <func0+0x57>
lea -0x1(%rsi),%r11d
mov $0x0,%ebp
mov $0x0,%r13d
jmp 11f5 <func0+0x4c>
mov %r10,%rax
cmpl $0x1,(%rdx,%rax,4)
cmove %eax,%r8d
cmove %ecx,%r9d
lea... | func0:
endbr64
push r12
push rbp
push rbx
mov r10, rdi
mov r11d, esi
mov ebx, edx
mov r12, rcx
test esi, esi
jle short loc_11F1
movsxd rdx, esi
mov edi, 0
loc_11C8:
mov esi, edi
mov rcx, [r10+rdi*8]
mov eax, 0
loc_11D3:
cmp dword ptr [rcx+rax*4], 1
cmovz r8d, eax
c... | _DWORD * func0(long long a1, int a2, int a3, int *a4, int a5, int a6)
{
long long i; // rdi
long long j; // rax
int v10; // ebp
_DWORD *result; // rax
long long v12; // rdx
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
for ( j = 0LL; j != a2; ++j )
{
if ( *(_DWORD *)(*(_QWOR... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R10,RDI
MOV R11D,ESI
MOV EBX,EDX
MOV R12,RCX
TEST ESI,ESI
JLE 0x001011f1
MOVSXD RDX,ESI
MOV EDI,0x0
LAB_001011c8:
MOV ESI,EDI
MOV RCX,qword ptr [R10 + RDI*0x8]
MOV EAX,0x0
LAB_001011d3:
CMP dword ptr [RCX + RAX*0x4],0x1
CMOVZ R8D,EAX
CMOVZ R9D,ESI
ADD RAX,0x1
CMP RAX,RDX
JN... | void func0(long param_1,int param_2,int param_3,int *param_4,int param_5,int param_6)
{
int iVar1;
long lVar2;
void *pvVar3;
ulong uVar4;
int iVar5;
long lVar6;
bool bVar7;
if (0 < param_2) {
lVar6 = 0;
do {
lVar2 = 0;
do {
bVar7 = *(int *)(*(long *)(param_1 + lVar6 * 8) ... |
1,174 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[... | O2 | c | func0:
endbr64
push %r13
lea -0x1(%rsi),%r13d
push %r12
mov %rcx,%r12
push %rbp
mov %esi,%ebp
push %rbx
mov %edx,%ebx
sub $0x8,%rsp
test %esi,%esi
jle 1880 <func0+0x60>
lea -0x1(%rsi),%edx
xor %esi,%esi
mov %rdx,%r13
nopl (%rax)
mov (%rdi,%rsi,8),%r8
movslq %esi,%rcx
xor %ea... | func0:
endbr64
push r12
mov r10, rdi
mov r11d, esi
mov r12, rcx
push rbp
mov ebp, edx
push rbx
test esi, esi
jle short loc_17AE
movsxd rsi, esi
xor edi, edi
nop dword ptr [rax+00h]
loc_1780:
mov rdx, [r10+rdi*8]
mov ecx, edi
xor eax, eax
nop dword ptr [rax+rax+00... | _DWORD * func0(long long a1, int a2, int a3, int *a4, int a5, int a6)
{
long long i; // rdi
long long j; // rax
int v10; // ebx
_DWORD *result; // rax
long long v12; // rdx
int v13; // ecx
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
for ( j = 0LL; j != a2; ++j )
{
if ( *... | func0:
ENDBR64
PUSH R12
MOV R10,RDI
MOV R11D,ESI
MOV R12,RCX
PUSH RBP
MOV EBP,EDX
PUSH RBX
TEST ESI,ESI
JLE 0x001017ae
MOVSXD RSI,ESI
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_00101780:
MOV RDX,qword ptr [R10 + RDI*0x8]
MOV ECX,EDI
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101790:
CMP dword ptr [RDX + RAX*0x4],0x1
CMOV... | void func0(long param_1,int param_2,int param_3,int *param_4,int param_5,int param_6)
{
long lVar1;
void *pvVar2;
int iVar3;
ulong uVar4;
int iVar5;
long lVar6;
bool bVar7;
if (0 < param_2) {
lVar6 = 0;
do {
lVar1 = 0;
do {
bVar7 = *(int *)(*(long *)(param_1 + lVar6 * 8) ... |
1,175 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if... | #include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[... | O3 | c | func0:
endbr64
push %r15
push %r14
lea -0x1(%rsi),%r14d
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %edx,0x14(%rsp)
mov %rcx,0x18(%rsp)
test %esi,%esi
jle 1a18 <func0+0x308>
lea -0x1(%rsi),%eax
mov %esi,%r15d
xor %edi,%edi
mov %esi,%r13d
mov %r... | func0:
endbr64
push r15
lea r15d, [rsi-1]
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov ebx, edx
mov rdx, rcx
sub rsp, 28h
test esi, esi
jle loc_19CA
movsxd rdi, esi
mov ecx, esi
mov [rsp+58h+var_44], ebx
mov r14d, esi
shr ecx, 2
mov [rsp... | __m128i * func0(long long a1, int a2, int a3, int *a4, int a5)
{
signed int v5; // eax
signed int v6; // r15d
int *v9; // rdx
__m128i si128; // xmm7
long long v11; // r9
__m128i v12; // xmm9
long long v13; // rdx
__m128i v14; // xmm4
__m128i v15; // xmm2
const __m128i *v16; // rax
__m128i v17; // ... | func0:
ENDBR64
PUSH R15
LEA R15D,[RSI + -0x1]
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV EBX,EDX
MOV RDX,RCX
SUB RSP,0x28
TEST ESI,ESI
JLE 0x001019ca
MOVSXD RDI,ESI
MOV ECX,ESI
MOV dword ptr [RSP + 0x14],EBX
MOV R14D,ESI
SHR ECX,0x2
MOV qword ptr [RSP + 0x8],RDI
LEA R15D,[RSI + -0x1]
AND R14D,0xffffff... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(long param_1,uint param_2,uint param_3,uint *param_4,uint param_5)
{
uint *puVar1;
uint *puVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
uint in_EAX;
uint uVar7;
uint *puVar8;
uint *puVar9;
ulong ... |
1,176 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
} | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movl $0x1,(%rax)
cmpl $0x0,-0x14(%rbp)
jne 11e9 <func0+0x40>
mov -0x8(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov dword ptr [rax], 1
cmp [rbp+var_14], 0
jnz short loc_11E9
mov r... | _DWORD * func0(int a1)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v3; // [rsp+18h] [rbp-8h]
v3 = malloc(4LL * (a1 + 1));
*v3 = 1;
if ( !a1 )
return v3;
v3[1] = 3;
for ( i = 2; i <= a1; ++i )
{
if ( (i & 1) != 0 )
v3[i] = (i + 1) / 2 + v3[i - 1] + v3[i - 2] + 1;
else
v3[i] = i / 2 + ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0x1
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001011e9
MOV RAX,qword ptr... | int4 * func0(int param_1)
{
int4 *puVar1;
uint local_14;
puVar1 = (int4 *)malloc((long)(param_1 + 1) << 2);
*puVar1 = 1;
if (param_1 != 0) {
puVar1[1] = 3;
for (local_14 = 2; (int)local_14 <= param_1; local_14 = local_14 + 1) {
if ((local_14 & 1) == 0) {
puVar1[(int)local_14] = (int)... |
1,177 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
} | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, ... | O1 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
lea 0x1(%rdi),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x1,(%rax)
test %ebx,%ebx
je 121e <func0+0x75>
movl $0x3,0x4(%rax)
cmp $0x1,%ebx
jle 121e <func0+0x75>
lea -0x2(%rbx),%r8d
add $0x3,%r8
mov $0x2,%edx
jmp 1208 <f... | func0:
endbr64
push rbx
mov ebx, edi
lea edi, [rdi+1]
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_121A
mov dword ptr [rax+4], 3
cmp ebx, 1
jle short loc_121A
lea r8d, [rbx+1]
mov edx, 2
jmp short loc_1204
loc_11E0... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v2; // rdx
int v3; // ecx
result = malloc(4LL * (a1 + 1));
*result = 1;
if ( a1 )
{
result[1] = 3;
if ( a1 > 1 )
{
v2 = 2LL;
do
{
if ( (v2 & 1) != 0 )
v3 = result[v2 - 1] + result[v2 - 2] + ((int)v2 ... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
LEA EDI,[RDI + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x0010121a
MOV dword ptr [RAX + 0x4],0x3
CMP EBX,0x1
JLE 0x0010121a
LEA R8D,[RBX + 0x1]
MOV EDX,0x2
JMP 0x00101204
LAB_001011e0:
MOV ESI,dword ptr [RAX + RDX*0x4 + -0x8]
ADD ESI,dwo... | void func0(int param_1)
{
int4 *puVar1;
ulong uVar2;
puVar1 = (int4 *)malloc((long)(param_1 + 1) << 2);
*puVar1 = 1;
if ((param_1 != 0) && (puVar1[1] = 3, 1 < param_1)) {
uVar2 = 2;
do {
if ((uVar2 & 1) == 0) {
puVar1[uVar2] = ((int)(((uint)(uVar2 >> 0x1f) & 1) + (int)uVar2) >> 1) + ... |
1,178 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
} | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, ... | O2 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x1,(%rax)
test %ebx,%ebx
je 17a5 <func0+0x75>
movl $0x3,0x4(%rax)
cmp $0x1,%ebx
jle 17a5 <func0+0x75>
lea -0x2(%rbx),%edi
mov $0x2,%edx
add $0x3,%rdi
jmp 1783 <func0... | func0:
endbr64
push rbx
mov ebx, edi
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_169B
mov dword ptr [rax+4], 3
cmp ebx, 1
jle short loc_169B
mov rcx, rax
mov edx, 2
jmp short loc_1672
loc_1660:
mov ... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
_DWORD *v3; // rcx
int v4; // edx
char v5; // di
int v6; // esi
int v7; // edi
result = malloc(4LL * (a1 + 1));
*result = 1;
if ( a1 )
{
result[1] = 3;
if ( a1 > 1 )
{
v3 = result;
v4 = 2;
do
{
while ( 1 )
... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x0010169b
MOV dword ptr [RAX + 0x4],0x3
CMP EBX,0x1
JLE 0x0010169b
MOV RCX,RAX
MOV EDX,0x2
JMP 0x00101672
LAB_00101660:
MOV EDI,ESI
ADD RCX,0x4
SAR EDI,0x1
ADD EDI,0x1
MOV dword ptr [RCX +... | void func0(uint param_1)
{
int *piVar1;
uint uVar2;
uint uVar3;
bool bVar4;
piVar1 = (int *)malloc((long)(int)(param_1 + 1) << 2);
*piVar1 = 1;
if ((param_1 != 0) && (piVar1[1] = 3, 1 < (int)param_1)) {
uVar2 = 2;
do {
while (uVar3 = uVar2 + 1, (uVar2 & 1) != 0) {
piVar1[2] = *pi... |
1,179 | func0 | #include <stdio.h>
#include <stdlib.h>
| int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
} | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, ... | O3 | c | func0:
endbr64
push %rbx
mov %edi,%ebx
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x1,(%rax)
test %ebx,%ebx
je 1825 <func0+0x75>
movl $0x3,0x4(%rax)
cmp $0x1,%ebx
jle 1825 <func0+0x75>
lea -0x2(%rbx),%edi
mov $0x2,%edx
add $0x3,%rdi
jmp 1803 <func0... | func0:
endbr64
push rbx
mov ebx, edi
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_168B
mov dword ptr [rax+4], 3
cmp ebx, 1
jle short loc_168B
mov rcx, rax
mov edx, 2
jmp short loc_1662
loc_1650:
mov ... | _DWORD * func0(int a1)
{
_DWORD *result; // rax
_DWORD *v3; // rcx
int v4; // edx
char v5; // di
int v6; // esi
int v7; // edi
result = malloc(4LL * (a1 + 1));
*result = 1;
if ( a1 )
{
result[1] = 3;
if ( a1 > 1 )
{
v3 = result;
v4 = 2;
do
{
while ( 1 )
... | func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x0010168b
MOV dword ptr [RAX + 0x4],0x3
CMP EBX,0x1
JLE 0x0010168b
MOV RCX,RAX
MOV EDX,0x2
JMP 0x00101662
LAB_00101650:
MOV EDI,ESI
ADD RCX,0x4
SAR EDI,0x1
ADD EDI,0x1
MOV dword ptr [RCX +... | void func0(uint param_1)
{
int *piVar1;
uint uVar2;
uint uVar3;
bool bVar4;
piVar1 = (int *)malloc((long)(int)(param_1 + 1) << 2);
*piVar1 = 1;
if ((param_1 != 0) && (piVar1[1] = 3, 1 < (int)param_1)) {
uVar2 = 2;
do {
while (uVar3 = uVar2 + 1, (uVar2 & 1) != 0) {
piVar1[2] = *pi... |
1,180 | func0 | #include <stdio.h>
| int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
} | #include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d3 <func0+0x8a>
mov -0x14(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 1
mov [rbp+var_8], 0
jmp short loc_11D7
loc_1164:
mov edx, [rbp+var_14]
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 ... | long long func0(int a1)
{
unsigned int v3; // [rsp+8h] [rbp-Ch]
int v4; // [rsp+Ch] [rbp-8h]
v3 = 1;
v4 = 0;
while ( a1 > 0 )
{
if ( a1 % 10 % 2 == 1 )
{
v4 = 1;
v3 *= a1 % 10;
}
a1 /= 10;
}
if ( v4 )
return v3;
else
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d7
LAB_00101164:
MOV EDX,dword ptr [RBP + -0x14]
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 ... | int func0(int param_1)
{
bool bVar1;
int4 local_1c;
int4 local_14;
local_14 = 1;
bVar1 = false;
for (local_1c = param_1; 0 < local_1c; local_1c = local_1c / 10) {
if ((local_1c % 10) % 2 == 1) {
bVar1 = true;
local_14 = local_14 * (local_1c % 10);
}
}
if (!bVar1) {
local_14 =... |
1,181 | func0 | #include <stdio.h>
| int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
} | #include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
} | O1 | c | func0:
endbr64
test %edi,%edi
jle 11be <func0+0x75>
mov $0x0,%esi
mov $0x1,%ecx
jmp 1179 <func0+0x30>
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
cmp $0x9,%edi
jle 11b6 <func0+0x6d>
mov %eax,%edi
movslq %edi,%rax
imul $0x66... | func0:
endbr64
mov edx, edi
test edi, edi
jle short loc_11BE
mov esi, 0
mov edi, 1
jmp short loc_117B
loc_115F:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
cmp edx, 9
jle short loc_11B6
mov edx, eax
loc_117B:
movsxd rax,... | long long func0(int a1)
{
int v1; // edx
unsigned int v2; // esi
unsigned int v3; // edi
v1 = a1;
if ( a1 <= 0 )
{
return 0;
}
else
{
v2 = 0;
v3 = 1;
while ( 1 )
{
if ( v1 % 10 % 2 == 1 )
{
v3 *= v1 % 10;
v2 = 1;
}
if ( v1 <= 9 )
br... | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x001011be
MOV ESI,0x0
MOV EDI,0x1
JMP 0x0010117b
LAB_0010115f:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
CMP EDX,0x9
JLE 0x001011b6
MOV EDX,EAX
LAB_0010117b:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR EC... | int func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
iVar3 = 1;
do {
if ((param_1 % 10) % 2 == 1) {
iVar3 = iVar3 * (param_1 % 10);
iVar2 = 1;
}
bVar1 = 9 < param_1;
param_1 = param_1 / 10;
... |
1,182 | func0 | #include <stdio.h>
| int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
} | #include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
} | O2 | c | func0:
endbr64
xor %r9d,%r9d
test %edi,%edi
jle 136c <func0+0x5c>
mov $0x1,%r8d
mov $0xcccccccd,%ecx
jmp 1332 <func0+0x22>
nopl 0x0(%rax,%rax,1)
mov %eax,%edi
mov %edi,%eax
mov %edi,%esi
mov %rax,%rdx
imul %rcx,%rdx
shr $0x23,%rdx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %ed... | func0:
endbr64
test edi, edi
jle short loc_1320
xor r9d, r9d
mov r8d, 1
mov esi, 0CCCCCCCDh
jmp short loc_12E2
loc_12E0:
mov edi, eax
loc_12E2:
mov eax, edi
mov rdx, rax
imul rdx, rsi
shr rdx, 23h
lea ecx, [rdx+rdx*4]
mov edx, edi
add ecx, ecx
sub edx, ecx
mov ... | long long func0(int a1)
{
int v1; // r9d
unsigned int v2; // r8d
if ( a1 <= 0 )
return 0LL;
v1 = 0;
v2 = 1;
while ( 1 )
{
if ( (a1 & 1) != 0 )
{
v2 *= a1 % 0xAu;
v1 = a1 & 1;
}
if ( a1 <= 9 )
break;
a1 /= 0xAu;
}
if ( !v1 )
return 0;
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101320
XOR R9D,R9D
MOV R8D,0x1
MOV ESI,0xcccccccd
JMP 0x001012e2
LAB_001012e0:
MOV EDI,EAX
LAB_001012e2:
MOV EAX,EDI
MOV RDX,RAX
IMUL RDX,RSI
SHR RDX,0x23
LEA ECX,[RDX + RDX*0x4]
MOV EDX,EDI
ADD ECX,ECX
SUB EDX,ECX
MOV ECX,EDI
AND ECX,0x1
JZ 0x00101306
IMUL R8D,EDX
MOV R9D,ECX
LAB_00... | int func0(uint param_1)
{
bool bVar1;
int iVar2;
uint uVar3;
if ((int)param_1 < 1) {
return 0;
}
uVar3 = 0;
iVar2 = 1;
do {
if ((param_1 & 1) != 0) {
iVar2 = iVar2 * (param_1 % 10);
uVar3 = param_1 & 1;
}
bVar1 = 9 < (int)param_1;
param_1 = param_1 / 10;
} while (bV... |
1,183 | func0 | #include <stdio.h>
| int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
} | #include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
} | O3 | c | func0:
endbr64
xor %r9d,%r9d
test %edi,%edi
jle 12dc <func0+0x5c>
mov $0x1,%r8d
mov $0xcccccccd,%ecx
jmp 12a2 <func0+0x22>
nopl 0x0(%rax,%rax,1)
mov %eax,%edi
mov %edi,%eax
mov %edi,%esi
mov %rax,%rdx
imul %rcx,%rdx
shr $0x23,%rdx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %ed... | func0:
endbr64
test edi, edi
jle short loc_12F0
xor r9d, r9d
mov r8d, 1
mov esi, 0CCCCCCCDh
jmp short loc_12B2
loc_12B0:
mov edi, eax
loc_12B2:
mov eax, edi
mov rdx, rax
imul rdx, rsi
shr rdx, 23h
lea ecx, [rdx+rdx*4]
mov edx, edi
add ecx, ecx
sub edx, ecx
mov ... | long long func0(int a1)
{
int v1; // r9d
unsigned int v2; // r8d
if ( a1 <= 0 )
return 0LL;
v1 = 0;
v2 = 1;
while ( 1 )
{
if ( (a1 & 1) != 0 )
{
v2 *= a1 % 0xAu;
v1 = a1 & 1;
}
if ( a1 <= 9 )
break;
a1 /= 0xAu;
}
if ( !v1 )
return 0;
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012f0
XOR R9D,R9D
MOV R8D,0x1
MOV ESI,0xcccccccd
JMP 0x001012b2
LAB_001012b0:
MOV EDI,EAX
LAB_001012b2:
MOV EAX,EDI
MOV RDX,RAX
IMUL RDX,RSI
SHR RDX,0x23
LEA ECX,[RDX + RDX*0x4]
MOV EDX,EDI
ADD ECX,ECX
SUB EDX,ECX
MOV ECX,EDI
AND ECX,0x1
JZ 0x001012d6
IMUL R8D,EDX
MOV R9D,ECX
LAB_00... | int func0(uint param_1)
{
bool bVar1;
int iVar2;
uint uVar3;
if ((int)param_1 < 1) {
return 0;
}
uVar3 = 0;
iVar2 = 1;
do {
if ((param_1 & 1) != 0) {
iVar2 = iVar2 * (param_1 % 10);
uVar3 = param_1 & 1;
}
bVar1 = 9 < (int)param_1;
param_1 = param_1 / 10;
} while (bV... |
1,184 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
... | #include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11f2 <func0+0x89>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5b,%al
jne ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_11F2
loc_1191:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, ... | long long func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-1Ch]
int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
v3 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] == 91 )
++v2;
if ( a1[i] == 93 )
--v2;
if ( v2 < 0 )
v2 = 0;
if ( v2 > v3 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011f2
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte... | int8 func0(char *param_1)
{
size_t sVar1;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= (ulong)(long)local_1c) {
return 0;
}
if (param_1[local_1c] == '[') {
local_24 = local_24 + 1... |
1,185 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
... | #include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert... | O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rsi,%rdx
lea -0x1(%rsi,%rcx,1),%rdi
mov $0x0,%ecx
mov $0x0,%eax
mov $0x0,%r8d
jmp 119f <func0+0x56>
cmp $0x5d,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%eax
test %eax,%e... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdx, rbx
lea rdi, [rbx+rax]
mov ecx, 0
mov eax, 0
jmp short loc_11A6
loc_1189:
add eax, 1
loc_118C:
test eax, eax
mov esi, 0
cmovs eax, esi
cmp ecx, eax
cmovl ecx, eax
add rdx, 1
lea esi, [rcx-1]
cmp eax, ... | long long func0(const char *a1)
{
size_t v1; // rax
const char *v2; // rdx
const char *v3; // rdi
int v4; // ecx
int v5; // eax
v1 = strlen(a1);
v2 = a1;
v3 = &a1[v1];
v4 = 0;
v5 = 0;
do
{
if ( v2 == v3 )
return 0LL;
if ( *v2 == 91 )
++v5;
else
v5 -= *v2 == 93;
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDX,RBX
LEA RDI,[RBX + RAX*0x1]
MOV ECX,0x0
MOV EAX,0x0
JMP 0x001011a6
LAB_00101189:
ADD EAX,0x1
LAB_0010118c:
TEST EAX,EAX
MOV ESI,0x0
CMOVS EAX,ESI
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0x1
LEA ESI,[RCX + -0x1]
CMP EAX,ESI
JL 0x001011cb
LAB_001011a6:
CMP RDX,RDI
JZ ... | int8 func0(char *param_1)
{
char *pcVar1;
int iVar2;
size_t sVar3;
int iVar4;
sVar3 = strlen(param_1);
pcVar1 = param_1 + sVar3;
iVar4 = 0;
iVar2 = 0;
do {
if (param_1 == pcVar1) {
return 0;
}
if (*param_1 == '[') {
iVar2 = iVar2 + 1;
}
else {
iVar2 = iVar2 - ... |
1,186 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
... | #include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert... | O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
xor %edx,%edx
add %rbx,%rax
xor %r8d,%r8d
jmp 1494 <func0+0x44>
nopl 0x0(%rax)
cmp $0x5d,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%edx
test %edx,%edx
cmovs %r8d,%edx
cmp %edx,%ecx
cmovl %e... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
xor edx, edx
add rax, rbx
xor r8d, r8d
jmp short loc_1490
loc_1470:
cmp sil, 5Dh ; ']'
jnz short loc_1480
sub edx, 1
cmp edx, 0FFFFFFFFh
cmovz edx, r8d
loc_1480:
cmp ecx, edx
cmovl ecx, ... | long long func0(const char *a1)
{
size_t v1; // rax
int v2; // ecx
int v3; // edx
const char *v4; // rax
v1 = strlen(a1);
v2 = 0;
v3 = 0;
v4 = &a1[v1];
while ( a1 != v4 )
{
if ( *a1 == 91 )
{
if ( v2 < ++v3 )
v2 = v3;
++a1;
if ( v2 - 1 > v3 )
return 1LL;
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RBX
XOR ECX,ECX
XOR EDX,EDX
ADD RAX,RBX
XOR R8D,R8D
JMP 0x00101490
LAB_00101470:
CMP SIL,0x5d
JNZ 0x00101480
SUB EDX,0x1
CMP EDX,-0x1
CMOVZ EDX,R8D
LAB_00101480:
CMP ECX,EDX
CMOVL ECX,EDX
ADD RDI,0x1
LEA ESI,[RCX + -0x1]
CMP ESI,EDX
JG 0x001014b1
LAB_00101490:... | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
int iVar4;
sVar1 = strlen(param_1);
iVar3 = 0;
iVar4 = 0;
pcVar2 = param_1 + sVar1;
do {
while( true ) {
if (param_1 == pcVar2) {
return 0;
}
if (*param_1 == '[') break;
if ((*param_1 == ']') && ... |
1,187 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
... | #include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert... | O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
xor %edx,%edx
add %rbx,%rax
xor %r8d,%r8d
jmp 1494 <func0+0x44>
nopl 0x0(%rax)
cmp $0x5d,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%edx
test %edx,%edx
cmovs %r8d,%edx
cmp %edx,%ecx
cmovl %e... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
xor edx, edx
add rax, rbx
xor r8d, r8d
jmp short loc_1490
loc_1470:
cmp sil, 5Dh ; ']'
jnz short loc_1480
sub edx, 1
cmp edx, 0FFFFFFFFh
cmovz edx, r8d
loc_1480:
cmp ecx, edx
cmovl ecx, ... | long long func0(const char *a1)
{
size_t v1; // rax
int v2; // ecx
int v3; // edx
const char *v4; // rax
v1 = strlen(a1);
v2 = 0;
v3 = 0;
v4 = &a1[v1];
while ( v4 != a1 )
{
if ( *a1 == 91 )
{
if ( v2 < ++v3 )
v2 = v3;
++a1;
if ( v2 - 1 > v3 )
return 1LL;
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RBX
XOR ECX,ECX
XOR EDX,EDX
ADD RAX,RBX
XOR R8D,R8D
JMP 0x00101490
LAB_00101470:
CMP SIL,0x5d
JNZ 0x00101480
SUB EDX,0x1
CMP EDX,-0x1
CMOVZ EDX,R8D
LAB_00101480:
CMP ECX,EDX
CMOVL ECX,EDX
ADD RDI,0x1
LEA ESI,[RCX + -0x1]
CMP ESI,EDX
JG 0x001014b1
LAB_00101490:... | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
int iVar4;
sVar1 = strlen(param_1);
iVar3 = 0;
iVar4 = 0;
pcVar2 = param_1 + sVar1;
do {
while( true ) {
if (pcVar2 == param_1) {
return 0;
}
if (*param_1 == '[') break;
if ((*param_1 == ']') && ... |
1,188 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
} | #include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[]... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1201 <func0+0x78>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_121D
loc_11AD:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, d... | long long func0(long long a1, int a2)
{
int v2; // ebx
unsigned int v4; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v2 = (int)ceil(*(float *)(4LL * i + a1));
v4 += v2 * (int)ceil(*(float *)(4LL * i + a1));
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010121d
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS ... | int func0(long param_1,int param_2)
{
double dVar1;
double dVar2;
int4 local_20;
int4 local_1c;
local_20 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
dVar1 = ceil((double)*(float *)(param_1 + (long)local_1c * 4));
dVar2 = ceil((double)*(float *)(param_1 + (long)local_1c... |
1,189 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
} | #include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[]... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11e2 <func0+0x79>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
mov $0x0,%ecx
movss 0xfcf(%rip),%xmm4
movss 0xfdf(%rip),%xmm3
movss 0xfc3(%rip),%xmm5
jmp 11ad <func0+0x44>
cvttss2si %xmm0,%eax
imul %eax,%eax
add %eax,%ecx
add $0x4,%rdx
cmp ... | func0:
endbr64
test esi, esi
jle short loc_11E1
mov rdx, rdi
movsxd rsi, esi
lea rsi, [rdi+rsi*4]
mov ecx, 0
movss xmm4, cs:dword_2004
movss xmm3, cs:dword_200C
movss xmm5, cs:dword_2008
jmp short loc_11AC
loc_119A:
cvttss2si eax, xmm2
imul eax, eax
add ecx, eax
add rdx, 4
cmp ... | long long func0(float *a1, int a2)
{
float *v2; // rdx
float *v3; // rsi
unsigned int v4; // ecx
__m128 v5; // xmm1
float v6; // xmm2_4
__m128 v7; // xmm0
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
v5 = (__m128)*(unsigned int *)v2;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011e1
MOV RDX,RDI
MOVSXD RSI,ESI
LEA RSI,[RDI + RSI*0x4]
MOV ECX,0x0
MOVSS XMM4,dword ptr [0x00102004]
MOVSS XMM3,dword ptr [0x0010200c]
MOVSS XMM5,dword ptr [0x00102008]
JMP 0x001011ac
LAB_0010119a:
CVTTSS2SI EAX,XMM2
IMUL EAX,EAX
ADD ECX,EAX
ADD RDX,0x4
CMP RDX,RSI
JZ 0x001011e6
L... | int func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
float fVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
pfVar1 = param_1 + param_2;
iVar2 = 0;
do {
fVar3 = *param_1;
if ((float)((uint)fVar3 & DAT_0010200c) < DAT_00102004) {
fVar3 = (float)(~DAT_0010200c ... |
1,190 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
} | #include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[]... | O2 | c | func0:
endbr64
test %esi,%esi
jle 15d0 <func0+0x80>
lea -0x1(%rsi),%eax
movss 0xbf5(%rip),%xmm4
xor %r8d,%r8d
movss 0xc02(%rip),%xmm3
movss 0xbe6(%rip),%xmm5
lea 0x4(%rdi,%rax,4),%rdx
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm0
movaps %xmm0,%xmm1
andps %xmm3,%xmm1
ucomiss %xmm1,%xmm4
jbe 15b6 <func... | func0:
endbr64
test esi, esi
jle short loc_1590
movsxd rsi, esi
movss xmm4, cs:dword_2004
xor edx, edx
movss xmm3, cs:dword_2008
movss xmm5, dword ptr cs:xmmword_2170
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1540:
movss xmm0, dword ptr [rdi]
movaps xmm1, xmm0
andps xmm1, xmm... | long long func0(float *a1, int a2)
{
unsigned int v2; // edx
float *v3; // rcx
__m128 v4; // xmm0
__m128 v5; // xmm1
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
v4 = (__m128)*(unsigned int *)a1;
if ( fabs(*a1) < 8388608.0 )
{
v5.m128_f32[0] = (float)(int)v4.m128_f32[0... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101590
MOVSXD RSI,ESI
MOVSS XMM4,dword ptr [0x00102004]
XOR EDX,EDX
MOVSS XMM3,dword ptr [0x00102008]
MOVSS XMM5,dword ptr [0x00102170]
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101540:
MOVSS XMM0,dword ptr [RDI]
MOVAPS XMM1,XMM0
ANDPS XMM1,XMM3
UCOMISS XMM4,XMM1
JBE 0x001015... | int func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
float fVar3;
if (0 < param_2) {
iVar2 = 0;
pfVar1 = param_1 + param_2;
do {
fVar3 = *param_1;
if ((float)((uint)fVar3 & DAT_00102008) < DAT_00102004) {
fVar3 = (float)((uint)((float)(int)fVar3 +
... |
1,191 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
} | #include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[]... | O3 | c | func0:
endbr64
test %esi,%esi
jle 15a0 <func0+0x80>
lea -0x1(%rsi),%eax
movss 0xc25(%rip),%xmm4
xor %r8d,%r8d
movss 0xc32(%rip),%xmm3
movss 0xc16(%rip),%xmm5
lea 0x4(%rdi,%rax,4),%rdx
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm0
movaps %xmm0,%xmm1
andps %xmm3,%xmm1
ucomiss %xmm1,%xmm4
jbe 1586 <func... | func0:
endbr64
test esi, esi
jle short loc_1590
movsxd rsi, esi
movss xmm4, cs:dword_2004
xor edx, edx
movss xmm3, cs:dword_2008
movss xmm5, dword ptr cs:xmmword_2170
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1540:
movss xmm0, dword ptr [rdi]
movaps xmm1, xmm0
andps xmm1, xmm... | long long func0(float *a1, int a2)
{
unsigned int v2; // edx
float *v3; // rcx
__m128 v4; // xmm0
__m128 v5; // xmm1
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
v4 = (__m128)*(unsigned int *)a1;
if ( fabs(*a1) < 8388608.0 )
{
v5.m128_f32[0] = (float)(int)v4.m128_f32[0... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101590
MOVSXD RSI,ESI
MOVSS XMM4,dword ptr [0x00102004]
XOR EDX,EDX
MOVSS XMM3,dword ptr [0x00102008]
MOVSS XMM5,dword ptr [0x00102170]
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101540:
MOVSS XMM0,dword ptr [RDI]
MOVAPS XMM1,XMM0
ANDPS XMM1,XMM3
UCOMISS XMM4,XMM1
JBE 0x001015... | int func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
float fVar3;
if (0 < param_2) {
iVar2 = 0;
pfVar1 = param_1 + param_2;
do {
fVar3 = *param_1;
if ((float)((uint)fVar3 & DAT_00102008) < DAT_00102004) {
fVar3 = (float)((uint)((float)(int)fVar3 +
... |
1,192 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *txt) {
int len = strlen(txt);
if (len == 0) return 0;
char last_char = txt[len - 1];
if (!isalpha((unsigned char)last_char)) return 0;
if (len == 1) return 1;
char second_last_char = txt[len - 2];
if (isalpha((unsigned char)second_last_char)) return 0;
return 1;
} | #include <assert.h>
int main() {
assert(func0("apple") == 0);
assert(func0("apple pi e") == 1);
assert(func0("eeeee") == 0);
assert(func0("A") == 1);
assert(func0("Pumpkin pie ") == 0);
assert(func0("Pumpkin pie 1") == 0);
assert(func0("") == 0);
assert(func0("eeeee e ") == 0);
asse... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 11b8 <func0+0x2f>
mov $0x0,%eax
jmpq 124c <func0+0xc3>
mov -0x4(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
cmp [rbp+var_4], 0
jnz short loc_11B8
mov eax, 0
jmp locret_124C
loc_11B8:
mov eax, [rbp+var_4]
cdqe
lea rdx, [rax-1]
mov rax, [... | _BOOL8 func0(const char *a1)
{
unsigned __int8 v2; // [rsp+1Ah] [rbp-6h]
unsigned __int8 v3; // [rsp+1Bh] [rbp-5h]
int v4; // [rsp+1Ch] [rbp-4h]
v4 = strlen(a1);
if ( !v4 )
return 0LL;
v2 = a1[v4 - 1];
if ( ((*__ctype_b_loc())[v2] & 0x400) == 0 )
return 0LL;
if ( v4 == 1 )
return 1LL;
v3... | 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 0x00101070
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x001011b8
MOV EAX,0x0
JMP 0x0010124c
LAB_001011b8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX + -0x1]
MOV ... | int8 func0(char *param_1)
{
byte bVar1;
int iVar2;
size_t sVar3;
int8 uVar4;
ushort **ppuVar5;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (iVar2 == 0) {
uVar4 = 0;
}
else {
bVar1 = param_1[(long)iVar2 + -1];
ppuVar5 = __ctype_b_loc();
if (((*ppuVar5)[bVar1] & 0x400) == 0) {
... |
1,193 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *txt) {
int len = strlen(txt);
if (len == 0) return 0;
char last_char = txt[len - 1];
if (!isalpha((unsigned char)last_char)) return 0;
if (len == 1) return 1;
char second_last_char = txt[len - 2];
if (isalpha((unsigned char)second_last_char)) return 0;
return 1;
} | #include <assert.h>
int main() {
assert(func0("apple") == 0);
assert(func0("apple pi e") == 1);
assert(func0("eeeee") == 0);
assert(func0("A") == 1);
assert(func0("Pumpkin pie ") == 0);
assert(func0("Pumpkin pie 1") == 0);
assert(func0("") == 0);
assert(func0("eeeee e ") == 0);
asse... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
mov %ebx,%r12d
test %ebx,%ebx
je 11cb <func0+0x62>
movslq %ebx,%r13
callq 1070 <__ctype_b_loc@plt>
mov ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_11D9
movsxd r14, eax
movzx r12d, byte ptr [r13+r14-1]
call ___ctype_b_loc
mov rax, [rax]
movzx r12d, r12b
test byte ptr [rax+r12*2+1], 4
jz ... | long long func0(const char *a1)
{
unsigned int v1; // eax
unsigned int v2; // ebp
long long v3; // r14
unsigned __int8 v4; // r12
const unsigned __int16 *v5; // rax
v1 = strlen(a1);
v2 = v1;
if ( v1 )
{
v3 = (int)v1;
v4 = a1[v1 - 1];
v5 = *__ctype_b_loc();
if ( (v5[v4] & 0x400) != 0 ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
CALL 0x00101070
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001011d9
MOVSXD R14,EAX
MOVZX R12D,byte ptr [R13 + R14*0x1 + -0x1]
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOVZX R12D,R12B
TEST byte ptr [RAX + R12*0x2 + 0x1],0x4
JZ 0x001011e4
CMP EBP,0x1
JZ 0x001011d9... | ulong func0(char *param_1)
{
byte bVar1;
int iVar2;
size_t sVar3;
ushort **ppuVar4;
ulong uVar5;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
uVar5 = sVar3 & 0xffffffff;
if (iVar2 != 0) {
bVar1 = param_1[(long)iVar2 + -1];
ppuVar4 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar4 + (ulo... |
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.