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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
894 | 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;
} | O2 | c | func0:
endbr64
mov %edi,%r8d
mov $0x2,%ecx
cmp $0x3,%edi
jle 136a <func0+0x4a>
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 1358 <func0+0x38>
jmp 135d <func0+0x3d>
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
cltd
mov %eax,%r8d
idiv %ecx
test %edx,%edx
jne 13... | func0:
endbr64
mov ecx, 2
cmp edi, 3
jle short loc_128E
xchg ax, ax
loc_1260:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_127E
jmp short loc_1282
loc_1270:
mov eax, edi
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jnz short loc_1282
loc_127E:
cmp ... | long long func0(int a1)
{
int v1; // ecx
int v2; // edx
v1 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) )
{
do
{
if ( a1 <= v1 )
break;
v2 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(__SPAIR64__(v2, a1) % v... | func0:
ENDBR64
MOV ECX,0x2
CMP EDI,0x3
JLE 0x0010128e
NOP
LAB_00101260:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x0010127e
JMP 0x00101282
LAB_00101270:
MOV EAX,EDI
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JNZ 0x00101282
LAB_0010127e:
CMP EDI,ECX
JG 0x00101270
LAB_00101282:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,EC... | 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... |
895 | 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;
} | O3 | c | func0:
endbr64
mov %edi,%r8d
mov $0x2,%ecx
cmp $0x3,%edi
jle 133a <func0+0x4a>
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 1328 <func0+0x38>
jmp 132d <func0+0x3d>
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
cltd
mov %eax,%r8d
idiv %ecx
test %edx,%edx
jne 13... | func0:
endbr64
mov ecx, 2
cmp edi, 3
jle short loc_13CE
xchg ax, ax
loc_13A0:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_13BE
jmp short loc_13C2
loc_13B0:
mov eax, edi
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jnz short loc_13C2
loc_13BE:
cmp ... | long long func0(int a1)
{
int v1; // ecx
int v2; // edx
v1 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) )
{
do
{
if ( a1 <= v1 )
break;
v2 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(__SPAIR64__(v2, a1) % v... | func0:
ENDBR64
MOV ECX,0x2
CMP EDI,0x3
JLE 0x001013ce
NOP
LAB_001013a0:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013be
JMP 0x001013c2
LAB_001013b0:
MOV EAX,EDI
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JNZ 0x001013c2
LAB_001013be:
CMP EDI,ECX
JG 0x001013b0
LAB_001013c2:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,EC... | 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... |
896 | func0 | #include <stdio.h>
| int func0(int n) {
return n * (n + 1) / 2;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(6) == 21);
assert(func0(11) == 66);
assert(func0(30) == 465);
assert(func0(100) == 5050);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
add $0x1,%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
add eax, 1
imul eax, [rbp+var_4]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
POP RBP
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
897 | func0 | #include <stdio.h>
| int func0(int n) {
return n * (n + 1) / 2;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(6) == 21);
assert(func0(11) == 66);
assert(func0(30) == 465);
assert(func0(100) == 5050);
return 0;
} | O1 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
| func0:
endbr64
lea edx, [rdi+1]
imul edx, edi
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
898 | func0 | #include <stdio.h>
| int func0(int n) {
return n * (n + 1) / 2;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(6) == 21);
assert(func0(11) == 66);
assert(func0(30) == 465);
assert(func0(100) == 5050);
return 0;
} | O2 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
lea edx, [rdi+1]
imul edx, edi
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
899 | func0 | #include <stdio.h>
| int func0(int n) {
return n * (n + 1) / 2;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(6) == 21);
assert(func0(11) == 66);
assert(func0(30) == 465);
assert(func0(100) == 5050);
return 0;
} | O3 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
lea edx, [rdi+1]
imul edx, edi
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
900 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
for (int i = 0; i < strlen(brackets); i++) {
if (brackets[i] == '(') level += 1;
if (brackets[i] == ')') level -= 1;
if (level < 0) return false;
}
return level == 0;
} | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("()"));
assert(func0("(()())"));
assert(func0("()()(()())()"));
assert(func0("()()((()()())())(()()(()))"));
assert(!func0("((()())))"));
assert(!func0(")(()"));
assert(!func0("("));
assert(!func0("(((("));
assert(!f... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11cb <func0+0x62>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x28,%al
jne 11a2 <func0+0x39>
addl ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_11CB
loc_118A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 28h ; '('
jnz short ... | bool func0(const char *a1)
{
int v2; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] == 40 )
++v2;
if ( a1[i] == 41 )
--v2;
if ( v2 < 0 )
return 0;
}
return v2 == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011cb
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x28
JNZ 0x001... | bool func0(char *param_1)
{
size_t sVar1;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= (ulong)(long)local_1c) {
return local_20 == 0;
}
if (param_1[local_1c] == '(') {
local_20 = local_20 + 1;
}
if (para... |
901 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
for (int i = 0; i < strlen(brackets); i++) {
if (brackets[i] == '(') level += 1;
if (brackets[i] == ')') level -= 1;
if (level < 0) return false;
}
return level == 0;
} | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("()"));
assert(func0("(()())"));
assert(func0("()()(()())()"));
assert(func0("()()((()()())())(()()(()))"));
assert(!func0("((()())))"));
assert(!func0(")(()"));
assert(!func0("("));
assert(!func0("(((("));
assert(!f... | O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rsi,%rdx
lea -0x1(%rsi,%rcx,1),%rsi
mov $0x0,%eax
jmp 1183 <func0+0x3a>
cmp $0x29,%cl
sete %cl
movzbl %cl,%ecx
sub %ecx,%eax
add $0x1,%rdx
test %eax,%eax
js 119b <func... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rax
mov rax, rbx
add rdi, rbx
mov ecx, 0
jmp short loc_118D
loc_1186:
add ecx, 1
loc_1189:
add rax, 1
loc_118D:
cmp rax, rdi
jz short loc_11AB
movzx edx, byte ptr [rax]
cmp dl, 28h ; '('
jz short loc_118... | bool func0(const char *a1)
{
size_t v2; // rdi
const char *v3; // rax
const char *v4; // rdi
int v5; // ecx
v2 = strlen(a1);
v3 = a1;
v4 = &a1[v2];
v5 = 0;
while ( v3 != v4 )
{
if ( *v3 == 40 )
{
++v5;
}
else if ( *v3 == 41 && --v5 < 0 )
{
return 0;
}
++v3;
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RAX
MOV RAX,RBX
ADD RDI,RBX
MOV ECX,0x0
JMP 0x0010118d
LAB_00101186:
ADD ECX,0x1
LAB_00101189:
ADD RAX,0x1
LAB_0010118d:
CMP RAX,RDI
JZ 0x001011ab
MOVZX EDX,byte ptr [RAX]
CMP DL,0x28
JZ 0x00101186
CMP DL,0x29
JNZ 0x00101189
SUB ECX,0x1
JNS 0x00101189
MOV EAX,... | bool func0(char *param_1)
{
size_t sVar1;
int iVar2;
char *pcVar3;
sVar1 = strlen(param_1);
pcVar3 = param_1 + sVar1;
iVar2 = 0;
do {
if (param_1 == pcVar3) {
return iVar2 == 0;
}
if (*param_1 == '(') {
iVar2 = iVar2 + 1;
}
else if ((*param_1 == ')') && (iVar2 = iVar2 +... |
902 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
for (int i = 0; i < strlen(brackets); i++) {
if (brackets[i] == '(') level += 1;
if (brackets[i] == ')') level -= 1;
if (level < 0) return false;
}
return level == 0;
} | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("()"));
assert(func0("(()())"));
assert(func0("()()(()())()"));
assert(func0("()()((()()())())(()()(()))"));
assert(!func0("((()())))"));
assert(!func0(")(()"));
assert(!func0("("));
assert(!func0("(((("));
assert(!f... | O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
add %rbx,%rax
jmp 1411 <func0+0x31>
nopw 0x0(%rax,%rax,1)
cmp $0x29,%dl
jne 140d <func0+0x2d>
sub $0x1,%ecx
cmp $0xffffffff,%ecx
je 1430 <func0+0x50>
add $0x1,%rdi
cmp %rax,%rdi
je 14... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
add rax, rbx
jmp short loc_140E
loc_1400:
cmp dl, 29h ; ')'
jnz short loc_140A
sub ecx, 1
jb short loc_1420
loc_140A:
add rdi, 1
loc_140E:
cmp rdi, rax
jz short loc_1428
movzx edx, byte ... | bool func0(const char *a1)
{
size_t v1; // rax
int v2; // ecx
const char *v3; // rax
v1 = strlen(a1);
v2 = 0;
v3 = &a1[v1];
while ( a1 != v3 )
{
if ( *a1 == 40 )
{
++v2;
}
else if ( *a1 == 41 && v2-- == 0 )
{
return 0;
}
++a1;
}
return v2 == 0;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RBX
XOR ECX,ECX
ADD RAX,RBX
JMP 0x0010140e
LAB_00101400:
CMP DL,0x29
JNZ 0x0010140a
SUB ECX,0x1
JC 0x00101420
LAB_0010140a:
ADD RDI,0x1
LAB_0010140e:
CMP RDI,RAX
JZ 0x00101428
MOVZX EDX,byte ptr [RDI]
CMP DL,0x28
JNZ 0x00101400
ADD ECX,0x1
JMP 0x0010140a
LAB_0... | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
bool bVar4;
sVar1 = strlen(param_1);
iVar3 = 0;
pcVar2 = param_1 + sVar1;
do {
if (param_1 == pcVar2) {
return CONCAT71((int7)((ulong)pcVar2 >> 8),iVar3 == 0);
}
if (*param_1 == '(') {
iVar3 = iVar3 + 1;
}... |
903 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char *brackets) {
int level = 0;
for (int i = 0; i < strlen(brackets); i++) {
if (brackets[i] == '(') level += 1;
if (brackets[i] == ')') level -= 1;
if (level < 0) return false;
}
return level == 0;
} | #include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("()"));
assert(func0("(()())"));
assert(func0("()()(()())()"));
assert(func0("()()((()()())())(()()(()))"));
assert(!func0("((()())))"));
assert(!func0(")(()"));
assert(!func0("("));
assert(!func0("(((("));
assert(!f... | O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
add %rbx,%rax
jmp 1411 <func0+0x31>
nopw 0x0(%rax,%rax,1)
cmp $0x29,%dl
jne 140d <func0+0x2d>
sub $0x1,%ecx
cmp $0xffffffff,%ecx
je 1430 <func0+0x50>
add $0x1,%rdi
cmp %rax,%rdi
je 14... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
add rax, rbx
jmp short loc_140E
loc_1400:
cmp dl, 29h ; ')'
jnz short loc_140A
sub ecx, 1
jb short loc_1420
loc_140A:
add rdi, 1
loc_140E:
cmp rdi, rax
jz short loc_1428
movzx edx, byte ... | bool func0(const char *a1)
{
size_t v1; // rax
int v2; // ecx
const char *v3; // rax
v1 = strlen(a1);
v2 = 0;
v3 = &a1[v1];
while ( a1 != v3 )
{
if ( *a1 == 40 )
{
++v2;
}
else if ( *a1 == 41 && v2-- == 0 )
{
return 0;
}
++a1;
}
return v2 == 0;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RBX
XOR ECX,ECX
ADD RAX,RBX
JMP 0x0010140e
LAB_00101400:
CMP DL,0x29
JNZ 0x0010140a
SUB ECX,0x1
JC 0x00101420
LAB_0010140a:
ADD RDI,0x1
LAB_0010140e:
CMP RDI,RAX
JZ 0x00101428
MOVZX EDX,byte ptr [RDI]
CMP DL,0x28
JNZ 0x00101400
ADD ECX,0x1
JMP 0x0010140a
LAB_0... | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
bool bVar4;
sVar1 = strlen(param_1);
iVar3 = 0;
pcVar2 = param_1 + sVar1;
do {
if (param_1 == pcVar2) {
return CONCAT71((int7)((ulong)pcVar2 >> 8),iVar3 == 0);
}
if (*param_1 == '(') {
iVar3 = iVar3 + 1;
}... |
904 | func0 | #include <stdio.h>
| void func0(const float *xs, int xs_size, float *out) {
for (int i = 1; i < xs_size; i++) {
out[i - 1] = i * xs[i];
}
} | #include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <string.h>
bool issame(const float *a, int a_size, const float *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return false;
}
return true;
}
int main() {
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11c2 <func0+0x59>
cvtsi2ssl -0x4(%rbp),%xmm1
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
mov -0x4(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_4], 1
jmp short loc_11C6
loc_1185:
pxor xmm1, xmm1
cvtsi2ss xmm1, [rbp+var_4]
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rd... | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
int i; // [rsp+24h] [rbp-4h]
for ( i = 1; ; ++i )
{
result = (unsigned int)i;
if ( i >= a2 )
break;
*(float *)(4LL * i - 4 + a3) = *(float *)(4LL * i + a1) * (float)i;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011c6
LAB_00101185:
PXOR XMM1,XMM1
CVTSI2SS XMM1,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP... | void func0(long param_1,int param_2,long param_3)
{
int4 local_c;
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
*(float *)(param_3 + (long)local_c * 4 + -4) =
*(float *)(param_1 + (long)local_c * 4) * (float)local_c;
}
return;
} |
905 | func0 | #include <stdio.h>
| void func0(const float *xs, int xs_size, float *out) {
for (int i = 1; i < xs_size; i++) {
out[i - 1] = i * xs[i];
}
} | #include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <string.h>
bool issame(const float *a, int a_size, const float *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return false;
}
return true;
}
int main() {
... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 119a <func0+0x31>
lea -0x2(%rsi),%ecx
add $0x2,%rcx
mov $0x1,%eax
pxor %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss (%rdi,%rax,4),%xmm0
movss %xmm0,-0x4(%rdx,%rax,4)
add $0x1,%rax
cmp %rcx,%rax
jne 117e <func0+0x15>
retq
| func0:
endbr64
cmp esi, 1
jle short locret_1195
mov esi, esi
mov eax, 1
loc_1179:
pxor xmm0, xmm0
cvtsi2ss xmm0, eax
mulss xmm0, dword ptr [rdi+rax*4]
movss dword ptr [rdx+rax*4-4], xmm0
add rax, 1
cmp rax, rsi
jnz short loc_1179
locret_1195:
retn | void func0(long long a1, int a2, long long a3)
{
long long i; // rax
if ( a2 > 1 )
{
for ( i = 1LL; i != a2; ++i )
*(float *)(a3 + 4 * i - 4) = (float)(int)i * *(float *)(a1 + 4 * i);
}
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101195
MOV ESI,ESI
MOV EAX,0x1
LAB_00101179:
PXOR XMM0,XMM0
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RDI + RAX*0x4]
MOVSS dword ptr [RDX + RAX*0x4 + -0x4],XMM0
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101179
LAB_00101195:
RET | void func0(long param_1,uint param_2,long param_3)
{
ulong uVar1;
if (1 < (int)param_2) {
uVar1 = 1;
do {
*(float *)(param_3 + -4 + uVar1 * 4) = (float)(int)uVar1 * *(float *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return;
} |
906 | func0 | #include <stdio.h>
| void func0(const float *xs, int xs_size, float *out) {
for (int i = 1; i < xs_size; i++) {
out[i - 1] = i * xs[i];
}
} | #include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <string.h>
bool issame(const float *a, int a_size, const float *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return false;
}
return true;
}
int main() {
... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 13b4 <func0+0x34>
lea -0x2(%rsi),%ecx
mov $0x1,%eax
add $0x2,%rcx
nopl (%rax)
pxor %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss (%rdi,%rax,4),%xmm0
movss %xmm0,-0x4(%rdx,%rax,4)
add $0x1,%rax
cmp %rax,%rcx
jne 1398 <func0+0x18>
retq
data16 nopw %cs:0x0(%rax,%rax,1... | func0:
endbr64
cmp esi, 1
jle short locret_144C
mov esi, esi
mov eax, 1
loc_1430:
pxor xmm0, xmm0
cvtsi2ss xmm0, eax
mulss xmm0, dword ptr [rdi+rax*4]
movss dword ptr [rdx+rax*4-4], xmm0
add rax, 1
cmp rsi, rax
jnz short loc_1430
locret_144C:
retn | void func0(long long a1, int a2, long long a3)
{
long long i; // rax
if ( a2 > 1 )
{
for ( i = 1LL; i != a2; ++i )
*(float *)(a3 + 4 * i - 4) = (float)(int)i * *(float *)(a1 + 4 * i);
}
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010144c
MOV ESI,ESI
MOV EAX,0x1
LAB_00101430:
PXOR XMM0,XMM0
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RDI + RAX*0x4]
MOVSS dword ptr [RDX + RAX*0x4 + -0x4],XMM0
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101430
LAB_0010144c:
RET | void func0(long param_1,uint param_2,long param_3)
{
ulong uVar1;
if (1 < (int)param_2) {
uVar1 = 1;
do {
*(float *)(param_3 + -4 + uVar1 * 4) = (float)(int)uVar1 * *(float *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (param_2 != uVar1);
}
return;
} |
907 | func0 | #include <stdio.h>
| void func0(const float *xs, int xs_size, float *out) {
for (int i = 1; i < xs_size; i++) {
out[i - 1] = i * xs[i];
}
} | #include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <string.h>
bool issame(const float *a, int a_size, const float *b, int b_size) {
if (a_size != b_size) return false;
for (int i = 0; i < a_size; i++) {
if (fabs(a[i] - b[i]) > 1e-4) return false;
}
return true;
}
int main() {
... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 147c <func0+0x11c>
lea 0x4(%rdi),%r8
lea 0x10(%rdx),%rcx
cmp %rcx,%r8
lea 0x14(%rdi),%rcx
lea -0x2(%rsi),%eax
setae %r8b
cmp %rcx,%rdx
setae %cl
or %cl,%r8b
je 1450 <func0+0xf0>
cmp $0x2,%eax
jbe 1450 <func0+0xf0>
lea -0x1(%rsi),%r8d
movdqa 0xd... | func0:
endbr64
mov rcx, rdi
cmp esi, 1
jle short locret_13A0
cmp esi, 2
jz short loc_1371
lea rdi, [rdi+8]
mov rax, rdx
sub rax, rdi
cmp rax, 8
ja short loc_13A8
loc_1371:
mov esi, esi
mov eax, 1
nop dword ptr [rax+rax+00000000h]
loc_1380:
pxor xmm0, xmm0
cvtsi2s... | void func0(long long a1, int a2, long long a3)
{
long long i; // rax
unsigned int v5; // edi
__m128i si128; // xmm1
__m128i v7; // xmm2
long long v8; // rax
__m128i v9; // xmm0
unsigned int v10; // edi
unsigned int v11; // r8d
unsigned int v12; // esi
signed int v13; // eax
if ( a2 > 1 )
{
... | func0:
ENDBR64
MOV RCX,RDI
CMP ESI,0x1
JLE 0x001013a0
CMP ESI,0x2
JZ 0x00101371
LEA RDI,[RDI + 0x8]
MOV RAX,RDX
SUB RAX,RDI
CMP RAX,0x8
JA 0x001013a8
LAB_00101371:
MOV ESI,ESI
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101380:
PXOR XMM0,XMM0
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RCX + RAX*0x4]
MOVSS dword ptr [R... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(long param_1,uint param_2,long param_3)
{
uint uVar1;
float *pfVar2;
float *pfVar3;
int8 uVar4;
float fVar5;
float fVar6;
float fVar7;
int iVar8;
int iVar9;
int iVar10;
uint uVar11;
ulong uVar12;
... |
908 | func0 | #include <stdio.h>
| int func0(int n) {
int ff[100] = {0};
ff[1] = 0;
ff[2] = 1;
for (int i = 3; i <= n; ++i) {
ff[i] = ff[i - 1] + ff[i - 2] + ff[i - 3];
}
return ff[n];
} | #include <assert.h>
int main() {
assert(func0(2) == 1);
assert(func0(1) == 0);
assert(func0(5) == 4);
assert(func0(8) == 24);
assert(func0(10) == 81);
assert(func0(12) == 274);
assert(func0(14) == 927);
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
lea -0x1a0(%rbp),%rdx
mov $0x0,%eax
mov $0x32,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x19c(%rbp)
movl $0x1,-0x198(%rbp)
movl $0x3,-0x1a4(... | 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
lea rdx, [rbp+var_1A0]
mov eax, 0
mov ecx, 32h ; '2'
mov rdi, rdx
rep stosq
mov [rbp+var_19C], 0
mov [rbp+var_198], 1
mov [rbp+var_1A4], 3
jm... | long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-1A4h]
_DWORD v3[102]; // [rsp+20h] [rbp-1A0h] BYREF
unsigned long long v4; // [rsp+1B8h] [rbp-8h]
v4 = __readfsqword(0x28u);
memset(v3, 0, 0x190uLL);
v3[1] = 0;
v3[2] = 1;
for ( i = 3; i <= a1; ++i )
v3[i] = v3[i - 3] + v3[i - 2] + v3[i - 1];
re... | 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
LEA RDX,[RBP + -0x1a0]
MOV EAX,0x0
MOV ECX,0x32
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x19c],0x0
MOV dword ptr [RBP + -0x198],0x1
MOV dword ptr [RBP + -0x1a... | int func0(int param_1)
{
long lVar1;
int *piVar2;
long in_FS_OFFSET;
int local_1ac;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = local_1a8;
for (lVar1 = 0x32; lVar1 != 0; lVar1 = lVar1 + -1) {
piVar2[0] = 0;
piVar2[1] = 0;
piVar2 = piVar2 + 2;... |
909 | func0 | #include <stdio.h>
| int func0(int n) {
int ff[100] = {0};
ff[1] = 0;
ff[2] = 1;
for (int i = 3; i <= n; ++i) {
ff[i] = ff[i - 1] + ff[i - 2] + ff[i - 3];
}
return ff[n];
} | #include <assert.h>
int main() {
assert(func0(2) == 1);
assert(func0(1) == 0);
assert(func0(5) == 4);
assert(func0(8) == 24);
assert(func0(10) == 81);
assert(func0(12) == 274);
assert(func0(14) == 927);
return 0;
} | O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %edi,%esi
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x32,%ecx
rep stos %rax,%es:(%rdi)
movl $0x1,0x8(%rsp)
cmp $0x2,%esi
jle 11c0 <func0+0x57>
mov %rsp,%rax
lea -0x3(%rsi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov 0x4(%ra... | func0:
endbr64
sub rsp, 1A8h
mov esi, edi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 32h ; '2'
rep stosq
mov [rsp+1A8h+var_1A0], 1
cmp esi, 2
jle short loc_11C0
mov rax, rsp
lea edx, [rsi-3]
lea rcx, [rsp+rdx*4+1A8h+var_1A4]
loc_11AC... | long long func0(int a1)
{
_DWORD *v1; // rax
_DWORD v3[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v4; // [rsp+198h] [rbp-10h]
v4 = __readfsqword(0x28u);
memset(v3, 0, 0x190uLL);
v3[2] = 1;
if ( a1 > 2 )
{
v1 = v3;
do
{
v1[3] = *v1 + v1[2] + v1[1];
++v1;
}
whi... | func0:
ENDBR64
SUB RSP,0x1a8
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x32
STOSQ.REP RDI
MOV dword ptr [RSP + 0x8],0x1
CMP ESI,0x2
JLE 0x001011c0
MOV RAX,RSP
LEA EDX,[RSI + -0x3]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011ac:
MOV EDX,dword ptr [RAX + 0x4]
ADD ... | int func0(int param_1)
{
int *piVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar1 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_1a8;
for (lVar2 = 0x32; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar3 = 0;
piVar3 = (int... |
910 | func0 | #include <stdio.h>
| int func0(int n) {
int ff[100] = {0};
ff[1] = 0;
ff[2] = 1;
for (int i = 3; i <= n; ++i) {
ff[i] = ff[i - 1] + ff[i - 2] + ff[i - 3];
}
return ff[n];
} | #include <assert.h>
int main() {
assert(func0(2) == 1);
assert(func0(1) == 0);
assert(func0(5) == 4);
assert(func0(8) == 24);
assert(func0(10) == 81);
assert(func0(12) == 274);
assert(func0(14) == 927);
return 0;
} | O2 | c | func0:
endbr64
sub $0x1a8,%rsp
movslq %edi,%r8
mov $0x32,%ecx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
movabs $0x100000000,%rax
mov %rax,0x4(%rsp)
cmp $0x2,%r8d
jle 1358 <func0+0x78>
lea -0x3(%r8),%edx
lea 0x4(%rsp),%rax
xor %esi,%es... | func0:
endbr64
sub rsp, 1A8h
movsxd r9, edi
mov ecx, 32h ; '2'
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov [rsp+1A8h+var_1A0], 1
cmp r9d, 2
jle short loc_1347
lea eax, [r9-3]
lea rdx, [rsp+1A8h+var_19C]
xor edi, edi
lea r8, [rsp... | long long func0(int a1)
{
long long v1; // r9
int v2; // ecx
_DWORD *v3; // rdx
int v4; // edi
int v5; // eax
int v6; // esi
_DWORD v8[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v9; // [rsp+198h] [rbp-10h]
v1 = a1;
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x190uLL);
v2 = 0;
v8[2] ... | func0:
ENDBR64
SUB RSP,0x1a8
MOVSXD R9,EDI
MOV ECX,0x32
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV dword ptr [RSP + 0x8],0x1
CMP R9D,0x2
JLE 0x00101347
LEA EAX,[R9 + -0x3]
LEA RDX,[RSP + 0xc]
XOR EDI,EDI
LEA R8,[RSP + RAX*0x4 + 0x10]
MOV EAX,0x1
NOP
LAB_0010133... | int4 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
int *piVar5;
int *piVar6;
int iVar7;
int8 *puVar8;
long in_FS_OFFSET;
int8 uStack_1a8;
int4 local_1a0;
int local_19c [99];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
puVar8 = &uStack_1a8;
for (lVar4... |
911 | func0 | #include <stdio.h>
| int func0(int n) {
int ff[100] = {0};
ff[1] = 0;
ff[2] = 1;
for (int i = 3; i <= n; ++i) {
ff[i] = ff[i - 1] + ff[i - 2] + ff[i - 3];
}
return ff[n];
} | #include <assert.h>
int main() {
assert(func0(2) == 1);
assert(func0(1) == 0);
assert(func0(5) == 4);
assert(func0(8) == 24);
assert(func0(10) == 81);
assert(func0(12) == 274);
assert(func0(14) == 927);
return 0;
} | O3 | c | func0:
endbr64
sub $0x1a8,%rsp
movslq %edi,%rsi
mov $0x32,%ecx
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
mov %rsp,%r9
mov %r9,%rdi
rep stos %rax,%es:(%rdi)
movabs $0x100000000,%rax
mov %rax,0x4(%rsp)
cmp $0x2,%esi
jle 1397 <func0+0xb7>
lea -0x1(%rsi),%r11d
cmp $0x5,%esi
jl... | func0:
endbr64
sub rsp, 1A8h
movsxd rsi, edi
mov ecx, 32h ; '2'
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov r9, rsp
mov rdi, r9
rep stosq
mov [rsp+1A8h+var_1A0], 1
cmp esi, 2
jle short loc_138F
lea r11d, [rsi-1]
cmp esi, 5
jle loc_13AD
lea r8, [rs... | long long func0(int a1)
{
long long v1; // rsi
int v2; // eax
_DWORD *v3; // r8
int v4; // edi
int v5; // edx
int v6; // ecx
int v7; // r10d
_DWORD *v8; // rax
int v9; // edx
_DWORD v11[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v12; // [rsp+198h] [rbp-10h]
v1 = a1;
v12 = __readfs... | func0:
ENDBR64
SUB RSP,0x1a8
MOVSXD RSI,EDI
MOV ECX,0x32
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV R9,RSP
MOV RDI,R9
STOSQ.REP RDI
MOV dword ptr [RSP + 0x8],0x1
CMP ESI,0x2
JLE 0x0010138f
LEA R11D,[RSI + -0x1]
CMP ESI,0x5
JLE 0x001013ad
LEA R8,[RSP + 0xc]
MOV EDI,0x1
XOR EDX,EDX
MOV EC... | int func0(int param_1)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
long in_FS_OFFSET;
int aiStack_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = 0;
piVar2 = aiStack_1a8;
for (lVar5 = 0x32; lVar5 != 0; lVar5 ... |
912 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *s) {
const char *vowels = "aeiouAEIOU";
int count = 0;
int length = strlen(s);
for (int i = 0; i < length; i++) {
if (strchr(vowels, s[i])) {
count++;
}
}
if (length > 0 && (s[length - 1] == 'y' || s[length - 1] == 'Y')) {
count... | #include <assert.h>
int main() {
assert(func0("abcde") == 2);
assert(func0("Alone") == 3);
assert(func0("key") == 2);
assert(func0("bye") == 1);
assert(func0("keY") == 2);
assert(func0("bYe") == 1);
assert(func0("ACEDY") == 3);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
lea 0xe68(%rip),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0xc(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11f1 <func0+0x68>
mov -0x10(%rbp),%eax
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
lea rax, aAeiouaeiou; "aeiouAEIOU"
mov [rbp+var_8], rax
mov [rbp+var_14], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov [rbp+var_10], 0
jmp short loc_11F1
loc_11C3:
mov eax... | long long func0(const char *a1)
{
unsigned int v2; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v4; // [rsp+24h] [rbp-Ch]
v2 = 0;
v4 = strlen(a1);
for ( i = 0; i < v4; ++i )
{
if ( strchr("aeiouAEIOU", a1[i]) )
++v2;
}
if ( v4 > 0 && (a1[v4 - 1] == 121 || a1[v4 - 1] == 89) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011f1
LAB_001011c3:
MOV E... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
int local_1c;
int local_18;
local_1c = 0;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
for (local_18 = 0; local_18 < iVar1; local_18 = local_18 + 1) {
pcVar3 = strchr("aeiouAEIOU",(int)param_1[local_18]);
if (pcVar3 != (char... |
913 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *s) {
const char *vowels = "aeiouAEIOU";
int count = 0;
int length = strlen(s);
for (int i = 0; i < length; i++) {
if (strchr(vowels, s[i])) {
count++;
}
}
if (length > 0 && (s[length - 1] == 'y' || s[length - 1] == 'Y')) {
count... | #include <assert.h>
int main() {
assert(func0("abcde") == 2);
assert(func0("Alone") == 3);
assert(func0("key") == 2);
assert(func0("bye") == 1);
assert(func0("keY") == 2);
assert(func0("bYe") == 1);
assert(func0("ACEDY") == 3);
return 0;
} | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r15
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r12
test %r12d,%r12d
jle 11f3 <func0+0x8a>
mov %r15,%rbx
lea -0x1(%r12),%eax
lea ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r15, rdi
call _strlen
test eax, eax
jle short loc_1203
mov r14, rax
mov rbx, r15
lea eax, [rax-1]
lea r13, [r15+rax+1]
mov ebp, 0
lea r12, s; "aeiouAEIOU"
loc_11C1:
movsx esi... | long long func0(const char *a1)
{
int v1; // eax
int v2; // r14d
const char *v3; // rbx
long long v4; // r13
int v5; // ebp
v1 = strlen(a1);
if ( v1 <= 0 )
{
return 0;
}
else
{
v2 = v1;
v3 = a1;
v4 = (long long)&a1[v1 - 1 + 1];
v5 = 0;
do
v5 -= (strchr("aeiouAEIOU",... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R15,RDI
CALL 0x00101070
TEST EAX,EAX
JLE 0x00101203
MOV R14,RAX
MOV RBX,R15
LEA EAX,[RAX + -0x1]
LEA R13,[R15 + RAX*0x1 + 0x1]
MOV EBP,0x0
LEA R12,[0x102004]
LAB_001011c1:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R12
CALL 0x00101080
CMP RAX,0x... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar4 = param_1;
do {
pcVar3 = strchr("aeiouAEIOU",(int)*pcVar4);
iVar5 = (iVar5 + ... |
914 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *s) {
const char *vowels = "aeiouAEIOU";
int count = 0;
int length = strlen(s);
for (int i = 0; i < length; i++) {
if (strchr(vowels, s[i])) {
count++;
}
}
if (length > 0 && (s[length - 1] == 'y' || s[length - 1] == 'Y')) {
count... | #include <assert.h>
int main() {
assert(func0("abcde") == 2);
assert(func0("Alone") == 3);
assert(func0("key") == 2);
assert(func0("bye") == 1);
assert(func0("keY") == 2);
assert(func0("bYe") == 1);
assert(func0("ACEDY") == 3);
return 0;
} | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 1388 <func0+0x88>
mov %rax,%r13
lea -0x1(%rax),%eax
mov %r14,%rbx
xor %r15d,%r15d
lea 0x1(%r14,%rax,1),%r12
lea 0xcce(%rip),%rbp
nop... | func0:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
call _strlen
test eax, eax
jle short loc_1380
mov r14, rax
lea eax, [rax-1]
mov rbx, r15
xor ebp, ebp
lea r13, [r15+rax+1]
lea r12, s; "aeiouAEIOU"
nop dword ptr [... | long long func0(const char *a1)
{
int v1; // eax
int v2; // r14d
const char *v3; // rbx
int v4; // ebp
long long v5; // r13
v1 = strlen(a1);
if ( v1 <= 0 )
{
return 0;
}
else
{
v2 = v1;
v3 = a1;
v4 = 0;
v5 = (long long)&a1[v1 - 1 + 1];
do
v4 -= (strchr("aeiouAEIOU",... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
TEST EAX,EAX
JLE 0x00101380
MOV R14,RAX
LEA EAX,[RAX + -0x1]
MOV RBX,R15
XOR EBP,EBP
LEA R13,[R15 + RAX*0x1 + 0x1]
LEA R12,[0x102004]
NOP dword ptr [RAX]
LAB_00101338:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R12
CALL 0... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar4 = param_1;
do {
pcVar3 = strchr("aeiouAEIOU",(int)*pcVar4);
iVar5 = (iVar5 + ... |
915 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *s) {
const char *vowels = "aeiouAEIOU";
int count = 0;
int length = strlen(s);
for (int i = 0; i < length; i++) {
if (strchr(vowels, s[i])) {
count++;
}
}
if (length > 0 && (s[length - 1] == 'y' || s[length - 1] == 'Y')) {
count... | #include <assert.h>
int main() {
assert(func0("abcde") == 2);
assert(func0("Alone") == 3);
assert(func0("key") == 2);
assert(func0("bye") == 1);
assert(func0("keY") == 2);
assert(func0("bYe") == 1);
assert(func0("ACEDY") == 3);
return 0;
} | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 1388 <func0+0x88>
mov %rax,%r13
lea -0x1(%rax),%eax
mov %r14,%rbx
xor %r15d,%r15d
lea 0x1(%r14,%rax,1),%r12
lea 0xcce(%rip),%rbp
nop... | func0:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
call _strlen
test eax, eax
jle short loc_1380
mov r14, rax
lea eax, [rax-1]
mov rbx, r15
xor ebp, ebp
lea r13, [r15+rax+1]
lea r12, s; "aeiouAEIOU"
nop dword ptr [... | long long func0(const char *a1)
{
int v1; // eax
int v2; // r14d
const char *v3; // rbx
int v4; // ebp
long long v5; // r13
v1 = strlen(a1);
if ( v1 <= 0 )
{
return 0;
}
else
{
v2 = v1;
v3 = a1;
v4 = 0;
v5 = (long long)&a1[v1 - 1 + 1];
do
v4 -= (strchr("aeiouAEIOU",... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
TEST EAX,EAX
JLE 0x00101380
MOV R14,RAX
LEA EAX,[RAX + -0x1]
MOV RBX,R15
XOR EBP,EBP
LEA R13,[R15 + RAX*0x1 + 0x1]
LEA R12,[0x102004]
NOP dword ptr [RAX]
LAB_00101338:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R12
CALL 0... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar4 = param_1;
do {
pcVar3 = strchr("aeiouAEIOU",(int)*pcVar4);
iVar5 = (iVar5 + ... |
916 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int x, int shift) {
static char xs[50];
sprintf(xs, "%d", x);
int len = strlen(xs);
if (len < shift) {
for (int i = 0; i < len / 2; i++) {
char temp = xs[i];
xs[i] = xs[len - 1 - i];
xs[len - 1 - i] = temp;
}
} else {
char temp... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(100, 2), "001") == 0);
assert(strcmp(func0(12, 2), "12") == 0);
assert(strcmp(func0(97, 8), "79") == 0);
assert(strcmp(func0(12, 1), "21") == 0);
assert(strcmp(func0(11, 101), "11") == 0);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %edi,-0x54(%rbp)
mov %esi,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x54(%rbp),%eax
mov %eax,%edx
lea 0xdd2(%rip),%rsi
lea 0x2e03(%rip),%rdi
mov $0x0,%eax
callq 1110 <sprintf@plt>
lea 0x2df2(%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_54], edi
mov [rbp+var_58], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_54]
mov edx, eax
lea rax, format; "%d"
mov rsi, rax; format
lea rax, xs_1
mov rdi, rax; s
mov eax, ... | char * func0(int a1, int a2)
{
char v3; // [rsp+17h] [rbp-49h]
int i; // [rsp+18h] [rbp-48h]
int v5; // [rsp+1Ch] [rbp-44h]
char dest[56]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+58h] [rbp-8h]
v7 = __readfsqword(0x28u);
sprintf(xs_1, "%d", a1);
v5 = strlen(xs_1);
if ( v5 >= a2 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0x54],EDI
MOV dword ptr [RBP + -0x58],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
LEA RAX,[0x102008]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101110
LE... | int1 * func0(uint param_1,int param_2)
{
int uVar1;
int iVar2;
size_t sVar3;
long in_FS_OFFSET;
int local_50;
char local_48 [56];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sprintf(xs_1,"%d",(ulong)param_1);
sVar3 = strlen(xs_1);
iVar2 = (int)sVar3;
if (iVar2 < param_2) {
... |
917 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int x, int shift) {
static char xs[50];
sprintf(xs, "%d", x);
int len = strlen(xs);
if (len < shift) {
for (int i = 0; i < len / 2; i++) {
char temp = xs[i];
xs[i] = xs[len - 1 - i];
xs[len - 1 - i] = temp;
}
} else {
char temp... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(100, 2), "001") == 0);
assert(strcmp(func0(12, 2), "12") == 0);
assert(strcmp(func0(97, 8), "79") == 0);
assert(strcmp(func0(12, 1), "21") == 0);
assert(strcmp(func0(11, 101), "11") == 0);
return 0;
} | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov %edi,%r8d
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0xe0f(%rip),%rcx
mov $0x32,%edx
mov $0x1,%esi
lea 0x2e3a(%rip),%rdi
callq 10d0 <__sprintf_chk@plt>
lea 0x2e2e(%r... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r8d, edi
mov ebp, esi
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
lea rcx, unk_2004
mov edx, 32h ; '2'
mov esi, 2
lea rbx, xs_1
mov rdi, rbx
call ___sprintf_chk
mov rdi, rbx; s
c... | char * func0(unsigned int a1, int a2)
{
int v2; // eax
int v3; // r8d
char *v4; // rax
long long v5; // rdx
char v6; // si
long long v8; // rbx
_BYTE v9[56]; // [rsp+0h] [rbp-68h] BYREF
unsigned long long v10; // [rsp+38h] [rbp-30h]
v10 = __readfsqword(0x28u);
__sprintf_chk(xs_1, 2LL, 50LL, &unk_20... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R8D,EDI
MOV EBP,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA RCX,[0x102004]
MOV EDX,0x32
MOV ESI,0x2
LEA RBX,[0x104040]
MOV RDI,RBX
CALL 0x00101110
MOV RDI,RBX
CALL 0x001010b0
CMP EAX,EBP
JGE 0x001012b6
MOV R8D,EAX
SHR... | int1 * func0(int4 param_1,int param_2)
{
int uVar1;
int iVar2;
size_t sVar3;
int1 *puVar4;
long lVar5;
long in_FS_OFFSET;
int auStack_68 [56];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(&xs_1,2,0x32,&DAT_00102004,param_1);
sVar3 = strlen(&xs_1);
iVar2 = (int)sVar... |
918 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int x, int shift) {
static char xs[50];
sprintf(xs, "%d", x);
int len = strlen(xs);
if (len < shift) {
for (int i = 0; i < len / 2; i++) {
char temp = xs[i];
xs[i] = xs[len - 1 - i];
xs[len - 1 - i] = temp;
}
} else {
char temp... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(100, 2), "001") == 0);
assert(strcmp(func0(12, 2), "12") == 0);
assert(strcmp(func0(97, 8), "79") == 0);
assert(strcmp(func0(12, 1), "21") == 0);
assert(strcmp(func0(11, 101), "11") == 0);
return 0;
} | O2 | c | func0:
endbr64
push %r12
mov %edi,%r8d
mov $0x32,%edx
lea 0xcbf(%rip),%rcx
push %rbp
lea 0x2cf3(%rip),%rdi
mov %esi,%ebp
mov $0x1,%esi
push %rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
callq 10d0 <__sprintf_chk@plt>
lea 0x2ccb(%rip),%rcx
mov %rcx,%rs... | func0:
endbr64
push r12
mov r8d, edi
movsxd r12, esi
mov edx, 32h ; '2'
push rbp
lea rcx, unk_2004
mov esi, 2
push rbx
lea rbx, xs_1
mov rdi, rbx
sub rsp, 40h
mov rax, fs:28h
mov [rsp+58h+var_20], rax
xor eax, eax
call ___sprintf_chk
mov rdi, rbx; s
call _strl... | char * func0(unsigned int a1, int a2)
{
size_t v2; // rax
int v3; // edi
char *v4; // rdx
char *v5; // rax
char *v6; // rdi
char v7; // si
char v8; // cl
size_t v10; // rbp
long long v11; // rax
long long v12; // rax
_BYTE v13[56]; // [rsp+0h] [rbp-58h] BYREF
unsigned long long v14; // [rsp+38h]... | func0:
ENDBR64
PUSH R12
MOV R8D,EDI
MOVSXD R12,ESI
MOV EDX,0x32
PUSH RBP
LEA RCX,[0x102004]
MOV ESI,0x2
PUSH RBX
LEA RBX,[0x104040]
MOV RDI,RBX
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x00101110
MOV RDI,RBX
CALL 0x001010b0
CMP EAX,R12D
JGE 0x00101400
MOV EDI,EAX
SAR EDI,... | int1 * func0(int4 param_1,int param_2)
{
int uVar1;
size_t sVar2;
int *puVar3;
long lVar4;
int8 uVar5;
int1 *puVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int auStack_58 [56];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(&xs_1,2,0x32,&DAT_00102004,param_1);... |
919 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int x, int shift) {
static char xs[50];
sprintf(xs, "%d", x);
int len = strlen(xs);
if (len < shift) {
for (int i = 0; i < len / 2; i++) {
char temp = xs[i];
xs[i] = xs[len - 1 - i];
xs[len - 1 - i] = temp;
}
} else {
char temp... | #include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(100, 2), "001") == 0);
assert(strcmp(func0(12, 2), "12") == 0);
assert(strcmp(func0(97, 8), "79") == 0);
assert(strcmp(func0(12, 1), "21") == 0);
assert(strcmp(func0(11, 101), "11") == 0);
return 0;
} | O3 | c | func0:
endbr64
push %r12
mov %edi,%r8d
mov $0x32,%edx
lea 0xcbf(%rip),%rcx
push %rbp
lea 0x2cf3(%rip),%rdi
mov %esi,%ebp
mov $0x1,%esi
push %rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
callq 10d0 <__sprintf_chk@plt>
lea 0x2ccb(%rip),%rcx
mov %rcx,%rs... | func0:
endbr64
push r12
mov r8d, edi
movsxd r12, esi
mov edx, 32h ; '2'
push rbp
lea rcx, unk_2004
mov esi, 2
push rbx
lea rbx, xs_1
mov rdi, rbx
sub rsp, 40h
mov rax, fs:28h
mov [rsp+58h+var_20], rax
xor eax, eax
call ___sprintf_chk
mov rdi, rbx; s
call _strl... | char * func0(unsigned int a1, int a2)
{
size_t v2; // rax
int v3; // edi
char *v4; // rdx
char *v5; // rax
char *v6; // rdi
char v7; // si
char v8; // cl
size_t v10; // rbp
long long v11; // rax
long long v12; // rax
_BYTE v13[56]; // [rsp+0h] [rbp-58h] BYREF
unsigned long long v14; // [rsp+38h]... | func0:
ENDBR64
PUSH R12
MOV R8D,EDI
MOVSXD R12,ESI
MOV EDX,0x32
PUSH RBP
LEA RCX,[0x102004]
MOV ESI,0x2
PUSH RBX
LEA RBX,[0x104040]
MOV RDI,RBX
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CALL 0x00101110
MOV RDI,RBX
CALL 0x001010b0
CMP EAX,R12D
JGE 0x00101400
MOV EDI,EAX
SAR EDI,... | int1 * func0(int4 param_1,int param_2)
{
int uVar1;
size_t sVar2;
int *puVar3;
long lVar4;
int8 uVar5;
int1 *puVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int auStack_58 [56];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(&xs_1,2,0x32,&DAT_00102004,param_1);... |
920 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
int sum = 0;
for (int i = 0; s[i] != '\0'; i++)
if (s[i] >= 'A' && s[i] <= 'Z')
sum += s[i];
return sum;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abAB") == 131);
assert(func0("abcCd") == 67);
assert(func0("helloE") == 69);
assert(func0("woArBld") == 131);
assert(func0("aAaaaXa") == 153);
assert(func0(" How are yOu?") == 151);
assert(func0("You arE Very Smart")... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a7 <func0+0x5e>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x40,%al
jle 11a3 <func0+0x5a>
mov -0x4(%rbp),%eax
movslq %eax,%rdx... | 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_11A7
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, 40h ; '@'
jle short loc_11A3
mov eax, ... | long long func0(long long a1)
{
unsigned int v2; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v2 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(char *)(i + a1) > 64 && *(char *)(i + a1) <= 90 )
v2 += *(char *)(i + a1);
}
return v2;
} | 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 0x001011a7
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,0x40
JLE 0x001011a3
MOV EAX,dword ptr [... | int func0(long param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
if (('@' < *(char *)(param_1 + local_c)) && (*(char *)(param_1 + local_c) < '[')) {
local_10 = local_10 + *(char *)(param_1 + local_c);
}
}
... |
921 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
int sum = 0;
for (int i = 0; s[i] != '\0'; i++)
if (s[i] >= 'A' && s[i] <= 'Z')
sum += s[i];
return sum;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abAB") == 131);
assert(func0("abcCd") == 67);
assert(func0("helloE") == 69);
assert(func0("woArBld") == 131);
assert(func0("aAaaaXa") == 153);
assert(func0(" How are yOu?") == 151);
assert(func0("You arE Very Smart")... | O1 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 117a <func0+0x31>
add $0x1,%rdi
mov $0x0,%edx
lea -0x41(%rax),%ecx
movsbl %al,%eax
add %edx,%eax
cmp $0x1a,%cl
cmovb %eax,%edx
add $0x1,%rdi
movzbl -0x1(%rdi),%eax
test %al,%al
jne 115d <func0+0x14>
mov %edx,%eax
retq
mov $0x0,%edx
jm... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_117A
add rdi, 1
mov edx, 0
loc_115D:
lea ecx, [rax-41h]
movsx eax, al
add eax, edx
cmp cl, 1Ah
cmovb edx, eax
add rdi, 1
movzx eax, byte ptr [rdi-1]
test al, al
jnz short loc_115D
loc_1177:
mov eax, edx
... | long long func0(char *a1)
{
char v1; // al
char *v2; // rdi
unsigned int v3; // edx
unsigned __int8 v4; // cl
unsigned int v5; // eax
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
v3 = 0;
do
{
v4 = v1 - 65;
v5 = v3 + v1;
if ( v4 < 0x1Au )
v3 = v5;
v1 = *v2++;
... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x0010117a
ADD RDI,0x1
MOV EDX,0x0
LAB_0010115d:
LEA ECX,[RAX + -0x41]
MOVSX EAX,AL
ADD EAX,EDX
CMP CL,0x1a
CMOVC EDX,EAX
ADD RDI,0x1
MOVZX EAX,byte ptr [RDI + -0x1]
TEST AL,AL
JNZ 0x0010115d
LAB_00101177:
MOV EAX,EDX
RET
LAB_0010117a:
MOV EDX,0x0
JMP 0x00101177 | int 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 ((byte)(cVar1 + 0xbfU) < 0x1a) {
iVar2 = cVar1 + iVar2;
}
cVar1 = *pcVar3;
pcVar3 = pcVar3... |
922 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
int sum = 0;
for (int i = 0; s[i] != '\0'; i++)
if (s[i] >= 'A' && s[i] <= 'Z')
sum += s[i];
return sum;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abAB") == 131);
assert(func0("abcCd") == 67);
assert(func0("helloE") == 69);
assert(func0("woArBld") == 131);
assert(func0("aAaaaXa") == 153);
assert(func0(" How are yOu?") == 151);
assert(func0("You arE Very Smart")... | O2 | c | func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 13c8 <func0+0x38>
add $0x1,%rdi
xor %r8d,%r8d
nopw 0x0(%rax,%rax,1)
lea -0x41(%rax),%edx
add %r8d,%eax
cmp $0x1a,%dl
cmovb %eax,%r8d
movsbl (%rdi),%eax
add $0x1,%rdi
test %al,%al
jne 13a8 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax... | func0:
endbr64
movsx eax, byte ptr [rdi]
test al, al
jz short loc_13E8
add rdi, 1
xor edx, edx
nop dword ptr [rax+00000000h]
loc_13C8:
lea ecx, [rax-41h]
add eax, edx
cmp cl, 1Ah
cmovb edx, eax
movsx eax, byte ptr [rdi]
add rdi, 1
test al, al
jnz short loc_13C8
mov e... | long long func0(_BYTE *a1)
{
int v1; // eax
char *v2; // rdi
unsigned int v3; // edx
unsigned __int8 v4; // cl
unsigned int v5; // eax
v1 = (char)*a1;
if ( !*a1 )
return 0LL;
v2 = a1 + 1;
v3 = 0;
do
{
v4 = v1 - 65;
v5 = v3 + v1;
if ( v4 < 0x1Au )
v3 = v5;
v1 = *v2++;
... | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001013e8
ADD RDI,0x1
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001013c8:
LEA ECX,[RAX + -0x41]
ADD EAX,EDX
CMP CL,0x1a
CMOVC EDX,EAX
MOVSX EAX,byte ptr [RDI]
ADD RDI,0x1
TEST AL,AL
JNZ 0x001013c8
MOV EAX,EDX
RET
LAB_001013e8:
XOR EDX,EDX
MOV EAX,EDX
RET | int func0(char *param_1)
{
char cVar1;
int iVar2;
cVar1 = *param_1;
if (cVar1 != '\0') {
param_1 = param_1 + 1;
iVar2 = 0;
do {
if ((byte)(cVar1 + 0xbfU) < 0x1a) {
iVar2 = cVar1 + iVar2;
}
cVar1 = *param_1;
param_1 = param_1 + 1;
} while (cVar1 != '\0');
r... |
923 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char *s) {
int sum = 0;
for (int i = 0; s[i] != '\0'; i++)
if (s[i] >= 'A' && s[i] <= 'Z')
sum += s[i];
return sum;
} | #include <assert.h>
int main() {
assert(func0("") == 0);
assert(func0("abAB") == 131);
assert(func0("abcCd") == 67);
assert(func0("helloE") == 69);
assert(func0("woArBld") == 131);
assert(func0("aAaaaXa") == 153);
assert(func0(" How are yOu?") == 151);
assert(func0("You arE Very Smart")... | O3 | c | func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 13e8 <func0+0x38>
add $0x1,%rdi
xor %r8d,%r8d
nopw 0x0(%rax,%rax,1)
lea -0x41(%rax),%edx
add %r8d,%eax
cmp $0x1a,%dl
cmovb %eax,%r8d
movsbl (%rdi),%eax
add $0x1,%rdi
test %al,%al
jne 13c8 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax... | func0:
endbr64
movsx eax, byte ptr [rdi]
test al, al
jz short loc_13E8
add rdi, 1
xor edx, edx
nop dword ptr [rax+00000000h]
loc_13C8:
lea ecx, [rax-41h]
add eax, edx
cmp cl, 1Ah
cmovb edx, eax
movsx eax, byte ptr [rdi]
add rdi, 1
test al, al
jnz short loc_13C8
mov e... | long long func0(_BYTE *a1)
{
int v1; // eax
char *v2; // rdi
unsigned int v3; // edx
unsigned __int8 v4; // cl
unsigned int v5; // eax
v1 = (char)*a1;
if ( !*a1 )
return 0LL;
v2 = a1 + 1;
v3 = 0;
do
{
v4 = v1 - 65;
v5 = v3 + v1;
if ( v4 < 0x1Au )
v3 = v5;
v1 = *v2++;
... | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001013e8
ADD RDI,0x1
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001013c8:
LEA ECX,[RAX + -0x41]
ADD EAX,EDX
CMP CL,0x1a
CMOVC EDX,EAX
MOVSX EAX,byte ptr [RDI]
ADD RDI,0x1
TEST AL,AL
JNZ 0x001013c8
MOV EAX,EDX
RET
LAB_001013e8:
XOR EDX,EDX
MOV EAX,EDX
RET | int func0(char *param_1)
{
char cVar1;
int iVar2;
cVar1 = *param_1;
if (cVar1 != '\0') {
param_1 = param_1 + 1;
iVar2 = 0;
do {
if ((byte)(cVar1 + 0xbfU) < 0x1a) {
iVar2 = cVar1 + iVar2;
}
cVar1 = *param_1;
param_1 = param_1 + 1;
} while (cVar1 != '\0');
r... |
924 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
| int func0(const char *s, int n) {
char num1[10] = "";
char num2[10] = "";
int is12 = 0, j = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (isdigit(s[i])) {
if (is12 == 0) {
num1[j++] = s[i];
} else {
num2[j++] = s[i];
}
} ... | #include <assert.h>
int main() {
assert(func0("5 apples and 6 oranges", 19) == 8);
assert(func0("5 apples and 6 oranges", 21) == 10);
assert(func0("0 apples and 1 oranges", 3) == 2);
assert(func0("1 apples and 0 oranges", 3) == 2);
assert(func0("2 apples and 3 oranges", 100) == 95);
assert(func... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movq $0x0,-0x2c(%rbp)
movw $0x0,-0x24(%rbp)
movq $0x0,-0x22(%rbp)
movw $0x0,-0x1a(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x3... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov qword ptr [rbp+nptr], 0
mov [rbp+var_24], 0
mov qword ptr [rbp+var_22], 0
mov [rbp+var_1A], 0
mov [rbp+var_3... | long long func0(long long a1, int a2)
{
int v2; // eax
int v3; // ebx
int v5; // [rsp+18h] [rbp-38h]
int v6; // [rsp+1Ch] [rbp-34h]
int i; // [rsp+20h] [rbp-30h]
char nptr[8]; // [rsp+24h] [rbp-2Ch] BYREF
__int16 v9; // [rsp+2Ch] [rbp-24h]
char v10[8]; // [rsp+2Eh] [rbp-22h] BYREF
__int16 v11; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x2c],0x0
MOV word ptr [RBP + -0x24],0x0
MOV qword ptr [RBP + -0x22],0x0
MOV word ptr [RBP + -0x1a],0x0
... | int func0(long param_1,int param_2)
{
bool bVar1;
int iVar2;
int iVar3;
ushort **ppuVar4;
long in_FS_OFFSET;
int local_3c;
int local_38;
char local_34 [20];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_34[0] = '\0';
local_34[1] = '\0';
local_34[2] = '\0';
local_34[3] =... |
925 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
| int func0(const char *s, int n) {
char num1[10] = "";
char num2[10] = "";
int is12 = 0, j = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (isdigit(s[i])) {
if (is12 == 0) {
num1[j++] = s[i];
} else {
num2[j++] = s[i];
}
} ... | #include <assert.h>
int main() {
assert(func0("5 apples and 6 oranges", 19) == 8);
assert(func0("5 apples and 6 oranges", 21) == 10);
assert(func0("0 apples and 1 oranges", 3) == 2);
assert(func0("1 apples and 0 oranges", 3) == 2);
assert(func0("2 apples and 3 oranges", 100) == 95);
assert(func... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %esi,%r12d
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,0x4(%rsp)
movw $0x0,0xc(%rsp)
movq $0x0,0xe(%rsp)
movw $0x0,0x16(%rsp)
movzbl (%rdi),%ebx
test %bl,%bl
je 125c <func0+0xb3>
mov %rdi,%rbp
callq ... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
mov r12d, esi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov qword ptr [rsp+38h+nptr], 0
mov [rsp+38h+var_2C], 0
mov qword ptr [rsp+38h+var_2A], 0
mov [rsp+38h+var_22], 0
movzx ebx, byte ptr [rdi]
test b... | long long func0(char *a1, int a2)
{
char v2; // bl
const unsigned __int16 *v4; // rdi
char *v5; // rdx
int v6; // ecx
int v7; // eax
int v8; // r12d
char nptr[8]; // [rsp+4h] [rbp-34h] BYREF
__int16 v11; // [rsp+Ch] [rbp-2Ch]
char v12[8]; // [rsp+Eh] [rbp-2Ah] BYREF
__int16 v13; // [rsp+16h] [rbp-2... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV R12D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x4],0x0
MOV word ptr [RSP + 0xc],0x0
MOV qword ptr [RSP + 0xe],0x0
MOV word ptr [RSP + 0x16],0x0
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x0010125e
MOV RBP,RDI
... | int func0(char *param_1,int param_2)
{
ushort *puVar1;
bool bVar2;
ushort **ppuVar3;
long lVar4;
long lVar5;
int iVar6;
char *pcVar7;
char cVar8;
long in_FS_OFFSET;
char local_34 [20];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_34[0] = '\0';
local_34[1] = '\0';
loc... |
926 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
| int func0(const char *s, int n) {
char num1[10] = "";
char num2[10] = "";
int is12 = 0, j = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (isdigit(s[i])) {
if (is12 == 0) {
num1[j++] = s[i];
} else {
num2[j++] = s[i];
}
} ... | #include <assert.h>
int main() {
assert(func0("5 apples and 6 oranges", 19) == 8);
assert(func0("5 apples and 6 oranges", 21) == 10);
assert(func0("0 apples and 1 oranges", 3) == 2);
assert(func0("1 apples and 0 oranges", 3) == 2);
assert(func0("2 apples and 3 oranges", 100) == 95);
assert(func... | O2 | c | func0:
endbr64
push %r12
xor %edx,%edx
mov %esi,%r12d
push %rbp
push %rbx
sub $0x20,%rsp
movzbl (%rdi),%ebx
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
xor %eax,%eax
mov %dx,0x16(%rsp)
movq $0x0,0x4(%rsp)
mov %ax,0xc(%rsp)
movq $0x0,0xe(%rsp)
test %bl,%bl
je 13fe <func... | func0:
endbr64
push r12
xor edx, edx
mov r12d, esi
push rbp
push rbx
sub rsp, 20h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
xor eax, eax
mov [rsp+38h+var_22], dx
mov qword ptr [rsp+38h+nptr], 0
mov [rsp+38h+var_2C], ax
mov qwo... | long long func0(char *a1, int a2)
{
char v3; // bl
const unsigned __int16 **v4; // rax
char *v5; // rdi
int v6; // edx
const unsigned __int16 *v7; // rsi
int v8; // eax
int v9; // r12d
char nptr[8]; // [rsp+4h] [rbp-34h] BYREF
__int16 v12; // [rsp+Ch] [rbp-2Ch]
char v13[8]; // [rsp+Eh] [rbp-2Ah] BY... | func0:
ENDBR64
PUSH R12
XOR EDX,EDX
MOV R12D,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
XOR EAX,EAX
MOV word ptr [RSP + 0x16],DX
MOV qword ptr [RSP + 0x4],0x0
MOV word ptr [RSP + 0xc],AX
MOV qword ptr [RSP + 0xe],0x0
TEST BL,BL
JZ 0... | int func0(char *param_1,int param_2)
{
ushort *puVar1;
bool bVar2;
ushort **ppuVar3;
long lVar4;
long lVar5;
int iVar6;
char cVar7;
long in_FS_OFFSET;
char local_34 [20];
long local_20;
cVar7 = *param_1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_34[0x12] = '\0';
local_34[0x13] = '... |
927 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
| int func0(const char *s, int n) {
char num1[10] = "";
char num2[10] = "";
int is12 = 0, j = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (isdigit(s[i])) {
if (is12 == 0) {
num1[j++] = s[i];
} else {
num2[j++] = s[i];
}
} ... | #include <assert.h>
int main() {
assert(func0("5 apples and 6 oranges", 19) == 8);
assert(func0("5 apples and 6 oranges", 21) == 10);
assert(func0("0 apples and 1 oranges", 3) == 2);
assert(func0("1 apples and 0 oranges", 3) == 2);
assert(func0("2 apples and 3 oranges", 100) == 95);
assert(func... | O3 | c | func0:
endbr64
push %r12
xor %edx,%edx
mov %esi,%r12d
push %rbp
push %rbx
sub $0x20,%rsp
movzbl (%rdi),%ebx
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
xor %eax,%eax
mov %dx,0x16(%rsp)
movq $0x0,0x4(%rsp)
mov %ax,0xc(%rsp)
movq $0x0,0xe(%rsp)
test %bl,%bl
je 13fe <func... | func0:
endbr64
push r12
xor edx, edx
mov r12d, esi
push rbp
push rbx
sub rsp, 20h
movzx ebx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
xor eax, eax
mov [rsp+38h+var_22], dx
mov qword ptr [rsp+38h+nptr], 0
mov [rsp+38h+var_2C], ax
mov qwo... | long long func0(char *a1, int a2)
{
char v3; // bl
const unsigned __int16 **v4; // rax
char *v5; // rdi
int v6; // edx
const unsigned __int16 *v7; // rsi
int v8; // eax
int v9; // r12d
char nptr[8]; // [rsp+4h] [rbp-34h] BYREF
__int16 v12; // [rsp+Ch] [rbp-2Ch]
char v13[8]; // [rsp+Eh] [rbp-2Ah] BY... | func0:
ENDBR64
PUSH R12
XOR EDX,EDX
MOV R12D,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOVZX EBX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
XOR EAX,EAX
MOV word ptr [RSP + 0x16],DX
MOV qword ptr [RSP + 0x4],0x0
MOV word ptr [RSP + 0xc],AX
MOV qword ptr [RSP + 0xe],0x0
TEST BL,BL
JZ 0... | int func0(char *param_1,int param_2)
{
ushort *puVar1;
bool bVar2;
ushort **ppuVar3;
long lVar4;
long lVar5;
int iVar6;
char cVar7;
long in_FS_OFFSET;
char local_34 [20];
long local_20;
cVar7 = *param_1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_34[0x12] = '\0';
local_34[0x13] = '... |
928 | func0 | #include <stdio.h>
#include <limits.h>
| int *func0(int arr[], int length, int output[2]) {
int smallestEven = INT_MAX;
int index = -1;
for (int i = 0; i < length; ++i) {
if (arr[i] % 2 == 0 && (arr[i] < smallestEven || index == -1)) {
smallestEven = arr[i];
index = i;
}
}
if (index == -1) ... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(const int *a, const int *b, int a_length, int b_length) {
if (a_length != b_length) return 0;
for (int i = 0; i < a_length; ++i) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int output[2];
int *result;
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x7fffffff,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f4 <func0+0x8b>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mo... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_C], 7FFFFFFFh
mov [rbp+var_8], 0FFFFFFFFh
mov [rbp+var_4], 0
jmp short loc_11F4
loc_1193:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18... | int * func0(long long a1, int a2, int *a3)
{
int v4; // [rsp+1Ch] [rbp-Ch]
int v5; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
v4 = 0x7FFFFFFF;
v5 = -1;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 && (v4 > *(_DWORD *)(4LL * i + a1) || v5 == -1) )
{
v4 = *(_... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0xc],0x7fffffff
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f4
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4... | int * func0(long param_1,int param_2,int *param_3)
{
int local_14;
int local_10;
int local_c;
local_14 = 0x7fffffff;
local_10 = -1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (((*(uint *)(param_1 + (long)local_c * 4) & 1) == 0) &&
((*(int *)(param_1 + (long)local_c * 4) ... |
929 | func0 | #include <stdio.h>
#include <limits.h>
| int *func0(int arr[], int length, int output[2]) {
int smallestEven = INT_MAX;
int index = -1;
for (int i = 0; i < length; ++i) {
if (arr[i] % 2 == 0 && (arr[i] < smallestEven || index == -1)) {
smallestEven = arr[i];
index = i;
}
}
if (index == -1) ... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(const int *a, const int *b, int a_length, int b_length) {
if (a_length != b_length) return 0;
for (int i = 0; i < a_length; ++i) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int output[2];
int *result;
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11c0 <func0+0x57>
lea -0x1(%rsi),%r10d
mov $0x0,%ecx
mov $0xffffffff,%r9d
mov $0x7fffffff,%eax
jmp 1198 <func0+0x2f>
mov %r8d,%r9d
mov %esi,%eax
lea 0x1(%rcx),%rsi
cmp %rcx,%r10
je 11b0 <func0+0x47>
mov %rsi,%rcx
mov %ecx,%r8d
mov (%rdi,%rcx... | func0:
endbr64
test esi, esi
jle short loc_11BC
movsxd rsi, esi
mov ecx, 0
mov r9d, 0FFFFFFFFh
mov eax, 7FFFFFFFh
jmp short loc_1195
loc_1186:
mov r9d, ecx
mov eax, r8d
loc_118C:
add rcx, 1
cmp rsi, rcx
jz short loc_11AC
loc_1195:
mov r8d, [rdi+rcx*4]
test r8b, 1
jnz ... | int * func0(long long a1, int a2, int *a3)
{
long long v3; // rcx
int v4; // r9d
int v5; // eax
int v6; // r8d
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
v4 = -1;
v5 = 0x7FFFFFFF;
do
{
v6 = *(_DWORD *)(a1 + 4 * v3);
if ( (v6 & 1) == 0 && (v4 == -1 || v6 < v5) )
{
v4 = v3;
v5 =... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011bc
MOVSXD RSI,ESI
MOV ECX,0x0
MOV R9D,0xffffffff
MOV EAX,0x7fffffff
JMP 0x00101195
LAB_00101186:
MOV R9D,ECX
MOV EAX,R8D
LAB_0010118c:
ADD RCX,0x1
CMP RSI,RCX
JZ 0x001011ac
LAB_00101195:
MOV R8D,dword ptr [RDI + RCX*0x4]
TEST R8B,0x1
JNZ 0x0010118c
CMP R9D,-0x1
JZ 0x00101186
CMP ... | uint * func0(long param_1,int param_2,uint *param_3)
{
uint uVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
if (param_2 < 1) {
return (uint *)0x0;
}
uVar3 = 0;
uVar4 = 0xffffffff;
uVar2 = 0x7fffffff;
do {
uVar1 = *(uint *)(param_1 + uVar3 * 4);
if (((uVar1 & 1) == 0) && (((int)uVar4 == ... |
930 | func0 | #include <stdio.h>
#include <limits.h>
| int *func0(int arr[], int length, int output[2]) {
int smallestEven = INT_MAX;
int index = -1;
for (int i = 0; i < length; ++i) {
if (arr[i] % 2 == 0 && (arr[i] < smallestEven || index == -1)) {
smallestEven = arr[i];
index = i;
}
}
if (index == -1) ... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(const int *a, const int *b, int a_length, int b_length) {
if (a_length != b_length) return 0;
for (int i = 0; i < a_length; ++i) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int output[2];
int *result;
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 16e0 <func0+0x60>
lea -0x1(%rsi),%r10d
xor %ecx,%ecx
mov $0xffffffff,%r9d
mov $0x7fffffff,%eax
jmp 16a3 <func0+0x23>
nopl 0x0(%rax,%rax,1)
mov %rsi,%rcx
mov (%rdi,%rcx,4),%esi
mov %ecx,%r8d
test $0x1,%sil
jne 16be <func0+0x3e>
cmp $0xffffffff,%r9d... | func0:
endbr64
test esi, esi
jle short loc_1558
movsxd rsi, esi
xor ecx, ecx
mov r9d, 0FFFFFFFFh
mov eax, 7FFFFFFFh
nop dword ptr [rax+rax+00000000h]
loc_1520:
mov r8d, [rdi+rcx*4]
test r8b, 1
jnz short loc_153B
cmp r9d, 0FFFFFFFFh
jz short loc_1535
cmp eax, r8d
jle s... | int * func0(long long a1, int a2, int *a3)
{
long long v3; // rcx
int v4; // r9d
int v5; // eax
int v6; // r8d
int *result; // rax
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
v4 = -1;
v5 = 0x7FFFFFFF;
do
{
v6 = *(_DWORD *)(a1 + 4 * v3);
if ( (v6 & 1) == 0 && (v4 == -1 || v5 > v6) )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101558
MOVSXD RSI,ESI
XOR ECX,ECX
MOV R9D,0xffffffff
MOV EAX,0x7fffffff
NOP dword ptr [RAX + RAX*0x1]
LAB_00101520:
MOV R8D,dword ptr [RDI + RCX*0x4]
TEST R8B,0x1
JNZ 0x0010153b
CMP R9D,-0x1
JZ 0x00101535
CMP EAX,R8D
JLE 0x0010153b
LAB_00101535:
MOV R9D,ECX
MOV EAX,R8D
LAB_0010153b:
... | uint * func0(long param_1,int param_2,uint *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
long lVar4;
if (0 < param_2) {
lVar4 = 0;
uVar3 = 0xffffffff;
uVar2 = 0x7fffffff;
do {
uVar1 = *(uint *)(param_1 + lVar4 * 4);
if (((uVar1 & 1) == 0) && ((uVar3 == 0xffffffff || ((int)uVa... |
931 | func0 | #include <stdio.h>
#include <limits.h>
| int *func0(int arr[], int length, int output[2]) {
int smallestEven = INT_MAX;
int index = -1;
for (int i = 0; i < length; ++i) {
if (arr[i] % 2 == 0 && (arr[i] < smallestEven || index == -1)) {
smallestEven = arr[i];
index = i;
}
}
if (index == -1) ... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(const int *a, const int *b, int a_length, int b_length) {
if (a_length != b_length) return 0;
for (int i = 0; i < a_length; ++i) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int output[2];
int *result;
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1660 <func0+0x60>
lea -0x1(%rsi),%r10d
xor %ecx,%ecx
mov $0xffffffff,%r9d
mov $0x7fffffff,%eax
jmp 1623 <func0+0x23>
nopl 0x0(%rax,%rax,1)
mov %rsi,%rcx
mov (%rdi,%rcx,4),%esi
mov %ecx,%r8d
test $0x1,%sil
jne 163e <func0+0x3e>
cmp $0xffffffff,%r9d... | func0:
endbr64
test esi, esi
jle short loc_13D8
movsxd rsi, esi
xor ecx, ecx
mov r9d, 0FFFFFFFFh
mov eax, 7FFFFFFFh
nop dword ptr [rax+rax+00000000h]
loc_13A0:
mov r8d, [rdi+rcx*4]
test r8b, 1
jnz short loc_13BB
cmp r9d, 0FFFFFFFFh
jz short loc_13B5
cmp eax, r8d
jle s... | int * func0(long long a1, int a2, int *a3)
{
long long v3; // rcx
int v4; // r9d
int v5; // eax
int v6; // r8d
int *result; // rax
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
v4 = -1;
v5 = 0x7FFFFFFF;
do
{
v6 = *(_DWORD *)(a1 + 4 * v3);
if ( (v6 & 1) == 0 && (v4 == -1 || v5 > v6) )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013d8
MOVSXD RSI,ESI
XOR ECX,ECX
MOV R9D,0xffffffff
MOV EAX,0x7fffffff
NOP dword ptr [RAX + RAX*0x1]
LAB_001013a0:
MOV R8D,dword ptr [RDI + RCX*0x4]
TEST R8B,0x1
JNZ 0x001013bb
CMP R9D,-0x1
JZ 0x001013b5
CMP EAX,R8D
JLE 0x001013bb
LAB_001013b5:
MOV R9D,ECX
MOV EAX,R8D
LAB_001013bb:
... | uint * func0(long param_1,int param_2,uint *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
long lVar4;
if (0 < param_2) {
lVar4 = 0;
uVar3 = 0xffffffff;
uVar2 = 0x7fffffff;
do {
uVar1 = *(uint *)(param_1 + lVar4 * 4);
if (((uVar1 & 1) == 0) && ((uVar3 == 0xffffffff || ((int)uVa... |
932 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *lst, int size) {
int *freq = (int *)calloc(size + 1, sizeof(int));
int max = -1;
for (int i = 0; i < size; i++) {
freq[lst[i]]++;
if ((freq[lst[i]] >= lst[i]) && (lst[i] > max)) {
max = lst[i];
}
}
free(freq);
return max;
} | #include <assert.h>
int main() {
int arr1[] = {5, 5, 5, 5, 1};
int arr2[] = {4, 1, 4, 1, 4, 4};
int arr3[] = {3, 3};
int arr4[] = {8, 8, 8, 8, 8, 8, 8, 8};
int arr5[] = {2, 3, 3, 2, 2};
int arr6[] = {2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1};
int arr7[] = {3, 2, 8,... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
add $0x1,%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 1090 <calloc@plt>
mov %rax,-0x8(%rbp)
movl $0xffffffff,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1271 <func0+0xe8>
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
add eax, 1
cdqe
mov esi, 4; size
mov rdi, rax; nmemb
call _calloc
mov [rbp+ptr], rax
mov [rbp+var_10], 0FFFFFFFFh
mov [rbp+var_C], 0
jmp loc_1271
loc_... | long long func0(long long a1, int a2)
{
_DWORD *v2; // rax
int v4; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
_DWORD *ptr; // [rsp+18h] [rbp-8h]
ptr = calloc(a2 + 1, 4uLL);
v4 = -1;
for ( i = 0; i < a2; ++i )
{
v2 = &ptr[*(int *)(4LL * i + a1)];
++*v2;
if ( ptr[*(int *)(4LL * i + ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL 0x00101090
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0xffffffff
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101271
LA... | int func0(long param_1,int param_2)
{
void *__ptr;
int *piVar1;
int4 local_18;
int4 local_14;
__ptr = calloc((long)(param_2 + 1),4);
local_18 = -1;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
piVar1 = (int *)((long)__ptr + (long)*(int *)(param_1 + (long)local_14 * 4) * 4);
... |
933 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *lst, int size) {
int *freq = (int *)calloc(size + 1, sizeof(int));
int max = -1;
for (int i = 0; i < size; i++) {
freq[lst[i]]++;
if ((freq[lst[i]] >= lst[i]) && (lst[i] > max)) {
max = lst[i];
}
}
free(freq);
return max;
} | #include <assert.h>
int main() {
int arr1[] = {5, 5, 5, 5, 1};
int arr2[] = {4, 1, 4, 1, 4, 4};
int arr3[] = {3, 3};
int arr4[] = {8, 8, 8, 8, 8, 8, 8, 8};
int arr5[] = {2, 3, 3, 2, 2};
int arr6[] = {2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1};
int arr7[] = {3, 2, 8,... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%ebx
lea 0x1(%rsi),%edi
movslq %edi,%rdi
mov $0x4,%esi
callq 1070 <calloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 11c7 <func0+0x5e>
mov %rbp,%rcx
lea -0x1(%rbx),%eax
lea 0x4(%rbp,%rax,4),%rax
mov $0xffffffff,%e... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
lea edi, [rsi+1]
movsxd rdi, edi; nmemb
mov esi, 4; size
call _calloc
mov rdi, rax; ptr
test ebx, ebx
jle short loc_11D7
mov rsi, rbp
movsxd rbx, ebx
lea rax, [rbp+rbx*4+0]
mov ebx, 0FFFFFFFFh
loc... | long long func0(int *a1, int a2)
{
char *v4; // rdi
int *v5; // rsi
int *v6; // rax
int v7; // ebx
int v8; // ecx
int *v9; // r8
int v10; // edx
int v11; // r8d
v4 = (char *)calloc(a2 + 1, 4uLL);
if ( a2 <= 0 )
{
v7 = -1;
}
else
{
v5 = a1;
v6 = &a1[a2];
v7 = -1;
do
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
LEA EDI,[RSI + 0x1]
MOVSXD RDI,EDI
MOV ESI,0x4
CALL 0x00101070
MOV RDI,RAX
TEST EBX,EBX
JLE 0x001011d7
MOV RSI,RBP
MOVSXD RBX,EBX
LEA RAX,[RBP + RBX*0x4]
MOV EBX,0xffffffff
LAB_0010119f:
MOV ECX,dword ptr [RSI]
MOVSXD RDX,ECX
LEA R8,[RDI + RDX*0x4]
MO... | int func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
int iVar5;
int iVar6;
__ptr = calloc((long)(param_2 + 1),4);
if (param_2 < 1) {
iVar6 = -1;
}
else {
piVar2 = param_1 + param_2;
iVar6 = -1;
do {
iVar3 = *param_1;
piV... |
934 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *lst, int size) {
int *freq = (int *)calloc(size + 1, sizeof(int));
int max = -1;
for (int i = 0; i < size; i++) {
freq[lst[i]]++;
if ((freq[lst[i]] >= lst[i]) && (lst[i] > max)) {
max = lst[i];
}
}
free(freq);
return max;
} | #include <assert.h>
int main() {
int arr1[] = {5, 5, 5, 5, 1};
int arr2[] = {4, 1, 4, 1, 4, 4};
int arr3[] = {3, 3};
int arr4[] = {8, 8, 8, 8, 8, 8, 8, 8};
int arr5[] = {2, 3, 3, 2, 2};
int arr6[] = {2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1};
int arr7[] = {3, 2, 8,... | O2 | c | func0:
endbr64
push %r12
mov %esi,%r12d
push %rbx
mov %rdi,%rbx
lea 0x1(%rsi),%edi
mov $0x4,%esi
movslq %edi,%rdi
sub $0x8,%rsp
callq 1070 <calloc@plt>
mov %rax,%r8
test %r12d,%r12d
jle 1200 <func0+0x80>
lea -0x1(%r12),%eax
mov %rbx,%rdi
mov $0xffffffff,%r12d
lea 0x4(%rbx,%rax,4)... | func0:
endbr64
push rbp
movsxd rbp, esi
mov esi, 4; size
push rbx
mov rbx, rdi
lea edi, [rbp+1]
movsxd rdi, edi; nmemb
sub rsp, 8
call _calloc
mov rdi, rax; ptr
test ebp, ebp
jle short loc_11F0
mov r8, rbx
lea rax, [rbx+rbp*4]
mov ebx, 0FFFFFFFFh
nop dword ptr [rax+... | long long func0(int *a1, int a2)
{
char *v3; // rdi
int *v4; // r8
int *v5; // rax
int v6; // ebx
int *v7; // rsi
int v8; // ecx
int v9; // edx
int v10; // esi
v3 = (char *)calloc(a2 + 1, 4uLL);
if ( a2 <= 0 )
{
free(v3);
return 0xFFFFFFFFLL;
}
else
{
v4 = a1;
v5 = &a1[a2];... | func0:
ENDBR64
PUSH RBP
MOVSXD RBP,ESI
MOV ESI,0x4
PUSH RBX
MOV RBX,RDI
LEA EDI,[RBP + 0x1]
MOVSXD RDI,EDI
SUB RSP,0x8
CALL 0x00101070
MOV RDI,RAX
TEST EBP,EBP
JLE 0x001011f0
MOV R8,RBX
LEA RAX,[RBX + RBP*0x4]
MOV EBX,0xffffffff
NOP dword ptr [RAX + RAX*0x1]
LAB_001011b8:
MOVSXD RDX,dword ptr [R8]
LEA RSI,[RDI + RDX*0x... | int func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
int iVar5;
int iVar6;
__ptr = calloc((long)(param_2 + 1),4);
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar6 = -1;
do {
iVar3 = *param_1;
piVar2 = (int *)((long)__ptr + (... |
935 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int *lst, int size) {
int *freq = (int *)calloc(size + 1, sizeof(int));
int max = -1;
for (int i = 0; i < size; i++) {
freq[lst[i]]++;
if ((freq[lst[i]] >= lst[i]) && (lst[i] > max)) {
max = lst[i];
}
}
free(freq);
return max;
} | #include <assert.h>
int main() {
int arr1[] = {5, 5, 5, 5, 1};
int arr2[] = {4, 1, 4, 1, 4, 4};
int arr3[] = {3, 3};
int arr4[] = {8, 8, 8, 8, 8, 8, 8, 8};
int arr5[] = {2, 3, 3, 2, 2};
int arr6[] = {2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1};
int arr7[] = {3, 2, 8,... | O3 | c | func0:
endbr64
push %r12
mov %esi,%r12d
push %rbx
mov %rdi,%rbx
lea 0x1(%rsi),%edi
mov $0x4,%esi
movslq %edi,%rdi
sub $0x8,%rsp
callq 1070 <calloc@plt>
mov %rax,%r8
test %r12d,%r12d
jle 1200 <func0+0x80>
lea -0x1(%r12),%eax
mov %rbx,%rdi
mov $0xffffffff,%r12d
lea 0x4(%rbx,%rax,4)... | func0:
endbr64
push rbp
movsxd rbp, esi
mov esi, 4; size
push rbx
mov rbx, rdi
lea edi, [rbp+1]
movsxd rdi, edi; nmemb
sub rsp, 8
call _calloc
mov rdi, rax; ptr
test ebp, ebp
jle short loc_11F0
mov r8, rbx
lea rax, [rbx+rbp*4]
mov ebx, 0FFFFFFFFh
nop dword ptr [rax+... | long long func0(int *a1, int a2)
{
char *v3; // rdi
int *v4; // r8
int *v5; // rax
int v6; // ebx
int *v7; // rsi
int v8; // ecx
int v9; // edx
int v10; // esi
v3 = (char *)calloc(a2 + 1, 4uLL);
if ( a2 <= 0 )
{
free(v3);
return 0xFFFFFFFFLL;
}
else
{
v4 = a1;
v5 = &a1[a2];... | func0:
ENDBR64
PUSH RBP
MOVSXD RBP,ESI
MOV ESI,0x4
PUSH RBX
MOV RBX,RDI
LEA EDI,[RBP + 0x1]
MOVSXD RDI,EDI
SUB RSP,0x8
CALL 0x00101070
MOV RDI,RAX
TEST EBP,EBP
JLE 0x001011f0
MOV R8,RBX
LEA RAX,[RBX + RBP*0x4]
MOV EBX,0xffffffff
NOP dword ptr [RAX + RAX*0x1]
LAB_001011b8:
MOVSXD RDX,dword ptr [R8]
LEA RSI,[RDI + RDX*0x... | int func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
void *__ptr;
int iVar5;
int iVar6;
__ptr = calloc((long)(param_2 + 1),4);
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar6 = -1;
do {
iVar3 = *param_1;
piVar2 = (int *)((long)__ptr + (... |
936 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *lst, int size, int *out) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (lst[i] > lst[j]) {
int temp = lst[i];
lst[i] = lst[j];
lst[j] = temp;
}
}
}
int l = 0, r = size - ... | #include <assert.h>
#include <string.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int a1[] = {1, 2, 3, 4};
int e1[] = {1, 4, 2, 3};
int out1[4];
func0(a1, 4, out1);
assert(issame(e1, out1, 4));... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 1239 <func0+0xd0>
mov -0x18(%rbp),%eax
add $0x1,%eax
mov %eax,-0x14(%rbp)
jmpq 1229 <func0+0xc0>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x2... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_18], 0
jmp loc_1239
loc_1188:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_14], eax
jmp loc_1229
loc_1196:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*... | long long func0(long long a1, int a2, long long a3)
{
int v3; // eax
_DWORD *v4; // rcx
int v5; // eax
_DWORD *v6; // rcx
int v7; // eax
long long result; // rax
int i; // [rsp+20h] [rbp-18h]
int j; // [rsp+24h] [rbp-14h]
unsigned int v11; // [rsp+28h] [rbp-10h]
int v12; // [rsp+2Ch] [rbp-Ch]
int... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101239
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00101229
LAB_00101196:
MOV EAX,dword ptr [RBP... | void func0(long param_1,int param_2,long param_3)
{
int iVar1;
int4 uVar2;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
for (local_20 = 0; local_1c = local_20, local_20 < param_2 + -1; local_20 = local_20 + 1) {
while (local_1c = local_1c + 1, local_1c < param_2) {
... |
937 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *lst, int size, int *out) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (lst[i] > lst[j]) {
int temp = lst[i];
lst[i] = lst[j];
lst[j] = temp;
}
}
}
int l = 0, r = size - ... | #include <assert.h>
#include <string.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int a1[] = {1, 2, 3, 4};
int e1[] = {1, 4, 2, 3};
int out1[4];
func0(a1, 4, out1);
assert(issame(e1, out1, 4));... | O1 | c | func0:
endbr64
push %rbx
lea -0x1(%rsi),%r10d
test %r10d,%r10d
jle 11bc <func0+0x53>
mov %rdi,%r9
lea -0x2(%rsi),%ebx
add $0x2,%rbx
mov $0x1,%r11d
jmp 11b2 <func0+0x49>
add $0x1,%rax
cmp %eax,%esi
jle 11a5 <func0+0x3c>
mov (%r9),%ecx
mov (%rdi,%rax,4),%r8d
cmp %r8d,%ecx
jle ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
mov r10, rdi
mov r11, rdx
lea r9d, [rsi-1]
test r9d, r9d
jle short loc_11D8
mov ebx, esi
lea rsi, [rdi+4]
mov ebp, ebx
mov r8d, 1
mov r13d, r9d
lea r12, [rdi+8]
jmp short loc_11BF
loc_1199:
add rax, 4
cmp ... | void func0(long long a1, int a2, long long a3)
{
int v4; // r9d
_DWORD *v6; // rsi
long long v7; // r8
_DWORD *v8; // rax
int v9; // edx
long long v10; // rdx
long long v11; // rax
v4 = a2 - 1;
if ( a2 - 1 <= 0 )
{
if ( v4 < 0 )
return;
}
else
{
v6 = (_DWORD *)(a1 + 4);
v7 ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R10,RDI
MOV R11,RDX
LEA R9D,[RSI + -0x1]
TEST R9D,R9D
JLE 0x001011d8
MOV EBX,ESI
LEA RSI,[RDI + 0x4]
MOV EBP,EBX
MOV R8D,0x1
MOV R13D,R9D
LEA R12,[RDI + 0x8]
JMP 0x001011bf
LAB_00101199:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011b2
LAB_001011a2:
MOV EDX,dword ptr [RSI + -... | void func0(long param_1,uint param_2,long param_3)
{
int iVar1;
int *piVar2;
long lVar3;
long lVar4;
int *piVar5;
ulong uVar6;
int iVar7;
iVar7 = param_2 - 1;
if (iVar7 < 1) {
if (iVar7 < 0) {
return;
}
}
else {
piVar5 = (int *)(param_1 + 4);
uVar6 = 1;
do {
if ... |
938 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *lst, int size, int *out) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (lst[i] > lst[j]) {
int temp = lst[i];
lst[i] = lst[j];
lst[j] = temp;
}
}
}
int l = 0, r = size - ... | #include <assert.h>
#include <string.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int a1[] = {1, 2, 3, 4};
int e1[] = {1, 4, 2, 3};
int out1[4];
func0(a1, 4, out1);
assert(issame(e1, out1, 4));... | O2 | c | func0:
endbr64
lea -0x1(%rsi),%r11d
push %rbx
test %r11d,%r11d
jle 17c5 <func0+0xa5>
lea -0x2(%rsi),%ebx
mov %rdi,%r9
mov $0x1,%r10d
add $0x2,%rbx
nopw 0x0(%rax,%rax,1)
mov %r10,%rax
cmp %r10d,%esi
jle 176a <func0+0x4a>
mov (%r9),%ecx
mov (%rdi,%rax,4),%r8d
cmp %r8d,%ecx
jle ... | func0:
endbr64
push r12
mov r11, rdi
push rbp
mov ebp, esi
lea r10d, [rbp-1]
push rbx
test r10d, r10d
jle loc_1696
mov rbx, rbp
add rdi, 4
mov r9d, 1
lea r12, [r11+8]
nop dword ptr [rax+rax+00h]
loc_1620:
cmp ebx, r9d
jle short loc_1657
mov eax, r10d
sub e... | void func0(long long a1, int a2, _DWORD *a3)
{
int v4; // r10d
_DWORD *v5; // rdi
long long v6; // r9
_DWORD *v7; // rax
int v8; // ecx
long long v9; // rax
long long v10; // rcx
int v11; // esi
v4 = a2 - 1;
if ( a2 - 1 <= 0 )
{
if ( a2 != 1 )
return;
}
else
{
v5 = (_DWORD *)... | func0:
ENDBR64
PUSH R12
MOV R11,RDI
PUSH RBP
MOV EBP,ESI
LEA R10D,[RBP + -0x1]
PUSH RBX
TEST R10D,R10D
JLE 0x00101696
MOV RBX,RBP
ADD RDI,0x4
MOV R9D,0x1
LEA R12,[R11 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101620:
CMP EBX,R9D
JLE 0x00101657
MOV EAX,R10D
SUB EAX,R9D
LEA RAX,[R9 + RAX*0x1 + -0x1]
LEA R8,[R12 + RAX*0x... | void func0(long param_1,uint param_2,int4 *param_3)
{
long lVar1;
int iVar2;
int *piVar3;
long lVar4;
long lVar5;
int *piVar6;
ulong uVar7;
int iVar8;
iVar8 = param_2 - 1;
if (iVar8 < 1) {
if (iVar8 != 0) {
return;
}
}
else {
piVar6 = (int *)(param_1 + 4);
uVar7 = 1;
... |
939 | func0 | #include <stdio.h>
#include <stdlib.h>
| void func0(int *lst, int size, int *out) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (lst[i] > lst[j]) {
int temp = lst[i];
lst[i] = lst[j];
lst[j] = temp;
}
}
}
int l = 0, r = size - ... | #include <assert.h>
#include <string.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int a1[] = {1, 2, 3, 4};
int e1[] = {1, 4, 2, 3};
int out1[4];
func0(a1, 4, out1);
assert(issame(e1, out1, 4));... | O3 | c | func0:
endbr64
lea -0x1(%rsi),%r11d
push %rbx
test %r11d,%r11d
jle 17fe <func0+0xae>
lea -0x2(%rsi),%ebx
mov %rdi,%r9
mov $0x1,%r10d
add $0x2,%rbx
nopw 0x0(%rax,%rax,1)
mov %r10,%rax
cmp %r10d,%esi
jle 179a <func0+0x4a>
mov (%r9),%ecx
mov (%rdi,%rax,4),%r8d
cmp %r8d,%ecx
jle ... | func0:
endbr64
push r12
mov r11, rdi
push rbp
mov ebp, esi
lea r10d, [rbp-1]
push rbx
test r10d, r10d
jle loc_16B6
mov rbx, rbp
add rdi, 4
mov r9d, 1
lea r12, [r11+8]
nop dword ptr [rax+rax+00h]
loc_1640:
cmp ebx, r9d
jle short loc_1677
mov eax, r10d
sub e... | void func0(long long a1, int a2, _DWORD *a3)
{
int v4; // r10d
_DWORD *v5; // rdi
long long v6; // r9
_DWORD *v7; // rax
int v8; // ecx
long long v9; // rax
long long v10; // rcx
int v11; // esi
v4 = a2 - 1;
if ( a2 - 1 <= 0 )
{
if ( a2 != 1 )
return;
}
else
{
v5 = (_DWORD *)... | func0:
ENDBR64
PUSH R12
MOV R11,RDI
PUSH RBP
MOV EBP,ESI
LEA R10D,[RBP + -0x1]
PUSH RBX
TEST R10D,R10D
JLE 0x001016b6
MOV RBX,RBP
ADD RDI,0x4
MOV R9D,0x1
LEA R12,[R11 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101640:
CMP EBX,R9D
JLE 0x00101677
MOV EAX,R10D
SUB EAX,R9D
LEA RAX,[R9 + RAX*0x1 + -0x1]
LEA R8,[R12 + RAX*0x... | void func0(long param_1,uint param_2,int4 *param_3)
{
long lVar1;
int iVar2;
int *piVar3;
long lVar4;
long lVar5;
int *piVar6;
ulong uVar7;
int iVar8;
iVar8 = param_2 - 1;
if (iVar8 < 1) {
if (iVar8 != 0) {
return;
}
}
else {
piVar6 = (int *)(param_1 + 4);
uVar7 = 1;
... |
940 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float b, float c) {
if (a + b <= c || a + c <= b || b + c <= a) return -1;
float s = (a + b + c) / 2;
float area = sqrtf(s * (s - a) * (s - b) * (s - c));
return roundf(area * 100) / 100;
} | #include <stdio.h>
#include <math.h>
#include <assert.h>
int main() {
assert(fabs(func0(3, 4, 5) - 6.00) < 0.01);
assert(fabs(func0(1, 2, 10) + 1) < 0.01);
assert(fabs(func0(4, 8, 5) - 8.18) < 0.01);
assert(fabs(func0(2, 2, 2) - 1.73) < 0.01);
assert(fabs(func0(1, 2, 3) + 1) < 0.01);
assert(fab... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movss %xmm0,-0x14(%rbp)
movss %xmm1,-0x18(%rbp)
movss %xmm2,-0x1c(%rbp)
movss -0x14(%rbp),%xmm0
movaps %xmm0,%xmm1
addss -0x18(%rbp),%xmm1
movss -0x1c(%rbp),%xmm0
comiss %xmm1,%xmm0
jae 11e9 <func0+0x60>
movss -0x14(%rbp),%xmm0
movaps %xmm0,%xmm1
a... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movss [rbp+var_14], xmm0
movss [rbp+var_18], xmm1
movss [rbp+var_1C], xmm2
movss xmm0, [rbp+var_14]
movaps xmm1, xmm0
addss xmm1, [rbp+var_18]
movss xmm0, [rbp+var_1C]
comiss xmm0, xmm1
jnb short loc_11E9
movss xmm0, [rbp+var_14]
movaps x... | float func0(float a1, float a2, float a3)
{
__m128i v4; // xmm0
__m128i v5; // xmm1
__m128i v6; // xmm0
__m128i v7; // xmm1
__m128i v8; // xmm0
unsigned int v11; // [rsp+18h] [rbp-8h]
float v12; // [rsp+1Ch] [rbp-4h]
if ( a3 >= (float)(a1 + a2) || a2 >= (float)(a1 + a3) || a1 >= (float)(a2 + a3) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSS dword ptr [RBP + -0x14],XMM0
MOVSS dword ptr [RBP + -0x18],XMM1
MOVSS dword ptr [RBP + -0x1c],XMM2
MOVSS XMM0,dword ptr [RBP + -0x14]
MOVAPS XMM1,XMM0
ADDSS XMM1,dword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RBP + -0x1c]
COMISS XMM0,XMM1
JNC 0x001011e9
MOVSS XMM0,d... | void func0(float param_1,float param_2,float param_3)
{
float fVar1;
if (((param_3 < param_1 + param_2) && (param_2 < param_1 + param_3)) &&
(param_1 < param_2 + param_3)) {
fVar1 = (param_1 + param_2 + param_3) / DAT_0010218c;
fVar1 = sqrtf((fVar1 - param_1) * fVar1 * (fVar1 - param_2) * (fVar1 - ... |
941 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float b, float c) {
if (a + b <= c || a + c <= b || b + c <= a) return -1;
float s = (a + b + c) / 2;
float area = sqrtf(s * (s - a) * (s - b) * (s - c));
return roundf(area * 100) / 100;
} | #include <stdio.h>
#include <math.h>
#include <assert.h>
int main() {
assert(fabs(func0(3, 4, 5) - 6.00) < 0.01);
assert(fabs(func0(1, 2, 10) + 1) < 0.01);
assert(fabs(func0(4, 8, 5) - 8.18) < 0.01);
assert(fabs(func0(2, 2, 2) - 1.73) < 0.01);
assert(fabs(func0(1, 2, 3) + 1) < 0.01);
assert(fab... | O1 | c | func0:
endbr64
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
comiss %xmm3,%xmm2
jae 1235 <func0+0xac>
movss 0xffb(%rip),%xmm4
movaps %xmm0,%xmm5
addss %xmm2,%xmm5
comiss %xmm5,%xmm1
jae 123d <func0+0xb4>
movaps %xmm1,%xmm5
addss %xmm2,%xmm5
comiss %xmm5,%xmm0
jae 123d <func0+0xb4>
sub $0x18,%rsp
addss %xmm2,%xm... | func0:
endbr64
movaps xmm4, xmm0
addss xmm4, xmm1
comiss xmm2, xmm4
jnb short loc_1216
movaps xmm3, xmm0
addss xmm0, xmm2
comiss xmm1, xmm0
jnb short loc_121F
movss xmm0, cs:dword_2004
movaps xmm5, xmm1
addss xmm5, xmm2
comiss xmm3, xmm5
jb short loc_11BA
retn
loc_11BA:
sub rsp, 8
addss ... | float func0(float a1, float a2, float a3)
{
float v3; // xmm4_4
float result; // xmm0_4
float v6; // xmm0_4
float v7; // xmm0_4
v3 = a1 + a2;
if ( a3 >= (float)(a1 + a2) )
return -1.0;
if ( a2 >= (float)(a1 + a3) )
return -1.0;
result = -1.0;
if ( a1 < (float)(a2 + a3) )
{
v6 = (float)... | func0:
ENDBR64
MOVAPS XMM4,XMM0
ADDSS XMM4,XMM1
COMISS XMM2,XMM4
JNC 0x00101216
MOVAPS XMM3,XMM0
ADDSS XMM0,XMM2
COMISS XMM1,XMM0
JNC 0x0010121f
MOVSS XMM0,dword ptr [0x00102004]
MOVAPS XMM5,XMM1
ADDSS XMM5,XMM2
COMISS XMM3,XMM5
JC 0x001011ba
RET
LAB_001011ba:
SUB RSP,0x8
ADDSS XMM4,XMM2
MULSS XMM4,dword ptr [0x0010200... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2,float param_3)
{
float fVar1;
if (param_1 + param_2 <= param_3) {
return DAT_00102004;
}
if (param_2 < param_1 + param_3) {
if (param_2 + param_3 <= param_1) {
return D... |
942 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float b, float c) {
if (a + b <= c || a + c <= b || b + c <= a) return -1;
float s = (a + b + c) / 2;
float area = sqrtf(s * (s - a) * (s - b) * (s - c));
return roundf(area * 100) / 100;
} | #include <stdio.h>
#include <math.h>
#include <assert.h>
int main() {
assert(fabs(func0(3, 4, 5) - 6.00) < 0.01);
assert(fabs(func0(1, 2, 10) + 1) < 0.01);
assert(fabs(func0(4, 8, 5) - 8.18) < 0.01);
assert(fabs(func0(2, 2, 2) - 1.73) < 0.01);
assert(fabs(func0(1, 2, 3) + 1) < 0.01);
assert(fab... | O2 | c | func0:
endbr64
movaps %xmm0,%xmm3
movss 0xe75(%rip),%xmm5
addss %xmm1,%xmm3
comiss %xmm3,%xmm2
jae 1220 <func0+0xa0>
movaps %xmm0,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm1
jae 1220 <func0+0xa0>
movaps %xmm1,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm0
jae 1220 <func0+0xa0>
addss %xmm2,%xmm3
sub $0x18,%r... | func0:
endbr64
movaps xmm4, xmm0
addss xmm4, xmm1
comiss xmm2, xmm4
jnb loc_1590
movaps xmm3, xmm0
addss xmm0, xmm2
comiss xmm1, xmm0
movss xmm0, cs:dword_2004
jnb short locret_1580
movaps xmm5, xmm1
addss xmm5, xmm2
comiss xmm3, xmm5
jnb short locret_1588
sub rsp, 8
addss xmm4, xmm2
mul... | float func0(float a1, float a2, float a3)
{
float v3; // xmm4_4
bool v5; // cf
float result; // xmm0_4
float v7; // xmm0_4
float v8; // xmm0_4
v3 = a1 + a2;
if ( a3 >= (float)(a1 + a2) )
return -1.0;
v5 = a2 < (float)(a1 + a3);
result = -1.0;
if ( v5 && a1 < (float)(a2 + a3) )
{
v7 = (fl... | func0:
ENDBR64
MOVAPS XMM4,XMM0
ADDSS XMM4,XMM1
COMISS XMM2,XMM4
JNC 0x00101590
MOVAPS XMM3,XMM0
ADDSS XMM0,XMM2
COMISS XMM1,XMM0
MOVSS XMM0,dword ptr [0x00102004]
JNC 0x00101580
MOVAPS XMM5,XMM1
ADDSS XMM5,XMM2
COMISS XMM3,XMM5
JNC 0x00101588
SUB RSP,0x8
ADDSS XMM4,XMM2
MULSS XMM4,dword ptr [0x00102008]
MOVAPS XMM0,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2,float param_3)
{
float fVar1;
if (param_1 + param_2 <= param_3) {
return DAT_00102004;
}
if (param_2 < param_1 + param_3) {
if (param_1 < param_2 + param_3) {
fVar1 = (... |
943 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float a, float b, float c) {
if (a + b <= c || a + c <= b || b + c <= a) return -1;
float s = (a + b + c) / 2;
float area = sqrtf(s * (s - a) * (s - b) * (s - c));
return roundf(area * 100) / 100;
} | #include <stdio.h>
#include <math.h>
#include <assert.h>
int main() {
assert(fabs(func0(3, 4, 5) - 6.00) < 0.01);
assert(fabs(func0(1, 2, 10) + 1) < 0.01);
assert(fabs(func0(4, 8, 5) - 8.18) < 0.01);
assert(fabs(func0(2, 2, 2) - 1.73) < 0.01);
assert(fabs(func0(1, 2, 3) + 1) < 0.01);
assert(fab... | O3 | c | func0:
endbr64
movaps %xmm0,%xmm3
movss 0xe75(%rip),%xmm5
addss %xmm1,%xmm3
comiss %xmm3,%xmm2
jae 1220 <func0+0xa0>
movaps %xmm0,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm1
jae 1220 <func0+0xa0>
movaps %xmm1,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm0
jae 1220 <func0+0xa0>
addss %xmm2,%xmm3
sub $0x18,%r... | func0:
endbr64
movaps xmm4, xmm0
addss xmm4, xmm1
comiss xmm2, xmm4
jnb loc_1220
movaps xmm3, xmm0
addss xmm0, xmm2
comiss xmm1, xmm0
movss xmm0, cs:dword_2004
jnb short locret_1210
movaps xmm5, xmm1
addss xmm5, xmm2
comiss xmm3, xmm5
jnb short locret_1218
sub rsp, 8
addss xmm4, xmm2
mul... | float func0(float a1, float a2, float a3)
{
float v3; // xmm4_4
bool v5; // cf
float result; // xmm0_4
float v7; // xmm0_4
float v8; // xmm0_4
v3 = a1 + a2;
if ( a3 >= (float)(a1 + a2) )
return -1.0;
v5 = a2 < (float)(a1 + a3);
result = -1.0;
if ( v5 && a1 < (float)(a2 + a3) )
{
v7 = (fl... | func0:
ENDBR64
MOVAPS XMM4,XMM0
ADDSS XMM4,XMM1
COMISS XMM2,XMM4
JNC 0x00101220
MOVAPS XMM3,XMM0
ADDSS XMM0,XMM2
COMISS XMM1,XMM0
MOVSS XMM0,dword ptr [0x00102004]
JNC 0x00101210
MOVAPS XMM5,XMM1
ADDSS XMM5,XMM2
COMISS XMM3,XMM5
JNC 0x00101218
SUB RSP,0x8
ADDSS XMM4,XMM2
MULSS XMM4,dword ptr [0x00102008]
MOVAPS XMM0,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2,float param_3)
{
float fVar1;
if (param_1 + param_2 <= param_3) {
return DAT_00102004;
}
if (param_2 < param_1 + param_3) {
if (param_1 < param_2 + param_3) {
fVar1 = (... |
944 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int q[], int size, int w) {
int sum = 0;
for (int i = 0; i < size / 2; i++) {
if (q[i] != q[size - 1 - i]) return false;
sum += q[i] + q[size - 1 - i];
}
if (size % 2 == 1) sum += q[size / 2];
return sum <= w;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {3, 2, 3};
assert(func0(test1, 3, 9) == true);
int test2[] = {1, 2};
assert(func0(test2, 2, 5) == false);
int test3[] = {3};
assert(func0(test3, 1, 5) == true);
int test4[] = {3, 2, 3};
assert(func0(test4, 3, 1) == fal... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1226 <func0+0x9d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x1c(%rbp),%... | 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_8], 0
mov [rbp+var_4], 0
jmp short loc_1226
loc_11AB:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mo... | bool func0(long long a1, int a2, int a3)
{
int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2 / 2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) != *(_DWORD *)(4LL * (a2 - 1 - i) + a1) )
return 0;
v4 += *(_DWORD *)(4LL * i + a1) + *(_DWORD *)(4LL * (a2 - 1 - 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 + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101226
LAB_001011ab:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX... | int4 func0(long param_1,int param_2,int param_3)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while( true ) {
if (param_2 / 2 <= local_c) {
if (param_2 % 2 == 1) {
local_10 = local_10 + *(int *)(param_1 + (long)(param_2 / 2) * 4);
}
return CONCAT31((int3)((uint)loc... |
945 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int q[], int size, int w) {
int sum = 0;
for (int i = 0; i < size / 2; i++) {
if (q[i] != q[size - 1 - i]) return false;
sum += q[i] + q[size - 1 - i];
}
if (size % 2 == 1) sum += q[size / 2];
return sum <= w;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {3, 2, 3};
assert(func0(test1, 3, 9) == true);
int test2[] = {1, 2};
assert(func0(test2, 2, 5) == false);
int test3[] = {3};
assert(func0(test3, 1, 5) == true);
int test4[] = {3, 2, 3};
assert(func0(test4, 3, 1) == fal... | O1 | c | func0:
endbr64
push %rbx
mov %esi,%ebx
shr $0x1f,%ebx
add %esi,%ebx
sar %ebx
cmp $0x1,%esi
jle 11e9 <func0+0x60>
mov %ebx,%r11d
movslq %esi,%rax
lea (%rdi,%rax,4),%r8
mov $0x0,%ecx
mov $0x0,%r10d
mov (%rdi,%rcx,4),%eax
mov -0x4(%r8),%r9d
cmp %r9d,%eax
jne 11fa <func0+0x71>
ad... | func0:
endbr64
mov r9, rdi
mov r10d, esi
mov r11d, edx
mov r8d, esi
shr r8d, 1Fh
add r8d, esi
sar r8d, 1
cmp esi, 1
jle short loc_11F2
movsxd rax, esi
lea rcx, [rdi+rax*4]
mov edx, 0
mov edi, 0
loc_11B9:
mov eax, [r9+rdx*4]
mov esi, [rcx-4]
cmp eax, esi
jnz ... | bool func0(long long a1, int a2, int a3)
{
int v6; // r8d
long long v7; // rcx
long long v8; // rdx
int v9; // edi
int v10; // eax
int v11; // esi
v6 = a2 / 2;
if ( a2 <= 1 )
{
v9 = 0;
LABEL_5:
if ( a2 % 2 == 1 )
v9 += *(_DWORD *)(a1 + 4LL * v6);
return v9 <= a3;
}
else
{
... | func0:
ENDBR64
MOV R9,RDI
MOV R10D,ESI
MOV R11D,EDX
MOV R8D,ESI
SHR R8D,0x1f
ADD R8D,ESI
SAR R8D,0x1
CMP ESI,0x1
JLE 0x001011f2
MOVSXD RAX,ESI
LEA RCX,[RDI + RAX*0x4]
MOV EDX,0x0
MOV EDI,0x0
LAB_001011b9:
MOV EAX,dword ptr [R9 + RDX*0x4]
MOV ESI,dword ptr [RCX + -0x4]
CMP EAX,ESI
JNZ 0x00101202
ADD EAX,ESI
ADD EDI,EAX
... | bool func0(long param_1,int param_2,int param_3)
{
int iVar1;
long lVar2;
long lVar3;
int iVar4;
if (param_2 < 2) {
iVar4 = 0;
}
else {
lVar2 = param_1 + (long)param_2 * 4;
lVar3 = 0;
iVar4 = 0;
do {
iVar1 = *(int *)(param_1 + lVar3 * 4);
if (iVar1 != *(int *)(lVar2 + -... |
946 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int q[], int size, int w) {
int sum = 0;
for (int i = 0; i < size / 2; i++) {
if (q[i] != q[size - 1 - i]) return false;
sum += q[i] + q[size - 1 - i];
}
if (size % 2 == 1) sum += q[size / 2];
return sum <= w;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {3, 2, 3};
assert(func0(test1, 3, 9) == true);
int test2[] = {1, 2};
assert(func0(test2, 2, 5) == false);
int test3[] = {3};
assert(func0(test3, 1, 5) == true);
int test4[] = {3, 2, 3};
assert(func0(test4, 3, 1) == fal... | O2 | c | func0:
endbr64
mov %esi,%r10d
shr $0x1f,%r10d
add %esi,%r10d
sar %r10d
cmp $0x1,%esi
jle 11bd <func0+0x4d>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
cltq
lea (%rdi,%rax,4),%rcx
xor %eax,%eax
jmp 11b1 <func0+0x41>
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%rax
lea (%r9,%r8,2),%r9d
sub $0x4,%... | func0:
endbr64
mov r8d, esi
mov r9, rdi
mov r10d, edx
shr r8d, 1Fh
add r8d, esi
sar r8d, 1
cmp esi, 1
jle short loc_13CB
lea eax, [rsi-1]
cdqe
lea rdx, [rdi+rax*4]
xor eax, eax
xor edi, edi
jmp short loc_13C0
loc_13B0:
add rax, 1
lea edi, [rdi+rcx*2]
sub r... | bool func0(long long a1, int a2, int a3)
{
int v5; // r8d
_DWORD *v6; // rdx
long long v7; // rax
int v8; // edi
int v9; // ecx
v5 = a2 / 2;
if ( a2 <= 1 )
{
v8 = 0;
LABEL_7:
if ( a2 % 2 == 1 )
v8 += *(_DWORD *)(a1 + 4LL * v5);
return v8 <= a3;
}
else
{
v6 = (_DWORD *)(a1 +... | func0:
ENDBR64
MOV R8D,ESI
MOV R9,RDI
MOV R10D,EDX
SHR R8D,0x1f
ADD R8D,ESI
SAR R8D,0x1
CMP ESI,0x1
JLE 0x001013cb
LEA EAX,[RSI + -0x1]
CDQE
LEA RDX,[RDI + RAX*0x4]
XOR EAX,EAX
XOR EDI,EDI
JMP 0x001013c0
LAB_001013b0:
ADD RAX,0x1
LEA EDI,[RDI + RCX*0x2]
SUB RDX,0x4
CMP R8D,EAX
JLE 0x001013d0
LAB_001013c0:
MOV ECX,dword... | bool func0(long param_1,int param_2,int param_3)
{
int iVar1;
long lVar2;
int *piVar3;
int iVar4;
if (param_2 < 2) {
iVar4 = 0;
}
else {
piVar3 = (int *)(param_1 + (long)(param_2 + -1) * 4);
lVar2 = 0;
iVar4 = 0;
do {
iVar1 = *(int *)(param_1 + lVar2 * 4);
if (iVar1 != ... |
947 | func0 | #include <stdio.h>
#include <stdbool.h>
| bool func0(int q[], int size, int w) {
int sum = 0;
for (int i = 0; i < size / 2; i++) {
if (q[i] != q[size - 1 - i]) return false;
sum += q[i] + q[size - 1 - i];
}
if (size % 2 == 1) sum += q[size / 2];
return sum <= w;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {3, 2, 3};
assert(func0(test1, 3, 9) == true);
int test2[] = {1, 2};
assert(func0(test2, 2, 5) == false);
int test3[] = {3};
assert(func0(test3, 1, 5) == true);
int test4[] = {3, 2, 3};
assert(func0(test4, 3, 1) == fal... | O3 | c | func0:
endbr64
mov %esi,%r10d
shr $0x1f,%r10d
add %esi,%r10d
sar %r10d
cmp $0x1,%esi
jle 11bd <func0+0x4d>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
cltq
lea (%rdi,%rax,4),%rcx
xor %eax,%eax
jmp 11b1 <func0+0x41>
nopw %cs:0x0(%rax,%rax,1)
add $0x1,%rax
lea (%r9,%r8,2),%r9d
sub $0x4,%... | func0:
endbr64
mov r8d, esi
mov r9, rdi
mov r10d, edx
shr r8d, 1Fh
add r8d, esi
sar r8d, 1
cmp esi, 1
jle short loc_11BB
lea eax, [rsi-1]
cdqe
lea rdx, [rdi+rax*4]
xor eax, eax
xor edi, edi
jmp short loc_11B0
loc_11A0:
add rax, 1
lea edi, [rdi+rcx*2]
sub r... | bool func0(long long a1, int a2, int a3)
{
int v5; // r8d
_DWORD *v6; // rdx
long long v7; // rax
int v8; // edi
int v9; // ecx
v5 = a2 / 2;
if ( a2 <= 1 )
{
v8 = 0;
LABEL_7:
if ( a2 % 2 == 1 )
v8 += *(_DWORD *)(a1 + 4LL * v5);
return v8 <= a3;
}
else
{
v6 = (_DWORD *)(a1 +... | func0:
ENDBR64
MOV R8D,ESI
MOV R9,RDI
MOV R10D,EDX
SHR R8D,0x1f
ADD R8D,ESI
SAR R8D,0x1
CMP ESI,0x1
JLE 0x001011bb
LEA EAX,[RSI + -0x1]
CDQE
LEA RDX,[RDI + RAX*0x4]
XOR EAX,EAX
XOR EDI,EDI
JMP 0x001011b0
LAB_001011a0:
ADD RAX,0x1
LEA EDI,[RDI + RCX*0x2]
SUB RDX,0x4
CMP R8D,EAX
JLE 0x001011c0
LAB_001011b0:
MOV ECX,dword... | bool func0(long param_1,int param_2,int param_3)
{
int iVar1;
long lVar2;
int *piVar3;
int iVar4;
if (param_2 < 2) {
iVar4 = 0;
}
else {
piVar3 = (int *)(param_1 + (long)(param_2 + -1) * 4);
lVar2 = 0;
iVar4 = 0;
do {
iVar1 = *(int *)(param_1 + lVar2 * 4);
if (iVar1 != ... |
948 | func0 | #include <stdio.h>
| int func0(int arr[], int size) {
int out = 0;
for (int i = 0; i < size / 2; i++) {
if (arr[i] != arr[size - 1 - i]) {
out++;
}
}
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 5, 4, 7, 9, 6};
assert(func0(test1, 8) == 4);
int test2[] = {1, 2, 3, 4, 3, 2, 2};
assert(func0(test2, 7) == 1);
int test3[] = {1, 4, 2};
assert(func0(test3, 3) == 1);
int test4[] = {1, 4, 4, 2};
assert(func0... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c6 <func0+0x5d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x1c(%rbp),%eax
sub $0x1,%eax
sub... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C6
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_1C]
su... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2 / 2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) != *(_DWORD *)(4LL * (a2 - 1 - i) + a1) )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c6
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2 / 2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) !=
*(int *)(param_1 + (long)((param_2 + -1) - local_c) * 4)) {
local_10 = local_10 + 1;
}
}
r... |
949 | func0 | #include <stdio.h>
| int func0(int arr[], int size) {
int out = 0;
for (int i = 0; i < size / 2; i++) {
if (arr[i] != arr[size - 1 - i]) {
out++;
}
}
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 5, 4, 7, 9, 6};
assert(func0(test1, 8) == 4);
int test2[] = {1, 2, 3, 4, 3, 2, 2};
assert(func0(test2, 7) == 1);
int test3[] = {1, 4, 2};
assert(func0(test3, 3) == 1);
int test4[] = {1, 4, 4, 2};
assert(func0... | O1 | c | func0:
endbr64
mov %esi,%r8d
shr $0x1f,%r8d
add %esi,%r8d
sar %r8d
cmp $0x1,%esi
jle 11b0 <func0+0x47>
movslq %esi,%rsi
lea (%rdi,%rsi,4),%rdx
mov $0x0,%eax
mov $0x0,%ecx
mov -0x4(%rdx),%esi
cmp %esi,(%rdi,%rax,4)
setne %sil
movzbl %sil,%esi
add %esi,%ecx
add $0x1,%rax
sub $0x... | func0:
endbr64
mov ecx, esi
shr ecx, 1Fh
add ecx, esi
sar ecx, 1
cmp esi, 1
jle short loc_11A9
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
mov eax, 0
mov esi, 0
jmp short loc_119A
loc_118E:
add rax, 1
sub rdx, 4
cmp ecx, eax
jle short loc_11AE
loc_119A:
mov r8d, [rd... | long long func0(long long a1, int a2)
{
int v2; // ecx
long long v3; // rdx
long long v4; // rax
unsigned int v5; // esi
v2 = a2 / 2;
if ( a2 <= 1 )
{
return 0;
}
else
{
v3 = a1 + 4LL * a2;
v4 = 0LL;
v5 = 0;
do
{
if ( *(_DWORD *)(a1 + 4 * v4) != *(_DWORD *)(v3 - 4) )
... | func0:
ENDBR64
MOV ECX,ESI
SHR ECX,0x1f
ADD ECX,ESI
SAR ECX,0x1
CMP ESI,0x1
JLE 0x001011a9
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
MOV EAX,0x0
MOV ESI,0x0
JMP 0x0010119a
LAB_0010118e:
ADD RAX,0x1
SUB RDX,0x4
CMP ECX,EAX
JLE 0x001011ae
LAB_0010119a:
MOV R8D,dword ptr [RDX + -0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JZ 0x00... | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
if (param_2 < 2) {
iVar3 = 0;
}
else {
lVar2 = param_1 + (long)param_2 * 4;
lVar1 = 0;
iVar3 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) != *(int *)(lVar2 + -4)) {
iVar3 = iVar3 + 1;
}
... |
950 | func0 | #include <stdio.h>
| int func0(int arr[], int size) {
int out = 0;
for (int i = 0; i < size / 2; i++) {
if (arr[i] != arr[size - 1 - i]) {
out++;
}
}
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 5, 4, 7, 9, 6};
assert(func0(test1, 8) == 4);
int test2[] = {1, 2, 3, 4, 3, 2, 2};
assert(func0(test2, 7) == 1);
int test3[] = {1, 4, 2};
assert(func0(test3, 3) == 1);
int test4[] = {1, 4, 4, 2};
assert(func0... | O2 | c | func0:
endbr64
mov %esi,%r9d
shr $0x1f,%r9d
add %esi,%r9d
sar %r9d
cmp $0x1,%esi
jle 1190 <func0+0x50>
sub $0x1,%esi
xor %eax,%eax
xor %r8d,%r8d
movslq %esi,%rsi
lea (%rdi,%rsi,4),%rdx
nopl (%rax)
mov (%rdx),%esi
xor %ecx,%ecx
cmp %esi,(%rdi,%rax,4)
setne %cl
add $0x1,%rax
s... | func0:
endbr64
mov r8d, esi
shr r8d, 1Fh
add r8d, esi
sar r8d, 1
cmp esi, 1
jle short loc_1450
sub esi, 1
xor eax, eax
xor ecx, ecx
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
nop dword ptr [rax+00h]
loc_1428:
mov esi, [rdx]
cmp [rdi+rax*4], esi
setnz sil
add rax, 1
s... | long long func0(long long a1, int a2)
{
int v2; // r8d
long long v3; // rax
unsigned int v4; // ecx
_DWORD *v5; // rdx
bool v6; // si
v2 = a2 / 2;
if ( a2 <= 1 )
return 0LL;
v3 = 0LL;
v4 = 0;
v5 = (_DWORD *)(a1 + 4LL * (a2 - 1));
do
{
v6 = *(_DWORD *)(a1 + 4 * v3++) != *v5--;
v4 +=... | func0:
ENDBR64
MOV R8D,ESI
SHR R8D,0x1f
ADD R8D,ESI
SAR R8D,0x1
CMP ESI,0x1
JLE 0x00101450
SUB ESI,0x1
XOR EAX,EAX
XOR ECX,ECX
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101428:
MOV ESI,dword ptr [RDX]
CMP dword ptr [RDI + RAX*0x4],ESI
SETNZ SIL
ADD RAX,0x1
SUB RDX,0x4
MOVZX ESI,SIL
ADD ECX,ESI
CM... | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
long lVar3;
int iVar4;
int *piVar5;
if (1 < param_2) {
lVar3 = 0;
iVar4 = 0;
piVar5 = (int *)(param_1 + (long)(param_2 + -1) * 4);
do {
iVar2 = *piVar5;
lVar1 = lVar3 * 4;
lVar3 = lVar3 + 1;
piVar5 = piV... |
951 | func0 | #include <stdio.h>
| int func0(int arr[], int size) {
int out = 0;
for (int i = 0; i < size / 2; i++) {
if (arr[i] != arr[size - 1 - i]) {
out++;
}
}
return out;
} | #include <stdio.h>
#include <assert.h>
int main() {
int test1[] = {1, 2, 3, 5, 4, 7, 9, 6};
assert(func0(test1, 8) == 4);
int test2[] = {1, 2, 3, 4, 3, 2, 2};
assert(func0(test2, 7) == 1);
int test3[] = {1, 4, 2};
assert(func0(test3, 3) == 1);
int test4[] = {1, 4, 4, 2};
assert(func0... | O3 | c | func0:
endbr64
mov %esi,%r8d
shr $0x1f,%r8d
add %esi,%r8d
sar %r8d
cmp $0x1,%esi
jle 1238 <func0+0xf8>
lea -0x1(%rsi),%r9d
cmp $0x7,%esi
jle 1241 <func0+0x101>
mov %r8d,%ecx
movslq %r9d,%rdx
pxor %xmm1,%xmm1
mov %rdi,%rax
shr $0x2,%ecx
lea -0xc(%rdi,%rdx,4),%rdx
pcmpeqd %xmm2,%x... | func0:
endbr64
mov r8d, esi
shr r8d, 1Fh
add r8d, esi
sar r8d, 1
cmp esi, 1
jle loc_1240
lea r9d, [rsi-1]
cmp esi, 7
jle loc_1249
mov ecx, r8d
movsxd rsi, esi
pxor xmm1, xmm1
mov rax, rdi
shr ecx, 2
lea rdx, [rdi+rsi*4-10h]
movdqa xmm2, xmm1
shl rcx, 4
add ... | long long func0(const __m128i *a1, int a2)
{
int v2; // r8d
int v3; // r9d
__m128i v4; // xmm1
const __m128i *v5; // rax
const __m128i *v6; // rdx
__m128i v7; // xmm3
__m128i v8; // xmm4
signed int v9; // edx
__m128i v10; // xmm1
long long result; // rax
long long v12; // r10
int v13; // edx
... | func0:
ENDBR64
MOV R8D,ESI
SHR R8D,0x1f
ADD R8D,ESI
SAR R8D,0x1
CMP ESI,0x1
JLE 0x00101240
LEA R9D,[RSI + -0x1]
CMP ESI,0x7
JLE 0x00101249
MOV ECX,R8D
MOVSXD RSI,ESI
PXOR XMM1,XMM1
MOV RAX,RDI
SHR ECX,0x2
LEA RDX,[RDI + RSI*0x4 + -0x10]
MOVDQA XMM2,XMM1
SHL RCX,0x4
ADD RCX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101190:... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int iVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int *piVar10;
uint uVar11;
int *piVar12;
uint uVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
uVar13 = param_2 / 2;
if (p... |
952 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char** arr1, int n1, char** arr2, int n2){
int i, sum1 = 0, sum2 = 0;
for(i=0; i<n1; i++){
sum1 += strlen(arr1[i]);
}
for(i=0; i<n2; i++){
sum2 += strlen(arr2[i]);
}
if(sum1 < sum2){
return arr1;
}
else if(sum1 > sum2){
return arr2;
}
else{
return arr1;
}
} | int issame(char** arr1, int n1, char** arr2, int n2){
int i;
if(n1 != n2) return 0;
for(i=0; i<n1; i++){
if(strcmp(arr1[i], arr2[i]) != 0) return 0;
}
return 1;
}
// Main function
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(){
char* arr1[] = {};
char* arr2[] = {};
int ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11e7 <func0+0x5e>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
mov [rbp+var_C], 0
jmp short loc_11E7
loc_11BA:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8... | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+24h] [rbp-Ch]
int j; // [rsp+24h] [rbp-Ch]
int v9; // [rsp+28h] [rbp-8h]
int v10; // [rsp+2Ch] [rbp-4h]
v9 = 0;
v10 = 0;
for ( i = 0; i < a2; ++i )
v9 += strlen(*(const char **)(8LL * i + a1));
for ( j = 0; j < a4; ++j )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011e7
LAB_001011ba:
MOV EAX,dword ptr [RB... | long func0(long param_1,int param_2,long param_3,int param_4)
{
size_t sVar1;
int local_14;
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
sVar1 = strlen(*(char **)(param_1 + (long)local_14 * 8));
local_10 = local_10 + (i... |
953 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char** arr1, int n1, char** arr2, int n2){
int i, sum1 = 0, sum2 = 0;
for(i=0; i<n1; i++){
sum1 += strlen(arr1[i]);
}
for(i=0; i<n2; i++){
sum2 += strlen(arr2[i]);
}
if(sum1 < sum2){
return arr1;
}
else if(sum1 > sum2){
return arr2;
}
else{
return arr1;
}
} | int issame(char** arr1, int n1, char** arr2, int n2){
int i;
if(n1 != n2) return 0;
for(i=0; i<n1; i++){
if(strcmp(arr1[i], arr2[i]) != 0) return 0;
}
return 1;
}
// Main function
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(){
char* arr1[] = {};
char* arr2[] = {};
int ... | O1 | c | func0:
endbr64
push %rbx
mov %rdi,%r10
mov %ecx,%r11d
test %esi,%esi
jle 11dc <func0+0x93>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rbx
mov $0x0,%r9d
mov $0xffffffffffffffff,%rsi
mov $0x0,%eax
mov (%r8),%rdi
mov %rsi,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r14, rdi
mov r13, rdx
mov r12d, ecx
test esi, esi
jle short loc_11F1
mov rbx, rdi
movsxd rsi, esi
lea r15, [rdi+rsi*8]
mov ebp, 0
loc_1197:
mov rdi, [rbx]; s
call _strlen
add ... | const char ** func0(const char **a1, int a2, const char **a3, int a4)
{
const char **v6; // rbx
int v7; // ebp
long long v8; // rbx
int v9; // r15d
const char **result; // rax
if ( a2 <= 0 )
{
v7 = 0;
if ( a4 <= 0 )
return a1;
goto LABEL_5;
}
v6 = a1;
v7 = 0;
do
v7 += strlen... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R14,RDI
MOV R13,RDX
MOV R12D,ECX
TEST ESI,ESI
JLE 0x001011f1
MOV RBX,RDI
MOVSXD RSI,ESI
LEA R15,[RDI + RSI*0x8]
MOV EBP,0x0
LAB_00101197:
MOV RDI,qword ptr [RBX]
CALL 0x00101060
ADD EBP,EAX
ADD RBX,0x8
CMP RBX,R15
JNZ 0x00101197
TEST R... | int8 * func0(int8 *param_1,int param_2,int8 *param_3,int param_4)
{
size_t sVar1;
int8 *puVar2;
long lVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
iVar4 = 0;
if (param_4 < 1) {
return param_1;
}
}
else {
iVar4 = 0;
puVar2 = param_1;
do {
sVar1 = strlen((char *)*... |
954 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char** arr1, int n1, char** arr2, int n2){
int i, sum1 = 0, sum2 = 0;
for(i=0; i<n1; i++){
sum1 += strlen(arr1[i]);
}
for(i=0; i<n2; i++){
sum2 += strlen(arr2[i]);
}
if(sum1 < sum2){
return arr1;
}
else if(sum1 > sum2){
return arr2;
}
else{
return arr1;
}
} | int issame(char** arr1, int n1, char** arr2, int n2){
int i;
if(n1 != n2) return 0;
for(i=0; i<n1; i++){
if(strcmp(arr1[i], arr2[i]) != 0) return 0;
}
return 1;
}
// Main function
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(){
char* arr1[] = {};
char* arr2[] = {};
int ... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
mov %rdx,%r13
push %r12
mov %ecx,%r12d
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1200 <func0+0x80>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %ebp,%ebp
lea 0x8(%rdi,%rax,8),%r15
nopl 0x0(%rax)
mov (%rbx),%rdi
... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
mov r13d, ecx
push r12
mov r12, rdx
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1200
movsxd rsi, esi
mov rbx, rdi
xor ebp, ebp
lea r15, [rdi+rsi*8]
nop dword ptr [rax+rax+00h]
loc_11B0:
mov ... | const char ** func0(const char **a1, int a2, long long a3, int a4)
{
const char **v7; // rbx
int v8; // ebp
const char **v9; // r15
const char *v10; // rdi
long long v11; // rbx
int v12; // r15d
const char *v13; // rdi
if ( a2 <= 0 )
{
v8 = 0;
if ( a4 <= 0 )
return a1;
}
else
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101200
MOVSXD RSI,ESI
MOV RBX,RDI
XOR EBP,EBP
LEA R15,[RDI + RSI*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001011b0:
MOV RDI,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101060
ADD EBP,EAX
CMP... | int8 * func0(int8 *param_1,int param_2,int8 *param_3,int param_4)
{
char *__s;
size_t sVar1;
int8 *puVar2;
long lVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
iVar4 = 0;
if (param_4 < 1) {
return param_1;
}
}
else {
iVar4 = 0;
puVar2 = param_1;
do {
__s = (char... |
955 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(char** arr1, int n1, char** arr2, int n2){
int i, sum1 = 0, sum2 = 0;
for(i=0; i<n1; i++){
sum1 += strlen(arr1[i]);
}
for(i=0; i<n2; i++){
sum2 += strlen(arr2[i]);
}
if(sum1 < sum2){
return arr1;
}
else if(sum1 > sum2){
return arr2;
}
else{
return arr1;
}
} | int issame(char** arr1, int n1, char** arr2, int n2){
int i;
if(n1 != n2) return 0;
for(i=0; i<n1; i++){
if(strcmp(arr1[i], arr2[i]) != 0) return 0;
}
return 1;
}
// Main function
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(){
char* arr1[] = {};
char* arr2[] = {};
int ... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
mov %rdx,%r13
push %r12
mov %ecx,%r12d
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1200 <func0+0x80>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %ebp,%ebp
lea 0x8(%rdi,%rax,8),%r15
nopl 0x0(%rax)
mov (%rbx),%rdi
... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
mov r13d, ecx
push r12
mov r12, rdx
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1200
movsxd rsi, esi
mov rbx, rdi
xor ebp, ebp
lea r15, [rdi+rsi*8]
nop dword ptr [rax+rax+00h]
loc_11B0:
mov ... | const char ** func0(const char **a1, int a2, long long a3, int a4)
{
const char **v7; // rbx
int v8; // ebp
const char **v9; // r15
const char *v10; // rdi
long long v11; // rbx
int v12; // r15d
const char *v13; // rdi
if ( a2 <= 0 )
{
v8 = 0;
if ( a4 <= 0 )
return a1;
}
else
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101200
MOVSXD RSI,ESI
MOV RBX,RDI
XOR EBP,EBP
LEA R15,[RDI + RSI*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001011b0:
MOV RDI,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101060
ADD EBP,EAX
CMP... | int8 * func0(int8 *param_1,int param_2,int8 *param_3,int param_4)
{
char *__s;
size_t sVar1;
int8 *puVar2;
long lVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
iVar4 = 0;
if (param_4 < 1) {
return param_1;
}
}
else {
iVar4 = 0;
puVar2 = param_1;
do {
__s = (char... |
956 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a) {
if (a < 2) return 0;
int num = 0;
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
a = a / i;
num++;
}
}
if (a > 1) num++;
return num == 3;
} | #include <assert.h>
int main() {
assert(func0(5) == 0);
assert(func0(30) == 1);
assert(func0(8) == 1); // 8 = 2 * 2 * 2
assert(func0(10) == 0);
assert(func0(125) == 1); // 125 = 5 * 5 * 5 (three times the same prime)
assert(func0(3 * 5 * 7) == 1);
assert(func0(3 * 6 * 7) == 0);
assert(f... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x1,-0x14(%rbp)
jg 1181 <func0+0x18>
mov $0x0,%eax
jmp 11cf <func0+0x66>
movl $0x0,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 11b0 <func0+0x47>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %eax,-0x14(%rbp)
addl $0x1,-0x8(%r... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 1
jg short loc_1181
mov eax, 0
jmp short loc_11CF
loc_1181:
mov [rbp+var_8], 0
mov [rbp+var_4], 2
jmp short loc_11B0
loc_1191:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov [rbp+var_14], eax
... | _BOOL8 func0(int a1)
{
int v2; // [rsp+0h] [rbp-14h]
int v3; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = a1;
if ( a1 <= 1 )
return 0LL;
v3 = 0;
for ( i = 2; v2 >= i * i; ++i )
{
while ( !(v2 % i) )
{
v2 /= i;
++v3;
}
}
if ( v2 > 1 )
++v3;
return v3 == 3... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x1
JG 0x00101181
MOV EAX,0x0
JMP 0x001011cf
LAB_00101181:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001011b0
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV dword ... | bool func0(int param_1)
{
bool bVar1;
int4 local_1c;
int4 local_10;
int4 local_c;
if (param_1 < 2) {
bVar1 = false;
}
else {
local_10 = 0;
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_1c = loca... |
957 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a) {
if (a < 2) return 0;
int num = 0;
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
a = a / i;
num++;
}
}
if (a > 1) num++;
return num == 3;
} | #include <assert.h>
int main() {
assert(func0(5) == 0);
assert(func0(30) == 1);
assert(func0(8) == 1); // 8 = 2 * 2 * 2
assert(func0(10) == 0);
assert(func0(125) == 1); // 125 = 5 * 5 * 5 (three times the same prime)
assert(func0(3 * 5 * 7) == 1);
assert(func0(3 * 6 * 7) == 0);
assert(f... | O1 | c | func0:
endbr64
mov $0x0,%eax
cmp $0x1,%edi
jle 11c1 <func0+0x58>
mov $0x2,%ecx
mov $0x0,%esi
cmp $0x3,%edi
jg 11a5 <func0+0x3c>
jmp 11b5 <func0+0x4c>
mov %edi,%eax
cltd
idiv %ecx
mov %eax,%edi
add $0x1,%esi
cltd
idiv %ecx
test %edx,%edx
je 1188 <func0+0x1f>
add $0x1,%ecx
m... | func0:
endbr64
mov eax, 0
cmp edi, 1
jle short locret_11C1
mov ecx, 2
mov esi, 0
cmp edi, 3
jg short loc_11A5
jmp short loc_11B5
loc_1188:
mov eax, edi
cdq
idiv ecx
mov edi, eax
add esi, 1
cdq
idiv ecx
test edx, edx
jz short loc_1188
loc_1199:
add ecx, 1
mo... | _BOOL8 func0(int a1)
{
_BOOL8 result; // rax
int v2; // ecx
int v3; // esi
result = 0LL;
if ( a1 > 1 )
{
v2 = 2;
v3 = 0;
if ( a1 <= 3 )
goto LABEL_9;
do
{
for ( ; !(a1 % v2); ++v3 )
a1 /= v2;
++v2;
}
while ( v2 * v2 <= a1 );
if ( a1 > 1 )
LABEL_9:
... | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,0x1
JLE 0x001011c1
MOV ECX,0x2
MOV ESI,0x0
CMP EDI,0x3
JG 0x001011a5
JMP 0x001011b5
LAB_00101188:
MOV EAX,EDI
CDQ
IDIV ECX
MOV EDI,EAX
ADD ESI,0x1
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101188
LAB_00101199:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x001011b0
LAB_001011a5:
MOV EAX... | bool func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 < 2) {
return false;
}
iVar2 = 2;
iVar4 = 0;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while (iVar3 == 0) {
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
... |
958 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a) {
if (a < 2) return 0;
int num = 0;
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
a = a / i;
num++;
}
}
if (a > 1) num++;
return num == 3;
} | #include <assert.h>
int main() {
assert(func0(5) == 0);
assert(func0(30) == 1);
assert(func0(8) == 1); // 8 = 2 * 2 * 2
assert(func0(10) == 0);
assert(func0(125) == 1); // 125 = 5 * 5 * 5 (three times the same prime)
assert(func0(3 * 5 * 7) == 1);
assert(func0(3 * 6 * 7) == 0);
assert(f... | O2 | c | func0:
endbr64
cmp $0x1,%edi
jle 13e0 <func0+0x10>
jmp 1380 <func0.part.0>
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
xor esi, esi
mov ecx, 2
cmp edi, 3
jle short loc_13BD
nop dword ptr [rax+00h]
loc_1390:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_13B1
nop dword ptr [rax+00000000h]
loc_13A0:
mov eax, edi
add esi, 1
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
... | _BOOL8 func0_part_0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 0;
v2 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v2) )
{
do
{
++v1;
v3 = (a1 / v2) >> 31;
a1 /= v2;
}
while ( !(unsigned int)(__SPAIR64__(v3, a1) %... | func0.part.0:
XOR ESI,ESI
MOV ECX,0x2
CMP EDI,0x3
JLE 0x001013bd
NOP dword ptr [RAX]
LAB_00101390:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001013b1
NOP dword ptr [RAX]
LAB_001013a0:
MOV EAX,EDI
ADD ESI,0x1
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JZ 0x001013a0
LAB_001013b1:
ADD ECX,0x1
MOV EAX,ECX
IMUL EA... | bool func0_part_0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = 0;
iVar2 = 2;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while (iVar3 == 0) {
iVar4 = iVar4 + 1;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
iVar... |
959 | func0 | #include <stdio.h>
#include <stdlib.h>
| int func0(int a) {
if (a < 2) return 0;
int num = 0;
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
a = a / i;
num++;
}
}
if (a > 1) num++;
return num == 3;
} | #include <assert.h>
int main() {
assert(func0(5) == 0);
assert(func0(30) == 1);
assert(func0(8) == 1); // 8 = 2 * 2 * 2
assert(func0(10) == 0);
assert(func0(125) == 1); // 125 = 5 * 5 * 5 (three times the same prime)
assert(func0(3 * 5 * 7) == 1);
assert(func0(3 * 6 * 7) == 0);
assert(f... | O3 | c | func0:
endbr64
xor %eax,%eax
cmp $0x1,%edi
jle 142a <func0+0x5a>
xor %esi,%esi
mov $0x2,%ecx
cmp $0x3,%edi
jle 1434 <func0+0x64>
nopw 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1411 <func0+0x41>
nopl 0x0(%rax)
mov %edi,%eax
add $0x1,%esi
cltd
idiv %ecx
cl... | func0_part_0:
xor esi, esi
mov ecx, 2
cmp edi, 3
jle short loc_13BD
nop dword ptr [rax+00h]
loc_1390:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_13B1
nop dword ptr [rax+00000000h]
loc_13A0:
mov eax, edi
add esi, 1
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
... | _BOOL8 func0_part_0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 0;
v2 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v2) )
{
do
{
++v1;
v3 = (a1 / v2) >> 31;
a1 /= v2;
}
while ( !(unsigned int)(__SPAIR64__(v3, a1) %... | func0.part.0:
XOR ESI,ESI
MOV ECX,0x2
CMP EDI,0x3
JLE 0x001013bd
NOP dword ptr [RAX]
LAB_00101390:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001013b1
NOP dword ptr [RAX]
LAB_001013a0:
MOV EAX,EDI
ADD ESI,0x1
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JZ 0x001013a0
LAB_001013b1:
ADD ECX,0x1
MOV EAX,ECX
IMUL EA... | bool func0_part_0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = 0;
iVar2 = 2;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while (iVar3 == 0) {
iVar4 = iVar4 + 1;
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
iVar... |
960 | func0 | #include <stdio.h>
| int func0(int x, int n) {
int p = 1, count = 0;
while (p <= x && count < 100) {
if (p == x) return 1;
p = p * n; count += 1;
}
return 0;
} | #include <assert.h>
int main() {
assert(func0(1, 4) == 1);
assert(func0(2, 2) == 1);
assert(func0(8, 2) == 1);
assert(func0(3, 2) == 0);
assert(func0(3, 1) == 0);
assert(func0(5, 3) == 0);
assert(func0(16, 2) == 1);
assert(func0(143214, 16) == 0);
assert(func0(4, 2) == 1);
asser... | 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 1184 <func0+0x3b>
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jne 1176 <func0+0x2d>
mov $0x1,%eax
jmp 1197 <func0+0x4e>
mov -0x8(%rbp),%eax
imul -0x18(%rbp),%... | 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_1184
loc_1167:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jnz short loc_1176
mov eax, 1
jmp short loc_1197
loc_1176:
mov eax, [rbp+var_8... | long long func0(int a1, int a2)
{
int v3; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v3 = 1;
for ( i = 0; v3 <= a1 && i <= 99; ++i )
{
if ( v3 == a1 )
return 1LL;
v3 *= a2;
}
return 0LL;
} | 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 0x00101184
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x00101176
MOV EAX,0x1
JMP 0x00101197
LAB_00101176:
MOV EAX,dw... | int8 func0(int param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 1;
for (local_c = 0; (local_10 <= param_1 && (local_c < 100)); local_c = local_c + 1) {
if (local_10 == param_1) {
return 1;
}
local_10 = local_10 * param_2;
}
return 0;
} |
961 | func0 | #include <stdio.h>
| int func0(int x, int n) {
int p = 1, count = 0;
while (p <= x && count < 100) {
if (p == x) return 1;
p = p * n; count += 1;
}
return 0;
} | #include <assert.h>
int main() {
assert(func0(1, 4) == 1);
assert(func0(2, 2) == 1);
assert(func0(8, 2) == 1);
assert(func0(3, 2) == 0);
assert(func0(3, 1) == 0);
assert(func0(5, 3) == 0);
assert(func0(16, 2) == 1);
assert(func0(143214, 16) == 0);
assert(func0(4, 2) == 1);
asser... | O1 | c | func0:
endbr64
test %edi,%edi
jle 117f <func0+0x36>
cmp $0x1,%edi
je 1185 <func0+0x3c>
mov $0x0,%edx
mov $0x1,%eax
imul %esi,%eax
add $0x1,%edx
cmp %eax,%edi
jl 1179 <func0+0x30>
cmp $0x63,%edx
jg 1179 <func0+0x30>
cmp %eax,%edi
jne 1160 <func0+0x17>
mov $0x1,%eax
retq
mov ... | func0:
endbr64
test edi, edi
jle short loc_117F
cmp edi, 1
jz short loc_1185
mov ecx, 0
mov edx, 1
loc_1160:
imul edx, esi
add ecx, 1
cmp edi, edx
jl short loc_1179
cmp ecx, 63h ; 'c'
jg short loc_1179
cmp edi, edx
jnz short loc_1160
mov eax, 1
retn
loc_1179:... | long long func0(int a1, int a2)
{
int v2; // ecx
int v3; // edx
if ( a1 <= 0 )
return 0LL;
if ( a1 == 1 )
return 1LL;
v2 = 0;
v3 = 1;
while ( 1 )
{
v3 *= a2;
++v2;
if ( a1 < v3 || v2 > 99 )
break;
if ( a1 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010117f
CMP EDI,0x1
JZ 0x00101185
MOV ECX,0x0
MOV EDX,0x1
LAB_00101160:
IMUL EDX,ESI
ADD ECX,0x1
CMP EDI,EDX
JL 0x00101179
CMP ECX,0x63
JG 0x00101179
CMP EDI,EDX
JNZ 0x00101160
MOV EAX,0x1
RET
LAB_00101179:
MOV EAX,0x0
RET
LAB_0010117f:
MOV EAX,0x0
RET
LAB_00101185:
MOV EAX,EDI
RET | int8 func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
return 0;
}
if (param_1 != 1) {
iVar1 = 0;
iVar2 = 1;
while( true ) {
iVar2 = iVar2 * param_2;
iVar1 = iVar1 + 1;
if ((param_1 < iVar2) || (99 < iVar1)) break;
if (param_1 == iVar2) {
... |
962 | func0 | #include <stdio.h>
| int func0(int x, int n) {
int p = 1, count = 0;
while (p <= x && count < 100) {
if (p == x) return 1;
p = p * n; count += 1;
}
return 0;
} | #include <assert.h>
int main() {
assert(func0(1, 4) == 1);
assert(func0(2, 2) == 1);
assert(func0(8, 2) == 1);
assert(func0(3, 2) == 0);
assert(func0(3, 1) == 0);
assert(func0(5, 3) == 0);
assert(func0(16, 2) == 1);
assert(func0(143214, 16) == 0);
assert(func0(4, 2) == 1);
asser... | O2 | c | func0:
endbr64
test %edi,%edi
jle 1228 <func0+0x38>
cmp $0x1,%edi
je 121b <func0+0x2b>
xor %edx,%edx
mov $0x1,%eax
nopl 0x0(%rax)
imul %esi,%eax
add $0x1,%edx
cmp %eax,%edi
jl 1228 <func0+0x38>
cmp $0x63,%edx
jg 1228 <func0+0x38>
cmp %eax,%edi
jne 1208 <func0+0x18>
mov $0... | func0:
endbr64
test edi, edi
jle short loc_1268
cmp edi, 1
jz short loc_125B
xor edx, edx
mov eax, 1
nop dword ptr [rax+00h]
loc_1248:
imul eax, esi
add edx, 1
cmp edi, eax
jl short loc_1268
cmp edx, 63h ; 'c'
jg short loc_1268
cmp edi, eax
jnz short loc_1248... | long long func0(int a1, int a2)
{
int v2; // edx
int v3; // eax
if ( a1 > 0 )
{
if ( a1 == 1 )
return 1LL;
v2 = 0;
v3 = 1;
while ( 1 )
{
v3 *= a2;
++v2;
if ( a1 < v3 || v2 > 99 )
break;
if ( a1 == v3 )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101268
CMP EDI,0x1
JZ 0x0010125b
XOR EDX,EDX
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101248:
IMUL EAX,ESI
ADD EDX,0x1
CMP EDI,EAX
JL 0x00101268
CMP EDX,0x63
JG 0x00101268
CMP EDI,EAX
JNZ 0x00101248
LAB_0010125b:
MOV EAX,0x1
RET
LAB_00101268:
XOR EAX,EAX
RET | int8 func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
return 0;
}
if (param_1 != 1) {
iVar2 = 0;
iVar1 = 1;
do {
iVar1 = iVar1 * param_2;
iVar2 = iVar2 + 1;
if (param_1 < iVar1) {
return 0;
}
if (99 < iVar2) {
return 0;... |
963 | func0 | #include <stdio.h>
| int func0(int x, int n) {
int p = 1, count = 0;
while (p <= x && count < 100) {
if (p == x) return 1;
p = p * n; count += 1;
}
return 0;
} | #include <assert.h>
int main() {
assert(func0(1, 4) == 1);
assert(func0(2, 2) == 1);
assert(func0(8, 2) == 1);
assert(func0(3, 2) == 0);
assert(func0(3, 1) == 0);
assert(func0(5, 3) == 0);
assert(func0(16, 2) == 1);
assert(func0(143214, 16) == 0);
assert(func0(4, 2) == 1);
asser... | O3 | c | func0:
endbr64
test %edi,%edi
jle 1228 <func0+0x38>
cmp $0x1,%edi
je 121b <func0+0x2b>
xor %edx,%edx
mov $0x1,%eax
nopl 0x0(%rax)
imul %esi,%eax
add $0x1,%edx
cmp %eax,%edi
jl 1228 <func0+0x38>
cmp $0x63,%edx
jg 1228 <func0+0x38>
cmp %eax,%edi
jne 1208 <func0+0x18>
mov $0... | func0:
endbr64
test edi, edi
jle short loc_1228
cmp edi, 1
jz short loc_121B
xor edx, edx
mov eax, 1
nop dword ptr [rax+00h]
loc_1208:
imul eax, esi
add edx, 1
cmp edi, eax
jl short loc_1228
cmp edx, 63h ; 'c'
jg short loc_1228
cmp edi, eax
jnz short loc_1208... | long long func0(int a1, int a2)
{
int v2; // edx
int v3; // eax
if ( a1 > 0 )
{
if ( a1 == 1 )
return 1LL;
v2 = 0;
v3 = 1;
while ( 1 )
{
v3 *= a2;
++v2;
if ( a1 < v3 || v2 > 99 )
break;
if ( a1 == v3 )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101228
CMP EDI,0x1
JZ 0x0010121b
XOR EDX,EDX
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101208:
IMUL EAX,ESI
ADD EDX,0x1
CMP EDI,EAX
JL 0x00101228
CMP EDX,0x63
JG 0x00101228
CMP EDI,EAX
JNZ 0x00101208
LAB_0010121b:
MOV EAX,0x1
RET
LAB_00101228:
XOR EAX,EAX
RET | int8 func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
return 0;
}
if (param_1 != 1) {
iVar2 = 0;
iVar1 = 1;
do {
iVar1 = iVar1 * param_2;
iVar2 = iVar2 + 1;
if (param_1 < iVar1) {
return 0;
}
if (99 < iVar2) {
return 0;... |
964 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| int func0(int a) {
for (int i = 0; i * i * i <= abs(a); i++)
if (i * i * i == abs(a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 0);
assert(func0(-1) == 1);
assert(func0(64) == 1);
assert(func0(180) == 0);
assert(func0(1000) == 1);
assert(func0(0) == 1);
assert(func0(1729) == 0);
printf("All tests passed.\n");
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a3 <func0+0x3a>
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
mov %eax,%ecx
mov -0x14(%rbp),%eax
cltd
mov %edx,%eax
xor -0x14(%rbp),%eax
sub %edx,%eax
cmp %eax,%ecx
jne 119f <func0+0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
jmp short loc_11A2
loc_117D:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
mov edx, eax
mov eax, [rbp+var_14]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp edx, eax
jnz short loc_119... | long long func0(int a1)
{
int v1; // eax
int v3; // eax
int i; // [rsp+10h] [rbp-4h]
for ( i = 0; ; ++i )
{
v3 = a1;
if ( a1 <= 0 )
v3 = -a1;
if ( i * i * i > v3 )
break;
v1 = a1;
if ( a1 <= 0 )
v1 = -a1;
if ( i * i * i == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a2
LAB_0010117d:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP EDX,EAX
JNZ 0x0010119e
MOV EAX,0x... | int8 func0(int param_1)
{
int iVar1;
int local_c;
local_c = 0;
while( true ) {
iVar1 = param_1;
if (param_1 < 1) {
iVar1 = -param_1;
}
if (iVar1 < local_c * local_c * local_c) {
return 0;
}
iVar1 = param_1;
if (param_1 < 1) {
iVar1 = -param_1;
}
if (loca... |
965 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| int func0(int a) {
for (int i = 0; i * i * i <= abs(a); i++)
if (i * i * i == abs(a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 0);
assert(func0(-1) == 1);
assert(func0(64) == 1);
assert(func0(180) == 0);
assert(func0(1000) == 1);
assert(func0(0) == 1);
assert(func0(1729) == 0);
printf("All tests passed.\n");
return 0;
} | O1 | c | func0:
endbr64
mov %edi,%eax
sar $0x1f,%eax
mov %eax,%ecx
xor %edi,%ecx
sub %eax,%ecx
test %edi,%edi
je 119f <func0+0x36>
mov $0x1,%edx
mov $0x1,%eax
cmp %eax,%ecx
je 11a5 <func0+0x3c>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
imul %edx,%eax
cmp %ecx,%eax
jle 1186 <fun... | func0:
endbr64
mov ecx, edi
neg ecx
cmovs ecx, edi
test edi, edi
jz short loc_119A
mov eax, 0
loc_117D:
add eax, 1
mov edx, eax
imul edx, eax
imul edx, eax
cmp edx, ecx
jg short loc_1194
jnz short loc_117D
mov eax, 1
retn
loc_1194:
mov eax, 0
retn
loc_119A:
mov ... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
int v3; // edx
v1 = -a1;
if ( a1 > 0 )
v1 = a1;
if ( !a1 )
return 1LL;
v2 = 0;
while ( 1 )
{
++v2;
v3 = v2 * v2 * v2;
if ( v3 > v1 )
break;
if ( v3 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV ECX,EDI
NEG ECX
CMOVS ECX,EDI
TEST EDI,EDI
JZ 0x0010119a
MOV EAX,0x0
LAB_0010117d:
ADD EAX,0x1
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
CMP EDX,ECX
JG 0x00101194
JNZ 0x0010117d
MOV EAX,0x1
RET
LAB_00101194:
MOV EAX,0x0
RET
LAB_0010119a:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = -param_1;
if (0 < param_1) {
iVar2 = param_1;
}
if (param_1 != 0) {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
iVar3 = iVar1 * iVar1 * iVar1;
if (iVar2 < iVar3) {
return 0;
}
} while (iVar3 != iV... |
966 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| int func0(int a) {
for (int i = 0; i * i * i <= abs(a); i++)
if (i * i * i == abs(a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 0);
assert(func0(-1) == 1);
assert(func0(64) == 1);
assert(func0(180) == 0);
assert(func0(1000) == 1);
assert(func0(0) == 1);
assert(func0(1729) == 0);
printf("All tests passed.\n");
return 0;
} | O2 | c | func0:
endbr64
mov %edi,%eax
sar $0x1f,%eax
mov %eax,%ecx
xor %edi,%ecx
sub %eax,%ecx
test %edi,%edi
je 12d0 <func0+0x40>
mov $0x1,%edx
mov $0x1,%eax
nopl (%rax)
cmp %eax,%ecx
je 12d0 <func0+0x40>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
imul %edx,%eax
cmp %ecx,%eax
jl... | func0:
endbr64
mov ecx, edi
neg ecx
cmovs ecx, edi
test edi, edi
jz short loc_12B0
xor eax, eax
jmp short loc_129A
loc_1298:
jz short loc_12B0
loc_129A:
add eax, 1
mov edx, eax
imul edx, eax
imul edx, eax
cmp edx, ecx
jle short loc_1298
xor eax, eax
retn
loc_12B0... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
int v3; // edx
v1 = -a1;
if ( a1 > 0 )
v1 = a1;
if ( !a1 )
return 1LL;
v2 = 0;
while ( 1 )
{
++v2;
v3 = v2 * v2 * v2;
if ( v3 > v1 )
break;
if ( v3 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV ECX,EDI
NEG ECX
CMOVS ECX,EDI
TEST EDI,EDI
JZ 0x001012b0
XOR EAX,EAX
JMP 0x0010129a
LAB_00101298:
JZ 0x001012b0
LAB_0010129a:
ADD EAX,0x1
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
CMP EDX,ECX
JLE 0x00101298
XOR EAX,EAX
RET
LAB_001012b0:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = -param_1;
if (0 < param_1) {
iVar2 = param_1;
}
if (param_1 != 0) {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
iVar3 = iVar1 * iVar1 * iVar1;
if (iVar2 < iVar3) {
return 0;
}
} while (iVar3 != iV... |
967 | func0 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
| int func0(int a) {
for (int i = 0; i * i * i <= abs(a); i++)
if (i * i * i == abs(a)) return 1;
return 0;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 0);
assert(func0(-1) == 1);
assert(func0(64) == 1);
assert(func0(180) == 0);
assert(func0(1000) == 1);
assert(func0(0) == 1);
assert(func0(1729) == 0);
printf("All tests passed.\n");
return 0;
} | O3 | c | func0:
endbr64
mov %edi,%eax
sar $0x1f,%eax
mov %eax,%ecx
xor %edi,%ecx
sub %eax,%ecx
test %edi,%edi
je 12d0 <func0+0x40>
mov $0x1,%edx
mov $0x1,%eax
nopl (%rax)
cmp %eax,%ecx
je 12d0 <func0+0x40>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
imul %edx,%eax
cmp %ecx,%eax
jl... | func0:
endbr64
mov ecx, edi
neg ecx
cmovs ecx, edi
test edi, edi
jz short loc_12B0
xor eax, eax
jmp short loc_129A
loc_1298:
jz short loc_12B0
loc_129A:
add eax, 1
mov edx, eax
imul edx, eax
imul edx, eax
cmp edx, ecx
jle short loc_1298
xor eax, eax
retn
loc_12B0... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
int v3; // edx
v1 = -a1;
if ( a1 > 0 )
v1 = a1;
if ( !a1 )
return 1LL;
v2 = 0;
while ( 1 )
{
++v2;
v3 = v2 * v2 * v2;
if ( v3 > v1 )
break;
if ( v3 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV ECX,EDI
NEG ECX
CMOVS ECX,EDI
TEST EDI,EDI
JZ 0x001012b0
XOR EAX,EAX
JMP 0x0010129a
LAB_00101298:
JZ 0x001012b0
LAB_0010129a:
ADD EAX,0x1
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
CMP EDX,ECX
JLE 0x00101298
XOR EAX,EAX
RET
LAB_001012b0:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = -param_1;
if (0 < param_1) {
iVar2 = param_1;
}
if (param_1 != 0) {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
iVar3 = iVar1 * iVar1 * iVar1;
if (iVar2 < iVar3) {
return 0;
}
} while (iVar3 != iV... |
968 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char* num) {
const char* key = "2357BD";
int out = 0;
for (int i = 0; i < strlen(num); i++) {
if (strchr(key, num[i])) out += 1;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("AB") == 1);
assert(func0("1077E") == 2);
assert(func0("ABED1A33") == 4);
assert(func0("2020") == 2);
assert(func0("123456789ABCDEF0") == 6);
assert(func0("112233445566778899AABBCCDDEEFF00") == 12);
assert(func0("") == 0);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
lea 0xe67(%rip),%rax
mov %rax,-0x18(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 11e3 <func0+0x5a>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
lea rax, a2357bd; "2357BD"
mov [rbp+s], rax
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp short loc_11E3
loc_11B5:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
mo... | long long func0(const char *a1)
{
unsigned int v2; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
v2 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( strchr("2357BD", a1[i]) )
++v2;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001011e3
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX... | int func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
int local_28;
int local_24;
local_28 = 0;
local_24 = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= (ulong)(long)local_24) break;
pcVar1 = strchr("2357BD",(int)param_1[local_24]);
if (pcVar1 != (char *)0x0) {
local_... |
969 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char* num) {
const char* key = "2357BD";
int out = 0;
for (int i = 0; i < strlen(num); i++) {
if (strchr(key, num[i])) out += 1;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("AB") == 1);
assert(func0("1077E") == 2);
assert(func0("ABED1A33") == 4);
assert(func0("2020") == 2);
assert(func0("123456789ABCDEF0") == 6);
assert(func0("112233445566778899AABBCCDDEEFF00") == 12);
assert(func0("") == 0);
return 0;
} | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rdx,%rbx
lea -0x1(%rdx,%rcx,1),%r12
mov $0x0,%ebp
lea 0xe65(%rip),%r13
cmp %r12,%rbx
je 11bc <func0+0x53>
movsbl... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
call _strlen
mov rbx, r12
add r12, rax
mov ebp, 0
lea r13, s; "2357BD"
jmp short loc_11C9
loc_11B3:
movsx esi, byte ptr [rbx]; c
mov rdi, r13; s
call _strchr
cmp rax, 1
sbb ebp, 0FFFFFF... | long long func0(const char *a1)
{
const char *v1; // rbx
char *v2; // r12
unsigned int v3; // ebp
v1 = a1;
v2 = (char *)&a1[strlen(a1)];
v3 = 0;
while ( v1 != v2 )
v3 -= (strchr("2357BD", *v1++) == 0LL) - 1;
return v3;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
CALL 0x00101070
MOV RBX,R12
ADD R12,RAX
MOV EBP,0x0
LEA R13,[0x102004]
JMP 0x001011c9
LAB_001011b3:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R13
CALL 0x00101080
CMP RAX,0x1
SBB EBP,-0x1
ADD RBX,0x1
LAB_001011c9:
CMP RBX,R12
JNZ 0x001011b3
MOV EAX,EBP
AD... | int func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
sVar1 = strlen(param_1);
pcVar4 = param_1 + sVar1;
iVar3 = 0;
for (; param_1 != pcVar4; param_1 = param_1 + 1) {
pcVar2 = strchr("2357BD",(int)*param_1);
iVar3 = (iVar3 + 1) - (uint)(pcVar2 == (char *)0x0);
}
... |
970 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char* num) {
const char* key = "2357BD";
int out = 0;
for (int i = 0; i < strlen(num); i++) {
if (strchr(key, num[i])) out += 1;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("AB") == 1);
assert(func0("1077E") == 2);
assert(func0("ABED1A33") == 4);
assert(func0("2020") == 2);
assert(func0("123456789ABCDEF0") == 6);
assert(func0("112233445566778899AABBCCDDEEFF00") == 12);
assert(func0("") == 0);
return 0;
} | O2 | c | func0:
endbr64
push %r13
lea 0xcf7(%rip),%r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea (%rbx,%rax,1),%rbp
jmp 1347 <func0+0x47>
nopw %cs:0x0(%rax,%rax,1)
movsbl (%rbx),%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
cmp $0x1,%ra... | func0:
endbr64
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test rax, rax
jz short loc_1360
lea r12, [rbx+rax]
xor ebp, ebp
lea r13, s; "2357BD"
nop dword ptr [rax+rax+00000000h]
loc_1330:
movsx esi, byte ptr [rbx]; c
mov rdi, r13; s
call ... | long long func0(const char *a1)
{
const char *v1; // rbx
size_t v2; // rax
char *v3; // r12
unsigned int v4; // ebp
v1 = a1;
v2 = strlen(a1);
if ( !v2 )
return 0LL;
v3 = (char *)&a1[v2];
v4 = 0;
do
v4 -= (strchr("2357BD", *v1++) == 0LL) - 1;
while ( v1 != v3 );
return v4;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
TEST RAX,RAX
JZ 0x00101360
LEA R12,[RBX + RAX*0x1]
XOR EBP,EBP
LEA R13,[0x102004]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101330:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R13
CALL 0x00101080
CMP RAX,0x1
SBB EBP,-0x1
ADD RBX,0x1
CMP RBX,R12
J... | int func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
char *pcVar3;
int iVar4;
sVar2 = strlen(param_1);
if (sVar2 != 0) {
pcVar1 = param_1 + sVar2;
iVar4 = 0;
do {
pcVar3 = strchr("2357BD",(int)*param_1);
iVar4 = (iVar4 + 1) - (uint)(pcVar3 == (char *)0x0);
param_1 = param... |
971 | func0 | #include <stdio.h>
#include <string.h>
| int func0(const char* num) {
const char* key = "2357BD";
int out = 0;
for (int i = 0; i < strlen(num); i++) {
if (strchr(key, num[i])) out += 1;
}
return out;
} | #include <assert.h>
int main() {
assert(func0("AB") == 1);
assert(func0("1077E") == 2);
assert(func0("ABED1A33") == 4);
assert(func0("2020") == 2);
assert(func0("123456789ABCDEF0") == 6);
assert(func0("112233445566778899AABBCCDDEEFF00") == 12);
assert(func0("") == 0);
return 0;
} | O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %rax,%rax
je 1360 <func0+0x60>
lea (%rbx,%rax,1),%rbp
xor %r12d,%r12d
lea 0xcdb(%rip),%r13
nopl 0x0(%rax)
movsbl (%rbx),%esi
mov %r13,%rdi
callq 1080 <strchr@plt>
cmp $0... | func0:
endbr64
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test rax, rax
jz short loc_1360
lea r12, [rbx+rax]
xor ebp, ebp
lea r13, s; "2357BD"
nop dword ptr [rax+rax+00000000h]
loc_1330:
movsx esi, byte ptr [rbx]; c
mov rdi, r13; s
call ... | long long func0(const char *a1)
{
const char *v1; // rbx
size_t v2; // rax
char *v3; // r12
unsigned int v4; // ebp
v1 = a1;
v2 = strlen(a1);
if ( !v2 )
return 0LL;
v3 = (char *)&a1[v2];
v4 = 0;
do
v4 -= (strchr("2357BD", *v1++) == 0LL) - 1;
while ( v1 != v3 );
return v4;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
TEST RAX,RAX
JZ 0x00101360
LEA R12,[RBX + RAX*0x1]
XOR EBP,EBP
LEA R13,[0x102004]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101330:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R13
CALL 0x00101080
CMP RAX,0x1
SBB EBP,-0x1
ADD RBX,0x1
CMP RBX,R12
J... | int func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
char *pcVar3;
int iVar4;
sVar2 = strlen(param_1);
if (sVar2 != 0) {
pcVar1 = param_1 + sVar2;
iVar4 = 0;
do {
pcVar3 = strchr("2357BD",(int)*param_1);
iVar4 = (iVar4 + 1) - (uint)(pcVar3 == (char *)0x0);
param_1 = param... |
972 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int decimal) {
char* out = malloc(64);
if (!out) {
return NULL;
}
int index = 62;
out[63] = '\0';
if (decimal == 0) {
out[index--] = '0';
} else {
while (decimal > 0) {
out[index--] = '0' + (decimal % 2);
decimal /= 2;
}
... | #include <assert.h>
#include <string.h>
int main() {
char* binary;
binary = func0(0);
assert(strcmp(binary, "db0db") == 0);
free(binary);
binary = func0(32);
assert(strcmp(binary, "db100000db") == 0);
free(binary);
binary = func0(103);
assert(strcmp(binary, "db1100111db") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov $0x40,%edi
callq 10d0 <malloc@plt>
mov %rax,-0x10(%rbp)
cmpq $0x0,-0x10(%rbp)
jne 11f7 <func0+0x2e>
mov $0x0,%eax
jmpq 1330 <func0+0x167>
movl $0x3e,-0x1c(%rbp)
mov -0x10(%rbp),%rax
add $0x3f,%rax
movb $... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov edi, 40h ; '@'; size
call _malloc
mov [rbp+ptr], rax
cmp [rbp+ptr], 0
jnz short loc_1217
mov eax, 0
jmp locret_1343
loc_1217:
mov [rbp+var_1C], 3Eh ; '>'
mov rax, [rbp+ptr]
add rax, 3Fh ; '?... | char * func0(int a1)
{
int v2; // eax
int v3; // [rsp+Ch] [rbp-24h]
int v4; // [rsp+14h] [rbp-1Ch]
int v5; // [rsp+18h] [rbp-18h]
_BYTE *ptr; // [rsp+20h] [rbp-10h]
char *dest; // [rsp+28h] [rbp-8h]
v3 = a1;
ptr = malloc(0x40uLL);
if ( !ptr )
return 0LL;
v4 = 62;
ptr[63] = 0;
if ( a1 )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV EDI,0x40
CALL 0x001010f0
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00101217
MOV EAX,0x0
JMP 0x00101343
LAB_00101217:
MOV dword ptr [RBP + -0x1c],0x3e
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3f
MOV byte ptr... | char * func0(int param_1)
{
char cVar1;
void *__ptr;
char *__dest;
size_t sVar2;
char *pcVar3;
int local_2c;
int local_24;
__ptr = malloc(0x40);
if (__ptr == (void *)0x0) {
__dest = (char *)0x0;
}
else {
local_24 = 0x3e;
*(int *)((long)__ptr + 0x3f) = 0;
local_2c = param_1;
... |
973 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int decimal) {
char* out = malloc(64);
if (!out) {
return NULL;
}
int index = 62;
out[63] = '\0';
if (decimal == 0) {
out[index--] = '0';
} else {
while (decimal > 0) {
out[index--] = '0' + (decimal % 2);
decimal /= 2;
}
... | #include <assert.h>
#include <string.h>
int main() {
char* binary;
binary = func0(0);
assert(strcmp(binary, "db0db") == 0);
free(binary);
binary = func0(32);
assert(strcmp(binary, "db100000db") == 0);
free(binary);
binary = func0(103);
assert(strcmp(binary, "db1100111db") == 0);
... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov $0x40,%edi
callq 10b0 <malloc@plt>
mov %rax,%rbp
test %rax,%rax
je 1281 <func0+0xd8>
movb $0x0,0x3f(%rax)
test %ebx,%ebx
je 1204 <func0+0x5b>
mov $0x3d,%edx
mov $0x3e,%esi
jle 120d <func0+0x64>
mov %edx,%esi
mov ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edi
mov edi, 40h ; '@'; size
call _malloc
mov rbp, rax
test rax, rax
jz loc_12CA
mov byte ptr [rax+3Fh], 0
test ebx, ebx
jz short loc_1252
mov edx, 3Dh ; '='
mov eax, 3Eh ; '>'
jle short... | void * func0(int a1)
{
int v1; // ebx
_BYTE *v2; // rax
_BYTE *v3; // rbp
long long v4; // rdx
int v5; // eax
int v6; // ecx
_BYTE *v7; // r13
size_t v8; // rbx
void *v9; // rax
void *v10; // r12
v1 = a1;
v2 = malloc(0x40uLL);
v3 = v2;
if ( !v2 )
return 0LL;
v2[63] = 0;
if ( a1 )
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV EDI,0x40
CALL 0x001010e0
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001012ca
MOV byte ptr [RAX + 0x3f],0x0
TEST EBX,EBX
JZ 0x00101252
MOV EDX,0x3d
MOV EAX,0x3e
JLE 0x0010125b
LAB_00101223:
MOV ECX,EBX
SHR ECX,0x1f
LEA EAX,[RBX + RCX*0x1]
AND EAX,0x1
SUB ... | void * func0(int param_1)
{
bool bVar1;
char cVar2;
long lVar3;
void *__ptr;
long lVar4;
void *pvVar5;
int iVar6;
size_t __size;
int *puVar7;
__ptr = malloc(0x40);
if (__ptr == (void *)0x0) {
pvVar5 = (void *)0x0;
}
else {
*(int *)((long)__ptr + 0x3f) = 0;
if (param_1 == 0) {
... |
974 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int decimal) {
char* out = malloc(64);
if (!out) {
return NULL;
}
int index = 62;
out[63] = '\0';
if (decimal == 0) {
out[index--] = '0';
} else {
while (decimal > 0) {
out[index--] = '0' + (decimal % 2);
decimal /= 2;
}
... | #include <assert.h>
#include <string.h>
int main() {
char* binary;
binary = func0(0);
assert(strcmp(binary, "db0db") == 0);
free(binary);
binary = func0(32);
assert(strcmp(binary, "db100000db") == 0);
free(binary);
binary = func0(103);
assert(strcmp(binary, "db1100111db") == 0);
... | O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov $0x40,%edi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %rax,%rax
je 13e5 <func0+0xe5>
movb $0x0,0x3f(%rax)
mov %rax,%rbp
test %ebx,%ebx
jne 1390 <func0+0x90>
movb $0x30,0x3e(%rax)
mov $0x5,%edi
mov $0x3c,%r... | func0:
endbr64
push r13
push r12
push rbp
push rbx
mov ebx, edi
mov edi, 40h ; '@'; size
sub rsp, 8
call _malloc
test rax, rax
jz loc_1426
mov byte ptr [rax+3Fh], 0
mov rbp, rax
test ebx, ebx
jnz short loc_13C8
mov byte ptr [rax+3Eh], 30h ; '0'
mov r12d, 5
mov ... | char * func0(int a1)
{
int v1; // ebx
_BYTE *v2; // rax
_BYTE *v3; // rbp
size_t v4; // r12
long long v5; // r13
long long v6; // rax
_BYTE *v7; // r13
char *v8; // rax
char *v9; // rbx
long long v10; // rax
long long v12; // rax
int v13; // edx
int v14; // edx
v1 = a1;
v2 = malloc(0x40uL... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV EDI,0x40
SUB RSP,0x8
CALL 0x001010f0
TEST RAX,RAX
JZ 0x00101426
MOV byte ptr [RAX + 0x3f],0x0
MOV RBP,RAX
TEST EBX,EBX
JNZ 0x001013c8
MOV byte ptr [RAX + 0x3e],0x30
MOV R12D,0x5
MOV R13D,0x3c
MOV EAX,0x3d
LAB_00101363:
ADD R13,RBP
MOV byte ptr [RBP + RA... | void * func0(int param_1)
{
void *__ptr;
long lVar1;
void *pvVar2;
int iVar3;
size_t __size;
long lVar4;
__ptr = malloc(0x40);
if (__ptr != (void *)0x0) {
*(int *)((long)__ptr + 0x3f) = 0;
if (param_1 == 0) {
*(int *)((long)__ptr + 0x3e) = 0x30;
__size = 5;
lVar4 = 0x3c;
... |
975 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int decimal) {
char* out = malloc(64);
if (!out) {
return NULL;
}
int index = 62;
out[63] = '\0';
if (decimal == 0) {
out[index--] = '0';
} else {
while (decimal > 0) {
out[index--] = '0' + (decimal % 2);
decimal /= 2;
}
... | #include <assert.h>
#include <string.h>
int main() {
char* binary;
binary = func0(0);
assert(strcmp(binary, "db0db") == 0);
free(binary);
binary = func0(32);
assert(strcmp(binary, "db100000db") == 0);
free(binary);
binary = func0(103);
assert(strcmp(binary, "db1100111db") == 0);
... | O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov $0x40,%edi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %rax,%rax
je 13e5 <func0+0xe5>
movb $0x0,0x3f(%rax)
mov %rax,%rbp
test %ebx,%ebx
jne 1390 <func0+0x90>
movb $0x30,0x3e(%rax)
mov $0x5,%edi
mov $0x3c,%r... | func0:
endbr64
push r13
push r12
push rbp
push rbx
mov ebx, edi
mov edi, 40h ; '@'; size
sub rsp, 8
call _malloc
test rax, rax
jz loc_1426
mov byte ptr [rax+3Fh], 0
mov rbp, rax
test ebx, ebx
jnz short loc_13C8
mov byte ptr [rax+3Eh], 30h ; '0'
mov r12d, 5
mov ... | char * func0(int a1)
{
int v1; // ebx
_BYTE *v2; // rax
_BYTE *v3; // rbp
size_t v4; // r12
long long v5; // r13
long long v6; // rax
_BYTE *v7; // r13
char *v8; // rax
char *v9; // rbx
long long v10; // rax
long long v12; // rax
int v13; // edx
int v14; // edx
v1 = a1;
v2 = malloc(0x40uL... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV EDI,0x40
SUB RSP,0x8
CALL 0x001010f0
TEST RAX,RAX
JZ 0x00101426
MOV byte ptr [RAX + 0x3f],0x0
MOV RBP,RAX
TEST EBX,EBX
JNZ 0x001013c8
MOV byte ptr [RAX + 0x3e],0x30
MOV R12D,0x5
MOV R13D,0x3c
MOV EAX,0x3d
LAB_00101363:
ADD R13,RBP
MOV byte ptr [RBP + RA... | void * func0(int param_1)
{
void *__ptr;
long lVar1;
void *pvVar2;
int iVar3;
size_t __size;
long lVar4;
__ptr = malloc(0x40);
if (__ptr != (void *)0x0) {
*(int *)((long)__ptr + 0x3f) = 0;
if (param_1 == 0) {
*(int *)((long)__ptr + 0x3e) = 0x30;
__size = 5;
lVar4 = 0x3c;
... |
976 | func0 | #include <string.h>
#include <stdbool.h>
| bool func0(const char* s) {
if (strlen(s) < 3) return false;
for (int i = 2; i < strlen(s); i++)
if (s[i] == s[i-1] || s[i] == s[i-2]) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("a") == false);
assert(func0("aa") == false);
assert(func0("abcd") == true);
assert(func0("aabb") == false);
assert(func0("adb") == true);
assert(func0("xyy") == false);
assert(func0("iopaxpoi") == true);
assert(func0("iopaxioi") == false);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp $0x2,%rax
ja 1193 <func0+0x2a>
mov $0x0,%eax
jmp 1211 <func0+0xa8>
movl $0x2,-0x14(%rbp)
jmp 11f5 <func0+0x8c>
mov -0x14(%rbp),%eax... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rax, 2
ja short loc_1193
mov eax, 0
jmp short loc_1211
loc_1193:
mov [rbp+var_14], 2
jmp short loc_11F5
loc_119C:
mov eax, [rbp+var_14]
... | long long func0(const char *a1)
{
int i; // [rsp+1Ch] [rbp-14h]
if ( strlen(a1) <= 2 )
return 0LL;
for ( i = 2; i < strlen(a1); ++i )
{
if ( a1[i] == a1[i - 1] || a1[i] == a1[i - 2] )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RAX,0x2
JA 0x00101193
MOV EAX,0x0
JMP 0x00101211
LAB_00101193:
MOV dword ptr [RBP + -0x14],0x2
JMP 0x001011f5
LAB_0010119c:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX... | int8 func0(char *param_1)
{
size_t sVar1;
int8 uVar2;
int local_1c;
sVar1 = strlen(param_1);
if (sVar1 < 3) {
uVar2 = 0;
}
else {
for (local_1c = 2; sVar1 = strlen(param_1), (ulong)(long)local_1c < sVar1;
local_1c = local_1c + 1) {
if ((param_1[local_1c] == param_1[(long)local_1c... |
977 | func0 | #include <string.h>
#include <stdbool.h>
| bool func0(const char* s) {
if (strlen(s) < 3) return false;
for (int i = 2; i < strlen(s); i++)
if (s[i] == s[i-1] || s[i] == s[i-2]) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("a") == false);
assert(func0("aa") == false);
assert(func0("abcd") == true);
assert(func0("aabb") == false);
assert(func0("adb") == true);
assert(func0("xyy") == false);
assert(func0("iopaxpoi") == true);
assert(func0("iopaxioi") == false);
... | O1 | c | func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp $0x2,%rcx
jbe 119a <func0+0x51>
mov %rdx,%rax
lea -0x2(%rdx,%rcx,1),%rcx
movzbl 0x2(%rax),%edx
cmp 0x1(%rax),%dl
je 118f <func0+0x46>
cmp (%rax),%dl
je 11... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov edx, 0
cmp rax, 2
jbe short loc_11AB
mov rdx, rbx
lea rcx, [rbx+rax-2]
loc_1189:
movzx eax, byte ptr [rdx+2]
cmp al, [rdx+1]
jz short loc_11A6
cmp al, [rdx]
jz short loc_11AF
add rdx, 1
cmp rdx, rcx
jnz s... | long long func0(const char *a1)
{
size_t v1; // rax
unsigned int v2; // edx
const char *v3; // rdx
long long v4; // rcx
char v5; // al
v1 = strlen(a1);
v2 = 0;
if ( v1 > 2 )
{
v3 = a1;
v4 = (long long)&a1[v1 - 2];
while ( 1 )
{
v5 = v3[2];
if ( v5 == v3[1] )
retur... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV EDX,0x0
CMP RAX,0x2
JBE 0x001011ab
MOV RDX,RBX
LEA RCX,[RBX + RAX*0x1 + -0x2]
LAB_00101189:
MOVZX EAX,byte ptr [RDX + 0x2]
CMP AL,byte ptr [RDX + 0x1]
JZ 0x001011a6
CMP AL,byte ptr [RDX]
JZ 0x001011af
ADD RDX,0x1
CMP RDX,RCX
JNZ 0x00101189
MOV EDX,0x1
JMP 0x001011... | int8 func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
int8 uVar3;
sVar2 = strlen(param_1);
uVar3 = 0;
if (2 < sVar2) {
pcVar1 = param_1 + (sVar2 - 2);
do {
if (param_1[2] == param_1[1]) {
return 0;
}
if (param_1[2] == *param_1) {
return 0;
}
param_... |
978 | func0 | #include <string.h>
#include <stdbool.h>
| bool func0(const char* s) {
if (strlen(s) < 3) return false;
for (int i = 2; i < strlen(s); i++)
if (s[i] == s[i-1] || s[i] == s[i-2]) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("a") == false);
assert(func0("aa") == false);
assert(func0("abcd") == true);
assert(func0("aabb") == false);
assert(func0("adb") == true);
assert(func0("xyy") == false);
assert(func0("iopaxpoi") == true);
assert(func0("iopaxioi") == false);
... | O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
xor %r8d,%r8d
cmp $0x2,%rax
jbe 1349 <func0+0x39>
mov %rbx,%rdi
lea -0x2(%rbx,%rax,1),%rdx
jmp 133d <func0+0x2d>
cmp (%rdi),%al
je 1346 <func0+0x36>
add $0x1,%rdi
cmp %rdx,%rdi
je 1350 <func0+0x40>
movzbl 0x2(%rdi),%... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
xor edx, edx
cmp rax, 2
jbe short loc_1348
mov rdi, rbx
lea rdx, [rbx+rax-2]
jmp short loc_133D
loc_1330:
cmp al, [rdi]
jz short loc_1346
add rdi, 1
cmp rdi, rdx
jz short loc_1350
loc_133D:
movzx eax, byte ptr [r... | long long func0(long long a1)
{
size_t v1; // rax
long long v2; // rdx
char v3; // al
v1 = strlen((const char *)a1);
if ( v1 > 2 )
{
v2 = a1 + v1 - 2;
while ( 1 )
{
v3 = *(_BYTE *)(a1 + 2);
if ( v3 == *(_BYTE *)(a1 + 1) || v3 == *(_BYTE *)a1 )
break;
if ( ++a1 == v2 )... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
XOR EDX,EDX
CMP RAX,0x2
JBE 0x00101348
MOV RDI,RBX
LEA RDX,[RBX + RAX*0x1 + -0x2]
JMP 0x0010133d
LAB_00101330:
CMP AL,byte ptr [RDI]
JZ 0x00101346
ADD RDI,0x1
CMP RDI,RDX
JZ 0x00101350
LAB_0010133d:
MOVZX EAX,byte ptr [RDI + 0x2]
CMP AL,byte ptr [RDI + 0x1]
JNZ 0x0010... | int8 func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
sVar2 = strlen(param_1);
if (2 < sVar2) {
pcVar1 = param_1 + (sVar2 - 2);
while ((param_1[2] != param_1[1] && (param_1[2] != *param_1))) {
param_1 = param_1 + 1;
if (param_1 == pcVar1) {
return 1;
}
}
}
return ... |
979 | func0 | #include <string.h>
#include <stdbool.h>
| bool func0(const char* s) {
if (strlen(s) < 3) return false;
for (int i = 2; i < strlen(s); i++)
if (s[i] == s[i-1] || s[i] == s[i-2]) return false;
return true;
} | #include <assert.h>
int main() {
assert(func0("a") == false);
assert(func0("aa") == false);
assert(func0("abcd") == true);
assert(func0("aabb") == false);
assert(func0("adb") == true);
assert(func0("xyy") == false);
assert(func0("iopaxpoi") == true);
assert(func0("iopaxioi") == false);
... | O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
xor %r8d,%r8d
cmp $0x2,%rax
jbe 1349 <func0+0x39>
mov %rbx,%rdi
lea -0x2(%rbx,%rax,1),%rdx
jmp 133d <func0+0x2d>
cmp (%rdi),%al
je 1346 <func0+0x36>
add $0x1,%rdi
cmp %rdx,%rdi
je 1350 <func0+0x40>
movzbl 0x2(%rdi),%... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
xor edx, edx
cmp rax, 2
jbe short loc_1348
mov rdi, rbx
lea rdx, [rbx+rax-2]
jmp short loc_133D
loc_1330:
cmp al, [rdi]
jz short loc_1346
add rdi, 1
cmp rdi, rdx
jz short loc_1350
loc_133D:
movzx eax, byte ptr [r... | long long func0(long long a1)
{
size_t v1; // rax
long long v2; // rdx
char v3; // al
v1 = strlen((const char *)a1);
if ( v1 > 2 )
{
v2 = a1 + v1 - 2;
while ( 1 )
{
v3 = *(_BYTE *)(a1 + 2);
if ( v3 == *(_BYTE *)(a1 + 1) || v3 == *(_BYTE *)a1 )
break;
if ( ++a1 == v2 )... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
XOR EDX,EDX
CMP RAX,0x2
JBE 0x00101348
MOV RDI,RBX
LEA RDX,[RBX + RAX*0x1 + -0x2]
JMP 0x0010133d
LAB_00101330:
CMP AL,byte ptr [RDI]
JZ 0x00101346
ADD RDI,0x1
CMP RDI,RDX
JZ 0x00101350
LAB_0010133d:
MOVZX EAX,byte ptr [RDI + 0x2]
CMP AL,byte ptr [RDI + 0x1]
JNZ 0x0010... | int8 func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
sVar2 = strlen(param_1);
if (2 < sVar2) {
pcVar1 = param_1 + (sVar2 - 2);
while ((param_1[2] != param_1[1] && (param_1[2] != *param_1))) {
param_1 = param_1 + 1;
if (param_1 == pcVar1) {
return 1;
}
}
}
return ... |
980 | func0 | #include <stdio.h>
#include <stdlib.h>
| char** func0(float* grades, int size) {
char** out = malloc(size * sizeof(char*));
for (int i = 0; i < size; ++i) {
if (grades[i] >= 3.9999) out[i] = "A+";
else if (grades[i] > 3.7001) out[i] = "A";
else if (grades[i] > 3.3001) out[i] = "A-";
else if (grades[i] > 3.0001) out[i] =... | #include <assert.h>
#include <stdbool.h>
#include <string.h>
bool issame(char** a, char** b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
int main() {
float grades1[] = {4.0, 3, 1.7, 2, 3.5};
char* expected1[] = {"A+", "B", "C-", ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1585 <func0+0x3bc>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp loc_1585
loc_11FD:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0... | _QWORD * func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_QWORD *v4; // [rsp+18h] [rbp-8h]
v4 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
if ( *(float *)(4LL * i + a1) < 3.9999 )
{
if ( *(float *)(4LL * i + a1) <= 3.7001 )
{
if ( *(float *)(4LL * i + a1) <= 3.3001 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101585
LAB_001011fd:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(long param_1,int param_2)
{
void *pvVar1;
int local_14;
pvVar1 = malloc((long)param_2 << 3);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if ((double)*(float *)(param_1 + (long)local_1... |
981 | func0 | #include <stdio.h>
#include <stdlib.h>
| char** func0(float* grades, int size) {
char** out = malloc(size * sizeof(char*));
for (int i = 0; i < size; ++i) {
if (grades[i] >= 3.9999) out[i] = "A+";
else if (grades[i] > 3.7001) out[i] = "A";
else if (grades[i] > 3.3001) out[i] = "A-";
else if (grades[i] > 3.0001) out[i] =... | #include <assert.h>
#include <stdbool.h>
#include <string.h>
bool issame(char** a, char** b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
int main() {
float grades1[] = {4.0, 3, 1.7, 2, 3.5};
char* expected1[] = {"A+", "B", "C-", ... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rdi
shl $0x3,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 134f <func0+0x186>
lea -0x1(%rbp),%esi
mov $0x0,%edx
movsd 0xf2c(%rip),%xmm1
movsd 0xf2c(%rip),%xmm2
movsd 0xf2c(%rip),%xmm3
jmp 122f <... | func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov r12d, esi
movsxd rsi, esi
lea rbp, ds:0[rsi*8]
mov rdi, rbp; size
call _malloc
test r12d, r12d
jle loc_134C
mov rcx, rbx
mov rdx, rax
lea rsi, [rbp+rax+0]
movsd xmm1, cs:qword_2108
movsd xmm2, cs:qword_2110
mo... | _QWORD * func0(float *a1, int a2)
{
_QWORD *result; // rax
_QWORD *v4; // rdx
double v5; // xmm0_8
result = malloc(8LL * a2);
if ( a2 > 0 )
{
v4 = result;
do
{
v5 = *a1;
if ( v5 < 3.9999 )
{
if ( v5 <= 3.7001 )
{
if ( v5 <= 3.3001 )
{
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV R12D,ESI
MOVSXD RSI,ESI
LEA RBP,[RSI*0x8]
MOV RDI,RBP
CALL 0x001010d0
TEST R12D,R12D
JLE 0x0010134c
MOV RCX,RBX
MOV RDX,RAX
LEA RSI,[RBP + RAX*0x1]
MOVSD XMM1,qword ptr [0x00102108]
MOVSD XMM2,qword ptr [0x00102110]
MOVSD XMM3,qword ptr [0x00102118]
LEA R9,[0x10... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(float *param_1,int param_2)
{
int8 *puVar1;
double dVar2;
double dVar3;
double dVar4;
int8 *puVar5;
double dVar6;
puVar5 = (int8 *)malloc((long)param_2 * 8);
dVar4 = DAT_00102118;
dVar3 = DAT_00102110;... |
982 | func0 | #include <stdio.h>
#include <stdlib.h>
| char** func0(float* grades, int size) {
char** out = malloc(size * sizeof(char*));
for (int i = 0; i < size; ++i) {
if (grades[i] >= 3.9999) out[i] = "A+";
else if (grades[i] > 3.7001) out[i] = "A";
else if (grades[i] > 3.3001) out[i] = "A-";
else if (grades[i] > 3.0001) out[i] =... | #include <assert.h>
#include <stdbool.h>
#include <string.h>
bool issame(char** a, char** b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
int main() {
float grades1[] = {4.0, 3, 1.7, 2, 3.5};
char* expected1[] = {"A+", "B", "C-", ... | O2 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 15c0 <func0+0x80>
movsd 0xbc0(%rip),%xmm1
movsd 0xbc0(%rip),%xmm2
lea -0x1(%rbp),%esi
xor %edx,%edx
movsd 0xbbb(%rip),%xmm3
jmp 1597 <f... | func0:
endbr64
push r12
push rbp
movsxd rbp, esi
push rbx
mov rbx, rdi
lea rdi, ds:0[rbp*8]; size
call _malloc
movsd xmm1, cs:qword_2108
test ebp, ebp
jle loc_1605
xor edx, edx
movsd xmm2, cs:qword_2110
movsd xmm3, cs:qword_2118
lea rsi, unk_2004
lea rdi, unk_2007
lea r... | _QWORD * func0(long long a1, int a2)
{
_QWORD *result; // rax
long long i; // rdx
void *v4; // rcx
double v5; // xmm0_8
result = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; result[i++] = v4 )
{
v4 = &unk_2004;
v5 = *(float *)(a1 + 4 * i);
if ( v5 < 3.9999 )
{... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RDI
LEA RDI,[RBP*0x8]
CALL 0x001010d0
MOVSD XMM1,qword ptr [0x00102108]
TEST EBP,EBP
JLE 0x00101605
XOR EDX,EDX
MOVSD XMM2,qword ptr [0x00102110]
MOVSD XMM3,qword ptr [0x00102118]
LEA RSI,[0x102004]
LEA RDI,[0x102007]
LEA R8,[0x102009]
LEA R9,[0x10200c]
N... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(long param_1,int param_2)
{
double dVar1;
double dVar2;
double dVar3;
void *pvVar4;
int *puVar5;
long lVar6;
double dVar7;
pvVar4 = malloc((long)param_2 * 8);
dVar3 = DAT_00102118;
dVar2 = DAT_001021... |
983 | func0 | #include <stdio.h>
#include <stdlib.h>
| char** func0(float* grades, int size) {
char** out = malloc(size * sizeof(char*));
for (int i = 0; i < size; ++i) {
if (grades[i] >= 3.9999) out[i] = "A+";
else if (grades[i] > 3.7001) out[i] = "A";
else if (grades[i] > 3.3001) out[i] = "A-";
else if (grades[i] > 3.0001) out[i] =... | #include <assert.h>
#include <stdbool.h>
#include <string.h>
bool issame(char** a, char** b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) return false;
}
return true;
}
int main() {
float grades1[] = {4.0, 3, 1.7, 2, 3.5};
char* expected1[] = {"A+", "B", "C-", ... | O3 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 15a0 <func0+0x80>
movsd 0xbe0(%rip),%xmm1
movsd 0xbe0(%rip),%xmm2
lea -0x1(%rbp),%esi
xor %edx,%edx
movsd 0xbdb(%rip),%xmm3
jmp 1577 <f... | func0:
endbr64
push r12
push rbp
movsxd rbp, esi
push rbx
mov rbx, rdi
lea rdi, ds:0[rbp*8]; size
call _malloc
movsd xmm1, cs:qword_2108
test ebp, ebp
jle loc_1605
xor edx, edx
movsd xmm2, cs:qword_2110
movsd xmm3, cs:qword_2118
lea rsi, unk_2004
lea rdi, unk_2007
lea r... | _QWORD * func0(long long a1, int a2)
{
_QWORD *result; // rax
long long i; // rdx
void *v4; // rcx
double v5; // xmm0_8
result = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; result[i++] = v4 )
{
v4 = &unk_2004;
v5 = *(float *)(a1 + 4 * i);
if ( v5 < 3.9999 )
{... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RDI
LEA RDI,[RBP*0x8]
CALL 0x001010d0
MOVSD XMM1,qword ptr [0x00102108]
TEST EBP,EBP
JLE 0x00101605
XOR EDX,EDX
MOVSD XMM2,qword ptr [0x00102110]
MOVSD XMM3,qword ptr [0x00102118]
LEA RSI,[0x102004]
LEA RDI,[0x102007]
LEA R8,[0x102009]
LEA R9,[0x10200c]
N... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(long param_1,int param_2)
{
double dVar1;
double dVar2;
double dVar3;
void *pvVar4;
int *puVar5;
long lVar6;
double dVar7;
pvVar4 = malloc((long)param_2 * 8);
dVar3 = DAT_00102118;
dVar2 = DAT_001021... |
984 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char* str) {
int l = strlen(str);
if (l < 2) return false;
for (int i = 2; i * i <= l; i++) {
if (l % i == 0) return false;
}
return true;
} | #include <assert.h>
int main() {
assert(func0("Hello") == true);
assert(func0("abcdcba") == true);
assert(func0("kittens") == true);
assert(func0("orange") == false);
assert(func0("wow") == true);
assert(func0("world") == true);
assert(func0("MadaM") == true);
assert(func0("Wow") == tru... | 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)
cmpl $0x1,-0x4(%rbp)
jg 1195 <func0+0x2c>
mov $0x0,%eax
jmp 11c6 <func0+0x5d>
movl $0x2,-0x8(%rbp)
jmp 11b6 <func0+0x4d>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
cmp [rbp+var_4], 1
jg short loc_1195
mov eax, 0
jmp short locret_11C6
loc_1195:
mov [rbp+var_8], 2
jmp short loc_11B6
loc_119E:
mov... | long long func0(const char *a1)
{
int i; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = strlen(a1);
if ( v3 <= 1 )
return 0LL;
for ( i = 2; v3 >= i * i; ++i )
{
if ( !(v3 % 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
CMP dword ptr [RBP + -0x4],0x1
JG 0x00101195
MOV EAX,0x0
JMP 0x001011c6
LAB_00101195:
MOV dword ptr [RBP + -0x8],0x2
JMP 0x001011b6
LAB_0010119e:
MO... | int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
int8 uVar3;
int local_10;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 2) {
uVar3 = 0;
}
else {
for (local_10 = 2; local_10 * local_10 <= iVar1; local_10 = local_10 + 1) {
if (iVar1 % local_10 == 0) {
return 0;
... |
985 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char* str) {
int l = strlen(str);
if (l < 2) return false;
for (int i = 2; i * i <= l; i++) {
if (l % i == 0) return false;
}
return true;
} | #include <assert.h>
int main() {
assert(func0("Hello") == true);
assert(func0("abcdcba") == true);
assert(func0("kittens") == true);
assert(func0("orange") == false);
assert(func0("wow") == true);
assert(func0("world") == true);
assert(func0("MadaM") == true);
assert(func0("Wow") == tru... | O1 | c | func0:
endbr64
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
mov %ecx,%esi
cmp $0x1,%ecx
jle 1192 <func0+0x49>
cmp $0x3,%ecx
jle 1199 <func0+0x50>
test $0x1,%cl
je 119f <func0+0x56>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %... | func0:
endbr64
sub rsp, 8
call _strlen
mov edx, 0
cmp eax, 1
jle short loc_11B1
mov esi, eax
cmp eax, 3
jle short loc_11B8
test al, 1
jz short loc_11BF
mov ecx, 2
loc_1190:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jg short loc_11AC
mov eax, es... | long long func0(const char *a1)
{
int v1; // eax
unsigned int v2; // edx
int v3; // ecx
v1 = strlen(a1);
v2 = 0;
if ( v1 > 1 )
{
if ( v1 <= 3 )
{
return 1;
}
else if ( (v1 & 1) != 0 )
{
v3 = 2;
while ( 1 )
{
++v3;
if ( v3 * v3 > v1 )
... | func0:
ENDBR64
SUB RSP,0x8
CALL 0x00101060
MOV EDX,0x0
CMP EAX,0x1
JLE 0x001011b1
MOV ESI,EAX
CMP EAX,0x3
JLE 0x001011b8
TEST AL,0x1
JZ 0x001011bf
MOV ECX,0x2
LAB_00101190:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JG 0x001011ac
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101190
MOV EDX,0x0
JMP 0x001011b1
LAB_... | int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int8 uVar4;
sVar2 = strlen(param_1);
uVar4 = 0;
iVar1 = (int)sVar2;
if (1 < iVar1) {
if (iVar1 < 4) {
uVar4 = 1;
}
else if ((sVar2 & 1) == 0) {
uVar4 = 0;
}
else {
iVar3 = 2;
do {
iVar... |
986 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char* str) {
int l = strlen(str);
if (l < 2) return false;
for (int i = 2; i * i <= l; i++) {
if (l % i == 0) return false;
}
return true;
} | #include <assert.h>
int main() {
assert(func0("Hello") == true);
assert(func0("abcdcba") == true);
assert(func0("kittens") == true);
assert(func0("orange") == false);
assert(func0("wow") == true);
assert(func0("world") == true);
assert(func0("MadaM") == true);
assert(func0("Wow") == tru... | O2 | c | func0:
endbr64
sub $0x8,%rsp
callq 1060 <strlen@plt>
xor %r8d,%r8d
cmp $0x1,%eax
jle 14fb <func0+0x4b>
cmp $0x3,%eax
jle 14f5 <func0+0x45>
test $0x1,%al
je 14fb <func0+0x4b>
mov %eax,%esi
mov $0x2,%ecx
jmp 14e9 <func0+0x39>
nopw 0x0(%rax,%rax,1)
mov %esi,%eax
cltd
idiv %ecx
test... | func0:
endbr64
sub rsp, 8
call _strlen
xor edx, edx
cmp eax, 1
jle short loc_14FA
cmp eax, 3
jle short loc_14F5
test al, 1
jz short loc_14FA
mov esi, eax
mov ecx, 2
jmp short loc_14E9
loc_14E0:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_1508
loc_14... | long long func0(const char *a1)
{
int v1; // eax
unsigned int v2; // edx
int v3; // ecx
v1 = strlen(a1);
v2 = 0;
if ( v1 <= 1 )
return v2;
if ( v1 <= 3 )
return 1;
if ( (v1 & 1) != 0 )
{
v3 = 2;
while ( 1 )
{
++v3;
if ( v3 * v3 > v1 )
break;
if ( !(v1 % ... | func0:
ENDBR64
SUB RSP,0x8
CALL 0x00101060
XOR EDX,EDX
CMP EAX,0x1
JLE 0x001014fa
CMP EAX,0x3
JLE 0x001014f5
TEST AL,0x1
JZ 0x001014fa
MOV ESI,EAX
MOV ECX,0x2
JMP 0x001014e9
LAB_001014e0:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101508
LAB_001014e9:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x001014e0
LA... | int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int8 uVar4;
sVar2 = strlen(param_1);
uVar4 = 0;
iVar1 = (int)sVar2;
if (1 < iVar1) {
if (3 < iVar1) {
if ((sVar2 & 1) == 0) {
return 0;
}
iVar3 = 2;
while (iVar3 = iVar3 + 1, iVar3 * iVar3 <= iVar1) {... |
987 | func0 | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
| bool func0(const char* str) {
int l = strlen(str);
if (l < 2) return false;
for (int i = 2; i * i <= l; i++) {
if (l % i == 0) return false;
}
return true;
} | #include <assert.h>
int main() {
assert(func0("Hello") == true);
assert(func0("abcdcba") == true);
assert(func0("kittens") == true);
assert(func0("orange") == false);
assert(func0("wow") == true);
assert(func0("world") == true);
assert(func0("MadaM") == true);
assert(func0("Wow") == tru... | O3 | c | func0:
endbr64
sub $0x8,%rsp
callq 1060 <strlen@plt>
xor %r8d,%r8d
cmp $0x1,%eax
jle 14fb <func0+0x4b>
cmp $0x3,%eax
jle 14f5 <func0+0x45>
test $0x1,%al
je 14fb <func0+0x4b>
mov %eax,%esi
mov $0x2,%ecx
jmp 14e9 <func0+0x39>
nopw 0x0(%rax,%rax,1)
mov %esi,%eax
cltd
idiv %ecx
test... | func0:
endbr64
sub rsp, 8
call _strlen
xor edx, edx
cmp eax, 1
jle short loc_14FA
cmp eax, 3
jle short loc_14F5
test al, 1
jz short loc_14FA
mov esi, eax
mov ecx, 2
jmp short loc_14E9
loc_14E0:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_1508
loc_14... | long long func0(const char *a1)
{
int v1; // eax
unsigned int v2; // edx
int v3; // ecx
v1 = strlen(a1);
v2 = 0;
if ( v1 <= 1 )
return v2;
if ( v1 <= 3 )
return 1;
if ( (v1 & 1) != 0 )
{
v3 = 2;
while ( 1 )
{
++v3;
if ( v3 * v3 > v1 )
break;
if ( !(v1 % ... | func0:
ENDBR64
SUB RSP,0x8
CALL 0x00101060
XOR EDX,EDX
CMP EAX,0x1
JLE 0x001014fa
CMP EAX,0x3
JLE 0x001014f5
TEST AL,0x1
JZ 0x001014fa
MOV ESI,EAX
MOV ECX,0x2
JMP 0x001014e9
LAB_001014e0:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101508
LAB_001014e9:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x001014e0
LA... | int8 func0(char *param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int8 uVar4;
sVar2 = strlen(param_1);
uVar4 = 0;
iVar1 = (int)sVar2;
if (1 < iVar1) {
if (3 < iVar1) {
if ((sVar2 & 1) == 0) {
return 0;
}
iVar3 = 2;
while (iVar3 = iVar3 + 1, iVar3 * iVar3 <= iVar1) {... |
988 | func0 | #include <stdio.h>
| int func0(int n) {
if (n < 1) return 0;
if (n == 1) return 1;
int out = 18;
for (int i = 2; i < n; i++)
out = out * 10;
return out;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 18);
assert(func0(3) == 180);
assert(func0(4) == 1800);
assert(func0(5) == 18000);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 1161 <func0+0x18>
mov $0x0,%eax
jmp 119c <func0+0x53>
cmpl $0x1,-0x14(%rbp)
jne 116e <func0+0x25>
mov $0x1,%eax
jmp 119c <func0+0x53>
movl $0x12,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 1191 <func0+0x48... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jg short loc_1161
mov eax, 0
jmp short loc_119C
loc_1161:
cmp [rbp+var_14], 1
jnz short loc_116E
mov eax, 1
jmp short loc_119C
loc_116E:
mov [rbp+var_8], 12h
mov [rbp+var_4], 2
jmp shor... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
if ( a1 <= 0 )
return 0LL;
if ( a1 == 1 )
return 1LL;
v2 = 18;
for ( i = 2; i < a1; ++i )
v2 *= 10;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JG 0x00101161
MOV EAX,0x0
JMP 0x0010119c
LAB_00101161:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x0010116e
MOV EAX,0x1
JMP 0x0010119c
LAB_0010116e:
MOV dword ptr [RBP + -0x8],0x12
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101191... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
if (param_1 < 1) {
local_10 = 0;
}
else if (param_1 == 1) {
local_10 = 1;
}
else {
local_10 = 0x12;
for (local_c = 2; local_c < param_1; local_c = local_c + 1) {
local_10 = local_10 * 10;
}
}
return local_10;
} |
989 | func0 | #include <stdio.h>
| int func0(int n) {
if (n < 1) return 0;
if (n == 1) return 1;
int out = 18;
for (int i = 2; i < n; i++)
out = out * 10;
return out;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 18);
assert(func0(3) == 180);
assert(func0(4) == 1800);
assert(func0(5) == 18000);
return 0;
} | O1 | c | func0:
endbr64
mov $0x0,%eax
test %edi,%edi
jle 117e <func0+0x35>
mov %edi,%eax
cmp $0x1,%edi
je 117e <func0+0x35>
cmp $0x2,%edi
jle 1179 <func0+0x30>
mov $0x2,%edx
mov $0x12,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
add $0x1,%edx
cmp %edx,%edi
jne 116c <func0+0x23>
retq
mov... | func0:
endbr64
mov eax, 0
test edi, edi
jle short locret_117E
mov eax, edi
cmp edi, 1
jz short locret_117E
cmp edi, 2
jle short loc_1179
mov edx, 2
mov eax, 12h
loc_116C:
lea eax, [rax+rax*4]
add eax, eax
add edx, 1
cmp edi, edx
jnz short loc_116C
retn
loc_117... | long long func0(int a1)
{
long long result; // rax
int v2; // edx
result = 0LL;
if ( a1 > 0 )
{
result = (unsigned int)a1;
if ( a1 != 1 )
{
if ( a1 <= 2 )
{
return 18LL;
}
else
{
v2 = 2;
LODWORD(result) = 18;
do
{
re... | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JLE 0x0010117e
MOV EAX,EDI
CMP EDI,0x1
JZ 0x0010117e
CMP EDI,0x2
JLE 0x00101179
MOV EDX,0x2
MOV EAX,0x12
LAB_0010116c:
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
ADD EDX,0x1
CMP EDI,EDX
JNZ 0x0010116c
RET
LAB_00101179:
MOV EAX,0x12
LAB_0010117e:
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if ((0 < param_1) && (iVar1 = param_1, param_1 != 1)) {
if (2 < param_1) {
iVar2 = 2;
iVar1 = 0x12;
do {
iVar1 = iVar1 * 10;
iVar2 = iVar2 + 1;
} while (param_1 != iVar2);
return iVar1;
}
iVar... |
990 | func0 | #include <stdio.h>
| int func0(int n) {
if (n < 1) return 0;
if (n == 1) return 1;
int out = 18;
for (int i = 2; i < n; i++)
out = out * 10;
return out;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 18);
assert(func0(3) == 180);
assert(func0(4) == 1800);
assert(func0(5) == 18000);
return 0;
} | O2 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
jle 117d <func0+0x3d>
mov $0x1,%eax
cmp $0x1,%edi
je 117d <func0+0x3d>
cmp $0x2,%edi
je 1178 <func0+0x38>
mov $0x2,%edx
mov $0x12,%eax
nopl 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%eax
add $0x1,%edx
add %eax,%eax
cmp %edx,%edi
jne 11... | func0:
endbr64
xor eax, eax
test edi, edi
jle short locret_117D
mov eax, 1
cmp edi, 1
jz short locret_117D
cmp edi, 2
jz short loc_1178
mov edx, 2
mov eax, 12h
nop dword ptr [rax+rax+00h]
loc_1168:
lea eax, [rax+rax*4]
add edx, 1
add eax, eax
cmp edi, edx
jnz... | long long func0(int a1)
{
long long result; // rax
int v2; // edx
result = 0LL;
if ( a1 > 0 )
{
result = 1LL;
if ( a1 != 1 )
{
if ( a1 == 2 )
{
return 18LL;
}
else
{
v2 = 2;
LODWORD(result) = 18;
do
{
++v2;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x0010117d
MOV EAX,0x1
CMP EDI,0x1
JZ 0x0010117d
CMP EDI,0x2
JZ 0x00101178
MOV EDX,0x2
MOV EAX,0x12
NOP dword ptr [RAX + RAX*0x1]
LAB_00101168:
LEA EAX,[RAX + RAX*0x4]
ADD EDX,0x1
ADD EAX,EAX
CMP EDI,EDX
JNZ 0x00101168
RET
LAB_00101178:
MOV EAX,0x12
LAB_0010117d:
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if ((0 < param_1) && (iVar1 = 1, param_1 != 1)) {
if (param_1 != 2) {
iVar2 = 2;
iVar1 = 0x12;
do {
iVar2 = iVar2 + 1;
iVar1 = iVar1 * 10;
} while (param_1 != iVar2);
return iVar1;
}
iVar1 = 0... |
991 | func0 | #include <stdio.h>
| int func0(int n) {
if (n < 1) return 0;
if (n == 1) return 1;
int out = 18;
for (int i = 2; i < n; i++)
out = out * 10;
return out;
} | #include <assert.h>
int main() {
assert(func0(1) == 1);
assert(func0(2) == 18);
assert(func0(3) == 180);
assert(func0(4) == 1800);
assert(func0(5) == 18000);
return 0;
} | O3 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
jle 117d <func0+0x3d>
mov $0x1,%eax
cmp $0x1,%edi
je 117d <func0+0x3d>
cmp $0x2,%edi
je 1178 <func0+0x38>
mov $0x2,%edx
mov $0x12,%eax
nopl 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%eax
add $0x1,%edx
add %eax,%eax
cmp %edx,%edi
jne 11... | func0:
endbr64
xor eax, eax
test edi, edi
jle short locret_117D
mov eax, 1
cmp edi, 1
jz short locret_117D
cmp edi, 2
jz short loc_1178
mov edx, 2
mov eax, 12h
nop dword ptr [rax+rax+00h]
loc_1168:
lea eax, [rax+rax*4]
add edx, 1
add eax, eax
cmp edi, edx
jnz... | long long func0(int a1)
{
long long result; // rax
int v2; // edx
result = 0LL;
if ( a1 > 0 )
{
result = 1LL;
if ( a1 != 1 )
{
if ( a1 == 2 )
{
return 18LL;
}
else
{
v2 = 2;
LODWORD(result) = 18;
do
{
++v2;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x0010117d
MOV EAX,0x1
CMP EDI,0x1
JZ 0x0010117d
CMP EDI,0x2
JZ 0x00101178
MOV EDX,0x2
MOV EAX,0x12
NOP dword ptr [RAX + RAX*0x1]
LAB_00101168:
LEA EAX,[RAX + RAX*0x4]
ADD EDX,0x1
ADD EAX,EAX
CMP EDI,EDX
JNZ 0x00101168
RET
LAB_00101178:
MOV EAX,0x12
LAB_0010117d:
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if ((0 < param_1) && (iVar1 = 1, param_1 != 1)) {
if (param_1 != 2) {
iVar2 = 2;
iVar1 = 0x12;
do {
iVar2 = iVar2 + 1;
iVar1 = iVar1 * 10;
} while (param_1 != iVar2);
return iVar1;
}
iVar1 = 0... |
992 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int N) {
char str[6];
sprintf(str, "%d", N);
int sum = 0;
for (int i = 0; str[i] != '\0'; i++)
sum += str[i] - '0';
char* bi = malloc(33);
int index = 0;
if (sum == 0) {
bi[index++] = '0';
} else {
while (sum > 0) {
bi[index++] = (sum % 2)... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0(1000);
assert(strcmp(result, "1") == 0);
free(result);
result = func0(150);
assert(strcmp(result, "110") == 0);
free(result);
result = func0(147);
assert(strcmp(result, "1100") == 0);
free(resul... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x34(%rbp),%edx
lea -0xe(%rbp),%rax
lea 0xdf3(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10f0 <sprintf@plt>
movl $0x0,-0x28(%rbp)
movl $0x0,-0x24(... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov edx, [rbp+var_34]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
mov [rbp+var_28],... | _BYTE * func0(int a1)
{
int v1; // eax
char v3; // [rsp+17h] [rbp-29h]
int v4; // [rsp+18h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-24h]
int v6; // [rsp+20h] [rbp-20h]
int j; // [rsp+24h] [rbp-1Ch]
_BYTE *v8; // [rsp+28h] [rbp-18h]
char s[6]; // [rsp+32h] [rbp-Eh] BYREF
unsigned long long v10; // [rsp+38h]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EDX,dword ptr [RBP + -0x34]
LEA RAX,[RBP + -0xe]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010f0
MOV dword ptr [RBP + -0x28],0x0
MOV dword pt... | int * func0(uint param_1)
{
int uVar1;
char cVar2;
int *puVar3;
long in_FS_OFFSET;
int local_30;
int local_2c;
int local_28;
int local_24;
char local_16 [6];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sprintf(local_16,"%d",(ulong)param_1);
local_30 = 0;
for (local_2c = 0; ... |
993 | func0 | #include <stdio.h>
#include <stdlib.h>
| char* func0(int N) {
char str[6];
sprintf(str, "%d", N);
int sum = 0;
for (int i = 0; str[i] != '\0'; i++)
sum += str[i] - '0';
char* bi = malloc(33);
int index = 0;
if (sum == 0) {
bi[index++] = '0';
} else {
while (sum > 0) {
bi[index++] = (sum % 2)... | #include <assert.h>
#include <string.h>
int main() {
char* result;
result = func0(1000);
assert(strcmp(result, "1") == 0);
free(result);
result = func0(150);
assert(strcmp(result, "110") == 0);
free(result);
result = func0(147);
assert(strcmp(result, "1100") == 0);
free(resul... | O1 | c | func0:
endbr64
push %rbx
sub $0x10,%rsp
mov %edi,%r8d
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0x2(%rsp),%rdi
lea 0xe13(%rip),%rcx
mov $0x6,%edx
mov $0x1,%esi
callq 10d0 <__sprintf_chk@plt>
movzbl 0x2(%rsp),%eax
test %al,%al
je 12c9 <func0+0x100>
lea 0x2(%rsp),%rdx
m... | func0:
endbr64
push rbx
sub rsp, 10h
mov r8d, edi
mov rax, fs:28h
mov [rsp+18h+var_10], rax
xor eax, eax
lea rdi, [rsp+18h+var_16]
lea rcx, unk_2004
mov edx, 6
mov esi, 2
call ___sprintf_chk
movzx eax, [rsp+18h+var_16]
test al, al
jz loc_12F2
lea rdx, [rsp+18h+var... | _BYTE * func0(unsigned int a1)
{
char v1; // al
_BYTE *v2; // rdx
int v3; // ebx
_BYTE *v4; // rcx
long long v5; // rdx
int v6; // eax
int v7; // esi
int v8; // eax
int v9; // r8d
_BYTE *v10; // rdx
long long v11; // rax
char v12; // si
_BYTE v14[6]; // [rsp+2h] [rbp-16h] BYREF
unsigned long... | func0:
ENDBR64
PUSH RBX
SUB RSP,0x10
MOV R8D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x2]
LEA RCX,[0x102004]
MOV EDX,0x6
MOV ESI,0x2
CALL 0x001010f0
MOVZX EAX,byte ptr [RSP + 0x2]
TEST AL,AL
JZ 0x001012f2
LEA RDX,[RSP + 0x2]
MOV EBX,0x0
LAB_00101237:
MOVSX EAX,AL
LEA EBX... | int * func0(int4 param_1)
{
int uVar1;
bool bVar2;
char cVar3;
ulong uVar4;
int iVar5;
int iVar6;
int *puVar7;
long lVar8;
char *pcVar9;
ulong uVar10;
int *puVar11;
long in_FS_OFFSET;
char local_16;
char local_15 [5];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__spri... |
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.