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,194 | 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... | O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %eax,%r12d
test %eax,%eax
je 13f3 <func0+0x53>
movslq %eax,%r13
callq 1090 <__ctype_b_loc@plt>
movzbl -0x1(%rbp,%r13,1),%edx
mov (%rax),%rax
testb $0x4,0x1(%rax,%rdx,2)
je 1408... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
call _strlen
mov r12d, eax
test eax, eax
jz short loc_13F2
movsxd r14, eax
call ___ctype_b_loc
movzx r13d, byte ptr [rbp+r14-1]
mov rax, [rax]
test byte ptr [rax+r13*2+1], 4
jz short loc_1400
cmp... | long long func0(const char *a1)
{
unsigned int v1; // eax
unsigned int v2; // r12d
long long v3; // r14
const unsigned __int16 *v4; // rax
v1 = strlen(a1);
v2 = v1;
if ( !v1 )
return v2;
v3 = (int)v1;
v4 = *__ctype_b_loc();
if ( (v4[(unsigned __int8)a1[v3 - 1]] & 0x400) != 0 )
{
if ( v2 ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV R12D,EAX
TEST EAX,EAX
JZ 0x001013f2
MOVSXD R14,EAX
CALL 0x00101090
MOVZX R13D,byte ptr [RBP + R14*0x1 + -0x1]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + R13*0x2 + 0x1],0x4
JZ 0x00101400
CMP R12D,0x1
JZ 0x001013f2
MOVZX EDX,byt... | ulong func0(char *param_1)
{
int iVar1;
size_t sVar2;
ushort **ppuVar3;
ulong uVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
uVar4 = sVar2 & 0xffffffff;
if (iVar1 != 0) {
ppuVar3 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar3 + (ulong)(byte)param_1[(long)iVar1 + -1] * 2 + 1) & 4) == 0... |
1,195 | 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... | O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %eax,%r12d
test %eax,%eax
je 13f3 <func0+0x53>
movslq %eax,%r13
callq 1090 <__ctype_b_loc@plt>
movzbl -0x1(%rbp,%r13,1),%edx
mov (%rax),%rax
testb $0x4,0x1(%rax,%rdx,2)
je 1408... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
call _strlen
mov r12d, eax
test eax, eax
jz short loc_13F2
movsxd r14, eax
call ___ctype_b_loc
movzx r13d, byte ptr [rbp+r14-1]
mov rax, [rax]
test byte ptr [rax+r13*2+1], 4
jz short loc_1400
cmp... | long long func0(const char *a1)
{
unsigned int v1; // eax
unsigned int v2; // r12d
long long v3; // r14
const unsigned __int16 *v4; // rax
v1 = strlen(a1);
v2 = v1;
if ( !v1 )
return v2;
v3 = (int)v1;
v4 = *__ctype_b_loc();
if ( (v4[(unsigned __int8)a1[v3 - 1]] & 0x400) != 0 )
{
if ( v2 ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV R12D,EAX
TEST EAX,EAX
JZ 0x001013f2
MOVSXD R14,EAX
CALL 0x00101090
MOVZX R13D,byte ptr [RBP + R14*0x1 + -0x1]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + R13*0x2 + 0x1],0x4
JZ 0x00101400
CMP R12D,0x1
JZ 0x001013f2
MOVZX EDX,byt... | ulong func0(char *param_1)
{
int iVar1;
size_t sVar2;
ushort **ppuVar3;
ulong uVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
uVar4 = sVar2 & 0xffffffff;
if (iVar1 != 0) {
ppuVar3 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar3 + (ulong)(byte)param_1[(long)iVar1 + -1] * 2 + 1) & 4) == 0... |
1,196 | func0 | #include <stdio.h>
| int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
} | #include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11c2 <func0+0x59>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
shl $0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0FFFFFFFFh
mov [rbp+var_4], 1
jmp short loc_11C2
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+v... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = -1;
for ( i = 1; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) < *(_DWORD *)(4LL * i - 4 + a1) )
v3 = i;
}
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],0xffffffff
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011c2
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = -1;
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)) {
local_10 = local_c;
}
}
return local_10;
} |
1,197 | func0 | #include <stdio.h>
| int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
} | #include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 1199 <func0+0x30>
lea -0x2(%rsi),%ecx
add $0x2,%rcx
mov $0x1,%eax
mov $0xffffffff,%edx
mov -0x4(%rdi,%rax,4),%esi
cmp %esi,(%rdi,%rax,4)
cmovl %eax,%edx
add $0x1,%rax
cmp %rcx,%rax
jne 1183 <func0+0x1a>
mov %edx,%eax
retq
mov $0xffffffff,%edx
jmp ... | func0:
endbr64
cmp esi, 1
jle short loc_1194
mov esi, esi
mov eax, 1
mov edx, 0FFFFFFFFh
loc_117E:
mov ecx, [rdi+rax*4-4]
cmp [rdi+rax*4], ecx
cmovl edx, eax
add rax, 1
cmp rax, rsi
jnz short loc_117E
loc_1191:
mov eax, edx
retn
loc_1194:
mov edx, 0FFFFFFFFh
jmp sho... | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // edx
if ( a2 <= 1 )
{
return (unsigned int)-1;
}
else
{
v2 = 1LL;
v3 = -1;
do
{
if ( *(_DWORD *)(a1 + 4 * v2) < *(_DWORD *)(a1 + 4 * v2 - 4) )
v3 = v2;
++v2;
}
while ( v2 != a2... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101194
MOV ESI,ESI
MOV EAX,0x1
MOV EDX,0xffffffff
LAB_0010117e:
MOV ECX,dword ptr [RDI + RAX*0x4 + -0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
CMOVL EDX,EAX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x0010117e
LAB_00101191:
MOV EAX,EDX
RET
LAB_00101194:
MOV EDX,0xffffffff
JMP 0x00101191 | ulong func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if ((int)param_2 < 2) {
uVar2 = 0xffffffff;
}
else {
uVar1 = 1;
uVar2 = 0xffffffff;
do {
if (*(int *)(param_1 + uVar1 * 4) < *(int *)(param_1 + -4 + uVar1 * 4)) {
uVar2 = uVar1 & 0xffffffff;
}
uVar... |
1,198 | func0 | #include <stdio.h>
| int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
} | #include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1280 <func0+0x40>
lea -0x2(%rsi),%edx
mov $0x1,%eax
mov $0xffffffff,%r8d
add $0x2,%rdx
nopl 0x0(%rax,%rax,1)
mov -0x4(%rdi,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
cmovl %eax,%r8d
add $0x1,%rax
cmp %rdx,%rax
jne 1260 <func0+0x20>
mov %r8d,%eax
retq
nopl... | func0:
endbr64
cmp esi, 1
jle short loc_1350
mov edx, [rdi]
mov esi, esi
mov eax, 1
mov ecx, 0FFFFFFFFh
nop word ptr [rax+rax+00000000h]
loc_1330:
mov r8d, edx
mov edx, [rdi+rax*4]
cmp r8d, edx
cmovg ecx, eax
add rax, 1
cmp rax, rsi
jnz short loc_1330
mov eax, e... | long long func0(int *a1, int a2)
{
int v2; // edx
long long v3; // rax
unsigned int v4; // ecx
int v5; // r8d
if ( a2 <= 1 )
return 0xFFFFFFFFLL;
v2 = *a1;
v3 = 1LL;
v4 = -1;
do
{
v5 = v2;
v2 = a1[v3];
if ( v5 > v2 )
v4 = v3;
++v3;
}
while ( v3 != a2 );
return v4;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101350
MOV EDX,dword ptr [RDI]
MOV ESI,ESI
MOV EAX,0x1
MOV ECX,0xffffffff
NOP word ptr [RAX + RAX*0x1]
LAB_00101330:
MOV R8D,EDX
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP R8D,EDX
CMOVG ECX,EAX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101330
MOV EAX,ECX
RET
LAB_00101350:
MOV ECX,0xffffffff
MOV EAX,... | ulong func0(int *param_1,uint param_2)
{
int *piVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
if (1 < (int)param_2) {
uVar2 = 1;
uVar3 = 0xffffffff;
iVar4 = *param_1;
do {
piVar1 = param_1 + uVar2;
if (*piVar1 < iVar4) {
uVar3 = uVar2 & 0xffffffff;
}
uVar2 = uV... |
1,199 | func0 | #include <stdio.h>
| int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
} | #include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1408 <func0+0x1a8>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%ecx
cmp $0x2,%eax
jbe 140e <func0+0x1ae>
mov %ecx,%edx
movdqa 0xdea(%rip),%xmm2
mov %rdi,%rax
pxor %xmm3,%xmm3
shr $0x2,%edx
movdqa 0xde8(%rip),%xmm4
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm0... | func0:
endbr64
cmp esi, 1
jle loc_12E8
lea eax, [rsi-2]
mov rcx, rdi
lea edi, [rsi-1]
cmp eax, 2
jbe loc_12EE
mov edx, edi
movdqa xmm2, cs:xmmword_2010
mov rax, rcx
pxor xmm3, xmm3
shr edx, 2
movdqa xmm4, cs:xmmword_2020
shl rdx, 4
add rdx, rcx
nop word ptr [rax+... | long long func0(long long a1, int a2)
{
int v3; // edi
__m128i si128; // xmm2
long long v5; // rax
__m128i v6; // xmm3
__m128i v7; // xmm4
__m128i v8; // xmm0
__m128i v9; // xmm5
__m128i v10; // xmm1
__m128i v11; // xmm0
__m128i v12; // xmm0
__m128i v13; // xmm1
__m128i v14; // xmm1
__m128i v... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012e8
LEA EAX,[RSI + -0x2]
MOV RCX,RDI
LEA EDI,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001012ee
MOV EDX,EDI
MOVDQA XMM2,xmmword ptr [0x00102010]
MOV RAX,RCX
PXOR XMM3,XMM3
SHR EDX,0x2
MOVDQA XMM4,xmmword ptr [0x00102020]
SHL RDX,0x4
ADD RDX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_00101188:
MOVDQ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int *piVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
... |
1,200 | func0 | #include <stdio.h>
| void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
r... | #include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1242 <func0+0xd9>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%e... | 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_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_1242
loc_1196:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ... | long long func0(long long a1, int a2, _DWORD *a3)
{
long long result; // rax
int v4; // [rsp+1Ch] [rbp-Ch]
unsigned int v5; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
v4 = 0;
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) < 0 && (!v4 || v4 < *(_DWORD *)(4LL * i + a1)) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101242
LAB_00101196:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qwor... | void func0(long param_1,int param_2,int *param_3)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(int *)(param_1 + (long)local_c * 4) < 0) &&
((local_14 == 0 || (local_14 < *(int *)(param_1 + (long)loc... |
1,201 | func0 | #include <stdio.h>
| void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
r... | #include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11b1 <func0+0x48>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r8
mov $0x0,%esi
mov $0x0,%edi
jmp 119f <func0+0x36>
cmp %edi,%eax
jg 1190 <func0+0x27>
test %edi,%edi
jne 1196 <func0+0x2d>
mov %eax,%edi
jmp 1196 <func0+0x2d>
mov %ea... | func0:
endbr64
test esi, esi
jle short loc_11BE
mov rcx, rdi
movsxd rsi, esi
lea r9, [rdi+rsi*4]
mov esi, 0
mov edi, 0
jmp short loc_11B4
loc_1187:
cmp edi, eax
mov r8d, eax
cmovge r8d, edi
test edi, edi
cmovnz eax, r8d
mov edi, eax
jmp short loc_11AB
loc_119A:
cmp e... | void func0(int *a1, int a2, int *a3)
{
int *v3; // rcx
int *v4; // r9
int v5; // esi
int v6; // edi
int v7; // r8d
int v8; // eax
int v9; // r8d
if ( a2 <= 0 )
{
v5 = 0;
v6 = 0;
}
else
{
v3 = a1;
v4 = &a1[a2];
v5 = 0;
v6 = 0;
do
{
v8 = *v3;
if ( *v3 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011be
MOV RCX,RDI
MOVSXD RSI,ESI
LEA R9,[RDI + RSI*0x4]
MOV ESI,0x0
MOV EDI,0x0
JMP 0x001011b4
LAB_00101187:
CMP EDI,EAX
MOV R8D,EAX
CMOVGE R8D,EDI
TEST EDI,EDI
CMOVNZ EAX,R8D
MOV EDI,EAX
JMP 0x001011ab
LAB_0010119a:
CMP ESI,EAX
MOV R8D,EAX
CMOVLE R8D,ESI
TEST ESI,ESI
CMOVNZ EAX,R8D... | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
bool bVar6;
if (param_2 < 1) {
iVar3 = 0;
iVar4 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar3 = 0;
iVar4 = 0;
do {
iVar2 = *param_1;
if (iVar2 < 0) {
... |
1,202 | func0 | #include <stdio.h>
| void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
r... | #include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1620 <func0+0x50>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%r8
nopl 0x0(%rax)
mov (%rdi),%eax
test %eax,%eax
js 1610 <func0+0x40>
je 15fa <func0+0x2a>
test %ecx,%ecx
je 15f8 <func0+0x28>
cmp %ecx,%eax
jge 15fa <fun... | func0:
endbr64
test esi, esi
jle short loc_15A0
movsxd rsi, esi
xor ecx, ecx
lea r9, [rdi+rsi*4]
xor esi, esi
jmp short loc_1574
loc_1558:
jz short loc_156B
cmp ecx, eax
mov r8d, eax
cmovle r8d, ecx
test ecx, ecx
cmovnz eax, r8d
mov ecx, eax
loc_156B:
add rdi, 4
cmp ... | void func0(int *a1, int a2, int *a3)
{
int v3; // ecx
int *v4; // r9
int v5; // esi
int v6; // r8d
int v7; // eax
int v8; // r8d
if ( a2 <= 0 )
{
*a3 = 0;
a3[1] = 0;
}
else
{
v3 = 0;
v4 = &a1[a2];
v5 = 0;
do
{
while ( 1 )
{
v7 = *a1;
if ( *... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001015a0
MOVSXD RSI,ESI
XOR ECX,ECX
LEA R9,[RDI + RSI*0x4]
XOR ESI,ESI
JMP 0x00101574
LAB_00101558:
JZ 0x0010156b
CMP ECX,EAX
MOV R8D,EAX
CMOVLE R8D,ECX
TEST ECX,ECX
CMOVNZ EAX,R8D
MOV ECX,EAX
LAB_0010156b:
ADD RDI,0x4
CMP RDI,R9
JZ 0x00101594
LAB_00101574:
MOV EAX,dword ptr [RDI]
TEST... | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
bool bVar6;
if (param_2 < 1) {
*param_3 = 0;
param_3[1] = 0;
return;
}
iVar3 = 0;
piVar1 = param_1 + param_2;
iVar4 = 0;
do {
while( true ) {
iVar2 = *param_1;
... |
1,203 | func0 | #include <stdio.h>
| void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
r... | #include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert... | O3 | c | func0:
endbr64
test %esi,%esi
jle 15a0 <func0+0x50>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%r8
nopl 0x0(%rax)
mov (%rdi),%eax
test %eax,%eax
js 1590 <func0+0x40>
je 157a <func0+0x2a>
test %ecx,%ecx
je 1578 <func0+0x28>
cmp %ecx,%eax
jge 157a <fun... | func0:
endbr64
test esi, esi
jle short loc_1590
movsxd rsi, esi
xor ecx, ecx
lea r9, [rdi+rsi*4]
xor esi, esi
jmp short loc_1564
loc_1548:
jz short loc_155B
cmp ecx, eax
mov r8d, eax
cmovle r8d, ecx
test ecx, ecx
cmovnz eax, r8d
mov ecx, eax
loc_155B:
add rdi, 4
cmp ... | void func0(int *a1, int a2, int *a3)
{
int v3; // ecx
int *v4; // r9
int v5; // esi
int v6; // r8d
int v7; // eax
int v8; // r8d
if ( a2 <= 0 )
{
*a3 = 0;
a3[1] = 0;
}
else
{
v3 = 0;
v4 = &a1[a2];
v5 = 0;
do
{
while ( 1 )
{
v7 = *a1;
if ( *... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101590
MOVSXD RSI,ESI
XOR ECX,ECX
LEA R9,[RDI + RSI*0x4]
XOR ESI,ESI
JMP 0x00101564
LAB_00101548:
JZ 0x0010155b
CMP ECX,EAX
MOV R8D,EAX
CMOVLE R8D,ECX
TEST ECX,ECX
CMOVNZ EAX,R8D
MOV ECX,EAX
LAB_0010155b:
ADD RDI,0x4
CMP RDI,R9
JZ 0x00101584
LAB_00101564:
MOV EAX,dword ptr [RDI]
TEST... | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
bool bVar6;
if (param_2 < 1) {
*param_3 = 0;
param_3[1] = 0;
return;
}
iVar3 = 0;
piVar1 = param_1 + param_2;
iVar4 = 0;
do {
while( true ) {
iVar2 = *param_1;
... |
1,204 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3")... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strdup@plt>
mov %rax,-0x28(%rbp)
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strdu... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+s], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+nptr], rax
mov rax, [rbp+var_50]
mov rdi, rax; s
call _strdup
mov ... | const char * func0(const char *a1, const char *a2)
{
int i; // [rsp+18h] [rbp-38h]
int j; // [rsp+1Ch] [rbp-34h]
char *endptr; // [rsp+20h] [rbp-30h] BYREF
char *nptr; // [rsp+28h] [rbp-28h]
void *ptr; // [rsp+30h] [rbp-20h]
double v8; // [rsp+38h] [rbp-18h]
double v9; // [rsp+40h] [rbp-10h]
unsigned lo... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
... | char * func0(char *param_1,char *param_2)
{
long in_FS_OFFSET;
int local_40;
int local_3c;
char *local_38;
char *local_30;
char *local_28;
double local_20;
double local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = strdup(param_1);
local_28 = strdup(param_2);
for... |
1,205 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3")... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %rsi,%r13
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10d0 <strdup@plt>
mov %rax,%rbx
mov %r13,%rdi
callq 10d0 <strdup@plt>
mov %rax,%rbp
movzbl (%rbx),%edx
test %dl,%dl
je 12... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r13, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
call _strdup
mov rbx, rax
mov rdi, r12; s
call _strdup
mov rbp, rax
movzx edx, byte ptr [rbx]
test dl, dl
jz sh... | const char * func0(const char *a1, const char *a2)
{
char *v2; // rbx
char *v3; // rbp
char v4; // dl
char *v5; // rax
char v6; // dl
char *v7; // rax
const char *result; // rax
double v9; // [rsp+0h] [rbp-48h]
double v10; // [rsp+8h] [rbp-40h]
char *endptr[7]; // [rsp+10h] [rbp-38h] BYREF
endptr... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R13,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBX,RAX
MOV RDI,R12
CALL 0x001010f0
MOV RBP,RAX
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x00101241
MOV RAX,RBX
JMP 0x00101237
LAB_0010122c:
AD... | char * func0(char *param_1,char *param_2)
{
char cVar1;
char *__nptr;
char *__nptr_00;
char *pcVar2;
long in_FS_OFFSET;
double dVar3;
double dVar4;
char *local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__nptr = strdup(param_1);
__nptr_00 = strdup(param_2);
cVar1 = *__np... |
1,206 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3")... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10d0 <strdup@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10d0 <strdup@plt>
movzbl (%r12),%edx
mov %rax,%r13
test %dl,%... | func0:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strdup
mov rdi, r13; s
mov rbx, rax
call _strdup
movzx edx, byte ptr [rbx]
mov rbp, rax
t... | const char * func0(const char *a1, const char *a2)
{
char *v2; // rbx
char *v3; // rax
char v4; // dl
char *v5; // rbp
char *v6; // rax
char v7; // dl
char *v8; // rax
double v9; // r15
double v10; // xmm0_8
const char *result; // rax
char *endptr[9]; // [rsp+10h] [rbp-48h] BYREF
endptr[1] = (c... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RDI,R13
MOV RBX,RAX
CALL 0x001010f0
MOVZX EDX,byte ptr [RBX]
MOV RBP,RAX
TEST DL,DL
JZ 0x0010146c
MOV RAX,RBX
NOP dword ptr... | char * func0(char *param_1,char *param_2)
{
char *pcVar1;
char cVar2;
char *__nptr;
char *__nptr_00;
char *pcVar3;
long in_FS_OFFSET;
double dVar4;
double dVar5;
char *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__nptr = strdup(param_1);
__nptr_00 = strdup(param_2);... |
1,207 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3")... | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10d0 <strdup@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10d0 <strdup@plt>
movzbl (%r12),%edx
mov %rax,%r13
test %dl,%... | func0:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strdup
mov rdi, r13; s
mov rbx, rax
call _strdup
movzx edx, byte ptr [rbx]
mov rbp, rax
t... | const char * func0(const char *a1, const char *a2)
{
char *v2; // rbx
char *v3; // rax
char v4; // dl
char *v5; // rbp
char *v6; // rax
char v7; // dl
char *v8; // rax
double v9; // r15
double v10; // xmm0_8
const char *result; // rax
char *endptr[9]; // [rsp+10h] [rbp-48h] BYREF
endptr[1] = (c... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RDI,R13
MOV RBX,RAX
CALL 0x001010f0
MOVZX EDX,byte ptr [RBX]
MOV RBP,RAX
TEST DL,DL
JZ 0x0010146d
MOV RAX,RBX
NOP dword ptr... | char * func0(char *param_1,char *param_2)
{
char *pcVar1;
char *__nptr;
char *__nptr_00;
char *pcVar2;
char cVar3;
long in_FS_OFFSET;
double dVar4;
double dVar5;
char *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__nptr = strdup(param_1);
__nptr_00 = strdup(param_2);... |
1,208 | func0 | #include <stdio.h>
| int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 116b <func0+0x22>
cmpl $0x7,-0x4(%rbp)
jle 116b <func0+0x22>
mov $0x1,%eax
jmp 1170 <func0+0x27>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
jnz short loc_116B
cmp [rbp+var_4], 7
jle short loc_116B
mov eax, 1
jmp short loc_1170
loc_116B:
mov eax, 0
loc_1170:
pop rbp
retn | _BOOL8 func0(int a1)
{
return (a1 & 1) == 0 && a1 > 7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x0010116b
CMP dword ptr [RBP + -0x4],0x7
JLE 0x0010116b
MOV EAX,0x1
JMP 0x00101170
LAB_0010116b:
MOV EAX,0x0
LAB_00101170:
POP RBP
RET | int8 func0(uint param_1)
{
int8 uVar1;
if (((param_1 & 1) == 0) && (7 < (int)param_1)) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
1,209 | func0 | #include <stdio.h>
| int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
} | O1 | c | func0:
endbr64
mov %edi,%edx
xor $0x1,%edx
cmp $0x7,%edi
setg %al
movzbl %al,%eax
and %edx,%eax
retq
| func0:
endbr64
mov edx, edi
xor edx, 1
cmp edi, 7
setnle al
movzx eax, al
and eax, edx
retn | long long func0(int a1)
{
return ((unsigned __int8)a1 ^ 1u) & (a1 > 7);
} | func0:
ENDBR64
MOV EDX,EDI
XOR EDX,0x1
CMP EDI,0x7
SETG AL
MOVZX EAX,AL
AND EAX,EDX
RET | uint func0(uint param_1)
{
return (uint)(7 < (int)param_1) & (param_1 ^ 1);
} |
1,210 | func0 | #include <stdio.h>
| int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
} | O2 | c | func0:
endbr64
cmp $0x7,%edi
not %edi
setg %al
and %eax,%edi
movzbl %dil,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
cmp edi, 7
not edi
setnle al
and eax, edi
movzx eax, al
retn | long long func0(int a1)
{
return (unsigned __int8)~(_BYTE)a1 & (a1 > 7);
} | func0:
ENDBR64
CMP EDI,0x7
NOT EDI
SETG AL
AND EAX,EDI
MOVZX EAX,AL
RET | uint func0(uint param_1)
{
return (uint)(7 < (int)param_1) & ~param_1;
} |
1,211 | func0 | #include <stdio.h>
| int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
} | O3 | c | func0:
endbr64
cmp $0x7,%edi
not %edi
setg %al
and %eax,%edi
movzbl %dil,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
cmp edi, 7
not edi
setnle al
and eax, edi
movzx eax, al
retn | long long func0(int a1)
{
return (unsigned __int8)~(_BYTE)a1 & (a1 > 7);
} | func0:
ENDBR64
CMP EDI,0x7
NOT EDI
SETG AL
AND EAX,EDI
MOVZX EAX,AL
RET | uint func0(uint param_1)
{
return (uint)(7 < (int)param_1) & ~param_1;
} |
1,212 | func0 | #include <stdio.h>
| long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
} | #include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movq $0x1,-0x10(%rbp)
movq $0x1,-0x8(%rbp)
movl $0x1,-0x14(%rbp)
jmp 118f <func0+0x46>
mov -0x14(%rbp),%eax
cltq
mov -0x10(%rbp),%rdx
imul %rdx,%rax
mov %rax,-0x10(%rbp)
mov -0x8(%rbp),%rax
imul -0x10(%rbp),%rax
mov %rax,-0x... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_10], 1
mov [rbp+var_8], 1
mov [rbp+var_14], 1
jmp short loc_118F
loc_116D:
mov eax, [rbp+var_14]
cdqe
mov rdx, [rbp+var_10]
imul rax, rdx
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
imul rax, [rbp+var... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-14h]
long long v3; // [rsp+14h] [rbp-10h]
long long v4; // [rsp+1Ch] [rbp-8h]
v3 = 1LL;
v4 = 1LL;
for ( i = 1; i <= a1; ++i )
{
v3 *= i;
v4 *= v3;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x10],0x1
MOV qword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x14],0x1
JMP 0x0010118f
LAB_0010116d:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV RDX,qword ptr [RBP + -0x10]
IMUL RAX,RDX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ... | long func0(int param_1)
{
int4 local_1c;
int8 local_18;
int8 local_10;
local_18 = 1;
local_10 = 1;
for (local_1c = 1; local_1c <= param_1; local_1c = local_1c + 1) {
local_18 = local_1c * local_18;
local_10 = local_10 * local_18;
}
return local_10;
} |
1,213 | func0 | #include <stdio.h>
| long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
} | #include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
} | O1 | c | func0:
endbr64
test %edi,%edi
jle 117c <func0+0x33>
lea -0x1(%rdi),%esi
add $0x2,%rsi
mov $0x1,%eax
mov $0x1,%ecx
mov $0x1,%edx
imul %rax,%rdx
imul %rdx,%rcx
add $0x1,%rax
cmp %rsi,%rax
jne 1167 <func0+0x1e>
mov %rcx,%rax
retq
mov $0x1,%ecx
jmp 1178 <func0+0x2f>
| func0:
endbr64
test edi, edi
jle short loc_1178
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
loc_1163:
imul rdx, rax
imul rcx, rdx
add rax, 1
cmp rax, rsi
jnz short loc_1163
loc_1174:
mov rax, rcx
retn
loc_1178:
mov ecx, 1
jmp short loc_1174 | long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1;
v2 *= v3;
++v1;
}
while ( v1 != a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
LAB_00101163:
IMUL RDX,RAX
IMUL RCX,RDX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101163
LAB_00101174:
MOV RAX,RCX
RET
LAB_00101178:
MOV ECX,0x1
JMP 0x00101174 | long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (param_1 < 1) {
lVar2 = 1;
}
else {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
lVar2 = lVar2 * lVar3;
uVar1 = uVar1 + 1;
} while (uVar1 != param_1 + 1);
}
return lVar2;
} |
1,214 | func0 | #include <stdio.h>
| long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
} | #include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
} | O2 | c | func0:
endbr64
test %edi,%edi
jle 11e8 <func0+0x38>
lea -0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%edx
add $0x2,%rcx
imul %rax,%rdx
add $0x1,%rax
imul %rdx,%r8
cmp %rcx,%rax
jne 11d0 <func0+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov $0x1,%r8d
mov %r8,%rax
retq
nopw ... | func0:
endbr64
test edi, edi
jle short loc_11E8
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
nop word ptr [rax+rax+00h]
loc_11D0:
imul rdx, rax
add rax, 1
imul rcx, rdx
cmp rax, rsi
jnz short loc_11D0
mov rax, rcx
retn
loc_11E8:
mov ecx, 1
mov rax, rcx
retn | long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1++;
v2 *= v3;
}
while ( v1 != a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011e8
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001011d0:
IMUL RDX,RAX
ADD RAX,0x1
IMUL RCX,RDX
CMP RAX,RSI
JNZ 0x001011d0
MOV RAX,RCX
RET
LAB_001011e8:
MOV ECX,0x1
MOV RAX,RCX
RET | long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (0 < param_1) {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
uVar1 = uVar1 + 1;
lVar2 = lVar2 * lVar3;
} while (uVar1 != param_1 + 1);
return lVar2;
}
return 1;
} |
1,215 | func0 | #include <stdio.h>
| long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
} | #include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
} | O3 | c | func0:
endbr64
test %edi,%edi
jle 1178 <func0+0x38>
lea -0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%edx
add $0x2,%rcx
imul %rax,%rdx
add $0x1,%rax
imul %rdx,%r8
cmp %rcx,%rax
jne 1160 <func0+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov $0x1,%r8d
mov %r8,%rax
retq
nopw ... | func0:
endbr64
test edi, edi
jle short loc_1178
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
nop word ptr [rax+rax+00h]
loc_1160:
imul rdx, rax
add rax, 1
imul rcx, rdx
cmp rax, rsi
jnz short loc_1160
mov rax, rcx
retn
loc_1178:
mov ecx, 1
mov rax, rcx
retn | long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1++;
v2 *= v3;
}
while ( v1 != a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
IMUL RDX,RAX
ADD RAX,0x1
IMUL RCX,RDX
CMP RAX,RSI
JNZ 0x00101160
MOV RAX,RCX
RET
LAB_00101178:
MOV ECX,0x1
MOV RAX,RCX
RET | long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (0 < param_1) {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
uVar1 = uVar1 + 1;
lVar2 = lVar2 * lVar3;
} while (uVar1 != param_1 + 1);
return lVar2;
}
return 1;
} |
1,216 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Y... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 1290 <func0+0xe7>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_1290
loc_11D8:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte pt... | _BYTE * func0(const char *a1, long long a2)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
_BYTE *result; // rax
int v10; // [rsp+14h] [rbp-1Ch]
int v11; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v10 = 0;
v11 = 0;
for ( ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101290
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -... | void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= (ulong)(long)local_1c) break;
if (param_1[local_1c] == ' ') {
local_24 = loc... |
1,217 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Y... | O1 | c | func0:
endbr64
mov %rdi,%r9
mov $0x0,%r8d
mov $0x0,%edx
mov $0x0,%r10d
mov $0xffffffffffffffff,%r11
mov $0x0,%eax
jmp 11c6 <func0+0x5d>
add $0x1,%r10d
jmp 11c2 <func0+0x59>
lea 0x1(%rdx),%ecx
movslq %edx,%rdx
movb $0x5f,(%rsi,%rdx,1)
jmp 11ad <func0+0x44>
jle 1203 <func0+0x9a>
lea ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13, rsi
mov ebp, 0
mov ebx, 0
mov r14d, 0
jmp short loc_1208
loc_11CD:
add r14d, 1
jmp short loc_1204
loc_11D3:
lea eax, [rbx+1]
movsxd rbx, ebx
mov byte ptr [r13+rbx+0], 5Fh ; '_'
jmp ... | long long func0(char *s, long long a2)
{
size_t v2; // rbp
int v3; // ebx
int v4; // r14d
int v5; // eax
long long result; // rax
v2 = 0LL;
v3 = 0;
v4 = 0;
while ( v2 < strlen(s) )
{
if ( s[v2] == 32 )
{
++v4;
}
else
{
if ( v4 == 1 )
{
v5 = v3 + 1;
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13,RSI
MOV EBP,0x0
MOV EBX,0x0
MOV R14D,0x0
JMP 0x00101208
LAB_001011cd:
ADD R14D,0x1
JMP 0x00101204
LAB_001011d3:
LEA EAX,[RBX + 0x1]
MOVSXD RBX,EBX
MOV byte ptr [R13 + RBX*0x1],0x5f
JMP 0x001011ef
LAB_001011e1:
JLE 0x00101242
LEA EAX,[RBX + ... | void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
iVar1 = 0;
iVar4 = 0;
for (uVar3 = 0; sVar2 = strlen(param_1), uVar3 < sVar2; uVar3 = uVar3 + 1) {
if (param_1[uVar3] == ' ') {
iVar4 = iVar4 + 1;
}
else {
if (iVar4 == 1) {
*(int ... |
1,218 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Y... | O2 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
xor %r12d,%r12d
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
callq 1070 <strlen@plt>
xor %edx,%edx
xor %ecx,%ecx
jmp 13da <func0+0x6a>
nopl 0x0(%rax)
lea 0x1(%r12),%ecx
movslq %ecx,%rax
add %r13,%rax
cmp $0x1,%... | func0:
endbr64
push r15
xor r15d, r15d
push r14
xor r14d, r14d
push r13
mov r13, rdi
push r12
xor r12d, r12d
push rbp
mov rbp, rsi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_13C0
loc_1388:
lea eax, [r15+1]
cmp r12d, 1
jz short loc_13E8
cmp r12d, 2
j... | size_t func0(char *s, long long a2)
{
int v2; // r15d
long long v3; // r14
int v4; // r12d
unsigned long long i; // rbx
int v7; // eax
char v8; // dl
size_t result; // rax
_BYTE *v10; // rsi
v2 = 0;
v3 = 0LL;
v4 = 0;
for ( i = 0LL; ; ++i )
{
result = strlen(s);
v10 = (_BYTE *)(a2 + v... | func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
XOR R14D,R14D
PUSH R13
MOV R13,RDI
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RSI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001013c0
LAB_00101388:
LEA EAX,[R15 + 0x1]
CMP R12D,0x1
JZ 0x001013e8
CMP R12D,0x2
JNZ 0x001013f8
MOVZX ECX,word ptr [0x00102194]
LEA EAX,[R15 + 0x2]
MOV w... | void func0(char *param_1,long param_2)
{
int2 *puVar1;
int iVar2;
size_t sVar3;
char cVar4;
ulong uVar5;
int iVar6;
long lVar7;
iVar2 = 0;
lVar7 = 0;
iVar6 = 0;
uVar5 = 0;
while( true ) {
sVar3 = strlen(param_1);
puVar1 = (int2 *)(param_2 + lVar7);
if (sVar3 <= uVar5) break;
... |
1,219 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
... | #include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Y... | O3 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %rax,%rax
je 1460 <func0+0xf0>
mov %r13,%rsi
xor %ebx,%ebx
xor %ebp,%ebp
xor %edx,%edx
jmp 13e7 <func0+0x77>
nopl (%rax)
lea 0x1(%rbp),%ecx
movslq %ec... | func0:
endbr64
push r15
xor r15d, r15d
push r14
xor r14d, r14d
push r13
mov r13, rdi
push r12
xor r12d, r12d
push rbp
mov rbp, rsi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_13C0
loc_1388:
lea eax, [r15+1]
cmp r12d, 1
jz short loc_13E8
cmp r12d, 2
j... | size_t func0(char *s, long long a2)
{
int v2; // r15d
long long v3; // r14
int v4; // r12d
unsigned long long i; // rbx
int v7; // eax
char v8; // dl
size_t result; // rax
_BYTE *v10; // rsi
v2 = 0;
v3 = 0LL;
v4 = 0;
for ( i = 0LL; ; ++i )
{
result = strlen(s);
v10 = (_BYTE *)(a2 + v... | func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
XOR R14D,R14D
PUSH R13
MOV R13,RDI
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RSI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001013c0
LAB_00101388:
LEA EAX,[R15 + 0x1]
CMP R12D,0x1
JZ 0x001013e8
CMP R12D,0x2
JNZ 0x001013f8
MOVZX ECX,word ptr [0x00102194]
LEA EAX,[R15 + 0x2]
MOV w... | void func0(char *param_1,long param_2)
{
int2 *puVar1;
int iVar2;
size_t sVar3;
char cVar4;
ulong uVar5;
int iVar6;
long lVar7;
iVar2 = 0;
lVar7 = 0;
iVar6 = 0;
uVar5 = 0;
while( true ) {
sVar3 = strlen(param_1);
puVar1 = (int2 *)(param_2 + lVar7);
if (sVar3 <= uVar5) break;
... |
1,220 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0xc(%rbp)
cmpl $0x4,-0xc(%rbp)
jg 11c8 <func0+0x3f>
lea 0xe45(%rip),%rax
jmpq 12cd <func0+0x144>... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
cmp [rbp+var_C], 4
jg short loc_11C8
lea rax, aNo; "No"
jmp locret_12D6
loc_11C8:
mov r... | const char * func0(const char *a1)
{
char v2; // [rsp+17h] [rbp-19h]
int v3; // [rsp+18h] [rbp-18h]
int v4; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v6; // [rsp+24h] [rbp-Ch]
char *s1; // [rsp+28h] [rbp-8h]
v3 = 0;
v4 = 0;
v6 = strlen(a1);
if ( v6 <= 4 )
return "No";
v2 = *a1;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0x4
JG 0x001011c8
LEA RAX,[0x102008]
JMP 0x001012d6
LAB_0... | int * func0(char *param_1)
{
char cVar1;
int iVar2;
int iVar3;
size_t sVar4;
int *puVar5;
char *__s1;
int local_20;
int local_1c;
int local_18;
local_20 = 0;
local_1c = 0;
sVar4 = strlen(param_1);
iVar2 = (int)sVar4;
if (iVar2 < 5) {
puVar5 = &DAT_00102008;
}
else {
cVar1 = *... |
1,221 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
... | O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
lea 0xe95(%rip),%rdx
cmp $0x4,%eax
jle 124f <func0+0x106>
movzbl (%r8),%edx
lea -0x5b(%rdx),%ecx
cmp $0x5,%cl
jbe 1248 <func0+0xff>
sub $0x41,%edx
... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
mov rbp, rax
lea rax, aNo; "No"
cmp ebp, 4
jle loc_126C
movzx eax, byte ptr [rbx]
lea edx, [rax-5Bh]
cmp dl, 5
jbe loc_1265
sub eax, 41h ; 'A'
cmp al, 39h ; '9'
ja loc_1265
movsxd rax, ebp
lea... | const char * func0(const char *a1)
{
int v2; // ebp
const char *result; // rax
int v4; // edx
const char *v5; // rax
int v6; // edi
int v7; // esi
v2 = strlen(a1);
result = "No";
if ( v2 > 4 )
{
if ( (unsigned __int8)(*a1 - 91) <= 5u || (unsigned __int8)(*a1 - 65) > 0x39u )
{
return "... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x00101070
MOV RBP,RAX
LEA RAX,[0x102004]
CMP EBP,0x4
JLE 0x0010126c
MOVZX EAX,byte ptr [RBX]
LEA EDX,[RAX + -0x5b]
CMP DL,0x5
JBE 0x00101265
SUB EAX,0x41
CMP AL,0x39
JA 0x00101265
MOVSXD RAX,EBP
LEA R12,[RBX + RAX*0x1 + -0x4]
LEA RSI,[0x102153]
MOV RDI,R12
CAL... | int * func0(char *param_1)
{
char *pcVar1;
int iVar2;
size_t sVar3;
int *puVar4;
int iVar5;
sVar3 = strlen(param_1);
puVar4 = &DAT_00102004;
iVar5 = (int)sVar3;
if (4 < iVar5) {
if (((byte)(*param_1 + 0xa5U) < 6) || (0x39 < (byte)(*param_1 + 0xbfU))) {
puVar4 = &DAT_00102004;
}
e... |
1,222 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
... | O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
lea 0x810(%rip),%r8
cmp $0x4,%eax
jle 188b <func0+0xab>
movzbl (%rbx),%edx
lea -0x5b(%rdx),%ecx
cmp $0x5,%cl
jbe 1890 <func0+0xb0>
sub $0x41,%edx
cmp $0x39,%dl
ja 1890 <func0+0xb0>
movslq %eax,%rdx
mov $0x5,%ecx
lea 0... | func0:
endbr64
push r13
push r12
lea r12, unk_2004
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
cmp eax, 4
jle loc_187C
mov rbp, rax
movzx eax, byte ptr [rbx]
lea edx, [rax-5Bh]
cmp dl, 5
jbe loc_1890
sub eax, 41h ; 'A'
cmp al, 39h ; '9'
ja loc... | const char * func0(const char *a1)
{
const char *v1; // r12
int v3; // eax
int v4; // ebp
const char *v5; // rax
int v6; // edi
int v7; // esi
long long v8; // r8
char v9; // dl
v1 = (const char *)&unk_2004;
v3 = strlen(a1);
if ( v3 <= 4 )
return v1;
v4 = v3;
if ( (unsigned __int8)(*a1 - ... | func0:
ENDBR64
PUSH R13
PUSH R12
LEA R12,[0x102004]
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
CMP EAX,0x4
JLE 0x0010187c
MOV RBP,RAX
MOVZX EAX,byte ptr [RBX]
LEA EDX,[RAX + -0x5b]
CMP DL,0x5
JBE 0x00101890
SUB EAX,0x41
CMP AL,0x39
JA 0x00101890
MOVSXD RAX,EBP
LEA RSI,[0x102153]
LEA R13,[RBX + RAX*0x1 + ... | int * func0(char *param_1)
{
char *pcVar1;
char cVar2;
int iVar3;
int iVar4;
size_t sVar5;
int iVar6;
int *puVar7;
puVar7 = &DAT_00102004;
sVar5 = strlen(param_1);
iVar3 = (int)sVar5;
if (4 < iVar3) {
if (((byte)(*param_1 + 0xa5U) < 6) || (0x39 < (byte)(*param_1 + 0xbfU))) {
LAB_00101890:
... |
1,223 | func0 | #include <stdio.h>
#include <string.h>
| const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
... | O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
lea 0x810(%rip),%r9
cmp $0x4,%eax
jle 1c8f <func0+0x4af>
movzbl (%rbx),%edx
lea -0x5b(%rdx),%ecx
cmp $0x5,%cl
jbe 1c88 <func0+0x4a8>
lea -0x41(%rdx),%ecx
cmp $0x39,%cl
ja 1c88 <func0+0x4a8>
movslq %eax,%rcx
lea 0x931(%ri... | func0:
endbr64
push r13
push r12
lea r12, unk_2004
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
cmp eax, 4
jle loc_1C31
mov rbp, rax
movzx eax, byte ptr [rbx]
lea edx, [rax-5Bh]
cmp dl, 5
jbe loc_1C40
sub eax, 41h ; 'A'
cmp al, 39h ; '9'
ja loc... | const char * func0(const char *a1)
{
const char *v1; // r12
int v3; // eax
int v4; // ebp
__m128i v5; // xmm2
const __m128i *v6; // rax
__m128 v7; // xmm3
__m128i si128; // xmm9
__m128i v9; // xmm7
__m128i v10; // xmm8
__m128 v11; // xmm6
__m128i v12; // xmm0
__m128i v13; // xmm10
__m128i v14;... | func0:
ENDBR64
PUSH R13
PUSH R12
LEA R12,[0x102004]
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
CMP EAX,0x4
JLE 0x00101c31
MOV RBP,RAX
MOVZX EAX,byte ptr [RBX]
LEA EDX,[RAX + -0x5b]
CMP DL,0x5
JBE 0x00101c40
SUB EAX,0x41
CMP AL,0x39
JA 0x00101c40
MOVSXD RAX,EBP
LEA RSI,[0x102153]
LEA R13,[RBX + RAX*0x1 + ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int * func0(char *param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12;
bool bVar13;
bool bVar14;
b... |
1,224 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
} | #include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(ls... | 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)
jmpq 1260 <func0+0xf7>
mov -0x4(%rbp),%ecx
movslq %ecx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %rax,%rdx
mov %ecx,%eax
sar $0x1f,%eax
mov %edx,%esi
s... | 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 loc_125C
loc_118B:
mov ecx, [rbp+var_4]
movsxd rax, ecx
imul rax, 55555556h
shr rax, 20h
mov rdx, rax
mov eax, ecx
sar eax, 1Fh
sub edx, eax
m... | long long func0(long long a1, int a2)
{
int v2; // eax
unsigned int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( i % 3 )
{
if ( (i & 3) != 0 )
v2 = *(_DWORD *)(4LL * i + a1);
else
v2 = *(_DWORD *)(4LL * i + a1) * *(_DW... | 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 0x0010125c
LAB_0010118b:
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV RDX,RAX
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,E... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; (int)local_c < param_2; local_c = local_c + 1) {
if ((int)local_c % 3 == 0) {
local_10 = local_10 +
*(int *)(param_1 + (long)(int)local_c * 4) *
*(int *)(param_1 + (... |
1,225 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
} | #include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(ls... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11ca <func0+0x61>
lea -0x1(%rsi),%r8d
mov $0x0,%edx
mov $0x0,%ecx
jmp 119f <func0+0x36>
test $0x3,%dl
jne 11c5 <func0+0x5c>
mov (%rdi,%rdx,4),%esi
mov %esi,%eax
imul %esi,%eax
imul %esi,%eax
add %eax,%ecx
lea 0x1(%rdx),%rax
cmp %r8,%rdx
je 1... | func0:
endbr64
mov r8, rdi
test esi, esi
jle short loc_11CC
movsxd rsi, esi
mov edx, 0
mov ecx, 0
jmp short loc_119F
loc_1183:
test dl, 3
jnz short loc_11C6
mov edi, [r8+rdx*4]
mov eax, edi
imul eax, edi
imul eax, edi
add ecx, eax
loc_1196:
add rdx, 1
cmp rdx, rs... | long long func0(long long a1, int a2)
{
long long v2; // rdx
unsigned int v3; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 0LL;
v3 = 0;
do
{
if ( 3 * ((int)v2 / 3) == (_DWORD)v2 )
{
v3 += *(_DWORD *)(a1 + 4 * v2) * *(_DWORD *)(a1 + 4 * v2);
}
else i... | func0:
ENDBR64
MOV R8,RDI
TEST ESI,ESI
JLE 0x001011cc
MOVSXD RSI,ESI
MOV EDX,0x0
MOV ECX,0x0
JMP 0x0010119f
LAB_00101183:
TEST DL,0x3
JNZ 0x001011c6
MOV EDI,dword ptr [R8 + RDX*0x4]
MOV EAX,EDI
IMUL EAX,EDI
IMUL EAX,EDI
ADD ECX,EAX
LAB_00101196:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x001011d1
LAB_0010119f:
MOVSXD RAX,EDX
IMUL RA... | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
ulong uVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
uVar3 = 0;
iVar2 = 0;
do {
if (((int)uVar3 / 3) * 3 == (int)uVar3) {
iVar1 = *(int *)(param_1 + uVar3 * 4);
iVar2 = iVar2 + iVar1 * iVar1;
}
e... |
1,226 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
} | #include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(ls... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1628 <func0+0x68>
sub $0x1,%esi
xor %eax,%eax
xor %r8d,%r8d
jmp 15ea <func0+0x2a>
nopw 0x0(%rax,%rax,1)
imul %edx,%edx
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 1613 <func0+0x53>
mov %rdx,%rax
imul $0xaaaaaaab,%eax,%ecx
mov (%rdi,%rax,4... | func0:
endbr64
test esi, esi
jle short loc_1540
movsxd rsi, esi
xor eax, eax
xor ecx, ecx
jmp short loc_1506
loc_14F8:
imul edx, edx
add ecx, edx
loc_14FD:
add rax, 1
cmp rax, rsi
jz short loc_1531
loc_1506:
imul edx, eax, 0AAAAAAABh
cmp edx, 55555555h
mov edx, [rdi+ra... | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // ecx
int v4; // edx
if ( a2 > 0 )
{
v2 = 0LL;
v3 = 0;
while ( 1 )
{
while ( 1 )
{
v4 = *(_DWORD *)(a1 + 4 * v2);
if ( (unsigned int)(-1431655765 * v2) > 0x55555555 )
break;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101540
MOVSXD RSI,ESI
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101506
LAB_001014f8:
IMUL EDX,EDX
ADD ECX,EDX
LAB_001014fd:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101531
LAB_00101506:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
MOV EDX,dword ptr [RDI + RAX*0x4]
JBE 0x001014f8
TEST AL,0x3
JNZ 0x0010153... | int func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
uVar1 = 0;
iVar2 = 0;
do {
iVar3 = *(int *)(param_1 + uVar1 * 4);
if ((uint)((int)uVar1 * -0x55555555) < 0x55555556) {
iVar3 = iVar3 * iVar3;
}
else if ((uVar1 & 3) == 0) {... |
1,227 | func0 | #include <stdio.h>
| int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
} | #include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(ls... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1558 <func0+0x68>
sub $0x1,%esi
xor %eax,%eax
xor %r8d,%r8d
jmp 151a <func0+0x2a>
nopw 0x0(%rax,%rax,1)
imul %edx,%edx
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 1543 <func0+0x53>
mov %rdx,%rax
imul $0xaaaaaaab,%eax,%ecx
mov (%rdi,%rax,4... | func0:
endbr64
test esi, esi
jle short loc_1540
movsxd rsi, esi
xor eax, eax
xor ecx, ecx
jmp short loc_1506
loc_14F8:
imul edx, edx
add ecx, edx
loc_14FD:
add rax, 1
cmp rsi, rax
jz short loc_1531
loc_1506:
imul edx, eax, 0AAAAAAABh
cmp edx, 55555555h
mov edx, [rdi+ra... | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // ecx
int v4; // edx
if ( a2 > 0 )
{
v2 = 0LL;
v3 = 0;
while ( 1 )
{
while ( 1 )
{
v4 = *(_DWORD *)(a1 + 4 * v2);
if ( (unsigned int)(-1431655765 * v2) > 0x55555555 )
break;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101540
MOVSXD RSI,ESI
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101506
LAB_001014f8:
IMUL EDX,EDX
ADD ECX,EDX
LAB_001014fd:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101531
LAB_00101506:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
MOV EDX,dword ptr [RDI + RAX*0x4]
JBE 0x001014f8
TEST AL,0x3
JNZ 0x0010153... | int func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
uVar1 = 0;
iVar2 = 0;
do {
iVar3 = *(int *)(param_1 + uVar1 * 4);
if ((uint)((int)uVar1 * -0x55555555) < 0x55555556) {
iVar3 = iVar3 * iVar3;
}
else if ((uVar1 & 3) == 0) {... |
1,228 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
... | #include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 129d <func0+0xf4>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_4], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_129D
loc_11DE:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
m... | _BYTE * func0(long long a1, long long a2)
{
int v2; // eax
int v3; // eax
_BYTE *result; // rax
char v5; // [rsp+1Bh] [rbp-15h]
char v6; // [rsp+1Bh] [rbp-15h]
int v7; // [rsp+1Ch] [rbp-14h]
int v8; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int j; // [rsp+28h] [rbp-8h]
int k; // [rsp+28h] ... | 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 + -0x4],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010129d
LAB_001011de:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RA... | void func0(long param_1,long param_2)
{
bool bVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
local_1c = 0;
local_18 = 0;
for (local_14 = 0; *(char *)(param_1 + local_14) != '\0'; local_14 = local_14 + 1) {
if (*(char *)(param_1 + local_14) == ' ') {
if (local_1c < 2) {
... |
1,229 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
... | #include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rsi,%r14
movzbl (%rdi),%eax
test %al,%al
je 123a <func0+0xb1>
mov %rdi,%r12
mov $0x0,%r13d
mov $0x0,%ebx
mov $0x0,%ebp
jmp 11c8 <func0+0x3f>
add $0x1,%ebx
add $0x1,%rbp
movzbl (%r12,%rbp,1),%eax
test %al,%al
... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rsi
movzx eax, byte ptr [rdi]
test al, al
jz loc_12BD
mov r12, rdi
mov r13d, 0
mov ebx, 0
mov ebp, 0
jmp short loc_11EF
loc_11D8:
cmp ebx, 1
jg short loc_11F8
mov ebx, 0
loc_11E2:
add r... | unsigned long long func0(unsigned __int8 *a1, long long a2)
{
unsigned long long result; // rax
int v3; // r13d
int v4; // ebx
long long v5; // rbp
int v6; // ecx
int v7; // ecx
result = *a1;
if ( !(_BYTE)result )
{
v3 = 0;
goto LABEL_28;
}
v3 = 0;
v4 = 0;
v5 = 0LL;
do
{
if (... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RSI
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001012bd
MOV R12,RDI
MOV R13D,0x0
MOV EBX,0x0
MOV EBP,0x0
JMP 0x001011ef
LAB_001011d8:
CMP EBX,0x1
JG 0x001011f8
MOV EBX,0x0
LAB_001011e2:
ADD RBP,0x1
MOVZX EAX,byte ptr [R12 + RBP*0x1]
TEST AL,AL
JZ 0x00101... | void * func0(byte *param_1,long param_2)
{
void *pvVar1;
int iVar2;
uint uVar3;
long lVar4;
int iVar5;
pvVar1 = (void *)(ulong)*param_1;
if (*param_1 == 0) {
iVar5 = 0;
}
else {
iVar5 = 0;
uVar3 = 0;
lVar4 = 0;
do {
if ((char)pvVar1 == ' ') {
if ((int)uVar3 < 2) {... |
1,230 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
... | #include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%eax
test %al,%al
je 1482 <func0+0xc2>
mov %rdi,%rbp
xor %r13d,%r13d
xor %ecx,%ecx
xor %ebx,%ebx
jmp 1400 <func0+0x40>
nopl 0x0(%rax,%rax,1)
add $0x1,%ecx
add $0x1,%rbx
movzbl 0x0(... | func0:
endbr64
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
movzx eax, byte ptr [rdi]
test al, al
jz loc_1471
mov r13, rdi
xor r14d, r14d
xor ebx, ebx
xor ebp, ebp
jmp short loc_13F1
loc_13E0:
add ebx, 1
loc_13E3:
add rbp, 1
movzx eax, byte ptr [r1... | unsigned long long func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // r12
unsigned long long result; // rax
int v5; // r14d
int v6; // ebx
long long v7; // rbp
long long v8; // rdi
int v9; // ecx
int v10; // ecx
long long v11; // rax
size_t v12; // rdx
long long v13; // rdi
long long v14; //... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101471
MOV R13,RDI
XOR R14D,R14D
XOR EBX,EBX
XOR EBP,EBP
JMP 0x001013f1
LAB_001013e0:
ADD EBX,0x1
LAB_001013e3:
ADD RBP,0x1
MOVZX EAX,byte ptr [R13 + RBP*0x1]
TEST AL,AL
JZ 0x0010140e
LAB_001013f1:
CMP AL,... | void * func0(byte *param_1,int *param_2)
{
void *pvVar1;
int iVar2;
size_t __n;
uint uVar3;
long lVar4;
int *puVar5;
long lVar6;
int iVar7;
pvVar1 = (void *)(ulong)*param_1;
puVar5 = param_2;
if (*param_1 != 0) {
iVar7 = 0;
uVar3 = 0;
lVar6 = 0;
do {
while (lVar4 = lVar6,... |
1,231 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
... | #include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output... | O3 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%eax
test %al,%al
je 1482 <func0+0xc2>
mov %rdi,%rbp
xor %r13d,%r13d
xor %ecx,%ecx
xor %ebx,%ebx
jmp 1400 <func0+0x40>
nopl 0x0(%rax,%rax,1)
add $0x1,%ecx
add $0x1,%rbx
movzbl 0x0(... | func0:
endbr64
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
movzx eax, byte ptr [rdi]
test al, al
jz loc_1471
mov r13, rdi
xor r14d, r14d
xor ebx, ebx
xor ebp, ebp
jmp short loc_13F1
loc_13E0:
add ebx, 1
loc_13E3:
add rbp, 1
movzx eax, byte ptr [r1... | unsigned long long func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // r12
unsigned long long result; // rax
int v5; // r14d
int v6; // ebx
long long v7; // rbp
long long v8; // rdi
int v9; // ecx
int v10; // ecx
long long v11; // rax
size_t v12; // rdx
long long v13; // rdi
long long v14; //... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101471
MOV R13,RDI
XOR R14D,R14D
XOR EBX,EBX
XOR EBP,EBP
JMP 0x001013f1
LAB_001013e0:
ADD EBX,0x1
LAB_001013e3:
ADD RBP,0x1
MOVZX EAX,byte ptr [R13 + RBP*0x1]
TEST AL,AL
JZ 0x0010140e
LAB_001013f1:
CMP AL,... | void * func0(byte *param_1,int *param_2)
{
void *pvVar1;
int iVar2;
size_t __n;
uint uVar3;
long lVar4;
int *puVar5;
long lVar6;
int iVar7;
pvVar1 = (void *)(ulong)*param_1;
puVar5 = param_2;
if (*param_1 != 0) {
iVar7 = 0;
uVar3 = 0;
lVar6 = 0;
do {
while (lVar4 = lVar6,... |
1,232 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);... | #include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(fun... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x110,%rsp
mov %rdi,-0x108(%rbp)
mov %rsi,-0x110(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0xf8(%rbp)
jmp 11ed <func0+0x64>
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x108(%rbp),%rax
add %rdx,%rax
movzbl (%rax),... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 110h
mov [rbp+var_108], rdi
mov [rbp+var_110], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_F8], 0
jmp short loc_11ED
loc_11C1:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_108]
add rax, rd... | _BOOL8 func0(long long a1, long long a2)
{
int i; // [rsp+18h] [rbp-F8h]
int j; // [rsp+18h] [rbp-F8h]
int k; // [rsp+18h] [rbp-F8h]
int m; // [rsp+18h] [rbp-F8h]
int v7; // [rsp+1Ch] [rbp-F4h]
int v8; // [rsp+1Ch] [rbp-F4h]
int v9; // [rsp+20h] [rbp-F0h]
int v10; // [rsp+24h] [rbp-ECh]
int v11; // [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
MOV qword ptr [RBP + -0x108],RDI
MOV qword ptr [RBP + -0x110],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xf8],0x0
JMP 0x001011ed
LAB_001011c1:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + ... | bool func0(long param_1,long param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
int local_100;
int local_fc;
char local_e8 [112];
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
for (local_100 = 0; *(char *)(param_1 + local_100) != '/'; l... |
1,233 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);... | #include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(fun... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xe0,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0xd8(%rsp)
xor %eax,%eax
movzbl (%rdi),%edx
cmp $0x2f,%dl
je 131d <func0+0x194>
mov $0x1,%eax
lea -0x1(%rsp),%rcx
mov %dl,(%rcx,%rax,1)
mov ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0E0h
mov rbp, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+108h+var_30], rax
xor eax, eax
movzx edx, byte ptr [rdi]
cmp dl, 2Fh ; '/'
jz loc_1320
mov eax, 1
lea rcx, [rsp+108h+var_109]
loc_11CB:
m... | _BOOL8 func0(char *a1, char *a2)
{
char v2; // dl
long long v3; // rax
int v4; // r13d
int v5; // r12d
char v6; // al
long long v7; // rdx
int v8; // ecx
int v9; // r13d
char v10; // al
long long v11; // rdx
int v12; // ebp
int v13; // r14d
char v14; // al
long long v15; // rdx
int v16; /... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xe0
MOV RBP,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
XOR EAX,EAX
MOVZX EDX,byte ptr [RDI]
CMP DL,0x2f
JZ 0x00101320
MOV EAX,0x1
LEA RCX,[RSP + -0x1]
LAB_001011cb:
MOV byte ptr [RCX + RAX*0x1],DL
MOV R13,RAX
ADD RAX,0x... | bool func0(char *param_1,char *param_2)
{
long lVar1;
long lVar2;
int iVar3;
char cVar4;
long lVar5;
long lVar6;
int iVar7;
long in_FS_OFFSET;
int8 uStack_110;
char local_108 [111];
char local_99 [105];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
cVar4 = *param_1;
if (cVa... |
1,234 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);... | #include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(fun... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0xf8,%rsp
movzbl (%rdi),%edx
mov %fs:0x28,%rax
mov %rax,0xe8(%rsp)
xor %eax,%eax
cmp $0x2f,%dl
je 1648 <func0+0x1b8>
mov $0x1,%eax
lea 0xf(%rsp),%rdi
nopl 0x0(%rax)
mo... | func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0F8h
movzx edx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
cmp dl, 2Fh ; '/'
jz loc_1650
mov eax, 1
lea rcx, [rsp+128h+var_119]... | _BOOL8 func0(char *a1, char *a2)
{
char v3; // dl
long long v4; // rax
int v5; // esi
int v6; // r12d
long long v7; // rax
long long v8; // r15
int v9; // ebp
char v10; // al
long long v11; // rdx
int v12; // ecx
int v13; // ebx
char v14; // al
long long v15; // rdx
int v16; // esi
int v1... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xf8
MOVZX EDX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
CMP DL,0x2f
JZ 0x00101650
MOV EAX,0x1
LEA RCX,[RSP + 0xf]
NOP dword ptr [RAX]
LAB_001014d8:
MOV byte ptr [RCX + RAX*0x... | bool func0(char *param_1,char *param_2)
{
long lVar1;
long lVar2;
char cVar3;
int iVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
int4 local_11c;
char local_118 [111];
char local_a9 [105];
long local_40;
cVar3 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar3 == '/') {
... |
1,235 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);... | #include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(fun... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0xf8,%rsp
movzbl (%rdi),%edx
mov %fs:0x28,%rax
mov %rax,0xe8(%rsp)
xor %eax,%eax
cmp $0x2f,%dl
je 1648 <func0+0x1b8>
mov $0x1,%eax
lea 0xf(%rsp),%rdi
nopl 0x0(%rax)
mo... | func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0F8h
movzx edx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
cmp dl, 2Fh ; '/'
jz loc_1650
mov eax, 1
lea rcx, [rsp+128h+var_119]... | _BOOL8 func0(char *a1, char *a2)
{
char v3; // dl
long long v4; // rax
int v5; // esi
int v6; // r12d
long long v7; // rax
long long v8; // r15
int v9; // ebp
char v10; // al
long long v11; // rdx
int v12; // ecx
int v13; // ebx
char v14; // al
long long v15; // rdx
int v16; // esi
int v1... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xf8
MOVZX EDX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
CMP DL,0x2f
JZ 0x00101650
MOV EAX,0x1
LEA RCX,[RSP + 0xf]
NOP dword ptr [RAX]
LAB_001014d8:
MOV byte ptr [RCX + RAX*0x... | bool func0(char *param_1,char *param_2)
{
long lVar1;
long lVar2;
char cVar3;
int iVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
int4 local_11c;
char local_118 [111];
char local_a9 [105];
long local_40;
cVar3 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar3 == '/') {
... |
1,236 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j ... | #include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, 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, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12,... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x4c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 1100 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x3c(%rbp)
jmpq 1312 <... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_4C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_3C], 0
jmp loc_1... | long long func0(long long a1, int a2)
{
int v2; // edx
int i; // [rsp+14h] [rbp-3Ch]
int v5; // [rsp+18h] [rbp-38h]
int v6; // [rsp+18h] [rbp-38h]
int j; // [rsp+1Ch] [rbp-34h]
int k; // [rsp+20h] [rbp-30h]
int m; // [rsp+24h] [rbp-2Ch]
int v10; // [rsp+28h] [rbp-28h]
int v11; // [rsp+28h] [rbp-28h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x3c]... | long func0(long param_1,int param_2)
{
uint uVar1;
int4 uVar2;
uint uVar3;
int iVar4;
void *__ptr;
size_t sVar5;
long in_FS_OFFSET;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
char local_1c [12];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__pt... |
1,237 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j ... | #include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, 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, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12,... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbp
mov %esi,%r14d
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movslq %esi,%rdi
shl $0x2,%rdi
callq 10e0 <malloc@plt>
mov %rax,%rbx
test %r14d,%r14d
jle 135a <func0+0x171... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r14, rdi
mov r13d, esi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movsxd rbp, esi
shl rbp, 2
mov rdi, rbp; size
call _malloc
mov r15, rax
test r13d, r13d
jle ... | int * func0(int *a1, int a2)
{
int *v3; // r15
int *v4; // rbx
int *v5; // rbp
int v6; // eax
int v7; // eax
long long v8; // r8
int v9; // eax
char *v10; // rdx
char *v11; // rsi
int v12; // r8d
int *v13; // rax
int *v14; // rdx
int v15; // esi
int v16; // ecx
int v17; // ecx
int *v19; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R14,RDI
MOV R13D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVSXD RBP,ESI
SHL RBP,0x2
MOV RDI,RBP
CALL 0x00101100
MOV R15,RAX
TEST R13D,R13D
JLE 0x00101355
MOV RBX,R14
LEA RAX,[RBP + R14*0x1]
MOV qword... | int * func0(int *param_1,int param_2)
{
int iVar1;
int *__ptr;
size_t sVar2;
int *piVar3;
char *pcVar4;
int *piVar5;
int iVar6;
long in_FS_OFFSET;
char local_4c;
char local_4b [11];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)malloc((long)param_2 * 4);
if (0 ... |
1,238 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j ... | #include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, 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, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12,... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
callq 10e0 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
jle 1891 <func0+0x171>
m... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
movsxd rbp, esi
push rbx
mov r12, rbp
shl rbp, 2
mov rdi, rbp; size
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _malloc
mov r14, rax
test r12d, r12d
jle ... | int * func0(int *a1, int a2)
{
__m128i *v3; // r14
int *v4; // r15
__m128i *v5; // rbp
long long v6; // r8
size_t v7; // rax
char *v8; // rdx
char *v9; // rsi
int v10; // eax
int v11; // ecx
int v12; // edx
int v13; // ecx
int v14; // r8d
int *v15; // rdx
__m128i *v16; // rax
__m128i v17; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV R12,RBP
SHL RBP,0x2
MOV RDI,RBP
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x00101100
MOV R14,RAX
TEST R12D,R12D
JLE 0x00101758
LEA RAX,[RBP + R13*0x1]
MOV R15,R13
LEA RBX,[R... | ulong * func0(ulong *param_1,int param_2)
{
char cVar1;
int *__ptr;
size_t sVar2;
int *piVar3;
char *pcVar4;
int iVar5;
ulong *puVar6;
long in_FS_OFFSET;
int iVar7;
int iVar8;
char local_4c;
char local_4b [11];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)ma... |
1,239 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j ... | #include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, 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, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12,... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x38,%rsp
mov %edi,0xc(%rsp)
shl $0x2,%rdi
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
callq 10e0 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
jle ... | func0:
endbr64
push r15
push r14
movsxd r14, esi
push r13
push r12
mov r12, rdi
push rbp
mov rbp, r14
shl r14, 2
push rbx
mov rdi, r14; size
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _malloc
mov r13, rax
test ebp, ebp
jle lo... | int * func0(int *a1, int a2)
{
__m128i *v2; // r13
int *v3; // r15
__m128i *v4; // r14
__m128i v5; // xmm1
__m128i v6; // xmm1
__m128i v7; // xmm0
__m128i v8; // xmm1
__m128i v9; // xmm5
__m128i v10; // xmm3
__m128i v11; // xmm0
int v12; // eax
int v13; // ecx
int v14; // edx
int v15; // ecx... | func0:
ENDBR64
PUSH R15
PUSH R14
MOVSXD R14,ESI
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,R14
SHL R14,0x2
PUSH RBX
MOV RDI,R14
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x00101100
MOV R13,RAX
TEST EBP,EBP
JLE 0x00101828
LEA RAX,[R14 + R12*0x1]
MOV R15,R12
LEA RBX,[RSP... | ulong * func0(ulong *param_1,int param_2)
{
int auVar1 [14];
int auVar2 [12];
unkbyte10 Var3;
int auVar4 [12];
int auVar5 [12];
int iVar6;
int *__ptr;
size_t sVar7;
int *piVar8;
int iVar9;
ulong *puVar10;
long in_FS_OFFSET;
short sVar11;
short sVar18;
short sVar19;
short sVar21;
int i... |
1,240 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first... | #include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 10... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 1265 <func0+0xfc>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0xa,%eax
jle 1261 <func0+0xf8>... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp loc_126B
loc_118B:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cmp eax, 0Ah
jle loc_12... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-14h]
int i; // [rsp+1Ch] [rbp-10h]
int j; // [rsp+20h] [rbp-Ch]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) > 10 )
{
for ( j = *(_DWORD *)(4LL * i + a1); j > 9; j /= 10 )
;
if ( j % ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010126b
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP ... | int func0(long param_1,int param_2)
{
int4 local_1c;
int4 local_18;
int4 local_14;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
if (10 < *(int *)(param_1 + (long)local_18 * 4)) {
for (local_14 = *(int *)(param_1 + (long)local_18 * 4); 9 < local_14; local_14 = l... |
1,241 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first... | #include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 10... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11fc <func0+0x93>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%r9d
jmp 1191 <func0+0x28>
add $0x4,%r8
cmp %rdi,%r8
je 1202 <func0+0x99>
mov (%r8),%esi
cmp $0xa,%esi
jle 1188 <func0+0x1f>
mov %esi,%eax
mov %eax,%ecx
mo... | func0:
endbr64
test esi, esi
jle loc_11FB
mov r8, rdi
movsxd rsi, esi
lea rdi, [rdi+rsi*4]
mov r9d, 0
jmp short loc_1190
loc_1187:
add r8, 4
cmp r8, rdi
jz short loc_1201
loc_1190:
mov esi, [r8]
cmp esi, 0Ah
jle short loc_1187
mov edx, esi
loc_119A:
mov ecx, edx
... | long long func0(int *a1, int a2)
{
int *v2; // r8
int *v3; // rdi
unsigned int v4; // r9d
int v5; // edx
int v6; // ecx
int v7; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
if ( *v2 > 10 )
{
v5 = *v2;
do
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011fb
MOV R8,RDI
MOVSXD RSI,ESI
LEA RDI,[RDI + RSI*0x4]
MOV R9D,0x0
JMP 0x00101190
LAB_00101187:
ADD R8,0x4
CMP R8,RDI
JZ 0x00101201
LAB_00101190:
MOV ESI,dword ptr [R8]
CMP ESI,0xa
JLE 0x00101187
MOV EDX,ESI
LAB_0010119a:
MOV ECX,EDX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar6 = 0;
do {
iVar2 = *param_1;
iVar5 = iVar2;
if (10 < iVar2) {
do {
... |
1,242 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first... | #include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 10... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1445 <func0+0x65>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r8
jmp 1409 <func0+0x29>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %r8,%rdi
je 1441 <func0+0x61>
mov (%rdi),%ecx
cmp $0xa,%ecx
jle 1400 <func0+0x20>
mov... | func0:
endbr64
test esi, esi
jle short loc_13E5
movsxd rsi, esi
xor r9d, r9d
lea r8, [rdi+rsi*4]
mov esi, 0CCCCCCCDh
jmp short loc_13A9
loc_13A0:
add rdi, 4
cmp rdi, r8
jz short loc_13E1
loc_13A9:
mov ecx, [rdi]
cmp ecx, 0Ah
jle short loc_13A0
mov eax, ecx
nop wo... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r9d
unsigned int *v3; // r8
unsigned int v4; // eax
int v5; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
if ( (int)*a1 > 10 )
{
v4 = *a1;
do
{
v5 = ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013e5
MOVSXD RSI,ESI
XOR R9D,R9D
LEA R8,[RDI + RSI*0x4]
MOV ESI,0xcccccccd
JMP 0x001013a9
LAB_001013a0:
ADD RDI,0x4
CMP RDI,R8
JZ 0x001013e1
LAB_001013a9:
MOV ECX,dword ptr [RDI]
CMP ECX,0xa
JLE 0x001013a0
MOV EAX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV EAX,EAX
MOV RDX,RA... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int iVar6;
if (0 < param_2) {
iVar6 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (10 < (int)uVar2) {
uVar3 = (ulong)uVar2;
do {
uVar4 = ... |
1,243 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first... | #include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 10... | O3 | c | func0:
endbr64
test %esi,%esi
jle 13e5 <func0+0x65>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r8
jmp 13a9 <func0+0x29>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %r8,%rdi
je 13e1 <func0+0x61>
mov (%rdi),%ecx
cmp $0xa,%ecx
jle 13a0 <func0+0x20>
mov... | func0:
endbr64
test esi, esi
jle short loc_13E5
movsxd rsi, esi
xor r9d, r9d
lea r8, [rdi+rsi*4]
mov esi, 0CCCCCCCDh
jmp short loc_13A9
loc_13A0:
add rdi, 4
cmp rdi, r8
jz short loc_13E1
loc_13A9:
mov ecx, [rdi]
cmp ecx, 0Ah
jle short loc_13A0
mov eax, ecx
nop wo... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r9d
unsigned int *v3; // r8
unsigned int v4; // eax
int v5; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
if ( (int)*a1 > 10 )
{
v4 = *a1;
do
{
v5 = ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013e5
MOVSXD RSI,ESI
XOR R9D,R9D
LEA R8,[RDI + RSI*0x4]
MOV ESI,0xcccccccd
JMP 0x001013a9
LAB_001013a0:
ADD RDI,0x4
CMP RDI,R8
JZ 0x001013e1
LAB_001013a9:
MOV ECX,dword ptr [RDI]
CMP ECX,0xa
JLE 0x001013a0
MOV EAX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV EAX,EAX
MOV RDX,RA... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int iVar6;
if (0 < param_2) {
iVar6 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (10 < (int)uVar2) {
uVar3 = (ulong)uVar2;
do {
uVar4 = ... |
1,244 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
... | #include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %edi,-0x64(%rbp)
mov -0x64(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x28(%rbp)
mov -0x64(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_64], edi
mov eax, [rbp+var_64]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_28], rax
mov eax, [rbp+var_64]
add eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [r... | long long func0(int a1)
{
_DWORD *v1; // rdx
_DWORD *v2; // rax
_DWORD *v3; // rdx
_DWORD *v4; // rax
int v5; // eax
int i; // [rsp+1Ch] [rbp-54h]
int j; // [rsp+20h] [rbp-50h]
int k; // [rsp+24h] [rbp-4Ch]
int m; // [rsp+28h] [rbp-48h]
int n; // [rsp+2Ch] [rbp-44h]
int ii; // [rsp+30h] [rbp-40h]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RBP + -0x64],EDI
MOV EAX,dword ptr [RBP + -0x64]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x64]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x20],RAX
... | int4 func0(int param_1)
{
int4 uVar1;
long lVar2;
long lVar3;
int iVar4;
void *__ptr;
long *__ptr_00;
long *__ptr_01;
void *pvVar5;
int local_5c;
int local_58;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
__ptr ... |
1,245 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
... | #include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
} | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%r13d
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
lea 0x1(%r13),%eax
cltq
lea 0x0(,%rax,8),%rbx
mov %rbx,0x8(%rsp)
mov %rbx,%rdi
callq 10b0 <malloc@plt>
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13d, edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov r12, rax
lea eax, [r13+1]
cdqe
lea rbx, ds:0[rax*8]
mov [rsp+48h+var_40], rbx
mov rdi, rbx; size
call _malloc
mov ... | long long func0(int a1)
{
_DWORD *v2; // r12
_QWORD *v3; // rbp
_QWORD *v4; // rbx
long long v5; // r14
_DWORD *v6; // rax
_DWORD *v7; // rax
long long i; // rcx
int v9; // eax
_DWORD *v10; // rdi
_DWORD *v11; // rdx
long long v12; // r14
int v13; // ecx
int v14; // r10d
long long v15; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13D,EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R12,RAX
LEA EAX,[R13 + 0x1]
CDQE
LEA RBX,[RAX*0x8]
MOV qword ptr [RSP + 0x8],RBX
MOV RDI,RBX
CALL 0x001010b0
MOV RBP,RAX
MOV RDI,RBX
CALL 0x001010b0
MOV RBX,RAX
TEST R13D,R13D
JS... | int4 func0(uint param_1)
{
size_t __size;
int iVar1;
int4 uVar2;
int4 *puVar3;
int4 *puVar4;
int iVar5;
void *__ptr;
int8 *__ptr_00;
int8 *__ptr_01;
void *pvVar6;
ulong uVar7;
long lVar8;
long lVar9;
long lVar10;
__ptr = malloc((long)(int)param_1 << 2);
__size = (long)(int)(param_1 +... |
1,246 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
... | #include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
} | O2 | c | func0:
endbr64
push %r15
push %r14
movslq %edi,%r14
push %r13
lea 0x0(,%r14,4),%rdi
push %r12
push %rbp
push %rbx
mov %r14,%rbx
sub $0x28,%rsp
mov %r14,0x18(%rsp)
callq 10b0 <malloc@plt>
mov %rax,%rbp
lea 0x1(%r14),%eax
lea 0x8(,%r14,8),%r14
cltq
lea 0x0(,%rax,8),%r15
mov %r15,%r... | func0:
endbr64
push r15
push r14
movsxd r14, edi
push r13
lea rdi, ds:0[r14*4]; size
mov r13, r14
push r12
push rbp
push rbx
sub rsp, 18h
call _malloc
mov r12, rax
lea eax, [r14+1]
cdqe
lea r15, ds:0[rax*8]
mov rdi, r15; size
mov [rsp+48h+var_40], r15
call _mallo... | long long func0(int a1)
{
_DWORD *v2; // r12
size_t v3; // r15
long long *v4; // rbx
long long *v5; // rbp
unsigned long long v6; // r15
long long v7; // rax
long long v8; // rax
long long v9; // r8
long long v10; // rdx
_DWORD *v11; // rcx
signed int v12; // eax
_DWORD *v13; // rsi
long long... | func0:
ENDBR64
PUSH R15
PUSH R14
MOVSXD R14,EDI
PUSH R13
LEA RDI,[R14*0x4]
MOV R13,R14
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
MOV R12,RAX
LEA EAX,[R14 + 0x1]
CDQE
LEA R15,[RAX*0x8]
MOV RDI,R15
MOV qword ptr [RSP + 0x8],R15
CALL 0x001010b0
MOV RDI,R15
MOV RBX,RAX
CALL 0x001010b0
MOV RBP,RAX
TEST R14D,R1... | int4 func0(uint param_1)
{
long lVar1;
int iVar2;
int8 *puVar3;
int4 *puVar4;
int4 *puVar5;
int8 *puVar6;
int8 uVar7;
int iVar8;
uint uVar9;
void *__ptr;
long lVar10;
int8 *__ptr_00;
int8 *__ptr_01;
void *pvVar11;
long lVar12;
ulong uVar13;
long lVar14;
int iVar15;
ulong uVar16;
... |
1,247 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
... | #include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
} | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
movslq %edi,%rbp
push %rbx
lea 0x1(%rbp),%ebx
lea 0x0(,%rbp,4),%rdi
mov %rbp,%r15
movslq %ebx,%rbx
shl $0x3,%rbx
sub $0x18,%rsp
mov %rbp,0x8(%rsp)
callq 10b0 <malloc@plt>
mov %rbx,%rdi
mov %rbx,(%rsp)
mov %rax,%r14
... | func0:
endbr64
push r15
push r14
push r13
movsxd r13, edi
push r12
lea rdi, ds:0[r13*4]; size
mov r14, r13
push rbp
push rbx
sub rsp, 18h
call _malloc
mov r12, rax
lea eax, [r13+1]
cdqe
lea r15, ds:0[rax*8]
mov rdi, r15; size
mov [rsp+48h+var_40], r15
call _mallo... | long long func0(int a1)
{
_DWORD *v2; // r12
size_t v3; // r15
long long *v4; // rbx
_QWORD *v5; // rbp
unsigned long long v6; // r15
long long v7; // rax
_DWORD *v8; // r9
long long v9; // r10
long long v10; // rdx
int i; // edi
_DWORD *v12; // rcx
signed int v13; // eax
long long v14; // r8... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,EDI
PUSH R12
LEA RDI,[R13*0x4]
MOV R14,R13
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
MOV R12,RAX
LEA EAX,[R13 + 0x1]
CDQE
LEA R15,[RAX*0x8]
MOV RDI,R15
MOV qword ptr [RSP + 0x8],R15
CALL 0x001010b0
MOV RDI,R15
MOV RBX,RAX
CALL 0x001010b0
MOV RBP,RAX
TEST R13D,R1... | int4 func0(uint param_1)
{
int *piVar1;
int iVar2;
int4 *puVar3;
int8 *puVar4;
int *piVar5;
int8 uVar6;
uint uVar7;
void *__ptr;
long lVar8;
int8 *__ptr_00;
int8 *__ptr_01;
void *pvVar9;
long lVar10;
ulong uVar11;
int8 *puVar12;
int4 uVar13;
int8 *puVar14;
ulong uVar15;
int iVar16... |
1,248 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
c... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %rdx,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe0b(%rip),%rax
mov %rax,-0x50(%rbp)
lea 0xe08(%rip),%rax
mov %rax,-0x48(%rbp)
lea 0xe03(%rip),%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+s2], rdi
mov [rbp+var_80], rsi
mov [rbp+var_88], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aMercury; "Mercury"
mov [rbp+s1], rax
lea rax, aVenus; "Venus"
mov [rbp+var_48], rax
lea rax, ... | _QWORD * func0(const char *a1, const char *a2, int *a3)
{
int v5; // [rsp+28h] [rbp-68h]
int v6; // [rsp+2Ch] [rbp-64h]
int i; // [rsp+30h] [rbp-60h]
int j; // [rsp+30h] [rbp-60h]
int v9; // [rsp+34h] [rbp-5Ch]
_QWORD *v10; // [rsp+38h] [rbp-58h]
char *s1[10]; // [rsp+40h] [rbp-50h]
s1[9] = (char *)__r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV qword ptr [RBP + -0x88],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0x102010]
MOV qword ptr [RBP + -0x48],RAX
LE... | void * func0(char *param_1,char *param_2,int *param_3)
{
int iVar1;
void *pvVar2;
long in_FS_OFFSET;
int local_70;
int local_6c;
int local_68;
char *local_58 [4];
char *local_38;
char *local_30;
char *local_28;
char *local_20;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
loc... |
1,249 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
c... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%r15
mov %rsi,(%rsp)
mov %rdx,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xe06(%rip),%rax
mov %rax,0x10(%rsp)
lea 0xe02(%rip),%rax
mov %rax,0x18(%rsp)
le... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov r15, rdi
mov [rsp+98h+s2], rsi
mov [rsp+98h+var_90], rdx
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea rax, aMercury; "Mercury"
mov [rsp+98h+s1], rax
lea rax, aVen... | _QWORD * func0(char *s2, const char *a2, int *a3)
{
long long v3; // rbx
int v4; // r13d
int v5; // ebp
const char *v6; // r12
int v7; // eax
int v8; // eax
_QWORD *result; // rax
int v10; // ebp
long long v11; // rdx
long long v12; // rcx
char *s1[17]; // [rsp+10h] [rbp-88h] BYREF
s1[9] = (cha... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV R15,RDI
MOV qword ptr [RSP],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[0x10200c]
MOV qword ptr [RSP + 0x18],RAX
L... | void * func0(char *param_1,char *param_2,int *param_3)
{
char *__s1;
int iVar1;
int iVar2;
void *pvVar3;
ulong uVar4;
ulong uVar5;
int iVar6;
ulong uVar7;
long in_FS_OFFSET;
bool bVar8;
char *local_88 [9];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "Mercury";... |
1,250 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
c... | O2 | c | func0:
endbr64
push %r15
mov $0xffffffff,%r15d
push %r14
mov %rdi,%r14
lea 0xa6c(%rip),%rdi
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov $0xffffffff,%ebp
push %rbx
xor %ebx,%ebx
sub $0x68,%rsp
mov %rdx,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0... | func0:
endbr64
push r15
lea rcx, aMercury; "Mercury"
mov r15d, 0FFFFFFFFh
push r14
movq xmm0, rcx
lea rcx, aEarth; "Earth"
push r13
push r12
xor r12d, r12d
push rbp
push rbx
mov ebx, 0FFFFFFFFh
sub rsp, 78h
mov [rsp+0A8h+s2], rdi
lea r14, [rsp+0A8h+var_88]
mov [r... | void * func0(const char *a1, const char *a2, int *a3)
{
int v3; // r15d
long long v4; // r12
int v5; // ebx
const char *v6; // rdi
int v7; // eax
void *v8; // rdi
int v10; // eax
_OWORD v13[4]; // [rsp+18h] [rbp-88h] BYREF
unsigned long long v14; // [rsp+60h] [rbp-40h]
v3 = -1;
v4 = 0LL;
v5 = -... | func0:
ENDBR64
PUSH R15
LEA RCX,[0x102004]
MOV R15D,0xffffffff
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x102012]
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
MOV EBX,0xffffffff
SUB RSP,0x78
MOV qword ptr [RSP + 0x8],RDI
LEA R14,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr FS... | void * func0(char *param_1,char *param_2,int *param_3)
{
char *__s1;
int iVar1;
int iVar2;
void *__dest;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
long in_FS_OFFSET;
char *local_88 [9];
long local_40;
uVar6 = 0xffffffff;
uVar4 = 0;
uVar3 = 0xffffffff;
local_40 = *(long *)(in_FS... |
1,251 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
c... | O3 | c | func0:
endbr64
push %r15
lea 0xa47(%rip),%rcx
mov $0x1,%r15d
push %r14
movq %rcx,%xmm0
lea 0xa41(%rip),%rcx
mov %rdx,%r14
push %r13
lea 0xa4f(%rip),%rdx
mov %rsi,%r13
mov %rdi,%rsi
push %r12
mov %rdi,%r12
push %rbp
push %rbx
xor %ebx,%ebx
sub $0x68,%rsp
mov %fs:0x28,%rax
m... | func0:
endbr64
push r15
lea r15, aEarth; "Earth"
push r14
lea r14, s2; "Jupiter"
push r13
lea r13, s1; "Mercury"
push r12
movq xmm0, r13
mov r12, rdi
push rbp
mov rbp, rsi
mov rsi, rdi; s2
mov rdi, r13; s1
push rbx
xor ebx, ebx
sub rsp, 68h
mov [rsp+98h+var_9... | void * func0(char *s2, char *a2, int *a3)
{
int v3; // r13d
int v4; // ebx
int v5; // eax
int v6; // eax
void *v7; // rcx
int v9; // [rsp+0h] [rbp-94h]
_OWORD src[4]; // [rsp+Ch] [rbp-88h] BYREF
unsigned long long v12; // [rsp+54h] [rbp-40h]
v12 = __readfsqword(0x28u);
src[0] = _mm_loadh_ps((const ... | func0:
ENDBR64
PUSH R15
LEA R15,[0x102012]
PUSH R14
LEA R14,[0x10201d]
PUSH R13
LEA R13,[0x102004]
PUSH R12
MOVQ XMM0,R13
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
MOV RSI,RDI
MOV RDI,R13
PUSH RBX
XOR EBX,EBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x8],RDX
MOVHPS XMM0,qword ptr [0x00103d70]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr ... | void * func0(char *param_1,char *param_2,int *param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
void *__dest;
long in_FS_OFFSET;
char *local_88 [4];
char *local_68;
int *puStack_60;
int *local_58;
int *puStack_50;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0]... |
1,252 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov -0x48(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0x28(%rbp)
jmp 129f <func0+0x96>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov rax, [rbp+var_48]
mov dword ptr [rax], 0
mov [rbp+var_28], 0
jmp short loc_129F
loc_1233:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [r... | _QWORD * func0(long long a1, int a2, int *a3)
{
int i; // [rsp+28h] [rbp-28h]
int j; // [rsp+28h] [rbp-28h]
int m; // [rsp+28h] [rbp-28h]
int k; // [rsp+2Ch] [rbp-24h]
_QWORD *v9; // [rsp+30h] [rbp-20h]
size_t v10; // [rsp+38h] [rbp-18h]
size_t v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rb... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x28],0x0
JMP 0x0010129f
LAB_00101233:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x8]
MOV... | void * func0(long param_1,int param_2,int *param_3)
{
int8 uVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
void *pvVar5;
int4 local_30;
int4 local_2c;
*param_3 = 0;
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
sVar3 = strlen(*(char **)(param_1 + (long)local_30 * 8));
if ... |
1,253 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %rdx,%r15
movl $0x0,(%rdx)
test %esi,%esi
jle 12f2 <func0+0x109>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r9
mov $0xffffffffffffffff,%r8
mov $0x0,%eax
jmp... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov r15, rdx
mov dword ptr [rdx], 0
test esi, esi
jle loc_12EF
mov rbx, rdi
movsxd rsi, esi
lea r13, [rdi+rsi*8]
jmp short loc_1244
loc_123B:
add rbx, 8
cmp rbx, r... | char * func0(const char **a1, int a2, int *a3)
{
const char **v4; // rbx
const char *v5; // rbp
int v6; // eax
long long v7; // rbx
const char *v8; // r13
size_t v9; // rbp
const char *v10; // r14
size_t v11; // rax
char *result; // rax
long long v13; // rsi
unsigned long long v14; // rdx
int v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV R15,RDX
MOV dword ptr [RDX],0x0
TEST ESI,ESI
JLE 0x001012ef
MOV RBX,RDI
MOVSXD RSI,ESI
LEA R13,[RDI + RSI*0x8]
JMP 0x00101244
LAB_0010123b:
ADD RBX,0x8
CMP RBX,R13
JZ 0x00101260
LAB_00101244:
MOV RBP,qword ptr [RBX]
MOV RD... | void func0(int8 *param_1,int param_2,int *param_3)
{
char *pcVar1;
char *__s;
int iVar2;
size_t sVar3;
size_t sVar4;
void *pvVar5;
int8 *puVar6;
long lVar7;
uint local_3c;
*param_3 = 0;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar6 = param_1;
do {
pcVar1 = (char *)*puVar6... |
1,254 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movl $0x0,(%rdx)
mov %rdx,0x18(%rsp)
test %esi,%esi
jle 1864 <func0+0x154>
lea 0x8(%rdi),%rdx
lea -0x1(%rsi),%eax
mov %rdi,%r12
xor %ebx,%ebx
mov %rdx,0x10(%rsp)
lea (%rd... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rdx], 0
mov [rsp+58h+src], rdi
mov [rsp+58h+var_48], rdx
test esi, esi
jle loc_1901
movsxd rsi, esi
mov rbx, rdi
xor r13d, r13d
lea r12, [rdi+rsi*8]
nop word ptr [ra... | void * func0(const char **a1, int a2, int *a3)
{
const char **v3; // rbx
int v4; // r13d
const char *v5; // rbp
long long v6; // rax
const char **v7; // r15
long long v8; // r12
const char *v9; // rbp
size_t v10; // rax
const char *v11; // rbx
size_t v12; // r14
size_t v13; // rax
void *v14; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RDX],0x0
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x10],RDX
TEST ESI,ESI
JLE 0x00101901
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R13D,R13D
LEA R12,[RDI + RSI*0x8]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017d0:
MOV RBP,qword ptr [R... | void * func0(int8 *param_1,int param_2,uint *param_3)
{
char *pcVar1;
char *__s;
int iVar2;
size_t sVar3;
long lVar4;
size_t sVar5;
void *__dest;
int8 *puVar6;
uint uVar7;
int8 *puVar8;
size_t local_40;
*param_3 = 0;
if (param_2 < 1) {
local_40 = 0;
}
else {
uVar7 = 0;
puVa... |
1,255 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movl $0x0,(%rdx)
mov %rdi,(%rsp)
mov %rdx,0x18(%rsp)
test %esi,%esi
jle 18b4 <func0+0x154>
lea 0x8(%rdi),%rdx
lea -0x1(%rsi),%eax
mov %rdi,%r12
xor %ebx,%ebx
mov %rdx,0x10(%rsp)
lea (%... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rdx], 0
mov [rsp+58h+src], rdi
mov [rsp+58h+var_48], rdx
test esi, esi
jle loc_1901
movsxd rsi, esi
mov rbx, rdi
xor r13d, r13d
lea r12, [rdi+rsi*8]
nop word ptr [ra... | void * func0(const char **a1, int a2, int *a3)
{
const char **v3; // rbx
int v4; // r13d
const char *v5; // rbp
long long v6; // rax
const char **v7; // r15
long long v8; // r12
const char *v9; // rbp
size_t v10; // rax
const char *v11; // rbx
size_t v12; // r14
size_t v13; // rax
void *v14; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RDX],0x0
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x10],RDX
TEST ESI,ESI
JLE 0x00101901
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R13D,R13D
LEA R12,[RDI + RSI*0x8]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017d0:
MOV RBP,qword ptr [R... | void * func0(int8 *param_1,int param_2,uint *param_3)
{
char *pcVar1;
char *__s;
int iVar2;
size_t sVar3;
long lVar4;
size_t sVar5;
void *__dest;
int8 *puVar6;
uint uVar7;
int8 *puVar8;
size_t local_40;
*param_3 = 0;
if (param_2 < 1) {
local_40 = 0;
}
else {
uVar7 = 0;
puVa... |
1,256 | func0 | #include <stdio.h>
| int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
} | #include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
movl $0x1,-0x8(%rbp)
cmpl $0x1,-0x14(%rbp)
jg 116e <func0+0x25>
movl $0x0,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 118f <func0+0x46>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_8], 1
cmp [rbp+var_14], 1
jg short loc_116E
mov [rbp+var_8], 0
loc_116E:
mov [rbp+var_4], 2
jmp short loc_118F
loc_1177:
mov eax, [rbp+var_14]
cdq
idiv [... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
_BOOL4 v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = a1 > 1;
for ( i = 2; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
v4 = 0;
}
if ( v4 )
return a2;
else
return a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x8],0x1
CMP dword ptr [RBP + -0x14],0x1
JG 0x0010116e
MOV dword ptr [RBP + -0x8],0x0
LAB_0010116e:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010118f
LAB_00101177:
MOV EA... | int4 func0(int param_1,int4 param_2,int4 param_3)
{
bool bVar1;
int local_c;
bVar1 = 1 < param_1;
for (local_c = 2; local_c * local_c <= param_1; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
bVar1 = false;
}
}
if (bVar1) {
param_3 = param_2;
}
return param_3;
} |
1,257 | func0 | #include <stdio.h>
| int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
} | #include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, ... | O1 | c | func0:
endbr64
mov %edx,%r9d
cmp $0x1,%edi
setg %r8b
movzbl %r8b,%r8d
cmp $0x3,%edi
jle 117c <func0+0x33>
mov $0x2,%ecx
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %edx,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1165 <func0+0x1c>
test %r8d,%r8d
cmovn... | func0:
endbr64
mov r10d, edx
cmp edi, 1
setnle r8b
movzx r8d, r8b
cmp edi, 3
jle short loc_117F
mov ecx, 2
loc_1165:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, edx
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp r9d, edi
jle short loc_1165
loc_117F:
test r8d, r... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
_BOOL4 v3; // r8d
int v4; // ecx
long long result; // rax
v3 = a1 > 1;
if ( a1 > 3 )
{
v4 = 2;
do
{
if ( !(a1 % v4) )
v3 = 0;
++v4;
}
while ( v4 * v4 <= a1 );
}
result = a3;
if ( v3 )
return a2;
... | func0:
ENDBR64
MOV R10D,EDX
CMP EDI,0x1
SETG R8B
MOVZX R8D,R8B
CMP EDI,0x3
JLE 0x0010117f
MOV ECX,0x2
LAB_00101165:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,EDX
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP R9D,EDI
JLE 0x00101165
LAB_0010117f:
TEST R8D,R8D
MOV EAX,R10D
CMOVNZ EAX,ESI
RET | int4 func0(int param_1,int4 param_2,int4 param_3)
{
int iVar1;
uint uVar2;
ulong uVar3;
uVar3 = (ulong)(1 < param_1);
uVar2 = (uint)(1 < param_1);
if (3 < param_1) {
iVar1 = 2;
do {
if ((int)((long)param_1 % (long)iVar1) == 0) {
uVar3 = (long)param_1 % (long)iVar1 & 0xffffffff;
... |
1,258 | func0 | #include <stdio.h>
| int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
} | #include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, ... | O2 | c | func0:
endbr64
xor %r8d,%r8d
cmp $0x1,%edi
mov %edx,%r10d
setg %r8b
cmp $0x3,%edi
jle 1327 <func0+0x37>
mov $0x2,%ecx
xor %r9d,%r9d
xchg %ax,%ax
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %r9d,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1310 <f... | func0:
endbr64
mov r11d, edx
cmp edi, 3
jle short loc_1328
mov ecx, 2
mov r8d, 1
xor r10d, r10d
nop word ptr [rax+rax+00h]
loc_1300:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, r10d
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp edi, r9d
jge short loc_1300
te... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
int v3; // ecx
int v4; // r8d
long long result; // rax
if ( a1 <= 3 )
{
result = a3;
if ( a1 > 1 )
return a2;
}
else
{
v3 = 2;
v4 = 1;
do
{
if ( !(a1 % v3) )
v4 = 0;
++v3;
}
while ( a1... | func0:
ENDBR64
MOV R11D,EDX
CMP EDI,0x3
JLE 0x00101328
MOV ECX,0x2
MOV R8D,0x1
XOR R10D,R10D
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,R10D
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP EDI,R9D
JGE 0x00101300
TEST R8D,R8D
MOV EAX,R11D
CMOVNZ EAX,ESI
RET
LAB_00101328:
XOR R8D,... | int4 func0(int param_1,int4 param_2,int4 param_3)
{
bool bVar1;
int iVar2;
if (3 < param_1) {
iVar2 = 2;
bVar1 = true;
do {
if (param_1 % iVar2 == 0) {
bVar1 = false;
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
if (bVar1) {
param_3 = param_2;
... |
1,259 | func0 | #include <stdio.h>
| int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
} | #include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, ... | O3 | c | func0:
endbr64
xor %r8d,%r8d
cmp $0x1,%edi
mov %edx,%r10d
setg %r8b
cmp $0x3,%edi
jle 12c7 <func0+0x37>
mov $0x2,%ecx
xor %r9d,%r9d
xchg %ax,%ax
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %r9d,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %eax,%edi
jge 12b0 <f... | func0:
endbr64
mov r11d, edx
cmp edi, 3
jle short loc_1328
mov ecx, 2
mov r8d, 1
xor r10d, r10d
nop word ptr [rax+rax+00h]
loc_1300:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, r10d
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp edi, r9d
jge short loc_1300
te... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
int v3; // ecx
int v4; // r8d
long long result; // rax
if ( a1 <= 3 )
{
result = a3;
if ( a1 > 1 )
return a2;
}
else
{
v3 = 2;
v4 = 1;
do
{
if ( !(a1 % v3) )
v4 = 0;
++v3;
}
while ( a1... | func0:
ENDBR64
MOV R11D,EDX
CMP EDI,0x3
JLE 0x00101328
MOV ECX,0x2
MOV R8D,0x1
XOR R10D,R10D
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,R10D
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP EDI,R9D
JGE 0x00101300
TEST R8D,R8D
MOV EAX,R11D
CMOVNZ EAX,ESI
RET
LAB_00101328:
XOR R8D,... | int4 func0(int param_1,int4 param_2,int4 param_3)
{
bool bVar1;
int iVar2;
if (3 < param_1) {
iVar2 = 2;
bVar1 = true;
do {
if (param_1 % iVar2 == 0) {
bVar1 = false;
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
if (bVar1) {
param_3 = param_2;
... |
1,260 | func0 | #include <stdio.h>
#include <math.h>
| long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}... | #include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movq $0x0,-0x18(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 12cf <func0+0x146>
mov -0x1c(%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, 38h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
mov [rbp+var_1C], 0
jmp loc_1311
loc_11B1:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword p... | long long func0(long long a1, int a2)
{
int v2; // ebx
int i; // [rsp+24h] [rbp-1Ch]
long long v5; // [rsp+28h] [rbp-18h]
v5 = 0LL;
for ( i = 0; i < a2; ++i )
{
if ( fabs(*(float *)(4LL * i + a1) - round(*(float *)(4LL * i + a1))) < 0.0001
&& *(float *)(4LL * i + a1) > 0.0
&& (int)round(*(... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101311
LAB_001011b1:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS ... | long func0(long param_1,int param_2)
{
float fVar1;
double dVar2;
double dVar3;
int4 local_24;
int8 local_20;
local_20 = 0;
for (local_24 = 0; local_24 < param_2; local_24 = local_24 + 1) {
fVar1 = *(float *)(param_1 + (long)local_24 * 4);
dVar2 = round((double)*(float *)(param_1 + (long)local... |
1,261 | func0 | #include <stdio.h>
#include <math.h>
| long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}... | #include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 1224 <func0+0x9b>
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rbp
mov $0x0,%r12d
jmp 11b9 <func0+0x30>
add $0x4,%rbx
cmp %rbp,%rbx
je 122a <func0+0xa1>
movss (%rbx),%xmm3
movss %xmm3,0xc(%... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_1224
mov rbx, rdi
movsxd rsi, esi
lea rbp, [rdi+rsi*4]
mov r12d, 0
jmp short loc_11B8
loc_11AF:
add rbx, 4
cmp rbx, rbp
jz short loc_122A
loc_11B8:
movss xmm3, dword ptr [rbx]
movss [rsp+28... | long long func0(float *a1, int a2)
{
float *v2; // rbx
long long v3; // r12
float v4; // xmm0_4
float v6; // [rsp+Ch] [rbp-1Ch]
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = 0LL;
do
{
v6 = *v2;
v4 = roundf(*v2);
if ( fabs(v6 - v4) < 0.0001 && v6 > 0.0 && (int)v4 % 2 == 1 )
v3 += (in... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x00101224
MOV RBX,RDI
MOVSXD RSI,ESI
LEA RBP,[RDI + RSI*0x4]
MOV R12D,0x0
JMP 0x001011b8
LAB_001011af:
ADD RBX,0x4
CMP RBX,RBP
JZ 0x0010122a
LAB_001011b8:
MOVSS XMM3,dword ptr [RBX]
MOVSS dword ptr [RSP + 0xc],XMM3
MOVAPS XMM0,XMM3
CALL 0x00101070... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long func0(float *param_1,int param_2)
{
float *pfVar1;
float __x;
int iVar2;
long lVar3;
float fVar4;
if (param_2 < 1) {
lVar3 = 0;
}
else {
pfVar1 = param_1 + param_2;
lVar3 = 0;
do {
__x = ... |
1,262 | func0 | #include <stdio.h>
#include <math.h>
| long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}... | #include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0... | O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 14b0 <func0+0xb0>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %r12d,%r12d
lea 0x4(%rdi,%rax,4),%rbp
nopw 0x0(%rax,%rax,1)
movss (%rbx),%xmm2
movaps %xmm2,%xmm0
movss %xmm2,0xc(%rsp)
callq 1070 <roundf@plt>
movss 0xc... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_1530
movsxd rsi, esi
mov rbx, rdi
xor r12d, r12d
lea rbp, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_14A8:
movss xmm2, dword ptr [rbx]
movaps xmm0, xmm2; x
movss [rsp+28h+var_1C], xmm2
call _roun... | long long func0(float *a1, int a2)
{
float *v2; // rbx
long long v3; // r12
float v4; // xmm0_4
float v6; // [rsp+Ch] [rbp-1Ch]
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = 0LL;
do
{
v6 = *v2;
v4 = roundf(*v2);
if ( fabs(v6 - v4) < 0.0001 && v6 > 0.0 && (int)v4 % 2 == 1 )
v3 += (in... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x00101530
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R12D,R12D
LEA RBP,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_001014a8:
MOVSS XMM2,dword ptr [RBX]
MOVAPS XMM0,XMM2
MOVSS dword ptr [RSP + 0xc],XMM2
CALL 0x00101070
MOVSS XMM2,dword ptr [RSP + 0xc]
PXOR XMM1,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long func0(float *param_1,int param_2)
{
float *pfVar1;
float __x;
int iVar2;
long lVar3;
float fVar4;
if (0 < param_2) {
lVar3 = 0;
pfVar1 = param_1 + param_2;
do {
__x = *param_1;
fVar4 = roun... |
1,263 | func0 | #include <stdio.h>
#include <math.h>
| long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}... | #include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0... | O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 1560 <func0+0xb0>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %r12d,%r12d
lea 0x4(%rdi,%rax,4),%rbp
nopw 0x0(%rax,%rax,1)
movss (%rbx),%xmm2
movaps %xmm2,%xmm0
movss %xmm2,0xc(%rsp)
callq 1070 <roundf@plt>
movss 0xc... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_1530
movsxd rsi, esi
mov rbx, rdi
xor r12d, r12d
lea rbp, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_14A8:
movss xmm2, dword ptr [rbx]
movaps xmm0, xmm2; x
movss [rsp+28h+var_1C], xmm2
call _roun... | long long func0(float *a1, int a2)
{
float *v2; // rbx
long long v3; // r12
float v4; // xmm0_4
float v6; // [rsp+Ch] [rbp-1Ch]
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = 0LL;
do
{
v6 = *v2;
v4 = roundf(*v2);
if ( fabs(v6 - v4) < 0.0001 && v6 > 0.0 && (int)v4 % 2 == 1 )
v3 += (in... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x00101530
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R12D,R12D
LEA RBP,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_001014a8:
MOVSS XMM2,dword ptr [RBX]
MOVAPS XMM0,XMM2
MOVSS dword ptr [RSP + 0xc],XMM2
CALL 0x00101070
MOVSS XMM2,dword ptr [RSP + 0xc]
PXOR XMM1,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long func0(float *param_1,int param_2)
{
float *pfVar1;
float __x;
int iVar2;
long lVar3;
float fVar4;
if (0 < param_2) {
lVar3 = 0;
pfVar1 = param_1 + param_2;
do {
__x = *param_1;
fVar4 = roun... |
1,264 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
} | #include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (c... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d9 <func0+0x70>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11DA
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]... | long long func0(long long a1, long long a2, long long a3, int a4)
{
int v4; // eax
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
v4 = *(_DWORD *)(4LL * (int)i + a1) - *(_DWORD *)(4LL * (int)i + a2);
if ( *(_... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011da
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | void func0(long param_1,long param_2,long param_3,int param_4)
{
int iVar1;
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
iVar1 = *(int *)(param_1 + (long)local_c * 4) - *(int *)(param_2 + (long)local_c * 4);
if (iVar1 < 1) {
iVar1 = -iVar1;
}
*(int *)(param... |
1,265 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
} | #include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (c... | O1 | c | func0:
endbr64
test %ecx,%ecx
jle 119d <func0+0x34>
lea -0x1(%rcx),%r9d
mov $0x0,%eax
mov (%rdi,%rax,4),%ecx
sub (%rsi,%rax,4),%ecx
mov %ecx,%r8d
sar $0x1f,%r8d
xor %r8d,%ecx
mov %ecx,(%rdx,%rax,4)
sub %r8d,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r9,%rcx
jne 117a <func... | func0:
endbr64
mov r9, rdi
test ecx, ecx
jle short locret_119E
movsxd rcx, ecx
lea r8, ds:0[rcx*4]
mov eax, 0
loc_1184:
mov ecx, [r9+rax]
sub ecx, [rsi+rax]
mov edi, ecx
neg edi
cmovns ecx, edi
mov [rdx+rax], ecx
add rax, 4
cmp rax, r8
jnz short loc_1184
locret_119E:... | void func0(long long a1, long long a2, long long a3, int a4)
{
long long v4; // r8
long long v5; // rax
int v6; // ecx
if ( a4 > 0 )
{
v4 = 4LL * a4;
v5 = 0LL;
do
{
v6 = *(_DWORD *)(a1 + v5) - *(_DWORD *)(a2 + v5);
if ( *(_DWORD *)(a2 + v5) - *(_DWORD *)(a1 + v5) >= 0 )
v... | func0:
ENDBR64
MOV R9,RDI
TEST ECX,ECX
JLE 0x0010119e
MOVSXD RCX,ECX
LEA R8,[RCX*0x4]
MOV EAX,0x0
LAB_00101184:
MOV ECX,dword ptr [R9 + RAX*0x1]
SUB ECX,dword ptr [RSI + RAX*0x1]
MOV EDI,ECX
NEG EDI
CMOVNS ECX,EDI
MOV dword ptr [RDX + RAX*0x1],ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x00101184
LAB_0010119e:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
int iVar2;
if (0 < param_4) {
lVar1 = 0;
do {
iVar2 = *(int *)(param_1 + lVar1) - *(int *)(param_2 + lVar1);
if (iVar2 < 1) {
iVar2 = -iVar2;
}
*(int *)(param_3 + lVar1) = iVar2;
lVar1 = ... |
1,266 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
} | #include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (c... | O2 | c | func0:
endbr64
test %ecx,%ecx
jle 15b3 <func0+0x33>
lea -0x1(%rcx),%r9d
xor %eax,%eax
xchg %ax,%ax
mov (%rdi,%rax,4),%ecx
sub (%rsi,%rax,4),%ecx
mov %ecx,%r8d
sar $0x1f,%r8d
xor %r8d,%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
sub %r8d,(%rdx,%rax,4)
add $0x1,%rax
cmp %r9,%rcx
jn... | func0:
endbr64
mov r9, rdi
test ecx, ecx
jle short locret_159A
movsxd rcx, ecx
xor eax, eax
lea r8, ds:0[rcx*4]
nop dword ptr [rax+rax+00000000h]
loc_1580:
mov ecx, [r9+rax]
sub ecx, [rsi+rax]
mov edi, ecx
neg edi
cmovns ecx, edi
mov [rdx+rax], ecx
add rax, 4
cmp r8,... | void func0(long long a1, long long a2, long long a3, int a4)
{
long long v4; // rax
long long v5; // r8
int v6; // ecx
if ( a4 > 0 )
{
v4 = 0LL;
v5 = 4LL * a4;
do
{
v6 = *(_DWORD *)(a1 + v4) - *(_DWORD *)(a2 + v4);
if ( *(_DWORD *)(a2 + v4) - *(_DWORD *)(a1 + v4) >= 0 )
v... | func0:
ENDBR64
MOV R9,RDI
TEST ECX,ECX
JLE 0x0010159a
MOVSXD RCX,ECX
XOR EAX,EAX
LEA R8,[RCX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101580:
MOV ECX,dword ptr [R9 + RAX*0x1]
SUB ECX,dword ptr [RSI + RAX*0x1]
MOV EDI,ECX
NEG EDI
CMOVNS ECX,EDI
MOV dword ptr [RDX + RAX*0x1],ECX
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101580
LAB_... | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
int iVar2;
if (0 < param_4) {
lVar1 = 0;
do {
iVar2 = *(int *)(param_1 + lVar1) - *(int *)(param_2 + lVar1);
if (iVar2 < 1) {
iVar2 = -iVar2;
}
*(int *)(param_3 + lVar1) = iVar2;
lVar1 = ... |
1,267 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
} | #include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (c... | O3 | c | func0:
endbr64
test %ecx,%ecx
jle 154b <func0+0x11b>
lea 0xf(%rdi),%r8
lea -0x1(%rcx),%eax
sub %rdx,%r8
cmp $0x1e,%r8
seta %r9b
cmp $0x2,%eax
seta %r8b
test %r8b,%r9b
je 1520 <func0+0xf0>
lea 0xf(%rsi),%r8
sub %rdx,%r8
cmp $0x1e,%r8
jbe 1520 <func0+0xf0>
mov %ecx,%r8d
xor ... | func0:
endbr64
mov r8, rdi
mov rdi, rdx
movsxd rdx, ecx
mov r9, rsi
test edx, edx
jle locret_136B
lea eax, [rdx-1]
cmp eax, 2
jbe loc_1340
lea rcx, [r8+4]
mov rax, rdi
sub rax, rcx
cmp rax, 8
jbe loc_1340
lea rcx, [rsi+4]
mov rax, rdi
sub rax, rcx
cmp ... | void func0(long long a1, long long a2, long long a3, int a4)
{
long long v8; // rax
__m128i v9; // xmm0
__m128i v10; // xmm1
unsigned int v11; // ecx
int v12; // esi
long long v13; // rax
int v14; // esi
int v15; // edx
long long v16; // rax
int v17; // edx
if ( a4 > 0 )
{
if ( (unsigned i... | func0:
ENDBR64
MOV R8,RDI
MOV RDI,RDX
MOVSXD RDX,ECX
MOV R9,RSI
TEST EDX,EDX
JLE 0x0010136b
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x00101340
LEA RCX,[R8 + 0x4]
MOV RAX,RDI
SUB RAX,RCX
CMP RAX,0x8
JBE 0x00101340
LEA RCX,[RSI + 0x4]
MOV RAX,RDI
SUB RAX,RCX
CMP RAX,0x8
JBE 0x00101340
MOV ECX,EDX
XOR EAX,EAX
SHR ECX,0x2
SHL... | void func0(long param_1,long param_2,long param_3,uint param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
long lVar9;
int iVar10;
ulong uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
if (0 < (int)param_4) {
if (((... |
1,268 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++)... | #include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tm... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x44(%rbp)
mov %rcx,-0x50(%rbp)
movl $0xfffffc18,-0x20(%rbp)
movq $0x0,-0x10(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 126f <func0+0xc6>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov [rbp+s], rcx
mov [rbp+var_20], 0FFFFFC18h
mov [rbp+var_10], 0
mov [rbp+var_1C], 0
jmp loc_126F
loc_11DF:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax... | int func0(const char *a1, long long a2, int a3, char *a4)
{
char v5; // [rsp+2Fh] [rbp-21h]
int v6; // [rsp+30h] [rbp-20h]
int i; // [rsp+34h] [rbp-1Ch]
int v8; // [rsp+38h] [rbp-18h]
int j; // [rsp+3Ch] [rbp-14h]
const char *v10; // [rsp+40h] [rbp-10h]
long long v11; // [rsp+48h] [rbp-8h]
v6 = -1000;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV qword ptr [RBP + -0x50],RCX
MOV dword ptr [RBP + -0x20],0xfffffc18
MOV qword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010126f
LAB_001011df:
MOV EAX,dwo... | void func0(int8 param_1,long param_2,int param_3,char *param_4)
{
char cVar1;
long lVar2;
int local_28;
int local_24;
int local_20;
int local_1c;
long local_18;
local_28 = -1000;
local_18 = 0;
for (local_24 = 0; local_24 < param_3; local_24 = local_24 + 1) {
lVar2 = *(long *)(param_2 + (long... |
1,269 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++)... | #include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tm... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r8
mov %rcx,%rbp
test %edx,%edx
jle 1204 <func0+0x7b>
mov %rsi,%r10
lea -0x1(%rdx),%eax
lea 0x8(%rsi,%rax,8),%rbx
mov $0x0,%r9d
mov $0xfffffc18,%edi
jmp 11ee <func0+0x65>
sub $0x61,%eax
cmp $0x1a,%al
sbb $0x0,%ecx
ad... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov r8, rdi
mov rbp, rcx
test edx, edx
jle short loc_1226
mov rdi, rsi
movsxd rdx, edx
lea rbx, [rsi+rdx*8]
mov r9d, 0
mov r11d, 0FFFFFC18h
jmp short loc_1210
loc_11D5:
sub eax, 61h ; 'a'
cmp al, 1Ah
sbb ecx, 0
loc_11D... | long long func0(const char *a1, const char **a2, int a3, long long a4)
{
const char **v6; // rdi
const char **v7; // rbx
const char *v8; // r9
int v9; // r11d
int v10; // ecx
char *v11; // rdx
char v12; // al
if ( a3 <= 0 )
{
v8 = 0LL;
}
else
{
v6 = a2;
v7 = &a2[a3];
v8 = 0LL;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R8,RDI
MOV RBP,RCX
TEST EDX,EDX
JLE 0x00101226
MOV RDI,RSI
MOVSXD RDX,EDX
LEA RBX,[RSI + RDX*0x8]
MOV R9D,0x0
MOV R11D,0xfffffc18
JMP 0x00101210
LAB_001011d5:
SUB EAX,0x61
CMP AL,0x1a
SBB ECX,0x0
LAB_001011dd:
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX + -0x1]
TEST AL,AL
JZ 0x0... | void func0(int8 param_1,int8 *param_2,int param_3,int8 param_4)
{
int8 *puVar1;
char cVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
char *pcVar6;
int iVar7;
if (param_3 < 1) {
pcVar6 = (char *)0x0;
}
else {
puVar1 = param_2 + param_3;
pcVar6 = (char *)0x0;
iVar7 = -1000;
do {
... |
1,270 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++)... | #include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tm... | O2 | c | func0:
endbr64
push %rbp
mov %rdi,%r8
mov %rcx,%rdi
push %rbx
test %edx,%edx
jle 17e4 <func0+0xa4>
lea -0x1(%rdx),%eax
mov %rsi,%r10
xor %r9d,%r9d
mov $0xfffffc18,%ebx
lea 0x8(%rsi,%rax,8),%rbp
nopw 0x0(%rax,%rax,1)
mov (%r10),%r11
movzbl (%r11),%eax
test %al,%al
je 17e0 <func0+... | func0:
endbr64
push rbp
mov r8, rdi
mov r11, rcx
push rbx
test edx, edx
jle loc_1854
movsxd rdx, edx
xor r9d, r9d
mov ebx, 0FFFFFC18h
lea rbp, [rsi+rdx*8]
nop dword ptr [rax+rax+00h]
loc_17D8:
mov r10, [rsi]
movzx eax, byte ptr [r10]
test al, al
jz short loc_1850
lea ... | long long func0(const char *a1, const char **a2, int a3, long long a4)
{
const char *v6; // r9
int v7; // ebx
const char **v8; // rbp
char v9; // al
char *v10; // rdx
int v11; // ecx
if ( a3 <= 0 )
{
v6 = 0LL;
}
else
{
v6 = 0LL;
v7 = -1000;
v8 = &a2[a3];
do
{
v9 = *... | func0:
ENDBR64
PUSH RBP
MOV R8,RDI
MOV R11,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x00101854
MOVSXD RDX,EDX
XOR R9D,R9D
MOV EBX,0xfffffc18
LEA RBP,[RSI + RDX*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001017d8:
MOV R10,qword ptr [RSI]
MOVZX EAX,byte ptr [R10]
TEST AL,AL
JZ 0x00101850
LEA RDX,[R10 + 0x1]
XOR ECX,ECX
JMP 0x001017fe
L... | void func0(int8 param_1,int8 *param_2,int param_3,int8 param_4)
{
int8 *puVar1;
char *pcVar2;
char cVar3;
int iVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
if (param_3 < 1) {
pcVar7 = (char *)0x0;
}
else {
pcVar7 = (char *)0x0;
iVar6 = -1000;
puVar1 = param_2 + param_3;
do {
... |
1,271 | func0 | #include <stdio.h>
#include <string.h>
| void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++)... | #include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tm... | O3 | c | func0:
endbr64
push %rbp
mov %rdi,%r8
mov %rcx,%rdi
push %rbx
test %edx,%edx
jle 1864 <func0+0xa4>
lea -0x1(%rdx),%eax
mov %rsi,%r10
xor %r9d,%r9d
mov $0xfffffc18,%ebx
lea 0x8(%rsi,%rax,8),%rbp
nopw 0x0(%rax,%rax,1)
mov (%r10),%r11
movzbl (%r11),%eax
test %al,%al
je 1860 <func0+... | func0:
endbr64
push rbp
mov r8, rdi
mov r11, rcx
push rbx
test edx, edx
jle loc_1854
movsxd rdx, edx
xor r9d, r9d
mov ebx, 0FFFFFC18h
lea rbp, [rsi+rdx*8]
nop dword ptr [rax+rax+00h]
loc_17D8:
mov r10, [rsi]
movzx eax, byte ptr [r10]
test al, al
jz short loc_1850
lea ... | long long func0(const char *a1, const char **a2, int a3, long long a4)
{
const char *v6; // r9
int v7; // ebx
const char **v8; // rbp
char v9; // al
char *v10; // rdx
int v11; // ecx
if ( a3 <= 0 )
{
v6 = 0LL;
}
else
{
v6 = 0LL;
v7 = -1000;
v8 = &a2[a3];
do
{
v9 = *... | func0:
ENDBR64
PUSH RBP
MOV R8,RDI
MOV R11,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x00101854
MOVSXD RDX,EDX
XOR R9D,R9D
MOV EBX,0xfffffc18
LEA RBP,[RSI + RDX*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001017d8:
MOV R10,qword ptr [RSI]
MOVZX EAX,byte ptr [R10]
TEST AL,AL
JZ 0x00101850
LEA RDX,[R10 + 0x1]
XOR ECX,ECX
JMP 0x001017fe
L... | void func0(int8 param_1,int8 *param_2,int param_3,int8 param_4)
{
int8 *puVar1;
char *pcVar2;
char cVar3;
int iVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
if (param_3 < 1) {
pcVar7 = (char *)0x0;
}
else {
pcVar7 = (char *)0x0;
iVar6 = -1000;
puVar1 = param_2 + param_3;
do {
... |
1,272 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
| bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,-0x10(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
add %... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+src], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], eax
mov rax, [rbp+src]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add eax, eax
add ... | long long func0(const char *a1, const char *a2)
{
int i; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+24h] [rbp-Ch]
char *dest; // [rsp+28h] [rbp-8h]
strlen(a1);
v4 = strlen(a2);
dest = (char *)malloc(2 * v4 + 1);
for ( i = 0; i < v4; ++i )
{
strncpy(dest, &a2[i], v4 - i);
strncpy(&dest[v4 - (long l... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0x10],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP +... | int8 func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
char *__dest;
char *pcVar3;
int local_1c;
strlen(param_1);
sVar2 = strlen(param_2);
iVar1 = (int)sVar2;
__dest = (char *)malloc((long)(iVar1 * 2 + 1));
local_1c = 0;
while( true ) {
if (iVar1 <= local_1c) {
free(__des... |
1,273 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
| bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r14
mov %rsi,%r13
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
lea 0x1(%rbx,%rbx,1),%edi
movslq %edi,%rdi
callq 10... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+haystack], rdi
mov r14, rsi
mov rdi, rsi; s
call _strlen
mov rbx, rax
lea r13d, [rax+rax+1]
movsxd r13, r13d
mov rdi, r13; size
call _malloc
mov r12, rax
test ebx, e... | long long func0(const char *a1, const char *a2)
{
size_t v2; // rbx
size_t v3; // r13
char *v4; // r12
long long v5; // r15
long long i; // rbp
size_t v7; // rcx
long long v9; // [rsp+8h] [rbp-40h]
LODWORD(v2) = strlen(a2);
v3 = 2 * (int)v2 + 1;
v4 = (char *)malloc(v3);
if ( (int)v2 <= 0 )
{
L... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RDI
MOV R14,RSI
MOV RDI,RSI
CALL 0x001010b0
MOV RBX,RAX
LEA R13D,[RAX + RAX*0x1 + 0x1]
MOVSXD R13,R13D
MOV RDI,R13
CALL 0x001010d0
MOV R12,RAX
TEST EBX,EBX
JLE 0x00101292
MOVSXD R15,EBX
LEA EAX,[RBX + -0x1]
MOV qword p... | int8 func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
char *__needle;
char *pcVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
bool bVar7;
sVar2 = strlen(param_2);
iVar1 = (int)sVar2;
sVar2 = (size_t)(iVar1 * 2 + 1);
__needle = (char *)malloc(sVar2);
if (0 < iVar1) {
uVar5 = (... |
1,274 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
| bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
mov %rsi,%rdi
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
callq 10c0 <strlen@plt>
lea 0x1(%rax,%rax,1),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r15
test %ebx,%ebx
jle 1418 <func... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+haystack], rdi
mov rdi, rsi; s
call _strlen
lea ebx, [rax+rax+1]
mov r15, rax
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov rbp, rax
test r15d, r1... | long long func0(const char *a1, const char *a2)
{
int v2; // r15d
size_t v3; // rbx
char *v4; // rax
char *v5; // rbp
size_t v6; // r14
char *v7; // r13
long long v8; // rax
long long v9; // r15
size_t v10; // rcx
char *v12; // [rsp+10h] [rbp-48h]
long long v13; // [rsp+18h] [rbp-40h]
v2 = str... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,RSI
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1 + 0x1]
MOV R15,RAX
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x001010d0
MOV RBP,RAX
TEST R15D,R15D
JLE 0x00101440
MOVSXD R14,R15D
LEA R13,[RAX + R14*0x1]
L... | int8 func0(char *param_1,char *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *__needle;
char *pcVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
__needle = (char *)malloc(sVar3);
if (0 < iVar2) {
uVar6 =... |
1,275 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
| bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
mov %rsi,%rdi
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
callq 10c0 <strlen@plt>
lea 0x1(%rax,%rax,1),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r15
test %ebx,%ebx
jle 1418 <func... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+haystack], rdi
mov rdi, rsi; s
call _strlen
lea ebx, [rax+rax+1]
mov r15, rax
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov rbp, rax
test r15d, r1... | long long func0(const char *a1, const char *a2)
{
int v2; // r15d
size_t v3; // rbx
char *v4; // rax
char *v5; // rbp
size_t v6; // r14
char *v7; // r13
long long v8; // rax
long long v9; // r15
size_t v10; // rcx
char *v12; // [rsp+10h] [rbp-48h]
long long v13; // [rsp+18h] [rbp-40h]
v2 = str... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,RSI
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1 + 0x1]
MOV R15,RAX
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x001010d0
MOV RBP,RAX
TEST R15D,R15D
JLE 0x00101440
MOVSXD R14,R15D
LEA R13,[RAX + R14*0x1]
L... | int8 func0(char *param_1,char *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *__needle;
char *pcVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
__needle = (char *)malloc(sVar3);
if (0 < iVar2) {
uVar6 =... |
1,276 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
... | #include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x14(%rbp),%eax
sar $0x1f,%eax
xor %eax,-0x14(%rbp)
sub %eax,-0x14(%rbp)
mov -0x14(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov eax, [rbp+var_14]
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_14], eax
loc_11B3:
mov edx, [rbp+var_14]
movsxd rax, edx
imul rax, 66666667h
shr ... | long long func0(int a1, _DWORD *a2)
{
int v2; // eax
long long result; // rax
int v4; // [rsp+Ch] [rbp-14h]
int v5; // [rsp+14h] [rbp-Ch]
unsigned int v6; // [rsp+18h] [rbp-8h]
v5 = 0;
v6 = 0;
v2 = a1;
if ( a1 <= 0 )
v2 = -a1;
v4 = v2;
do
{
if ( ((v4 % 10) & 1) != 0 )
++v6;
e... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
LAB_001011b3:
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RAX,ED... | void func0(int param_1,int *param_2)
{
int local_1c;
int local_14;
int local_10;
local_14 = 0;
local_10 = 0;
local_1c = param_1;
if (param_1 < 1) {
local_1c = -param_1;
}
do {
if ((local_1c % 10 & 1U) == 0) {
local_14 = local_14 + 1;
}
else {
local_10 = local_10 + 1;
... |
1,277 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
... | #include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, ... | O1 | c | func0:
endbr64
mov %edi,%eax
sar $0x1f,%eax
xor %eax,%edi
sub %eax,%edi
mov $0x0,%ecx
mov $0x0,%r8d
jmp 11c3 <func0+0x3a>
add $0x1,%r8d
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
cmp $0x9,%edi
jle 11ce <func0+0x45>
mo... | func0:
endbr64
mov edx, edi
neg edx
cmovs edx, edi
mov edi, 0
mov r8d, 0
jmp short loc_11C1
loc_11A1:
add r8d, 1
loc_11A5:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
cmp edx, 9
jle short loc_11CB
mov edx, eax
loc_11C1... | long long func0(int a1, _DWORD *a2)
{
int v2; // edx
int v3; // edi
int v4; // r8d
long long result; // rax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = 0;
v4 = 0;
while ( 1 )
{
if ( (v2 & 1) != 0 )
++v3;
else
++v4;
result = (unsigned int)(v2 / 10);
if ( v2 <= 9 )
br... | func0:
ENDBR64
MOV EDX,EDI
NEG EDX
CMOVS EDX,EDI
MOV EDI,0x0
MOV R8D,0x0
JMP 0x001011c1
LAB_001011a1:
ADD R8D,0x1
LAB_001011a5:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
CMP EDX,0x9
JLE 0x001011cb
MOV EDX,EAX
LAB_001011c1:
TEST DL,0x1
JZ 0x001011a1
ADD EDI,0x1
JMP 0x001011... | void func0(uint param_1,int *param_2)
{
bool bVar1;
uint uVar2;
int iVar3;
int iVar4;
uVar2 = -param_1;
if (0 < (int)param_1) {
uVar2 = param_1;
}
iVar3 = 0;
iVar4 = 0;
do {
if ((uVar2 & 1) == 0) {
iVar4 = iVar4 + 1;
}
else {
iVar3 = iVar3 + 1;
}
bVar1 = 9 < (... |
1,278 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
... | #include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, ... | O2 | c | func0:
endbr64
mov %edi,%eax
xor %edx,%edx
xor %ecx,%ecx
mov $0xcccccccd,%r8d
sar $0x1f,%eax
xor %eax,%edi
sub %eax,%edi
jmp 1412 <func0+0x32>
nopl 0x0(%rax)
imul %r8,%rax
add $0x1,%ecx
shr $0x23,%rax
cmp $0x9,%edi
jle 142a <func0+0x4a>
mov %eax,%edi
mov %edi,%eax
test $0... | func0:
endbr64
mov edx, edi
mov r8d, 0CCCCCCCDh
neg edx
cmovs edx, edi
xor ecx, ecx
xor edi, edi
jmp short loc_1422
loc_1410:
imul rax, r8
add edi, 1
shr rax, 23h
cmp edx, 9
jle short loc_1439
loc_1420:
mov edx, eax
loc_1422:
mov eax, edx
test dl, 1
jz short ... | unsigned long long func0(int a1, _DWORD *a2)
{
int v2; // edx
int v3; // ecx
int v4; // edi
unsigned long long result; // rax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = 0;
v4 = 0;
while ( (v2 & 1) == 0 )
{
++v4;
result = (unsigned int)v2 / 0xAuLL;
if ( v2 <= 9 )
goto LABEL_8;
LABE... | func0:
ENDBR64
MOV EDX,EDI
MOV R8D,0xcccccccd
NEG EDX
CMOVS EDX,EDI
XOR ECX,ECX
XOR EDI,EDI
JMP 0x00101422
LAB_00101410:
IMUL RAX,R8
ADD EDI,0x1
SHR RAX,0x23
CMP EDX,0x9
JLE 0x00101439
LAB_00101420:
MOV EDX,EAX
LAB_00101422:
MOV EAX,EDX
TEST DL,0x1
JZ 0x00101410
IMUL RAX,R8
ADD ECX,0x1
SHR RAX,0x23
CMP EDX,0x9
JG 0x001... | void func0(uint param_1,int *param_2)
{
uint uVar1;
int iVar2;
ulong uVar3;
int iVar4;
uVar3 = (ulong)-param_1;
if (0 < (int)param_1) {
uVar3 = (ulong)param_1;
}
iVar2 = 0;
iVar4 = 0;
while( true ) {
if ((uVar3 & 1) == 0) {
iVar4 = iVar4 + 1;
uVar1 = (uint)(uVar3 / 10);
}... |
1,279 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
... | #include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, ... | O3 | c | func0:
endbr64
mov %edi,%eax
xor %edx,%edx
xor %ecx,%ecx
mov $0xcccccccd,%r8d
sar $0x1f,%eax
xor %eax,%edi
sub %eax,%edi
jmp 11f2 <func0+0x32>
nopl 0x0(%rax)
imul %r8,%rax
add $0x1,%ecx
shr $0x23,%rax
cmp $0x9,%edi
jle 120a <func0+0x4a>
mov %eax,%edi
mov %edi,%eax
test $0... | func0:
endbr64
mov edx, edi
mov r8d, 0CCCCCCCDh
neg edx
cmovs edx, edi
xor ecx, ecx
xor edi, edi
jmp short loc_11E2
loc_11D0:
imul rax, r8
add edi, 1
shr rax, 23h
cmp edx, 9
jle short loc_11F9
loc_11E0:
mov edx, eax
loc_11E2:
mov eax, edx
test dl, 1
jz short ... | unsigned long long func0(int a1, _DWORD *a2)
{
int v2; // edx
int v3; // ecx
int v4; // edi
unsigned long long result; // rax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = 0;
v4 = 0;
while ( (v2 & 1) == 0 )
{
++v4;
result = (unsigned int)v2 / 0xAuLL;
if ( v2 <= 9 )
goto LABEL_8;
LABE... | func0:
ENDBR64
MOV EDX,EDI
MOV R8D,0xcccccccd
NEG EDX
CMOVS EDX,EDI
XOR ECX,ECX
XOR EDI,EDI
JMP 0x001011e2
LAB_001011d0:
IMUL RAX,R8
ADD EDI,0x1
SHR RAX,0x23
CMP EDX,0x9
JLE 0x001011f9
LAB_001011e0:
MOV EDX,EAX
LAB_001011e2:
MOV EAX,EDX
TEST DL,0x1
JZ 0x001011d0
IMUL RAX,R8
ADD ECX,0x1
SHR RAX,0x23
CMP EDX,0x9
JG 0x001... | void func0(uint param_1,int *param_2)
{
uint uVar1;
int iVar2;
ulong uVar3;
int iVar4;
uVar3 = (ulong)-param_1;
if (0 < (int)param_1) {
uVar3 = (ulong)param_1;
}
iVar2 = 0;
iVar4 = 0;
while( true ) {
if ((uVar3 & 1) == 0) {
iVar4 = iVar4 + 1;
uVar1 = (uint)(uVar3 / 10);
}... |
1,280 | func0 | #include <stdio.h>
#include <string.h>
| void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
... | #include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %edi,-0xc4(%rbp)
mov %rsi,-0xd0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe2d(%rip),%rax
mov %rax,-0x70(%rbp)
lea 0xe24(%rip),%rax
mov %rax,-0x68(%rbp)
lea 0xe1c(%rip),%rax
mov %rax,-0x60(%rbp)
lea ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_C4], edi
mov [rbp+dest], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aM; "m"
mov [rbp+src], rax
lea rax, aCm; "cm"
mov [rbp+var_68], rax
lea rax, aD; "d"
mov [rbp+var_60], rax
lea ... | unsigned long long func0(int a1, char *a2)
{
int v4; // [rsp+1Ch] [rbp-B4h]
_DWORD v5[16]; // [rsp+20h] [rbp-B0h]
char *src[13]; // [rsp+60h] [rbp-70h]
unsigned long long v7; // [rsp+C8h] [rbp-8h]
v7 = __readfsqword(0x28u);
src[0] = "m";
src[1] = "cm";
src[2] = "d";
src[3] = "cd";
src[4] = "c";
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV dword ptr [RBP + -0xc4],EDI
MOV qword ptr [RBP + -0xd0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[0x10200a]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[0x10200d]
MOV qword ptr [... | void func0(int param_1,char *param_2)
{
long in_FS_OFFSET;
int local_cc;
int local_bc;
int local_b8 [16];
int *local_78 [4];
int *local_58;
int *local_50;
int *local_48;
int *local_40;
int *local_38;
int *local_30;
int *local_28;
int *local_20;
int *local_18;
long local_10;
local_10 ... |
1,281 | func0 | #include <stdio.h>
#include <string.h>
| void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
... | #include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0xe4f(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xe42(%rip),%rax
mov %rax,0x48(%rsp)
lea 0xe3a(%rip),%rax
mov %rax,0x50(%rsp)
lea 0xe2d(%rip),%rax
m... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0D8h+var_30], rax
xor eax, eax
lea rax, aCm+1; "m"
mov [rsp+0D8h+var_98], rax
lea rax, aCm; "cm"
mov [rsp+0D8h+var_90], rax
lea rax, aCd+1; "d"
mov [rsp+0D8h+var_88],... | unsigned long long func0(int a1, char *a2)
{
int v2; // ebx
int *v3; // r14
const char **i; // r12
int v5; // ebp
_DWORD v7[16]; // [rsp+0h] [rbp-D8h] BYREF
_QWORD v8[13]; // [rsp+40h] [rbp-98h] BYREF
unsigned long long v9; // [rsp+A8h] [rbp-30h]
v9 = __readfsqword(0x28u);
v8[0] = "m";
v8[1] = "cm... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RAX,[0x102005]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x48],RAX
LEA RAX,[0x102008]
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[0x102007]
MOV qwo... | void func0(int param_1,char *param_2)
{
int iVar1;
int **ppuVar2;
int *piVar3;
long in_FS_OFFSET;
int local_d8 [16];
int *local_98 [4];
int *local_78;
int *local_70;
int *local_68;
int *local_60;
int *local_58;
int *local_50;
int *local_48;
int *local_40;
int *local_38;
long local_30;
... |
1,282 | func0 | #include <stdio.h>
#include <string.h>
| void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
... | #include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0xac8(%rip),%rax
movb $0x0,(%rsi)
mov %rax,0x40(%rsp)
lea 0xab8(%rip),%rax
mov %rax,0x48(%rsp)
lea 0xab0(%rip),%rax
mov %rax,0x50(%rsp)
lea ... | func0:
endbr64
push r15
lea rcx, unk_2005
push r14
movq xmm0, rcx
lea rcx, unk_2008
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
lea rax, unk_2004
mov [rsp+0E8h+var_B8], 1
mov byte ptr [rsi], 0
movq xmm1, rax
lea ... | unsigned long long func0(int a1, char *a2)
{
int v2; // ebx
char *v3; // rdx
long long i; // r13
int v5; // ebp
const char *v6; // r12
_OWORD v8[3]; // [rsp+0h] [rbp-E8h]
int v9; // [rsp+30h] [rbp-B8h]
_OWORD v10[6]; // [rsp+40h] [rbp-A8h]
char *v11; // [rsp+A0h] [rbp-48h]
unsigned long long v12; /... | func0:
ENDBR64
PUSH R15
LEA RCX,[0x102005]
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x102008]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
LEA RAX,[0x102004]
MOV dword ptr [RSP + 0x30],0x1
MOV byte ptr [RSI],0x0
MOVQ XMM1,RAX
LEA RAX,[0x102007]
PUNPCKLQDQ XMM0,XMM1
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int param_1,char *param_2)
{
int iVar1;
char *__src;
long lVar2;
long in_FS_OFFSET;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int4 local_b8;
int *l... |
1,283 | func0 | #include <stdio.h>
#include <string.h>
| void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
... | #include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(... | O3 | c | func0:
endbr64
push %r15
lea 0xae8(%rip),%rcx
mov %rsi,%rdx
push %r14
movq %rcx,%xmm0
lea 0xada(%rip),%rcx
push %r13
xor %r13d,%r13d
push %r12
push %rbp
push %rbx
mov %edi,%ebx
sub $0xb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0xaaa(%rip),%rax
movb $0x0... | func0:
endbr64
push r15
lea rcx, unk_2005
push r14
movq xmm0, rcx
lea rcx, unk_2008
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
lea rax, unk_2004
mov [rsp+0E8h+var_B8], 1
mov byte ptr [rsi], 0
movq xmm1, rax
lea ... | unsigned long long func0(int a1, char *a2)
{
int v2; // ebx
char *v3; // rdx
long long i; // r13
int v5; // ebp
const char *v6; // r12
_OWORD v8[3]; // [rsp+0h] [rbp-E8h]
int v9; // [rsp+30h] [rbp-B8h]
_OWORD v10[6]; // [rsp+40h] [rbp-A8h]
char *v11; // [rsp+A0h] [rbp-48h]
unsigned long long v12; /... | func0:
ENDBR64
PUSH R15
LEA RCX,[0x102005]
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x102008]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
LEA RAX,[0x102004]
MOV dword ptr [RSP + 0x30],0x1
MOV byte ptr [RSI],0x0
MOVQ XMM1,RAX
LEA RAX,[0x102007]
PUNPCKLQDQ XMM0,XMM1
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int param_1,char *param_2)
{
int iVar1;
char *__src;
long lVar2;
long in_FS_OFFSET;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int4 local_b8;
int *l... |
1,284 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(fun... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss %xmm2,-0xc(%rbp)
movss -0x4(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss %xmm0,%xmm1
movss -0x8(%rbp),%xmm0
mulss %xmm0,%xmm0
addss %xmm0,%xmm1
movss -0xc(%rbp),%xmm0
mulss %xmm0,%xmm0
subss %xmm0,%xmm1
movaps %xmm1,%xmm0... | func0:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
movss xmm0, [rbp+var_4]
movaps xmm1, xmm0
mulss xmm1, xmm0
movss xmm0, [rbp+var_8]
mulss xmm0, xmm0
addss xmm1, xmm0
movss xmm0, [rbp+var_C]
movaps xmm2, xmm0
mulss xmm2, xmm0
subss ... | _BOOL8 func0(float a1, float a2, float a3)
{
return fabs((float)((float)(a1 * a1) + (float)(a2 * a2)) - (float)(a3 * a3)) < 0.0001
|| fabs((float)((float)(a1 * a1) + (float)(a3 * a3)) - (float)(a2 * a2)) < 0.0001
|| fabs((float)((float)(a2 * a2) + (float)(a3 * a3)) - (float)(a1 * a1)) < 0.0001;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x8]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0xc]
MOVAPS XMM2,XMM... | int8 func0(float param_1,float param_2,float param_3)
{
int8 uVar1;
if ((((double)(float)((uint)((param_1 * param_1 + param_2 * param_2) - param_3 * param_3) &
DAT_00102120) < DAT_00102130) ||
((double)(float)((uint)((param_1 * param_1 + param_3 * param_3) - param_2 * param_2) &
... |
1,285 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(fun... | O1 | c | func0:
endbr64
mulss %xmm0,%xmm0
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps 0xec5(%rip),%xmm3
cvtss2sd %xmm3,%xmm3
mov $0x1,%eax
movsd 0xec4(%rip),%xmm4
comisd %xmm3,%xmm4
ja 119b <func0+0x72>
movaps %xmm0,%xmm3
addss %xmm2,%xmm3
subss %xmm1,%xmm3
an... | func0:
endbr64
movaps xmm3, xmm0
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, cs:xmmword_2010
cvtss2sd xmm0, xmm0
mov eax, 1
movsd xmm4, cs:qword_2020
comisd xmm4, xmm0
ja short locret_119E
movaps xmm0, xmm3
addss xmm0, x... | _BOOL8 func0(float a1, float a2, float a3)
{
float v3; // xmm3_4
float v4; // xmm1_4
float v5; // xmm2_4
_BOOL8 result; // rax
v3 = a1 * a1;
v4 = a2 * a2;
v5 = a3 * a3;
result = 1LL;
if ( fabs((float)((float)(a1 * a1) + v4) - v5) >= 0.0001 && fabs((float)(v3 + v5) - v4) >= 0.0001 )
return fabs((... | func0:
ENDBR64
MOVAPS XMM3,XMM0
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,xmmword ptr [0x00102010]
CVTSS2SD XMM0,XMM0
MOV EAX,0x1
MOVSD XMM4,qword ptr [0x00102020]
COMISD XMM4,XMM0
JA 0x0010119e
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,XMM1
ANDPS XMM0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
param_1 = param_1 * param_1;
param_2 = param_2 * param_2;
param_3 = param_3 * param_3;
bVar1 = true;
if ((DAT_00102020 <= (double)(float)((uint)((para... |
1,286 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(fun... | O2 | c | func0:
endbr64
mulss %xmm0,%xmm0
movsd 0xed0(%rip),%xmm4
movss 0xeb8(%rip),%xmm5
mov $0x1,%eax
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ad <func0+0x6d>
movaps %xmm0,%xmm3
addss %xmm2,%xmm3
su... | func0:
endbr64
movaps xmm3, xmm0
movsd xmm4, cs:qword_2020
movss xmm5, cs:dword_2010
mov eax, 1
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11B0
movaps xmm0, xmm... | _BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
float v4; // xmm3_4
float v5; // xmm1_4
float v6; // xmm2_4
result = 1LL;
v4 = a1 * a1;
v5 = a2 * a2;
v6 = a3 * a3;
if ( fabs((float)((float)(a1 * a1) + v5) - v6) >= 0.0001 && fabs((float)(v4 + v6) - v5) >= 0.0001 )
return fabs((... | func0:
ENDBR64
MOVAPS XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102020]
MOVSS XMM5,dword ptr [0x00102010]
MOV EAX,0x1
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011b0
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,X... | bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
bVar1 = true;
param_1 = param_1 * param_1;
param_2 = param_2 * param_2;
param_3 = param_3 * param_3;
if ((DAT_00102020 <= (double)(float)((uint)((param_1 + param_2) - param_3) & DAT_00102010)) &&
(DAT_00102020 <= (double)(float)((u... |
1,287 | func0 | #include <stdio.h>
#include <math.h>
| int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(fun... | O3 | c | func0:
endbr64
mulss %xmm0,%xmm0
movsd 0xed0(%rip),%xmm4
movss 0xeb8(%rip),%xmm5
mov $0x1,%eax
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ad <func0+0x6d>
movaps %xmm0,%xmm3
addss %xmm2,%xmm3
su... | func0:
endbr64
movaps xmm3, xmm0
movsd xmm4, cs:qword_2020
movss xmm5, cs:dword_2010
mov eax, 1
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11B0
movaps xmm0, xmm... | _BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
float v4; // xmm3_4
float v5; // xmm1_4
float v6; // xmm2_4
result = 1LL;
v4 = a1 * a1;
v5 = a2 * a2;
v6 = a3 * a3;
if ( fabs((float)((float)(a1 * a1) + v5) - v6) >= 0.0001 && fabs((float)(v4 + v6) - v5) >= 0.0001 )
return fabs((... | func0:
ENDBR64
MOVAPS XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102020]
MOVSS XMM5,dword ptr [0x00102010]
MOV EAX,0x1
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011b0
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,X... | bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
bVar1 = true;
param_1 = param_1 * param_1;
param_2 = param_2 * param_2;
param_3 = param_3 * param_3;
if ((DAT_00102020 <= (double)(float)((uint)((param_1 + param_2) - param_3) & DAT_00102010)) &&
(DAT_00102020 <= (double)(float)((u... |
1,288 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
... | #include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(fu... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x140,%rsp
mov %rdi,-0x138(%rbp)
mov %esi,-0x13c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe0d(%rip),%rax
mov %rax,-0x118(%rbp)
movl $0x0,-0x12c(%rbp)
movl $0x0,-0x128(%rbp)
jmpq 14d7 <func0+0x30e>
movq $0x0,-0x110(%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 140h
mov [rbp+var_138], rdi
mov [rbp+var_13C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, unk_2008
mov [rbp+s2], rax
mov [rbp+var_12C], 0
mov [rbp+var_128], 0
jmp loc_14D7
loc_121B:
mov qword ptr [rb... | char * func0(long long a1, int a2)
{
int v3; // [rsp+14h] [rbp-12Ch]
int i; // [rsp+18h] [rbp-128h]
int v5; // [rsp+1Ch] [rbp-124h]
int j; // [rsp+20h] [rbp-120h]
int v7; // [rsp+24h] [rbp-11Ch]
char *s2; // [rsp+28h] [rbp-118h]
char s[8]; // [rsp+30h] [rbp-110h] BYREF
long long v10; // [rsp+38h] [rbp-1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x140
MOV qword ptr [RBP + -0x138],RDI
MOV dword ptr [RBP + -0x13c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x118],RAX
MOV dword ptr [RBP + -0x12c],0x0
MOV dword ptr [RBP + -0x128],0x0
JMP 0x001014d7
... | char * func0(long param_1,int param_2)
{
int iVar1;
char *pcVar2;
size_t sVar3;
long in_FS_OFFSET;
int local_134;
int local_130;
int local_12c;
int local_128;
char *local_120;
char local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_120 = "";
local_134 = 0;
... |
1,289 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
... | #include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(fu... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
lea 0xe4c(%rip),%rax
mov %rax,0x10(%rsp)
test %esi,%esi
jle 141a <func0+0x271>
mov %rdi,%r14
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
lea rax, aAaaaaaa+7; ""
mov [rsp+168h+s2], rax
test esi, esi
jle loc_1430
mov r14, rdi
movsxd rsi, esi
lea rax, [rdi+rsi*8]... | char * func0(const char **a1, int a2)
{
const char **v2; // r14
int v3; // eax
int v4; // r13d
char *v5; // rbp
char v6; // bl
int v7; // eax
const char *v8; // r15
int v10; // [rsp+Ch] [rbp-15Ch]
char *s2; // [rsp+10h] [rbp-158h]
_QWORD v12[41]; // [rsp+20h] [rbp-148h] BYREF
v12[33] = __readfsqw... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[0x102024]
MOV qword ptr [RSP + 0x10],RAX
TEST ESI,ESI
JLE 0x00101430
MOV R14,RDI
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV d... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s1;
int iVar2;
int iVar3;
size_t sVar4;
char *pcVar5;
char cVar6;
char *pcVar7;
int iVar8;
long in_FS_OFFSET;
int local_15c;
char *local_158;
char local_148 [264];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
... |
1,290 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
... | #include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(fu... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
lea 0x995(%rip),%rax
mov %rax,0x18(%rsp)
test %esi,%esi
jle 1807 <func0+0x1a7>
lea -0x1(%rsi),%eax
movl $0x0,0xc(%rsp)
mov %rdi,%rbp
... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov rax, fs:28h
mov [rsp+168h+var_40], rax
lea rax, aAaaaaaa+7; ""
mov [rsp+168h+s2], rax
test esi, esi
jle loc_18A2
movsxd rsi, esi
mov [rsp+168h+var_15C], 0
mov r12, rdi
lea rbx... | char * func0(const char **a1, int a2)
{
const char **v2; // r12
const char *v3; // r13
char v4; // r14
char *v5; // r15
int v6; // ebp
int v7; // eax
int v9; // [rsp+Ch] [rbp-15Ch]
char *s2; // [rsp+18h] [rbp-150h]
char s[16]; // [rsp+20h] [rbp-148h] BYREF
__int128 v12; // [rsp+30h] [rbp-138h]
__i... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
LEA RAX,[0x102040]
MOV qword ptr [RSP + 0x18],RAX
TEST ESI,ESI
JLE 0x001018a2
MOVSXD RSI,ESI
MOV dword ptr [RSP + 0xc],0x0
MOV R12,RDI
LEA RBX,[RSP + 0x20]
LEA RAX,[RDI + RSI*0x... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s1;
int iVar2;
char *pcVar3;
size_t sVar4;
int iVar5;
char cVar6;
char *pcVar7;
long in_FS_OFFSET;
int local_15c;
char *local_150;
int local_148 [16];
int local_138 [16];
int local_128 [16];
int local_118 [16];
int local_10... |
1,291 | func0 | #include <stdio.h>
#include <string.h>
| char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
... | #include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(fu... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
lea 0x955(%rip),%rax
mov %rax,0x18(%rsp)
test %esi,%esi
jle 17ef <func0+0x14f>
lea -0x1(%rsi),%eax
movl $0x0,0xc(%rsp)
mov %rdi,%rbp
... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov rax, fs:28h
mov [rsp+168h+var_40], rax
lea rax, aAaaaaaa+7; ""
mov [rsp+168h+s2], rax
test esi, esi
jle loc_1877
movsxd rsi, esi
mov [rsp+168h+var_15C], 0
mov r12, rdi
lea rbx... | char * func0(const char **a1, int a2)
{
const char **i; // r12
const char *v3; // r13
char v4; // r14
char *v5; // r15
int v6; // ebp
bool v7; // zf
int v9; // eax
int v10; // [rsp+Ch] [rbp-15Ch]
char *s2; // [rsp+18h] [rbp-150h]
char s[16]; // [rsp+20h] [rbp-148h] BYREF
__int128 v13; // [rsp+30h]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
LEA RAX,[0x102040]
MOV qword ptr [RSP + 0x18],RAX
TEST ESI,ESI
JLE 0x00101877
MOVSXD RSI,ESI
MOV dword ptr [RSP + 0xc],0x0
MOV R12,RDI
LEA RBX,[RSP + 0x20]
LEA RAX,[RDI + RSI*0x... | char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s1;
int iVar2;
int iVar3;
char *pcVar4;
size_t sVar5;
char cVar6;
char *pcVar7;
long in_FS_OFFSET;
int local_15c;
char *local_150;
int local_148 [16];
int local_138 [16];
int local_128 [16];
int local_118 [16];
int local_10... |
1,292 | func0 | #include <stdio.h>
| void func0(int number, int need, int remaining, int result[2]) {
if (need > remaining) {
result[0] = number + remaining;
result[1] = 0;
} else {
result[0] = number + need;
result[1] = remaining - need;
}
} | #include <assert.h>
int issame(int a[2], int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0(5, 6, 10, result);
assert(issame(result, (const int[]){11, 4}));
func0(4, 8, 9, result);
assert(issame(result, (const int[]){12, 1}));
func0(1, 10, 10, result);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov %rcx,-0x18(%rbp)
mov -0x8(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 11a4 <func0+0x3b>
mov -0x4(%rbp),%edx
mov -0xc(%rbp),%eax
add %eax,%edx
mov -0x18(%rbp),%rax
mov %edx,(%rax)
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov [rbp+var_18], rcx
mov eax, [rbp+var_8]
cmp eax, [rbp+var_C]
jle short loc_11A4
mov edx, [rbp+var_4]
mov eax, [rbp+var_C]
add edx, eax
mov rax, [rbp+var_18]
mov [... | unsigned long long func0(int a1, int a2, int a3, _DWORD *a4)
{
unsigned long long result; // rax
if ( a2 <= a3 )
{
*a4 = a2 + a1;
result = (unsigned int)(a3 - a2);
a4[1] = result;
}
else
{
*a4 = a3 + a1;
result = (unsigned long long)(a4 + 1);
a4[1] = 0;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x001011a4
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0xc]
ADD EDX,EAX
MOV RAX,... | void func0(int param_1,int param_2,int param_3,int *param_4)
{
if (param_3 < param_2) {
*param_4 = param_1 + param_3;
param_4[1] = 0;
}
else {
*param_4 = param_1 + param_2;
param_4[1] = param_3 - param_2;
}
return;
} |
1,293 | func0 | #include <stdio.h>
| void func0(int number, int need, int remaining, int result[2]) {
if (need > remaining) {
result[0] = number + remaining;
result[1] = 0;
} else {
result[0] = number + need;
result[1] = remaining - need;
}
} | #include <assert.h>
int issame(int a[2], int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0(5, 6, 10, result);
assert(issame(result, (const int[]){11, 4}));
func0(4, 8, 9, result);
assert(issame(result, (const int[]){12, 1}));
func0(1, 10, 10, result);
... | O1 | c | func0:
endbr64
cmp %edx,%esi
jle 117d <func0+0x14>
add %edi,%edx
mov %edx,(%rcx)
movl $0x0,0x4(%rcx)
retq
add %esi,%edi
mov %edi,(%rcx)
sub %esi,%edx
mov %edx,0x4(%rcx)
retq
| func0:
endbr64
cmp esi, edx
jle short loc_117E
add edi, edx
mov edx, 0
loc_1178:
mov [rcx], edi
mov [rcx+4], edx
retn
loc_117E:
add edi, esi
sub edx, esi
jmp short loc_1178 | void func0(int a1, int a2, int a3, _DWORD *a4)
{
int v4; // edi
int v5; // edx
if ( a2 <= a3 )
{
v4 = a2 + a1;
v5 = a3 - a2;
}
else
{
v4 = a3 + a1;
v5 = 0;
}
*a4 = v4;
a4[1] = v5;
} | func0:
ENDBR64
CMP ESI,EDX
JLE 0x0010117e
ADD EDI,EDX
MOV EDX,0x0
LAB_00101178:
MOV dword ptr [RCX],EDI
MOV dword ptr [RCX + 0x4],EDX
RET
LAB_0010117e:
ADD EDI,ESI
SUB EDX,ESI
JMP 0x00101178 | void func0(int param_1,int param_2,int param_3,int *param_4)
{
if (param_3 < param_2) {
param_1 = param_1 + param_3;
param_3 = 0;
}
else {
param_1 = param_1 + param_2;
param_3 = param_3 - param_2;
}
*param_4 = param_1;
param_4[1] = param_3;
return;
} |
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.