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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
794 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l, int size, int *out_size) {
int *out = malloc(size * sizeof(int));
int found, out_count = 0, i, j;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < out_count; j++) {
if (l[i] == out[j]) {
found = 1;
break;
}
... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int main() {
int test_array[] = {5, 3, 5, 2, 3, 3, 9, 0, 123};
int expected_array[] = {0, 2, 3, 5, 9, 123};
int unique_size;
int *unique_array = func0(test_array, sizeof(test_array) / sizeof(test_array[0]), &unique_size);
assert(unique_siz... | O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %r12d,%r12d
jle 13c9 <func0+0xd9>
lea -0x1(%r12),%edx
mov %rbx,%r8
lea 0x4(%rax),%r11
xor %r9d,%r9d
lea 0x4(%rbx,%rdx,4),%r10
nopw 0... | func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
movsxd rdi, esi
lea r12, ds:0[rdi*4]
mov r13, rdi
mov rdi, r12; size
sub rsp, 8
call _malloc
mov r10, rax
test r13d, r13d
jle loc_13C6
mov rsi, rbx
lea rdi, [rbx+r12]
xor r9d, r9d
... | _DWORD * func0(int *a1, int a2, int *a3)
{
size_t v4; // r12
_DWORD *v5; // r10
int *v6; // rsi
int *v7; // rdi
int v8; // r9d
int v9; // edx
_DWORD *v10; // rax
_DWORD *v11; // rsi
long long i; // r8
_DWORD *v13; // rax
int v14; // edx
v4 = a2;
v5 = malloc(v4 * 4);
if ( a2 <= 0 )
{
v... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA R12,[RDI*0x4]
MOV R13,RDI
MOV RDI,R12
SUB RSP,0x8
CALL 0x001010d0
MOV R10,RAX
TEST R13D,R13D
JLE 0x001013c6
MOV RSI,RBX
LEA RDI,[RBX + R12*0x1]
XOR R9D,R9D
LAB_00101310:
MOVSXD R8,R9D
MOV EDX,dword ptr [RSI]
LEA RCX,[R10 + R8*... | int * func0(int *param_1,int param_2,uint *param_3)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
ulong uVar5;
uint uVar6;
piVar2 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
uVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
uVar6 = 0;
do {
iVar4 = *param_1;
... |
795 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l, int size, int *out_size) {
int *out = malloc(size * sizeof(int));
int found, out_count = 0, i, j;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < out_count; j++) {
if (l[i] == out[j]) {
found = 1;
break;
}
... | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int main() {
int test_array[] = {5, 3, 5, 2, 3, 3, 9, 0, 123};
int expected_array[] = {0, 2, 3, 5, 9, 123};
int unique_size;
int *unique_array = func0(test_array, sizeof(test_array) / sizeof(test_array[0]), &unique_size);
assert(unique_siz... | O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%r12
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %r12d,%r12d
jle 13a9 <func0+0xd9>
lea -0x1(%r12),%edx
mov %rbx,%r8
lea 0x4(%rax),%r11
xor %r9d,%r9d
lea 0x4(%rbx,%rdx,4),%r10
nopw 0... | func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
movsxd rdi, esi
lea r12, ds:0[rdi*4]
mov r13, rdi
mov rdi, r12; size
sub rsp, 8
call _malloc
mov r10, rax
test r13d, r13d
jle loc_13B6
mov rsi, rbx
lea rdi, [rbx+r12]
xor r9d, r9d
... | _DWORD * func0(int *a1, int a2, int *a3)
{
size_t v4; // r12
_DWORD *v5; // r10
int *v6; // rsi
int *v7; // rdi
int v8; // r9d
int v9; // edx
_DWORD *v10; // rax
_DWORD *v11; // rsi
long long i; // r8
_DWORD *v13; // rax
int v14; // edx
v4 = a2;
v5 = malloc(v4 * 4);
if ( a2 <= 0 )
{
v... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
LEA R12,[RDI*0x4]
MOV R13,RDI
MOV RDI,R12
SUB RSP,0x8
CALL 0x001010d0
MOV R10,RAX
TEST R13D,R13D
JLE 0x001013b6
MOV RSI,RBX
LEA RDI,[RBX + R12*0x1]
XOR R9D,R9D
LAB_00101300:
MOVSXD R8,R9D
MOV EDX,dword ptr [RSI]
LEA RCX,[R10 + R8*... | int * func0(int *param_1,int param_2,uint *param_3)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
ulong uVar5;
uint uVar6;
piVar2 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
uVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
uVar6 = 0;
do {
iVar4 = *param_1;
... |
796 | func0 | #include <stdio.h>
| float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movss 0xf24(%rip),%xmm0
movss %xmm0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11cd <func0+0x64>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
comiss -0x8(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
movss xmm0, cs:dword_2084
movss [rbp+var_8], xmm0
mov [rbp+var_4], 0
jmp short loc_11CD
loc_118E:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dw... | float func0(long long a1, int a2)
{
float v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = -10000.0;
for ( i = 0; i < a2; ++i )
{
if ( *(float *)(4LL * i + a1) > v3 )
v3 = *(float *)(4LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOVSS XMM0,dword ptr [0x00102084]
MOVSS dword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cd
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RA... | float func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = DAT_00102084;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_10 < *(float *)(param_1 + (long)local_c * 4)) {
local_10 = *(float *)(param_1 + (long)local_c * 4);
}
}
return local_10;
} |
797 | func0 | #include <stdio.h>
| float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
} | O1 | c | func0:
endbr64
test %esi,%esi
jle 1199 <func0+0x30>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
movss 0xf18(%rip),%xmm0
movss (%rax),%xmm1
maxss %xmm0,%xmm1
movaps %xmm1,%xmm0
add $0x4,%rax
cmp %rdx,%rax
jne 1184 <func0+0x1b>
retq
movss 0xefb(%rip),%xmm0
retq
| func0:
endbr64
test esi, esi
jle short loc_1198
mov rax, rdi
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
movss xmm0, cs:dword_2004
loc_1183:
movss xmm1, dword ptr [rax]
maxss xmm1, xmm0
movaps xmm0, xmm1
add rax, 4
cmp rax, rdx
jnz short loc_1183
retn
loc_1198:
movss xmm0, cs:dword_2004
re... | float func0(float *a1, int a2)
{
float *v2; // rax
float result; // xmm0_4
if ( a2 <= 0 )
return -10000.0;
v2 = a1;
result = -10000.0;
do
result = fmaxf(*v2++, result);
while ( v2 != &a1[a2] );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101198
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
MOVSS XMM0,dword ptr [0x00102004]
LAB_00101183:
MOVSS XMM1,dword ptr [RAX]
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101183
RET
LAB_00101198:
MOVSS XMM0,dword ptr [0x00102004]
RET | float func0(float *param_1,int param_2)
{
float *pfVar1;
float fVar2;
float fVar3;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
fVar3 = DAT_00102004;
do {
fVar2 = *param_1;
if (*param_1 <= fVar3) {
fVar2 = fVar3;
}
fVar3 = fVar2;
param_1 = param_1 + 1;
... |
798 | func0 | #include <stdio.h>
| float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
} | O2 | c | func0:
endbr64
test %esi,%esi
jle 1298 <func0+0x38>
lea -0x1(%rsi),%eax
movss 0xe01(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm1
add $0x4,%rdi
maxss %xmm0,%xmm1
movaps %xmm1,%xmm0
cmp %rax,%rdi
jne 1280 <func0+0x20>
retq
nopl (%rax)
movss 0xdd4(%rip),%xmm0
r... | func0:
endbr64
test esi, esi
jle short loc_1278
movsxd rsi, esi
movss xmm0, cs:dword_2004
lea rax, [rdi+rsi*4]
nop word ptr [rax+rax+00000000h]
loc_1260:
movss xmm1, dword ptr [rdi]
add rdi, 4
maxss xmm1, xmm0
movaps xmm0, xmm1
cmp rax, rdi
jnz short loc_1260
retn
loc_1278:
movss xm... | float func0(float *a1, int a2)
{
float result; // xmm0_4
float *v3; // rax
float v4; // xmm1_4
if ( a2 <= 0 )
return -10000.0;
result = -10000.0;
v3 = &a1[a2];
do
{
v4 = *a1++;
result = fmaxf(v4, result);
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101278
MOVSXD RSI,ESI
MOVSS XMM0,dword ptr [0x00102004]
LEA RAX,[RDI + RSI*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101260:
MOVSS XMM1,dword ptr [RDI]
ADD RDI,0x4
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
CMP RAX,RDI
JNZ 0x00101260
RET
LAB_00101278:
MOVSS XMM0,dword ptr [0x00102004]
RET | float func0(float *param_1,int param_2)
{
float *pfVar1;
float fVar2;
float fVar3;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
fVar3 = DAT_00102004;
do {
fVar2 = *param_1;
param_1 = param_1 + 1;
if (fVar2 <= fVar3) {
fVar2 = fVar3;
}
fVar3 = fVar2;
} ... |
799 | func0 | #include <stdio.h>
| float func0(float *l, int size) {
float max = -10000;
for (int i = 0; i < size; i++)
if (max < l[i]) max = l[i];
return max;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {1, 2, 3};
assert(fabs(func0(list1, 3) - 3) < 1e-4);
float list2[] = {5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10};
assert(fabs(func0(list2, 11) - 124) < 1e-4);
} | O3 | c | func0:
endbr64
test %esi,%esi
jle 12c8 <func0+0x38>
lea -0x1(%rsi),%eax
movss 0xdd1(%rip),%xmm0
lea 0x4(%rdi,%rax,4),%rax
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm1
add $0x4,%rdi
maxss %xmm0,%xmm1
movaps %xmm1,%xmm0
cmp %rax,%rdi
jne 12b0 <func0+0x20>
retq
nopl (%rax)
movss 0xda4(%rip),%xmm0
r... | func0:
endbr64
test esi, esi
jle short loc_1178
movsxd rsi, esi
movss xmm0, cs:dword_2004
lea rax, [rdi+rsi*4]
nop word ptr [rax+rax+00000000h]
loc_1160:
movss xmm1, dword ptr [rdi]
add rdi, 4
maxss xmm1, xmm0
movaps xmm0, xmm1
cmp rax, rdi
jnz short loc_1160
retn
loc_1178:
movss xm... | float func0(float *a1, int a2)
{
float result; // xmm0_4
float *v3; // rax
float v4; // xmm1_4
if ( a2 <= 0 )
return -10000.0;
result = -10000.0;
v3 = &a1[a2];
do
{
v4 = *a1++;
result = fmaxf(v4, result);
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101178
MOVSXD RSI,ESI
MOVSS XMM0,dword ptr [0x00102004]
LEA RAX,[RDI + RSI*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
MOVSS XMM1,dword ptr [RDI]
ADD RDI,0x4
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
CMP RAX,RDI
JNZ 0x00101160
RET
LAB_00101178:
MOVSS XMM0,dword ptr [0x00102004]
RET | float func0(float *param_1,int param_2)
{
float *pfVar1;
float fVar2;
float fVar3;
if (0 < param_2) {
pfVar1 = param_1 + param_2;
fVar3 = DAT_00102004;
do {
fVar2 = *param_1;
param_1 = param_1 + 1;
if (fVar2 <= fVar3) {
fVar2 = fVar3;
}
fVar3 = fVar2;
} ... |
800 | func0 | #include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1229 <func0+0xe0>
mov -0x8(%rbp),%ecx
movslq %ecx,%rax
imul $0x2e8ba2e9,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar %edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp loc_1229
loc_1167:
mov ecx, [rbp+var_8]
movsxd rax, ecx
imul rax, 2E8BA2E9h
shr rax, 20h
mov edx, eax
sar edx, 1
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax,... | long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 0; i < a1; ++i )
{
if ( !(i % 11) || !(i % 13) )
{
for ( j = i; j > 0; j /= 10 )
{
if ( j % 10 == 7 )
++v2;
}
}
}
r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101229
LAB_00101167:
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x2e8ba2e9
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x1
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL E... | int func0(int param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_1; local_10 = local_10 + 1) {
if ((local_10 % 0xb == 0) || (local_10 % 0xd == 0)) {
for (local_c = local_10; 0 < local_c; local_c = local_c / 10) {
if (local_c % 10 == 7... |
801 | func0 | #include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
} | O1 | c | func0:
endbr64
test %edi,%edi
jle 1204 <func0+0xbb>
mov $0x0,%ecx
mov $0x0,%esi
jmp 116c <func0+0x23>
add $0x1,%ecx
cmp %ecx,%edi
je 1209 <func0+0xc0>
movslq %ecx,%rax
imul $0x2e8ba2e9,%rax,%rax
sar $0x21,%rax
mov %ecx,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%edx
lea... | func0:
endbr64
test edi, edi
jle loc_1200
mov ecx, 0
mov esi, 0
jmp short loc_11B6
loc_1161:
mov edx, eax
loc_1163:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov r8d, edx
sar r8d, 1Fh
sub eax, r8d
lea eax, [rax+rax*4]
add eax, eax
mov r8d, edx
sub r8d, e... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
int v3; // edx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 0;
v2 = 0;
do
{
if ( v1 == 11 * (v1 / 11) || v1 == 13 * (v1 / 13) )
{
v3 = v1;
if ( v1 > 0 )
{
while ( 1 )
... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101200
MOV ECX,0x0
MOV ESI,0x0
JMP 0x001011b6
LAB_00101161:
MOV EDX,EAX
LAB_00101163:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV R8D,EDX
SAR R8D,0x1f
SUB EAX,R8D
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
MOV R8D,EDX
SUB R8D,EAX
CMP R8D,0x7
SETZ AL
MOVZX EAX,AL
ADD ESI,EAX
MOVS... | int func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 < 1) {
iVar4 = 0;
}
else {
iVar2 = 0;
iVar4 = 0;
do {
if (((iVar2 == (iVar2 / 0xb) * 0xb) || (iVar2 == (iVar2 / 0xd) * 0xd)) &&
(iVar3 = iVar2, 0 < iVar2)) {
do {
iVar4 = ... |
802 | func0 | #include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
} | O2 | c | func0:
endbr64
test %edi,%edi
jle 167c <func0+0x7c>
xor %esi,%esi
xor %r8d,%r8d
mov $0xcccccccd,%r9d
jmp 162c <func0+0x2c>
nopl (%rax)
imul $0xc4ec4ec5,%esi,%eax
cmp $0x13b13b13,%eax
jbe 1639 <func0+0x39>
add $0x1,%esi
cmp %esi,%edi
je 1678 <func0+0x78>
imul $0xba2e8ba3,%esi,%eax
... | func0:
endbr64
xor r8d, r8d
xor esi, esi
mov r9d, 0CCCCCCCDh
test edi, edi
jle short loc_135B
nop dword ptr [rax+rax+00h]
loc_1308:
add r8d, 1
cmp edi, r8d
jz short loc_135B
loc_1311:
imul eax, r8d, 0BA2E8BA3h
cmp eax, 1745D174h
jbe short loc_132D
imul eax, r8d, 0C4EC4E... | long long func0(int a1)
{
unsigned int v1; // r8d
unsigned int v2; // esi
unsigned int v3; // edx
v1 = 0;
v2 = 0;
if ( a1 > 0 )
{
while ( a1 != ++v1 )
{
while ( -1171354717 * v1 <= 0x1745D174 || -991146299 * v1 <= 0x13B13B13 )
{
v3 = v1;
do
{
v2 += v... | func0:
ENDBR64
XOR R8D,R8D
XOR ESI,ESI
MOV R9D,0xcccccccd
TEST EDI,EDI
JLE 0x0010135b
NOP dword ptr [RAX + RAX*0x1]
LAB_00101308:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x0010135b
LAB_00101311:
IMUL EAX,R8D,-0x45d1745d
CMP EAX,0x1745d174
JBE 0x0010132d
IMUL EAX,R8D,-0x3b13b13b
CMP EAX,0x13b13b13
JA 0x00101308
LAB_0010132d:
MOV EDX... | int func0(uint param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uVar3 = 0;
iVar2 = 0;
if (0 < (int)param_1) {
while (uVar3 = uVar3 + 1, param_1 != uVar3) {
while ((uVar1 = uVar3, uVar3 * -0x45d1745d < 0x1745d175 || (uVar3 * -0x3b13b13b < 0x13b13b14))
) {
do {
iVar2 =... |
803 | func0 | #include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 0; i < n; i++)
if (i % 11 == 0 || i % 13 == 0) {
int q = i;
while (q > 0) {
if (q % 10 == 7) count += 1;
q = q / 10;
}
}
return count;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(50) == 0);
assert(func0(78) == 2);
assert(func0(79) == 3);
assert(func0(100) == 3);
assert(func0(200) == 6);
assert(func0(4000) == 192);
assert(func0(10000) == 639);
assert(func0(100000) == 8026);
} | O3 | c | func0:
endbr64
test %edi,%edi
jle 167c <func0+0x7c>
mov $0x1,%esi
xor %r8d,%r8d
mov $0xcccccccd,%r9d
cmp $0x1,%edi
jne 1634 <func0+0x34>
jmp 1678 <func0+0x78>
nopl (%rax)
imul $0xc4ec4ec5,%esi,%eax
cmp $0x13b13b13,%eax
jbe 1641 <func0+0x41>
add $0x1,%esi
cmp %esi,%edi
je 1678 ... | func0:
endbr64
xor r8d, r8d
xor esi, esi
mov r9d, 0CCCCCCCDh
test edi, edi
jle short loc_168B
nop dword ptr [rax+rax+00h]
loc_1638:
add r8d, 1
cmp edi, r8d
jz short loc_168B
loc_1641:
imul eax, r8d, 0BA2E8BA3h
cmp eax, 1745D174h
jbe short loc_165D
imul eax, r8d, 0C4EC4E... | long long func0(int a1)
{
unsigned int v1; // r8d
unsigned int v2; // esi
unsigned int v3; // edx
v1 = 0;
v2 = 0;
if ( a1 > 0 )
{
while ( a1 != ++v1 )
{
while ( -1171354717 * v1 <= 0x1745D174 || -991146299 * v1 <= 0x13B13B13 )
{
v3 = v1;
do
{
v2 += v... | func0:
ENDBR64
XOR R8D,R8D
XOR ESI,ESI
MOV R9D,0xcccccccd
TEST EDI,EDI
JLE 0x0010168b
NOP dword ptr [RAX + RAX*0x1]
LAB_00101638:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x0010168b
LAB_00101641:
IMUL EAX,R8D,-0x45d1745d
CMP EAX,0x1745d174
JBE 0x0010165d
IMUL EAX,R8D,-0x3b13b13b
CMP EAX,0x13b13b13
JA 0x00101638
LAB_0010165d:
MOV EDX... | int func0(uint param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uVar3 = 0;
iVar2 = 0;
if (0 < (int)param_1) {
while (uVar3 = uVar3 + 1, param_1 != uVar3) {
while ((uVar1 = uVar3, uVar3 * -0x45d1745d < 0x1745d175 || (uVar3 * -0x3b13b13b < 0x13b13b14))
) {
do {
iVar2 =... |
804 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov eax, [rbp+var_2C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+pt... | void func0(long long a1, int a2, long long a3)
{
int v3; // eax
_DWORD *v4; // rdx
int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+28h] [rbp-18h]
int m; // [rsp+28h] [rbp-18h]
int k; // [rsp+2Ch] [rbp-14h]
int v10; // [rsp+30h] [rbp-10h]
int v11; // [rsp+34h] [rbp-Ch]
_DWORD *ptr; // [rsp+38h] [rbp-8h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dw... | void func0(long param_1,int param_2,long param_3)
{
int4 uVar1;
void *__ptr;
int4 local_20;
int4 local_1c;
int4 local_18;
__ptr = malloc((long)(param_2 / 2 + 1) << 2);
local_18 = 0;
for (local_20 = 0; (int)local_20 < param_2; local_20 = local_20 + 2) {
*(int4 *)((long)__ptr + (long)local_18 * 4)... |
805 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, ... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
mov %rdx,%r12
mov %esi,%edi
shr $0x1f,%edi
add %esi,%edi
sar %edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 126e <func0+0xc5>
mov $0x0,%edx
mo... | func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
mov r12, rdx
mov edi, esi
shr edi, 1Fh
add edi, esi
sar edi, 1
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jle loc_127F
mov eax, 0
loc_11E1:
mo... | void func0(long long a1, int a2, long long a3)
{
float *v6; // rdi
long long v7; // rax
signed int v8; // esi
signed int v9; // ecx
float *v10; // rax
float v11; // xmm0_4
float v12; // xmm1_4
float v13; // xmm0_4
long long v14; // rax
v6 = (float *)malloc(4LL * (a2 / 2 + 1));
if ( a2 > 0 )
{
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
MOV R12,RDX
MOV EDI,ESI
SHR EDI,0x1f
ADD EDI,ESI
SAR EDI,0x1
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x0010127f
MOV EAX,0x0
LAB_001011e1:
MOVSS XMM0,dword ptr [RBP + RAX*0x4]
MOVSS dword ptr [RDI + RAX*0x2],XMM... | void func0(long param_1,int param_2,long param_3)
{
float *__ptr;
long lVar1;
float *pfVar2;
ulong uVar3;
int iVar4;
uint uVar5;
float fVar6;
__ptr = (float *)malloc((long)(param_2 / 2 + 1) << 2);
if (0 < param_2) {
lVar1 = 0;
do {
*(int4 *)((long)__ptr + lVar1 * 2) = *(int4 *)(param... |
806 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, ... | O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
mov %esi,%edi
shr $0x1f,%edi
push %rbx
mov %esi,%ebx
add %esi,%edi
sar %edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r8
test %ebx,%ebx
jle 15f8 <func0+0xd8>
xor %ecx,%ecx
nop... | func0:
endbr64
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
movsxd rbx, esi
mov edi, ebx
shr edi, 1Fh
add edi, ebx
sar edi, 1
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
xor eax, eax
test ebx, ebx
jle loc_14C4
nop wo... | void func0(long long a1, int a2, long long a3)
{
long long v5; // rbx
__m128i *v6; // rdi
long long v7; // rax
signed int v8; // ecx
signed int v9; // esi
__m128i *v10; // rax
__m128 v11; // xmm0
long long v12; // rax
v5 = a2;
v6 = (__m128i *)malloc(4LL * (a2 / 2 + 1));
v7 = 0LL;
if ( a2 > 0 )... | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVSXD RBX,ESI
MOV EDI,EBX
SHR EDI,0x1f
ADD EDI,EBX
SAR EDI,0x1
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
XOR EAX,EAX
TEST EBX,EBX
JLE 0x001014c4
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101410:
MOVSS XMM0,dword ptr [RBP + RAX*0x4]
... | void func0(long param_1,int param_2,long param_3)
{
int8 *__ptr;
long lVar1;
int8 *puVar2;
ulong uVar3;
int iVar4;
uint uVar5;
float fVar6;
float fVar7;
__ptr = (int8 *)malloc((long)(param_2 / 2 + 1) << 2);
lVar1 = 0;
if (0 < param_2) {
do {
*(int4 *)((long)__ptr + lVar1 * 2) = *(int... |
807 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| void func0(float *l, int size, float *out) {
float *even = malloc((size / 2 + 1) * sizeof(float));
int i, j, even_count = 0;
for (i = 0; i < size; i += 2) {
even[even_count++] = l[i];
}
for (i = 0; i < even_count - 1; i++) {
for (j = 0; j < even_count - i - 1; j++) {
if... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int issame(float *a, float *b, int size) {
for (int i = 0; i < size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) {
return 0;
}
}
return 1;
}
int main() {
float test1[] = {1, 2, 3};
float result1[3];
func0(test1, 3, ... | O3 | c | func0:
endbr64
push %r12
mov %esi,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
mov %esi,%edi
shr $0x1f,%edi
add %esi,%edi
sar %edi
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r12d,%r12d
jle 182f <func0+0x16f>
lea -0x1(%r12... | func0:
endbr64
push r12
mov r12, rdx
push rbp
movsxd rbp, esi
push rbx
mov rbx, rdi
mov edi, ebp
shr edi, 1Fh
add edi, ebp
sar edi, 1
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test ebp, ebp
jle loc_1787
lea eax, [rbp-1]
mov ... | void func0(long long a1, int a2, long long a3)
{
long long v4; // rbp
__m128i *v6; // rdi
unsigned int v7; // esi
unsigned long long v8; // rax
unsigned int v9; // edx
int v10; // ecx
int v11; // eax
long long v12; // rcx
long long v13; // r8
int v14; // ecx
__m128i *v15; // rax
__m128 v16; // ... | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RDI
MOV EDI,EBP
SHR EDI,0x1f
ADD EDI,EBP
SAR EDI,0x1
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RDI,RAX
TEST EBP,EBP
JLE 0x00101787
LEA EAX,[RBP + -0x1]
MOV ESI,EAX
SHR ESI,0x1
CMP EAX,0x7
JBE 0x001017c5
SHR EAX,0x3
MOV ECX,EAX... | void func0(long param_1,int param_2,long param_3)
{
int4 *puVar1;
long lVar2;
int4 *puVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
uint uVar7;
uint uVar8;
int iVar9;
int8 *__ptr;
long lVar10;
int8 *puVar11;
ulong uVar12;
int iVar13;
float fVar14;
float fVar15;
__ptr = (int8 *)malloc((... |
808 | func0 | #include <stdio.h>
#include <string.h>
| void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char t... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
add $0x2,%eax
movslq %eax,%rdx
i... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], eax
mov eax, [rbp+var_18]
add eax, 2
movsxd rdx, eax
imul r... | unsigned long long func0(const char *a1, int a2)
{
int v2; // eax
char v4; // [rsp+12h] [rbp-1Eh]
char v5; // [rsp+13h] [rbp-1Dh]
int i; // [rsp+14h] [rbp-1Ch]
int v7; // [rsp+18h] [rbp-18h]
int v8; // [rsp+20h] [rbp-10h]
char dest; // [rsp+24h] [rbp-Ch] BYREF
char v10; // [rsp+25h] [rbp-Bh]
char v11... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x2
... | void func0(char *param_1,int param_2)
{
char cVar1;
char cVar2;
int iVar3;
int iVar4;
size_t sVar5;
long in_FS_OFFSET;
int local_24;
char local_14 [4];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar5 = strlen(param_1);
iVar3 = (int)sVar5;
for (local_24 = 0; local_24 < (iVar... |
809 | func0 | #include <stdio.h>
#include <string.h>
| void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char t... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
mov %ebp,0x8(%rsp)
... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rbp, rdi
mov [rsp+58h+var_4C], esi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strlen
mov r12, rax
mov [rsp+58h+var_50], eax
lea eax, [rax+2]
movsxd r15, eax
i... | unsigned long long func0(char *src, int a2)
{
const char *v2; // rbp
int v3; // r12d
int v4; // r15d
int v5; // ebx
size_t v6; // r13
char v7; // al
char v8; // al
char *dest; // [rsp+0h] [rbp-58h]
int v11; // [rsp+8h] [rbp-50h]
char srca[4]; // [rsp+14h] [rbp-44h] BYREF
unsigned long long v13; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBP,RDI
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV R12,RAX
MOV dword ptr [RSP + 0x8],EAX
LEA EAX,[RAX + 0x2]
MOVSXD R15,EAX
IMUL R15,R15,0x55555556
SHR R15,... | void func0(char *param_1,int param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
int iVar4;
int iVar5;
long in_FS_OFFSET;
char local_44 [4];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (0 < iVar2) {
iVar4 = 0;
do {
iVar4... |
810 | func0 | #include <stdio.h>
#include <string.h>
| void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char t... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] ... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
lea 0x2(%rax),%edx
lea (%rax,%rbx,1),%edi
mov %eax,0x4(%rsp)
movslq %edx,%r12
sar... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov [rsp+58h+var_4C], esi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strlen
mov rbp, rax
mov r14d, eax
add eax, 2
movsxd r13, eax
sar eax, 1Fh
im... | unsigned long long func0(char *dest, int a2)
{
const char *v2; // rbx
int v3; // ebp
int v4; // r14d
int v5; // r13d
int v6; // r15d
char v7; // cl
char v8; // dl
__int16 v9; // ax
size_t v10; // rdx
char *v11; // rdi
_BYTE desta[3]; // [rsp+14h] [rbp-44h] BYREF
char v14; // [rsp+17h] [rbp-41h]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBP,RAX
MOV R14D,EAX
ADD EAX,0x2
MOVSXD R13,EAX
SAR EAX,0x1f
IMUL R13,R13,0x55555556
SHR R13,0x20
SUB R13... | void func0(char *param_1,int param_2)
{
int2 uVar1;
int iVar2;
size_t sVar3;
size_t __n;
int iVar4;
int iVar5;
long in_FS_OFFSET;
int local_44 [2];
char cStack_42;
int local_41;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (0... |
811 | func0 | #include <stdio.h>
#include <string.h>
| void func0(char *s, int encode) {
int l = strlen(s);
int num = (l + 2) / 3;
char x[4];
for (int i = 0; i < num; ++i) {
int len = (i * 3 + 3 <= l) ? 3 : l - i * 3;
strncpy(x, s + i * 3, len);
x[len] = '\0';
if (len == 3) {
if (encode) {
char t... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main(){
srand((unsigned int)time(NULL));
char str[22], temp[22], decoded_str[22];
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
for (int j = 0; j < l; j++) {
str[j] ... | O3 | c | func0:
endbr64
push %r15
mov %esi,%r15d
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
mov %rax,%rbp
mov %eax,%r13d
add $0x2,%eax
movslq %eax,%r12
sar $0x1f,%eax
imul ... | func0:
endbr64
push r15
mov r15d, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strlen
mov rbp, rax
mov r14d, eax
add eax, 2
movsxd r13, eax
sar eax, 1Fh
imul r13, 5... | unsigned long long func0(char *dest, int a2)
{
int v2; // r15d
const char *v3; // rbx
int v4; // ebp
int v5; // r14d
int v6; // r13d
__int16 v7; // dx
size_t v8; // rdx
char *v9; // rdi
int v11; // r15d
__int16 v12; // ax
char v13; // dl
size_t v14; // rdx
char *v15; // rdi
_BYTE desta[3]; ... | func0:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBP,RAX
MOV R14D,EAX
ADD EAX,0x2
MOVSXD R13,EAX
SAR EAX,0x1f
IMUL R13,R13,0x55555556
SHR R13,0x20
SUB R13D,EAX
TEST EBP,EB... | void func0(char *param_1,int param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
int iVar5;
int iVar6;
long in_FS_OFFSET;
int local_44;
int2 uStack_43;
int local_41;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
iVar1 = ... |
812 | func0 | #include <stdio.h>
| int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (ispr... | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
asse... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movl $0x1,-0x18(%rbp)
movl $0x2,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11cf <func0+0x86>
mov -0x14(%rbp),%eax
add %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x4(... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_18], 1
mov [rbp+var_14], 2
mov [rbp+var_10], 0
jmp short loc_11CF
loc_116B:
mov eax, [rbp+var_14]
add [rbp+var_18], eax
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
mov [rbp+var... | long long func0(int a1)
{
int v2; // [rsp+Ch] [rbp-18h]
int v3; // [rsp+10h] [rbp-14h]
int v4; // [rsp+14h] [rbp-10h]
int v5; // [rsp+18h] [rbp-Ch]
int i; // [rsp+1Ch] [rbp-8h]
int v7; // [rsp+20h] [rbp-4h]
v2 = 1;
v3 = 2;
v4 = 0;
while ( v4 < a1 )
{
v7 = v3 + v2;
v2 = v3;
v3 = v7;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x18],0x1
MOV dword ptr [RBP + -0x14],0x2
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011cf
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x14]
ADD dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
... | int func0(int param_1)
{
int iVar1;
bool bVar2;
int local_20;
int local_1c;
int local_18;
int local_10;
local_20 = 1;
local_1c = 2;
local_18 = 0;
iVar1 = local_1c;
do {
local_1c = iVar1;
if (param_1 <= local_18) {
return 0;
}
iVar1 = local_20 + local_1c;
local_20 = lo... |
813 | func0 | #include <stdio.h>
| int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (ispr... | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
asse... | O1 | c | func0:
endbr64
mov $0x0,%r8d
mov $0x2,%esi
mov $0x1,%eax
jmp 1175 <func0+0x2c>
mov $0x0,%esi
mov %esi,%eax
retq
add $0x1,%r8d
cmp %r8d,%edi
je 1164 <func0+0x1b>
mov %esi,%eax
mov %r9d,%esi
cmp %edi,%r8d
jge 115f <func0+0x16>
lea (%rax,%rsi,1),%r9d
cmp $0x3,%esi
jle 1167 ... | func0:
endbr64
mov r8d, 0
mov esi, 2
mov eax, 1
jmp short loc_116D
loc_115F:
add r8d, 1
cmp edi, r8d
jz short loc_11A2
loc_1168:
mov eax, esi
mov esi, r9d
loc_116D:
cmp r8d, edi
jge short loc_119D
lea r9d, [rax+rsi]
cmp esi, 3
jle short loc_115F
test sil, 1
jz... | long long func0(int a1)
{
int v1; // r8d
int v2; // esi
int v3; // eax
int v4; // r9d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
while ( v1 < a1 )
{
v4 = v3 + v2;
if ( v2 > 3 )
{
if ( (v2 & 1) == 0 )
goto LABEL_3;
v5 = 2;
while ( 1 )
{
++v5;
... | func0:
ENDBR64
MOV R8D,0x0
MOV ESI,0x2
MOV EAX,0x1
JMP 0x0010116d
LAB_0010115f:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x001011a2
LAB_00101168:
MOV EAX,ESI
MOV ESI,R9D
LAB_0010116d:
CMP R8D,EDI
JGE 0x0010119d
LEA R9D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x0010115f
TEST SIL,0x1
JZ 0x00101168
MOV ECX,0x2
LAB_00101186:
ADD ECX,0x1
MOV EAX... | uint func0(int param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
uint uVar4;
int iVar5;
iVar5 = 0;
uVar1 = 2;
uVar2 = 1;
do {
do {
while( true ) {
uVar4 = uVar1;
if (param_1 <= iVar5) {
return 0;
}
uVar1 = uVar2 + uVar4;
uVar2 = uVar4;
... |
814 | func0 | #include <stdio.h>
| int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (ispr... | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
asse... | O2 | c | func0:
endbr64
test %edi,%edi
jle 16b8 <func0+0x58>
xor %r9d,%r9d
mov $0x2,%esi
mov $0x1,%eax
nopl (%rax)
mov %esi,%r8d
add %eax,%esi
cmp $0x3,%r8d
jle 16a7 <func0+0x47>
test $0x1,%r8b
je 16b0 <func0+0x50>
mov $0x2,%ecx
jmp 169a <func0+0x3a>
mov %r8d,%eax
cltd
idiv %ecx
test... | func0:
endbr64
xor r8d, r8d
mov esi, 2
mov eax, 1
cmp r8d, edi
jge short loc_13C8
nop word ptr [rax+rax+00000000h]
loc_1380:
lea r9d, [rax+rsi]
cmp esi, 3
jle short loc_13B5
test sil, 1
jz short loc_13BE
mov ecx, 2
jmp short loc_13A9
loc_13A0:
mov eax, esi
cdq
idi... | long long func0(int a1)
{
int v1; // r8d
int v2; // esi
int v3; // eax
int v4; // r9d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
if ( a1 > 0 )
{
while ( 1 )
{
v4 = v3 + v2;
if ( v2 <= 3 )
goto LABEL_7;
if ( (v2 & 1) != 0 )
break;
LABEL_8:
v3 = v2;
... | func0:
ENDBR64
XOR R8D,R8D
MOV ESI,0x2
MOV EAX,0x1
CMP R8D,EDI
JGE 0x001013c8
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101380:
LEA R9D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x001013b5
TEST SIL,0x1
JZ 0x001013be
MOV ECX,0x2
JMP 0x001013a9
LAB_001013a0:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013be
LAB_001013a9:
ADD ECX,0x1... | uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
uint uVar5;
iVar4 = 0;
uVar3 = 2;
uVar1 = 1;
if (0 < param_1) {
do {
uVar5 = uVar1 + uVar3;
if ((int)uVar3 < 4) {
LAB_001013b5:
iVar4 = iVar4 + 1;
if (param_1 == iVar4) {
return uVar3;... |
815 | func0 | #include <stdio.h>
| int func0(int n) {
int f1 = 1, f2 = 2, m;
int count = 0;
while (count < n) {
f1 = f1 + f2;
m = f1; f1 = f2; f2 = m;
int isprime = 1;
for (int w = 2; w * w <= f1; w++) {
if (f1 % w == 0) {
isprime = 0; break;
}
}
if (ispr... | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(1) == 2);
assert(func0(2) == 3);
assert(func0(3) == 5);
assert(func0(4) == 13);
assert(func0(5) == 89);
assert(func0(6) == 233);
assert(func0(7) == 1597);
assert(func0(8) == 28657);
assert(func0(9) == 514229);
asse... | O3 | c | func0:
endbr64
test %edi,%edi
jle 16b8 <func0+0x58>
xor %r9d,%r9d
mov $0x2,%esi
mov $0x1,%eax
nopl (%rax)
mov %esi,%r8d
add %eax,%esi
cmp $0x3,%r8d
jle 16a7 <func0+0x47>
test $0x1,%r8b
je 16b0 <func0+0x50>
mov $0x2,%ecx
jmp 169a <func0+0x3a>
mov %r8d,%eax
cltd
idiv %ecx
test... | func0:
endbr64
xor r8d, r8d
mov esi, 2
mov eax, 1
cmp r8d, edi
jge short loc_1618
nop word ptr [rax+rax+00000000h]
loc_15D0:
lea r9d, [rax+rsi]
cmp esi, 3
jle short loc_1605
test sil, 1
jz short loc_160E
mov ecx, 2
jmp short loc_15F9
loc_15F0:
mov eax, esi
cdq
idi... | long long func0(int a1)
{
int v1; // r8d
int v2; // esi
int v3; // eax
int v4; // r9d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
if ( a1 > 0 )
{
while ( 1 )
{
v4 = v3 + v2;
if ( v2 <= 3 )
goto LABEL_7;
if ( (v2 & 1) != 0 )
break;
LABEL_8:
v3 = v2;
... | func0:
ENDBR64
XOR R8D,R8D
MOV ESI,0x2
MOV EAX,0x1
CMP R8D,EDI
JGE 0x00101618
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001015d0:
LEA R9D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x00101605
TEST SIL,0x1
JZ 0x0010160e
MOV ECX,0x2
JMP 0x001015f9
LAB_001015f0:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x0010160e
LAB_001015f9:
ADD ECX,0x1... | uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
uint uVar5;
iVar4 = 0;
uVar3 = 2;
uVar1 = 1;
if (0 < param_1) {
do {
uVar5 = uVar1 + uVar3;
if ((int)uVar3 < 4) {
LAB_00101605:
iVar4 = iVar4 + 1;
if (param_1 == iVar4) {
return uVar3;... |
816 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
asser... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1207 <func0+0x9e>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmp 11fb <func0+0x92>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11ef <func0+0x86>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
jmp loc_1207
loc_1184:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp short loc_11FB
loc_118F:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp sho... | long long func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
int j; // [rsp+14h] [rbp-8h]
int k; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
for ( k = j + 1; k < a2; ++k )
{
if ( !(*(_DWORD *)(4LL * j + a1) + *(_DWORD *)(4LL * i + a... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101207
LAB_00101184:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011fb
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr ... | int8 func0(long param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
do {
local_10 = local_14;
if (param_2 <= local_14) {
return 0;
}
while (local_10 = local_10 + 1, local_c = local_10, local_10 < param_2) {
while (local_c = local_c + 1, local_c < param... |
817 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
asser... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11b7 <func0+0x4e>
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
cmp %r9,%r8
je 11bd <func0+0x54>
lea 0x1(%r8),%r10
mov %r10,%rcx
cmp %ecx,%esi
jle 11b2 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
add -0x4(%rdi,%r8,4),%edx
mov %rcx,%rax
mov %edx... | func0:
endbr64
test esi, esi
jle short loc_11D8
lea r11d, [rsi+1]
movsxd rax, esi
lea r10, [rax+2]
mov r9d, 2
cmp r9, r11
jz short loc_11EC
push rbx
jmp short loc_1198
loc_118A:
add r9, 1
cmp r9, r10
jz short loc_11D1
cmp r9, r11
jz short loc_11DE
loc_1198:
mov ... | long long func0(long long a1, int a2)
{
long long v2; // r11
long long v3; // r9
long long v4; // r8
long long v5; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (unsigned int)(a2 + 1);
v3 = 2LL;
if ( v2 == 2 )
return 0LL;
do
{
v4 = v3;
while ( 2 )
{
if ( a2 > (int)v4 )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011d8
LEA R11D,[RSI + 0x1]
MOVSXD RAX,ESI
LEA R10,[RAX + 0x2]
MOV R9D,0x2
CMP R9,R11
JZ 0x001011ec
PUSH RBX
JMP 0x00101198
LAB_0010118a:
ADD R9,0x1
CMP R9,R10
JZ 0x001011d1
CMP R9,R11
JZ 0x001011de
LAB_00101198:
MOV EAX,ESI
SUB EAX,R9D
LEA RBX,[R9 + RAX*0x1 + 0x1]
MOV R8,R9
LAB_0010... | int8 func0(long param_1,int param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
if (param_2 < 1) {
return 0;
}
uVar3 = 2;
if ((ulong)(param_2 + 1) == 2) {
return 0;
}
do {
uVar2 = uVar3;
do {
if (param_2 <= (int)uVar2) break;
uVar1 = uVar2;
do {
if (*(int *)... |
818 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
asser... | O2 | c | func0:
endbr64
test %esi,%esi
jle 14cd <func0+0x5d>
lea -0x1(%rsi),%r9d
mov $0x1,%r8d
add $0x1,%r9
cmp %r9,%r8
je 14cd <func0+0x5d>
lea 0x1(%r8),%r10
mov %r10,%rcx
cmp %ecx,%esi
jle 14c8 <func0+0x58>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
add -0x4(%rdi,%r8,4),%edx
jmp 14b0... | func0:
endbr64
test esi, esi
jle short loc_1477
lea r10d, [rsi+1]
mov r9d, 2
loc_1432:
cmp r10, r9
jz short loc_1477
mov r8, r9
cmp esi, r8d
jle short loc_1471
loc_143F:
mov edx, [rdi+r8*4-4]
mov rax, r8
add edx, [rdi+r9*4-8]
jmp short loc_1458
loc_1450:
add rax, ... | long long func0(long long a1, int a2)
{
long long i; // r9
long long j; // r8
long long v4; // rax
if ( a2 > 0 )
{
for ( i = 2LL; a2 + 1 != i; ++i )
{
for ( j = i; a2 > (int)j; ++j )
{
v4 = j;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v4) + *(_DWORD *)(a1 + 4 * i... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101477
LEA R10D,[RSI + 0x1]
MOV R9D,0x2
LAB_00101432:
CMP R10,R9
JZ 0x00101477
MOV R8,R9
CMP ESI,R8D
JLE 0x00101471
LAB_0010143f:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
ADD EDX,dword ptr [RDI + R9*0x4 + -0x8]
JMP 0x00101458
LAB_00101450:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x0010... | int8 func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
if (0 < param_2) {
for (uVar4 = 2; param_2 + 1 != uVar4; uVar4 = uVar4 + 1) {
iVar2 = (int)uVar4;
uVar3 = uVar4;
while (iVar2 < param_2) {
uVar1 = uVar3;
do {
if (*(int ... |
819 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
for (int k = j + 1; k < size; k++)
if (l[i] + l[j] + l[k] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, 5, -1};
assert(func0(test2, 4) == false);
int test3[] = {1, 3, -2, 1};
assert(func0(test3, 4) == true);
int test4[] = {1, 2, 3, 7};
asser... | O3 | c | func0:
endbr64
test %esi,%esi
jle 147d <func0+0x5d>
lea -0x1(%rsi),%r9d
mov $0x1,%r8d
add $0x1,%r9
cmp %r9,%r8
je 147d <func0+0x5d>
lea 0x1(%r8),%r10
mov %r10,%rcx
cmp %ecx,%esi
jle 1478 <func0+0x58>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
add -0x4(%rdi,%r8,4),%edx
jmp 1460... | func0:
endbr64
test esi, esi
jle short loc_1477
lea r10d, [rsi+1]
mov r9d, 2
loc_1432:
cmp r10, r9
jz short loc_1477
mov r8, r9
cmp esi, r8d
jle short loc_1471
loc_143F:
mov edx, [rdi+r8*4-4]
mov rax, r8
add edx, [rdi+r9*4-8]
jmp short loc_1458
loc_1450:
add rax, ... | long long func0(long long a1, int a2)
{
long long i; // r9
long long j; // r8
long long v4; // rax
if ( a2 > 0 )
{
for ( i = 2LL; a2 + 1 != i; ++i )
{
for ( j = i; a2 > (int)j; ++j )
{
v4 = j;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v4) + *(_DWORD *)(a1 + 4 * i... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101477
LEA R10D,[RSI + 0x1]
MOV R9D,0x2
LAB_00101432:
CMP R10,R9
JZ 0x00101477
MOV R8,R9
CMP ESI,R8D
JLE 0x00101471
LAB_0010143f:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
ADD EDX,dword ptr [RDI + R9*0x4 + -0x8]
JMP 0x00101458
LAB_00101450:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x0010... | int8 func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
if (0 < param_2) {
for (uVar4 = 2; param_2 + 1 != uVar4; uVar4 = uVar4 + 1) {
iVar2 = (int)uVar4;
uVar3 = uVar4;
while (iVar2 < param_2) {
uVar1 = uVar3;
do {
if (*(int ... |
820 | func0 | #include <stdio.h>
| int func0(int n) {
return n * n;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
imul eax, eax
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
POP RBP
RET | int func0(int param_1)
{
return param_1 * param_1;
} |
821 | func0 | #include <stdio.h>
| int func0(int n) {
return n * n;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
} | O1 | c | func0:
endbr64
imul %edi,%edi
mov %edi,%eax
retq
| func0:
endbr64
imul edi, edi
mov eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET | int func0(int param_1)
{
return param_1 * param_1;
} |
822 | func0 | #include <stdio.h>
| int func0(int n) {
return n * n;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
} | O2 | c | func0:
endbr64
mov %edi,%eax
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
imul edi, edi
mov eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET | int func0(int param_1)
{
return param_1 * param_1;
} |
823 | func0 | #include <stdio.h>
| int func0(int n) {
return n * n;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(2) == 4);
assert(func0(3) == 9);
assert(func0(4) == 16);
assert(func0(8) == 64);
assert(func0(10) == 100);
return 0;
} | O3 | c | func0:
endbr64
mov %edi,%eax
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
imul edi, edi
mov eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET | int func0(int param_1)
{
return param_1 * param_1;
} |
824 | func0 | #include <stdio.h>
| void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
} | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(is... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b4 <func0+0x4b>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11B4
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax... | long long func0(long long a1, int a2)
{
long long result; // rax
unsigned int i; // [rsp+18h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
++*(_DWORD *)(4LL * (int)i + a1);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b4
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LE... | void func0(long param_1,int param_2)
{
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(int *)(param_1 + (long)local_c * 4) = *(int *)(param_1 + (long)local_c * 4) + 1;
}
return;
} |
825 | func0 | #include <stdio.h>
| void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
} | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(is... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1188 <func0+0x1f>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
addl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 117c <func0+0x13>
retq
| func0:
endbr64
test esi, esi
jle short locret_1187
mov rax, rdi
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
loc_117B:
add dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_117B
locret_1187:
retn | void func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 > 0 )
{
v2 = a1;
do
++*v2++;
while ( v2 != &a1[a2] );
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101187
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
LAB_0010117b:
ADD dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010117b
LAB_00101187:
RET | void func0(int *param_1,int param_2)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
*param_1 = *param_1 + 1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return;
} |
826 | func0 | #include <stdio.h>
| void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
} | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(is... | O2 | c | func0:
endbr64
test %esi,%esi
jle 135c <func0+0x1c>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
addl $0x1,(%rdi)
add $0x4,%rdi
cmp %rax,%rdi
jne 1350 <func0+0x10>
retq
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short locret_1350
movsxd rsi, esi
lea rax, [rdi+rsi*4]
and esi, 1
jz short loc_1340
add dword ptr [rdi], 1
add rdi, 4
cmp rdi, rax
jz short locret_1351
loc_1340:
add dword ptr [rdi], 1
add dword ptr [rdi+4], 1
add rdi, 8
cmp rdi, rax... | void func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 > 0 )
{
v2 = &a1[a2];
if ( (a2 & 1) == 0 || (++*a1, ++a1, a1 != v2) )
{
do
{
++*a1;
++a1[1];
a1 += 2;
}
while ( a1 != v2 );
}
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101350
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
AND ESI,0x1
JZ 0x00101340
ADD dword ptr [RDI],0x1
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101351
LAB_00101340:
ADD dword ptr [RDI],0x1
ADD dword ptr [RDI + 0x4],0x1
ADD RDI,0x8
CMP RDI,RAX
JNZ 0x00101340
LAB_00101350:
RET
LAB_00101351:
RET | void func0(int *param_1,uint param_2)
{
int *piVar1;
if (0 < (int)param_2) {
piVar1 = param_1 + (int)param_2;
if ((param_2 & 1) != 0) {
*param_1 = *param_1 + 1;
param_1 = param_1 + 1;
if (param_1 == piVar1) {
return;
}
}
do {
*param_1 = *param_1 + 1;
p... |
827 | func0 | #include <stdio.h>
| void func0(int *l, int size) {
for (int i = 0; i < size; i++)
l[i] += 1;
} | #include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int list1[] = {};
int result1[] = {};
func0(list1, 0);
assert(is... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1362 <func0+0x72>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1369 <func0+0x79>
mov %esi,%edx
movdqa 0xda6(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
paddd %xmm1,%xmm0
movups ... | func0:
endbr64
test esi, esi
jle short locret_1373
lea eax, [rsi-1]
cmp eax, 2
jbe short loc_1379
mov edx, esi
movdqa xmm1, cs:xmmword_2090
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00000000h]
loc_1330:
movdqu xmm0, xmmword ptr [rax]
add rax, ... | void func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm1
const __m128i *v3; // rax
__m128i v4; // xmm0
int v5; // edx
long long v6; // rax
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2090);
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101373
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101379
MOV EDX,ESI
MOVDQA XMM1,xmmword ptr [0x00102090]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101330:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM1
MOVUPS xmmword ptr [RAX + -0x1... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int *piVar5;
int *piVar6;
uint uVar7;
iVar4 = _UNK_0010209c;
iVar3 = _UNK_00102098;
iVar2 = _UNK_00102094;
iVar1 = _DAT_0010... |
828 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d5 <func0+0x6c>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11c9 <func0+0x60>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%ra... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
jmp short loc_11D5
loc_1181:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11C9
loc_118C:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [r... | long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( !(*(_DWORD *)(4LL * i + a1) + *(_DWORD *)(4LL * j + a1)) )
return 1LL;
}
}
return 0LL;
} | 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
JMP 0x001011d5
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011c9
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV... | int8 func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
do {
local_c = local_10;
if (param_2 <= local_10) {
return 0;
}
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_c * 4) + *(int *)(param_1 + (long)local_10 * 4) ==... |
829 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11a1 <func0+0x38>
lea -0x1(%rsi),%r8d
add $0x1,%r8
mov $0x1,%ecx
cmp %r8,%rcx
je 11a7 <func0+0x3e>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
mov %edx,%r9d
add (%rdi,%rax,4),%r9d
je 11ad <func0+0x44>
add $0x1,%rax
cmp %eax,%esi
jg 118a <func... | func0:
endbr64
test esi, esi
jle short loc_11AD
mov r9d, esi
movsxd r10, esi
mov r8d, 1
loc_117D:
cmp r8, r9
jz short loc_11B3
mov edx, [rdi+r8*4-4]
mov rax, r8
loc_118A:
mov ecx, edx
add ecx, [rdi+rax*4]
jz short loc_11B9
add rax, 1
cmp esi, eax
jg short loc_1... | long long func0(long long a1, int a2)
{
long long v2; // r8
long long v3; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
while ( 2 )
{
if ( v2 == a2 )
return 0LL;
v3 = v2;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v3) + *(_DWORD *)(a1 + 4 * v2 - 4)) )
return 1LL;
++v3;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ad
MOV R9D,ESI
MOVSXD R10,ESI
MOV R8D,0x1
LAB_0010117d:
CMP R8,R9
JZ 0x001011b3
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
LAB_0010118a:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JZ 0x001011b9
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010118a
LEA RAX,[R8 + 0x1]
CMP R8,R10
JZ 0x00... | int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
bool bVar3;
if ((int)param_2 < 1) {
return 0;
}
uVar2 = 1;
do {
if (uVar2 == param_2) {
return 0;
}
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) + *(int *)(param_1 + uVar1 * 4) == 0) {
... |
830 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1649 <func0+0x49>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %r8,%rcx
je 1649 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 1630 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 1640 <func0+0x40>
mov %edx... | func0:
endbr64
test esi, esi
jle short loc_1481
mov r9d, esi
mov r8d, 1
cmp r8, r9
jz short loc_1481
loc_1456:
mov edx, [rdi+r8*4-4]
mov rax, r8
jmp short loc_1468
loc_1460:
add rax, 1
cmp esi, eax
jle short loc_1478
loc_1468:
mov ecx, edx
add ecx, [rdi+rax*4]
jnz... | long long func0(long long a1, int a2)
{
long long i; // r8
long long v3; // rax
if ( a2 > 0 )
{
for ( i = 1LL; i != a2; ++i )
{
v3 = i;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v3) + *(_DWORD *)(a1 + 4 * i - 4)) )
return 1LL;
++v3;
}
while ( a2 > (int)v3... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101481
MOV R9D,ESI
MOV R8D,0x1
CMP R8,R9
JZ 0x00101481
LAB_00101456:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x00101468
LAB_00101460:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101478
LAB_00101468:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101460
MOV EAX,0x1
RET
LAB_0... | int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if (0 < (int)param_2) {
uVar2 = 1;
if ((ulong)param_2 != 1) {
do {
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) + *(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
... |
831 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size) {
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (l[i] + l[j] == 0) return true;
return false;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 3, 5, 0};
assert(func0(test1, 4) == false);
int test2[] = {1, 3, -2, 1};
assert(func0(test2, 4) == false);
int test3[] = {1, 2, 3, 7};
assert(func0(test3, 4) == false);
int test4[] = {2, 4, -5, 3, 5, 7};
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1669 <func0+0x49>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %rcx,%r8
je 1669 <func0+0x49>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 1650 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 1660 <func0+0x40>
mov %edx... | func0:
endbr64
test esi, esi
jle short loc_1181
mov r9d, esi
mov r8d, 1
cmp r9, r8
jz short loc_1181
loc_1156:
mov edx, [rdi+r8*4-4]
mov rax, r8
jmp short loc_1168
loc_1160:
add rax, 1
cmp esi, eax
jle short loc_1178
loc_1168:
mov ecx, edx
add ecx, [rdi+rax*4]
jnz... | long long func0(long long a1, int a2)
{
long long i; // r8
long long v3; // rax
if ( a2 > 0 )
{
for ( i = 1LL; a2 != i; ++i )
{
v3 = i;
do
{
if ( !(*(_DWORD *)(a1 + 4 * v3) + *(_DWORD *)(a1 + 4 * i - 4)) )
return 1LL;
++v3;
}
while ( a2 > (int)v3... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101181
MOV R9D,ESI
MOV R8D,0x1
CMP R9,R8
JZ 0x00101181
LAB_00101156:
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x00101168
LAB_00101160:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101178
LAB_00101168:
MOV ECX,EDX
ADD ECX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101160
MOV EAX,0x1
RET
LAB_0... | int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if (0 < (int)param_2) {
uVar2 = 1;
if ((ulong)param_2 != 1) {
do {
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) + *(int *)(param_1 + uVar1 * 4) == 0) {
return 1;
}
... |
832 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
f... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %rdx,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x38(%rbp)
jmp 11fe <func0+0x55>
mov -0x44(%rbp),%eax
cltd
idivl -0x48(%rbp)
mov %edx,%eax
lea 0x30... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_44], edi
mov [rbp+var_48], esi
mov [rbp+var_50], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_38], 0
jmp short loc_11FE
loc_11D7:
mov eax, [rbp+var_44]
cdq
idiv [rbp+var_48]
mov eax... | unsigned long long func0(int a1, int a2, long long a3)
{
int v3; // eax
int v4; // eax
int v7; // [rsp+18h] [rbp-38h]
int v8; // [rsp+1Ch] [rbp-34h]
_BYTE v9[40]; // [rsp+20h] [rbp-30h]
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7 = 0;
while ( a1 > 0 )
{
v3 = v7... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0x44],EDI
MOV dword ptr [RBP + -0x48],ESI
MOV qword ptr [RBP + -0x50],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001011fe
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x44]
CDQ
IDIV dw... | void func0(int param_1,int param_2,long param_3)
{
long in_FS_OFFSET;
int local_4c;
int local_40;
int local_3c;
char acStack_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = 0;
for (local_4c = param_1; 0 < local_4c; local_4c = local_4c / param_2) {
acStack_38[local... |
833 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
f... | O1 | c | func0:
endbr64
sub $0x38,%rsp
mov %rdx,%r9
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
test %edi,%edi
jle 1236 <func0+0x8d>
mov $0x1,%ecx
lea -0x1(%rsp),%r11
mov %ecx,%r8d
mov %edi,%eax
cltd
idiv %esi
lea 0x30(%rdx),%edi
mov %dil,(%r11,%rcx,1)
mov %eax,%edi
add $0x1... | func0:
endbr64
sub rsp, 38h
mov r10, rdx
mov rax, fs:28h
mov [rsp+38h+var_10], rax
xor eax, eax
test edi, edi
jle short loc_1236
mov ecx, 1
lea r9, [rsp+38h+var_39]
loc_11D2:
mov eax, edi
cdq
idiv esi
add edx, 30h ; '0'
mov [r9+rcx], dl
mov edi, eax
mov r8, rcx
... | unsigned long long func0(int a1, int a2, _BYTE *a3)
{
long long v4; // rcx
int v5; // r8d
int v6; // edi
_BYTE *v7; // rdx
_BYTE *v8; // rax
_BYTE v10[41]; // [rsp+1h] [rbp-39h] BYREF
unsigned long long v11; // [rsp+2Ah] [rbp-10h]
v11 = __readfsqword(0x28u);
if ( a1 <= 0 )
{
v6 = 0;
}
else... | func0:
ENDBR64
SUB RSP,0x38
MOV R10,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101236
MOV ECX,0x1
LEA R9,[RSP + -0x1]
LAB_001011d2:
MOV EAX,EDI
CDQ
IDIV ESI
ADD EDX,0x30
MOV byte ptr [R9 + RCX*0x1],DL
MOV EDI,EAX
MOV R8,RCX
ADD RCX,0x1
TEST EAX,EAX
JG 0x001011d2
MOV ... | void func0(int param_1,int param_2,char *param_3)
{
long lVar1;
int iVar2;
char *pcVar3;
long lVar4;
char *pcVar5;
long in_FS_OFFSET;
int8 uStack_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 < 1) {
iVar2 = 0;
}
else {
lVar1 = 1;
... |
834 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
f... | O2 | c | func0:
endbr64
sub $0x38,%rsp
mov %edi,%eax
mov %rdx,%r8
mov %fs:0x28,%rdi
mov %rdi,0x28(%rsp)
xor %edi,%edi
test %eax,%eax
jle 15d6 <func0+0x76>
mov $0x1,%ecx
lea -0x1(%rsp),%r10
nopl 0x0(%rax,%rax,1)
cltd
movslq %ecx,%rdi
mov %rcx,%r9
idiv %esi
add $0x30,%edx
mov %dl,(%r10,%r... | func0:
endbr64
sub rsp, 38h
mov r9, rdx
mov rdx, fs:28h
mov [rsp+38h+var_10], rdx
xor edx, edx
test edi, edi
jle short loc_14C6
mov eax, edi
mov ecx, 1
lea r8, [rsp+38h+var_39]
nop dword ptr [rax+rax+00h]
loc_1480:
cdq
mov rdi, rcx
idiv esi
add edx, 30h ; '0'
mov ... | unsigned long long func0(int a1, int a2, _BYTE *a3)
{
int v4; // eax
long long v5; // rcx
int v6; // edi
int v7; // et2
char *v8; // rdx
_BYTE *v9; // rax
char v10; // cl
_BYTE v12[41]; // [rsp+1h] [rbp-39h] BYREF
unsigned long long v13; // [rsp+2Ah] [rbp-10h]
v13 = __readfsqword(0x28u);
if ( a1... | func0:
ENDBR64
SUB RSP,0x38
MOV R9,RDX
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RDX
XOR EDX,EDX
TEST EDI,EDI
JLE 0x001014c6
MOV EAX,EDI
MOV ECX,0x1
LEA R8,[RSP + -0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101480:
CDQ
MOV RDI,RCX
IDIV ESI
ADD EDX,0x30
MOV byte ptr [R8 + RCX*0x1],DL
ADD RCX,0x1
TEST EAX,EAX
... | void func0(ulong param_1,char *param_2,char *param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
char *pcVar8;
long in_FS_OFFSET;
int8 uStack_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar8 = (char ... |
835 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| void func0(int x, int base, char *out) {
int index = 0;
char temp[33];
while (x > 0) {
temp[index++] = (x % base) + '0';
x = x / base;
}
int j = 0;
while(index > 0) {
out[j++] = temp[--index];
}
out[j] = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char buffer[33];
func0(8, 3, buffer);
assert(strcmp(buffer, "22") == 0);
func0(9, 3, buffer);
assert(strcmp(buffer, "100") == 0);
func0(234, 2, buffer);
assert(strcmp(buffer, "11101010") == 0);
f... | O3 | c | func0:
endbr64
sub $0x38,%rsp
mov %edi,%eax
mov %rdx,%r8
mov %fs:0x28,%rdi
mov %rdi,0x28(%rsp)
xor %edi,%edi
test %eax,%eax
jle 1506 <func0+0x76>
mov $0x1,%ecx
lea -0x1(%rsp),%r10
nopl 0x0(%rax,%rax,1)
cltd
movslq %ecx,%rdi
mov %rcx,%r9
idiv %esi
add $0x30,%edx
mov %dl,(%r10,%r... | func0:
endbr64
sub rsp, 38h
mov r9, rdx
mov rdx, fs:28h
mov [rsp+38h+var_10], rdx
xor edx, edx
test edi, edi
jle short loc_1456
mov eax, edi
mov ecx, 1
lea r8, [rsp+38h+var_39]
nop dword ptr [rax+rax+00h]
loc_1410:
cdq
mov rdi, rcx
idiv esi
add edx, 30h ; '0'
mov ... | unsigned long long func0(int a1, int a2, _BYTE *a3)
{
int v4; // eax
long long v5; // rcx
int v6; // edi
int v7; // et2
char *v8; // rdx
_BYTE *v9; // rax
char v10; // cl
_BYTE v12[41]; // [rsp+1h] [rbp-39h] BYREF
unsigned long long v13; // [rsp+2Ah] [rbp-10h]
v13 = __readfsqword(0x28u);
if ( a1... | func0:
ENDBR64
SUB RSP,0x38
MOV R9,RDX
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RDX
XOR EDX,EDX
TEST EDI,EDI
JLE 0x00101456
MOV EAX,EDI
MOV ECX,0x1
LEA R8,[RSP + -0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101410:
CDQ
MOV RDI,RCX
IDIV ESI
ADD EDX,0x30
MOV byte ptr [R8 + RCX*0x1],DL
ADD RCX,0x1
TEST EAX,EAX
... | void func0(ulong param_1,char *param_2,char *param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
char *pcVar8;
long in_FS_OFFSET;
int8 uStack_40;
char local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar8 = (char ... |
836 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float h) {
return (a * h) * 0.5;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss -0x4(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss -0x8(%rbp),%xmm1
movss 0xf48(%rip),%xmm0
mulss %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss xmm0, [rbp+var_4]
movaps xmm1, xmm0
mulss xmm1, [rbp+var_8]
movss xmm0, cs:dword_2098
mulss xmm0, xmm1
pop rbp
retn | float func0(float a1, float a2)
{
return 0.5 * (float)(a1 * a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM1,XMM0
MULSS XMM1,dword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [0x00102098]
MULSS XMM0,XMM1
POP RBP
RET | float func0(float param_1,float param_2)
{
return DAT_00102098 * param_1 * param_2;
} |
837 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float h) {
return (a * h) * 0.5;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
} | O1 | c | func0:
endbr64
mulss %xmm1,%xmm0
mulss 0xecb(%rip),%xmm0
retq
| func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
} |
838 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float h) {
return (a * h) * 0.5;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
} | O2 | c | func0:
endbr64
mulss %xmm1,%xmm0
mulss 0xeb4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
} |
839 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float h) {
return (a * h) * 0.5;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(fabs(func0(5, 3) - 7.5) < 1e-4);
assert(fabs(func0(2, 2) - 2.0) < 1e-4);
assert(fabs(func0(10, 8) - 40.0) < 1e-4);
return 0;
} | O3 | c | func0:
endbr64
mulss %xmm1,%xmm0
mulss 0xeb4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
} |
840 | func0 | #include <stdio.h>
| int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1c0,%rsp
mov %edi,-0x1b4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x1a0(%rbp)
movl $0x0,-0x19c(%rbp)
movl $0x2,-0x198(%rbp)
movl $0x0,-0x194(%rbp)
movl $0x4,-0x1a4(%rbp)
jmp 1225 <func0+0xbc>
mov -0x1a4(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1C0h
mov [rbp+var_1B4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_1A0], 0
mov [rbp+var_19C], 0
mov [rbp+var_198], 2
mov [rbp+var_194], 0
mov [rbp+var_1A4], 4
jmp short loc_1225
loc_11C1:
mov eax... | long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-1A4h]
_DWORD v3[102]; // [rsp+20h] [rbp-1A0h]
unsigned long long v4; // [rsp+1B8h] [rbp-8h]
v4 = __readfsqword(0x28u);
v3[0] = 0;
v3[1] = 0;
v3[2] = 2;
v3[3] = 0;
for ( i = 4; i <= a1; ++i )
v3[i] = v3[i - 4] + v3[i - 3] + v3[i - 2] + v3[i - 1];... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1c0
MOV dword ptr [RBP + -0x1b4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x1a0],0x0
MOV dword ptr [RBP + -0x19c],0x0
MOV dword ptr [RBP + -0x198],0x2
MOV dword ptr [RBP + -0x194],0x0
MOV dword ptr [RBP + -0x1a4],0x4
J... | int func0(int param_1)
{
long in_FS_OFFSET;
int local_1ac;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8[0] = 0;
local_1a8[1] = 0;
local_1a8[2] = 2;
local_1a8[3] = 0;
for (local_1ac = 4; local_1ac <= param_1; local_1ac = local_1ac + 1) {
local_1a8[l... |
841 | func0 | #include <stdio.h>
| int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
} | O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movl $0x0,(%rsp)
movl $0x0,0x4(%rsp)
movl $0x2,0x8(%rsp)
movl $0x0,0xc(%rsp)
cmp $0x3,%edi
jle 11cd <func0+0x64>
mov %rsp,%rax
lea -0x4(%rdi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov 0x8(%rax),%edx
add ... | func0:
endbr64
sub rsp, 1A8h
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov [rsp+1A8h+var_1A8], 0
mov [rsp+1A8h+var_1A4], 0
mov [rsp+1A8h+var_1A0], 2
mov [rsp+1A8h+var_19C], 0
cmp edi, 3
jle short loc_11CD
mov rax, rsp
lea edx, [rdi-4]
lea rcx, [rsp+rdx*4... | long long func0(int a1)
{
int *v1; // rax
int v3; // [rsp+0h] [rbp-1A8h] BYREF
_DWORD v4[101]; // [rsp+4h] [rbp-1A4h] BYREF
unsigned long long v5; // [rsp+198h] [rbp-10h]
v5 = __readfsqword(0x28u);
v3 = 0;
v4[0] = 0;
v4[1] = 2;
v4[2] = 0;
if ( a1 > 3 )
{
v1 = &v3;
do
{
v1[4] = ... | func0:
ENDBR64
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x0
MOV dword ptr [RSP + 0x8],0x2
MOV dword ptr [RSP + 0xc],0x0
CMP EDI,0x3
JLE 0x001011cd
MOV RAX,RSP
LEA EDX,[RDI + -0x4]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011b6:
M... | int func0(int param_1)
{
int *piVar1;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar1 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8[0] = 0;
local_1a8[1] = 0;
local_1a8[2] = 2;
local_1a8[3] = 0;
if (3 < param_1) {
do {
piVar1[4] = piVar1[2] + piVar1[3... |
842 | func0 | #include <stdio.h>
| int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
} | O2 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x2,0x8(%rsp)
cmp $0x3,%edi
jle 12af <func0+0x6f>
lea -0x4(%rdi),%eax
lea 0x4(%rsp),%rdx
xor %r8d,%r8d
xor %esi,%esi
lea 0x8(%rsp,%rax,4),%r9
mov $0x2,%ecx
xor %eax,%eax
... | func0:
endbr64
sub rsp, 1A8h
movdqa xmm0, cs:xmmword_2070
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
movaps [rsp+1A8h+var_1A8], xmm0
cmp edi, 3
jle short loc_12A4
lea eax, [rdi-4]
mov rdx, rsp
mov ecx, 2
xor r8d, r8d
lea r9, [rsp+rax*4+1A8h+var_1A8+4]
xor e... | long long func0(int a1)
{
__m128i *p_si128; // rdx
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // esi
__m128i si128; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v8; // [rsp+198h] [rbp-10h]
v8 = __readfsqword(0x28u);
si128 = _mm_load_si128((const __m128i *)&xmmword_2070);
if ( a1 > 3 )... | func0:
ENDBR64
SUB RSP,0x1a8
MOVDQA XMM0,xmmword ptr [0x00102070]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
CMP EDI,0x3
JLE 0x001012a4
LEA EAX,[RDI + -0x4]
MOV RDX,RSP
MOV ECX,0x2
XOR R8D,R8D
LEA R9,[RSP + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int *piVar5;
int iVar6;
long in_FS_OFFSET;
int8 local_1a8;
int8 uStack_1a0;
int local_198 [98];
long local_10;
local_10 = *(long *)(in... |
843 | func0 | #include <stdio.h>
| int func0(int n) {
int f[100];
f[0] = 0;
f[1] = 0;
f[2] = 2;
f[3] = 0;
for (int i = 4; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3] + f[i - 4];
}
return f[n];
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(5) == 4);
assert(func0(8) == 28);
assert(func0(10) == 104);
assert(func0(12) == 386);
return 0;
} | O3 | c | func0:
endbr64
sub $0x1a8,%rsp
movdqa 0xe3d(%rip),%xmm0
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movaps %xmm0,(%rsp)
cmp $0x3,%edi
jle 12fa <func0+0xba>
lea -0x1(%rdi),%r11d
cmp $0x6,%edi
jle 131b <func0+0xdb>
mov %rsp,%r10
mov 0x8(%rsp),%esi
mov 0xc(%rsp),%edx
mov $0x... | func0:
endbr64
sub rsp, 1A8h
movdqa xmm0, cs:xmmword_2070
movsxd rsi, edi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
movaps [rsp+1A8h+var_1A8], xmm0
cmp esi, 3
jle loc_12FA
lea r11d, [rsi-1]
cmp esi, 6
jle loc_1318
mov r10, rsp
xor r8d, r8d
mov edi, 2
xor ... | long long func0(int a1)
{
long long v1; // rsi
int v2; // r8d
int v3; // edi
int v4; // edx
__m128i *p_si128; // rax
int v6; // ecx
int v7; // r9d
char *v8; // rdx
int v9; // eax
__m128i si128; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v12; // [rsp+198h] [rbp-10h]
v1 = a1;
v12 = __read... | func0:
ENDBR64
SUB RSP,0x1a8
MOVDQA XMM0,xmmword ptr [0x00102070]
MOVSXD RSI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
CMP ESI,0x3
JLE 0x001012fa
LEA R11D,[RSI + -0x1]
CMP ESI,0x6
JLE 0x00101318
MOV R10,RSP
XOR R8D,R8D
MOV EDI,0x2
XOR EDX,EDX
MOV RAX,R10
M... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(int param_1)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
int8 local_1a8;
int8 uStack_1a0;
long local_10;
local_10 = *(long *)(in_FS_OFFSET ... |
844 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
ret... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4)... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1245 <func0+0xdc>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 1235 <func0+0xcc>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%ra... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
jmp loc_1245
loc_1184:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp loc_1235
loc_1192:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
a... | float func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
int j; // [rsp+14h] [rbp-8h]
int v5; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(float *)(4LL * i + a1) > *(float *)(4LL * j + a1) )
{
v5 = *(_DWORD *)(4LL * i + a1);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101245
LAB_00101184:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101235
LAB_00101192:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV... | float func0(long param_1,int param_2)
{
int4 uVar1;
float fVar2;
int4 local_14;
int4 local_10;
for (local_14 = 0; local_10 = local_14, local_14 < param_2; local_14 = local_14 + 1) {
while (local_10 = local_10 + 1, local_10 < param_2) {
if (*(float *)(param_1 + (long)local_10 * 4) < *(float *)(pa... |
845 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
ret... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4)... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11b6 <func0+0x4d>
mov %rdi,%rdx
lea -0x1(%rsi),%r8d
add $0x1,%r8
mov $0x1,%ecx
jmp 11ac <func0+0x43>
add $0x1,%rax
cmp %eax,%esi
jle 11a4 <func0+0x3b>
movss (%rdx),%xmm0
movss (%rdi,%rax,4),%xmm1
comiss %xmm1,%xmm0
jbe 1183 <func0+0x1a>
movss %xmm1,(%... | func0:
endbr64
push rbx
mov r11, rdi
mov edi, esi
test esi, esi
jle short loc_11EA
lea rdx, [r11+4]
lea ebx, [rsi-1]
mov r8d, esi
movsxd r10, esi
mov esi, 1
lea r9, [r11+8]
jmp short loc_11C1
loc_118F:
add rax, 4
cmp rax, rcx
jz short loc_11B1
loc_1198:
movss xm... | float func0(long long a1, int a2)
{
_DWORD *v4; // rdx
int v5; // ebx
long long v6; // r8
long long v7; // r10
long long i; // rsi
_DWORD *v9; // rax
float v10; // xmm0_4
if ( a2 <= 0 )
return (float)(*(float *)(a1 + 4LL * (a2 / 2) - 4) + *(float *)(a1 + 4LL * (a2 / 2))) * 0.5;
v4 = (_DWORD *)(a... | func0:
ENDBR64
PUSH RBX
MOV R11,RDI
MOV EDI,ESI
TEST ESI,ESI
JLE 0x001011ea
LEA RDX,[R11 + 0x4]
LEA EBX,[RSI + -0x1]
MOV R8D,ESI
MOVSXD R10,ESI
MOV ESI,0x1
LEA R9,[R11 + 0x8]
JMP 0x001011c1
LAB_0010118f:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x001011b1
LAB_00101198:
MOVSS XMM0,dword ptr [RDX + -0x4]
MOVSS XMM1,dword ptr [RAX]
COM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(long param_1,uint param_2)
{
float fVar1;
float *pfVar2;
float *pfVar3;
ulong uVar4;
bool bVar5;
if (0 < (int)param_2) {
pfVar3 = (float *)(param_1 + 4);
uVar4 = 1;
do {
if (uVar4 == param... |
846 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
ret... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4)... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1424 <func0+0x54>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
mov %rdi,%rdx
add $0x1,%r8
cmp %rcx,%r8
je 1424 <func0+0x54>
nopl (%rax)
mov %rcx,%rax
nopl 0x0(%rax,%rax,1)
movss (%rdx),%xmm0
movss (%rdi,%rax,4),%xmm1
comiss %xmm1,%xmm0
jbe 140f <func0+0x3f>
mov... | func0:
endbr64
test esi, esi
jle short loc_13EA
cmp esi, 1
jz short loc_1409
mov rdx, rdi
mov r8d, esi
mov ecx, 1
nop dword ptr [rax+rax+00000000h]
loc_13B0:
mov rax, rcx
nop dword ptr [rax+rax+00h]
loc_13B8:
movss xmm0, dword ptr [rdx]
movss xmm1, dword ptr [rdi+rax*4]
comis... | float func0(float *a1, int a2)
{
float *v2; // rdx
long long i; // rcx
long long v4; // rax
float v5; // xmm0_4
float v6; // xmm1_4
if ( a2 <= 0 )
return (float)(a1[a2 / 2 - 1] + a1[a2 / 2]) * 0.5;
if ( a2 == 1 )
return a1[a2 >> 1];
v2 = a1;
for ( i = 1LL; i != a2; ++i )
{
v4 = i;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013ea
CMP ESI,0x1
JZ 0x00101409
MOV RDX,RDI
MOV R8D,ESI
MOV ECX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV RAX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b8:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDI + RAX*0x4]
COMISS XMM0,XMM1
JBE 0x001013cf
MOVSS dword ptr [RD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float *param_1,uint param_2)
{
float fVar1;
ulong uVar2;
ulong uVar3;
float *pfVar4;
if ((int)param_2 < 1) {
LAB_001013ea:
return (param_1[(long)((int)param_2 / 2) + -1] + param_1[(int)param_2 / 2]) * _DA... |
847 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| float func0(float *l, int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (l[i] > l[j]) {
float temp = l[i];
l[i] = l[j];
l[j] = temp;
}
}
}
if (size % 2 == 1) return l[size / 2];
ret... | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
float list1[] = {3, 1, 2, 4, 5};
assert(fabs(func0(list1, 5) - 3) < 1e-4);
float list2[] = {-10, 4, 6, 1000, 10, 20};
assert(fabs(func0(list2, 6) - 8.0) < 1e-4);
float list3[] = {5};
assert(fabs(func0(list3, 1) - 5) < 1e-4)... | O3 | c | func0:
endbr64
test %esi,%esi
jle 13e4 <func0+0x54>
cmp $0x1,%esi
je 13e4 <func0+0x54>
lea -0x2(%rsi),%r8d
mov %rdi,%rdx
mov $0x1,%ecx
add $0x2,%r8
nopl (%rax)
mov %rcx,%rax
nopl 0x0(%rax,%rax,1)
movss (%rdx),%xmm0
movss (%rdi,%rax,4),%xmm1
comiss %xmm1,%xmm0
jbe 13cf <func0+0x3f>
mo... | func0:
endbr64
test esi, esi
jle short loc_12BA
cmp esi, 1
jz short loc_12D9
mov rdx, rdi
mov r8d, esi
mov ecx, 1
nop dword ptr [rax+rax+00000000h]
loc_1280:
mov rax, rcx
nop dword ptr [rax+rax+00h]
loc_1288:
movss xmm0, dword ptr [rdx]
movss xmm1, dword ptr [rdi+rax*4]
comis... | float func0(float *a1, int a2)
{
float *v2; // rdx
long long i; // rcx
long long v4; // rax
float v5; // xmm0_4
float v6; // xmm1_4
if ( a2 <= 0 )
return (float)(a1[a2 / 2 - 1] + a1[a2 / 2]) * 0.5;
if ( a2 == 1 )
return a1[a2 >> 1];
v2 = a1;
for ( i = 1LL; i != a2; ++i )
{
v4 = i;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012ba
CMP ESI,0x1
JZ 0x001012d9
MOV RDX,RDI
MOV R8D,ESI
MOV ECX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101280:
MOV RAX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101288:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDI + RAX*0x4]
COMISS XMM0,XMM1
JBE 0x0010129f
MOVSS dword ptr [RD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float *param_1,uint param_2)
{
float fVar1;
ulong uVar2;
ulong uVar3;
float *pfVar4;
if ((int)param_2 < 1) {
LAB_001012ba:
return (param_1[(long)((int)param_2 / 2) + -1] + param_1[(int)param_2 / 2]) * _DA... |
848 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11c6 <func0+0x5d>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%e... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_11C6
loc_1191:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte pt... | long long func0(const char *a1)
{
int i; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = strlen(a1);
for ( i = 0; i < v3 / 2; ++i )
{
if ( a1[i] != a1[v3 - 1 - i] )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011c6
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | int8 func0(char *param_1)
{
size_t sVar1;
int local_10;
sVar1 = strlen(param_1);
local_10 = 0;
while( true ) {
if ((int)sVar1 / 2 <= local_10) {
return 1;
}
if (param_1[local_10] != param_1[((int)sVar1 + -1) - local_10]) break;
local_10 = local_10 + 1;
}
return 0;
} |
849 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
} | O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 119d <func0+0x54>
cltq
lea -0x1(%rsi,%rax,1),%rdx
mov $0x0,%eax
movzbl (%... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_11AC
cdqe
lea rdx, [rbx+rax-1]
mov eax, 0
loc_1190:
movzx esi, byte ptr [rdx]
cmp [rbx+rax], sil
jnz short loc_11B3
add rax, 1
sub rdx,... | long long func0(const char *a1)
{
int v1; // eax
int v2; // ecx
const char *v3; // rdx
long long v4; // rax
v1 = strlen(a1);
v2 = v1 / 2;
if ( v1 <= 1 )
return 1LL;
v3 = &a1[v1 - 1];
v4 = 0LL;
while ( a1[v4] == *v3 )
{
++v4;
--v3;
if ( v2 <= (int)v4 )
return 1LL;
}
retu... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x001011ac
CDQE
LEA RDX,[RBX + RAX*0x1 + -0x1]
MOV EAX,0x0
LAB_00101190:
MOVZX ESI,byte ptr [RDX]
CMP byte ptr [RBX + RAX*0x1],SIL
JNZ 0x001011b3
ADD RAX,0x1
SUB RDX,0x1
CMP ECX,EAX
JG 0x00101190
MOV EAX... | int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (1 < iVar1) {
pcVar4 = param_1 + (long)iVar1 + -1;
lVar3 = 0;
do {
if (param_1[lVar3] != *pcVar4) {
return 0;
}
lVar3 = lVar3 + 1;
... |
850 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
} | O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 1330 <func0+0x50>
sub $0x1,%eax
xor %edx,%edx
cltq
add %rbx,%rax
jmp 131c <func0+0x3c>
nopw 0x0(%rax,%rax,1)
add $0x1,%rdx
sub $0x1,%rax
cmp ... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_1330
sub eax, 1
xor edx, edx
cdqe
add rax, rbx
jmp short loc_131C
loc_1310:
add rdx, 1
sub rax, 1
cmp ecx, edx
jle short loc_1330... | long long func0(const char *a1)
{
int v1; // eax
int v2; // ecx
long long v3; // rdx
const char *i; // rax
v1 = strlen(a1);
v2 = v1 / 2;
if ( v1 <= 1 )
return 1LL;
v3 = 0LL;
for ( i = &a1[v1 - 1]; a1[v3] == *i; --i )
{
if ( v2 <= (int)++v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x00101330
SUB EAX,0x1
XOR EDX,EDX
CDQE
ADD RAX,RBX
JMP 0x0010131c
LAB_00101310:
ADD RDX,0x1
SUB RAX,0x1
CMP ECX,EDX
JLE 0x00101330
LAB_0010131c:
MOVZX ESI,byte ptr [RAX]
CMP byte ptr [RBX + RDX*0x1],SIL... | int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (1 < iVar1) {
lVar4 = 0;
pcVar3 = param_1 + (iVar1 + -1);
do {
if (param_1[lVar4] != *pcVar3) {
return 0;
}
lVar4 = lVar4 + 1;
pcVa... |
851 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *text) {
int len = strlen(text);
for (int i = 0; i < len / 2; i++) {
if (text[i] != text[len - 1 - i]) {
return false;
}
}
return true;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0("") == true);
assert(func0("aba") == true);
assert(func0("aaaaa") == true);
assert(func0("zbcd") == false);
assert(func0("xywyx") == true);
assert(func0("xywyz") == false);
assert(func0("xywzx") == false);
return 0;
} | O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 1330 <func0+0x50>
sub $0x1,%eax
xor %edx,%edx
cltq
add %rbx,%rax
jmp 131c <func0+0x3c>
nopw 0x0(%rax,%rax,1)
add $0x1,%rdx
sub $0x1,%rax
cmp ... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_1330
sub eax, 1
xor edx, edx
cdqe
add rax, rbx
jmp short loc_131C
loc_1310:
add rdx, 1
sub rax, 1
cmp ecx, edx
jle short loc_1330... | long long func0(const char *a1)
{
int v1; // eax
int v2; // ecx
long long v3; // rdx
const char *i; // rax
v1 = strlen(a1);
v2 = v1 / 2;
if ( v1 <= 1 )
return 1LL;
v3 = 0LL;
for ( i = &a1[v1 - 1]; a1[v3] == *i; --i )
{
if ( v2 <= (int)++v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x00101330
SUB EAX,0x1
XOR EDX,EDX
CDQE
ADD RAX,RBX
JMP 0x0010131c
LAB_00101310:
ADD RDX,0x1
SUB RAX,0x1
CMP ECX,EDX
JLE 0x00101330
LAB_0010131c:
MOVZX ESI,byte ptr [RAX]
CMP byte ptr [RBX + RDX*0x1],SIL... | int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (1 < iVar1) {
lVar4 = 0;
pcVar3 = param_1 + (iVar1 + -1);
do {
if (param_1[lVar4] != *pcVar3) {
return 0;
}
lVar4 = lVar4 + 1;
pcVa... |
852 | func0 | #include <stdio.h>
| int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
ret... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1197 <func0+0x2e>
mov -0x8(%rbp),%eax
add %eax,%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1197
loc_1187:
mov eax, [rbp+var_8]
add eax, eax
cdq
idiv [rbp+var_18]
mov [rbp+var_8], edx
add [rbp+var_4], 1
loc_1197:
mov eax, [rbp+va... | long long func0(int a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v3 = 1;
for ( i = 0; i < a1; ++i )
v3 = (int)(2 * v3) % a2;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101197
LAB_00101187:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x8],EDX
ADD dword ptr [RBP + -... | int func0(int param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 0; local_c < param_1; local_c = local_c + 1) {
local_10 = (local_10 * 2) % param_2;
}
return local_10;
} |
853 | func0 | #include <stdio.h>
| int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
ret... | O1 | c | func0:
endbr64
test %edi,%edi
jle 118b <func0+0x22>
mov $0x0,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
cltd
idiv %esi
add $0x1,%ecx
cmp %ecx,%edi
jne 117b <func0+0x12>
mov %edx,%eax
retq
mov $0x1,%edx
jmp 1188 <func0+0x1f>
| func0:
endbr64
test edi, edi
jle short loc_118B
mov ecx, 0
mov edx, 1
loc_117B:
lea eax, [rdx+rdx]
cdq
idiv esi
add ecx, 1
cmp edi, ecx
jnz short loc_117B
loc_1188:
mov eax, edx
retn
loc_118B:
mov edx, 1
jmp short loc_1188 | long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
{
return 1;
}
else
{
v2 = 0;
v3 = 1;
do
{
v3 = (int)(2 * v3) % a2;
++v2;
}
while ( a1 != v2 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010118b
MOV ECX,0x0
MOV EDX,0x1
LAB_0010117b:
LEA EAX,[RDX + RDX*0x1]
CDQ
IDIV ESI
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x0010117b
LAB_00101188:
MOV EAX,EDX
RET
LAB_0010118b:
MOV EDX,0x1
JMP 0x00101188 | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 1;
}
else {
iVar1 = 0;
iVar2 = 1;
do {
iVar2 = (iVar2 * 2) % param_2;
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
}
return iVar2;
} |
854 | func0 | #include <stdio.h>
| int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
ret... | O2 | c | func0:
endbr64
test %edi,%edi
jle 1310 <func0+0x20>
xor %ecx,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
add $0x1,%ecx
cltd
idiv %esi
cmp %ecx,%edi
jne 1300 <func0+0x10>
mov %edx,%eax
retq
mov $0x1,%edx
mov %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1310
xor ecx, ecx
mov edx, 1
nop
loc_1300:
lea eax, [rdx+rdx]
add ecx, 1
cdq
idiv esi
cmp edi, ecx
jnz short loc_1300
mov eax, edx
retn
loc_1310:
mov edx, 1
mov eax, edx
retn | long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
return 1LL;
v2 = 0;
v3 = 1;
do
{
++v2;
v3 = (int)(2 * v3) % a2;
}
while ( a1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101310
XOR ECX,ECX
MOV EDX,0x1
NOP
LAB_00101300:
LEA EAX,[RDX + RDX*0x1]
ADD ECX,0x1
CDQ
IDIV ESI
CMP EDI,ECX
JNZ 0x00101300
MOV EAX,EDX
RET
LAB_00101310:
MOV EDX,0x1
MOV EAX,EDX
RET | ulong func0(int param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 0;
iVar3 = 1;
do {
iVar2 = iVar2 + 1;
uVar1 = (long)(iVar3 * 2) % (long)param_2;
iVar3 = (int)uVar1;
} while (param_1 != iVar2);
return uVar1 & 0xffffffff;
}
return ... |
855 | func0 | #include <stdio.h>
| int func0(int n, int p) {
int out = 1;
for (int i = 0; i < n; i++)
out = (out * 2) % p;
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
assert(func0(3, 5) == 3);
assert(func0(1101, 101) == 2);
assert(func0(0, 101) == 1);
assert(func0(3, 11) == 8);
assert(func0(100, 101) == 1);
assert(func0(30, 5) == 4);
assert(func0(31, 5) == 3);
printf("All tests passed.\n");
ret... | O3 | c | func0:
endbr64
test %edi,%edi
jle 1310 <func0+0x20>
xor %ecx,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
add $0x1,%ecx
cltd
idiv %esi
cmp %ecx,%edi
jne 1300 <func0+0x10>
mov %edx,%eax
retq
mov $0x1,%edx
mov %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1310
xor ecx, ecx
mov edx, 1
nop
loc_1300:
lea eax, [rdx+rdx]
add ecx, 1
cdq
idiv esi
cmp edi, ecx
jnz short loc_1300
mov eax, edx
retn
loc_1310:
mov edx, 1
mov eax, edx
retn | long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
return 1LL;
v2 = 0;
v3 = 1;
do
{
++v2;
v3 = (int)(2 * v3) % a2;
}
while ( a1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101310
XOR ECX,ECX
MOV EDX,0x1
NOP
LAB_00101300:
LEA EAX,[RDX + RDX*0x1]
ADD ECX,0x1
CDQ
IDIV ESI
CMP EDI,ECX
JNZ 0x00101300
MOV EAX,EDX
RET
LAB_00101310:
MOV EDX,0x1
MOV EAX,EDX
RET | ulong func0(int param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 0;
iVar3 = 1;
do {
iVar2 = iVar2 + 1;
uVar1 = (long)(iVar3 * 2) % (long)param_2;
iVar3 = (int)uVar1;
} while (param_1 != iVar2);
return uVar1 & 0xffffffff;
}
return ... |
856 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
} | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
cmpl $0x0,-0x2c(%rbp)
je 1269 <func0+0x20>
mov $0x5,%eax
jmp 126e <func0+0x25>
mov $0x15,%eax
mov %eax,-0x18(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %rax... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_2C], esi
cmp [rbp+var_2C], 0
jz short loc_1269
mov eax, 5
jmp short loc_126E
loc_1269:
mov eax, 15h
loc_126E:
mov [rbp+var_18], eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov ... | size_t func0(const char *a1, int a2)
{
int v2; // eax
size_t result; // rax
int v4; // [rsp+18h] [rbp-18h]
size_t i; // [rsp+20h] [rbp-10h]
size_t v6; // [rsp+28h] [rbp-8h]
if ( a2 )
v2 = 5;
else
v2 = 21;
v4 = v2;
v6 = strlen(a1);
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= v6... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x00101269
MOV EAX,0x5
JMP 0x0010126e
LAB_00101269:
MOV EAX,0x15
LAB_0010126e:
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010f0
M... | void func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
int iVar3;
ulong local_18;
if (param_2 == 0) {
iVar1 = 0x15;
}
else {
iVar1 = 5;
}
sVar2 = strlen(param_1);
for (local_18 = 0; local_18 < sVar2; local_18 = local_18 + 1) {
iVar3 = param_1[local_18] + -0x61 + iVar1;
... |
857 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
} | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr... | O1 | c | func0:
endbr64
mov %rdi,%rdx
cmp $0x1,%esi
sbb %r8d,%r8d
and $0x10,%r8d
add $0x5,%r8d
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
sub $0x1,%rdi
je 128e <func0+0x65>
mov %rdx,%rcx
add %rdx,%rdi
movsbl (%rcx),%eax
lea -0x61(%r8,%ra... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
cmp esi, 1
sbb ebx, ebx
and ebx, 10h
add ebx, 5
call _strlen
test rax, rax
jz short loc_12A2
mov rcx, rbp
lea rdi, [rbp+rax+0]
loc_1273:
movsx eax, byte ptr [rcx]
lea edx, [rbx+rax-61h]
movsxd rax, edx
imul ... | size_t func0(const char *a1, int a2)
{
size_t result; // rax
char *v3; // rcx
char *v4; // rdi
int v5; // edx
result = strlen(a1);
if ( result )
{
v3 = (char *)a1;
v4 = (char *)&a1[result];
do
{
v5 = (a2 == 0 ? 21 : 5) + *v3 - 97;
result = (unsigned int)(26 * (v5 / 26));
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
CMP ESI,0x1
SBB EBX,EBX
AND EBX,0x10
ADD EBX,0x5
CALL 0x001010e0
TEST RAX,RAX
JZ 0x001012a2
MOV RCX,RBP
LEA RDI,[RBP + RAX*0x1]
LAB_00101273:
MOVSX EAX,byte ptr [RCX]
LEA EDX,[RBX + RAX*0x1 + -0x61]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x4ec4ec4f
SAR RAX,0x23
MOV ESI,EDX
... | void func0(char *param_1,int param_2)
{
int iVar1;
char *pcVar2;
size_t sVar3;
sVar3 = strlen(param_1);
if (sVar3 != 0) {
pcVar2 = param_1 + sVar3;
do {
iVar1 = ((-(uint)(param_2 == 0) & 0x10) - 0x5c) + (int)*param_1;
*param_1 = (char)iVar1 + (char)(iVar1 / 0x1a) * -0x1a + 'a';
p... |
858 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
} | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr... | O2 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
cmp $0x1,%esi
sbb %ebp,%ebp
and $0x10,%ebp
add $0x5,%ebp
callq 10f0 <strlen@plt>
test %rax,%rax
je 13f0 <func0+0x60>
mov %rbx,%rdi
lea (%rbx,%rax,1),%rsi
nopl 0x0(%rax)
movsbl (%rdi),%eax
add $0x1,%rdi
lea -0x61(%r... | func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
cmp esi, 1
sbb ebp, ebp
and ebp, 10h
add ebp, 5
call _strlen
test rax, rax
jz short loc_1460
mov rdi, rbx
add rax, rbx
nop dword ptr [rax+rax+00000000h]
loc_1430:
movsx edx, byte ptr [rdi]
add rdi, 1
lea ... | size_t func0(const char *a1, int a2)
{
size_t result; // rax
int v3; // edx
result = strlen(a1);
if ( result )
{
result += (size_t)a1;
do
{
v3 = *a1++;
*((_BYTE *)a1 - 1) = ((a2 == 0 ? 21 : 5) + v3 - 97) % 26 + 97;
}
while ( a1 != (const char *)result );
}
return result;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CMP ESI,0x1
SBB EBP,EBP
AND EBP,0x10
ADD EBP,0x5
CALL 0x001010e0
TEST RAX,RAX
JZ 0x00101460
MOV RDI,RBX
ADD RAX,RBX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101430:
MOVSX EDX,byte ptr [RDI]
ADD RDI,0x1
LEA ECX,[RBP + RDX*0x1 + -0x61]
MOVSXD RDX,ECX
MOV ESI,ECX
IMUL RD... | void func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
sVar2 = strlen(param_1);
if (sVar2 != 0) {
pcVar3 = param_1;
do {
pcVar4 = pcVar3 + 1;
iVar1 = ((-(uint)(param_2 == 0) & 0x10) - 0x5c) + (int)*pcVar3;
*pcVar3 = (char)iVar1 + (char)(iVa... |
859 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *s, int encode) {
int shift = encode ? 5 : 21;
size_t len = strlen(s);
for (size_t i = 0; i < len; i++) {
int w = ((s[i] - 'a' + shift) % 26) + 'a';
s[i] = (char)w;
}
} | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
int main() {
srand((unsigned int)time(NULL));
for (int i = 0; i < 100; i++) {
int l = 10 + rand() % 11;
char *str = (char *)malloc(l + 1);
for (int j = 0; j < l; j++) {
char chr... | O3 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
cmp $0x1,%esi
sbb %ebp,%ebp
and $0x10,%ebp
add $0x5,%ebp
callq 10f0 <strlen@plt>
test %rax,%rax
je 212c <func0+0x4bc>
lea -0x1(%rax),%rdx
cmp $0xe,%rdx
jbe 2133 <func0+0x4c3>
movd %ebp,%xmm2
mov %rax,%rcx
movdqa 0x... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
cmp esi, 1
sbb ebx, ebx
and ebx, 10h
add ebx, 5
call _strlen
test rax, rax
jz loc_294C
mov rdx, rax
lea rax, [rax-1]
cmp rax, 0Eh
jbe loc_2953
pxor xmm5, xmm5
movd xmm7, ebx
mov rcx, rdx
mov r... | size_t func0(const char *a1, int a2)
{
unsigned int v3; // ebx
size_t result; // rax
unsigned long long v5; // rdx
__m128i v6; // xmm7
__m128i si128; // xmm4
unsigned long long v8; // rcx
char *v9; // rsi
__m128i v10; // xmm9
__m128i v11; // xmm6
__m128i v12; // xmm7
__m128i v13; // xmm11
__m12... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CMP ESI,0x1
SBB EBX,EBX
AND EBX,0x10
ADD EBX,0x5
CALL 0x001010e0
TEST RAX,RAX
JZ 0x0010294c
MOV RDX,RAX
LEA RAX,[RAX + -0x1]
CMP RAX,0xe
JBE 0x00102953
PXOR XMM5,XMM5
MOVD XMM7,EBX
MOV RCX,RDX
MOV RAX,RBP
MOVDQA XMM4,xmmword ptr [0x00103060]
MOVDQA XMM6,XMM5
PUNP... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int (*param_1) [16],int param_2)
{
ushort uVar1;
ushort uVar2;
ushort uVar3;
ushort uVar4;
ushort uVar5;
ushort uVar6;
ushort uVar7;
ushort uVar8;
int auVar9 [14];
int auVar10 [12];
unkbyte10 Var11;
... |
860 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
asser... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
lea 0xe48(%rip),%rax
mov %rax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov %rax,-0x10(%rbp)
jmp 1205 <func0+0x5c>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x8(%rbp),%rax
mov %edx,%esi
mov %rax,%rd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
lea rax, aAeiouaeiou; "AEIOUaeiou"
mov [rbp+s], rax
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
jmp short loc_1205
loc_11CE:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+... | _BYTE * func0(_BYTE *a1)
{
_BYTE *v1; // rax
_BYTE *result; // rax
_BYTE *v3; // [rsp+8h] [rbp-18h]
_BYTE *v4; // [rsp+10h] [rbp-10h]
v3 = a1;
v4 = a1;
while ( *v3 )
{
if ( !strchr("AEIOUaeiou", (char)*v3) )
{
v1 = v4++;
*v1 = *v3;
}
++v3;
}
result = v4;
*v4 = 0;
ret... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00101205
LAB_001011ce:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -... | void func0(char *param_1)
{
char *pcVar1;
char *local_20;
char *local_18;
local_18 = param_1;
for (local_20 = param_1; *local_20 != '\0'; local_20 = local_20 + 1) {
pcVar1 = strchr("AEIOUaeiou",(int)*local_20);
if (pcVar1 == (char *)0x0) {
*local_18 = *local_20;
local_18 = local_18 + 1... |
861 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
asser... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
movzbl (%rdi),%ebp
test %bpl,%bpl
je 11d6 <func0+0x4d>
mov %rdi,%r12
lea 0xe58(%rip),%r13
jmp 11c3 <func0+0x3a>
mov %bpl,(%r12)
lea 0x1(%r12),%r12
add $0x1,%rbx
movzbl (%rbx),%ebp
test %bpl,%bpl
je... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
movzx ebp, byte ptr [rdi]
test bpl, bpl
jz short loc_11F6
mov r12, rdi
lea r13, s; "AEIOUaeiou"
jmp short loc_11DA
loc_11CE:
add rbx, 1
movzx ebp, byte ptr [rbx]
test bpl, bpl
jz short loc_... | void func0(_BYTE *a1)
{
_BYTE *v1; // rbx
char v2; // bp
_BYTE *v3; // r12
v1 = a1;
v2 = *a1;
if ( *a1 )
{
v3 = a1;
do
{
if ( !strchr("AEIOUaeiou", v2) )
*v3++ = v2;
v2 = *++v1;
}
while ( *v1 );
}
else
{
v3 = a1;
}
*v3 = 0;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOVZX EBP,byte ptr [RDI]
TEST BPL,BPL
JZ 0x001011f6
MOV R12,RDI
LEA R13,[0x102004]
JMP 0x001011da
LAB_001011ce:
ADD RBX,0x1
MOVZX EBP,byte ptr [RBX]
TEST BPL,BPL
JZ 0x001011f9
LAB_001011da:
MOVSX ESI,BPL
MOV RDI,R13
CALL 0x00101090
TEST RAX,RAX
... | void func0(char *param_1)
{
char cVar1;
char *pcVar2;
char *pcVar3;
cVar1 = *param_1;
pcVar3 = param_1;
while (cVar1 != '\0') {
pcVar2 = strchr("AEIOUaeiou",(int)cVar1);
if (pcVar2 == (char *)0x0) {
*pcVar3 = cVar1;
pcVar3 = pcVar3 + 1;
}
param_1 = param_1 + 1;
cVar1 = *p... |
862 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
asser... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1468 <func0+0x58>
mov %rdi,%rbp
lea 0xbd2(%rip),%r13
jmp 1444 <func0+0x34>
nopl 0x0(%rax)
movzbl 0x1(%rbp),%ebx
add $0x1,%rbp
test %bl,%bl
je 1468 <func0+0x58>
mo... | func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_1468
mov rbp, rdi
lea r13, s; "AEIOUaeiou"
jmp short loc_1444
loc_1438:
movzx ebx, byte ptr [rbp+1]
add rbp, 1
test bl, bl
jz short loc_14... | void func0(_BYTE *a1)
{
_BYTE *v1; // r12
char v2; // bl
char *v3; // rbp
v1 = a1;
v2 = *a1;
if ( *a1 )
{
v3 = a1;
do
{
while ( strchr("AEIOUaeiou", v2) )
{
v2 = *++v3;
if ( !v2 )
goto LABEL_6;
}
++v3;
*v1++ = v2;
v2 = *v3;
}
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101468
MOV RBP,RDI
LEA R13,[0x102004]
JMP 0x00101444
LAB_00101438:
MOVZX EBX,byte ptr [RBP + 0x1]
ADD RBP,0x1
TEST BL,BL
JZ 0x00101468
LAB_00101444:
MOVSX ESI,BL
MOV RDI,R13
CALL 0x00101090
TEST RAX,RAX... | void func0(char *param_1)
{
char *pcVar1;
char cVar2;
char *pcVar3;
cVar2 = *param_1;
pcVar3 = param_1;
while (cVar2 != '\0') {
while (pcVar1 = strchr("AEIOUaeiou",(int)cVar2), pcVar1 == (char *)0x0) {
param_1 = param_1 + 1;
*pcVar3 = cVar2;
pcVar3 = pcVar3 + 1;
cVar2 = *para... |
863 | func0 | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
| void func0(char *text) {
const char *vowels = "AEIOUaeiou";
char *out = text;
while (*text != '\0') {
if (strchr(vowels, *text) == NULL) {
*out++ = *text;
}
text++;
}
*out = '\0';
} | #include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
char test1[] = "";
func0(test1);
assert(strcmp(test1, "") == 0);
char test2[] = "abcdef\nghijklm";
func0(test2);
assert(strcmp(test2, "bcdf\nghjklm") == 0);
char test3[] = "fedcba";
func0(test3);
asser... | O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
movzbl (%rdi),%ebp
test %bpl,%bpl
je 1456 <func0+0x46>
lea 0xbd1(%rip),%r13
nopl 0x0(%rax,%rax,1)
movsbl %bpl,%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 1470 <func0+0x... | func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
movzx ebp, byte ptr [rdi]
test bpl, bpl
jz short loc_1456
lea r13, s; "AEIOUaeiou"
nop dword ptr [rax+rax+00h]
loc_1438:
movsx esi, bpl; c
mov rdi, r13; s
call _strchr
test rax, ... | void func0(_BYTE *a1)
{
_BYTE *v1; // r12
char *v2; // rbx
char v3; // bp
v1 = a1;
v2 = a1;
v3 = *a1;
if ( *a1 )
{
do
{
while ( strchr("AEIOUaeiou", v3) )
{
v3 = *++v2;
if ( !v3 )
goto LABEL_4;
}
++v2;
*v1 = v3;
v3 = *v2;
++v1... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOVZX EBP,byte ptr [RDI]
TEST BPL,BPL
JZ 0x00101456
LEA R13,[0x102004]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101438:
MOVSX ESI,BPL
MOV RDI,R13
CALL 0x00101090
TEST RAX,RAX
JZ 0x00101470
MOVZX EBP,byte ptr [RBX + 0x1]
ADD RBX,0x1
TEST B... | void func0(char *param_1)
{
char *pcVar1;
char cVar2;
char *pcVar3;
cVar2 = *param_1;
pcVar3 = param_1;
do {
if (cVar2 == '\0') {
*pcVar3 = '\0';
return;
}
while (pcVar1 = strchr("AEIOUaeiou",(int)cVar2), pcVar1 == (char *)0x0) {
param_1 = param_1 + 1;
*pcVar3 = cVar2... |
864 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
} | #include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11aa <func0+0x41>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jg 11a6 <func0+... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_4], 0
jmp short loc_11AA
loc_1184:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax... | long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( a3 <= *(_DWORD *)(4LL * i + a1) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011aa
LAB_00101184:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dw... | int8 func0(long param_1,int param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (param_3 <= *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
865 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
} | #include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rcx
cmp %edx,(%rax)
jge 1195 <func0+0x2c>
add $0x4,%rax
cmp %rcx,%rax
jne 117c <func0+0x13>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_118E
mov rax, rdi
movsxd rsi, esi
lea rcx, [rdi+rsi*4]
loc_117B:
cmp [rax], edx
jge short loc_1194
add rax, 4
cmp rax, rcx
jnz short loc_117B
mov eax, 1
retn
loc_118E:
mov eax, 1
retn
loc_1194:
mov eax, 0
retn | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = a1;
while ( *v3 < a3 )
{
if ( ++v3 == &a1[a2] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118e
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RCX,[RDI + RSI*0x4]
LAB_0010117b:
CMP dword ptr [RAX],EDX
JGE 0x00101194
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010117b
MOV EAX,0x1
RET
LAB_0010118e:
MOV EAX,0x1
RET
LAB_00101194:
MOV EAX,0x0
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (param_2 < 1) {
return 1;
}
piVar1 = param_1 + param_2;
do {
if (param_3 <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 1;
} |
866 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
} | #include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
cmp %edx,(%rdi)
jl 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_1370
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1361
loc_1358:
add rdi, 4
cmp rdi, rax
jz short loc_1370
loc_1361:
cmp [rdi], edx
jl short loc_1358
xor eax, eax
retn
loc_1370:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = &a1[a2];
while ( *a1 < a3 )
{
if ( ++a1 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101370
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101361
LAB_00101358:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101370
LAB_00101361:
CMP dword ptr [RDI],EDX
JL 0x00101358
XOR EAX,EAX
RET
LAB_00101370:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (param_3 <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
} |
867 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int *l, int size, int t) {
for (int i = 0; i < size; i++)
if (l[i] >= t) return false;
return true;
} | #include <assert.h>
int main() {
int list1[] = {1, 2, 4, 10};
assert(func0(list1, 4, 100));
int list2[] = {1, 20, 4, 10};
assert(!func0(list2, 4, 5));
int list3[] = {1, 20, 4, 10};
assert(func0(list3, 4, 21));
int list4[] = {1, 20, 4, 10};
assert(func0(list4, 4, 22));
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
cmp %edx,(%rdi)
jl 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
cmp [rdi], edx
jl short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = &a1[a2];
while ( *a1 < a3 )
{
if ( ++a1 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
CMP dword ptr [RDI],EDX
JL 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (param_3 <= *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
} |
868 | func0 | #include <stdio.h>
| int func0(int x, int y) {
return x + y;
} | #include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
asser... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
POP RBP
RET | int func0(int param_1,int param_2)
{
return param_2 + param_1;
} |
869 | func0 | #include <stdio.h>
| int func0(int x, int y) {
return x + y;
} | #include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
asser... | O1 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
retq
| func0:
endbr64
lea eax, [rdi+rsi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET | int func0(int param_1,int param_2)
{
return param_1 + param_2;
} |
870 | func0 | #include <stdio.h>
| int func0(int x, int y) {
return x + y;
} | #include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
asser... | O2 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rsi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET | int func0(int param_1,int param_2)
{
return param_1 + param_2;
} |
871 | func0 | #include <stdio.h>
| int func0(int x, int y) {
return x + y;
} | #include <assert.h>
#include <stdlib.h>
int main() {
assert(func0(0, 1) == 1);
assert(func0(1, 0) == 1);
assert(func0(2, 3) == 5);
assert(func0(5, 7) == 12);
assert(func0(7, 5) == 12);
for (int i = 0; i < 100; i += 1) {
int x = rand() % 1000;
int y = rand() % 1000;
asser... | O3 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rsi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET | int func0(int param_1,int param_2)
{
return param_1 + param_2;
} |
872 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
... | 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 1060 <strlen@plt>
mov %eax,-0x8(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x18(%rbp)
jmp 1... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov rax, [rbp+var_30]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_18], 0
jmp short loc_1... | long long func0(const char *a1, const char *a2)
{
char v3; // [rsp+16h] [rbp-1Ah]
char v4; // [rsp+17h] [rbp-19h]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int k; // [rsp+20h] [rbp-10h]
int m; // [rsp+24h] [rbp-Ch]
int v9; // [rsp+28h] [rbp-8h]
int v10; // [rsp+2Ch] [rbp-4h]
v9 = s... | 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 0x00101060
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x1... | int8 func0(char *param_1,char *param_2)
{
bool bVar1;
size_t sVar2;
size_t sVar3;
int local_20;
int local_1c;
int local_18;
int local_14;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
for (local_20 = 0; local_20 < (int)sVar2; local_20 = local_20 + 1) {
bVar1 = false;
for (local_1c = ... |
873 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
... | O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%r8
mov $0xffffffffffffffff,%rdx
mov $0x0,%eax
mov %rdx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r11
mov %r11d,%r10d
mov %rdx,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%r9
test %... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
call _strlen
mov r13, rax
mov r12d, eax
mov rdi, rbx; s
call _strlen
mov r10, rax
test r13d, r13d
jle short loc_11EA
mov r8d, eax
mov rdi, rbp
lea eax, [r13-1]
lea ... | long long func0(const char *a1, const char *a2)
{
const char *v2; // rbp
int v4; // r13d
int v5; // eax
int v6; // r10d
long long v7; // rsi
const char *v8; // rdx
long long result; // rax
const char *v10; // rsi
const char *v11; // rax
v2 = a1;
v4 = strlen(a1);
v5 = strlen(a2);
v6 = v5;
i... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
CALL 0x00101060
MOV R13,RAX
MOV R12D,EAX
MOV RDI,RBX
CALL 0x00101060
MOV R10,RAX
TEST R13D,R13D
JLE 0x001011ea
MOV R8D,EAX
MOV RDI,RBP
LEA EAX,[R13 + -0x1]
LEA R9,[RBP + RAX*0x1 + 0x1]
LEA EAX,[R10 + -0x1]
LEA RSI,[RBX + RAX*0x1 + 0x... | int8 func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
sVar2 = strlen(param_2);
iVar5 = (int)sVar2;
if (iVar1 < 1) {
if (iVar5 < 1) {
return 1;
}
}
else {
pcVar4 = param_1;
d... |
874 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
... | O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
mov %rax,%r12
callq 1060 <strlen@plt>
test %r12d,%r12d
jle 13c7 <func0+0xb7>
lea -0x1(%r12),%r9d
mov %eax,%esi
lea 0x1(%rbp),%rdi
sub $0x1,%eax
mov %r9,%r12
mov %rbp,... | func0:
endbr64
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
call _strlen
mov rdi, rbx; s
mov r12, rax
call _strlen
mov rdx, rax
test r12d, r12d
jle loc_13D7
lea eax, [r12-1]
mov rsi, rbp
lea rdi, [rbp+rax+1]
test edx, edx
jle loc_13D0
lea ecx, [rd... | long long func0(const char *a1, const char *a2)
{
int v3; // r12d
int v4; // edx
const char *v5; // rsi
const char *v6; // r8
long long v7; // r9
const char *v8; // rax
const char *v9; // rsi
const char *v10; // rax
long long result; // rax
v3 = strlen(a1);
v4 = strlen(a2);
if ( v3 <= 0 )
{
... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
CALL 0x00101060
MOV RDI,RBX
MOV R12,RAX
CALL 0x00101060
MOV RDX,RAX
TEST R12D,R12D
JLE 0x001013d7
LEA EAX,[R12 + -0x1]
MOV RSI,RBP
LEA RDI,[RBP + RAX*0x1 + 0x1]
TEST EDX,EDX
JLE 0x001013d0
LEA ECX,[RDX + -0x1]
LEA R8,[RBX + 0x1]
MOV R9,RCX
ADD RCX,R8
NOP... | int8 func0(char *param_1,char *param_2)
{
size_t sVar1;
size_t sVar2;
char *pcVar3;
ulong uVar4;
int iVar5;
char *pcVar6;
int iVar7;
sVar1 = strlen(param_1);
sVar2 = strlen(param_2);
iVar7 = (int)sVar1;
iVar5 = (int)sVar2;
if (iVar7 < 1) {
if (iVar5 < 1) {
return 1;
}
uVar4... |
875 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char *s0, const char *s1) {
int len0 = strlen(s0), len1 = strlen(s1);
for (int i = 0; i < len0; i++) {
bool found = false;
for (int j = 0; j < len1; j++) {
if (s0[i] == s1[j]) {
found = true;
break;
}
}
if (... | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert(func0("abcd", "dddddddabc") == true);
assert(func0("dddddddabc", "abcd") == true);
assert(func0("eabcd", "dddddddabc") == false);
assert(func0("abcd", "dddddddabce") == false);
... | O3 | c | func0:
endbr64
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
push %rbx
callq 1060 <strlen@plt>
mov %r12,%rdi
mov %rax,%rbx
callq 1060 <strlen@plt>
test %ebx,%ebx
jle 13c7 <func0+0xb7>
lea -0x1(%rbx),%esi
mov %eax,%r8d
lea 0x1(%rbp),%r9
sub $0x1,%eax
mov %rsi,%rbx
mov %rbp,%r... | func0:
endbr64
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
call _strlen
mov rdi, rbx; s
mov r12, rax
call _strlen
mov rdx, rax
test r12d, r12d
jle loc_13D7
lea eax, [r12-1]
mov rsi, rbp
lea rdi, [rbp+rax+1]
test edx, edx
jle loc_13D0
lea ecx, [rd... | long long func0(const char *a1, const char *a2)
{
int v3; // r12d
int v4; // edx
const char *v5; // rsi
const char *v6; // r8
long long v7; // r9
const char *v8; // rax
const char *v9; // rsi
const char *v10; // rax
long long result; // rax
v3 = strlen(a1);
v4 = strlen(a2);
if ( v3 <= 0 )
{
... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
CALL 0x00101060
MOV RDI,RBX
MOV R12,RAX
CALL 0x00101060
MOV RDX,RAX
TEST R12D,R12D
JLE 0x001013d7
LEA EAX,[R12 + -0x1]
MOV RSI,RBP
LEA RDI,[RBP + RAX*0x1 + 0x1]
TEST EDX,EDX
JLE 0x001013d0
LEA ECX,[RDX + -0x1]
LEA R8,[RBX + 0x1]
MOV R9,RCX
ADD RCX,R8
NOP... | int8 func0(char *param_1,char *param_2)
{
size_t sVar1;
size_t sVar2;
char *pcVar3;
ulong uVar4;
int iVar5;
char *pcVar6;
int iVar7;
sVar1 = strlen(param_1);
sVar2 = strlen(param_2);
iVar7 = (int)sVar1;
iVar5 = (int)sVar2;
if (iVar7 < 1) {
if (iVar5 < 1) {
return 1;
}
uVar4... |
876 | func0 | #include <stdio.h>
| int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
} | #include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xfd0,%rsp
mov %edi,-0xfc4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0xfb0(%rbp),%rdx
mov $0x0,%eax
mov $0x1f4,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0xfb0(%rbp)
movl $0x1,-0xfac(%rbp)
movl $0x2,-0xfb4... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0FD0h
mov [rbp+var_FC4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_FB0]
mov eax, 0
mov ecx, 1F4h
mov rdi, rdx
rep stosq
mov [rbp+var_FB0], 0
mov [rbp+var_FAC], 1
mov [rbp+var_FB4], 2
jmp ... | long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-FB4h]
_DWORD v3[1002]; // [rsp+20h] [rbp-FB0h] BYREF
unsigned long long v4; // [rsp+FC8h] [rbp-8h]
v4 = __readfsqword(0x28u);
memset(v3, 0, 0xFA0uLL);
v3[0] = 0;
v3[1] = 1;
for ( i = 2; i <= a1; ++i )
v3[i] = v3[i - 2] + v3[i - 1];
return (unsig... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xfd0
MOV dword ptr [RBP + -0xfc4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0xfb0]
MOV EAX,0x0
MOV ECX,0x1f4
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0xfb0],0x0
MOV dword ptr [RBP + -0xfac],0x1
MOV dword ptr [RBP + -0xf... | int func0(int param_1)
{
long lVar1;
int *piVar2;
long in_FS_OFFSET;
int local_fbc;
int local_fb8 [1002];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = local_fb8;
for (lVar1 = 500; lVar1 != 0; lVar1 = lVar1 + -1) {
piVar2[0] = 0;
piVar2[1] = 0;
piVar2 = piVar2 + 2;... |
877 | func0 | #include <stdio.h>
| int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
} | #include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
} | O1 | c | func0:
endbr64
sub $0xfb8,%rsp
mov %edi,%esi
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1f4,%ecx
rep stos %rax,%es:(%rdi)
movl $0x1,0x4(%rsp)
cmp $0x1,%esi
jle 11bd <func0+0x54>
mov %rsp,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov (%rax)... | func0:
endbr64
sub rsp, 0FB8h
mov esi, edi
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 1F4h
rep stosq
mov [rsp+0FB8h+var_FB4], 1
cmp esi, 1
jle short loc_11BD
mov rax, rsp
lea edx, [rsi-2]
lea rcx, [rsp+rdx*4+0FB8h+var_FB4]
loc_11AC:... | long long func0(int a1)
{
_DWORD *v1; // rax
_DWORD v3[1002]; // [rsp+0h] [rbp-FB8h] BYREF
unsigned long long v4; // [rsp+FA8h] [rbp-10h]
v4 = __readfsqword(0x28u);
memset(v3, 0, 0xFA0uLL);
v3[1] = 1;
if ( a1 > 1 )
{
v1 = v3;
do
{
v1[2] = v1[1] + *v1;
++v1;
}
while ( v1... | func0:
ENDBR64
SUB RSP,0xfb8
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x1f4
STOSQ.REP RDI
MOV dword ptr [RSP + 0x4],0x1
CMP ESI,0x1
JLE 0x001011bd
MOV RAX,RSP
LEA EDX,[RSI + -0x2]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011ac:
MOV EDX,dword ptr [RAX]
ADD EDX,d... | int func0(int param_1)
{
int *piVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
int local_fb8 [1002];
long local_10;
piVar1 = local_fb8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_fb8;
for (lVar2 = 500; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar3 = 0;
piVar3 = (int... |
878 | func0 | #include <stdio.h>
| int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
} | #include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
} | O2 | c | func0:
endbr64
sub $0xfb8,%rsp
movslq %edi,%r8
mov $0x1f4,%ecx
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movabs $0x100000000,%rax
mov %rax,(%rsp)
cmp $0x1,%r8d
jle 12d8 <func0+0x68>
lea -0x2(%r8),%edx
lea 0x8(%rsp),%rax
lea (%rax,%rdx... | func0:
endbr64
sub rsp, 0FB8h
movsxd r8, edi
mov ecx, 1F4h
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov [rsp+0FB8h+var_FB4], 1
cmp r8d, 1
jle short loc_12D2
lea eax, [r8-2]
lea rdx, [rsp+0FB8h+var_FB0]
lea rdi, [rsp+rax*4+0FB8h+var_... | long long func0(int a1)
{
int v1; // ecx
_DWORD *v2; // rdx
int v3; // eax
int v4; // esi
_DWORD v6[1002]; // [rsp+0h] [rbp-FB8h] BYREF
unsigned long long v7; // [rsp+FA8h] [rbp-10h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 0xFA0uLL);
v1 = 0;
v6[1] = 1;
if ( a1 > 1 )
{
v2 = &v6[2];
v3 ... | func0:
ENDBR64
SUB RSP,0xfb8
MOVSXD R8,EDI
MOV ECX,0x1f4
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RSP + 0x4],0x1
CMP R8D,0x1
JLE 0x001012d2
LEA EAX,[R8 + -0x2]
LEA RDX,[RSP + 0x8]
LEA RDI,[RSP + RAX*0x4 + 0xc]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00... | int4 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
int *piVar5;
int *piVar6;
int8 *puVar7;
long in_FS_OFFSET;
int8 uStack_fb8;
int local_fb0 [1000];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
puVar7 = &uStack_fb8;
for (lVar4 = 500; lVar4 != 0; lVar4 = l... |
879 | func0 | #include <stdio.h>
| int func0(int n) {
int f[1000] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
return f[n];
} | #include <assert.h>
int main() {
assert(func0(10) == 55);
assert(func0(1) == 1);
assert(func0(8) == 21);
assert(func0(11) == 89);
assert(func0(12) == 144);
return 0;
} | O3 | c | func0:
endbr64
sub $0xfb8,%rsp
movslq %edi,%rsi
mov $0x1f4,%ecx
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
mov %rsp,%r9
mov %r9,%rdi
rep stos %rax,%es:(%rdi)
movabs $0x100000000,%rax
mov %rax,(%rsp)
cmp $0x1,%esi
jle 1304 <func0+0x94>
cmp $0x3,%esi
jle 1322 <func0+0xb2>
lea... | func0:
endbr64
sub rsp, 0FB8h
movsxd rsi, edi
mov ecx, 1F4h
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov r8, rsp
mov rdi, r8
rep stosq
mov [rsp+0FB8h+var_FB4], 1
cmp esi, 1
jle short loc_1304
cmp esi, 3
jle short loc_1322
lea ecx, [rsi-4]
lea rdi,... | long long func0(int a1)
{
long long v1; // rsi
int v2; // eax
_DWORD *v3; // rdi
int v4; // edx
int v5; // r9d
int v6; // ecx
_DWORD *v7; // rax
int v8; // edx
_DWORD v10[1002]; // [rsp+0h] [rbp-FB8h] BYREF
unsigned long long v11; // [rsp+FA8h] [rbp-10h]
v1 = a1;
v11 = __readfsqword(0x28u);
... | func0:
ENDBR64
SUB RSP,0xfb8
MOVSXD RSI,EDI
MOV ECX,0x1f4
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV R8,RSP
MOV RDI,R8
STOSQ.REP RDI
MOV dword ptr [RSP + 0x4],0x1
CMP ESI,0x1
JLE 0x00101304
CMP ESI,0x3
JLE 0x00101322
LEA ECX,[RSI + -0x4]
LEA RDI,[RSP + 0x8]
MOV EDX,0x1
MOV R9D,0x2
AND E... | int func0(int param_1)
{
int iVar1;
int *piVar2;
int iVar3;
long lVar4;
int iVar5;
int iVar6;
long in_FS_OFFSET;
int local_fb8 [1002];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = 0;
piVar2 = local_fb8;
for (lVar4 = 500; lVar4 != 0; lVar4 = lVar4 + -1) {
*(int8 *)p... |
880 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
asser... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a6 <func0+0x5d>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x3c,%al
jne 117d <func0+0x34>
addl $0x1,-0x8(%rbp)
mov -0x4(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A6
loc_1165:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 3Ch ; '<'
jnz short loc_117D
add [rbp+... | _BOOL8 func0(long long a1)
{
int v2; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v2 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(_BYTE *)(i + a1) == 60 )
++v2;
if ( *(_BYTE *)(i + a1) == 62 )
--v2;
if ( v2 < 0 )
return 0LL;
}
return v2 == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a6
LAB_00101165:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x3c
JNZ 0x0010117d
ADD dword ptr [RBP ... | bool func0(long param_1)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while( true ) {
if (*(char *)(param_1 + local_c) == '\0') {
return local_10 == 0;
}
if (*(char *)(param_1 + local_c) == '<') {
local_10 = local_10 + 1;
}
if (*(char *)(param_1 + local_c) == '>'... |
881 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
asser... | O1 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 1182 <func0+0x39>
add $0x1,%rdi
mov $0x0,%edx
jmp 1179 <func0+0x30>
cmp $0x3e,%al
sete %al
movzbl %al,%eax
sub %eax,%edx
test %edx,%edx
js 118d <func0+0x44>
add $0x1,%rdi
movzbl -0x1(%rdi),%eax
test %al,%al
je 1187 <func0+0x3e>
cmp ... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_1181
add rdi, 1
mov edx, 0
jmp short loc_116E
loc_115F:
add edx, 1
loc_1162:
add rdi, 1
movzx eax, byte ptr [rdi-1]
test al, al
jz short loc_1186
loc_116E:
cmp al, 3Ch ; '<'
jz short loc_115F
cmp al, 3... | bool func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // edx
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
v3 = 0;
while ( 1 )
{
if ( v1 == 60 )
{
++v3;
}
else if ( v1 == 62 && --v3 < 0 )
{
return 0;
}
v1 = *v2++;
if ( !v1 )
... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101181
ADD RDI,0x1
MOV EDX,0x0
JMP 0x0010116e
LAB_0010115f:
ADD EDX,0x1
LAB_00101162:
ADD RDI,0x1
MOVZX EAX,byte ptr [RDI + -0x1]
TEST AL,AL
JZ 0x00101186
LAB_0010116e:
CMP AL,0x3c
JZ 0x0010115f
CMP AL,0x3e
JNZ 0x00101162
SUB EDX,0x1
JNS 0x00101162
MOV EAX,0x0
R... | bool func0(char *param_1)
{
char cVar1;
int iVar2;
char *pcVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar2 = 0;
}
else {
iVar2 = 0;
pcVar3 = param_1 + 1;
do {
if (cVar1 == '<') {
iVar2 = iVar2 + 1;
}
else if (cVar1 == '>') {
iVar2 = iVar2 + -1;
... |
882 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
asser... | O2 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 14f3 <func0+0x53>
add $0x1,%rdi
xor %edx,%edx
jmp 14cf <func0+0x2f>
nopl 0x0(%rax,%rax,1)
cmp $0x3e,%al
jne 14c4 <func0+0x24>
sub $0x1,%edx
cmp $0xffffffff,%edx
je 14f0 <func0+0x50>
movzbl (%rdi),%eax
add $0x1,%rdi
test %al,%al
je ... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_140B
add rdi, 1
xor edx, edx
jmp short loc_13EC
loc_13D8:
cmp al, 3Eh ; '>'
jnz short loc_13E1
sub edx, 1
jb short loc_1408
loc_13E1:
movzx eax, byte ptr [rdi]
add rdi, 1
test al, al
jz short loc_13FE
... | char func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // edx
v1 = *a1;
if ( !*a1 )
return 1;
v2 = a1 + 1;
v3 = 0;
while ( 1 )
{
while ( v1 == 60 )
{
v1 = *v2++;
++v3;
if ( !v1 )
return v3 == 0;
}
if ( v1 == 62 && v3-- == 0 )
break;
v1 ... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x0010140b
ADD RDI,0x1
XOR EDX,EDX
JMP 0x001013ec
LAB_001013d8:
CMP AL,0x3e
JNZ 0x001013e1
SUB EDX,0x1
JC 0x00101408
LAB_001013e1:
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
TEST AL,AL
JZ 0x001013fe
LAB_001013ec:
CMP AL,0x3c
JNZ 0x001013d8
MOVZX EAX,byte ptr [RDI]
ADD RDI... | bool func0(char *param_1)
{
char cVar1;
int iVar2;
bool bVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
return true;
}
param_1 = param_1 + 1;
iVar2 = 0;
do {
while (cVar1 == '<') {
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar2 = iVar2 + 1;
if (cVar1 == '\0') goto LAB... |
883 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
int i = 0;
while (brackets[i]) {
if (brackets[i] == '<') level++;
if (brackets[i] == '>') level--;
if (level < 0) return false;
i++;
}
if (level != 0) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("<>"));
assert(func0("<<><>>"));
assert(func0("<><><<><>><>"));
assert(func0("<><><<<><><>><>><<><><<>>>"));
assert(!func0("<<<><>>>>"));
assert(!func0("><<>"));
assert(!func0("<"));
assert(!func0("<<<<"));
assert(!func0(">"));
asser... | O3 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 14f3 <func0+0x53>
add $0x1,%rdi
xor %edx,%edx
jmp 14cf <func0+0x2f>
nopl 0x0(%rax,%rax,1)
cmp $0x3e,%al
jne 14c4 <func0+0x24>
sub $0x1,%edx
cmp $0xffffffff,%edx
je 14f0 <func0+0x50>
movzbl (%rdi),%eax
add $0x1,%rdi
test %al,%al
je ... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_153B
add rdi, 1
xor edx, edx
jmp short loc_151C
loc_1508:
cmp al, 3Eh ; '>'
jnz short loc_1511
sub edx, 1
jb short loc_1538
loc_1511:
movzx eax, byte ptr [rdi]
add rdi, 1
test al, al
jz short loc_152E
... | char func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // edx
v1 = *a1;
if ( !*a1 )
return 1;
v2 = a1 + 1;
v3 = 0;
while ( 1 )
{
while ( v1 == 60 )
{
v1 = *v2++;
++v3;
if ( !v1 )
return v3 == 0;
}
if ( v1 == 62 && v3-- == 0 )
break;
v1 ... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x0010153b
ADD RDI,0x1
XOR EDX,EDX
JMP 0x0010151c
LAB_00101508:
CMP AL,0x3e
JNZ 0x00101511
SUB EDX,0x1
JC 0x00101538
LAB_00101511:
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
TEST AL,AL
JZ 0x0010152e
LAB_0010151c:
CMP AL,0x3c
JNZ 0x00101508
MOVZX EAX,byte ptr [RDI]
ADD RDI... | bool func0(char *param_1)
{
char cVar1;
int iVar2;
bool bVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
return true;
}
param_1 = param_1 + 1;
iVar2 = 0;
do {
while (cVar1 == '<') {
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar2 = iVar2 + 1;
if (cVar1 == '\0') goto LAB... |
884 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
} | #include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
movl $0x1,-0x4(%rbp)
jmp 120a <func0+0xa1>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xm... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
mov [rbp+var_4], 1
jmp short loc_120A
loc_118E:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, r... | _BOOL8 func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = 0;
v3 = 0;
for ( i = 1; i < a2; ++i )
{
if ( *(float *)(4LL * i + a1) > *(float *)(4LL * i - 4 + a1) )
v3 = 1;
if ( *(float *)(4LL * i - 4 + a1) > *(float *)(4... | 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 EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010120a
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword... | bool func0(long param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_10 = 0;
local_14 = 0;
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (*(float *)(param_1 + (long)local_c * 4 + -4) < *(float *)(param_1 + (long)local_c * 4)) {
local_14 = 1;
}
if (*(... |
885 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
} | #include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11b3 <func0+0x4a>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdi
mov $0x0,%ecx
mov $0x0,%edx
mov $0x1,%esi
movss 0x4(%rax),%xmm0
movss (%rax),%xmm1
ucomiss %xmm1,%xmm0
cmova %esi,%edx
ucomiss %xmm0,%xmm1
cmova %esi,%ecx
add $0x4,%rax
cmp %r... | func0:
endbr64
cmp esi, 1
jle short loc_11AF
mov rax, rdi
lea edx, [rsi-2]
lea rsi, [rdi+rdx*4+4]
mov edx, 0
mov edi, 0
mov ecx, 1
jmp short loc_1199
loc_118E:
mov edi, ecx
loc_1190:
add rax, 4
cmp rax, rsi
jz short loc_11B9
loc_1199:
movss xmm0, dword ptr [rax+4]
... | bool func0(float *a1, int a2)
{
float *v2; // rax
long long v3; // rsi
int v4; // edx
int v5; // edi
float v6; // xmm0_4
if ( a2 <= 1 )
{
v4 = 0;
v5 = 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 2 + 1];
v4 = 0;
v5 = 0;
do
{
v6 = v2[1];
if ( v6 > *v2 )
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011af
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
MOV EDI,0x0
MOV ECX,0x1
JMP 0x00101199
LAB_0010118e:
MOV EDI,ECX
LAB_00101190:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x001011b9
LAB_00101199:
MOVSS XMM0,dword ptr [RAX + 0x4]
MOVSS XMM1,dword ptr [RAX]
COMISS XMM0,... | bool func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
int iVar3;
if (param_2 < 2) {
iVar2 = 0;
iVar3 = 0;
}
else {
pfVar1 = param_1 + (ulong)(param_2 - 2) + 1;
iVar2 = 0;
iVar3 = 0;
do {
if (*param_1 < param_1[1]) {
iVar3 = 1;
}
else if (par... |
886 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
} | #include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1300 <func0+0x50>
lea -0x2(%rsi),%eax
xor %edx,%edx
mov $0x1,%ecx
lea 0x4(%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
movss 0x4(%rdi),%xmm0
movss (%rdi),%xmm1
ucomiss %xmm1,%xmm0
cmova %ecx,%eax
ucomiss %xmm0,%xmm1
cmova %ecx,%edx
add $0x4,%rdi
cm... | func0:
endbr64
cmp esi, 1
jle short loc_1440
lea edx, [rsi-2]
movss xmm0, dword ptr [rdi]
lea rax, [rdi+4]
xor esi, esi
lea rcx, [rdi+rdx*4+8]
xor edx, edx
mov edi, 1
jmp short loc_1417
loc_1408:
ucomiss xmm1, xmm0
cmova edx, edi
add rax, 4
cmp rax, rcx
jz short loc_... | char func0(float *a1, int a2)
{
long long v2; // rdx
float v3; // xmm0_4
float *v4; // rax
int v5; // esi
long long v6; // rcx
int v7; // edx
float v8; // xmm1_4
if ( a2 <= 1 )
return 1;
v2 = (unsigned int)(a2 - 2);
v3 = *a1;
v4 = a1 + 1;
v5 = 0;
v6 = (long long)&a1[v2 + 2];
v7 = 0;
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101440
LEA EDX,[RSI + -0x2]
MOVSS XMM0,dword ptr [RDI]
LEA RAX,[RDI + 0x4]
XOR ESI,ESI
LEA RCX,[RDI + RDX*0x4 + 0x8]
XOR EDX,EDX
MOV EDI,0x1
JMP 0x00101417
LAB_00101408:
UCOMISS XMM1,XMM0
CMOVA EDX,EDI
ADD RAX,0x4
CMP RAX,RCX
JZ 0x00101431
LAB_00101417:
MOVAPS XMM1,XMM0
MOVSS XMM0,dwo... | int8 func0(float *param_1,int param_2)
{
float fVar1;
float *pfVar2;
float *pfVar3;
int iVar4;
int iVar5;
float fVar6;
if (param_2 < 2) {
return 1;
}
iVar5 = 0;
iVar4 = 0;
pfVar2 = param_1 + 1;
fVar6 = *param_1;
do {
while (pfVar3 = pfVar2, fVar1 = *pfVar3, fVar6 < fVar1) {
i... |
887 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(float *l, int size) {
int incr, decr;
incr = decr = 0;
for (int i = 1; i < size; i++) {
if (l[i] > l[i - 1]) incr = 1;
if (l[i] < l[i - 1]) decr = 1;
}
if (incr + decr == 2) return false;
return true;
} | #include <assert.h>
int main() {
float list1[] = {1, 2, 4, 10};
float list2[] = {1, 2, 4, 20};
float list3[] = {1, 20, 4, 10};
float list4[] = {4, 1, 0, -10};
float list5[] = {4, 1, 1, 0};
float list6[] = {1, 2, 3, 2, 5, 60};
float list7[] = {1, 2, 3, 4, 5, 60};
float list8[] = {9, 9, 9... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1320 <func0+0xa0>
cmp $0x3,%esi
jle 1326 <func0+0xa6>
lea -0x4(%rsi),%eax
movss (%rdi),%xmm0
mov $0x3,%r8d
xor %ecx,%ecx
shr %eax
xor %edx,%edx
mov $0x1,%r9d
lea 0x5(%rax,%rax,1),%r10
movss -0x8(%rdi,%r8,4),%xmm1
movslq %r8d,%rax
ucomiss %xmm0,%xmm1
cm... | func0:
endbr64
cmp esi, 1
jle loc_1620
lea eax, [rsi-2]
lea r11d, [rsi-1]
cmp eax, 2
jbe loc_1626
mov edx, r11d
pxor xmm3, xmm3
movdqa xmm5, cs:xmmword_2080
mov rax, rdi
shr edx, 2
movdqa xmm4, xmm3
shl rdx, 4
add rdx, rdi
nop dword ptr [rax]
loc_1340:
movups xmm6, ... | char func0(__m128 *a1, int a2)
{
int v2; // r11d
__m128i v3; // xmm3
__m128i si128; // xmm5
__m128 *v5; // rax
__m128i v6; // xmm4
__m128 v7; // xmm6
__m128 v8; // xmm0
__m128i v9; // xmm0
__m128i v10; // xmm1
__m128i v11; // xmm1
signed int v12; // ecx
__m128i v13; // xmm0
__m128i v14; // xm... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101620
LEA EAX,[RSI + -0x2]
LEA R11D,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101626
MOV EDX,R11D
PXOR XMM3,XMM3
MOVDQA XMM5,xmmword ptr [0x00102080]
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM4,XMM3
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101340:
MOVUPS XMM6,xmmword ptr [RAX + 0x4]
MOVUPS X... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(float *param_1,int param_2)
{
float fVar1;
uint uVar2;
float *pfVar3;
float *pfVar4;
int iVar5;
int iVar6;
uint uVar7;
long lVar8;
int iVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
... |
888 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
... | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %ecx,-0x30(%rbp)
mov %r8,-0x40(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x20(%rbp)
movl... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_30], ecx
mov [rbp+var_40], r8
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_20]... | _DWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v5; // eax
int v10; // [rsp+20h] [rbp-20h]
int i; // [rsp+24h] [rbp-1Ch]
int m; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+28h] [rbp-18h]
int n; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
int v16; // [rsp+30h] [rbp-10h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x30],ECX
MOV qword ptr [RBP + -0x40],R8
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV ... | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
int4 uVar1;
bool bVar2;
void *pvVar3;
int4 local_28;
int4 local_24;
int4 local_20;
int4 local_1c;
pvVar3 = malloc((long)param_2 << 2);
local_28 = 0;
local_24 = 0;
do {
if (param_2 <= local_24) {
for (local... |
889 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
... | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == ... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %esi,%r12d
mov %rdx,%r13
mov %ecx,%ebp
mov %r8,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 1286 <func0+0xdd>
mov %r14,%rdi
lea -0x1(%r12),%edx
lea 0x4(%r14,%... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r15, rdi
mov r14d, esi
mov r12, rdx
mov ebp, ecx
mov rbx, r8
movsxd r13, esi
shl r13, 2
mov rdi, r13; size
call _malloc
mov rdi, rax
test r14d, r14d
jle loc_1287
mov r... | _DWORD * func0(int *a1, int a2, _DWORD *a3, int a4, int *a5)
{
size_t v9; // r13
_DWORD *v10; // rdi
int *v11; // rsi
int *v12; // r13
int v13; // r9d
_DWORD *v14; // rax
int v15; // edx
_DWORD *v16; // rax
int i; // r8d
int *v18; // rax
int v19; // edx
int v20; // ecx
v9 = a2;
v10 = malloc... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R15,RDI
MOV R14D,ESI
MOV R12,RDX
MOV EBP,ECX
MOV RBX,R8
MOVSXD R13,ESI
SHL R13,0x2
MOV RDI,R13
CALL 0x001010b0
MOV RDI,RAX
TEST R14D,R14D
JLE 0x00101287
MOV RSI,R15
ADD R13,R15
MOVSXD RAX,EBP
LEA R8,[R12 + RAX*0x4]
MOV R9D,0x0
JMP 0x00... | int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
int iVar6;
piVar2 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar4 = param_1 + param_2;
iVar6 = 0;
do {
... |
890 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
... | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == ... | O2 | c | func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
mov %ecx,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %r8,%rbx
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 15b1 <func0+0x111>
lea -0x1(%r13),%edx
mov %r14,%r10
lea 0x4(%rax)... | func0:
endbr64
push r15
movsxd r10, esi
push r14
lea r14, ds:0[r10*4]
mov r15, r10
push r13
mov r13d, ecx
push r12
mov r12, rdx
push rbp
mov rbp, r8
push rbx
mov rbx, rdi
mov rdi, r14; size
sub rsp, 8
call _malloc
mov r8, rax
test r15d, r15d
jle loc_1580
... | __m128i * func0(__int32 *a1, int a2, _DWORD *a3, int a4, int *a5)
{
size_t v5; // r14
__m128i *v9; // r8
__int32 *v10; // rsi
__int32 *v11; // r10
int v12; // r9d
__m128i *v13; // rax
int i; // edi
__m128i *v15; // rax
__m128i v16; // xmm0
__int32 v18; // edx
_DWORD *v19; // rax
long long v20; /... | func0:
ENDBR64
PUSH R15
MOVSXD R10,ESI
PUSH R14
LEA R14,[R10*0x4]
MOV R15,R10
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,R8
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
SUB RSP,0x8
CALL 0x001010b0
MOV R8,RAX
TEST R15D,R15D
JLE 0x00101580
MOVSXD RAX,R13D
MOV RSI,RBX
LEA R10,[RBX + R14*0x1]
XOR R9D,R9D
LEA RDI,[R12 ... | int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int *piVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
piVar1 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar2 = param_1 + param_2;
... |
891 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *l1, int size1, int *l2, int size2, int *out_size) {
int *out = malloc(size1 * sizeof(int));
int k = 0, i, j, m;
for (i = 0; i < size1; i++) {
int exists_in_out = 0;
for (m = 0; m < k; m++) {
if (out[m] == l1[i]) {
exists_in_out = 1;
... | #include <assert.h>
#include <stdlib.h>
#include <string.h>
int main() {
int size;
int l1[] = {1, 4, 3, 34, 653, 2, 5};
int l2[] = {5, 7, 1, 5, 9, 653, 121};
int expected1[] = {1, 5, 653};
int *result1 = func0(l1, 7, l2, 7, &size);
for (int i = 0; i < size; i++) {
assert(result1[i] == ... | O3 | c | func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
mov %ecx,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %r8,%rbx
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 1541 <func0+0x111>
lea -0x1(%r13),%edx
mov %r14,%r10
lea 0x4(%rax)... | func0:
endbr64
push r15
movsxd r10, esi
push r14
lea r14, ds:0[r10*4]
mov r15, r10
push r13
mov r13d, ecx
push r12
mov r12, rdx
push rbp
mov rbp, r8
push rbx
mov rbx, rdi
mov rdi, r14; size
sub rsp, 8
call _malloc
mov r8, rax
test r15d, r15d
jle loc_1550
... | __m128i * func0(__int32 *a1, int a2, _DWORD *a3, int a4, int *a5)
{
size_t v5; // r14
__m128i *v9; // r8
__int32 *v10; // rsi
__int32 *v11; // r10
int v12; // r9d
__m128i *v13; // rax
int i; // edi
__m128i *v15; // rax
__m128i v16; // xmm0
__int32 v18; // edx
_DWORD *v19; // rax
long long v20; /... | func0:
ENDBR64
PUSH R15
MOVSXD R10,ESI
PUSH R14
LEA R14,[R10*0x4]
MOV R15,R10
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,R8
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
SUB RSP,0x8
CALL 0x001010b0
MOV R8,RAX
TEST R15D,R15D
JLE 0x00101550
MOVSXD RAX,R13D
MOV RSI,RBX
LEA R10,[RBX + R14*0x1]
XOR R9D,R9D
LEA RDI,[R12 ... | int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int *piVar1;
int *piVar2;
int *piVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
piVar1 = (int *)malloc((long)param_2 * 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar2 = param_1 + param_2;
... |
892 | func0 | #include <stdio.h>
| int func0(int n) {
for (int i = 2; i * i <= n; i++)
while (n % i == 0 && n > i) n = n / i;
return n;
} | #include <assert.h>
int main() {
assert(func0(15) == 5);
assert(func0(27) == 3);
assert(func0(63) == 7);
assert(func0(330) == 11);
assert(func0(13195) == 29);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x2,-0x4(%rbp)
jmp 1180 <func0+0x37>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 117c <func0+0x33>
mov -0x14(%rbp),%eax
cmp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 2
jmp short loc_1180
loc_115D:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov [rbp+var_14], eax
loc_1167:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_117C
m... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
for ( i = 2; a1 >= i * i; ++i )
{
while ( !(a1 % i) && a1 > i )
a1 /= i;
}
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101180
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST E... | int func0(int param_1)
{
int4 local_1c;
int4 local_c;
local_1c = param_1;
for (local_c = 2; local_c * local_c <= local_1c; local_c = local_c + 1) {
for (; (local_1c % local_c == 0 && (local_c < local_1c)); local_1c = local_1c / local_c) {
}
}
return local_1c;
} |
893 | func0 | #include <stdio.h>
| int func0(int n) {
for (int i = 2; i * i <= n; i++)
while (n % i == 0 && n > i) n = n / i;
return n;
} | #include <assert.h>
int main() {
assert(func0(15) == 5);
assert(func0(27) == 3);
assert(func0(63) == 7);
assert(func0(330) == 11);
assert(func0(13195) == 29);
return 0;
} | O1 | c | func0:
endbr64
mov $0x2,%ecx
cmp $0x3,%edi
jg 1166 <func0+0x1d>
mov %edi,%eax
retq
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 1157 <func0+0xe>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 115a <func0+0x11>
cmp %ecx,%edi
jle 115a <func0+0x11>
mov %edi,%e... | func0:
endbr64
mov ecx, 2
cmp edi, 3
jg short loc_1166
loc_1157:
mov eax, edi
retn
loc_115A:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_1157
loc_1166:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_115A
cmp edi, ecx
jle short loc_115... | long long func0(int a1)
{
int v1; // ecx
int v3; // esi
v1 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) && a1 > v1 )
{
do
{
v3 = a1 / v1;
a1 = v3;
}
while ( !(v3 % v1) && v3 > v1 );
}
++v1;
}
while ( v1 * v1 <= a1 );
... | func0:
ENDBR64
MOV ECX,0x2
CMP EDI,0x3
JG 0x00101166
LAB_00101157:
MOV EAX,EDI
RET
LAB_0010115a:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x00101157
LAB_00101166:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010115a
CMP EDI,ECX
JLE 0x0010115a
LAB_00101173:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
MOV EDI,EAX
CDQ... | int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
iVar2 = 2;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while ((iVar3 == 0 && (iVar2 < param_1))) {
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
iVar3 = (int)((long)((ulong)(uint)(param_1... |
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.