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 135d <func0+0x3d>
cmp %ecx,%r8d
jg 1348 <func0+0x28>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %r8d,%eax
jle 1338 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
|
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 edi, ecx
jg short loc_1270
loc_1282:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1260
loc_128E:
mov eax, edi
retn
|
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) % v1) );
}
++v1;
}
while ( v1 * v1 <= a1 );
}
return (unsigned int)a1;
}
|
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,ECX
CMP EAX,EDI
JLE 0x00101260
LAB_0010128e:
MOV EAX,EDI
RET
|
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 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
}
return 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 132d <func0+0x3d>
cmp %ecx,%r8d
jg 1318 <func0+0x28>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %r8d,%eax
jle 1308 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
|
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 edi, ecx
jg short loc_13B0
loc_13C2:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_13A0
loc_13CE:
mov eax, edi
retn
|
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) % v1) );
}
++v1;
}
while ( v1 * v1 <= a1 );
}
return (unsigned int)a1;
}
|
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,ECX
CMP EAX,EDI
JLE 0x001013a0
LAB_001013ce:
MOV EAX,EDI
RET
|
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 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
}
return 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(!func0(")"));
assert(!func0("(()"));
assert(!func0("()()(()())())(()"));
assert(!func0("()()(()())()))()"));
return 0;
}
|
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 $0x1,-0x18(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x29,%al
jne 11ba <func0+0x51>
subl $0x1,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
jns 11c7 <func0+0x5e>
mov $0x0,%eax
jmp 11e9 <func0+0x80>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 118a <func0+0x21>
cmpl $0x0,-0x18(%rbp)
sete %al
add $0x28,%rsp
pop %rbx
pop %rbp
retq
|
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 loc_11A2
add [rbp+var_18], 1
loc_11A2:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 29h ; ')'
jnz short loc_11BA
sub [rbp+var_18], 1
loc_11BA:
cmp [rbp+var_18], 0
jns short loc_11C7
mov eax, 0
jmp short loc_11E9
loc_11C7:
add [rbp+var_14], 1
loc_11CB:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_118A
cmp [rbp+var_18], 0
setz al
loc_11E9:
mov rbx, [rbp+var_8]
leave
retn
|
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 0x001011a2
ADD dword ptr [RBP + -0x18],0x1
LAB_001011a2:
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,0x29
JNZ 0x001011ba
SUB dword ptr [RBP + -0x18],0x1
LAB_001011ba:
CMP dword ptr [RBP + -0x18],0x0
JNS 0x001011c7
MOV EAX,0x0
JMP 0x001011e9
LAB_001011c7:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011cb:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x0010118a
CMP dword ptr [RBP + -0x18],0x0
SETZ AL
LAB_001011e9:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
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 (param_1[local_1c] == ')') {
local_20 = local_20 + -1;
}
if (local_20 < 0) break;
local_1c = local_1c + 1;
}
return false;
}
|
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(!func0(")"));
assert(!func0("(()"));
assert(!func0("()()(()())())(()"));
assert(!func0("()()(()())()))()"));
return 0;
}
|
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 <func0+0x52>
cmp %rsi,%rdx
je 1195 <func0+0x4c>
movzbl (%rdx),%ecx
cmp $0x28,%cl
jne 1170 <func0+0x27>
add $0x1,%eax
jmp 117b <func0+0x32>
test %eax,%eax
sete %al
retq
mov $0x0,%eax
retq
|
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_1186
cmp dl, 29h ; ')'
jnz short loc_1189
sub ecx, 1
jns short loc_1189
mov eax, 0
jmp short loc_11B0
loc_11AB:
test ecx, ecx
setz al
loc_11B0:
pop rbx
retn
|
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;
}
return v5 == 0;
}
|
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,0x0
JMP 0x001011b0
LAB_001011ab:
TEST ECX,ECX
SETZ AL
LAB_001011b0:
POP RBX
RET
|
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 + -1, iVar2 < 0)) {
return false;
}
param_1 = param_1 + 1;
} while( true );
}
|
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(!func0(")"));
assert(!func0("(()"));
assert(!func0("()()(()())())(()"));
assert(!func0("()()(()())()))()"));
return 0;
}
|
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 1428 <func0+0x48>
movzbl (%rdi),%edx
cmp $0x28,%dl
jne 1400 <func0+0x20>
add $0x1,%ecx
jmp 140d <func0+0x2d>
nopl 0x0(%rax,%rax,1)
test %ecx,%ecx
pop %rbx
sete %al
retq
xor %eax,%eax
pop %rbx
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
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 ptr [rdi]
cmp dl, 28h ; '('
jnz short loc_1400
add ecx, 1
jmp short loc_140A
loc_1420:
xor eax, eax
pop rbx
retn
loc_1428:
test ecx, ecx
pop rbx
setz al
retn
|
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_00101420:
XOR EAX,EAX
POP RBX
RET
LAB_00101428:
TEST ECX,ECX
POP RBX
SETZ AL
RET
|
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;
}
else if (*param_1 == ')') {
bVar4 = iVar3 == 0;
iVar3 = iVar3 + -1;
if (bVar4) {
return 0;
}
}
param_1 = param_1 + 1;
} while( true );
}
|
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(!func0(")"));
assert(!func0("(()"));
assert(!func0("()()(()())())(()"));
assert(!func0("()()(()())()))()"));
return 0;
}
|
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 1428 <func0+0x48>
movzbl (%rdi),%edx
cmp $0x28,%dl
jne 1400 <func0+0x20>
add $0x1,%ecx
jmp 140d <func0+0x2d>
nopl 0x0(%rax,%rax,1)
test %ecx,%ecx
pop %rbx
sete %al
retq
xor %eax,%eax
pop %rbx
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
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 ptr [rdi]
cmp dl, 28h ; '('
jnz short loc_1400
add ecx, 1
jmp short loc_140A
loc_1420:
xor eax, eax
pop rbx
retn
loc_1428:
test ecx, ecx
pop rbx
setz al
retn
|
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_00101420:
XOR EAX,EAX
POP RBX
RET
LAB_00101428:
TEST ECX,ECX
POP RBX
SETZ AL
RET
|
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;
}
else if (*param_1 == ')') {
bVar4 = iVar3 == 0;
iVar3 = iVar3 + -1;
if (bVar4) {
return 0;
}
}
param_1 = param_1 + 1;
} while( true );
}
|
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() {
float result[4];
float case1[] = {3, 1, 2, 4, 5};
float expected1[] = {1, 4, 12, 20};
func0(case1, 5, result);
assert(issame(result, 4, expected1, 4));
float case2[] = {1, 2, 3};
float expected2[] = {2, 6};
func0(case2, 3, result);
assert(issame(result, 2, expected2, 2));
float case3[] = {3, 2, 1};
float expected3[] = {2, 2};
func0(case3, 3, result);
assert(issame(result, 2, expected3, 2));
float case4[] = {3, 2, 1, 0, 4};
float expected4[] = {2, 2, 0, 16};
func0(case4, 5, result);
assert(issame(result, 4, expected4, 4));
float case5[] = {1};
func0(case5, 1, result);
assert(issame(result, 0, NULL, 0));
return 0;
}
|
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(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mulss %xmm1,%xmm0
movss %xmm0,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1185 <func0+0x1c>
pop %rbp
retq
|
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, rdx
movss xmm0, dword ptr [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_28]
add rax, rdx
mulss xmm0, xmm1
movss dword ptr [rax], xmm0
add [rbp+var_4], 1
loc_11C6:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1185
nop
nop
pop rbp
retn
|
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 + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MULSS XMM0,XMM1
MOVSS dword ptr [RAX],XMM0
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101185
NOP
NOP
POP RBP
RET
|
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() {
float result[4];
float case1[] = {3, 1, 2, 4, 5};
float expected1[] = {1, 4, 12, 20};
func0(case1, 5, result);
assert(issame(result, 4, expected1, 4));
float case2[] = {1, 2, 3};
float expected2[] = {2, 6};
func0(case2, 3, result);
assert(issame(result, 2, expected2, 2));
float case3[] = {3, 2, 1};
float expected3[] = {2, 2};
func0(case3, 3, result);
assert(issame(result, 2, expected3, 2));
float case4[] = {3, 2, 1, 0, 4};
float expected4[] = {2, 2, 0, 16};
func0(case4, 5, result);
assert(issame(result, 4, expected4, 4));
float case5[] = {1};
func0(case5, 1, result);
assert(issame(result, 0, NULL, 0));
return 0;
}
|
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() {
float result[4];
float case1[] = {3, 1, 2, 4, 5};
float expected1[] = {1, 4, 12, 20};
func0(case1, 5, result);
assert(issame(result, 4, expected1, 4));
float case2[] = {1, 2, 3};
float expected2[] = {2, 6};
func0(case2, 3, result);
assert(issame(result, 2, expected2, 2));
float case3[] = {3, 2, 1};
float expected3[] = {2, 2};
func0(case3, 3, result);
assert(issame(result, 2, expected3, 2));
float case4[] = {3, 2, 1, 0, 4};
float expected4[] = {2, 2, 0, 16};
func0(case4, 5, result);
assert(issame(result, 4, expected4, 4));
float case5[] = {1};
func0(case5, 1, result);
assert(issame(result, 0, NULL, 0));
return 0;
}
|
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() {
float result[4];
float case1[] = {3, 1, 2, 4, 5};
float expected1[] = {1, 4, 12, 20};
func0(case1, 5, result);
assert(issame(result, 4, expected1, 4));
float case2[] = {1, 2, 3};
float expected2[] = {2, 6};
func0(case2, 3, result);
assert(issame(result, 2, expected2, 2));
float case3[] = {3, 2, 1};
float expected3[] = {2, 2};
func0(case3, 3, result);
assert(issame(result, 2, expected3, 2));
float case4[] = {3, 2, 1, 0, 4};
float expected4[] = {2, 2, 0, 16};
func0(case4, 5, result);
assert(issame(result, 4, expected4, 4));
float case5[] = {1};
func0(case5, 1, result);
assert(issame(result, 0, NULL, 0));
return 0;
}
|
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 0xd59(%rip),%xmm1
movdqa 0xd61(%rip),%xmm2
xor %eax,%eax
mov %r8d,%ecx
shr $0x2,%ecx
shl $0x4,%rcx
nopl 0x0(%rax,%rax,1)
movups 0x4(%rdi,%rax,1),%xmm3
movdqa %xmm1,%xmm0
paddd %xmm2,%xmm1
cvtdq2ps %xmm0,%xmm0
mulps %xmm3,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %rcx,%rax
jne 13c0 <func0+0x60>
mov %r8d,%eax
and $0xfffffffc,%eax
lea 0x1(%rax),%ecx
cmp %eax,%r8d
je 147c <func0+0x11c>
movslq %ecx,%r8
pxor %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss (%rdi,%r8,4),%xmm0
lea 0x2(%rax),%ecx
movss %xmm0,-0x4(%rdx,%r8,4)
cmp %ecx,%esi
jle 147c <func0+0x11c>
movslq %ecx,%r8
pxor %xmm0,%xmm0
add $0x3,%eax
cvtsi2ss %ecx,%xmm0
mulss (%rdi,%r8,4),%xmm0
movss %xmm0,-0x4(%rdx,%r8,4)
cmp %eax,%esi
jle 147c <func0+0x11c>
movslq %eax,%rcx
pxor %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss (%rdi,%rcx,4),%xmm0
movss %xmm0,-0x4(%rdx,%rcx,4)
retq
nopw 0x0(%rax,%rax,1)
lea 0x2(%rax),%rcx
mov $0x1,%eax
nopl 0x0(%rax)
pxor %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss (%rdi,%rax,4),%xmm0
movss %xmm0,-0x4(%rdx,%rax,4)
add $0x1,%rax
cmp %rcx,%rax
jne 1460 <func0+0x100>
retq
nopl (%rax)
|
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
cvtsi2ss xmm0, eax
mulss xmm0, dword ptr [rcx+rax*4]
movss dword ptr [rdx+rax*4-4], xmm0
add rax, 1
cmp rsi, rax
jnz short loc_1380
retn
locret_13A0:
retn
loc_13A8:
lea eax, [rsi-2]
lea edi, [rsi-1]
cmp eax, 2
jbe loc_145C
mov r8d, edi
movdqa xmm1, cs:xmmword_20E0
movdqa xmm2, cs:xmmword_20F0
xor eax, eax
shr r8d, 2
shl r8, 4
nop dword ptr [rax+00h]
loc_13D8:
movups xmm3, xmmword ptr [rcx+rax+4]
movdqa xmm0, xmm1
paddd xmm1, xmm2
cvtdq2ps xmm0, xmm0
mulps xmm0, xmm3
movups xmmword ptr [rdx+rax], xmm0
add rax, 10h
cmp rax, r8
jnz short loc_13D8
test dil, 3
jz short locret_13A0
and edi, 0FFFFFFFCh
lea r8d, [rdi+1]
sub esi, edi
mov eax, r8d
lea edi, [rsi-1]
cmp esi, 2
jz short loc_1445
loc_1412:
mov esi, r8d
lea r8d, [rax+1]
movd xmm0, eax
movq xmm1, qword ptr [rcx+rsi*4]
movd xmm4, r8d
punpckldq xmm0, xmm4
cvtdq2ps xmm0, xmm0
mulps xmm0, xmm1
movlps qword ptr [rdx+rsi*4-4], xmm0
test dil, 1
jz locret_13A0
and edi, 0FFFFFFFEh
add eax, edi
loc_1445:
movsxd rsi, eax
pxor xmm0, xmm0
cvtsi2ss xmm0, eax
mulss xmm0, dword ptr [rcx+rsi*4]
movss dword ptr [rdx+rsi*4-4], xmm0
retn
loc_145C:
mov eax, 1
mov r8d, 1
jmp short loc_1412
|
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 )
{
if ( a2 == 2 || (unsigned long long)(a3 - (a1 + 8)) <= 8 )
{
for ( i = 1LL; i != a2; ++i )
*(float *)(a3 + 4 * i - 4) = (float)(int)i * *(float *)(a1 + 4 * i);
return;
}
v5 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v13 = 1;
v11 = 1;
LABEL_13:
_mm_storel_ps(
(double *)(a3 + 4LL * v11 - 4),
_mm_mul_ps(
_mm_cvtepi32_ps(_mm_unpacklo_epi32(_mm_cvtsi32_si128(v13), _mm_cvtsi32_si128(v13 + 1))),
(__m128)_mm_loadl_epi64((const __m128i *)(a1 + 4LL * v11))));
if ( (v5 & 1) == 0 )
return;
v13 += v5 & 0xFFFFFFFE;
LABEL_15:
*(float *)(a3 + 4LL * v13 - 4) = (float)v13 * *(float *)(a1 + 4LL * v13);
return;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v7 = _mm_load_si128((const __m128i *)&xmmword_20F0);
v8 = 0LL;
do
{
v9 = si128;
si128 = _mm_add_epi32(si128, v7);
*(__m128 *)(a3 + v8) = _mm_mul_ps(_mm_cvtepi32_ps(v9), *(__m128 *)(a1 + v8 + 4));
v8 += 16LL;
}
while ( v8 != 16LL * (v5 >> 2) );
if ( (v5 & 3) != 0 )
{
v10 = v5 & 0xFFFFFFFC;
v11 = v10 + 1;
v12 = a2 - v10;
v13 = v10 + 1;
v5 = v12 - 1;
if ( v12 == 2 )
goto LABEL_15;
goto LABEL_13;
}
}
}
|
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 [RDX + RAX*0x4 + -0x4],XMM0
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101380
RET
LAB_001013a0:
RET
LAB_001013a8:
LEA EAX,[RSI + -0x2]
LEA EDI,[RSI + -0x1]
CMP EAX,0x2
JBE 0x0010145c
MOV R8D,EDI
MOVDQA XMM1,xmmword ptr [0x001020e0]
MOVDQA XMM2,xmmword ptr [0x001020f0]
XOR EAX,EAX
SHR R8D,0x2
SHL R8,0x4
NOP dword ptr [RAX]
LAB_001013d8:
MOVUPS XMM3,xmmword ptr [RCX + RAX*0x1 + 0x4]
MOVDQA XMM0,XMM1
PADDD XMM1,XMM2
CVTDQ2PS XMM0,XMM0
MULPS XMM0,XMM3
MOVUPS xmmword ptr [RDX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,R8
JNZ 0x001013d8
TEST DIL,0x3
JZ 0x001013a0
AND EDI,0xfffffffc
LEA R8D,[RDI + 0x1]
SUB ESI,EDI
MOV EAX,R8D
LEA EDI,[RSI + -0x1]
CMP ESI,0x2
JZ 0x00101445
LAB_00101412:
MOV ESI,R8D
LEA R8D,[RAX + 0x1]
MOVD XMM0,EAX
MOVQ XMM1,qword ptr [RCX + RSI*0x4]
MOVD XMM4,R8D
PUNPCKLDQ XMM0,XMM4
CVTDQ2PS XMM0,XMM0
MULPS XMM0,XMM1
MOVLPS qword ptr [RDX + RSI*0x4 + -0x4],XMM0
TEST DIL,0x1
JZ 0x001013a0
AND EDI,0xfffffffe
ADD EAX,EDI
LAB_00101445:
MOVSXD RSI,EAX
PXOR XMM0,XMM0
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RCX + RSI*0x4]
MOVSS dword ptr [RDX + RSI*0x4 + -0x4],XMM0
RET
LAB_0010145c:
MOV EAX,0x1
MOV R8D,0x1
JMP 0x00101412
|
/* 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;
long lVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
iVar10 = _UNK_001020fc;
iVar9 = _UNK_001020f8;
iVar8 = _UNK_001020f4;
iVar14 = _DAT_001020f0;
if (1 < (int)param_2) {
if ((param_2 == 2) || ((ulong)(param_3 - (param_1 + 8)) < 9)) {
uVar12 = 1;
do {
*(float *)(param_3 + -4 + uVar12 * 4) =
(float)(int)uVar12 * *(float *)(param_1 + uVar12 * 4);
uVar12 = uVar12 + 1;
} while (param_2 != uVar12);
return;
}
uVar1 = param_2 - 1;
if (param_2 - 2 < 3) {
uVar11 = 1;
uVar12 = 1;
}
else {
lVar13 = 0;
iVar15 = _DAT_001020e0;
iVar16 = _UNK_001020e4;
iVar17 = _UNK_001020e8;
iVar18 = _UNK_001020ec;
do {
pfVar3 = (float *)(param_1 + 4 + lVar13);
fVar5 = pfVar3[1];
fVar6 = pfVar3[2];
fVar7 = pfVar3[3];
pfVar2 = (float *)(param_3 + lVar13);
*pfVar2 = (float)iVar15 * *pfVar3;
pfVar2[1] = (float)iVar16 * fVar5;
pfVar2[2] = (float)iVar17 * fVar6;
pfVar2[3] = (float)iVar18 * fVar7;
lVar13 = lVar13 + 0x10;
iVar15 = iVar15 + iVar14;
iVar16 = iVar16 + iVar8;
iVar17 = iVar17 + iVar9;
iVar18 = iVar18 + iVar10;
} while (lVar13 != (ulong)(uVar1 >> 2) << 4);
if ((uVar1 & 3) == 0) {
return;
}
uVar11 = (uVar1 & 0xfffffffc) + 1;
uVar12 = (ulong)uVar11;
iVar14 = param_2 - (uVar1 & 0xfffffffc);
uVar1 = iVar14 - 1;
if (iVar14 == 2) goto LAB_00101445;
}
uVar4 = *(int8 *)(param_1 + uVar12 * 4);
*(ulong *)(param_3 + -4 + uVar12 * 4) =
CONCAT44((float)(int)(uVar11 + 1) * (float)((ulong)uVar4 >> 0x20),
(float)(int)uVar11 * (float)uVar4);
if ((uVar1 & 1) != 0) {
uVar11 = uVar11 + (uVar1 & 0xfffffffe);
LAB_00101445:
*(float *)(param_3 + -4 + (long)(int)uVar11 * 4) =
(float)(int)uVar11 * *(float *)(param_1 + (long)(int)uVar11 * 4);
return;
}
}
return;
}
|
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(%rbp)
jmp 1214 <func0+0xab>
mov -0x1a4(%rbp),%eax
sub $0x1,%eax
cltq
mov -0x1a0(%rbp,%rax,4),%edx
mov -0x1a4(%rbp),%eax
sub $0x2,%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
add %eax,%edx
mov -0x1a4(%rbp),%eax
sub $0x3,%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
add %eax,%edx
mov -0x1a4(%rbp),%eax
cltq
mov %edx,-0x1a0(%rbp,%rax,4)
addl $0x1,-0x1a4(%rbp)
mov -0x1a4(%rbp),%eax
cmp -0x1b4(%rbp),%eax
jle 11c4 <func0+0x5b>
mov -0x1b4(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1245 <func0+0xdc>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
|
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
jmp short loc_1214
loc_11C4:
mov eax, [rbp+var_1A4]
sub eax, 1
cdqe
mov edx, [rbp+rax*4+var_1A0]
mov eax, [rbp+var_1A4]
sub eax, 2
cdqe
mov eax, [rbp+rax*4+var_1A0]
add edx, eax
mov eax, [rbp+var_1A4]
sub eax, 3
cdqe
mov eax, [rbp+rax*4+var_1A0]
add edx, eax
mov eax, [rbp+var_1A4]
cdqe
mov [rbp+rax*4+var_1A0], edx
add [rbp+var_1A4], 1
loc_1214:
mov eax, [rbp+var_1A4]
cmp eax, [rbp+var_1B4]
jle short loc_11C4
mov eax, [rbp+var_1B4]
cdqe
mov eax, [rbp+rax*4+var_1A0]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1245
call ___stack_chk_fail
locret_1245:
leave
retn
|
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];
return (unsigned int)v3[a1];
}
|
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 + -0x1a4],0x3
JMP 0x00101214
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0x1a4]
SUB EAX,0x1
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV EAX,dword ptr [RBP + -0x1a4]
SUB EAX,0x2
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1a4]
SUB EAX,0x3
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX
ADD dword ptr [RBP + -0x1a4],0x1
LAB_00101214:
MOV EAX,dword ptr [RBP + -0x1a4]
CMP EAX,dword ptr [RBP + -0x1b4]
JLE 0x001011c4
MOV EAX,dword ptr [RBP + -0x1b4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101245
CALL 0x00101060
LAB_00101245:
LEAVE
RET
|
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;
}
local_1a8[1] = 0;
local_1a8[2] = 1;
for (local_1ac = 3; local_1ac <= param_1; local_1ac = local_1ac + 1) {
local_1a8[local_1ac] =
local_1a8[local_1ac + -1] + local_1a8[local_1ac + -2] + local_1a8[local_1ac + -3];
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_1a8[param_1];
}
|
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(%rax),%edx
add 0x8(%rax),%edx
add (%rax),%edx
mov %edx,0xc(%rax)
add $0x4,%rax
cmp %rcx,%rax
jne 11ac <func0+0x43>
movslq %esi,%rsi
mov (%rsp,%rsi,4),%eax
mov 0x198(%rsp),%rdi
xor %fs:0x28,%rdi
jne 11e1 <func0+0x78>
add $0x1a8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
|
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:
mov edx, [rax+4]
add edx, [rax+8]
add edx, [rax]
mov [rax+0Ch], edx
add rax, 4
cmp rax, rcx
jnz short loc_11AC
loc_11C0:
movsxd rsi, esi
mov eax, [rsp+rsi*4+1A8h+var_1A8]
mov rdx, [rsp+1A8h+var_10]
sub rdx, fs:28h
jnz short loc_11E1
add rsp, 1A8h
retn
loc_11E1:
call ___stack_chk_fail
|
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;
}
while ( v1 != &v3[a1 - 3 + 1] );
}
return (unsigned int)v3[a1];
}
|
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 EDX,dword ptr [RAX + 0x8]
ADD EDX,dword ptr [RAX]
MOV dword ptr [RAX + 0xc],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011ac
LAB_001011c0:
MOVSXD RSI,ESI
MOV EAX,dword ptr [RSP + RSI*0x4]
MOV RDX,qword ptr [RSP + 0x198]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001011e1
ADD RSP,0x1a8
RET
LAB_001011e1:
CALL 0x00101060
|
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 *)((long)piVar3 + 8);
}
local_1a8[2] = 1;
if (2 < param_1) {
do {
piVar1[3] = piVar1[1] + piVar1[2] + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != local_1a8 + (ulong)(param_1 - 3) + 1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_1a8[param_1];
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
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,%esi
lea 0x8(%rsp,%rdx,4),%rdi
mov $0x1,%edx
jmp 1348 <func0+0x68>
nopl 0x0(%rax,%rax,1)
mov 0x4(%rax),%edx
mov (%rax),%ecx
mov -0x4(%rax),%esi
add %ecx,%edx
add $0x4,%rax
add %esi,%edx
mov %edx,0x4(%rax)
cmp %rax,%rdi
jne 1340 <func0+0x60>
mov 0x198(%rsp),%rdi
xor %fs:0x28,%rdi
mov (%rsp,%r8,4),%eax
jne 1377 <func0+0x97>
add $0x1a8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
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+rax*4+1A8h+var_198]
mov eax, 1
nop
loc_1330:
mov esi, eax
lea eax, [rax+rcx]
add rdx, 4
add eax, edi
mov edi, ecx
mov ecx, esi
mov [rdx-4], eax
cmp rdx, r8
jnz short loc_1330
loc_1347:
mov eax, [rsp+r9*4+1A8h+var_1A8]
mov rdx, [rsp+1A8h+var_10]
sub rdx, fs:28h
jnz short loc_1366
add rsp, 1A8h
retn
loc_1366:
call ___stack_chk_fail
|
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] = 1;
if ( a1 > 2 )
{
v3 = &v8[3];
v4 = 0;
v5 = 1;
do
{
v6 = v5;
++v3;
v5 += v4 + v2;
v4 = v2;
v2 = v6;
*(v3 - 1) = v5;
}
while ( v3 != &v8[(unsigned int)(v1 - 3) + 4] );
}
return (unsigned int)v8[v1];
}
|
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_00101330:
MOV ESI,EAX
LEA EAX,[RAX + RCX*0x1]
ADD RDX,0x4
ADD EAX,EDI
MOV EDI,ECX
MOV ECX,ESI
MOV dword ptr [RDX + -0x4],EAX
CMP RDX,R8
JNZ 0x00101330
LAB_00101347:
MOV EAX,dword ptr [RSP + R9*0x4]
MOV RDX,qword ptr [RSP + 0x198]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101366
ADD RSP,0x1a8
RET
LAB_00101366:
CALL 0x00101060
|
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 = 0x32; lVar4 != 0; lVar4 = lVar4 + -1) {
*puVar8 = 0;
puVar8 = puVar8 + 1;
}
local_1a0 = 1;
if (2 < param_1) {
piVar5 = local_19c;
iVar2 = 1;
iVar1 = 0;
iVar7 = 0;
do {
iVar3 = iVar1;
iVar1 = iVar2;
piVar6 = piVar5 + 1;
iVar2 = iVar1 + iVar3 + iVar7;
*piVar5 = iVar2;
piVar5 = piVar6;
iVar7 = iVar3;
} while (piVar6 != local_19c + (ulong)(param_1 - 3) + 1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)((long)&uStack_1a8 + (long)param_1 * 4);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
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
jle 13b5 <func0+0xd5>
mov (%rsp),%r8d
lea 0xc(%rsp),%rdi
mov $0x1,%edx
xor %eax,%eax
mov $0x3,%ecx
lea (%rdx,%rax,1),%r10d
add $0xc,%rdi
add %r10d,%r8d
lea (%r8,%rdx,1),%r10d
mov %r8d,-0xc(%rdi)
add %r10d,%eax
lea (%r8,%rax,1),%r10d
mov %eax,-0x8(%rdi)
add %r10d,%edx
mov %ecx,%r10d
add $0x3,%ecx
add $0x4,%r10d
mov %edx,-0x4(%rdi)
cmp %r10d,%r11d
jg 1345 <func0+0x65>
movslq %ecx,%rax
lea (%r9,%rax,4),%rax
xchg %ax,%ax
mov -0x4(%rax),%edx
add $0x1,%ecx
add -0x8(%rax),%edx
add $0x4,%rax
add -0x10(%rax),%edx
mov %edx,-0x4(%rax)
cmp %ecx,%esi
jge 1380 <func0+0xa0>
mov 0x198(%rsp),%rdi
xor %fs:0x28,%rdi
mov (%rsp,%rsi,4),%eax
jne 13bc <func0+0xdc>
add $0x1a8,%rsp
retq
mov $0x3,%ecx
jmp 1377 <func0+0x97>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
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, [rsp+1A8h+var_19C]
mov edi, 1
xor edx, edx
mov ecx, 3
loc_133A:
lea r10d, [rdx+rdi]
add r8, 0Ch
add eax, r10d
lea r10d, [rax+rdi]
mov [r8-0Ch], eax
add edx, r10d
lea r10d, [rax+rdx]
mov [r8-8], edx
add edi, r10d
mov r10d, ecx
add ecx, 3
add r10d, 4
mov [r8-4], edi
cmp r11d, r10d
jg short loc_133A
loc_136E:
movsxd rax, ecx
lea rax, [r9+rax*4]
nop dword ptr [rax]
loc_1378:
mov edx, [rax-4]
add ecx, 1
add edx, [rax-8]
add rax, 4
add edx, [rax-10h]
mov [rax-4], edx
cmp esi, ecx
jge short loc_1378
loc_138F:
mov eax, [rsp+rsi*4+1A8h+var_1A8]
mov rdx, [rsp+1A8h+var_10]
sub rdx, fs:28h
jnz short loc_13B4
add rsp, 1A8h
retn
loc_13AD:
mov ecx, 3
jmp short loc_136E
loc_13B4:
call ___stack_chk_fail
|
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 = __readfsqword(0x28u);
v2 = 0;
memset(v11, 0, 0x190uLL);
v11[2] = 1;
if ( a1 > 2 )
{
if ( a1 <= 5 )
{
v6 = 3;
}
else
{
v3 = &v11[3];
v4 = 1;
v5 = 0;
v6 = 3;
do
{
v3 += 3;
v2 += v5 + v4;
*(v3 - 3) = v2;
v5 += v2 + v4;
*(v3 - 2) = v5;
v4 += v2 + v5;
v7 = v6;
v6 += 3;
*(v3 - 1) = v4;
}
while ( (int)v1 - 1 > v7 + 4 );
}
v8 = &v11[v6];
do
{
++v6;
v9 = *(v8 - 2) + *(v8 - 1);
++v8;
*(v8 - 1) = *(v8 - 4) + v9;
}
while ( (int)v1 >= v6 );
}
return (unsigned int)v11[v1];
}
|
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 ECX,0x3
LAB_0010133a:
LEA R10D,[RDX + RDI*0x1]
ADD R8,0xc
ADD EAX,R10D
LEA R10D,[RAX + RDI*0x1]
MOV dword ptr [R8 + -0xc],EAX
ADD EDX,R10D
LEA R10D,[RAX + RDX*0x1]
MOV dword ptr [R8 + -0x8],EDX
ADD EDI,R10D
MOV R10D,ECX
ADD ECX,0x3
ADD R10D,0x4
MOV dword ptr [R8 + -0x4],EDI
CMP R11D,R10D
JG 0x0010133a
LAB_0010136e:
MOVSXD RAX,ECX
LEA RAX,[R9 + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101378:
MOV EDX,dword ptr [RAX + -0x4]
ADD ECX,0x1
ADD EDX,dword ptr [RAX + -0x8]
ADD RAX,0x4
ADD EDX,dword ptr [RAX + -0x10]
MOV dword ptr [RAX + -0x4],EDX
CMP ESI,ECX
JGE 0x00101378
LAB_0010138f:
MOV EAX,dword ptr [RSP + RSI*0x4]
MOV RDX,qword ptr [RSP + 0x198]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013b4
ADD RSP,0x1a8
RET
LAB_001013ad:
MOV ECX,0x3
JMP 0x0010136e
LAB_001013b4:
CALL 0x00101060
|
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 = lVar5 + -1) {
*(int8 *)piVar2 = 0;
piVar2 = (int *)((long)piVar2 + 8);
}
aiStack_1a8[2] = 1;
if (2 < param_1) {
if (param_1 < 6) {
iVar4 = 3;
}
else {
piVar2 = aiStack_1a8;
iVar7 = 1;
iVar6 = 0;
iVar3 = 3;
do {
piVar2 = piVar2 + 3;
iVar1 = iVar1 + iVar6 + iVar7;
*piVar2 = iVar1;
iVar6 = iVar6 + iVar1 + iVar7;
piVar2[1] = iVar6;
iVar7 = iVar7 + iVar1 + iVar6;
iVar4 = iVar3 + 3;
iVar8 = iVar3 + 4;
piVar2[2] = iVar7;
iVar3 = iVar4;
} while (iVar8 < param_1 + -1);
}
piVar2 = aiStack_1a8 + iVar4;
do {
iVar4 = iVar4 + 1;
*piVar2 = piVar2[-1] + piVar2[-2] + piVar2[-3];
piVar2 = piVar2 + 1;
} while (iVar4 <= param_1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return aiStack_1a8[param_1];
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
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++;
}
return 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
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x8(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 11ed <func0+0x64>
addl $0x1,-0x14(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jl 11c3 <func0+0x3a>
cmpl $0x0,-0xc(%rbp)
jle 1231 <func0+0xa8>
mov -0xc(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x79,%al
je 122d <func0+0xa4>
mov -0xc(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x59,%al
jne 1231 <func0+0xa8>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
leaveq
retq
|
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, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+var_8]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jz short loc_11ED
add [rbp+var_14], 1
loc_11ED:
add [rbp+var_10], 1
loc_11F1:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jl short loc_11C3
cmp [rbp+var_C], 0
jle short loc_1231
mov eax, [rbp+var_C]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 79h ; 'y'
jz short loc_122D
mov eax, [rbp+var_C]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 59h ; 'Y'
jnz short loc_1231
loc_122D:
add [rbp+var_14], 1
loc_1231:
mov eax, [rbp+var_14]
leave
retn
|
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) )
++v2;
return v2;
}
|
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 EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101080
TEST RAX,RAX
JZ 0x001011ed
ADD dword ptr [RBP + -0x14],0x1
LAB_001011ed:
ADD dword ptr [RBP + -0x10],0x1
LAB_001011f1:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JL 0x001011c3
CMP dword ptr [RBP + -0xc],0x0
JLE 0x00101231
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x79
JZ 0x0010122d
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x59
JNZ 0x00101231
LAB_0010122d:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101231:
MOV EAX,dword ptr [RBP + -0x14]
LEAVE
RET
|
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 *)0x0) {
local_1c = local_1c + 1;
}
}
if ((0 < iVar1) && ((param_1[(long)iVar1 + -1] == 'y' || (param_1[(long)iVar1 + -1] == 'Y')))) {
local_1c = local_1c + 1;
}
return local_1c;
}
|
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++;
}
return 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 0x1(%r15,%rax,1),%r14
mov $0x0,%ebp
lea 0xe53(%rip),%r13
movsbl (%rbx),%esi
mov %r13,%rdi
callq 1060 <strchr@plt>
cmp $0x1,%rax
sbb $0xffffffff,%ebp
add $0x1,%rbx
cmp %r14,%rbx
jne 11b1 <func0+0x48>
movslq %r12d,%r12
movzbl -0x1(%r15,%r12,1),%eax
and $0xffffffdf,%eax
cmp $0x59,%al
sete %al
movzbl %al,%eax
add %eax,%ebp
mov %ebp,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x0,%ebp
jmp 11e2 <func0+0x79>
|
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, byte ptr [rbx]; c
mov rdi, r12; s
call _strchr
cmp rax, 1
sbb ebp, 0FFFFFFFFh
add rbx, 1
cmp rbx, r13
jnz short loc_11C1
movsxd r14, r14d
movzx eax, byte ptr [r15+r14-1]
and eax, 0FFFFFFDFh
cmp al, 59h ; 'Y'
setz al
movzx eax, al
add ebp, eax
loc_11F2:
mov eax, ebp
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1203:
mov ebp, 0
jmp short loc_11F2
|
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", *v3++) == 0LL) - 1;
while ( v3 != (const char *)v4 );
return (unsigned int)(((a1[v2 - 1] & 0xDF) == 89) + v5);
}
}
|
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,0x1
SBB EBP,-0x1
ADD RBX,0x1
CMP RBX,R13
JNZ 0x001011c1
MOVSXD R14,R14D
MOVZX EAX,byte ptr [R15 + R14*0x1 + -0x1]
AND EAX,0xffffffdf
CMP AL,0x59
SETZ AL
MOVZX EAX,AL
ADD EBP,EAX
LAB_001011f2:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101203:
MOV EBP,0x0
JMP 0x001011f2
|
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 + 1) - (uint)(pcVar3 == (char *)0x0);
pcVar4 = pcVar4 + 1;
} while (pcVar4 != param_1 + (ulong)(iVar1 - 1) + 1);
iVar5 = iVar5 + (uint)((param_1[(long)iVar1 + -1] & 0xdfU) == 0x59);
}
return 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++;
}
return 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
nopw %cs:0x0(%rax,%rax,1)
movsbl (%rbx),%esi
mov %rbp,%rdi
callq 1080 <strchr@plt>
cmp $0x1,%rax
sbb $0xffffffff,%r15d
add $0x1,%rbx
cmp %r12,%rbx
jne 1340 <func0+0x40>
movslq %r13d,%r13
movzbl -0x1(%r14,%r13,1),%eax
and $0xffffffdf,%eax
cmp $0x59,%al
sete %al
movzbl %al,%eax
add %eax,%r15d
add $0x8,%rsp
mov %r15d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %r15d,%r15d
jmp 1373 <func0+0x73>
nopl (%rax)
|
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 [rax]
loc_1338:
movsx esi, byte ptr [rbx]; c
mov rdi, r12; s
call _strchr
cmp rax, 1
sbb ebp, 0FFFFFFFFh
add rbx, 1
cmp rbx, r13
jnz short loc_1338
movsxd r14, r14d
movzx eax, byte ptr [r15+r14-1]
and eax, 0FFFFFFDFh
cmp al, 59h ; 'Y'
setz al
movzx eax, al
add ebp, eax
loc_1369:
add rsp, 8
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1380:
xor ebp, ebp
jmp short loc_1369
|
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", *v3++) == 0LL) - 1;
while ( v3 != (const char *)v5 );
return (unsigned int)(((a1[v2 - 1] & 0xDF) == 89) + v4);
}
}
|
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 0x00101080
CMP RAX,0x1
SBB EBP,-0x1
ADD RBX,0x1
CMP RBX,R13
JNZ 0x00101338
MOVSXD R14,R14D
MOVZX EAX,byte ptr [R15 + R14*0x1 + -0x1]
AND EAX,0xffffffdf
CMP AL,0x59
SETZ AL
MOVZX EAX,AL
ADD EBP,EAX
LAB_00101369:
ADD RSP,0x8
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101380:
XOR EBP,EBP
JMP 0x00101369
|
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 + 1) - (uint)(pcVar3 == (char *)0x0);
pcVar4 = pcVar4 + 1;
} while (pcVar4 != param_1 + (ulong)(iVar1 - 1) + 1);
iVar5 = iVar5 + (uint)((param_1[(long)iVar1 + -1] & 0xdfU) == 0x59);
}
return 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++;
}
return 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
nopw %cs:0x0(%rax,%rax,1)
movsbl (%rbx),%esi
mov %rbp,%rdi
callq 1080 <strchr@plt>
cmp $0x1,%rax
sbb $0xffffffff,%r15d
add $0x1,%rbx
cmp %r12,%rbx
jne 1340 <func0+0x40>
movslq %r13d,%r13
movzbl -0x1(%r14,%r13,1),%eax
and $0xffffffdf,%eax
cmp $0x59,%al
sete %al
movzbl %al,%eax
add %eax,%r15d
add $0x8,%rsp
mov %r15d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %r15d,%r15d
jmp 1373 <func0+0x73>
nopl (%rax)
|
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 [rax]
loc_1338:
movsx esi, byte ptr [rbx]; c
mov rdi, r12; s
call _strchr
cmp rax, 1
sbb ebp, 0FFFFFFFFh
add rbx, 1
cmp rbx, r13
jnz short loc_1338
movsxd r14, r14d
movzx eax, byte ptr [r15+r14-1]
and eax, 0FFFFFFDFh
cmp al, 59h ; 'Y'
setz al
movzx eax, al
add ebp, eax
loc_1369:
add rsp, 8
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1380:
xor ebp, ebp
jmp short loc_1369
|
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", *v3++) == 0LL) - 1;
while ( v3 != (const char *)v5 );
return (unsigned int)(((a1[v2 - 1] & 0xDF) == 89) + v4);
}
}
|
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 0x00101080
CMP RAX,0x1
SBB EBP,-0x1
ADD RBX,0x1
CMP RBX,R13
JNZ 0x00101338
MOVSXD R14,R14D
MOVZX EAX,byte ptr [R15 + R14*0x1 + -0x1]
AND EAX,0xffffffdf
CMP AL,0x59
SETZ AL
MOVZX EAX,AL
ADD EBP,EAX
LAB_00101369:
ADD RSP,0x8
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101380:
XOR EBP,EBP
JMP 0x00101369
|
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 + 1) - (uint)(pcVar3 == (char *)0x0);
pcVar4 = pcVar4 + 1;
} while (pcVar4 != param_1 + (ulong)(iVar1 - 1) + 1);
iVar5 = iVar5 + (uint)((param_1[(long)iVar1 + -1] & 0xdfU) == 0x59);
}
return 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[50];
strcpy(temp, xs + len - shift);
temp[shift] = '\0';
strncat(temp, xs, len - shift);
strcpy(xs, temp);
}
return xs;
}
|
#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(%rip),%rdi
callq 10c0 <strlen@plt>
mov %eax,-0x44(%rbp)
mov -0x44(%rbp),%eax
cmp -0x58(%rbp),%eax
jge 12cf <func0+0xc6>
movl $0x0,-0x48(%rbp)
jmp 12bc <func0+0xb3>
mov -0x48(%rbp),%eax
cltq
lea 0x2dcd(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
mov %al,-0x49(%rbp)
mov -0x44(%rbp),%eax
sub $0x1,%eax
sub -0x48(%rbp),%eax
cltq
lea 0x2db4(%rip),%rdx
movzbl (%rax,%rdx,1),%edx
mov -0x48(%rbp),%eax
cltq
lea 0x2da4(%rip),%rcx
mov %dl,(%rax,%rcx,1)
mov -0x44(%rbp),%eax
sub $0x1,%eax
sub -0x48(%rbp),%eax
cltq
lea 0x2d8f(%rip),%rcx
movzbl -0x49(%rbp),%edx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x48(%rbp)
mov -0x44(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x48(%rbp)
jl 1267 <func0+0x5e>
jmp 132f <func0+0x126>
mov -0x44(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%eax
cltq
sub %rax,%rdx
lea 0x2d5c(%rip),%rax
add %rax,%rdx
lea -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcpy@plt>
mov -0x58(%rbp),%eax
cltq
movb $0x0,-0x40(%rbp,%rax,1)
mov -0x44(%rbp),%eax
sub -0x58(%rbp),%eax
movslq %eax,%rdx
lea -0x40(%rbp),%rax
lea 0x2d2c(%rip),%rsi
mov %rax,%rdi
callq 10f0 <strncat@plt>
lea -0x40(%rbp),%rax
mov %rax,%rsi
lea 0x2d16(%rip),%rdi
callq 10b0 <strcpy@plt>
lea 0x2d0a(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 134a <func0+0x141>
callq 10d0 <__stack_chk_fail@plt>
leaveq
retq
|
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, 0
call _sprintf
lea rax, xs_1
mov rdi, rax; s
call _strlen
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
cmp eax, [rbp+var_58]
jge short loc_12D8
mov [rbp+var_48], 0
jmp short loc_12C5
loc_1270:
mov eax, [rbp+var_48]
cdqe
lea rdx, xs_1
movzx eax, byte ptr [rax+rdx]
mov [rbp+var_49], al
mov eax, [rbp+var_44]
sub eax, 1
sub eax, [rbp+var_48]
cdqe
lea rdx, xs_1
movzx edx, byte ptr [rax+rdx]
mov eax, [rbp+var_48]
cdqe
lea rcx, xs_1
mov [rax+rcx], dl
mov eax, [rbp+var_44]
sub eax, 1
sub eax, [rbp+var_48]
cdqe
lea rcx, xs_1
movzx edx, [rbp+var_49]
mov [rax+rcx], dl
add [rbp+var_48], 1
loc_12C5:
mov eax, [rbp+var_44]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_48], eax
jl short loc_1270
jmp short loc_133E
loc_12D8:
mov eax, [rbp+var_44]
movsxd rdx, eax
mov eax, [rbp+var_58]
cdqe
sub rdx, rax
lea rax, xs_1
add rdx, rax
lea rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov eax, [rbp+var_58]
cdqe
mov [rbp+rax+dest], 0
mov eax, [rbp+var_44]
sub eax, [rbp+var_58]
movsxd rdx, eax; n
lea rax, [rbp+dest]
lea rcx, xs_1
mov rsi, rcx; src
mov rdi, rax; dest
call _strncat
lea rax, [rbp+dest]
mov rsi, rax; src
lea rax, xs_1
mov rdi, rax; dest
call _strcpy
loc_133E:
lea rax, xs_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1359
call ___stack_chk_fail
locret_1359:
leave
retn
|
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 )
{
strcpy(dest, &xs_1[v5 - (long long)a2]);
dest[a2] = 0;
strncat(dest, xs_1, v5 - a2);
strcpy(xs_1, dest);
}
else
{
for ( i = 0; i < v5 / 2; ++i )
{
v3 = xs_1[i];
xs_1[i] = xs_1[v5 - 1 - i];
xs_1[v5 - 1 - i] = v3;
}
}
return xs_1;
}
|
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
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x58]
JGE 0x001012d8
MOV dword ptr [RBP + -0x48],0x0
JMP 0x001012c5
LAB_00101270:
MOV EAX,dword ptr [RBP + -0x48]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
MOV byte ptr [RBP + -0x49],AL
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x48]
CDQE
LEA RDX,[0x104040]
MOVZX EDX,byte ptr [RAX + RDX*0x1]
MOV EAX,dword ptr [RBP + -0x48]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x48]
CDQE
LEA RCX,[0x104040]
MOVZX EDX,byte ptr [RBP + -0x49]
MOV byte ptr [RAX + RCX*0x1],DL
ADD dword ptr [RBP + -0x48],0x1
LAB_001012c5:
MOV EAX,dword ptr [RBP + -0x44]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x48],EAX
JL 0x00101270
JMP 0x0010133e
LAB_001012d8:
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CDQE
SUB RDX,RAX
LEA RAX,[0x104040]
ADD RDX,RAX
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0x58]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x40],0x0
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,dword ptr [RBP + -0x58]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x40]
LEA RCX,[0x104040]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010f0
LEA RAX,[RBP + -0x40]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010b0
LAB_0010133e:
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101359
CALL 0x001010d0
LAB_00101359:
LEAVE
RET
|
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) {
for (local_50 = 0; local_50 < iVar2 / 2; local_50 = local_50 + 1) {
uVar1 = xs_1[local_50];
xs_1[local_50] = xs_1[(iVar2 + -1) - local_50];
xs_1[(iVar2 + -1) - local_50] = uVar1;
}
}
else {
strcpy(local_48,xs_1 + ((long)iVar2 - (long)param_2));
local_48[param_2] = '\0';
strncat(local_48,xs_1,(long)(iVar2 - param_2));
strcpy(xs_1,local_48);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return xs_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
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[50];
strcpy(temp, xs + len - shift);
temp[shift] = '\0';
strncat(temp, xs, len - shift);
strcpy(xs, temp);
}
return xs;
}
|
#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(%rip),%rdi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
cmp %ebp,%ebx
jge 1297 <func0+0xce>
mov %ebx,%r8d
shr $0x1f,%r8d
add %ebx,%r8d
sar %r8d
cmp $0x1,%ebx
jle 1273 <func0+0xaa>
movslq %ebx,%rdx
lea 0x2df9(%rip),%rax
add %rax,%rdx
mov $0x0,%eax
lea 0x2dea(%rip),%rcx
movzbl (%rcx,%rax,1),%esi
movzbl -0x1(%rdx),%edi
mov %dil,(%rcx,%rax,1)
mov %sil,-0x1(%rdx)
add $0x1,%rax
sub $0x1,%rdx
cmp %eax,%r8d
jg 1256 <func0+0x8d>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 12e6 <func0+0x11d>
lea 0x2db6(%rip),%rax
add $0x40,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
movslq %ebx,%rsi
movslq %ebp,%r14
sub %r14,%rsi
lea 0x2d99(%rip),%r12
add %r12,%rsi
mov %rsp,%r13
mov $0x32,%edx
mov %r13,%rdi
callq 10b0 <__strcpy_chk@plt>
movb $0x0,(%rsp,%r14,1)
sub %ebp,%ebx
movslq %ebx,%rdx
mov $0x32,%ecx
mov %r12,%rsi
mov %r13,%rdi
callq 10c0 <__strncat_chk@plt>
mov $0x32,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 10b0 <__strcpy_chk@plt>
jmp 1273 <func0+0xaa>
callq 1090 <__stack_chk_fail@plt>
|
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
call _strlen
cmp eax, ebp
jge short loc_12B6
mov r8d, eax
shr r8d, 1Fh
add r8d, eax
sar r8d, 1
cmp eax, 1
jle short loc_1294
cdqe
add rax, rbx
mov edx, 0
mov rcx, rbx
loc_1277:
movzx esi, byte ptr [rcx+rdx]
movzx edi, byte ptr [rax-1]
mov [rcx+rdx], dil
mov [rax-1], sil
add rdx, 1
sub rax, 1
cmp r8d, edx
jg short loc_1277
loc_1294:
mov rax, [rsp+68h+var_30]
sub rax, fs:28h
jnz short loc_1303
lea rax, xs_1
add rsp, 48h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12B6:
movsxd rbx, eax
movsxd rbp, ebp
sub rbx, rbp
lea r12, xs_1
lea rsi, [rbx+r12]
mov r13, rsp
mov edx, 32h ; '2'
mov rdi, r13
call ___strcpy_chk
mov [rsp+rbp+68h+var_68], 0
mov ecx, 32h ; '2'
mov rdx, rbx
mov rsi, r12
mov rdi, r13
call ___strncat_chk
mov edx, 32h ; '2'
mov rsi, r13
mov rdi, r12
call ___strcpy_chk
jmp short loc_1294
loc_1303:
call ___stack_chk_fail
|
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_2004, a1);
v2 = strlen(xs_1);
if ( v2 >= a2 )
{
v8 = v2 - (long long)a2;
__strcpy_chk(v9, &xs_1[v8], 50LL);
v9[a2] = 0;
__strncat_chk(v9, xs_1, v8, 50LL);
__strcpy_chk(xs_1, v9, 50LL);
}
else
{
v3 = v2 / 2;
if ( v2 > 1 )
{
v4 = &xs_1[v2];
v5 = 0LL;
do
{
v6 = xs_1[v5];
xs_1[v5] = *(v4 - 1);
*(v4 - 1) = v6;
++v5;
--v4;
}
while ( v3 > (int)v5 );
}
}
return xs_1;
}
|
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 R8D,0x1f
ADD R8D,EAX
SAR R8D,0x1
CMP EAX,0x1
JLE 0x00101294
CDQE
ADD RAX,RBX
MOV EDX,0x0
MOV RCX,RBX
LAB_00101277:
MOVZX ESI,byte ptr [RCX + RDX*0x1]
MOVZX EDI,byte ptr [RAX + -0x1]
MOV byte ptr [RCX + RDX*0x1],DIL
MOV byte ptr [RAX + -0x1],SIL
ADD RDX,0x1
SUB RAX,0x1
CMP R8D,EDX
JG 0x00101277
LAB_00101294:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101303
LEA RAX,[0x104040]
ADD RSP,0x48
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012b6:
MOVSXD RBX,EAX
MOVSXD RBP,EBP
SUB RBX,RBP
LEA R12,[0x104040]
LEA RSI,[RBX + R12*0x1]
MOV R13,RSP
MOV EDX,0x32
MOV RDI,R13
CALL 0x001010f0
MOV byte ptr [RSP + RBP*0x1],0x0
MOV ECX,0x32
MOV RDX,RBX
MOV RSI,R12
MOV RDI,R13
CALL 0x00101100
MOV EDX,0x32
MOV RSI,R13
MOV RDI,R12
CALL 0x001010f0
JMP 0x00101294
LAB_00101303:
CALL 0x001010c0
|
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)sVar3;
if (iVar2 < param_2) {
if (1 < iVar2) {
puVar4 = &xs_1 + iVar2;
lVar5 = 0;
do {
uVar1 = (&xs_1)[lVar5];
(&xs_1)[lVar5] = puVar4[-1];
puVar4[-1] = uVar1;
lVar5 = lVar5 + 1;
puVar4 = puVar4 + -1;
} while ((int)lVar5 < (int)(((uint)(sVar3 >> 0x1f) & 1) + iVar2) >> 1);
}
}
else {
lVar5 = (long)iVar2 - (long)param_2;
__strcpy_chk(auStack_68,&xs_1 + lVar5,0x32);
auStack_68[param_2] = 0;
__strncat_chk(auStack_68,&xs_1,lVar5,0x32);
__strcpy_chk(&xs_1,auStack_68,0x32);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return &xs_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
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[50];
strcpy(temp, xs + len - shift);
temp[shift] = '\0';
strncat(temp, xs, len - shift);
strcpy(xs, temp);
}
return xs;
}
|
#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,%rsi
mov %rcx,%rbx
mov (%rbx),%edx
add $0x4,%rbx
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 137b <func0+0x4b>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rbx),%rdx
cmove %rdx,%rbx
mov %eax,%edi
add %al,%dil
sbb $0x3,%rbx
sub %rcx,%rbx
movslq %ebx,%rcx
cmp %ebp,%ebx
jge 1418 <func0+0xe8>
sar %ebx
je 13f2 <func0+0xc2>
lea 0x2c7b(%rip),%rax
lea -0x1(%rbx),%edi
lea 0x1(%rax),%rdx
lea -0x1(%rsi,%rcx,1),%rcx
add %rdx,%rdi
nopl 0x0(%rax)
movzbl (%rcx),%esi
movzbl (%rax),%edx
add $0x1,%rax
sub $0x1,%rcx
mov %sil,-0x1(%rax)
mov %dl,0x1(%rcx)
cmp %rdi,%rax
jne 13d8 <func0+0xa8>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1468 <func0+0x138>
add $0x40,%rsp
lea 0x2c33(%rip),%rax
pop %rbx
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
movslq %ebp,%r12
mov %rbx,%rax
mov %rsp,%r8
mov $0x32,%edx
sub %r12,%rax
mov %r8,%rdi
sub %ebp,%ebx
add %rax,%rsi
callq 10b0 <__strcpy_chk@plt>
movslq %ebx,%rdx
mov $0x32,%ecx
lea 0x2bfb(%rip),%rsi
mov %rax,%rdi
movb $0x0,(%rsp,%r12,1)
callq 10c0 <__strncat_chk@plt>
mov $0x32,%edx
lea 0x2be2(%rip),%rdi
mov %rax,%rsi
callq 10b0 <__strcpy_chk@plt>
jmp 13f2 <func0+0xc2>
callq 1090 <__stack_chk_fail@plt>
nopl (%rax)
|
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 _strlen
cmp eax, r12d
jge short loc_1400
mov edi, eax
sar edi, 1
jz short loc_13E2
movsxd rdi, edi
mov rdx, rbx
lea rax, [rbx+rax-1]
add rdi, rbx
nop dword ptr [rax+rax+00h]
loc_13C8:
movzx esi, byte ptr [rax]
movzx ecx, byte ptr [rdx]
add rdx, 1
sub rax, 1
mov [rdx-1], sil
mov [rax+1], cl
cmp rdx, rdi
jnz short loc_13C8
loc_13E2:
mov rax, [rsp+58h+var_20]
sub rax, fs:28h
jnz short loc_1441
add rsp, 40h
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_1400:
sub rax, r12
mov rdi, rsp
mov edx, 32h ; '2'
lea rsi, [rbx+rax]
mov rbp, rax
call ___strcpy_chk
mov rdx, rbp
mov rsi, rbx
mov ecx, 32h ; '2'
mov rdi, rax
mov [rsp+r12+58h+var_58], 0
call ___strncat_chk
mov edx, 32h ; '2'
mov rdi, rbx
mov rsi, rax
call ___strcpy_chk
jmp short loc_13E2
loc_1441:
call ___stack_chk_fail
|
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] [rbp-20h]
v14 = __readfsqword(0x28u);
__sprintf_chk(xs_1, 2LL, 50LL, &unk_2004, a1);
v2 = strlen(xs_1);
if ( (int)v2 >= a2 )
{
v10 = v2 - a2;
v11 = __strcpy_chk(v13, &xs_1[v10], 50LL);
v13[a2] = 0;
v12 = __strncat_chk(v11, xs_1, v10, 50LL);
__strcpy_chk(xs_1, v12, 50LL);
}
else
{
v3 = (int)v2 >> 1;
if ( (int)v2 >> 1 )
{
v4 = xs_1;
v5 = &xs_1[v2 - 1];
v6 = &xs_1[v3];
do
{
v7 = *v5;
v8 = *v4++;
--v5;
*(v4 - 1) = v7;
v5[1] = v8;
}
while ( v4 != v6 );
}
}
return xs_1;
}
|
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,0x1
JZ 0x001013e2
MOVSXD RDI,EDI
MOV RDX,RBX
LEA RAX,[RBX + RAX*0x1 + -0x1]
ADD RDI,RBX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c8:
MOVZX ESI,byte ptr [RAX]
MOVZX ECX,byte ptr [RDX]
ADD RDX,0x1
SUB RAX,0x1
MOV byte ptr [RDX + -0x1],SIL
MOV byte ptr [RAX + 0x1],CL
CMP RDX,RDI
JNZ 0x001013c8
LAB_001013e2:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101441
ADD RSP,0x40
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_00101400:
SUB RAX,R12
MOV RDI,RSP
MOV EDX,0x32
LEA RSI,[RBX + RAX*0x1]
MOV RBP,RAX
CALL 0x001010f0
MOV RDX,RBP
MOV RSI,RBX
MOV ECX,0x32
MOV RDI,RAX
MOV byte ptr [RSP + R12*0x1],0x0
CALL 0x00101100
MOV EDX,0x32
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001010f0
JMP 0x001013e2
LAB_00101441:
CALL 0x001010c0
|
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);
sVar2 = strlen(&xs_1);
if ((int)sVar2 < param_2) {
iVar8 = (int)sVar2 >> 1;
if (iVar8 != 0) {
puVar3 = &DAT_0010403f + sVar2;
puVar6 = &xs_1;
do {
uVar1 = *puVar6;
puVar7 = puVar6 + 1;
*puVar6 = *puVar3;
*puVar3 = uVar1;
puVar3 = puVar3 + -1;
puVar6 = puVar7;
} while (puVar7 != &xs_1 + iVar8);
}
}
else {
lVar4 = sVar2 - (long)param_2;
uVar5 = __strcpy_chk(auStack_58,&xs_1 + lVar4,0x32);
auStack_58[param_2] = 0;
uVar5 = __strncat_chk(uVar5,&xs_1,lVar4,0x32);
__strcpy_chk(&xs_1,uVar5,0x32);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return &xs_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
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[50];
strcpy(temp, xs + len - shift);
temp[shift] = '\0';
strncat(temp, xs, len - shift);
strcpy(xs, temp);
}
return xs;
}
|
#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,%rsi
mov %rcx,%rbx
mov (%rbx),%edx
add $0x4,%rbx
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 137b <func0+0x4b>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rbx),%rdx
cmove %rdx,%rbx
mov %eax,%edi
add %al,%dil
sbb $0x3,%rbx
sub %rcx,%rbx
movslq %ebx,%rcx
cmp %ebp,%ebx
jge 1418 <func0+0xe8>
sar %ebx
je 13f2 <func0+0xc2>
lea 0x2c7b(%rip),%rax
lea -0x1(%rbx),%edi
lea 0x1(%rax),%rdx
lea -0x1(%rsi,%rcx,1),%rcx
add %rdx,%rdi
nopl 0x0(%rax)
movzbl (%rcx),%esi
movzbl (%rax),%edx
add $0x1,%rax
sub $0x1,%rcx
mov %sil,-0x1(%rax)
mov %dl,0x1(%rcx)
cmp %rdi,%rax
jne 13d8 <func0+0xa8>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1468 <func0+0x138>
add $0x40,%rsp
lea 0x2c33(%rip),%rax
pop %rbx
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
movslq %ebp,%r12
mov %rbx,%rax
mov %rsp,%r8
mov $0x32,%edx
sub %r12,%rax
mov %r8,%rdi
sub %ebp,%ebx
add %rax,%rsi
callq 10b0 <__strcpy_chk@plt>
movslq %ebx,%rdx
mov $0x32,%ecx
lea 0x2bfb(%rip),%rsi
mov %rax,%rdi
movb $0x0,(%rsp,%r12,1)
callq 10c0 <__strncat_chk@plt>
mov $0x32,%edx
lea 0x2be2(%rip),%rdi
mov %rax,%rsi
callq 10b0 <__strcpy_chk@plt>
jmp 13f2 <func0+0xc2>
callq 1090 <__stack_chk_fail@plt>
nopl (%rax)
|
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 _strlen
cmp eax, r12d
jge short loc_1400
mov edi, eax
sar edi, 1
jz short loc_13E2
movsxd rdi, edi
mov rdx, rbx
lea rax, [rbx+rax-1]
add rdi, rbx
nop dword ptr [rax+rax+00h]
loc_13C8:
movzx esi, byte ptr [rax]
movzx ecx, byte ptr [rdx]
add rdx, 1
sub rax, 1
mov [rdx-1], sil
mov [rax+1], cl
cmp rdx, rdi
jnz short loc_13C8
loc_13E2:
mov rax, [rsp+58h+var_20]
sub rax, fs:28h
jnz short loc_1441
add rsp, 40h
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_1400:
sub rax, r12
mov rdi, rsp
mov edx, 32h ; '2'
lea rsi, [rbx+rax]
mov rbp, rax
call ___strcpy_chk
mov rdx, rbp
mov rsi, rbx
mov ecx, 32h ; '2'
mov rdi, rax
mov [rsp+r12+58h+var_58], 0
call ___strncat_chk
mov edx, 32h ; '2'
mov rdi, rbx
mov rsi, rax
call ___strcpy_chk
jmp short loc_13E2
loc_1441:
call ___stack_chk_fail
|
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] [rbp-20h]
v14 = __readfsqword(0x28u);
__sprintf_chk(xs_1, 2LL, 50LL, &unk_2004, a1);
v2 = strlen(xs_1);
if ( (int)v2 >= a2 )
{
v10 = v2 - a2;
v11 = __strcpy_chk(v13, &xs_1[v10], 50LL);
v13[a2] = 0;
v12 = __strncat_chk(v11, xs_1, v10, 50LL);
__strcpy_chk(xs_1, v12, 50LL);
}
else
{
v3 = (int)v2 >> 1;
if ( (int)v2 >> 1 )
{
v4 = xs_1;
v5 = &xs_1[v2 - 1];
v6 = &xs_1[v3];
do
{
v7 = *v5;
v8 = *v4++;
--v5;
*(v4 - 1) = v7;
v5[1] = v8;
}
while ( v4 != v6 );
}
}
return xs_1;
}
|
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,0x1
JZ 0x001013e2
MOVSXD RDI,EDI
MOV RDX,RBX
LEA RAX,[RBX + RAX*0x1 + -0x1]
ADD RDI,RBX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c8:
MOVZX ESI,byte ptr [RAX]
MOVZX ECX,byte ptr [RDX]
ADD RDX,0x1
SUB RAX,0x1
MOV byte ptr [RDX + -0x1],SIL
MOV byte ptr [RAX + 0x1],CL
CMP RDX,RDI
JNZ 0x001013c8
LAB_001013e2:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101441
ADD RSP,0x40
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_00101400:
SUB RAX,R12
MOV RDI,RSP
MOV EDX,0x32
LEA RSI,[RBX + RAX*0x1]
MOV RBP,RAX
CALL 0x001010f0
MOV RDX,RBP
MOV RSI,RBX
MOV ECX,0x32
MOV RDI,RAX
MOV byte ptr [RSP + R12*0x1],0x0
CALL 0x00101100
MOV EDX,0x32
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001010f0
JMP 0x001013e2
LAB_00101441:
CALL 0x001010c0
|
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);
sVar2 = strlen(&xs_1);
if ((int)sVar2 < param_2) {
iVar8 = (int)sVar2 >> 1;
if (iVar8 != 0) {
puVar3 = &DAT_0010403f + sVar2;
puVar6 = &xs_1;
do {
uVar1 = *puVar6;
puVar7 = puVar6 + 1;
*puVar6 = *puVar3;
*puVar3 = uVar1;
puVar3 = puVar3 + -1;
puVar6 = puVar7;
} while (puVar7 != &xs_1 + iVar8);
}
}
else {
lVar4 = sVar2 - (long)param_2;
uVar5 = __strcpy_chk(auStack_58,&xs_1 + lVar4,0x32);
auStack_58[param_2] = 0;
uVar5 = __strncat_chk(uVar5,&xs_1,lVar4,0x32);
__strcpy_chk(&xs_1,uVar5,0x32);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return &xs_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
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") == 327);
return 0;
}
|
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
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5a,%al
jg 11a3 <func0+0x5a>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1165 <func0+0x1c>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
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, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 5Ah ; 'Z'
jg short loc_11A3
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
add [rbp+var_8], eax
loc_11A3:
add [rbp+var_4], 1
loc_11A7:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1165
mov eax, [rbp+var_8]
pop rbp
retn
|
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 [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x5a
JG 0x001011a3
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
ADD dword ptr [RBP + -0x8],EAX
LAB_001011a3:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a7:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101165
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
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);
}
}
return local_10;
}
|
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") == 327);
return 0;
}
|
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
jmp 1177 <func0+0x2e>
|
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
retn
loc_117A:
mov edx, 0
jmp short loc_1177
|
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++;
}
while ( v1 );
}
else
{
return 0;
}
return v3;
}
|
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 + 1;
} while (cVar1 != '\0');
}
return iVar2;
}
|
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") == 327);
return 0;
}
|
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)
xor %r8d,%r8d
mov %r8d,%eax
retq
|
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 eax, edx
retn
loc_13E8:
xor edx, edx
mov eax, edx
retn
|
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++;
}
while ( (_BYTE)v1 );
return v3;
}
|
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');
return iVar2;
}
return 0;
}
|
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") == 327);
return 0;
}
|
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)
xor %r8d,%r8d
mov %r8d,%eax
retq
|
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 eax, edx
retn
loc_13E8:
xor edx, edx
mov eax, edx
retn
|
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++;
}
while ( (_BYTE)v1 );
return v3;
}
|
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');
return iVar2;
}
return 0;
}
|
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];
}
} else {
if (is12 == 0 && j > 0) {
is12 = 1;
j = 0;
}
}
}
return n - atoi(num1) - atoi(num2);
}
|
#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(func0("2 apples and 3 oranges", 5) == 0);
assert(func0("1 apples and 100 oranges", 120) == 19);
return 0;
}
|
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,-0x34(%rbp)
movl $0x0,-0x30(%rbp)
jmpq 129b <func0+0xf2>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 127d <func0+0xd4>
cmpl $0x0,-0x38(%rbp)
jne 125b <func0+0xb2>
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x34(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x34(%rbp)
movzbl (%rcx),%edx
cltq
mov %dl,-0x2c(%rbp,%rax,1)
jmp 1297 <func0+0xee>
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x34(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x34(%rbp)
movzbl (%rcx),%edx
cltq
mov %dl,-0x22(%rbp,%rax,1)
jmp 1297 <func0+0xee>
cmpl $0x0,-0x38(%rbp)
jne 1297 <func0+0xee>
cmpl $0x0,-0x34(%rbp)
jle 1297 <func0+0xee>
movl $0x1,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1202 <func0+0x59>
lea -0x2c(%rbp),%rax
mov %rax,%rdi
callq 10a0 <atoi@plt>
mov -0x4c(%rbp),%edx
mov %edx,%ebx
sub %eax,%ebx
lea -0x22(%rbp),%rax
mov %rax,%rdi
callq 10a0 <atoi@plt>
sub %eax,%ebx
mov %ebx,%eax
mov -0x18(%rbp),%rsi
xor %fs:0x28,%rsi
je 12ea <func0+0x141>
callq 1080 <__stack_chk_fail@plt>
add $0x48,%rsp
pop %rbx
pop %rbp
retq
|
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_38], 0
mov [rbp+var_34], 0
mov [rbp+var_30], 0
jmp loc_129B
loc_1202:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_30]
movsxd rcx, edx
mov rdx, [rbp+var_48]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz short loc_127D
cmp [rbp+var_38], 0
jnz short loc_125B
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, [rbp+var_48]
lea rcx, [rdx+rax]
mov eax, [rbp+var_34]
lea edx, [rax+1]
mov [rbp+var_34], edx
movzx edx, byte ptr [rcx]
cdqe
mov [rbp+rax+nptr], dl
jmp short loc_1297
loc_125B:
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, [rbp+var_48]
lea rcx, [rdx+rax]
mov eax, [rbp+var_34]
lea edx, [rax+1]
mov [rbp+var_34], edx
movzx edx, byte ptr [rcx]
cdqe
mov [rbp+rax+var_22], dl
jmp short loc_1297
loc_127D:
cmp [rbp+var_38], 0
jnz short loc_1297
cmp [rbp+var_34], 0
jle short loc_1297
mov [rbp+var_38], 1
mov [rbp+var_34], 0
loc_1297:
add [rbp+var_30], 1
loc_129B:
mov eax, [rbp+var_30]
movsxd rdx, eax
mov rax, [rbp+var_48]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_1202
lea rax, [rbp+nptr]
mov rdi, rax; nptr
call _atoi
mov edx, [rbp+var_4C]
mov ebx, edx
sub ebx, eax
lea rax, [rbp+var_22]
mov rdi, rax; nptr
call _atoi
sub ebx, eax
mov edx, ebx
mov eax, edx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_12EC
call ___stack_chk_fail
loc_12EC:
mov rbx, [rbp+var_8]
leave
retn
|
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; // [rsp+36h] [rbp-1Ah]
unsigned long long v12; // [rsp+38h] [rbp-18h]
v12 = __readfsqword(0x28u);
*(_QWORD *)nptr = 0LL;
v9 = 0;
*(_QWORD *)v10 = 0LL;
v11 = 0;
v5 = 0;
v6 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x800) != 0 )
{
v2 = v6++;
if ( v5 )
v10[v2] = *(_BYTE *)(i + a1);
else
nptr[v2] = *(_BYTE *)(i + a1);
}
else if ( !v5 && v6 > 0 )
{
v5 = 1;
v6 = 0;
}
}
v3 = a2 - atoi(nptr);
return (unsigned int)(v3 - atoi(v10));
}
|
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
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x34],0x0
MOV dword ptr [RBP + -0x30],0x0
JMP 0x0010129b
LAB_00101202:
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x0010127d
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x0010125b
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x34],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x2c],DL
JMP 0x00101297
LAB_0010125b:
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x34]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x34],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x22],DL
JMP 0x00101297
LAB_0010127d:
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x00101297
CMP dword ptr [RBP + -0x34],0x0
JLE 0x00101297
MOV dword ptr [RBP + -0x38],0x1
MOV dword ptr [RBP + -0x34],0x0
LAB_00101297:
ADD dword ptr [RBP + -0x30],0x1
LAB_0010129b:
MOV EAX,dword ptr [RBP + -0x30]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101202
LEA RAX,[RBP + -0x2c]
MOV RDI,RAX
CALL 0x001010a0
MOV EDX,dword ptr [RBP + -0x4c]
MOV EBX,EDX
SUB EBX,EAX
LEA RAX,[RBP + -0x22]
MOV RDI,RAX
CALL 0x001010a0
SUB EBX,EAX
MOV EDX,EBX
MOV EAX,EDX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012ec
CALL 0x00101080
LAB_001012ec:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
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] = '\0';
local_34[4] = '\0';
local_34[5] = '\0';
local_34[6] = '\0';
local_34[7] = '\0';
local_34[8] = '\0';
local_34[9] = '\0';
local_34[10] = '\0';
local_34[0xb] = '\0';
local_34[0xc] = '\0';
local_34[0xd] = '\0';
local_34[0xe] = '\0';
local_34[0xf] = '\0';
local_34[0x10] = '\0';
local_34[0x11] = '\0';
local_34[0x12] = '\0';
local_34[0x13] = '\0';
bVar1 = false;
local_3c = 0;
for (local_38 = 0; *(char *)(param_1 + local_38) != '\0'; local_38 = local_38 + 1) {
ppuVar4 = __ctype_b_loc();
if (((*ppuVar4)[*(char *)(param_1 + local_38)] & 0x800) == 0) {
if ((!bVar1) && (0 < local_3c)) {
bVar1 = true;
local_3c = 0;
}
}
else if (bVar1) {
local_34[(long)local_3c + 10] = *(char *)(local_38 + param_1);
local_3c = local_3c + 1;
}
else {
local_34[local_3c] = *(char *)(local_38 + param_1);
local_3c = local_3c + 1;
}
}
iVar2 = atoi(local_34);
iVar3 = atoi(local_34 + 10);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (param_2 - iVar2) - iVar3;
}
|
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];
}
} else {
if (is12 == 0 && j > 0) {
is12 = 1;
j = 0;
}
}
}
return n - atoi(num1) - atoi(num2);
}
|
#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(func0("2 apples and 3 oranges", 5) == 0);
assert(func0("1 apples and 100 oranges", 120) == 19);
return 0;
}
|
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 10b0 <__ctype_b_loc@plt>
mov (%rax),%rsi
lea 0x1(%rbp),%rdi
mov $0x0,%edx
mov $0x0,%eax
mov $0x0,%r9d
mov $0x1,%r8d
jmp 1241 <func0+0x98>
movslq %edx,%rcx
mov %bl,0xe(%rsp,%rcx,1)
lea 0x1(%rdx),%edx
jmp 1235 <func0+0x8c>
test %eax,%eax
jne 1235 <func0+0x8c>
test %edx,%edx
setg %cl
test %cl,%cl
cmovne %r9d,%edx
cmovne %r8d,%eax
add $0x1,%rdi
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 125c <func0+0xb3>
movsbq %bl,%rcx
testb $0x8,0x1(%rsi,%rcx,2)
je 1222 <func0+0x79>
test %eax,%eax
jne 1216 <func0+0x6d>
movslq %edx,%rcx
mov %bl,0x4(%rsp,%rcx,1)
lea 0x1(%rdx),%edx
jmp 1235 <func0+0x8c>
lea 0x4(%rsp),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 10a0 <strtol@plt>
sub %eax,%r12d
lea 0xe(%rsp),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 10a0 <strtol@plt>
sub %eax,%r12d
mov %r12d,%eax
mov 0x18(%rsp),%rsi
xor %fs:0x28,%rsi
jne 12a6 <func0+0xfd>
add $0x20,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 1080 <__stack_chk_fail@plt>
|
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 bl, bl
jz short loc_125E
mov rbp, rdi
call ___ctype_b_loc
mov rdi, [rax]
lea rdx, [rbp+1]
mov ecx, 0
mov eax, 0
mov r9d, 0
mov r8d, 1
jmp short loc_1243
loc_1216:
movsxd rsi, ecx
mov [rsp+rsi+38h+var_2A], bl
lea ecx, [rcx+1]
jmp short loc_1237
loc_1222:
test eax, eax
jnz short loc_1237
test ecx, ecx
setnle sil
test sil, sil
cmovnz ecx, r9d
cmovnz eax, r8d
loc_1237:
add rdx, 1
movzx ebx, byte ptr [rdx-1]
test bl, bl
jz short loc_125E
loc_1243:
movsx rsi, bl
test byte ptr [rdi+rsi*2+1], 8
jz short loc_1222
test eax, eax
jnz short loc_1216
movsxd rsi, ecx
mov [rsp+rsi+38h+nptr], bl
lea ecx, [rcx+1]
jmp short loc_1237
loc_125E:
lea rdi, [rsp+38h+nptr]; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
sub r12d, eax
lea rdi, [rsp+38h+var_2A]; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
sub r12d, eax
mov rax, [rsp+38h+var_20]
sub rax, fs:28h
jnz short loc_12A8
mov eax, r12d
add rsp, 20h
pop rbx
pop rbp
pop r12
retn
loc_12A8:
call ___stack_chk_fail
|
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-22h]
unsigned long long v14; // [rsp+18h] [rbp-20h]
v14 = __readfsqword(0x28u);
*(_QWORD *)nptr = 0LL;
v11 = 0;
*(_QWORD *)v12 = 0LL;
v13 = 0;
v2 = *a1;
if ( *a1 )
{
v4 = *__ctype_b_loc();
v5 = a1 + 1;
v6 = 0;
v7 = 0;
do
{
if ( (v4[v2] & 0x800) != 0 )
{
if ( v7 )
v12[v6] = v2;
else
nptr[v6] = v2;
++v6;
}
else if ( !v7 && v6 > 0 )
{
v6 = 0;
v7 = 1;
}
v2 = *v5++;
}
while ( v2 );
}
v8 = a2 - strtol(nptr, 0LL, 10);
return v8 - (unsigned int)strtol(v12, 0LL, 10);
}
|
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
CALL 0x001010b0
MOV RDI,qword ptr [RAX]
LEA RDX,[RBP + 0x1]
MOV ECX,0x0
MOV EAX,0x0
MOV R9D,0x0
MOV R8D,0x1
JMP 0x00101243
LAB_00101216:
MOVSXD RSI,ECX
MOV byte ptr [RSP + RSI*0x1 + 0xe],BL
LEA ECX,[RCX + 0x1]
JMP 0x00101237
LAB_00101222:
TEST EAX,EAX
JNZ 0x00101237
TEST ECX,ECX
SETG SIL
TEST SIL,SIL
CMOVNZ ECX,R9D
CMOVNZ EAX,R8D
LAB_00101237:
ADD RDX,0x1
MOVZX EBX,byte ptr [RDX + -0x1]
TEST BL,BL
JZ 0x0010125e
LAB_00101243:
MOVSX RSI,BL
TEST byte ptr [RDI + RSI*0x2 + 0x1],0x8
JZ 0x00101222
TEST EAX,EAX
JNZ 0x00101216
MOVSXD RSI,ECX
MOV byte ptr [RSP + RSI*0x1 + 0x4],BL
LEA ECX,[RCX + 0x1]
JMP 0x00101237
LAB_0010125e:
LEA RDI,[RSP + 0x4]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x001010a0
SUB R12D,EAX
LEA RDI,[RSP + 0xe]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x001010a0
SUB R12D,EAX
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012a8
MOV EAX,R12D
ADD RSP,0x20
POP RBX
POP RBP
POP R12
RET
LAB_001012a8:
CALL 0x00101080
|
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';
local_34[2] = '\0';
local_34[3] = '\0';
local_34[4] = '\0';
local_34[5] = '\0';
local_34[6] = '\0';
local_34[7] = '\0';
local_34[8] = '\0';
local_34[9] = '\0';
local_34[10] = '\0';
local_34[0xb] = '\0';
local_34[0xc] = '\0';
local_34[0xd] = '\0';
local_34[0xe] = '\0';
local_34[0xf] = '\0';
local_34[0x10] = '\0';
local_34[0x11] = '\0';
local_34[0x12] = '\0';
local_34[0x13] = '\0';
cVar8 = *param_1;
if (cVar8 != '\0') {
ppuVar3 = __ctype_b_loc();
puVar1 = *ppuVar3;
iVar6 = 0;
bVar2 = false;
pcVar7 = param_1 + 1;
do {
if ((*(byte *)((long)puVar1 + (long)cVar8 * 2 + 1) & 8) == 0) {
if ((!bVar2) && (0 < iVar6)) {
iVar6 = 0;
bVar2 = true;
}
}
else if (bVar2) {
local_34[(long)iVar6 + 10] = cVar8;
iVar6 = iVar6 + 1;
}
else {
local_34[iVar6] = cVar8;
iVar6 = iVar6 + 1;
}
cVar8 = *pcVar7;
pcVar7 = pcVar7 + 1;
} while (cVar8 != '\0');
}
lVar4 = strtol(local_34,(char **)0x0,10);
lVar5 = strtol(local_34 + 10,(char **)0x0,10);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (param_2 - (int)lVar4) - (int)lVar5;
}
|
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];
}
} else {
if (is12 == 0 && j > 0) {
is12 = 1;
j = 0;
}
}
}
return n - atoi(num1) - atoi(num2);
}
|
#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(func0("2 apples and 3 oranges", 5) == 0);
assert(func0("1 apples and 100 oranges", 120) == 19);
return 0;
}
|
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 <func0+0xae>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %edx,%edx
xor %r9d,%r9d
mov (%rax),%rsi
mov $0x1,%r8d
xor %eax,%eax
jmp 13d5 <func0+0x85>
nopl 0x0(%rax)
movslq %edx,%rcx
test %eax,%eax
jne 1448 <func0+0xf8>
mov %bl,0x4(%rsp,%rcx,1)
add $0x1,%edx
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
je 13fe <func0+0xae>
movsbq %bl,%rcx
testb $0x8,0x1(%rsi,%rcx,2)
jne 13b8 <func0+0x68>
test %eax,%eax
jne 13ca <func0+0x7a>
test %edx,%edx
setg %cl
test %cl,%cl
cmovne %r9d,%edx
cmovne %r8d,%eax
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
jne 13d5 <func0+0x85>
xor %esi,%esi
lea 0x4(%rsp),%rdi
mov $0xa,%edx
callq 10a0 <strtol@plt>
xor %esi,%esi
lea 0xe(%rsp),%rdi
mov $0xa,%edx
sub %eax,%r12d
callq 10a0 <strtol@plt>
sub %eax,%r12d
mov 0x18(%rsp),%rsi
xor %fs:0x28,%rsi
mov %r12d,%eax
jne 1454 <func0+0x104>
add $0x20,%rsp
pop %rbx
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
mov %bl,0xe(%rsp,%rcx,1)
add $0x1,%edx
jmpq 13ca <func0+0x7a>
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
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 qword ptr [rsp+38h+var_2A], 0
test bl, bl
jz short loc_13EE
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor edx, edx
xor r9d, r9d
mov rsi, [rax]
mov r8d, 1
xor eax, eax
jmp short loc_13C5
loc_13A8:
movsxd rcx, edx
test eax, eax
jnz loc_1438
mov [rsp+rcx+38h+nptr], bl
add edx, 1
loc_13BA:
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jz short loc_13EE
loc_13C5:
movsx rcx, bl
test byte ptr [rsi+rcx*2+1], 8
jnz short loc_13A8
test al, 1
jnz short loc_13BA
test edx, edx
setnle cl
test cl, cl
cmovnz edx, r9d
cmovnz eax, r8d
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jnz short loc_13C5
loc_13EE:
lea rdi, [rsp+38h+nptr]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
call _strtol
lea rdi, [rsp+38h+var_2A]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
sub r12d, eax
call _strtol
sub r12d, eax
mov rax, [rsp+38h+var_20]
sub rax, fs:28h
jnz short loc_1444
add rsp, 20h
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1438:
mov [rsp+rcx+38h+var_2A], bl
add edx, 1
jmp loc_13BA
loc_1444:
call ___stack_chk_fail
|
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] BYREF
__int16 v14; // [rsp+16h] [rbp-22h]
unsigned long long v15; // [rsp+18h] [rbp-20h]
v3 = *a1;
v15 = __readfsqword(0x28u);
v14 = 0;
*(_QWORD *)nptr = 0LL;
v12 = 0;
*(_QWORD *)v13 = 0LL;
if ( v3 )
{
v4 = __ctype_b_loc();
v5 = a1 + 1;
v6 = 0;
v7 = *v4;
v8 = 0;
while ( (v7[v3] & 0x800) == 0 )
{
if ( (v8 & 1) != 0 )
{
LABEL_6:
v3 = *v5++;
if ( !v3 )
goto LABEL_12;
}
else
{
if ( v6 > 0 )
{
v6 = 0;
v8 = 1;
}
v3 = *v5++;
if ( !v3 )
goto LABEL_12;
}
}
if ( v8 )
v13[v6] = v3;
else
nptr[v6] = v3;
++v6;
goto LABEL_6;
}
LABEL_12:
v9 = a2 - strtol(nptr, 0LL, 10);
return v9 - (unsigned int)strtol(v13, 0LL, 10);
}
|
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 0x001013ee
MOV RBP,RDI
CALL 0x001010b0
LEA RDI,[RBP + 0x1]
XOR EDX,EDX
XOR R9D,R9D
MOV RSI,qword ptr [RAX]
MOV R8D,0x1
XOR EAX,EAX
JMP 0x001013c5
LAB_001013a8:
MOVSXD RCX,EDX
TEST EAX,EAX
JNZ 0x00101438
MOV byte ptr [RSP + RCX*0x1 + 0x4],BL
ADD EDX,0x1
LAB_001013ba:
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JZ 0x001013ee
LAB_001013c5:
MOVSX RCX,BL
TEST byte ptr [RSI + RCX*0x2 + 0x1],0x8
JNZ 0x001013a8
TEST AL,0x1
JNZ 0x001013ba
TEST EDX,EDX
SETG CL
TEST CL,CL
CMOVNZ EDX,R9D
CMOVNZ EAX,R8D
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JNZ 0x001013c5
LAB_001013ee:
LEA RDI,[RSP + 0x4]
MOV EDX,0xa
XOR ESI,ESI
CALL 0x001010a0
LEA RDI,[RSP + 0xe]
MOV EDX,0xa
XOR ESI,ESI
SUB R12D,EAX
CALL 0x001010a0
SUB R12D,EAX
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101444
ADD RSP,0x20
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101438:
MOV byte ptr [RSP + RCX*0x1 + 0xe],BL
ADD EDX,0x1
JMP 0x001013ba
LAB_00101444:
CALL 0x00101080
|
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] = '\0';
local_34[0] = '\0';
local_34[1] = '\0';
local_34[2] = '\0';
local_34[3] = '\0';
local_34[4] = '\0';
local_34[5] = '\0';
local_34[6] = '\0';
local_34[7] = '\0';
local_34[8] = '\0';
local_34[9] = '\0';
local_34[10] = '\0';
local_34[0xb] = '\0';
local_34[0xc] = '\0';
local_34[0xd] = '\0';
local_34[0xe] = '\0';
local_34[0xf] = '\0';
local_34[0x10] = '\0';
local_34[0x11] = '\0';
if (cVar7 != '\0') {
ppuVar3 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar6 = 0;
puVar1 = *ppuVar3;
bVar2 = false;
do {
while ((*(byte *)((long)puVar1 + (long)cVar7 * 2 + 1) & 8) != 0) {
if (bVar2) {
local_34[(long)iVar6 + 10] = cVar7;
iVar6 = iVar6 + 1;
}
else {
local_34[iVar6] = cVar7;
iVar6 = iVar6 + 1;
}
LAB_001013ba:
cVar7 = *param_1;
param_1 = param_1 + 1;
if (cVar7 == '\0') goto LAB_001013ee;
}
if (bVar2) goto LAB_001013ba;
if (0 < iVar6) {
bVar2 = true;
iVar6 = 0;
}
cVar7 = *param_1;
param_1 = param_1 + 1;
} while (cVar7 != '\0');
}
LAB_001013ee:
lVar4 = strtol(local_34,(char **)0x0,10);
lVar5 = strtol(local_34 + 10,(char **)0x0,10);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (param_2 - (int)lVar4) - (int)lVar5;
}
|
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];
}
} else {
if (is12 == 0 && j > 0) {
is12 = 1;
j = 0;
}
}
}
return n - atoi(num1) - atoi(num2);
}
|
#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(func0("2 apples and 3 oranges", 5) == 0);
assert(func0("1 apples and 100 oranges", 120) == 19);
return 0;
}
|
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 <func0+0xae>
mov %rdi,%rbp
callq 10b0 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %edx,%edx
xor %r9d,%r9d
mov (%rax),%rsi
mov $0x1,%r8d
xor %eax,%eax
jmp 13d5 <func0+0x85>
nopl 0x0(%rax)
movslq %edx,%rcx
test %eax,%eax
jne 1448 <func0+0xf8>
mov %bl,0x4(%rsp,%rcx,1)
add $0x1,%edx
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
je 13fe <func0+0xae>
movsbq %bl,%rcx
testb $0x8,0x1(%rsi,%rcx,2)
jne 13b8 <func0+0x68>
test %eax,%eax
jne 13ca <func0+0x7a>
test %edx,%edx
setg %cl
test %cl,%cl
cmovne %r9d,%edx
cmovne %r8d,%eax
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
jne 13d5 <func0+0x85>
xor %esi,%esi
lea 0x4(%rsp),%rdi
mov $0xa,%edx
callq 10a0 <strtol@plt>
xor %esi,%esi
lea 0xe(%rsp),%rdi
mov $0xa,%edx
sub %eax,%r12d
callq 10a0 <strtol@plt>
sub %eax,%r12d
mov 0x18(%rsp),%rsi
xor %fs:0x28,%rsi
mov %r12d,%eax
jne 1454 <func0+0x104>
add $0x20,%rsp
pop %rbx
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
mov %bl,0xe(%rsp,%rcx,1)
add $0x1,%edx
jmpq 13ca <func0+0x7a>
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
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 qword ptr [rsp+38h+var_2A], 0
test bl, bl
jz short loc_13EE
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor edx, edx
xor r9d, r9d
mov rsi, [rax]
mov r8d, 1
xor eax, eax
jmp short loc_13C5
loc_13A8:
movsxd rcx, edx
test eax, eax
jnz loc_1438
mov [rsp+rcx+38h+nptr], bl
add edx, 1
loc_13BA:
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jz short loc_13EE
loc_13C5:
movsx rcx, bl
test byte ptr [rsi+rcx*2+1], 8
jnz short loc_13A8
test al, 1
jnz short loc_13BA
test edx, edx
setnle cl
test cl, cl
cmovnz edx, r9d
cmovnz eax, r8d
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jnz short loc_13C5
loc_13EE:
lea rdi, [rsp+38h+nptr]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
call _strtol
lea rdi, [rsp+38h+var_2A]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
sub r12d, eax
call _strtol
sub r12d, eax
mov rax, [rsp+38h+var_20]
sub rax, fs:28h
jnz short loc_1444
add rsp, 20h
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1438:
mov [rsp+rcx+38h+var_2A], bl
add edx, 1
jmp loc_13BA
loc_1444:
call ___stack_chk_fail
|
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] BYREF
__int16 v14; // [rsp+16h] [rbp-22h]
unsigned long long v15; // [rsp+18h] [rbp-20h]
v3 = *a1;
v15 = __readfsqword(0x28u);
v14 = 0;
*(_QWORD *)nptr = 0LL;
v12 = 0;
*(_QWORD *)v13 = 0LL;
if ( v3 )
{
v4 = __ctype_b_loc();
v5 = a1 + 1;
v6 = 0;
v7 = *v4;
v8 = 0;
while ( (v7[v3] & 0x800) == 0 )
{
if ( (v8 & 1) != 0 )
{
LABEL_6:
v3 = *v5++;
if ( !v3 )
goto LABEL_12;
}
else
{
if ( v6 > 0 )
{
v6 = 0;
v8 = 1;
}
v3 = *v5++;
if ( !v3 )
goto LABEL_12;
}
}
if ( v8 )
v13[v6] = v3;
else
nptr[v6] = v3;
++v6;
goto LABEL_6;
}
LABEL_12:
v9 = a2 - strtol(nptr, 0LL, 10);
return v9 - (unsigned int)strtol(v13, 0LL, 10);
}
|
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 0x001013ee
MOV RBP,RDI
CALL 0x001010b0
LEA RDI,[RBP + 0x1]
XOR EDX,EDX
XOR R9D,R9D
MOV RSI,qword ptr [RAX]
MOV R8D,0x1
XOR EAX,EAX
JMP 0x001013c5
LAB_001013a8:
MOVSXD RCX,EDX
TEST EAX,EAX
JNZ 0x00101438
MOV byte ptr [RSP + RCX*0x1 + 0x4],BL
ADD EDX,0x1
LAB_001013ba:
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JZ 0x001013ee
LAB_001013c5:
MOVSX RCX,BL
TEST byte ptr [RSI + RCX*0x2 + 0x1],0x8
JNZ 0x001013a8
TEST AL,0x1
JNZ 0x001013ba
TEST EDX,EDX
SETG CL
TEST CL,CL
CMOVNZ EDX,R9D
CMOVNZ EAX,R8D
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JNZ 0x001013c5
LAB_001013ee:
LEA RDI,[RSP + 0x4]
MOV EDX,0xa
XOR ESI,ESI
CALL 0x001010a0
LEA RDI,[RSP + 0xe]
MOV EDX,0xa
XOR ESI,ESI
SUB R12D,EAX
CALL 0x001010a0
SUB R12D,EAX
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101444
ADD RSP,0x20
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101438:
MOV byte ptr [RSP + RCX*0x1 + 0xe],BL
ADD EDX,0x1
JMP 0x001013ba
LAB_00101444:
CALL 0x00101080
|
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] = '\0';
local_34[0] = '\0';
local_34[1] = '\0';
local_34[2] = '\0';
local_34[3] = '\0';
local_34[4] = '\0';
local_34[5] = '\0';
local_34[6] = '\0';
local_34[7] = '\0';
local_34[8] = '\0';
local_34[9] = '\0';
local_34[10] = '\0';
local_34[0xb] = '\0';
local_34[0xc] = '\0';
local_34[0xd] = '\0';
local_34[0xe] = '\0';
local_34[0xf] = '\0';
local_34[0x10] = '\0';
local_34[0x11] = '\0';
if (cVar7 != '\0') {
ppuVar3 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar6 = 0;
puVar1 = *ppuVar3;
bVar2 = false;
do {
while ((*(byte *)((long)puVar1 + (long)cVar7 * 2 + 1) & 8) != 0) {
if (bVar2) {
local_34[(long)iVar6 + 10] = cVar7;
iVar6 = iVar6 + 1;
}
else {
local_34[iVar6] = cVar7;
iVar6 = iVar6 + 1;
}
LAB_001013ba:
cVar7 = *param_1;
param_1 = param_1 + 1;
if (cVar7 == '\0') goto LAB_001013ee;
}
if (bVar2) goto LAB_001013ba;
if (0 < iVar6) {
bVar2 = true;
iVar6 = 0;
}
cVar7 = *param_1;
param_1 = param_1 + 1;
} while (cVar7 != '\0');
}
LAB_001013ee:
lVar4 = strtol(local_34,(char **)0x0,10);
lVar5 = strtol(local_34 + 10,(char **)0x0,10);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (param_2 - (int)lVar4) - (int)lVar5;
}
|
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) {
return NULL;
}
output[0] = smallestEven;
output[1] = index;
return output;
}
|
#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;
int test1[] = {4, 2, 3};
int expect1[] = {2, 1};
result = func0(test1, 3, output);
assert(issame(result, expect1, 2, 2));
int test2[] = {1, 2, 3};
int expect2[] = {2, 1};
result = func0(test2, 3, output);
assert(issame(result, expect2, 2, 2));
int test3[] = {};
result = func0(test3, 0, output);
assert(result == NULL);
int test4[] = {5, 0, 3, 0, 4, 2};
int expect4[] = {0, 1};
result = func0(test4, 6, output);
assert(issame(result, expect4, 2, 2));
int test5[] = {1, 2, 3, 0, 5, 3};
int expect5[] = {0, 3};
result = func0(test5, 6, output);
assert(issame(result, expect5, 2, 2));
int test6[] = {5, 4, 8, 4, 8};
int expect6[] = {4, 1};
result = func0(test6, 5, output);
assert(issame(result, expect6, 2, 2));
int test7[] = {7, 6, 7, 1};
int expect7[] = {6, 1};
result = func0(test7, 4, output);
assert(issame(result, expect7, 2, 2));
int test8[] = {7, 9, 7, 1};
result = func0(test8, 4, output);
assert(result == NULL);
return 0;
}
|
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
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11f0 <func0+0x87>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jg 11d1 <func0+0x68>
cmpl $0xffffffff,-0x8(%rbp)
jne 11f0 <func0+0x87>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1193 <func0+0x2a>
cmpl $0xffffffff,-0x8(%rbp)
jne 1209 <func0+0xa0>
mov $0x0,%eax
jmp 1223 <func0+0xba>
mov -0x28(%rbp),%rax
mov -0xc(%rbp),%edx
mov %edx,(%rax)
mov -0x28(%rbp),%rax
lea 0x4(%rax),%rdx
mov -0x8(%rbp),%eax
mov %eax,(%rdx)
mov -0x28(%rbp),%rax
pop %rbp
retq
|
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]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11F0
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jg short loc_11D1
cmp [rbp+var_8], 0FFFFFFFFh
jnz short loc_11F0
loc_11D1:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
loc_11F0:
add [rbp+var_4], 1
loc_11F4:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1193
cmp [rbp+var_8], 0FFFFFFFFh
jnz short loc_1209
mov eax, 0
jmp short loc_1223
loc_1209:
mov rax, [rbp+var_28]
mov edx, [rbp+var_C]
mov [rax], edx
mov rax, [rbp+var_28]
lea rdx, [rax+4]
mov eax, [rbp+var_8]
mov [rdx], eax
mov rax, [rbp+var_28]
loc_1223:
pop rbp
retn
|
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 = *(_DWORD *)(4LL * i + a1);
v5 = i;
}
}
if ( v5 == -1 )
return 0LL;
*a3 = v4;
a3[1] = v5;
return a3;
}
|
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]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011f0
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JG 0x001011d1
CMP dword ptr [RBP + -0x8],-0x1
JNZ 0x001011f0
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011f0:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011f4:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101193
CMP dword ptr [RBP + -0x8],-0x1
JNZ 0x00101209
MOV EAX,0x0
JMP 0x00101223
LAB_00101209:
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0xc]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x28]
LAB_00101223:
POP RBP
RET
|
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) < local_14 || (local_10 == -1)))) {
local_14 = *(int *)(param_1 + (long)local_c * 4);
local_10 = local_c;
}
}
if (local_10 == -1) {
param_3 = (int *)0x0;
}
else {
*param_3 = local_14;
param_3[1] = local_10;
}
return param_3;
}
|
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) {
return NULL;
}
output[0] = smallestEven;
output[1] = index;
return output;
}
|
#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;
int test1[] = {4, 2, 3};
int expect1[] = {2, 1};
result = func0(test1, 3, output);
assert(issame(result, expect1, 2, 2));
int test2[] = {1, 2, 3};
int expect2[] = {2, 1};
result = func0(test2, 3, output);
assert(issame(result, expect2, 2, 2));
int test3[] = {};
result = func0(test3, 0, output);
assert(result == NULL);
int test4[] = {5, 0, 3, 0, 4, 2};
int expect4[] = {0, 1};
result = func0(test4, 6, output);
assert(issame(result, expect4, 2, 2));
int test5[] = {1, 2, 3, 0, 5, 3};
int expect5[] = {0, 3};
result = func0(test5, 6, output);
assert(issame(result, expect5, 2, 2));
int test6[] = {5, 4, 8, 4, 8};
int expect6[] = {4, 1};
result = func0(test6, 5, output);
assert(issame(result, expect6, 2, 2));
int test7[] = {7, 6, 7, 1};
int expect7[] = {6, 1};
result = func0(test7, 4, output);
assert(issame(result, expect7, 2, 2));
int test8[] = {7, 9, 7, 1};
result = func0(test8, 4, output);
assert(result == NULL);
return 0;
}
|
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,4),%esi
test $0x1,%sil
jne 118c <func0+0x23>
cmp $0xffffffff,%r9d
je 1187 <func0+0x1e>
cmp %eax,%esi
jl 1187 <func0+0x1e>
jmp 118c <func0+0x23>
cmp $0xffffffff,%r9d
je 11c6 <func0+0x5d>
mov %eax,(%rdx)
mov %r9d,0x4(%rdx)
mov %rdx,%rax
retq
mov $0x0,%eax
retq
mov $0x0,%eax
retq
|
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 short loc_118C
cmp r9d, 0FFFFFFFFh
jz short loc_1186
cmp r8d, eax
jl short loc_1186
jmp short loc_118C
loc_11AC:
cmp r9d, 0FFFFFFFFh
jz short loc_11C2
mov [rdx], eax
mov [rdx+4], r9d
mov rax, rdx
retn
loc_11BC:
mov eax, 0
retn
loc_11C2:
mov eax, 0
retn
|
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 = *(_DWORD *)(a1 + 4 * v3);
}
++v3;
}
while ( a2 != v3 );
if ( v4 == -1 )
return 0LL;
*a3 = v5;
a3[1] = v4;
return a3;
}
|
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 R8D,EAX
JL 0x00101186
JMP 0x0010118c
LAB_001011ac:
CMP R9D,-0x1
JZ 0x001011c2
MOV dword ptr [RDX],EAX
MOV dword ptr [RDX + 0x4],R9D
MOV RAX,RDX
RET
LAB_001011bc:
MOV EAX,0x0
RET
LAB_001011c2:
MOV EAX,0x0
RET
|
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 == -1 || ((int)uVar1 < (int)uVar2)))) {
uVar4 = uVar3 & 0xffffffff;
uVar2 = uVar1;
}
uVar3 = uVar3 + 1;
} while ((long)param_2 != uVar3);
if ((uint)uVar4 == 0xffffffff) {
return (uint *)0x0;
}
*param_3 = uVar2;
param_3[1] = (uint)uVar4;
return param_3;
}
|
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) {
return NULL;
}
output[0] = smallestEven;
output[1] = index;
return output;
}
|
#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;
int test1[] = {4, 2, 3};
int expect1[] = {2, 1};
result = func0(test1, 3, output);
assert(issame(result, expect1, 2, 2));
int test2[] = {1, 2, 3};
int expect2[] = {2, 1};
result = func0(test2, 3, output);
assert(issame(result, expect2, 2, 2));
int test3[] = {};
result = func0(test3, 0, output);
assert(result == NULL);
int test4[] = {5, 0, 3, 0, 4, 2};
int expect4[] = {0, 1};
result = func0(test4, 6, output);
assert(issame(result, expect4, 2, 2));
int test5[] = {1, 2, 3, 0, 5, 3};
int expect5[] = {0, 3};
result = func0(test5, 6, output);
assert(issame(result, expect5, 2, 2));
int test6[] = {5, 4, 8, 4, 8};
int expect6[] = {4, 1};
result = func0(test6, 5, output);
assert(issame(result, expect6, 2, 2));
int test7[] = {7, 6, 7, 1};
int expect7[] = {6, 1};
result = func0(test7, 4, output);
assert(issame(result, expect7, 2, 2));
int test8[] = {7, 9, 7, 1};
result = func0(test8, 4, output);
assert(result == NULL);
return 0;
}
|
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
je 16b9 <func0+0x39>
cmp %eax,%esi
jge 16be <func0+0x3e>
mov %r8d,%r9d
mov %esi,%eax
lea 0x1(%rcx),%rsi
cmp %r10,%rcx
jne 16a0 <func0+0x20>
cmp $0xffffffff,%r9d
je 16e0 <func0+0x60>
mov %eax,(%rdx)
mov %rdx,%rax
mov %r9d,0x4(%rdx)
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
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 short loc_153B
loc_1535:
mov r9d, ecx
mov eax, r8d
loc_153B:
add rcx, 1
cmp rsi, rcx
jnz short loc_1520
cmp r9d, 0FFFFFFFFh
jz short loc_1558
mov [rdx], eax
mov rax, rdx
mov [rdx+4], r9d
retn
loc_1558:
xor eax, eax
retn
|
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) )
{
v4 = v3;
v5 = *(_DWORD *)(a1 + 4 * v3);
}
++v3;
}
while ( a2 != v3 );
if ( v4 == -1 )
return 0LL;
*a3 = v5;
result = a3;
a3[1] = v4;
return result;
}
|
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:
ADD RCX,0x1
CMP RSI,RCX
JNZ 0x00101520
CMP R9D,-0x1
JZ 0x00101558
MOV dword ptr [RDX],EAX
MOV RAX,RDX
MOV dword ptr [RDX + 0x4],R9D
RET
LAB_00101558:
XOR EAX,EAX
RET
|
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)uVar1 < (int)uVar2)))) {
uVar3 = (uint)lVar4;
uVar2 = uVar1;
}
lVar4 = lVar4 + 1;
} while (param_2 != lVar4);
if (uVar3 != 0xffffffff) {
*param_3 = uVar2;
param_3[1] = uVar3;
return param_3;
}
}
return (uint *)0x0;
}
|
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) {
return NULL;
}
output[0] = smallestEven;
output[1] = index;
return output;
}
|
#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;
int test1[] = {4, 2, 3};
int expect1[] = {2, 1};
result = func0(test1, 3, output);
assert(issame(result, expect1, 2, 2));
int test2[] = {1, 2, 3};
int expect2[] = {2, 1};
result = func0(test2, 3, output);
assert(issame(result, expect2, 2, 2));
int test3[] = {};
result = func0(test3, 0, output);
assert(result == NULL);
int test4[] = {5, 0, 3, 0, 4, 2};
int expect4[] = {0, 1};
result = func0(test4, 6, output);
assert(issame(result, expect4, 2, 2));
int test5[] = {1, 2, 3, 0, 5, 3};
int expect5[] = {0, 3};
result = func0(test5, 6, output);
assert(issame(result, expect5, 2, 2));
int test6[] = {5, 4, 8, 4, 8};
int expect6[] = {4, 1};
result = func0(test6, 5, output);
assert(issame(result, expect6, 2, 2));
int test7[] = {7, 6, 7, 1};
int expect7[] = {6, 1};
result = func0(test7, 4, output);
assert(issame(result, expect7, 2, 2));
int test8[] = {7, 9, 7, 1};
result = func0(test8, 4, output);
assert(result == NULL);
return 0;
}
|
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
je 1639 <func0+0x39>
cmp %esi,%eax
jle 163e <func0+0x3e>
mov %r8d,%r9d
mov %esi,%eax
lea 0x1(%rcx),%rsi
cmp %rcx,%r10
jne 1620 <func0+0x20>
cmp $0xffffffff,%r9d
je 1660 <func0+0x60>
mov %eax,(%rdx)
mov %rdx,%rax
mov %r9d,0x4(%rdx)
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
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 short loc_13BB
loc_13B5:
mov r9d, ecx
mov eax, r8d
loc_13BB:
add rcx, 1
cmp rsi, rcx
jnz short loc_13A0
cmp r9d, 0FFFFFFFFh
jz short loc_13D8
mov [rdx], eax
mov rax, rdx
mov [rdx+4], r9d
retn
loc_13D8:
xor eax, eax
retn
|
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) )
{
v4 = v3;
v5 = *(_DWORD *)(a1 + 4 * v3);
}
++v3;
}
while ( a2 != v3 );
if ( v4 == -1 )
return 0LL;
*a3 = v5;
result = a3;
a3[1] = v4;
return result;
}
|
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:
ADD RCX,0x1
CMP RSI,RCX
JNZ 0x001013a0
CMP R9D,-0x1
JZ 0x001013d8
MOV dword ptr [RDX],EAX
MOV RAX,RDX
MOV dword ptr [RDX + 0x4],R9D
RET
LAB_001013d8:
XOR EAX,EAX
RET
|
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)uVar1 < (int)uVar2)))) {
uVar3 = (uint)lVar4;
uVar2 = uVar1;
}
lVar4 = lVar4 + 1;
} while (param_2 != lVar4);
if (uVar3 != 0xffffffff) {
*param_3 = uVar2;
param_3[1] = uVar3;
return param_3;
}
}
return (uint *)0x0;
}
|
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, 2};
int arr8[] = {6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10};
int arr9[] = {8, 8, 3, 6, 5, 6, 4};
int arr10[] = {6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9};
int arr11[] = {1, 9, 10, 1, 3};
int arr12[] = {6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10};
int arr13[] = {1};
int arr14[] = {8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5};
int arr15[] = {2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10};
int arr16[] = {1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3};
int arr17[] = {9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4};
int arr18[] = {2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7};
int arr19[] = {9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1};
int arr20[] = {5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8};
int arr21[] = {10};
int arr22[] = {9, 7, 7, 2, 4,7, 2, 10, 9, 7, 5, 7, 2};
int arr23[] = {5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8};
int arr24[] = {7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6};
int arr25[] = {3, 10, 10, 9, 2};
return 0;
}
|
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 -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
add $0x1,%edx
mov %edx,(%rax)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jl 126d <func0+0xe4>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x10(%rbp)
jge 126d <func0+0xe4>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11c8 <func0+0x3f>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1070 <free@plt>
mov -0x10(%rbp),%eax
leaveq
retq
|
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_11C8:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
add edx, 1
mov [rax], edx
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jl short loc_126D
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_10], eax
jge short loc_126D
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
loc_126D:
add [rbp+var_C], 1
loc_1271:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_11C8
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_10]
leave
retn
|
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 + a1)] >= *(_DWORD *)(4LL * i + a1) && v4 < *(_DWORD *)(4LL * i + a1) )
v4 = *(_DWORD *)(4LL * i + a1);
}
free(ptr);
return (unsigned int)v4;
}
|
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
LAB_001011c8:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
ADD EDX,0x1
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JL 0x0010126d
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x10],EAX
JGE 0x0010126d
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
LAB_0010126d:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101271:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011c8
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101070
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET
|
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);
*piVar1 = *piVar1 + 1;
if ((*(int *)(param_1 + (long)local_14 * 4) <=
*(int *)((long)__ptr + (long)*(int *)(param_1 + (long)local_14 * 4) * 4)) &&
(local_18 < *(int *)(param_1 + (long)local_14 * 4))) {
local_18 = *(int *)(param_1 + (long)local_14 * 4);
}
}
free(__ptr);
return local_18;
}
|
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, 2};
int arr8[] = {6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10};
int arr9[] = {8, 8, 3, 6, 5, 6, 4};
int arr10[] = {6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9};
int arr11[] = {1, 9, 10, 1, 3};
int arr12[] = {6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10};
int arr13[] = {1};
int arr14[] = {8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5};
int arr15[] = {2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10};
int arr16[] = {1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3};
int arr17[] = {9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4};
int arr18[] = {2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7};
int arr19[] = {9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1};
int arr20[] = {5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8};
int arr21[] = {10};
int arr22[] = {9, 7, 7, 2, 4,7, 2, 10, 9, 7, 5, 7, 2};
int arr23[] = {5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8};
int arr24[] = {7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6};
int arr25[] = {3, 10, 10, 9, 2};
return 0;
}
|
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,%ebx
jmp 11aa <func0+0x41>
add $0x4,%rcx
cmp %rax,%rcx
je 11cc <func0+0x63>
mov (%rcx),%esi
movslq %esi,%rdx
lea (%rdi,%rdx,4),%r8
mov (%r8),%edx
add $0x1,%edx
mov %edx,(%r8)
cmp %edx,%esi
jg 11a1 <func0+0x38>
cmp %esi,%ebx
cmovl %esi,%ebx
jmp 11a1 <func0+0x38>
mov $0xffffffff,%ebx
callq 1060 <free@plt>
mov %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
|
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_119F:
mov ecx, [rsi]
movsxd rdx, ecx
lea r8, [rdi+rdx*4]
mov edx, [r8]
add edx, 1
mov [r8], edx
cmp ebx, ecx
mov r8d, ecx
cmovge r8d, ebx
cmp ecx, edx
cmovle ebx, r8d
add rsi, 4
cmp rsi, rax
jnz short loc_119F
loc_11C9:
call _free
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
loc_11D7:
mov ebx, 0FFFFFFFFh
jmp short loc_11C9
|
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
{
v8 = *v5;
v9 = (int *)&v4[4 * *v5];
v10 = *v9 + 1;
*v9 = v10;
v11 = v8;
if ( v7 >= v8 )
v11 = v7;
if ( v8 <= v10 )
v7 = v11;
++v5;
}
while ( v5 != v6 );
}
free(v4);
return (unsigned int)v7;
}
|
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]
MOV EDX,dword ptr [R8]
ADD EDX,0x1
MOV dword ptr [R8],EDX
CMP EBX,ECX
MOV R8D,ECX
CMOVGE R8D,EBX
CMP ECX,EDX
CMOVLE EBX,R8D
ADD RSI,0x4
CMP RSI,RAX
JNZ 0x0010119f
LAB_001011c9:
CALL 0x00101060
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011d7:
MOV EBX,0xffffffff
JMP 0x001011c9
|
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;
piVar1 = (int *)((long)__ptr + (long)iVar3 * 4);
iVar5 = *piVar1 + 1;
*piVar1 = iVar5;
iVar4 = iVar3;
if (iVar3 <= iVar6) {
iVar4 = iVar6;
}
if (iVar3 <= iVar5) {
iVar6 = iVar4;
}
param_1 = param_1 + 1;
} while (param_1 != piVar2);
}
free(__ptr);
return iVar6;
}
|
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, 2};
int arr8[] = {6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10};
int arr9[] = {8, 8, 3, 6, 5, 6, 4};
int arr10[] = {6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9};
int arr11[] = {1, 9, 10, 1, 3};
int arr12[] = {6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10};
int arr13[] = {1};
int arr14[] = {8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5};
int arr15[] = {2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10};
int arr16[] = {1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3};
int arr17[] = {9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4};
int arr18[] = {2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7};
int arr19[] = {9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1};
int arr20[] = {5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8};
int arr21[] = {10};
int arr22[] = {9, 7, 7, 2, 4,7, 2, 10, 9, 7, 5, 7, 2};
int arr23[] = {5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8};
int arr24[] = {7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6};
int arr25[] = {3, 10, 10, 9, 2};
return 0;
}
|
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),%rax
nopl 0x0(%rax)
movslq (%rdi),%rdx
lea (%r8,%rdx,4),%rsi
mov %rdx,%rcx
mov (%rsi),%ebx
lea 0x1(%rbx),%edx
mov %edx,(%rsi)
cmp %edx,%ecx
jg 11dc <func0+0x5c>
cmp %ecx,%r12d
cmovl %ecx,%r12d
add $0x4,%rdi
cmp %rdi,%rax
jne 11c0 <func0+0x40>
mov %r8,%rdi
callq 1060 <free@plt>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r12d
jmp 11e5 <func0+0x65>
nopl 0x0(%rax,%rax,1)
|
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+rax+00h]
loc_11B8:
movsxd rdx, dword ptr [r8]
lea rsi, [rdi+rdx*4]
mov rcx, rdx
mov edx, [rsi]
add edx, 1
cmp ebx, ecx
mov [rsi], edx
mov esi, ecx
cmovge esi, ebx
cmp ecx, edx
cmovle ebx, esi
add r8, 4
cmp rax, r8
jnz short loc_11B8
call _free
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
retn
loc_11F0:
call _free
mov ebx, 0FFFFFFFFh
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
retn
|
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];
v6 = -1;
do
{
v7 = (int *)&v3[4 * *v4];
v8 = *v4;
v9 = *v7 + 1;
*v7 = v9;
v10 = v8;
if ( v6 >= v8 )
v10 = v6;
if ( v8 <= v9 )
v6 = v10;
++v4;
}
while ( v5 != v4 );
free(v3);
return (unsigned int)v6;
}
}
|
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*0x4]
MOV RCX,RDX
MOV EDX,dword ptr [RSI]
ADD EDX,0x1
CMP EBX,ECX
MOV dword ptr [RSI],EDX
MOV ESI,ECX
CMOVGE ESI,EBX
CMP ECX,EDX
CMOVLE EBX,ESI
ADD R8,0x4
CMP RAX,R8
JNZ 0x001011b8
CALL 0x00101060
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
RET
LAB_001011f0:
CALL 0x00101060
MOV EBX,0xffffffff
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
RET
|
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 + (long)iVar3 * 4);
iVar5 = *piVar2 + 1;
*piVar2 = iVar5;
iVar4 = iVar3;
if (iVar3 <= iVar6) {
iVar4 = iVar6;
}
if (iVar3 <= iVar5) {
iVar6 = iVar4;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
free(__ptr);
return iVar6;
}
free(__ptr);
return -1;
}
|
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, 2};
int arr8[] = {6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10};
int arr9[] = {8, 8, 3, 6, 5, 6, 4};
int arr10[] = {6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9};
int arr11[] = {1, 9, 10, 1, 3};
int arr12[] = {6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10};
int arr13[] = {1};
int arr14[] = {8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5};
int arr15[] = {2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10};
int arr16[] = {1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3};
int arr17[] = {9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4};
int arr18[] = {2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7};
int arr19[] = {9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1};
int arr20[] = {5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8};
int arr21[] = {10};
int arr22[] = {9, 7, 7, 2, 4,7, 2, 10, 9, 7, 5, 7, 2};
int arr23[] = {5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8};
int arr24[] = {7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6};
int arr25[] = {3, 10, 10, 9, 2};
return 0;
}
|
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),%rax
nopl 0x0(%rax)
movslq (%rdi),%rdx
lea (%r8,%rdx,4),%rsi
mov %rdx,%rcx
mov (%rsi),%ebx
lea 0x1(%rbx),%edx
mov %edx,(%rsi)
cmp %edx,%ecx
jg 11dc <func0+0x5c>
cmp %ecx,%r12d
cmovl %ecx,%r12d
add $0x4,%rdi
cmp %rdi,%rax
jne 11c0 <func0+0x40>
mov %r8,%rdi
callq 1060 <free@plt>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r12d
jmp 11e5 <func0+0x65>
nopl 0x0(%rax,%rax,1)
|
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+rax+00h]
loc_11B8:
movsxd rdx, dword ptr [r8]
lea rsi, [rdi+rdx*4]
mov rcx, rdx
mov edx, [rsi]
add edx, 1
cmp ebx, ecx
mov [rsi], edx
mov esi, ecx
cmovge esi, ebx
cmp ecx, edx
cmovle ebx, esi
add r8, 4
cmp rax, r8
jnz short loc_11B8
call _free
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
retn
loc_11F0:
call _free
mov ebx, 0FFFFFFFFh
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
retn
|
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];
v6 = -1;
do
{
v7 = (int *)&v3[4 * *v4];
v8 = *v4;
v9 = *v7 + 1;
*v7 = v9;
v10 = v8;
if ( v6 >= v8 )
v10 = v6;
if ( v8 <= v9 )
v6 = v10;
++v4;
}
while ( v5 != v4 );
free(v3);
return (unsigned int)v6;
}
}
|
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*0x4]
MOV RCX,RDX
MOV EDX,dword ptr [RSI]
ADD EDX,0x1
CMP EBX,ECX
MOV dword ptr [RSI],EDX
MOV ESI,ECX
CMOVGE ESI,EBX
CMP ECX,EDX
CMOVLE EBX,ESI
ADD R8,0x4
CMP RAX,R8
JNZ 0x001011b8
CALL 0x00101060
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
RET
LAB_001011f0:
CALL 0x00101060
MOV EBX,0xffffffff
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
RET
|
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 + (long)iVar3 * 4);
iVar5 = *piVar2 + 1;
*piVar2 = iVar5;
iVar4 = iVar3;
if (iVar3 <= iVar6) {
iVar4 = iVar6;
}
if (iVar3 <= iVar5) {
iVar6 = iVar4;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
free(__ptr);
return iVar6;
}
free(__ptr);
return -1;
}
|
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 - 1;
int index = 0;
while (l <= r) {
if (l == r) {
out[index++] = lst[l++];
} else {
out[index++] = lst[l++];
out[index++] = lst[r--];
}
}
}
|
#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));
int a2[] = {5, 6, 7, 8, 9};
int e2[] = {5, 9, 6, 8, 7};
int out2[5];
func0(a2, 5, out2);
assert(issame(e2, out2, 5));
int a3[] = {1, 2, 3, 4, 5};
int e3[] = {1, 5, 2, 4, 3};
int out3[5];
func0(a3, 5, out3);
assert(issame(e3, out3, 5));
int a4[] = {5, 6, 7, 8, 9, 1};
int e4[] = {1, 9, 5, 8, 6, 7};
int out4[6];
func0(a4, 6, out4);
assert(issame(e4, out4, 6));
int a5[] = {5, 5, 5, 5};
int e5[] = {5, 5, 5, 5};
int out5[4];
func0(a5, 4, out5);
assert(issame(e5, out5, 4));
int a6[] = {};
int e6[] = {};
int out6[0];
func0(a6, 0, out6);
assert(issame(e6, out6, 0));
int a7[] = {1, 2, 3, 4, 5, 6, 7, 8};
int e7[] = {1, 8, 2, 7, 3, 6, 4, 5};
int out7[8];
func0(a7, 8, out7);
assert(issame(e7, out7, 8));
int a8[] = {0, 2, 2, 2, 5, 5, -5, -5};
int e8[] = {-5, 5, -5, 5, 0, 2, 2, 2};
int out8[8];
func0(a8, 8, out8);
assert(issame(e8, out8, 8));
int a9[] = {111111};
int e9[] = {111111};
int out9[1];
func0(a9, 1, out9);
assert(issame(e9, out9, 1));
return 0;
}
|
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 -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1225 <func0+0xbc>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1196 <func0+0x2d>
addl $0x1,-0x18(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x18(%rbp)
jl 1188 <func0+0x1f>
movl $0x0,-0x10(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1319 <func0+0x1b0>
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jne 12a7 <func0+0x13e>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
jmp 1319 <func0+0x1b0>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,-0xc(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 1264 <func0+0xfb>
pop %rbp
retq
|
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*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_1225
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_18]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_1225:
add [rbp+var_14], 1
loc_1229:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl loc_1196
add [rbp+var_18], 1
loc_1239:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_18], eax
jl loc_1188
mov [rbp+var_10], 0
mov eax, [rbp+var_2C]
sub eax, 1
mov [rbp+var_C], eax
mov [rbp+var_8], 0
jmp loc_1319
loc_1264:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jnz short loc_12A7
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
jmp short loc_1319
loc_12A7:
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov eax, [rbp+var_C]
lea edx, [rax-1]
mov [rbp+var_C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1319:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jle loc_1264
nop
nop
pop rbp
retn
|
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 k; // [rsp+30h] [rbp-8h]
int v14; // [rsp+34h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4LL * j + a1) )
{
v14 = *(_DWORD *)(4LL * i + a1);
*(_DWORD *)(4LL * i + a1) = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(a1 + 4LL * j) = v14;
}
}
}
v11 = 0;
v12 = a2 - 1;
for ( k = 0; ; ++k )
{
result = v11;
if ( (int)v11 > v12 )
break;
v3 = v11;
if ( v11 == v12 )
{
++v11;
}
else
{
++v11;
v6 = (_DWORD *)(4LL * v3 + a1);
v7 = k++;
*(_DWORD *)(a3 + 4LL * v7) = *v6;
v3 = v12--;
}
v4 = (_DWORD *)(4LL * v3 + a1);
v5 = k;
*(_DWORD *)(a3 + 4LL * v5) = *v4;
}
return result;
}
|
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 + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x00101225
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_00101225:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101229:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101196
ADD dword ptr [RBP + -0x18],0x1
LAB_00101239:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x18],EAX
JL 0x00101188
MOV dword ptr [RBP + -0x10],0x0
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101319
LAB_00101264:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x001012a7
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
JMP 0x00101319
LAB_001012a7:
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RBP + -0xc],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101319:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x00101264
NOP
NOP
POP RBP
RET
|
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) {
if (*(int *)(param_1 + (long)local_1c * 4) < *(int *)(param_1 + (long)local_20 * 4)) {
uVar2 = *(int4 *)(param_1 + (long)local_20 * 4);
*(int4 *)(param_1 + (long)local_20 * 4) =
*(int4 *)(param_1 + (long)local_1c * 4);
*(int4 *)((long)local_1c * 4 + param_1) = uVar2;
}
}
}
local_18 = 0;
local_10 = 0;
local_14 = param_2 + -1;
while (local_18 <= local_14) {
if (local_18 == local_14) {
*(int4 *)((long)local_10 * 4 + param_3) = *(int4 *)((long)local_18 * 4 + param_1);
local_18 = local_18 + 1;
local_10 = local_10 + 1;
}
else {
iVar1 = local_10 + 1;
*(int4 *)((long)local_10 * 4 + param_3) = *(int4 *)((long)local_18 * 4 + param_1);
local_10 = local_10 + 2;
*(int4 *)((long)iVar1 * 4 + param_3) = *(int4 *)((long)local_14 * 4 + param_1);
local_18 = local_18 + 1;
local_14 = local_14 + -1;
}
}
return;
}
|
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 - 1;
int index = 0;
while (l <= r) {
if (l == r) {
out[index++] = lst[l++];
} else {
out[index++] = lst[l++];
out[index++] = lst[r--];
}
}
}
|
#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));
int a2[] = {5, 6, 7, 8, 9};
int e2[] = {5, 9, 6, 8, 7};
int out2[5];
func0(a2, 5, out2);
assert(issame(e2, out2, 5));
int a3[] = {1, 2, 3, 4, 5};
int e3[] = {1, 5, 2, 4, 3};
int out3[5];
func0(a3, 5, out3);
assert(issame(e3, out3, 5));
int a4[] = {5, 6, 7, 8, 9, 1};
int e4[] = {1, 9, 5, 8, 6, 7};
int out4[6];
func0(a4, 6, out4);
assert(issame(e4, out4, 6));
int a5[] = {5, 5, 5, 5};
int e5[] = {5, 5, 5, 5};
int out5[4];
func0(a5, 4, out5);
assert(issame(e5, out5, 4));
int a6[] = {};
int e6[] = {};
int out6[0];
func0(a6, 0, out6);
assert(issame(e6, out6, 0));
int a7[] = {1, 2, 3, 4, 5, 6, 7, 8};
int e7[] = {1, 8, 2, 7, 3, 6, 4, 5};
int out7[8];
func0(a7, 8, out7);
assert(issame(e7, out7, 8));
int a8[] = {0, 2, 2, 2, 5, 5, -5, -5};
int e8[] = {-5, 5, -5, 5, 0, 2, 2, 2};
int out8[8];
func0(a8, 8, out8);
assert(issame(e8, out8, 8));
int a9[] = {111111};
int e9[] = {111111};
int out9[1];
func0(a9, 1, out9);
assert(issame(e9, out9, 1));
return 0;
}
|
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 1189 <func0+0x20>
mov %r8d,(%r9)
mov %ecx,(%rdi,%rax,4)
jmp 1189 <func0+0x20>
add $0x1,%r11
add $0x4,%r9
cmp %rbx,%r11
je 11be <func0+0x55>
cmp %r11d,%esi
jle 11a5 <func0+0x3c>
mov %r11,%rax
jmp 1191 <func0+0x28>
jne 11f5 <func0+0x8c>
movslq %r10d,%rcx
mov $0x0,%eax
jmp 11e1 <func0+0x78>
mov (%rdi,%rax,4),%esi
mov %esi,(%rdx,%rax,8)
mov (%rdi,%rcx,4),%esi
mov %esi,0x4(%rdx,%rax,8)
add $0x1,%rax
sub $0x1,%rcx
cmp %ecx,%eax
jg 11f5 <func0+0x8c>
lea (%rax,%rax,1),%esi
cmp %eax,%ecx
jne 11c8 <func0+0x5f>
movslq %eax,%r8
mov (%rdi,%r8,4),%eax
movslq %esi,%rsi
mov %eax,(%rdx,%rsi,4)
pop %rbx
retq
|
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 rax, rdi
jz short loc_11B2
loc_11A2:
mov edx, [rsi-4]
mov ecx, [rax]
cmp edx, ecx
jle short loc_1199
mov [rsi-4], ecx
mov [rax], edx
jmp short loc_1199
loc_11B2:
add r8, 1
add rsi, 4
cmp r8, rbp
jz short loc_11DA
loc_11BF:
cmp ebx, r8d
jle short loc_11B2
mov eax, r13d
sub eax, r8d
lea rax, [r8+rax-1]
lea rdi, [r12+rax*4]
mov rax, rsi
jmp short loc_11A2
loc_11D8:
js short loc_1214
loc_11DA:
movsxd rdx, r9d
mov eax, 0
jmp short loc_1201
loc_11E4:
mov ecx, [r10+rax*4]
mov [r11+rax*8], ecx
mov ecx, [r10+rdx*4]
mov [r11+rax*8+4], ecx
add rax, 1
sub rdx, 1
cmp eax, edx
jg short loc_1214
loc_1201:
cmp edx, eax
jnz short loc_11E4
movsxd rdx, eax
mov edx, [r10+rdx*4]
add eax, eax
cdqe
mov [r11+rax*4], edx
loc_1214:
pop rbx
pop rbp
pop r12
pop r13
retn
|
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 = 1LL;
do
{
if ( a2 > (int)v7 )
{
v8 = v6;
do
{
v9 = *(v6 - 1);
if ( v9 > *v8 )
{
*(v6 - 1) = *v8;
*v8 = v9;
}
++v8;
}
while ( v8 != (_DWORD *)(a1 + 8 + 4 * (v7 + (unsigned int)(v4 - v7) - 1)) );
}
++v7;
++v6;
}
while ( v7 != a2 );
}
v10 = v4;
v11 = 0LL;
while ( (_DWORD)v10 != (_DWORD)v11 )
{
*(_DWORD *)(a3 + 8 * v11) = *(_DWORD *)(a1 + 4 * v11);
*(_DWORD *)(a3 + 8 * v11++ + 4) = *(_DWORD *)(a1 + 4 * v10);
if ( (int)v11 > (int)--v10 )
return;
}
*(_DWORD *)(a3 + 8LL * (_DWORD)v11) = *(_DWORD *)(a1 + 4LL * (int)v11);
}
|
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 + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x00101199
MOV dword ptr [RSI + -0x4],ECX
MOV dword ptr [RAX],EDX
JMP 0x00101199
LAB_001011b2:
ADD R8,0x1
ADD RSI,0x4
CMP R8,RBP
JZ 0x001011da
LAB_001011bf:
CMP EBX,R8D
JLE 0x001011b2
MOV EAX,R13D
SUB EAX,R8D
LEA RAX,[R8 + RAX*0x1 + -0x1]
LEA RDI,[R12 + RAX*0x4]
MOV RAX,RSI
JMP 0x001011a2
LAB_001011d8:
JS 0x00101214
LAB_001011da:
MOVSXD RDX,R9D
MOV EAX,0x0
JMP 0x00101201
LAB_001011e4:
MOV ECX,dword ptr [R10 + RAX*0x4]
MOV dword ptr [R11 + RAX*0x8],ECX
MOV ECX,dword ptr [R10 + RDX*0x4]
MOV dword ptr [R11 + RAX*0x8 + 0x4],ECX
ADD RAX,0x1
SUB RDX,0x1
CMP EAX,EDX
JG 0x00101214
LAB_00101201:
CMP EDX,EAX
JNZ 0x001011e4
MOVSXD RDX,EAX
MOV EDX,dword ptr [R10 + RDX*0x4]
ADD EAX,EAX
CDQE
MOV dword ptr [R11 + RAX*0x4],EDX
LAB_00101214:
POP RBX
POP RBP
POP R12
POP R13
RET
|
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 ((int)uVar6 < (int)param_2) {
piVar2 = piVar5;
do {
iVar1 = piVar5[-1];
if (*piVar2 < iVar1) {
piVar5[-1] = *piVar2;
*piVar2 = iVar1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != (int *)(param_1 + 8 +
((uVar6 - 1) + (ulong)(uint)(iVar7 - (int)uVar6)) * 4));
}
uVar6 = uVar6 + 1;
piVar5 = piVar5 + 1;
} while (uVar6 != param_2);
}
lVar4 = (long)iVar7;
lVar3 = 0;
do {
iVar7 = (int)lVar3;
if ((int)lVar4 == iVar7) {
*(int4 *)(param_3 + (long)(iVar7 * 2) * 4) = *(int4 *)(param_1 + (long)iVar7 * 4);
return;
}
*(int4 *)(param_3 + lVar3 * 8) = *(int4 *)(param_1 + lVar3 * 4);
*(int4 *)(param_3 + 4 + lVar3 * 8) = *(int4 *)(param_1 + lVar4 * 4);
lVar3 = lVar3 + 1;
lVar4 = lVar4 + -1;
} while ((int)lVar3 <= (int)lVar4);
return;
}
|
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 - 1;
int index = 0;
while (l <= r) {
if (l == r) {
out[index++] = lst[l++];
} else {
out[index++] = lst[l++];
out[index++] = lst[r--];
}
}
}
|
#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));
int a2[] = {5, 6, 7, 8, 9};
int e2[] = {5, 9, 6, 8, 7};
int out2[5];
func0(a2, 5, out2);
assert(issame(e2, out2, 5));
int a3[] = {1, 2, 3, 4, 5};
int e3[] = {1, 5, 2, 4, 3};
int out3[5];
func0(a3, 5, out3);
assert(issame(e3, out3, 5));
int a4[] = {5, 6, 7, 8, 9, 1};
int e4[] = {1, 9, 5, 8, 6, 7};
int out4[6];
func0(a4, 6, out4);
assert(issame(e4, out4, 6));
int a5[] = {5, 5, 5, 5};
int e5[] = {5, 5, 5, 5};
int out5[4];
func0(a5, 4, out5);
assert(issame(e5, out5, 4));
int a6[] = {};
int e6[] = {};
int out6[0];
func0(a6, 0, out6);
assert(issame(e6, out6, 0));
int a7[] = {1, 2, 3, 4, 5, 6, 7, 8};
int e7[] = {1, 8, 2, 7, 3, 6, 4, 5};
int out7[8];
func0(a7, 8, out7);
assert(issame(e7, out7, 8));
int a8[] = {0, 2, 2, 2, 5, 5, -5, -5};
int e8[] = {-5, 5, -5, 5, 0, 2, 2, 2};
int out8[8];
func0(a8, 8, out8);
assert(issame(e8, out8, 8));
int a9[] = {111111};
int e9[] = {111111};
int out9[1];
func0(a9, 1, out9);
assert(issame(e9, out9, 1));
return 0;
}
|
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 1762 <func0+0x42>
mov %r8d,(%r9)
mov %ecx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 1750 <func0+0x30>
add $0x1,%r10
add $0x4,%r9
cmp %rbx,%r10
jne 1748 <func0+0x28>
xor %eax,%eax
xor %esi,%esi
jmp 179c <func0+0x7c>
nopl (%rax)
movslq %r11d,%r8
add $0x1,%rax
sub $0x1,%r11d
add $0x2,%esi
mov (%rdi,%r8,4),%r8d
mov %r8d,0x4(%rdx,%rcx,1)
cmp %eax,%r11d
jl 17c3 <func0+0xa3>
movslq %esi,%rcx
mov (%rdi,%rax,4),%r9d
lea 0x1(%rsi),%r10d
shl $0x2,%rcx
lea (%rdx,%rcx,1),%r8
mov %r9d,(%r8)
cmp %eax,%r11d
jne 1780 <func0+0x60>
add $0x1,%rax
mov %r10d,%esi
cmp %eax,%r11d
jge 179c <func0+0x7c>
pop %rbx
retq
je 1777 <func0+0x57>
pop %rbx
retq
nopl 0x0(%rax)
|
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 eax, r9d
lea rax, [r9+rax-1]
lea r8, [r12+rax*4]
mov rax, rdi
nop word ptr [rax+rax+00000000h]
loc_1640:
mov ecx, [rdi-4]
mov esi, [rax]
cmp ecx, esi
jle short loc_164E
mov [rdi-4], esi
mov [rax], ecx
loc_164E:
add rax, 4
cmp rax, r8
jnz short loc_1640
loc_1657:
add r9, 1
add rdi, 4
cmp r9, rbp
jnz short loc_1620
loc_1664:
movsxd rax, r10d
xor ecx, ecx
jmp short loc_1687
loc_1670:
mov esi, [r11+rax*4]
add rcx, 1
sub rax, 1
add rdx, 8
mov [rdx-4], esi
cmp ecx, eax
jg short loc_1691
loc_1687:
mov esi, [r11+rcx*4]
mov [rdx], esi
cmp ecx, eax
jnz short loc_1670
loc_1691:
pop rbx
pop rbp
pop r12
retn
loc_1696:
jz short loc_1664
pop rbx
pop rbp
pop r12
retn
|
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 *)(a1 + 4);
v6 = 1LL;
do
{
if ( a2 > (int)v6 )
{
v7 = v5;
do
{
v8 = *(v5 - 1);
if ( v8 > *v7 )
{
*(v5 - 1) = *v7;
*v7 = v8;
}
++v7;
}
while ( v7 != (_DWORD *)(a1 + 8 + 4 * (v6 + (unsigned int)(v4 - v6) - 1)) );
}
++v6;
++v5;
}
while ( v6 != a2 );
}
v9 = v4;
v10 = 0LL;
do
{
*a3 = *(_DWORD *)(a1 + 4 * v10);
if ( (_DWORD)v10 == (_DWORD)v9 )
break;
v11 = *(_DWORD *)(a1 + 4 * v9);
++v10;
--v9;
a3 += 2;
*(a3 - 1) = v11;
}
while ( (int)v10 <= (int)v9 );
}
|
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*0x4]
MOV RAX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101640:
MOV ECX,dword ptr [RDI + -0x4]
MOV ESI,dword ptr [RAX]
CMP ECX,ESI
JLE 0x0010164e
MOV dword ptr [RDI + -0x4],ESI
MOV dword ptr [RAX],ECX
LAB_0010164e:
ADD RAX,0x4
CMP RAX,R8
JNZ 0x00101640
LAB_00101657:
ADD R9,0x1
ADD RDI,0x4
CMP R9,RBP
JNZ 0x00101620
LAB_00101664:
MOVSXD RAX,R10D
XOR ECX,ECX
JMP 0x00101687
LAB_00101670:
MOV ESI,dword ptr [R11 + RAX*0x4]
ADD RCX,0x1
SUB RAX,0x1
ADD RDX,0x8
MOV dword ptr [RDX + -0x4],ESI
CMP ECX,EAX
JG 0x00101691
LAB_00101687:
MOV ESI,dword ptr [R11 + RCX*0x4]
MOV dword ptr [RDX],ESI
CMP ECX,EAX
JNZ 0x00101670
LAB_00101691:
POP RBX
POP RBP
POP R12
RET
LAB_00101696:
JZ 0x00101664
POP RBX
POP RBP
POP R12
RET
|
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;
do {
if ((int)uVar7 < (int)param_2) {
piVar3 = piVar6;
do {
iVar2 = piVar6[-1];
if (*piVar3 < iVar2) {
piVar6[-1] = *piVar3;
*piVar3 = iVar2;
}
piVar3 = piVar3 + 1;
} while (piVar3 != (int *)(param_1 + 8 +
((uVar7 - 1) + (ulong)(uint)(iVar8 - (int)uVar7)) * 4));
}
uVar7 = uVar7 + 1;
piVar6 = piVar6 + 1;
} while (uVar7 != param_2);
}
lVar4 = (long)iVar8;
lVar5 = 0;
do {
*param_3 = *(int4 *)(param_1 + lVar5 * 4);
if ((int)lVar5 == (int)lVar4) {
return;
}
lVar1 = lVar4 * 4;
lVar5 = lVar5 + 1;
lVar4 = lVar4 + -1;
param_3[1] = *(int4 *)(param_1 + lVar1);
param_3 = param_3 + 2;
} while ((int)lVar5 <= (int)lVar4);
return;
}
|
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 - 1;
int index = 0;
while (l <= r) {
if (l == r) {
out[index++] = lst[l++];
} else {
out[index++] = lst[l++];
out[index++] = lst[r--];
}
}
}
|
#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));
int a2[] = {5, 6, 7, 8, 9};
int e2[] = {5, 9, 6, 8, 7};
int out2[5];
func0(a2, 5, out2);
assert(issame(e2, out2, 5));
int a3[] = {1, 2, 3, 4, 5};
int e3[] = {1, 5, 2, 4, 3};
int out3[5];
func0(a3, 5, out3);
assert(issame(e3, out3, 5));
int a4[] = {5, 6, 7, 8, 9, 1};
int e4[] = {1, 9, 5, 8, 6, 7};
int out4[6];
func0(a4, 6, out4);
assert(issame(e4, out4, 6));
int a5[] = {5, 5, 5, 5};
int e5[] = {5, 5, 5, 5};
int out5[4];
func0(a5, 4, out5);
assert(issame(e5, out5, 4));
int a6[] = {};
int e6[] = {};
int out6[0];
func0(a6, 0, out6);
assert(issame(e6, out6, 0));
int a7[] = {1, 2, 3, 4, 5, 6, 7, 8};
int e7[] = {1, 8, 2, 7, 3, 6, 4, 5};
int out7[8];
func0(a7, 8, out7);
assert(issame(e7, out7, 8));
int a8[] = {0, 2, 2, 2, 5, 5, -5, -5};
int e8[] = {-5, 5, -5, 5, 0, 2, 2, 2};
int out8[8];
func0(a8, 8, out8);
assert(issame(e8, out8, 8));
int a9[] = {111111};
int e9[] = {111111};
int out9[1];
func0(a9, 1, out9);
assert(issame(e9, out9, 1));
return 0;
}
|
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 1792 <func0+0x42>
mov %r8d,(%r9)
mov %ecx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 1780 <func0+0x30>
add $0x1,%r10
add $0x4,%r9
cmp %r10,%rbx
jne 1778 <func0+0x28>
xor %eax,%eax
xor %esi,%esi
nopl 0x0(%rax,%rax,1)
movslq %esi,%rcx
mov (%rdi,%rax,4),%r9d
lea 0x1(%rsi),%r10d
shl $0x2,%rcx
lea (%rdx,%rcx,1),%r8
mov %r9d,(%r8)
cmp %eax,%r11d
je 17f0 <func0+0xa0>
lea -0x1(%r11),%r8d
movslq %r11d,%r11
add $0x1,%rax
add $0x2,%esi
mov (%rdi,%r11,4),%r9d
mov %r9d,0x4(%rdx,%rcx,1)
cmp %eax,%r8d
jl 1800 <func0+0xb0>
mov %r8d,%r11d
jmp 17b0 <func0+0x60>
nopl 0x0(%rax)
add $0x1,%rax
cmp %eax,%r11d
jl 1800 <func0+0xb0>
mov %r10d,%esi
jmp 17b0 <func0+0x60>
je 17a7 <func0+0x57>
pop %rbx
retq
data16 nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
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 eax, r9d
lea rax, [r9+rax-1]
lea r8, [r12+rax*4]
mov rax, rdi
nop word ptr [rax+rax+00000000h]
loc_1660:
mov ecx, [rdi-4]
mov esi, [rax]
cmp ecx, esi
jle short loc_166E
mov [rdi-4], esi
mov [rax], ecx
loc_166E:
add rax, 4
cmp r8, rax
jnz short loc_1660
loc_1677:
add r9, 1
add rdi, 4
cmp r9, rbp
jnz short loc_1640
loc_1684:
movsxd rax, r10d
xor ecx, ecx
jmp short loc_16A7
loc_1690:
mov esi, [r11+rax*4]
add rcx, 1
sub rax, 1
add rdx, 8
mov [rdx-4], esi
cmp eax, ecx
jl short loc_16B1
loc_16A7:
mov esi, [r11+rcx*4]
mov [rdx], esi
cmp ecx, eax
jnz short loc_1690
loc_16B1:
pop rbx
pop rbp
pop r12
retn
loc_16B6:
jz short loc_1684
pop rbx
pop rbp
pop r12
retn
|
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 *)(a1 + 4);
v6 = 1LL;
do
{
if ( a2 > (int)v6 )
{
v7 = v5;
do
{
v8 = *(v5 - 1);
if ( v8 > *v7 )
{
*(v5 - 1) = *v7;
*v7 = v8;
}
++v7;
}
while ( (_DWORD *)(a1 + 8 + 4 * (v6 + (unsigned int)(v4 - v6) - 1)) != v7 );
}
++v6;
++v5;
}
while ( v6 != a2 );
}
v9 = v4;
v10 = 0LL;
do
{
*a3 = *(_DWORD *)(a1 + 4 * v10);
if ( (_DWORD)v10 == (_DWORD)v9 )
break;
v11 = *(_DWORD *)(a1 + 4 * v9);
++v10;
--v9;
a3 += 2;
*(a3 - 1) = v11;
}
while ( (int)v9 >= (int)v10 );
}
|
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*0x4]
MOV RAX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101660:
MOV ECX,dword ptr [RDI + -0x4]
MOV ESI,dword ptr [RAX]
CMP ECX,ESI
JLE 0x0010166e
MOV dword ptr [RDI + -0x4],ESI
MOV dword ptr [RAX],ECX
LAB_0010166e:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101660
LAB_00101677:
ADD R9,0x1
ADD RDI,0x4
CMP R9,RBP
JNZ 0x00101640
LAB_00101684:
MOVSXD RAX,R10D
XOR ECX,ECX
JMP 0x001016a7
LAB_00101690:
MOV ESI,dword ptr [R11 + RAX*0x4]
ADD RCX,0x1
SUB RAX,0x1
ADD RDX,0x8
MOV dword ptr [RDX + -0x4],ESI
CMP EAX,ECX
JL 0x001016b1
LAB_001016a7:
MOV ESI,dword ptr [R11 + RCX*0x4]
MOV dword ptr [RDX],ESI
CMP ECX,EAX
JNZ 0x00101690
LAB_001016b1:
POP RBX
POP RBP
POP R12
RET
LAB_001016b6:
JZ 0x00101684
POP RBX
POP RBP
POP R12
RET
|
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;
do {
if ((int)uVar7 < (int)param_2) {
piVar3 = piVar6;
do {
iVar2 = piVar6[-1];
if (*piVar3 < iVar2) {
piVar6[-1] = *piVar3;
*piVar3 = iVar2;
}
piVar3 = piVar3 + 1;
} while ((int *)(param_1 + 8 + ((uVar7 - 1) + (ulong)(uint)(iVar8 - (int)uVar7)) * 4) !=
piVar3);
}
uVar7 = uVar7 + 1;
piVar6 = piVar6 + 1;
} while (uVar7 != param_2);
}
lVar4 = (long)iVar8;
lVar5 = 0;
do {
*param_3 = *(int4 *)(param_1 + lVar5 * 4);
if ((int)lVar5 == (int)lVar4) {
return;
}
lVar1 = lVar4 * 4;
lVar5 = lVar5 + 1;
lVar4 = lVar4 + -1;
param_3[1] = *(int4 *)(param_1 + lVar1);
param_3 = param_3 + 2;
} while ((int)lVar5 <= (int)lVar4);
return;
}
|
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(fabs(func0(10, 5, 7) - 16.25) < 0.01);
assert(fabs(func0(2, 6, 3) + 1) < 0.01);
assert(fabs(func0(1, 1, 1) - 0.43) < 0.01);
assert(fabs(func0(2, 2, 10) + 1) < 0.01);
return 0;
}
|
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
addss -0x1c(%rbp),%xmm1
movss -0x18(%rbp),%xmm0
comiss %xmm1,%xmm0
jae 11e9 <func0+0x60>
movss -0x18(%rbp),%xmm0
movaps %xmm0,%xmm1
addss -0x1c(%rbp),%xmm1
movss -0x14(%rbp),%xmm0
comiss %xmm1,%xmm0
jb 11f3 <func0+0x6a>
movss 0xfb7(%rip),%xmm0
jmp 126f <func0+0xe6>
movss -0x14(%rbp),%xmm0
addss -0x18(%rbp),%xmm0
addss -0x1c(%rbp),%xmm0
movss 0xfa2(%rip),%xmm1
divss %xmm1,%xmm0
movss %xmm0,-0x8(%rbp)
movss -0x8(%rbp),%xmm0
subss -0x14(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss -0x8(%rbp),%xmm1
movss -0x8(%rbp),%xmm0
subss -0x18(%rbp),%xmm0
mulss %xmm0,%xmm1
movss -0x8(%rbp),%xmm0
subss -0x1c(%rbp),%xmm0
mulss %xmm1,%xmm0
callq 1090 <sqrtf@plt>
movd %xmm0,%eax
mov %eax,-0x4(%rbp)
movss -0x4(%rbp),%xmm1
movss 0xf56(%rip),%xmm0
mulss %xmm1,%xmm0
callq 1070 <roundf@plt>
movss 0xf45(%rip),%xmm1
divss %xmm1,%xmm0
leaveq
retq
|
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 xmm1, xmm0
addss xmm1, [rbp+var_1C]
movss xmm0, [rbp+var_18]
comiss xmm0, xmm1
jnb short loc_11E9
movss xmm0, [rbp+var_18]
movaps xmm1, xmm0
addss xmm1, [rbp+var_1C]
movss xmm0, [rbp+var_14]
comiss xmm0, xmm1
jb short loc_11F6
loc_11E9:
movss xmm0, cs:dword_2188
jmp locret_128A
loc_11F6:
movss xmm0, [rbp+var_14]
addss xmm0, [rbp+var_18]
addss xmm0, [rbp+var_1C]
movss xmm1, cs:dword_218C
divss xmm0, xmm1
movss [rbp+var_8], xmm0
movss xmm0, [rbp+var_8]
subss xmm0, [rbp+var_14]
movaps xmm1, xmm0
mulss xmm1, [rbp+var_8]
movss xmm0, [rbp+var_8]
subss xmm0, [rbp+var_18]
mulss xmm1, xmm0
movss xmm0, [rbp+var_8]
subss xmm0, [rbp+var_1C]
mulss xmm1, xmm0
movd eax, xmm1
movd xmm0, eax; x
call _sqrtf
movd eax, xmm0
mov [rbp+var_4], eax
movss xmm1, [rbp+var_4]
movss xmm0, cs:dword_2190
mulss xmm1, xmm0
movd eax, xmm1
movd xmm0, eax; x
call _roundf
movd eax, xmm0
movss xmm1, cs:dword_2190
movd xmm0, eax
divss xmm0, xmm1
locret_128A:
leave
retn
|
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) )
return -1.0;
*(float *)&v11 = (float)((float)(a1 + a2) + a3) / 2.0;
v4 = (__m128i)v11;
*(float *)v4.m128i_i32 = *(float *)&v11 - a1;
v5 = v4;
*(float *)v5.m128i_i32 = (float)((float)((float)(*(float *)&v11 - a1) * *(float *)&v11)
* (float)((float)((float)((float)(a1 + a2) + a3) / 2.0) - a2))
* (float)((float)((float)((float)(a1 + a2) + a3) / 2.0) - a3);
v6 = _mm_cvtsi32_si128(_mm_cvtsi128_si32(v5));
*(float *)v6.m128i_i32 = sqrtf(*(float *)v6.m128i_i32);
v12 = COERCE_FLOAT(_mm_cvtsi128_si32(v6));
v7 = (__m128i)LODWORD(v12);
*(float *)v7.m128i_i32 = v12 * 100.0;
v8 = _mm_cvtsi32_si128(_mm_cvtsi128_si32(v7));
*(float *)v8.m128i_i32 = roundf(*(float *)v8.m128i_i32);
return COERCE_FLOAT(_mm_cvtsi128_si32(v8)) / 100.0;
}
|
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,dword ptr [RBP + -0x14]
MOVAPS XMM1,XMM0
ADDSS XMM1,dword ptr [RBP + -0x1c]
MOVSS XMM0,dword ptr [RBP + -0x18]
COMISS XMM0,XMM1
JNC 0x001011e9
MOVSS XMM0,dword ptr [RBP + -0x18]
MOVAPS XMM1,XMM0
ADDSS XMM1,dword ptr [RBP + -0x1c]
MOVSS XMM0,dword ptr [RBP + -0x14]
COMISS XMM0,XMM1
JC 0x001011f6
LAB_001011e9:
MOVSS XMM0,dword ptr [0x00102188]
JMP 0x0010128a
LAB_001011f6:
MOVSS XMM0,dword ptr [RBP + -0x14]
ADDSS XMM0,dword ptr [RBP + -0x18]
ADDSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM1,dword ptr [0x0010218c]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x8],XMM0
MOVSS XMM0,dword ptr [RBP + -0x8]
SUBSS XMM0,dword ptr [RBP + -0x14]
MOVAPS XMM1,XMM0
MULSS XMM1,dword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RBP + -0x8]
SUBSS XMM0,dword ptr [RBP + -0x18]
MULSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x8]
SUBSS XMM0,dword ptr [RBP + -0x1c]
MULSS XMM1,XMM0
MOVD EAX,XMM1
MOVD XMM0,EAX
CALL 0x00101090
MOVD EAX,XMM0
MOV dword ptr [RBP + -0x4],EAX
MOVSS XMM1,dword ptr [RBP + -0x4]
MOVSS XMM0,dword ptr [0x00102190]
MULSS XMM1,XMM0
MOVD EAX,XMM1
MOVD XMM0,EAX
CALL 0x00101070
MOVD EAX,XMM0
MOVSS XMM1,dword ptr [0x00102190]
MOVD XMM0,EAX
DIVSS XMM0,XMM1
LAB_0010128a:
LEAVE
RET
|
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 - param_3));
roundf(fVar1 * DAT_00102190);
}
return;
}
|
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(fabs(func0(10, 5, 7) - 16.25) < 0.01);
assert(fabs(func0(2, 6, 3) + 1) < 0.01);
assert(fabs(func0(1, 1, 1) - 0.43) < 0.01);
assert(fabs(func0(2, 2, 10) + 1) < 0.01);
return 0;
}
|
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,%xmm3
mulss 0xfd3(%rip),%xmm3
movaps %xmm3,%xmm6
subss %xmm0,%xmm6
movaps %xmm6,%xmm0
mulss %xmm3,%xmm0
movaps %xmm3,%xmm7
subss %xmm1,%xmm7
mulss %xmm7,%xmm0
subss %xmm2,%xmm3
mulss %xmm3,%xmm0
movaps %xmm0,%xmm6
sqrtss %xmm6,%xmm6
movss %xmm6,0xc(%rsp)
pxor %xmm1,%xmm1
ucomiss %xmm0,%xmm1
ja 122e <func0+0xa5>
movss 0xf98(%rip),%xmm0
mulss 0xc(%rsp),%xmm0
callq 1070 <roundf@plt>
movaps %xmm0,%xmm4
divss 0xf82(%rip),%xmm4
movaps %xmm4,%xmm0
add $0x18,%rsp
retq
callq 1090 <sqrtf@plt>
jmp 1208 <func0+0x7f>
movss 0xf63(%rip),%xmm4
movaps %xmm4,%xmm0
retq
|
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 xmm4, xmm2
mulss xmm4, cs:dword_2008
movaps xmm0, xmm4
subss xmm0, xmm3
mulss xmm0, xmm4
movaps xmm3, xmm4
subss xmm3, xmm1
mulss xmm0, xmm3
subss xmm4, xmm2
mulss xmm0, xmm4; x
pxor xmm1, xmm1
ucomiss xmm1, xmm0
ja short loc_120F
sqrtss xmm0, xmm0
loc_11F5:
mulss xmm0, cs:dword_200C; x
call _roundf
divss xmm0, cs:dword_200C
add rsp, 8
retn
loc_120F:
call _sqrtf
jmp short loc_11F5
loc_1216:
movss xmm0, cs:dword_2004
retn
loc_121F:
movss xmm0, cs:dword_2004
retn
|
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)((float)((float)((float)((float)(v3 + a3) * 0.5) - a1) * (float)((float)(v3 + a3) * 0.5))
* (float)((float)((float)(v3 + a3) * 0.5) - a2))
* (float)((float)((float)(v3 + a3) * 0.5) - a3);
if ( v6 < 0.0 )
v7 = sqrtf(v6);
else
v7 = fsqrt(v6);
return roundf(v7 * 100.0) / 100.0;
}
return result;
}
|
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 [0x00102008]
MOVAPS XMM0,XMM4
SUBSS XMM0,XMM3
MULSS XMM0,XMM4
MOVAPS XMM3,XMM4
SUBSS XMM3,XMM1
MULSS XMM0,XMM3
SUBSS XMM4,XMM2
MULSS XMM0,XMM4
PXOR XMM1,XMM1
UCOMISS XMM1,XMM0
JA 0x0010120f
SQRTSS XMM0,XMM0
LAB_001011f5:
MULSS XMM0,dword ptr [0x0010200c]
CALL 0x00101070
DIVSS XMM0,dword ptr [0x0010200c]
ADD RSP,0x8
RET
LAB_0010120f:
CALL 0x00101090
JMP 0x001011f5
LAB_00101216:
MOVSS XMM0,dword ptr [0x00102004]
RET
LAB_0010121f:
MOVSS XMM0,dword ptr [0x00102004]
RET
|
/* 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 DAT_00102004;
}
fVar1 = (param_1 + param_2 + param_3) * _DAT_00102008;
fVar1 = (fVar1 - param_1) * fVar1 * (fVar1 - param_2) * (fVar1 - param_3);
if (fVar1 < 0.0) {
fVar1 = sqrtf(fVar1);
}
else {
fVar1 = SQRT(fVar1);
}
fVar1 = roundf(fVar1 * _DAT_0010200c);
return fVar1 / _DAT_0010200c;
}
return DAT_00102004;
}
|
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(fabs(func0(10, 5, 7) - 16.25) < 0.01);
assert(fabs(func0(2, 6, 3) + 1) < 0.01);
assert(fabs(func0(1, 1, 1) - 0.43) < 0.01);
assert(fabs(func0(2, 2, 10) + 1) < 0.01);
return 0;
}
|
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,%rsp
mulss 0xe44(%rip),%xmm3
movaps %xmm3,%xmm6
movaps %xmm3,%xmm7
subss %xmm0,%xmm6
subss %xmm1,%xmm7
movaps %xmm6,%xmm0
mulss %xmm3,%xmm0
subss %xmm2,%xmm3
pxor %xmm2,%xmm2
mulss %xmm7,%xmm0
mulss %xmm3,%xmm0
ucomiss %xmm0,%xmm2
movaps %xmm0,%xmm1
sqrtss %xmm1,%xmm1
ja 1224 <func0+0xa4>
movss 0xe0f(%rip),%xmm0
mulss %xmm1,%xmm0
callq 1060 <roundf@plt>
movaps %xmm0,%xmm5
divss 0xdfb(%rip),%xmm5
add $0x18,%rsp
movaps %xmm5,%xmm0
retq
nopl 0x0(%rax)
movaps %xmm5,%xmm0
retq
movss %xmm1,0xc(%rsp)
callq 1070 <sqrtf@plt>
movss 0xc(%rsp),%xmm1
jmp 11f5 <func0+0x75>
nopw 0x0(%rax,%rax,1)
|
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
mulss xmm4, cs:dword_2008
movaps xmm0, xmm4
subss xmm0, xmm3
movaps xmm3, xmm4
subss xmm3, xmm1
pxor xmm1, xmm1
mulss xmm0, xmm4
subss xmm4, xmm2
mulss xmm0, xmm3
mulss xmm0, xmm4; x
ucomiss xmm1, xmm0
ja short loc_1599
sqrtss xmm0, xmm0
loc_155F:
mulss xmm0, cs:dword_200C; x
call _roundf
divss xmm0, cs:dword_200C
add rsp, 8
retn
locret_1580:
retn
locret_1588:
retn
loc_1590:
movss xmm0, cs:dword_2004
retn
loc_1599:
call _sqrtf
jmp short loc_155F
|
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 = (float)((float)((float)((float)((float)(v3 + a3) * 0.5) - a1) * (float)((float)(v3 + a3) * 0.5))
* (float)((float)((float)(v3 + a3) * 0.5) - a2))
* (float)((float)((float)(v3 + a3) * 0.5) - a3);
if ( v7 < 0.0 )
v8 = sqrtf(v7);
else
v8 = fsqrt(v7);
return roundf(v8 * 100.0) / 100.0;
}
return result;
}
|
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,XMM4
SUBSS XMM0,XMM3
MOVAPS XMM3,XMM4
SUBSS XMM3,XMM1
PXOR XMM1,XMM1
MULSS XMM0,XMM4
SUBSS XMM4,XMM2
MULSS XMM0,XMM3
MULSS XMM0,XMM4
UCOMISS XMM1,XMM0
JA 0x00101599
SQRTSS XMM0,XMM0
LAB_0010155f:
MULSS XMM0,dword ptr [0x0010200c]
CALL 0x00101070
DIVSS XMM0,dword ptr [0x0010200c]
ADD RSP,0x8
RET
LAB_00101580:
RET
LAB_00101588:
RET
LAB_00101590:
MOVSS XMM0,dword ptr [0x00102004]
RET
LAB_00101599:
CALL 0x00101090
JMP 0x0010155f
|
/* 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 = (param_1 + param_2 + param_3) * _DAT_00102008;
fVar1 = (fVar1 - param_1) * fVar1 * (fVar1 - param_2) * (fVar1 - param_3);
if (fVar1 < 0.0) {
fVar1 = sqrtf(fVar1);
}
else {
fVar1 = SQRT(fVar1);
}
fVar1 = roundf(fVar1 * _DAT_0010200c);
return fVar1 / _DAT_0010200c;
}
return DAT_00102004;
}
return DAT_00102004;
}
|
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(fabs(func0(10, 5, 7) - 16.25) < 0.01);
assert(fabs(func0(2, 6, 3) + 1) < 0.01);
assert(fabs(func0(1, 1, 1) - 0.43) < 0.01);
assert(fabs(func0(2, 2, 10) + 1) < 0.01);
return 0;
}
|
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,%rsp
mulss 0xe44(%rip),%xmm3
movaps %xmm3,%xmm6
movaps %xmm3,%xmm7
subss %xmm0,%xmm6
subss %xmm1,%xmm7
movaps %xmm6,%xmm0
mulss %xmm3,%xmm0
subss %xmm2,%xmm3
pxor %xmm2,%xmm2
mulss %xmm7,%xmm0
mulss %xmm3,%xmm0
ucomiss %xmm0,%xmm2
movaps %xmm0,%xmm1
sqrtss %xmm1,%xmm1
ja 1224 <func0+0xa4>
movss 0xe0f(%rip),%xmm0
mulss %xmm1,%xmm0
callq 1060 <roundf@plt>
movaps %xmm0,%xmm5
divss 0xdfb(%rip),%xmm5
add $0x18,%rsp
movaps %xmm5,%xmm0
retq
nopl 0x0(%rax)
movaps %xmm5,%xmm0
retq
movss %xmm1,0xc(%rsp)
callq 1070 <sqrtf@plt>
movss 0xc(%rsp),%xmm1
jmp 11f5 <func0+0x75>
nopw 0x0(%rax,%rax,1)
|
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
mulss xmm4, cs:dword_2008
movaps xmm0, xmm4
subss xmm0, xmm3
movaps xmm3, xmm4
subss xmm3, xmm1
pxor xmm1, xmm1
mulss xmm0, xmm4
subss xmm4, xmm2
mulss xmm0, xmm3
mulss xmm0, xmm4; x
ucomiss xmm1, xmm0
ja short loc_1229
sqrtss xmm0, xmm0
loc_11EF:
mulss xmm0, cs:dword_200C; x
call _roundf
divss xmm0, cs:dword_200C
add rsp, 8
retn
locret_1210:
retn
locret_1218:
retn
loc_1220:
movss xmm0, cs:dword_2004
retn
loc_1229:
call _sqrtf
jmp short loc_11EF
|
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 = (float)((float)((float)((float)((float)(v3 + a3) * 0.5) - a1) * (float)((float)(v3 + a3) * 0.5))
* (float)((float)((float)(v3 + a3) * 0.5) - a2))
* (float)((float)((float)(v3 + a3) * 0.5) - a3);
if ( v7 < 0.0 )
v8 = sqrtf(v7);
else
v8 = fsqrt(v7);
return roundf(v8 * 100.0) / 100.0;
}
return result;
}
|
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,XMM4
SUBSS XMM0,XMM3
MOVAPS XMM3,XMM4
SUBSS XMM3,XMM1
PXOR XMM1,XMM1
MULSS XMM0,XMM4
SUBSS XMM4,XMM2
MULSS XMM0,XMM3
MULSS XMM0,XMM4
UCOMISS XMM1,XMM0
JA 0x00101229
SQRTSS XMM0,XMM0
LAB_001011ef:
MULSS XMM0,dword ptr [0x0010200c]
CALL 0x00101060
DIVSS XMM0,dword ptr [0x0010200c]
ADD RSP,0x8
RET
LAB_00101210:
RET
LAB_00101218:
RET
LAB_00101220:
MOVSS XMM0,dword ptr [0x00102004]
RET
LAB_00101229:
CALL 0x00101070
JMP 0x001011ef
|
/* 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 = (param_1 + param_2 + param_3) * _DAT_00102008;
fVar1 = (fVar1 - param_1) * fVar1 * (fVar1 - param_2) * (fVar1 - param_3);
if (fVar1 < 0.0) {
fVar1 = sqrtf(fVar1);
}
else {
fVar1 = SQRT(fVar1);
}
fVar1 = roundf(fVar1 * _DAT_0010200c);
return fVar1 / _DAT_0010200c;
}
return DAT_00102004;
}
return DAT_00102004;
}
|
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) == false);
int test5[] = {1, 2, 3};
assert(func0(test5, 3, 6) == false);
int test6[] = {5};
assert(func0(test6, 1, 5) == true);
printf("All tests passed.\n");
return 0;
}
|
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),%eax
sub $0x1,%eax
sub -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 11eb <func0+0x62>
mov $0x0,%eax
jmpq 1279 <func0+0xf0>
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 -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %edx,%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x4(%rbp)
jl 11ab <func0+0x22>
mov -0x1c(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 1270 <func0+0xe7>
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x20(%rbp),%eax
setle %al
pop %rbp
retq
|
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]
mov eax, [rbp+var_1C]
sub eax, 1
sub eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_11EB
mov eax, 0
jmp loc_127F
loc_11EB:
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]
sub eax, 1
sub eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
add eax, edx
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_1226:
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_4], eax
jl loc_11AB
mov edx, [rbp+var_1C]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_1276
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_1276:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_20]
setle al
loc_127F:
pop rbp
retn
|
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) + a1);
}
if ( a2 % 2 == 1 )
v4 += *(_DWORD *)(4LL * (a2 / 2) + a1);
return v4 <= a3;
}
|
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
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001011eb
MOV EAX,0x0
JMP 0x0010127f
LAB_001011eb:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101226:
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x001011ab
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x00101276
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
LAB_00101276:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x20]
SETLE AL
LAB_0010127f:
POP RBP
RET
|
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)local_10 >> 8),local_10 <= param_3);
}
if (*(int *)(param_1 + (long)local_c * 4) !=
*(int *)(param_1 + (long)((param_2 + -1) - local_c) * 4)) break;
local_10 = local_10 +
*(int *)(param_1 + (long)((param_2 + -1) - local_c) * 4) +
*(int *)(param_1 + (long)local_c * 4);
local_c = local_c + 1;
}
return 0;
}
|
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) == false);
int test5[] = {1, 2, 3};
assert(func0(test5, 3, 6) == false);
int test6[] = {5};
assert(func0(test6, 1, 5) == true);
printf("All tests passed.\n");
return 0;
}
|
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>
add %r9d,%eax
add %eax,%r10d
add $0x1,%rcx
sub $0x4,%r8
cmp %ecx,%r11d
jg 11b1 <func0+0x28>
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
and $0x1,%esi
sub %eax,%esi
cmp $0x1,%esi
je 11f1 <func0+0x68>
cmp %edx,%r10d
setle %al
pop %rbx
retq
mov $0x0,%r10d
jmp 11d0 <func0+0x47>
movslq %ebx,%rbx
add (%rdi,%rbx,4),%r10d
jmp 11e1 <func0+0x58>
mov $0x0,%eax
jmp 11e7 <func0+0x5e>
|
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 short loc_1202
add eax, esi
add edi, eax
add rdx, 1
sub rcx, 4
cmp r8d, edx
jg short loc_11B9
loc_11D5:
mov eax, r10d
shr eax, 1Fh
add r10d, eax
and r10d, 1
sub r10d, eax
cmp r10d, 1
jz short loc_11F9
loc_11EB:
cmp edi, r11d
setle al
retn
loc_11F2:
mov edi, 0
jmp short loc_11D5
loc_11F9:
movsxd r8, r8d
add edi, [r9+r8*4]
jmp short loc_11EB
loc_1202:
mov eax, 0
retn
|
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
{
v7 = a1 + 4LL * a2;
v8 = 0LL;
v9 = 0;
while ( 1 )
{
v10 = *(_DWORD *)(a1 + 4 * v8);
v11 = *(_DWORD *)(v7 - 4);
if ( v10 != v11 )
return 0;
v9 += v11 + v10;
++v8;
v7 -= 4LL;
if ( v6 <= (int)v8 )
goto LABEL_5;
}
}
}
|
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
ADD RDX,0x1
SUB RCX,0x4
CMP R8D,EDX
JG 0x001011b9
LAB_001011d5:
MOV EAX,R10D
SHR EAX,0x1f
ADD R10D,EAX
AND R10D,0x1
SUB R10D,EAX
CMP R10D,0x1
JZ 0x001011f9
LAB_001011eb:
CMP EDI,R11D
SETLE AL
RET
LAB_001011f2:
MOV EDI,0x0
JMP 0x001011d5
LAB_001011f9:
MOVSXD R8,R8D
ADD EDI,dword ptr [R9 + R8*0x4]
JMP 0x001011eb
LAB_00101202:
MOV EAX,0x0
RET
|
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 + -4)) {
return false;
}
iVar4 = iVar4 + iVar1 + *(int *)(lVar2 + -4);
lVar3 = lVar3 + 1;
lVar2 = lVar2 + -4;
} while ((int)lVar3 < param_2 / 2);
}
if (param_2 % 2 == 1) {
iVar4 = iVar4 + *(int *)(param_1 + (long)(param_2 / 2) * 4);
}
return iVar4 <= param_3;
}
|
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) == false);
int test5[] = {1, 2, 3};
assert(func0(test5, 3, 6) == false);
int test6[] = {5};
assert(func0(test6, 1, 5) == true);
printf("All tests passed.\n");
return 0;
}
|
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,%rcx
cmp %eax,%r10d
jle 11c0 <func0+0x50>
mov (%rdi,%rax,4),%r8d
cmp (%rcx),%r8d
je 11a0 <func0+0x30>
xor %eax,%eax
retq
xor %r9d,%r9d
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
and $0x1,%esi
sub %eax,%esi
cmp $0x1,%esi
je 11e0 <func0+0x70>
cmp %edx,%r9d
setle %al
retq
nopl 0x0(%rax,%rax,1)
movslq %r10d,%r10
add (%rdi,%r10,4),%r9d
cmp %edx,%r9d
setle %al
retq
xchg %ax,%ax
|
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 rdx, 4
cmp r8d, eax
jle short loc_13D0
loc_13C0:
mov ecx, [r9+rax*4]
cmp ecx, [rdx]
jz short loc_13B0
xor eax, eax
retn
loc_13CB:
xor edi, edi
nop dword ptr [rax]
loc_13D0:
mov eax, esi
shr eax, 1Fh
add esi, eax
and esi, 1
sub esi, eax
cmp esi, 1
jz short loc_13F0
cmp edi, r10d
setle al
retn
loc_13F0:
movsxd r8, r8d
add edi, [r9+r8*4]
cmp edi, r10d
setle al
retn
|
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 + 4LL * (a2 - 1));
v7 = 0LL;
v8 = 0;
while ( 1 )
{
v9 = *(_DWORD *)(a1 + 4 * v7);
if ( v9 != *v6 )
return 0;
++v7;
v8 += 2 * v9;
--v6;
if ( v5 <= (int)v7 )
goto LABEL_7;
}
}
}
|
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 ptr [R9 + RAX*0x4]
CMP ECX,dword ptr [RDX]
JZ 0x001013b0
XOR EAX,EAX
RET
LAB_001013cb:
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_001013d0:
MOV EAX,ESI
SHR EAX,0x1f
ADD ESI,EAX
AND ESI,0x1
SUB ESI,EAX
CMP ESI,0x1
JZ 0x001013f0
CMP EDI,R10D
SETLE AL
RET
LAB_001013f0:
MOVSXD R8,R8D
ADD EDI,dword ptr [R9 + R8*0x4]
CMP EDI,R10D
SETLE AL
RET
|
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 != *piVar3) {
return false;
}
lVar2 = lVar2 + 1;
iVar4 = iVar4 + iVar1 * 2;
piVar3 = piVar3 + -1;
} while ((int)lVar2 < param_2 / 2);
}
if (param_2 % 2 != 1) {
return iVar4 <= param_3;
}
return iVar4 + *(int *)(param_1 + (long)(param_2 / 2) * 4) <= param_3;
}
|
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) == false);
int test5[] = {1, 2, 3};
assert(func0(test5, 3, 6) == false);
int test6[] = {5};
assert(func0(test6, 1, 5) == true);
printf("All tests passed.\n");
return 0;
}
|
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,%rcx
cmp %eax,%r10d
jle 11c0 <func0+0x50>
mov (%rdi,%rax,4),%r8d
cmp (%rcx),%r8d
je 11a0 <func0+0x30>
xor %eax,%eax
retq
xor %r9d,%r9d
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
and $0x1,%esi
sub %eax,%esi
cmp $0x1,%esi
je 11e0 <func0+0x70>
cmp %edx,%r9d
setle %al
retq
nopl 0x0(%rax,%rax,1)
movslq %r10d,%r10
add (%rdi,%r10,4),%r9d
cmp %edx,%r9d
setle %al
retq
xchg %ax,%ax
|
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 rdx, 4
cmp r8d, eax
jle short loc_11C0
loc_11B0:
mov ecx, [r9+rax*4]
cmp ecx, [rdx]
jz short loc_11A0
xor eax, eax
retn
loc_11BB:
xor edi, edi
nop dword ptr [rax]
loc_11C0:
mov eax, esi
shr eax, 1Fh
add esi, eax
and esi, 1
sub esi, eax
cmp esi, 1
jz short loc_11E0
cmp edi, r10d
setle al
retn
loc_11E0:
movsxd r8, r8d
add edi, [r9+r8*4]
cmp edi, r10d
setle al
retn
|
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 + 4LL * (a2 - 1));
v7 = 0LL;
v8 = 0;
while ( 1 )
{
v9 = *(_DWORD *)(a1 + 4 * v7);
if ( v9 != *v6 )
return 0;
++v7;
v8 += 2 * v9;
--v6;
if ( v5 <= (int)v7 )
goto LABEL_7;
}
}
}
|
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 ptr [R9 + RAX*0x4]
CMP ECX,dword ptr [RDX]
JZ 0x001011a0
XOR EAX,EAX
RET
LAB_001011bb:
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_001011c0:
MOV EAX,ESI
SHR EAX,0x1f
ADD ESI,EAX
AND ESI,0x1
SUB ESI,EAX
CMP ESI,0x1
JZ 0x001011e0
CMP EDI,R10D
SETLE AL
RET
LAB_001011e0:
MOVSXD R8,R8D
ADD EDI,dword ptr [R9 + R8*0x4]
CMP EDI,R10D
SETLE AL
RET
|
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 != *piVar3) {
return false;
}
lVar2 = lVar2 + 1;
iVar4 = iVar4 + iVar1 * 2;
piVar3 = piVar3 + -1;
} while ((int)lVar2 < param_2 / 2);
}
if (param_2 % 2 != 1) {
return iVar4 <= param_3;
}
return iVar4 + *(int *)(param_1 + (long)(param_2 / 2) * 4) <= param_3;
}
|
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(test4, 4) == 1);
int test5[] = {1, 2, 3, 2, 1};
assert(func0(test5, 5) == 0);
int test6[] = {3, 1, 1, 3};
assert(func0(test6, 4) == 0);
int test7[] = {1};
assert(func0(test7, 1) == 0);
int test8[] = {0, 1};
assert(func0(test8, 2) == 1);
return 0;
}
|
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 -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 11c2 <func0+0x59>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x4(%rbp)
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
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]
sub eax, 1
sub eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_11C2
add [rbp+var_8], 1
loc_11C2:
add [rbp+var_4], 1
loc_11C6:
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_4], eax
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn
|
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,dword ptr [RBP + -0x1c]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001011c2
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c2:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
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;
}
}
return local_10;
}
|
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(test4, 4) == 1);
int test5[] = {1, 2, 3, 2, 1};
assert(func0(test5, 5) == 0);
int test6[] = {3, 1, 1, 3};
assert(func0(test6, 4) == 0);
int test7[] = {1};
assert(func0(test7, 1) == 0);
int test8[] = {0, 1};
assert(func0(test8, 2) == 1);
return 0;
}
|
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 $0x4,%rdx
cmp %eax,%r8d
jg 1190 <func0+0x27>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 11ad <func0+0x44>
|
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, [rdx-4]
cmp [rdi+rax*4], r8d
jz short loc_118E
add esi, 1
jmp short loc_118E
loc_11A9:
mov esi, 0
loc_11AE:
mov eax, esi
retn
|
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) )
++v5;
++v4;
v3 -= 4LL;
}
while ( v2 > (int)v4 );
}
return v5;
}
|
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 0x0010118e
ADD ESI,0x1
JMP 0x0010118e
LAB_001011a9:
MOV ESI,0x0
LAB_001011ae:
MOV EAX,ESI
RET
|
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;
}
lVar1 = lVar1 + 1;
lVar2 = lVar2 + -4;
} while ((int)lVar1 < param_2 / 2);
}
return iVar3;
}
|
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(test4, 4) == 1);
int test5[] = {1, 2, 3, 2, 1};
assert(func0(test5, 5) == 0);
int test6[] = {3, 1, 1, 3};
assert(func0(test6, 4) == 0);
int test7[] = {1};
assert(func0(test7, 1) == 0);
int test8[] = {0, 1};
assert(func0(test8, 2) == 1);
return 0;
}
|
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
sub $0x4,%rdx
add %ecx,%r8d
cmp %eax,%r9d
jg 1168 <func0+0x28>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
|
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
sub rdx, 4
movzx esi, sil
add ecx, esi
cmp r8d, eax
jg short loc_1428
mov eax, ecx
retn
loc_1450:
xor ecx, ecx
mov eax, ecx
retn
|
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 += v6;
}
while ( v2 > (int)v3 );
return 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
CMP R8D,EAX
JG 0x00101428
MOV EAX,ECX
RET
LAB_00101450:
XOR ECX,ECX
MOV EAX,ECX
RET
|
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 = piVar5 + -1;
iVar4 = iVar4 + (uint)(*(int *)(param_1 + lVar1) != iVar2);
} while ((int)lVar3 < param_2 / 2);
return iVar4;
}
return 0;
}
|
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(test4, 4) == 1);
int test5[] = {1, 2, 3, 2, 1};
assert(func0(test5, 5) == 0);
int test6[] = {3, 1, 1, 3};
assert(func0(test6, 4) == 0);
int test7[] = {1};
assert(func0(test7, 1) == 0);
int test8[] = {0, 1};
assert(func0(test8, 2) == 1);
return 0;
}
|
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,%xmm2
shl $0x4,%rcx
add %rdi,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rdx),%xmm3
movdqu (%rax),%xmm4
add $0x10,%rax
sub $0x10,%rdx
pshufd $0x1b,%xmm3,%xmm0
pcmpeqd %xmm4,%xmm0
pandn %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rcx,%rax
jne 1190 <func0+0x50>
movdqa %xmm1,%xmm0
mov %r8d,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
test $0x3,%r8b
je 1240 <func0+0x100>
mov %r9d,%ecx
movslq %edx,%rsi
sub %edx,%ecx
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
cmp %ecx,(%rdi,%rsi,4)
je 11f6 <func0+0xb6>
add $0x1,%eax
lea 0x1(%rdx),%ecx
cmp %r8d,%ecx
jge 123a <func0+0xfa>
mov %r9d,%esi
sub %ecx,%esi
movslq %ecx,%rcx
movslq %esi,%rsi
mov (%rdi,%rcx,4),%ecx
cmp %ecx,(%rdi,%rsi,4)
je 1214 <func0+0xd4>
add $0x1,%eax
add $0x2,%edx
cmp %r8d,%edx
jge 123a <func0+0xfa>
sub %edx,%r9d
movslq %edx,%rcx
movslq %r9d,%r9
mov (%rdi,%r9,4),%esi
cmp %esi,(%rdi,%rcx,4)
je 123a <func0+0xfa>
add $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 11e0 <func0+0xa0>
nopw 0x0(%rax,%rax,1)
|
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 rcx, rdi
nop word ptr [rax+rax+00000000h]
loc_1190:
movdqu xmm3, xmmword ptr [rdx]
movdqu xmm4, xmmword ptr [rax]
add rax, 10h
sub rdx, 10h
pshufd xmm0, xmm3, 1Bh
pcmpeqd xmm0, xmm4
pcmpeqd xmm0, xmm2
psubd xmm1, xmm0
cmp rax, rcx
jnz short loc_1190
movdqa xmm0, xmm1
mov edx, r8d
psrldq xmm0, 8
and edx, 0FFFFFFFCh
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
test r8b, 3
jz short locret_1248
loc_11E0:
mov ecx, r9d
movsxd rsi, edx
sub ecx, edx
lea r10, ds:0[rsi*4]
movsxd rcx, ecx
mov ecx, [rdi+rcx*4]
cmp [rdi+rsi*4], ecx
jz short loc_11FE
add eax, 1
loc_11FE:
lea esi, [rdx+1]
cmp r8d, esi
jle short locret_1242
mov ecx, r9d
sub ecx, esi
mov esi, [rdi+r10+4]
movsxd rcx, ecx
cmp [rdi+rcx*4], esi
jz short loc_121B
add eax, 1
loc_121B:
add edx, 2
cmp edx, r8d
jge short locret_1242
sub r9d, edx
movsxd r9, r9d
mov esi, [rdi+r9*4]
cmp [rdi+r10+8], esi
jz short locret_1242
add eax, 1
retn
loc_1240:
xor eax, eax
locret_1242:
retn
locret_1248:
retn
loc_1249:
xor edx, edx
xor eax, eax
jmp short loc_11E0
|
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
v2 = a2 / 2;
if ( a2 <= 1 )
return 0LL;
v3 = a2 - 1;
if ( a2 <= 7 )
{
v9 = 0;
result = 0LL;
}
else
{
v4 = 0LL;
v5 = a1;
v6 = (const __m128i *)((char *)a1 + 4 * a2 - 16);
do
{
v7 = _mm_loadu_si128(v6);
v8 = _mm_loadu_si128(v5++);
--v6;
v4 = _mm_sub_epi32(v4, _mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_shuffle_epi32(v7, 27), v8), (__m128i)0LL));
}
while ( v5 != &a1[(unsigned int)v2 >> 2] );
v9 = v2 & 0xFFFFFFFC;
v10 = _mm_add_epi32(v4, _mm_srli_si128(v4, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v10, _mm_srli_si128(v10, 4)));
if ( (v2 & 3) == 0 )
return result;
}
v12 = v9;
if ( a1->m128i_i32[v12] != a1->m128i_i32[v3 - v9] )
result = (unsigned int)(result + 1);
if ( v2 > v9 + 1 )
{
if ( a1->m128i_i32[v3 - (v9 + 1)] != a1->m128i_i32[v12 + 1] )
result = (unsigned int)(result + 1);
v13 = v9 + 2;
if ( v13 < v2 && a1->m128i_i32[v12 + 2] != a1->m128i_i32[v3 - v13] )
return (unsigned int)(result + 1);
}
return result;
}
|
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:
MOVDQU XMM3,xmmword ptr [RDX]
MOVDQU XMM4,xmmword ptr [RAX]
ADD RAX,0x10
SUB RDX,0x10
PSHUFD XMM0,XMM3,0x1b
PCMPEQD XMM0,XMM4
PCMPEQD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RAX,RCX
JNZ 0x00101190
MOVDQA XMM0,XMM1
MOV EDX,R8D
PSRLDQ XMM0,0x8
AND EDX,0xfffffffc
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
TEST R8B,0x3
JZ 0x00101248
LAB_001011e0:
MOV ECX,R9D
MOVSXD RSI,EDX
SUB ECX,EDX
LEA R10,[RSI*0x4]
MOVSXD RCX,ECX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP dword ptr [RDI + RSI*0x4],ECX
JZ 0x001011fe
ADD EAX,0x1
LAB_001011fe:
LEA ESI,[RDX + 0x1]
CMP R8D,ESI
JLE 0x00101242
MOV ECX,R9D
SUB ECX,ESI
MOV ESI,dword ptr [RDI + R10*0x1 + 0x4]
MOVSXD RCX,ECX
CMP dword ptr [RDI + RCX*0x4],ESI
JZ 0x0010121b
ADD EAX,0x1
LAB_0010121b:
ADD EDX,0x2
CMP EDX,R8D
JGE 0x00101242
SUB R9D,EDX
MOVSXD R9,R9D
MOV ESI,dword ptr [RDI + R9*0x4]
CMP dword ptr [RDI + R10*0x1 + 0x8],ESI
JZ 0x00101242
ADD EAX,0x1
RET
LAB_00101240:
XOR EAX,EAX
LAB_00101242:
RET
LAB_00101248:
RET
LAB_00101249:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011e0
|
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 (param_2 < 2) {
iVar14 = 0;
}
else {
iVar1 = param_2 + -1;
if (param_2 < 8) {
uVar11 = 0;
iVar14 = 0;
}
else {
iVar14 = 0;
iVar15 = 0;
iVar16 = 0;
iVar17 = 0;
piVar12 = param_1 + (long)param_2 + -4;
piVar10 = param_1;
do {
iVar2 = *piVar12;
piVar3 = piVar12 + 1;
piVar4 = piVar12 + 2;
piVar5 = piVar12 + 3;
iVar6 = *piVar10;
piVar7 = piVar10 + 1;
piVar8 = piVar10 + 2;
piVar9 = piVar10 + 3;
piVar10 = piVar10 + 4;
piVar12 = piVar12 + -4;
iVar14 = iVar14 + (uint)(*piVar5 != iVar6);
iVar15 = iVar15 + (uint)(*piVar4 != *piVar7);
iVar16 = iVar16 + (uint)(*piVar3 != *piVar8);
iVar17 = iVar17 + (uint)(iVar2 != *piVar9);
} while (piVar10 != param_1 + (ulong)(uVar13 >> 2) * 4);
uVar11 = uVar13 & 0xfffffffc;
iVar14 = iVar14 + iVar16 + iVar15 + iVar17;
if ((uVar13 & 3) == 0) {
return iVar14;
}
}
if (param_1[(int)uVar11] != param_1[(int)(iVar1 - uVar11)]) {
iVar14 = iVar14 + 1;
}
if ((int)(uVar11 + 1) < (int)uVar13) {
if (param_1[(int)(iVar1 - (uVar11 + 1))] != param_1[(long)(int)uVar11 + 1]) {
iVar14 = iVar14 + 1;
}
if (((int)(uVar11 + 2) < (int)uVar13) &&
(param_1[(long)(int)uVar11 + 2] != param_1[(int)(iVar1 - (uVar11 + 2))])) {
return iVar14 + 1;
}
}
}
return iVar14;
}
|
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 n1 = 0, n2 = 0;
issame(func0(arr1, n1, arr2, n2), n1, arr2, n2);
char* arr3[] = {"hi", "admin"};
char* arr4[] = {"hi", "hi"};
n1 = 2; n2 = 2;
issame(func0(arr3, n1, arr4, n2), n1, arr4, n2);
char* arr5[] = {"hi", "admin"};
char* arr6[] = {"hi", "hi", "admin", "project"};
n1 = 2; n2 = 4;
issame(func0(arr5, n1, arr6, n2), n1, arr5, n1);
// Other test cases
return 0;
}
|
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(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,%edx
mov -0x8(%rbp),%eax
add %edx,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ba <func0+0x31>
movl $0x0,-0xc(%rbp)
jmp 1225 <func0+0x9c>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,%edx
mov -0x4(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11f8 <func0+0x6f>
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jge 123b <func0+0xb2>
mov -0x18(%rbp),%rax
jmp 124d <func0+0xc4>
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jle 1249 <func0+0xc0>
mov -0x28(%rbp),%rax
jmp 124d <func0+0xc4>
mov -0x18(%rbp),%rax
leaveq
retq
|
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]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov edx, eax
mov eax, [rbp+var_8]
add eax, edx
mov [rbp+var_8], eax
add [rbp+var_C], 1
loc_11E7:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11BA
mov [rbp+var_C], 0
jmp short loc_1225
loc_11F8:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov edx, eax
mov eax, [rbp+var_4]
add eax, edx
mov [rbp+var_4], eax
add [rbp+var_C], 1
loc_1225:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_20]
jl short loc_11F8
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jge short loc_123B
mov rax, [rbp+var_18]
jmp short locret_124D
loc_123B:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jle short loc_1249
mov rax, [rbp+var_28]
jmp short locret_124D
loc_1249:
mov rax, [rbp+var_18]
locret_124D:
leave
retn
|
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 )
v10 += strlen(*(const char **)(8LL * j + a3));
if ( v9 < v10 )
return a1;
if ( v9 <= v10 )
return a1;
return a3;
}
|
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 [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_001011e7:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ba
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101225
LAB_001011f8:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_00101225:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011f8
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JGE 0x0010123b
MOV RAX,qword ptr [RBP + -0x18]
JMP 0x0010124d
LAB_0010123b:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JLE 0x00101249
MOV RAX,qword ptr [RBP + -0x28]
JMP 0x0010124d
LAB_00101249:
MOV RAX,qword ptr [RBP + -0x18]
LAB_0010124d:
LEAVE
RET
|
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 + (int)sVar1;
}
for (local_14 = 0; local_14 < param_4; local_14 = local_14 + 1) {
sVar1 = strlen(*(char **)(param_3 + (long)local_14 * 8));
local_c = local_c + (int)sVar1;
}
if ((local_c <= local_10) && (local_c < local_10)) {
param_1 = param_3;
}
return param_1;
}
|
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 n1 = 0, n2 = 0;
issame(func0(arr1, n1, arr2, n2), n1, arr2, n2);
char* arr3[] = {"hi", "admin"};
char* arr4[] = {"hi", "hi"};
n1 = 2; n2 = 2;
issame(func0(arr3, n1, arr4, n2), n1, arr4, n2);
char* arr5[] = {"hi", "admin"};
char* arr6[] = {"hi", "hi", "admin", "project"};
n1 = 2; n2 = 4;
issame(func0(arr5, n1, arr6, n2), n1, arr5, n1);
// Other test cases
return 0;
}
|
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 -0x1(%r9,%rcx,1),%r9d
add $0x8,%r8
cmp %rbx,%r8
jne 1179 <func0+0x30>
test %r11d,%r11d
jle 11d4 <func0+0x8b>
mov $0x0,%esi
mov $0x0,%r8d
mov $0xffffffffffffffff,%rbx
mov $0x0,%eax
mov (%rdx,%rsi,8),%rdi
mov %rbx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%r8,%rcx,1),%r8d
add $0x1,%rsi
cmp %esi,%r11d
jg 11ae <func0+0x65>
cmp %r8d,%r9d
cmovle %r10,%rdx
mov %rdx,%rax
pop %rbx
retq
mov $0x0,%r8d
jmp 11c8 <func0+0x7f>
mov $0x0,%r9d
test %ecx,%ecx
jg 1197 <func0+0x4e>
mov %rdi,%rdx
jmp 11cf <func0+0x86>
|
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 ebp, eax
add rbx, 8
cmp rbx, r15
jnz short loc_1197
test r12d, r12d
jle short loc_11E9
loc_11AF:
mov ebx, 0
mov r15d, 0
loc_11BA:
mov rdi, [r13+rbx*8+0]; s
call _strlen
add r15d, eax
add rbx, 1
cmp r12d, ebx
jg short loc_11BA
loc_11D0:
cmp ebp, r15d
mov rax, r13
cmovle rax, r14
loc_11DA:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_11E9:
mov r15d, 0
jmp short loc_11D0
loc_11F1:
mov ebp, 0
test ecx, ecx
jg short loc_11AF
mov rax, rdi
jmp short loc_11DA
|
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(*v6++);
while ( v6 != &a1[a2] );
if ( a4 > 0 )
{
LABEL_5:
v8 = 0LL;
v9 = 0;
do
v9 += strlen(a3[v8++]);
while ( a4 > (int)v8 );
goto LABEL_7;
}
v9 = 0;
LABEL_7:
result = a3;
if ( v7 <= v9 )
return a1;
return result;
}
|
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 R12D,R12D
JLE 0x001011e9
LAB_001011af:
MOV EBX,0x0
MOV R15D,0x0
LAB_001011ba:
MOV RDI,qword ptr [R13 + RBX*0x8]
CALL 0x00101060
ADD R15D,EAX
ADD RBX,0x1
CMP R12D,EBX
JG 0x001011ba
LAB_001011d0:
CMP EBP,R15D
MOV RAX,R13
CMOVLE RAX,R14
LAB_001011da:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001011e9:
MOV R15D,0x0
JMP 0x001011d0
LAB_001011f1:
MOV EBP,0x0
TEST ECX,ECX
JG 0x001011af
MOV RAX,RDI
JMP 0x001011da
|
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 *)*puVar2);
iVar4 = iVar4 + (int)sVar1;
puVar2 = puVar2 + 1;
} while (puVar2 != param_1 + param_2);
if (param_4 < 1) {
iVar5 = 0;
goto LAB_001011d0;
}
}
lVar3 = 0;
iVar5 = 0;
do {
sVar1 = strlen((char *)param_3[lVar3]);
iVar5 = iVar5 + (int)sVar1;
lVar3 = lVar3 + 1;
} while ((int)lVar3 < param_4);
LAB_001011d0:
if (iVar4 <= iVar5) {
param_3 = param_1;
}
return param_3;
}
|
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 n1 = 0, n2 = 0;
issame(func0(arr1, n1, arr2, n2), n1, arr2, n2);
char* arr3[] = {"hi", "admin"};
char* arr4[] = {"hi", "hi"};
n1 = 2; n2 = 2;
issame(func0(arr3, n1, arr4, n2), n1, arr4, n2);
char* arr5[] = {"hi", "admin"};
char* arr6[] = {"hi", "hi", "admin", "project"};
n1 = 2; n2 = 4;
issame(func0(arr5, n1, arr6, n2), n1, arr5, n1);
// Other test cases
return 0;
}
|
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
add $0x8,%rbx
callq 1060 <strlen@plt>
add %eax,%ebp
cmp %rbx,%r15
jne 11b0 <func0+0x30>
test %r12d,%r12d
jle 1210 <func0+0x90>
xor %ebx,%ebx
xor %r15d,%r15d
nopl (%rax)
mov 0x0(%r13,%rbx,8),%rdi
add $0x1,%rbx
callq 1060 <strlen@plt>
add %eax,%r15d
cmp %ebx,%r12d
jg 11d0 <func0+0x50>
cmp %r15d,%ebp
mov %r13,%rax
cmovle %r14,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %ebp,%ebp
test %ecx,%ecx
jg 11c8 <func0+0x48>
mov %rdi,%rax
jmp 11f0 <func0+0x70>
nopl 0x0(%rax,%rax,1)
xor %r15d,%r15d
jmp 11e6 <func0+0x66>
data16 nopw %cs:0x0(%rax,%rax,1)
|
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 rdi, [rbx]; s
add rbx, 8
call _strlen
add ebp, eax
cmp r15, rbx
jnz short loc_11B0
test r13d, r13d
jle short loc_1210
loc_11C8:
xor ebx, ebx
xor r15d, r15d
nop dword ptr [rax]
loc_11D0:
mov rdi, [r12+rbx*8]; s
add rbx, 1
call _strlen
add r15d, eax
cmp r13d, ebx
jg short loc_11D0
loc_11E5:
cmp ebp, r15d
cmovle r12, r14
loc_11EC:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1200:
xor ebp, ebp
test ecx, ecx
jg short loc_11C8
mov r12, rdi
jmp short loc_11EC
loc_1210:
xor r15d, r15d
jmp short loc_11E5
|
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
{
v7 = a1;
v8 = 0;
v9 = &a1[a2];
do
{
v10 = *v7++;
v8 += strlen(v10);
}
while ( v9 != v7 );
if ( a4 <= 0 )
{
v12 = 0;
goto LABEL_7;
}
}
v11 = 0LL;
v12 = 0;
do
{
v13 = *(const char **)(a3 + 8 * v11++);
v12 += strlen(v13);
}
while ( a4 > (int)v11 );
LABEL_7:
if ( v8 <= v12 )
return a1;
return (const char **)a3;
}
|
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 R15,RBX
JNZ 0x001011b0
TEST R13D,R13D
JLE 0x00101210
LAB_001011c8:
XOR EBX,EBX
XOR R15D,R15D
NOP dword ptr [RAX]
LAB_001011d0:
MOV RDI,qword ptr [R12 + RBX*0x8]
ADD RBX,0x1
CALL 0x00101060
ADD R15D,EAX
CMP R13D,EBX
JG 0x001011d0
LAB_001011e5:
CMP EBP,R15D
CMOVLE R12,R14
LAB_001011ec:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101200:
XOR EBP,EBP
TEST ECX,ECX
JG 0x001011c8
MOV R12,RDI
JMP 0x001011ec
LAB_00101210:
XOR R15D,R15D
JMP 0x001011e5
|
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 *)*puVar2;
puVar2 = puVar2 + 1;
sVar1 = strlen(__s);
iVar4 = iVar4 + (int)sVar1;
} while (param_1 + param_2 != puVar2);
if (param_4 < 1) {
iVar5 = 0;
goto LAB_001011e5;
}
}
lVar3 = 0;
iVar5 = 0;
do {
puVar2 = param_3 + lVar3;
lVar3 = lVar3 + 1;
sVar1 = strlen((char *)*puVar2);
iVar5 = iVar5 + (int)sVar1;
} while ((int)lVar3 < param_4);
LAB_001011e5:
if (iVar4 <= iVar5) {
param_3 = param_1;
}
return param_3;
}
|
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 n1 = 0, n2 = 0;
issame(func0(arr1, n1, arr2, n2), n1, arr2, n2);
char* arr3[] = {"hi", "admin"};
char* arr4[] = {"hi", "hi"};
n1 = 2; n2 = 2;
issame(func0(arr3, n1, arr4, n2), n1, arr4, n2);
char* arr5[] = {"hi", "admin"};
char* arr6[] = {"hi", "hi", "admin", "project"};
n1 = 2; n2 = 4;
issame(func0(arr5, n1, arr6, n2), n1, arr5, n1);
// Other test cases
return 0;
}
|
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
add $0x8,%rbx
callq 1060 <strlen@plt>
add %eax,%ebp
cmp %rbx,%r15
jne 11b0 <func0+0x30>
test %r12d,%r12d
jle 1210 <func0+0x90>
xor %ebx,%ebx
xor %r15d,%r15d
nopl (%rax)
mov 0x0(%r13,%rbx,8),%rdi
add $0x1,%rbx
callq 1060 <strlen@plt>
add %eax,%r15d
cmp %ebx,%r12d
jg 11d0 <func0+0x50>
cmp %r15d,%ebp
mov %r13,%rax
cmovle %r14,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %ebp,%ebp
test %ecx,%ecx
jg 11c8 <func0+0x48>
mov %rdi,%rax
jmp 11f0 <func0+0x70>
nopl 0x0(%rax,%rax,1)
xor %r15d,%r15d
jmp 11e6 <func0+0x66>
data16 nopw %cs:0x0(%rax,%rax,1)
|
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 rdi, [rbx]; s
add rbx, 8
call _strlen
add ebp, eax
cmp r15, rbx
jnz short loc_11B0
test r13d, r13d
jle short loc_1210
loc_11C8:
xor ebx, ebx
xor r15d, r15d
nop dword ptr [rax]
loc_11D0:
mov rdi, [r12+rbx*8]; s
add rbx, 1
call _strlen
add r15d, eax
cmp r13d, ebx
jg short loc_11D0
loc_11E5:
cmp ebp, r15d
cmovle r12, r14
loc_11EC:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1200:
xor ebp, ebp
test ecx, ecx
jg short loc_11C8
mov r12, rdi
jmp short loc_11EC
loc_1210:
xor r15d, r15d
jmp short loc_11E5
|
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
{
v7 = a1;
v8 = 0;
v9 = &a1[a2];
do
{
v10 = *v7++;
v8 += strlen(v10);
}
while ( v9 != v7 );
if ( a4 <= 0 )
{
v12 = 0;
goto LABEL_7;
}
}
v11 = 0LL;
v12 = 0;
do
{
v13 = *(const char **)(a3 + 8 * v11++);
v12 += strlen(v13);
}
while ( a4 > (int)v11 );
LABEL_7:
if ( v8 <= v12 )
return a1;
return (const char **)a3;
}
|
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 R15,RBX
JNZ 0x001011b0
TEST R13D,R13D
JLE 0x00101210
LAB_001011c8:
XOR EBX,EBX
XOR R15D,R15D
NOP dword ptr [RAX]
LAB_001011d0:
MOV RDI,qword ptr [R12 + RBX*0x8]
ADD RBX,0x1
CALL 0x00101060
ADD R15D,EAX
CMP R13D,EBX
JG 0x001011d0
LAB_001011e5:
CMP EBP,R15D
CMOVLE R12,R14
LAB_001011ec:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101200:
XOR EBP,EBP
TEST ECX,ECX
JG 0x001011c8
MOV R12,RDI
JMP 0x001011ec
LAB_00101210:
XOR R15D,R15D
JMP 0x001011e5
|
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 *)*puVar2;
puVar2 = puVar2 + 1;
sVar1 = strlen(__s);
iVar4 = iVar4 + (int)sVar1;
} while (param_1 + param_2 != puVar2);
if (param_4 < 1) {
iVar5 = 0;
goto LAB_001011e5;
}
}
lVar3 = 0;
iVar5 = 0;
do {
puVar2 = param_3 + lVar3;
lVar3 = lVar3 + 1;
sVar1 = strlen((char *)*puVar2);
iVar5 = iVar5 + (int)sVar1;
} while ((int)lVar3 < param_4);
LAB_001011e5:
if (iVar4 <= iVar5) {
param_3 = param_1;
}
return param_3;
}
|
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(func0(9 * 9 * 9) == 0);
assert(func0(11 * 9 * 9) == 0);
assert(func0(11 * 13 * 7) == 1);
printf("All tests passed!\n");
return 0;
}
|
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(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
je 1191 <func0+0x28>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 119f <func0+0x36>
cmpl $0x1,-0x14(%rbp)
jle 11c5 <func0+0x5c>
addl $0x1,-0x8(%rbp)
cmpl $0x3,-0x8(%rbp)
sete %al
movzbl %al,%eax
pop %rbp
retq
|
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
add [rbp+var_8], 1
loc_119F:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jz short loc_1191
add [rbp+var_4], 1
loc_11B0:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_119F
cmp [rbp+var_14], 1
jle short loc_11C5
add [rbp+var_8], 1
loc_11C5:
cmp [rbp+var_8], 3
setz al
movzx eax, al
loc_11CF:
pop rbp
retn
|
_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 ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_0010119f:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x00101191
ADD dword ptr [RBP + -0x4],0x1
LAB_001011b0:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x0010119f
CMP dword ptr [RBP + -0x14],0x1
JLE 0x001011c5
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c5:
CMP dword ptr [RBP + -0x8],0x3
SETZ AL
MOVZX EAX,AL
LAB_001011cf:
POP RBP
RET
|
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 = local_1c / local_c) {
local_10 = local_10 + 1;
}
}
if (1 < local_1c) {
local_10 = local_10 + 1;
}
bVar1 = local_10 == 3;
}
return bVar1;
}
|
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(func0(9 * 9 * 9) == 0);
assert(func0(11 * 9 * 9) == 0);
assert(func0(11 * 13 * 7) == 1);
printf("All tests passed!\n");
return 0;
}
|
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
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 11b0 <func0+0x47>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1188 <func0+0x1f>
jmp 1199 <func0+0x30>
cmp $0x1,%edi
jle 11b8 <func0+0x4f>
add $0x1,%esi
cmp $0x3,%esi
sete %al
movzbl %al,%eax
retq
|
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
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_11B0
loc_11A5:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1188
jmp short loc_1199
loc_11B0:
cmp edi, 1
jle short loc_11B8
loc_11B5:
add esi, 1
loc_11B8:
cmp esi, 3
setz al
movzx eax, al
locret_11C1:
retn
|
_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:
++v3;
return v3 == 3;
}
return result;
}
|
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,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101188
JMP 0x00101199
LAB_001011b0:
CMP EDI,0x1
JLE 0x001011b8
LAB_001011b5:
ADD ESI,0x1
LAB_001011b8:
CMP ESI,0x3
SETZ AL
MOVZX EAX,AL
LAB_001011c1:
RET
|
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);
iVar4 = iVar4 + 1;
iVar3 = (int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
if (param_1 < 2) goto LAB_001011b8;
}
iVar4 = iVar4 + 1;
LAB_001011b8:
return iVar4 == 3;
}
|
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(func0(9 * 9 * 9) == 0);
assert(func0(11 * 9 * 9) == 0);
assert(func0(11 * 13 * 7) == 1);
printf("All tests passed!\n");
return 0;
}
|
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
test edx, edx
jz short loc_13A0
loc_13B1:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1390
loc_13BD:
xor eax, eax
cmp edi, 1
setnle al
add esi, eax
xor eax, eax
cmp esi, 3
setz al
retn
|
_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) % v2) );
}
++v2;
}
while ( v2 * v2 <= a1 );
}
return (a1 > 1) + v1 == 3;
}
|
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 EAX,ECX
CMP EAX,EDI
JLE 0x00101390
LAB_001013bd:
XOR EAX,EAX
CMP EDI,0x1
SETG AL
ADD ESI,EAX
XOR EAX,EAX
CMP ESI,0x3
SETZ AL
RET
|
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);
iVar3 = (int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
}
return iVar4 + (uint)(1 < param_1) == 3;
}
|
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(func0(9 * 9 * 9) == 0);
assert(func0(11 * 9 * 9) == 0);
assert(func0(11 * 13 * 7) == 1);
printf("All tests passed!\n");
return 0;
}
|
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
cltd
mov %eax,%edi
idiv %ecx
test %edx,%edx
je 1400 <func0+0x30>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %eax,%edi
jge 13f0 <func0+0x20>
cmp $0x1,%edi
jle 142b <func0+0x5b>
xor %eax,%eax
cmp $0x2,%esi
sete %al
retq
xor %eax,%eax
cmp $0x3,%esi
sete %al
retq
retq
nopw %cs:0x0(%rax,%rax,1)
|
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
test edx, edx
jz short loc_13A0
loc_13B1:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1390
loc_13BD:
xor eax, eax
cmp edi, 1
setnle al
add esi, eax
xor eax, eax
cmp esi, 3
setz al
retn
|
_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) % v2) );
}
++v2;
}
while ( v2 * v2 <= a1 );
}
return (a1 > 1) + v1 == 3;
}
|
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 EAX,ECX
CMP EAX,EDI
JLE 0x00101390
LAB_001013bd:
XOR EAX,EAX
CMP EDI,0x1
SETG AL
ADD ESI,EAX
XOR EAX,EAX
CMP ESI,0x3
SETZ AL
RET
|
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);
iVar3 = (int)((long)((ulong)(uint)(param_1 >> 0x1f) << 0x20 |
lVar1 / (long)iVar2 & 0xffffffffU) % (long)iVar2);
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
}
return iVar4 + (uint)(1 < param_1) == 3;
}
|
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);
assert(func0(9, 3) == 1);
assert(func0(16, 4) == 1);
assert(func0(24, 2) == 0);
assert(func0(128, 4) == 0);
assert(func0(12, 6) == 0);
assert(func0(1, 1) == 1);
assert(func0(1, 12) == 1);
return 0;
}
|
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),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 1192 <func0+0x49>
cmpl $0x63,-0x4(%rbp)
jle 1167 <func0+0x1e>
mov $0x0,%eax
pop %rbp
retq
|
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]
imul eax, [rbp+var_18]
mov [rbp+var_8], eax
add [rbp+var_4], 1
loc_1184:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jg short loc_1192
cmp [rbp+var_4], 63h ; 'c'
jle short loc_1167
loc_1192:
mov eax, 0
loc_1197:
pop rbp
retn
|
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,dword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101184:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JG 0x00101192
CMP dword ptr [RBP + -0x4],0x63
JLE 0x00101167
LAB_00101192:
MOV EAX,0x0
LAB_00101197:
POP RBP
RET
|
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);
assert(func0(9, 3) == 1);
assert(func0(16, 4) == 1);
assert(func0(24, 2) == 0);
assert(func0(128, 4) == 0);
assert(func0(12, 6) == 0);
assert(func0(1, 1) == 1);
assert(func0(1, 12) == 1);
return 0;
}
|
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 $0x0,%eax
retq
mov $0x0,%eax
retq
mov %edi,%eax
retq
|
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:
mov eax, 0
retn
loc_117F:
mov eax, 0
retn
loc_1185:
mov eax, edi
retn
|
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) {
return 1;
}
}
return 0;
}
return 1;
}
|
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);
assert(func0(9, 3) == 1);
assert(func0(16, 4) == 1);
assert(func0(24, 2) == 0);
assert(func0(128, 4) == 0);
assert(func0(12, 6) == 0);
assert(func0(1, 1) == 1);
assert(func0(1, 12) == 1);
return 0;
}
|
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 $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
|
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
loc_125B:
mov eax, 1
retn
loc_1268:
xor eax, eax
retn
|
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;
}
} while (param_1 != iVar1);
}
return 1;
}
|
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);
assert(func0(9, 3) == 1);
assert(func0(16, 4) == 1);
assert(func0(24, 2) == 0);
assert(func0(128, 4) == 0);
assert(func0(12, 6) == 0);
assert(func0(1, 1) == 1);
assert(func0(1, 12) == 1);
return 0;
}
|
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 $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
|
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
loc_121B:
mov eax, 1
retn
loc_1228:
xor eax, eax
retn
|
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;
}
} while (param_1 != iVar1);
}
return 1;
}
|
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+0x36>
mov $0x1,%eax
jmp 11c3 <func0+0x5a>
addl $0x1,-0x4(%rbp)
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
jle 117d <func0+0x14>
mov $0x0,%eax
pop %rbp
retq
|
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_119E
mov eax, 1
jmp short loc_11C1
loc_119E:
add [rbp+var_4], 1
loc_11A2:
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
jle short loc_117D
mov eax, 0
loc_11C1:
pop rbp
retn
|
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,0x1
JMP 0x001011c1
LAB_0010119e:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a2:
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
JLE 0x0010117d
MOV EAX,0x0
LAB_001011c1:
POP RBP
RET
|
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 (local_c * local_c * local_c == iVar1) break;
local_c = local_c + 1;
}
return 1;
}
|
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 <func0+0x1d>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
mov $0x1,%eax
retq
|
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 eax, 1
retn
|
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 != iVar2);
return 1;
}
return 1;
}
|
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
jle 12b0 <func0+0x20>
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
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:
mov eax, 1
retn
|
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 != iVar2);
}
return 1;
}
|
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
jle 12b0 <func0+0x20>
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
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:
mov eax, 1
retn
|
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 != iVar2);
}
return 1;
}
|
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
movsbl %al,%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
je 11df <func0+0x56>
addl $0x1,-0x20(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
cmp %rax,%rbx
jb 11b5 <func0+0x2c>
mov -0x20(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
|
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
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+s]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jz short loc_11DF
add [rbp+var_20], 1
loc_11DF:
add [rbp+var_1C], 1
loc_11E3:
mov eax, [rbp+var_1C]
movsxd rbx, eax
mov rax, [rbp+var_28]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_11B5
mov eax, [rbp+var_20]
mov rbx, [rbp+var_8]
leave
retn
|
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,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101080
TEST RAX,RAX
JZ 0x001011df
ADD dword ptr [RBP + -0x20],0x1
LAB_001011df:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001011e3:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
CMP RBX,RAX
JC 0x001011b5
MOV EAX,dword ptr [RBP + -0x20]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
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_28 = local_28 + 1;
}
local_24 = local_24 + 1;
}
return local_28;
}
|
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 (%rbx),%esi
mov %r13,%rdi
callq 1060 <strchr@plt>
cmp $0x1,%rax
sbb $0xffffffff,%ebp
add $0x1,%rbx
jmp 119f <func0+0x36>
mov %ebp,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
|
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, 0FFFFFFFFh
add rbx, 1
loc_11C9:
cmp rbx, r12
jnz short loc_11B3
mov eax, ebp
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
|
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
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
|
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);
}
return iVar3;
}
|
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,%rax
sbb $0xffffffff,%r12d
add $0x1,%rbx
cmp %rbp,%rbx
jne 1330 <func0+0x30>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
|
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 _strchr
cmp rax, 1
sbb ebp, 0FFFFFFFFh
add rbx, 1
cmp rbx, r12
jnz short loc_1330
add rsp, 8
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1360:
add rsp, 8
xor ebp, ebp
pop rbx
mov eax, ebp
pop rbp
pop r12
pop r13
retn
|
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
JNZ 0x00101330
ADD RSP,0x8
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101360:
ADD RSP,0x8
XOR EBP,EBP
POP RBX
MOV EAX,EBP
POP RBP
POP R12
POP R13
RET
|
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_1 + 1;
} while (param_1 != pcVar1);
return iVar4;
}
return 0;
}
|
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 $0x1,%rax
sbb $0xffffffff,%r12d
add $0x1,%rbx
cmp %rbp,%rbx
jne 1330 <func0+0x30>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
xor %r12d,%r12d
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
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 _strchr
cmp rax, 1
sbb ebp, 0FFFFFFFFh
add rbx, 1
cmp rbx, r12
jnz short loc_1330
add rsp, 8
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1360:
add rsp, 8
xor ebp, ebp
pop rbx
mov eax, ebp
pop rbp
pop r12
pop r13
retn
|
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
JNZ 0x00101330
ADD RSP,0x8
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101360:
ADD RSP,0x8
XOR EBP,EBP
POP RBX
MOV EAX,EBP
POP RBP
POP R12
POP R13
RET
|
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_1 + 1;
} while (param_1 != pcVar1);
return iVar4;
}
return 0;
}
|
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;
}
}
out[index--] = 'b';
out[index--] = 'd';
int start = index + 1;
int len = 62 - start;
char* formatted_out = malloc(len + 3);
if (!formatted_out) {
free(out);
return NULL;
}
strcpy(formatted_out, &out[start]);
strcat(formatted_out, "db");
free(out);
return formatted_out;
}
|
#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);
free(binary);
binary = func0(15);
assert(strcmp(binary, "db1111db") == 0);
free(binary);
return 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 $0x0,(%rax)
cmpl $0x0,-0x24(%rbp)
jne 125e <func0+0x95>
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
movb $0x30,(%rax)
jmp 1264 <func0+0x9b>
mov -0x24(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
lea 0x30(%rax),%ecx
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
mov -0x24(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x24(%rbp)
cmpl $0x0,-0x24(%rbp)
jg 1227 <func0+0x5e>
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
movb $0x62,(%rax)
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
movb $0x64,(%rax)
mov -0x1c(%rbp),%eax
add $0x1,%eax
mov %eax,-0x18(%rbp)
mov $0x3e,%eax
sub -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
add $0x3,%eax
cltq
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 12d2 <func0+0x109>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov $0x0,%eax
jmp 1330 <func0+0x167>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x10(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10a0 <strcpy@plt>
mov -0x8(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movw $0x6264,(%rax)
movb $0x0,0x2(%rax)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x8(%rbp),%rax
leaveq
retq
|
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 ; '?'
mov byte ptr [rax], 0
cmp [rbp+var_24], 0
jnz short loc_1284
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+ptr]
add rax, rdx
mov byte ptr [rax], 30h ; '0'
jmp short loc_128A
loc_1247:
mov edx, [rbp+var_24]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
lea ecx, [rax+30h]
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+ptr]
add rax, rdx
mov edx, ecx
mov [rax], dl
mov eax, [rbp+var_24]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_24], eax
loc_1284:
cmp [rbp+var_24], 0
jg short loc_1247
loc_128A:
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+ptr]
add rax, rdx
mov byte ptr [rax], 62h ; 'b'
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+ptr]
add rax, rdx
mov byte ptr [rax], 64h ; 'd'
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_18], eax
mov eax, 3Eh ; '>'
sub eax, [rbp+var_18]
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
add eax, 3
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
cmp [rbp+dest], 0
jnz short loc_12F8
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov eax, 0
jmp short locret_1343
loc_12F8:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+ptr]
add rdx, rax
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 6264h
mov byte ptr [rax+2], 0
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+dest]
locret_1343:
leave
retn
|
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 )
{
while ( v3 > 0 )
{
v2 = v4--;
ptr[v2] = v3 % 2 + 48;
v3 /= 2;
}
}
else
{
v4 = 61;
ptr[62] = 48;
}
ptr[v4] = 98;
ptr[v4 - 1] = 100;
v5 = v4 - 2 + 1;
dest = (char *)malloc(62 - v5 + 3);
if ( dest )
{
strcpy(dest, &ptr[v5]);
strcpy(&dest[strlen(dest)], "db");
free(ptr);
return dest;
}
else
{
free(ptr);
return 0LL;
}
}
|
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 [RAX],0x0
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00101284
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV byte ptr [RAX],0x30
JMP 0x0010128a
LAB_00101247:
MOV EDX,dword ptr [RBP + -0x24]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
LEA ECX,[RAX + 0x30]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
LAB_00101284:
CMP dword ptr [RBP + -0x24],0x0
JG 0x00101247
LAB_0010128a:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV byte ptr [RAX],0x62
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV byte ptr [RAX],0x64
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,0x3e
SUB EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x3
CDQE
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x001012f8
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,0x0
JMP 0x00101343
LAB_001012f8:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV word ptr [RAX],0x6264
MOV byte ptr [RAX + 0x2],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x8]
LAB_00101343:
LEAVE
RET
|
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;
if (param_1 == 0) {
local_24 = 0x3d;
*(int *)((long)__ptr + 0x3e) = 0x30;
}
else {
for (; 0 < local_2c; local_2c = local_2c / 2) {
cVar1 = (char)(local_2c >> 0x1f);
*(byte *)((long)__ptr + (long)local_24) = ((char)local_2c - cVar1 & 1U) + cVar1 + '0';
local_24 = local_24 + -1;
}
}
*(int *)((long)__ptr + (long)local_24) = 0x62;
*(int *)((long)__ptr + (long)(local_24 + -1)) = 100;
__dest = (char *)malloc((long)(0x41 - (local_24 + -1)));
if (__dest == (char *)0x0) {
free(__ptr);
__dest = (char *)0x0;
}
else {
strcpy(__dest,(char *)((long)(local_24 + -1) + (long)__ptr));
sVar2 = strlen(__dest);
pcVar3 = __dest + sVar2;
pcVar3[0] = 'd';
pcVar3[1] = 'b';
pcVar3[2] = '\0';
free(__ptr);
}
}
return __dest;
}
|
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;
}
}
out[index--] = 'b';
out[index--] = 'd';
int start = index + 1;
int len = 62 - start;
char* formatted_out = malloc(len + 3);
if (!formatted_out) {
free(out);
return NULL;
}
strcpy(formatted_out, &out[start]);
strcat(formatted_out, "db");
free(out);
return formatted_out;
}
|
#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);
free(binary);
binary = func0(15);
assert(strcmp(binary, "db1111db") == 0);
free(binary);
return 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 %ebx,%ecx
shr $0x1f,%ecx
lea (%rbx,%rcx,1),%eax
and $0x1,%eax
sub %ecx,%eax
add $0x30,%eax
mov %al,0x1(%rbp,%rdx,1)
mov %ebx,%eax
add %ecx,%ebx
sar %ebx
sub $0x1,%rdx
cmp $0x1,%eax
jg 11dd <func0+0x34>
jmp 120d <func0+0x64>
movb $0x30,0x3e(%rax)
mov $0x3d,%esi
lea -0x1(%rsi),%eax
movslq %esi,%rsi
movb $0x62,0x0(%rbp,%rsi,1)
movslq %eax,%r12
add %rbp,%r12
movb $0x64,(%r12)
mov $0x41,%edi
sub %eax,%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbx
test %rax,%rax
je 1277 <func0+0xce>
mov %r12,%rsi
mov %rax,%rdi
callq 1090 <strcpy@plt>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rbx,%rcx,1),%rax
movw $0x6264,(%rax)
movb $0x0,0x2(%rax)
mov %rbp,%rdi
callq 1080 <free@plt>
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
retq
mov %rbp,%rdi
callq 1080 <free@plt>
jmp 126f <func0+0xc6>
mov %rax,%rbx
jmp 126f <func0+0xc6>
|
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 loc_125B
loc_1223:
mov ecx, ebx
shr ecx, 1Fh
lea eax, [rbx+rcx]
and eax, 1
sub eax, ecx
add eax, 30h ; '0'
mov [rbp+rdx+1], al
mov ecx, ebx
mov eax, ebx
shr eax, 1Fh
add eax, ebx
sar eax, 1
mov ebx, eax
mov rax, rdx
sub rdx, 1
cmp ecx, 1
jg short loc_1223
jmp short loc_125B
loc_1252:
mov byte ptr [rax+3Eh], 30h ; '0'
mov eax, 3Dh ; '='
loc_125B:
lea edx, [rax-1]
cdqe
mov byte ptr [rbp+rax+0], 62h ; 'b'
movsxd r13, edx
add r13, rbp
mov byte ptr [r13+0], 64h ; 'd'
mov ebx, 41h ; 'A'
sub ebx, edx
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov r12, rax
test rax, rax
jz short loc_12C0
mov rdx, rbx
mov rsi, r13
mov rdi, rax
call ___strcpy_chk
mov rdx, rbx
lea rsi, aDb100000db+8; "db"
mov rdi, r12
call ___strcat_chk
mov rdi, rbp; ptr
call _free
loc_12B2:
mov rax, r12
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12C0:
mov rdi, rbp; ptr
call _free
jmp short loc_12B2
loc_12CA:
mov r12, rax
jmp short loc_12B2
|
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 )
{
v4 = 61LL;
v5 = 62;
if ( a1 > 0 )
{
do
{
v3[v4 + 1] = v1 % 2 + 48;
v6 = v1;
v1 /= 2;
v5 = v4--;
}
while ( v6 > 1 );
}
}
else
{
v2[62] = 48;
v5 = 61;
}
v3[v5] = 98;
v7 = &v3[v5 - 1];
*v7 = 100;
v8 = 65 - (v5 - 1);
v9 = malloc(v8);
v10 = v9;
if ( v9 )
{
__strcpy_chk(v9, v7, v8);
__strcat_chk(v10, "db", v8);
}
free(v3);
return v10;
}
|
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 EAX,ECX
ADD EAX,0x30
MOV byte ptr [RBP + RDX*0x1 + 0x1],AL
MOV ECX,EBX
MOV EAX,EBX
SHR EAX,0x1f
ADD EAX,EBX
SAR EAX,0x1
MOV EBX,EAX
MOV RAX,RDX
SUB RDX,0x1
CMP ECX,0x1
JG 0x00101223
JMP 0x0010125b
LAB_00101252:
MOV byte ptr [RAX + 0x3e],0x30
MOV EAX,0x3d
LAB_0010125b:
LEA EDX,[RAX + -0x1]
CDQE
MOV byte ptr [RBP + RAX*0x1],0x62
MOVSXD R13,EDX
ADD R13,RBP
MOV byte ptr [R13],0x64
MOV EBX,0x41
SUB EBX,EDX
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x001010e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001012c0
MOV RDX,RBX
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RBX
LEA RSI,[0x10202f]
MOV RDI,R12
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010b0
LAB_001012b2:
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012c0:
MOV RDI,RBP
CALL 0x001010b0
JMP 0x001012b2
LAB_001012ca:
MOV R12,RAX
JMP 0x001012b2
|
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) {
*(int *)((long)__ptr + 0x3e) = 0x30;
lVar4 = 0x3d;
}
else {
lVar4 = 0x3e;
lVar3 = 0x3d;
if (0 < param_1) {
do {
lVar4 = lVar3;
cVar2 = (char)(param_1 >> 0x1f);
*(byte *)((long)__ptr + lVar4 + 1) = ((char)param_1 - cVar2 & 1U) + cVar2 + '0';
bVar1 = 1 < param_1;
lVar3 = lVar4 + -1;
param_1 = param_1 / 2;
} while (bVar1);
}
}
iVar6 = (int)lVar4 + -1;
*(int *)((long)__ptr + (long)(int)lVar4) = 0x62;
puVar7 = (int *)((long)iVar6 + (long)__ptr);
*puVar7 = 100;
__size = (size_t)(0x41 - iVar6);
pvVar5 = malloc(__size);
if (pvVar5 == (void *)0x0) {
free(__ptr);
}
else {
__strcpy_chk(pvVar5,puVar7,__size);
__strcat_chk(pvVar5,&DAT_0010202f,__size);
free(__ptr);
}
}
return pvVar5;
}
|
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;
}
}
out[index--] = 'b';
out[index--] = 'd';
int start = index + 1;
int len = 62 - start;
char* formatted_out = malloc(len + 3);
if (!formatted_out) {
free(out);
return NULL;
}
strcpy(formatted_out, &out[start]);
strcat(formatted_out, "db");
free(out);
return formatted_out;
}
|
#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);
free(binary);
binary = func0(15);
assert(strcmp(binary, "db1111db") == 0);
free(binary);
return 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,%r13d
mov $0x3d,%eax
add %rbp,%r13
movb $0x62,0x0(%rbp,%rax,1)
movb $0x64,0x0(%r13)
callq 10b0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1373 <func0+0x73>
mov %r13,%rsi
mov %rax,%rdi
callq 1090 <stpcpy@plt>
mov $0x6264,%edx
mov %dx,(%rax)
movb $0x0,0x2(%rax)
mov %rbp,%rdi
callq 1080 <free@plt>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
mov $0x3d,%eax
jle 13d0 <func0+0xd0>
nopw 0x0(%rax,%rax,1)
mov %ebx,%edx
mov %eax,%ecx
and $0x1,%edx
add $0x30,%edx
mov %dl,0x1(%rbp,%rax,1)
sub $0x1,%rax
sar %ebx
jne 13a0 <func0+0xa0>
movslq %ecx,%rax
mov $0x41,%edi
sub $0x1,%ecx
sub %ecx,%edi
movslq %ecx,%r13
movslq %edi,%rdi
jmpq 1342 <func0+0x42>
xchg %ax,%ax
mov $0x4,%edi
mov $0x3d,%r13d
mov $0x3e,%eax
jmpq 1342 <func0+0x42>
xor %r12d,%r12d
jmp 137b <func0+0x7b>
nopw 0x0(%rax,%rax,1)
|
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 r13d, 3Ch ; '<'
mov eax, 3Dh ; '='
loc_1363:
add r13, rbp
mov byte ptr [rbp+rax+0], 62h ; 'b'
mov rdi, r12; size
mov byte ptr [r13+0], 64h ; 'd'
call _malloc
mov rbx, rax
test rax, rax
jz loc_141E
mov rdx, r12
mov rsi, r13
mov rdi, rax
call ___stpcpy_chk
mov rcx, rbx
mov edx, 3
lea rsi, aDb100000db+8; "db"
sub rcx, rax
mov rdi, rax
add rcx, r12
call ___memcpy_chk
mov rdi, rbp; ptr
call _free
loc_13B7:
add rsp, 8
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13C8:
mov eax, 3Dh ; '='
jle short loc_1408
nop
loc_13D0:
mov edx, ebx
and edx, 1
add edx, 30h ; '0'
mov [rbp+rax+1], dl
mov rdx, rax
sub rax, 1
sar ebx, 1
jnz short loc_13D0
movsxd rax, edx
mov r12d, 41h ; 'A'
sub edx, 1
sub r12d, edx
movsxd r13, edx
movsxd r12, r12d
jmp loc_1363
loc_1408:
mov r12d, 4
mov r13d, 3Dh ; '='
mov eax, 3Eh ; '>'
jmp loc_1363
loc_141E:
mov rdi, rbp; ptr
call _free
loc_1426:
xor ebx, ebx
jmp short loc_13B7
|
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(0x40uLL);
if ( !v2 )
return 0LL;
v2[63] = 0;
v3 = v2;
if ( a1 )
{
v12 = 61LL;
if ( a1 <= 0 )
{
v4 = 4LL;
v5 = 61LL;
v6 = 62LL;
}
else
{
do
{
v3[v12 + 1] = (v1 & 1) + 48;
v13 = v12--;
v1 >>= 1;
}
while ( v1 );
v6 = v13;
v14 = v13 - 1;
v5 = v14;
v4 = 65 - v14;
}
}
else
{
v2[62] = 48;
v4 = 5LL;
v5 = 60LL;
v6 = 61LL;
}
v7 = &v3[v5];
v3[v6] = 98;
*v7 = 100;
v8 = (char *)malloc(v4);
v9 = v8;
if ( !v8 )
{
free(v3);
return 0LL;
}
v10 = __stpcpy_chk(v8, v7, v4);
__memcpy_chk(v10, "db", 3LL, &v9[v4 - v10]);
free(v3);
return v9;
}
|
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 + RAX*0x1],0x62
MOV RDI,R12
MOV byte ptr [R13],0x64
CALL 0x001010f0
MOV RBX,RAX
TEST RAX,RAX
JZ 0x0010141e
MOV RDX,R12
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010e0
MOV RCX,RBX
MOV EDX,0x3
LEA RSI,[0x10202f]
SUB RCX,RAX
MOV RDI,RAX
ADD RCX,R12
CALL 0x001010d0
MOV RDI,RBP
CALL 0x001010a0
LAB_001013b7:
ADD RSP,0x8
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013c8:
MOV EAX,0x3d
JLE 0x00101408
NOP
LAB_001013d0:
MOV EDX,EBX
AND EDX,0x1
ADD EDX,0x30
MOV byte ptr [RBP + RAX*0x1 + 0x1],DL
MOV RDX,RAX
SUB RAX,0x1
SAR EBX,0x1
JNZ 0x001013d0
MOVSXD RAX,EDX
MOV R12D,0x41
SUB EDX,0x1
SUB R12D,EDX
MOVSXD R13,EDX
MOVSXD R12,R12D
JMP 0x00101363
LAB_00101408:
MOV R12D,0x4
MOV R13D,0x3d
MOV EAX,0x3e
JMP 0x00101363
LAB_0010141e:
MOV RDI,RBP
CALL 0x001010a0
LAB_00101426:
XOR EBX,EBX
JMP 0x001013b7
|
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;
lVar1 = 0x3d;
}
else {
lVar1 = 0x3d;
if (param_1 < 1) {
__size = 4;
lVar4 = 0x3d;
lVar1 = 0x3e;
}
else {
do {
lVar4 = lVar1;
*(byte *)((long)__ptr + lVar4 + 1) = ((byte)param_1 & 1) + 0x30;
param_1 = param_1 >> 1;
lVar1 = lVar4 + -1;
} while (param_1 != 0);
lVar1 = (long)(int)lVar4;
iVar3 = (int)lVar4 + -1;
lVar4 = (long)iVar3;
__size = (size_t)(0x41 - iVar3);
}
}
*(int *)((long)__ptr + lVar1) = 0x62;
*(int *)(lVar4 + (long)__ptr) = 100;
pvVar2 = malloc(__size);
if (pvVar2 != (void *)0x0) {
lVar1 = __stpcpy_chk(pvVar2,(int *)(lVar4 + (long)__ptr),__size);
__memcpy_chk(lVar1,&DAT_0010202f,3,(long)pvVar2 + (__size - lVar1));
free(__ptr);
return pvVar2;
}
free(__ptr);
}
return (void *)0x0;
}
|
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;
}
}
out[index--] = 'b';
out[index--] = 'd';
int start = index + 1;
int len = 62 - start;
char* formatted_out = malloc(len + 3);
if (!formatted_out) {
free(out);
return NULL;
}
strcpy(formatted_out, &out[start]);
strcat(formatted_out, "db");
free(out);
return formatted_out;
}
|
#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);
free(binary);
binary = func0(15);
assert(strcmp(binary, "db1111db") == 0);
free(binary);
return 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,%r13d
mov $0x3d,%eax
add %rbp,%r13
movb $0x62,0x0(%rbp,%rax,1)
movb $0x64,0x0(%r13)
callq 10b0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1373 <func0+0x73>
mov %r13,%rsi
mov %rax,%rdi
callq 1090 <stpcpy@plt>
mov $0x6264,%edx
mov %dx,(%rax)
movb $0x0,0x2(%rax)
mov %rbp,%rdi
callq 1080 <free@plt>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
mov $0x3d,%eax
jle 13d0 <func0+0xd0>
nopw 0x0(%rax,%rax,1)
mov %ebx,%edx
mov %eax,%ecx
and $0x1,%edx
add $0x30,%edx
mov %dl,0x1(%rbp,%rax,1)
sub $0x1,%rax
sar %ebx
jne 13a0 <func0+0xa0>
movslq %ecx,%rax
mov $0x41,%edi
sub $0x1,%ecx
sub %ecx,%edi
movslq %ecx,%r13
movslq %edi,%rdi
jmpq 1342 <func0+0x42>
xchg %ax,%ax
mov $0x4,%edi
mov $0x3d,%r13d
mov $0x3e,%eax
jmpq 1342 <func0+0x42>
xor %r12d,%r12d
jmp 137b <func0+0x7b>
nopw 0x0(%rax,%rax,1)
|
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 r13d, 3Ch ; '<'
mov eax, 3Dh ; '='
loc_1363:
add r13, rbp
mov byte ptr [rbp+rax+0], 62h ; 'b'
mov rdi, r12; size
mov byte ptr [r13+0], 64h ; 'd'
call _malloc
mov rbx, rax
test rax, rax
jz loc_141E
mov rdx, r12
mov rsi, r13
mov rdi, rax
call ___stpcpy_chk
mov rcx, rbx
mov edx, 3
lea rsi, aDb100000db+8; "db"
sub rcx, rax
mov rdi, rax
add rcx, r12
call ___memcpy_chk
mov rdi, rbp; ptr
call _free
loc_13B7:
add rsp, 8
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13C8:
mov eax, 3Dh ; '='
jle short loc_1408
nop
loc_13D0:
mov edx, ebx
and edx, 1
add edx, 30h ; '0'
mov [rbp+rax+1], dl
mov rdx, rax
sub rax, 1
sar ebx, 1
jnz short loc_13D0
movsxd rax, edx
mov r12d, 41h ; 'A'
sub edx, 1
sub r12d, edx
movsxd r13, edx
movsxd r12, r12d
jmp loc_1363
loc_1408:
mov r12d, 4
mov r13d, 3Dh ; '='
mov eax, 3Eh ; '>'
jmp loc_1363
loc_141E:
mov rdi, rbp; ptr
call _free
loc_1426:
xor ebx, ebx
jmp short loc_13B7
|
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(0x40uLL);
if ( !v2 )
return 0LL;
v2[63] = 0;
v3 = v2;
if ( a1 )
{
v12 = 61LL;
if ( a1 <= 0 )
{
v4 = 4LL;
v5 = 61LL;
v6 = 62LL;
}
else
{
do
{
v3[v12 + 1] = (v1 & 1) + 48;
v13 = v12--;
v1 >>= 1;
}
while ( v1 );
v6 = v13;
v14 = v13 - 1;
v5 = v14;
v4 = 65 - v14;
}
}
else
{
v2[62] = 48;
v4 = 5LL;
v5 = 60LL;
v6 = 61LL;
}
v7 = &v3[v5];
v3[v6] = 98;
*v7 = 100;
v8 = (char *)malloc(v4);
v9 = v8;
if ( !v8 )
{
free(v3);
return 0LL;
}
v10 = __stpcpy_chk(v8, v7, v4);
__memcpy_chk(v10, "db", 3LL, &v9[v4 - v10]);
free(v3);
return v9;
}
|
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 + RAX*0x1],0x62
MOV RDI,R12
MOV byte ptr [R13],0x64
CALL 0x001010f0
MOV RBX,RAX
TEST RAX,RAX
JZ 0x0010141e
MOV RDX,R12
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010e0
MOV RCX,RBX
MOV EDX,0x3
LEA RSI,[0x10202f]
SUB RCX,RAX
MOV RDI,RAX
ADD RCX,R12
CALL 0x001010d0
MOV RDI,RBP
CALL 0x001010a0
LAB_001013b7:
ADD RSP,0x8
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013c8:
MOV EAX,0x3d
JLE 0x00101408
NOP
LAB_001013d0:
MOV EDX,EBX
AND EDX,0x1
ADD EDX,0x30
MOV byte ptr [RBP + RAX*0x1 + 0x1],DL
MOV RDX,RAX
SUB RAX,0x1
SAR EBX,0x1
JNZ 0x001013d0
MOVSXD RAX,EDX
MOV R12D,0x41
SUB EDX,0x1
SUB R12D,EDX
MOVSXD R13,EDX
MOVSXD R12,R12D
JMP 0x00101363
LAB_00101408:
MOV R12D,0x4
MOV R13D,0x3d
MOV EAX,0x3e
JMP 0x00101363
LAB_0010141e:
MOV RDI,RBP
CALL 0x001010a0
LAB_00101426:
XOR EBX,EBX
JMP 0x001013b7
|
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;
lVar1 = 0x3d;
}
else {
lVar1 = 0x3d;
if (param_1 < 1) {
__size = 4;
lVar4 = 0x3d;
lVar1 = 0x3e;
}
else {
do {
lVar4 = lVar1;
*(byte *)((long)__ptr + lVar4 + 1) = ((byte)param_1 & 1) + 0x30;
param_1 = param_1 >> 1;
lVar1 = lVar4 + -1;
} while (param_1 != 0);
lVar1 = (long)(int)lVar4;
iVar3 = (int)lVar4 + -1;
lVar4 = (long)iVar3;
__size = (size_t)(0x41 - iVar3);
}
}
*(int *)((long)__ptr + lVar1) = 0x62;
*(int *)(lVar4 + (long)__ptr) = 100;
pvVar2 = malloc(__size);
if (pvVar2 != (void *)0x0) {
lVar1 = __stpcpy_chk(pvVar2,(int *)(lVar4 + (long)__ptr),__size);
__memcpy_chk(lVar1,&DAT_0010202f,3,(long)pvVar2 + (__size - lVar1));
free(__ptr);
return pvVar2;
}
free(__ptr);
}
return (void *)0x0;
}
|
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);
return 0;
}
|
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
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea -0x1(%rax),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
je 11ea <func0+0x81>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea -0x2(%rax),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 11f1 <func0+0x88>
mov $0x0,%eax
jmp 1211 <func0+0xa8>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 119c <func0+0x33>
mov $0x1,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
|
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]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, [rax-1]
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_11EA
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, [rax-2]
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_11F1
loc_11EA:
mov eax, 0
jmp short loc_1211
loc_11F1:
add [rbp+var_14], 1
loc_11F5:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_119C
mov eax, 1
loc_1211:
mov rbx, [rbp+var_8]
leave
retn
|
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,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x001011ea
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX + -0x2]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001011f1
LAB_001011ea:
MOV EAX,0x0
JMP 0x00101211
LAB_001011f1:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011f5:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x0010119c
MOV EAX,0x1
LAB_00101211:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
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 + -1]) ||
(param_1[local_1c] == param_1[(long)local_1c + -2])) {
return 0;
}
}
uVar2 = 1;
}
return uVar2;
}
|
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);
return 0;
}
|
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 1195 <func0+0x4c>
add $0x1,%rax
cmp %rcx,%rax
jne 1173 <func0+0x2a>
mov $0x1,%eax
retq
mov $0x0,%eax
retq
mov $0x0,%eax
retq
|
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 short loc_1189
mov edx, 1
jmp short loc_11AB
loc_11A6:
mov edx, 0
loc_11AB:
mov eax, edx
pop rbx
retn
loc_11AF:
mov edx, 0
jmp short loc_11AB
|
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] )
return 0;
if ( v5 == *v3 )
break;
if ( ++v3 == (const char *)v4 )
return 1;
}
return 0;
}
return v2;
}
|
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 0x001011ab
LAB_001011a6:
MOV EDX,0x0
LAB_001011ab:
MOV EAX,EDX
POP RBX
RET
LAB_001011af:
MOV EDX,0x0
JMP 0x001011ab
|
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_1 = param_1 + 1;
} while (param_1 != pcVar1);
uVar3 = 1;
}
return uVar3;
}
|
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);
return 0;
}
|
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),%eax
cmp 0x1(%rdi),%al
jne 1330 <func0+0x20>
xor %r8d,%r8d
mov %r8d,%eax
pop %rbx
retq
xchg %ax,%ax
mov $0x1,%r8d
pop %rbx
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
|
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 [rdi+2]
cmp al, [rdi+1]
jnz short loc_1330
loc_1346:
xor edx, edx
loc_1348:
mov eax, edx
pop rbx
retn
loc_1350:
mov edx, 1
pop rbx
mov eax, edx
retn
|
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 )
return 1LL;
}
}
return 0LL;
}
|
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 0x00101330
LAB_00101346:
XOR EDX,EDX
LAB_00101348:
MOV EAX,EDX
POP RBX
RET
LAB_00101350:
MOV EDX,0x1
POP RBX
MOV EAX,EDX
RET
|
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 0;
}
|
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);
return 0;
}
|
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),%eax
cmp 0x1(%rdi),%al
jne 1330 <func0+0x20>
xor %r8d,%r8d
mov %r8d,%eax
pop %rbx
retq
xchg %ax,%ax
mov $0x1,%r8d
pop %rbx
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
|
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 [rdi+2]
cmp al, [rdi+1]
jnz short loc_1330
loc_1346:
xor edx, edx
loc_1348:
mov eax, edx
pop rbx
retn
loc_1350:
mov edx, 1
pop rbx
mov eax, edx
retn
|
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 )
return 1LL;
}
}
return 0LL;
}
|
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 0x00101330
LAB_00101346:
XOR EDX,EDX
LAB_00101348:
MOV EAX,EDX
POP RBX
RET
LAB_00101350:
MOV EDX,0x1
POP RBX
MOV EAX,EDX
RET
|
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 0;
}
|
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] = "B+";
else if (grades[i] > 2.7001) out[i] = "B";
else if (grades[i] > 2.3001) out[i] = "B-";
else if (grades[i] > 2.0001) out[i] = "C+";
else if (grades[i] > 1.7001) out[i] = "C";
else if (grades[i] > 1.3001) out[i] = "C-";
else if (grades[i] > 1.0001) out[i] = "D+";
else if (grades[i] > 0.7001) out[i] = "D";
else if (grades[i] > 0.0001) out[i] = "D-";
else out[i] = "E";
}
return out;
}
|
#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-", "C", "A-"};
char** result1 = func0(grades1, 5);
assert(issame(result1, expected1, 5));
free(result1);
float grades2[] = {1.2};
char* expected2[] = {"D+"};
char** result2 = func0(grades2, 1);
assert(issame(result2, expected2, 1));
free(result2);
float grades3[] = {0.5};
char* expected3[] = {"D-"};
char** result3 = func0(grades3, 1);
assert(issame(result3, expected3, 1));
free(result3);
float grades4[] = {0.0};
char* expected4[] = {"E"};
char** result4 = func0(grades4, 1);
assert(issame(result4, expected4, 1));
free(result4);
float grades5[] = {1, 0.3, 1.5, 2.8, 3.3};
char* expected5[] = {"D", "D-", "C-", "B", "B+"};
char** result5 = func0(grades5, 5);
assert(issame(result5, expected5, 5));
free(result5);
float grades6[] = {0, 0.7};
char* expected6[] = {"E", "D-"};
char** result6 = func0(grades6, 2);
assert(issame(result6, expected6, 2));
free(result6);
return 0;
}
|
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),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xf0f(%rip),%xmm0
jb 1246 <func0+0x7d>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xdca(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xece(%rip),%xmm0
jbe 128f <func0+0xc6>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xd84(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xe8d(%rip),%xmm0
jbe 12d8 <func0+0x10f>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xd3d(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xe4c(%rip),%xmm0
jbe 1321 <func0+0x158>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xcf7(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xe0b(%rip),%xmm0
jbe 136a <func0+0x1a1>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xcb1(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xdca(%rip),%xmm0
jbe 13b3 <func0+0x1ea>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xc6a(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xd89(%rip),%xmm0
jbe 13fc <func0+0x233>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xc24(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xd48(%rip),%xmm0
jbe 1445 <func0+0x27c>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xbde(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xd07(%rip),%xmm0
jbe 148e <func0+0x2c5>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xb97(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xcc6(%rip),%xmm0
jbe 14d7 <func0+0x30e>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xb51(%rip),%rdx
mov %rdx,(%rax)
jmpq 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xc85(%rip),%xmm0
jbe 151d <func0+0x354>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xb0b(%rip),%rdx
mov %rdx,(%rax)
jmp 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
comisd 0xc47(%rip),%xmm0
jbe 1563 <func0+0x39a>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xac7(%rip),%rdx
mov %rdx,(%rax)
jmp 1581 <func0+0x3b8>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0xaaa(%rip),%rdx
mov %rdx,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11fd <func0+0x34>
mov -0x8(%rbp),%rax
leaveq
retq
|
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[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2108
jb short loc_1246
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2008
mov [rax], rdx
jmp loc_1581
loc_1246:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2110
jbe short loc_128F
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_200B
mov [rax], rdx
jmp loc_1581
loc_128F:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2118
jbe short loc_12D8
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_200D
mov [rax], rdx
jmp loc_1581
loc_12D8:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2120
jbe short loc_1321
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2010
mov [rax], rdx
jmp loc_1581
loc_1321:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2128
jbe short loc_136A
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2013
mov [rax], rdx
jmp loc_1581
loc_136A:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2130
jbe short loc_13B3
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2015
mov [rax], rdx
jmp loc_1581
loc_13B3:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2138
jbe short loc_13FC
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2018
mov [rax], rdx
jmp loc_1581
loc_13FC:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2140
jbe short loc_1445
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_201B
mov [rax], rdx
jmp loc_1581
loc_1445:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2148
jbe short loc_148E
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_201D
mov [rax], rdx
jmp loc_1581
loc_148E:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2150
jbe short loc_14D7
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2020
mov [rax], rdx
jmp loc_1581
loc_14D7:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2158
jbe short loc_151D
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2023
mov [rax], rdx
jmp short loc_1581
loc_151D:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
movss xmm0, dword ptr [rax]
cvtss2sd xmm0, xmm0
comisd xmm0, cs:qword_2160
jbe short loc_1563
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2025
mov [rax], rdx
jmp short loc_1581
loc_1563:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
lea rdx, unk_2028
mov [rax], rdx
loc_1581:
add [rbp+var_C], 1
loc_1585:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl loc_11FD
mov rax, [rbp+var_8]
leave
retn
|
_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 )
{
if ( *(float *)(4LL * i + a1) <= 3.0001 )
{
if ( *(float *)(4LL * i + a1) <= 2.7001 )
{
if ( *(float *)(4LL * i + a1) <= 2.3001 )
{
if ( *(float *)(4LL * i + a1) <= 2.0001 )
{
if ( *(float *)(4LL * i + a1) <= 1.7001 )
{
if ( *(float *)(4LL * i + a1) <= 1.3001 )
{
if ( *(float *)(4LL * i + a1) <= 1.0001 )
{
if ( *(float *)(4LL * i + a1) <= 0.7000999999999999 )
{
if ( *(float *)(4LL * i + a1) <= 0.0001 )
v4[i] = &unk_2028;
else
v4[i] = &unk_2025;
}
else
{
v4[i] = &unk_2023;
}
}
else
{
v4[i] = &unk_2020;
}
}
else
{
v4[i] = &unk_201D;
}
}
else
{
v4[i] = &unk_201B;
}
}
else
{
v4[i] = &unk_2018;
}
}
else
{
v4[i] = &unk_2015;
}
}
else
{
v4[i] = &unk_2013;
}
}
else
{
v4[i] = &unk_2010;
}
}
else
{
v4[i] = &unk_200D;
}
}
else
{
v4[i] = &unk_200B;
}
}
else
{
v4[i] = &unk_2008;
}
}
return v4;
}
|
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 RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102108]
JC 0x00101246
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102008]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_00101246:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102110]
JBE 0x0010128f
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x10200b]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_0010128f:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102118]
JBE 0x001012d8
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x10200d]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_001012d8:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102120]
JBE 0x00101321
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102010]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_00101321:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102128]
JBE 0x0010136a
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102013]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_0010136a:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102130]
JBE 0x001013b3
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102015]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_001013b3:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102138]
JBE 0x001013fc
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102018]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_001013fc:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102140]
JBE 0x00101445
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x10201b]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_00101445:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102148]
JBE 0x0010148e
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x10201d]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_0010148e:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102150]
JBE 0x001014d7
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102020]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_001014d7:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102158]
JBE 0x0010151d
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102023]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_0010151d:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
CVTSS2SD XMM0,XMM0
COMISD XMM0,qword ptr [0x00102160]
JBE 0x00101563
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102025]
MOV qword ptr [RAX],RDX
JMP 0x00101581
LAB_00101563:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA RDX,[0x102028]
MOV qword ptr [RAX],RDX
LAB_00101581:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101585:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011fd
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
/* 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_14 * 4) < _DAT_00102108) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102110) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102118) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102120) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102128) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102130) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102138) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102140) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102148) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102150) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102158) {
if ((double)*(float *)(param_1 + (long)local_14 * 4) <= _DAT_00102160) {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102028;
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102025;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102023;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102020;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_0010201d;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_0010201b;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102018;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102015;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102013;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102010;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_0010200d;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_0010200b;
}
}
else {
*(int **)((long)pvVar1 + (long)local_14 * 8) = &DAT_00102008;
}
}
return pvVar1;
}
|
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] = "B+";
else if (grades[i] > 2.7001) out[i] = "B";
else if (grades[i] > 2.3001) out[i] = "B-";
else if (grades[i] > 2.0001) out[i] = "C+";
else if (grades[i] > 1.7001) out[i] = "C";
else if (grades[i] > 1.3001) out[i] = "C-";
else if (grades[i] > 1.0001) out[i] = "D+";
else if (grades[i] > 0.7001) out[i] = "D";
else if (grades[i] > 0.0001) out[i] = "D-";
else out[i] = "E";
}
return out;
}
|
#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-", "C", "A-"};
char** result1 = func0(grades1, 5);
assert(issame(result1, expected1, 5));
free(result1);
float grades2[] = {1.2};
char* expected2[] = {"D+"};
char** result2 = func0(grades2, 1);
assert(issame(result2, expected2, 1));
free(result2);
float grades3[] = {0.5};
char* expected3[] = {"D-"};
char** result3 = func0(grades3, 1);
assert(issame(result3, expected3, 1));
free(result3);
float grades4[] = {0.0};
char* expected4[] = {"E"};
char** result4 = func0(grades4, 1);
assert(issame(result4, expected4, 1));
free(result4);
float grades5[] = {1, 0.3, 1.5, 2.8, 3.3};
char* expected5[] = {"D", "D-", "C-", "B", "B+"};
char** result5 = func0(grades5, 5);
assert(issame(result5, expected5, 5));
free(result5);
float grades6[] = {0, 0.7};
char* expected6[] = {"E", "D-"};
char** result6 = func0(grades6, 2);
assert(issame(result6, expected6, 2));
free(result6);
return 0;
}
|
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+0x66>
comisd %xmm2,%xmm0
jbe 124b <func0+0x82>
lea 0xdec(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
lea 0x1(%rdx),%rcx
cmp %rsi,%rdx
je 134f <func0+0x186>
mov %rcx,%rdx
pxor %xmm0,%xmm0
cvtss2sd (%rbx,%rdx,4),%xmm0
comisd %xmm1,%xmm0
jb 120e <func0+0x45>
lea 0xdbf(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 121f <func0+0x56>
comisd %xmm3,%xmm0
jbe 125e <func0+0x95>
lea 0xdb1(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 121f <func0+0x56>
comisd 0xeda(%rip),%xmm0
jbe 1275 <func0+0xac>
lea 0xd9d(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 121f <func0+0x56>
comisd 0xecb(%rip),%xmm0
jbe 128c <func0+0xc3>
lea 0xd89(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 121f <func0+0x56>
comisd 0xebc(%rip),%xmm0
jbe 12a6 <func0+0xdd>
lea 0xd74(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 121f <func0+0x56>
comisd 0xeaa(%rip),%xmm0
jbe 12c0 <func0+0xf7>
lea 0xd5d(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 121f <func0+0x56>
comisd 0xe98(%rip),%xmm0
jbe 12da <func0+0x111>
lea 0xd46(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 121f <func0+0x56>
comisd 0xe86(%rip),%xmm0
jbe 12f4 <func0+0x12b>
lea 0xd2e(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 121f <func0+0x56>
comisd 0xe74(%rip),%xmm0
jbe 130e <func0+0x145>
lea 0xd17(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 121f <func0+0x56>
comisd 0xe62(%rip),%xmm0
jbe 1328 <func0+0x15f>
lea 0xd00(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 121f <func0+0x56>
movsd 0xe50(%rip),%xmm4
comisd %xmm4,%xmm0
lea 0xce6(%rip),%rcx
lea 0xce2(%rip),%rdi
cmovbe %rdi,%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 121f <func0+0x56>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
|
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
movsd xmm3, cs:qword_2118
lea r9, unk_2009
lea r8, unk_2007
lea rdi, unk_2004
jmp short loc_1247
loc_122D:
comisd xmm0, xmm2
jbe short loc_125A
mov [rdx], r8
loc_1236:
add rcx, 4
add rdx, 8
cmp rdx, rsi
jz loc_134C
loc_1247:
pxor xmm0, xmm0
cvtss2sd xmm0, dword ptr [rcx]
comisd xmm0, xmm1
jb short loc_122D
mov [rdx], rdi
jmp short loc_1236
loc_125A:
comisd xmm0, xmm3
jbe short loc_1265
mov [rdx], r9
jmp short loc_1236
loc_1265:
comisd xmm0, cs:qword_2120
jbe short loc_127B
lea rbx, unk_200C
mov [rdx], rbx
jmp short loc_1236
loc_127B:
comisd xmm0, cs:qword_2128
jbe short loc_1291
lea rbx, unk_200F
mov [rdx], rbx
jmp short loc_1236
loc_1291:
comisd xmm0, cs:qword_2130
jbe short loc_12A7
lea rbx, unk_2011
mov [rdx], rbx
jmp short loc_1236
loc_12A7:
comisd xmm0, cs:qword_2138
jbe short loc_12C0
lea rbx, unk_2014
mov [rdx], rbx
jmp loc_1236
loc_12C0:
comisd xmm0, cs:qword_2140
jbe short loc_12D9
lea rbx, unk_2017
mov [rdx], rbx
jmp loc_1236
loc_12D9:
comisd xmm0, cs:qword_2148
jbe short loc_12F2
lea rbx, unk_2019
mov [rdx], rbx
jmp loc_1236
loc_12F2:
comisd xmm0, cs:qword_2150
jbe short loc_130B
lea rbx, unk_201C
mov [rdx], rbx
jmp loc_1236
loc_130B:
comisd xmm0, cs:qword_2158
jbe short loc_1324
lea rbx, unk_201F
mov [rdx], rbx
jmp loc_1236
loc_1324:
comisd xmm0, cs:qword_2160
jbe short loc_133D
lea rbx, unk_2021
mov [rdx], rbx
jmp loc_1236
loc_133D:
lea rbx, unk_2024
mov [rdx], rbx
jmp loc_1236
loc_134C:
pop rbx
pop rbp
pop r12
retn
|
_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 )
{
if ( v5 <= 3.0001 )
{
if ( v5 <= 2.7001 )
{
if ( v5 <= 2.3001 )
{
if ( v5 <= 2.0001 )
{
if ( v5 <= 1.7001 )
{
if ( v5 <= 1.3001 )
{
if ( v5 <= 1.0001 )
{
if ( v5 <= 0.7000999999999999 )
{
if ( v5 <= 0.0001 )
*v4 = &unk_2024;
else
*v4 = &unk_2021;
}
else
{
*v4 = &unk_201F;
}
}
else
{
*v4 = &unk_201C;
}
}
else
{
*v4 = &unk_2019;
}
}
else
{
*v4 = &unk_2017;
}
}
else
{
*v4 = &unk_2014;
}
}
else
{
*v4 = &unk_2011;
}
}
else
{
*v4 = &unk_200F;
}
}
else
{
*v4 = &unk_200C;
}
}
else
{
*v4 = &unk_2009;
}
}
else
{
*v4 = &unk_2007;
}
}
else
{
*v4 = &unk_2004;
}
++a1;
++v4;
}
while ( v4 != &result[a2] );
}
return result;
}
|
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,[0x102009]
LEA R8,[0x102007]
LEA RDI,[0x102004]
JMP 0x00101247
LAB_0010122d:
COMISD XMM0,XMM2
JBE 0x0010125a
MOV qword ptr [RDX],R8
LAB_00101236:
ADD RCX,0x4
ADD RDX,0x8
CMP RDX,RSI
JZ 0x0010134c
LAB_00101247:
PXOR XMM0,XMM0
CVTSS2SD XMM0,dword ptr [RCX]
COMISD XMM0,XMM1
JC 0x0010122d
MOV qword ptr [RDX],RDI
JMP 0x00101236
LAB_0010125a:
COMISD XMM0,XMM3
JBE 0x00101265
MOV qword ptr [RDX],R9
JMP 0x00101236
LAB_00101265:
COMISD XMM0,qword ptr [0x00102120]
JBE 0x0010127b
LEA RBX,[0x10200c]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_0010127b:
COMISD XMM0,qword ptr [0x00102128]
JBE 0x00101291
LEA RBX,[0x10200f]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_00101291:
COMISD XMM0,qword ptr [0x00102130]
JBE 0x001012a7
LEA RBX,[0x102011]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_001012a7:
COMISD XMM0,qword ptr [0x00102138]
JBE 0x001012c0
LEA RBX,[0x102014]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_001012c0:
COMISD XMM0,qword ptr [0x00102140]
JBE 0x001012d9
LEA RBX,[0x102017]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_001012d9:
COMISD XMM0,qword ptr [0x00102148]
JBE 0x001012f2
LEA RBX,[0x102019]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_001012f2:
COMISD XMM0,qword ptr [0x00102150]
JBE 0x0010130b
LEA RBX,[0x10201c]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_0010130b:
COMISD XMM0,qword ptr [0x00102158]
JBE 0x00101324
LEA RBX,[0x10201f]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_00101324:
COMISD XMM0,qword ptr [0x00102160]
JBE 0x0010133d
LEA RBX,[0x102021]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_0010133d:
LEA RBX,[0x102024]
MOV qword ptr [RDX],RBX
JMP 0x00101236
LAB_0010134c:
POP RBX
POP RBP
POP R12
RET
|
/* 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;
dVar2 = DAT_00102108;
if (0 < param_2) {
puVar1 = puVar5 + param_2;
do {
dVar6 = (double)*param_1;
if (dVar6 < dVar2) {
if (dVar6 <= dVar3) {
if (dVar6 <= dVar4) {
if (dVar6 <= _DAT_00102120) {
if (dVar6 <= _DAT_00102128) {
if (dVar6 <= _DAT_00102130) {
if (dVar6 <= _DAT_00102138) {
if (dVar6 <= _DAT_00102140) {
if (dVar6 <= _DAT_00102148) {
if (dVar6 <= _DAT_00102150) {
if (dVar6 <= _DAT_00102158) {
if (dVar6 <= _DAT_00102160) {
*puVar5 = &DAT_00102024;
}
else {
*puVar5 = &DAT_00102021;
}
}
else {
*puVar5 = &DAT_0010201f;
}
}
else {
*puVar5 = &DAT_0010201c;
}
}
else {
*puVar5 = &DAT_00102019;
}
}
else {
*puVar5 = &DAT_00102017;
}
}
else {
*puVar5 = &DAT_00102014;
}
}
else {
*puVar5 = &DAT_00102011;
}
}
else {
*puVar5 = &DAT_0010200f;
}
}
else {
*puVar5 = &DAT_0010200c;
}
}
else {
*puVar5 = &DAT_00102009;
}
}
else {
*puVar5 = &DAT_00102007;
}
}
else {
*puVar5 = &DAT_00102004;
}
param_1 = param_1 + 1;
puVar5 = puVar5 + 1;
} while (puVar5 != puVar1);
}
return;
}
|
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] = "B+";
else if (grades[i] > 2.7001) out[i] = "B";
else if (grades[i] > 2.3001) out[i] = "B-";
else if (grades[i] > 2.0001) out[i] = "C+";
else if (grades[i] > 1.7001) out[i] = "C";
else if (grades[i] > 1.3001) out[i] = "C-";
else if (grades[i] > 1.0001) out[i] = "D+";
else if (grades[i] > 0.7001) out[i] = "D";
else if (grades[i] > 0.0001) out[i] = "D-";
else out[i] = "E";
}
return out;
}
|
#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-", "C", "A-"};
char** result1 = func0(grades1, 5);
assert(issame(result1, expected1, 5));
free(result1);
float grades2[] = {1.2};
char* expected2[] = {"D+"};
char** result2 = func0(grades2, 1);
assert(issame(result2, expected2, 1));
free(result2);
float grades3[] = {0.5};
char* expected3[] = {"D-"};
char** result3 = func0(grades3, 1);
assert(issame(result3, expected3, 1));
free(result3);
float grades4[] = {0.0};
char* expected4[] = {"E"};
char** result4 = func0(grades4, 1);
assert(issame(result4, expected4, 1));
free(result4);
float grades5[] = {1, 0.3, 1.5, 2.8, 3.3};
char* expected5[] = {"D", "D-", "C-", "B", "B+"};
char** result5 = func0(grades5, 5);
assert(issame(result5, expected5, 5));
free(result5);
float grades6[] = {0, 0.7};
char* expected6[] = {"E", "D-"};
char** result6 = func0(grades6, 2);
assert(issame(result6, expected6, 2));
free(result6);
return 0;
}
|
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 <func0+0x57>
lea 0xa7d(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
lea 0x1(%rdx),%rcx
cmp %rdx,%rsi
je 15c0 <func0+0x80>
mov %rcx,%rdx
pxor %xmm0,%xmm0
cvtss2sd (%rbx,%rdx,4),%xmm0
comisd %xmm1,%xmm0
jae 1580 <func0+0x40>
comisd %xmm2,%xmm0
jbe 15d0 <func0+0x90>
lea 0xa54(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
lea 0x1(%rdx),%rcx
cmp %rdx,%rsi
jne 1594 <func0+0x54>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
comisd %xmm3,%xmm0
jbe 15e8 <func0+0xa8>
lea 0xa2c(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 158b <func0+0x4b>
nopl 0x0(%rax,%rax,1)
comisd 0xb50(%rip),%xmm0
jbe 1600 <func0+0xc0>
lea 0xa13(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 158b <func0+0x4b>
comisd 0xb40(%rip),%xmm0
jbe 1620 <func0+0xe0>
lea 0x9fe(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
nopw 0x0(%rax,%rax,1)
comisd 0xb28(%rip),%xmm0
ja 1648 <func0+0x108>
comisd 0xb26(%rip),%xmm0
jbe 1658 <func0+0x118>
lea 0x9d9(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
nopl 0x0(%rax)
lea 0x9c2(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
comisd 0xb00(%rip),%xmm0
ja 167c <func0+0x13c>
comisd 0xafe(%rip),%xmm0
jbe 168c <func0+0x14c>
lea 0x9a6(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
lea 0x994(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
comisd 0xadc(%rip),%xmm0
jbe 16a6 <func0+0x166>
lea 0x97f(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
comisd 0xaca(%rip),%xmm0
jbe 16c0 <func0+0x180>
lea 0x968(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
movsd 0xab8(%rip),%xmm4
lea 0x952(%rip),%rcx
lea 0x94e(%rip),%rdi
comisd %xmm4,%xmm0
cmovbe %rdi,%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 158b <func0+0x4b>
nopw 0x0(%rax,%rax,1)
|
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 r8, unk_2009
lea r9, unk_200C
nop dword ptr [rax+00000000h]
loc_15B0:
pxor xmm0, xmm0
mov rcx, rsi
cvtss2sd xmm0, dword ptr [rbx+rdx*4]
comisd xmm0, xmm1
jnb short loc_15F8
comisd xmm0, xmm2
mov rcx, rdi
ja short loc_15F8
comisd xmm0, xmm3
mov rcx, r8
ja short loc_15F8
comisd xmm0, cs:qword_2120
mov rcx, r9
ja short loc_15F8
comisd xmm0, cs:qword_2128
lea rcx, unk_200F
jbe short loc_1610
nop word ptr [rax+rax+00h]
loc_15F8:
mov [rax+rdx*8], rcx
add rdx, 1
cmp rbp, rdx
jnz short loc_15B0
loc_1605:
pop rbx
pop rbp
pop r12
retn
loc_1610:
comisd xmm0, cs:qword_2130
lea rcx, unk_2011
ja short loc_15F8
comisd xmm0, cs:qword_2138
lea rcx, unk_2014
ja short loc_15F8
comisd xmm0, cs:qword_2140
lea rcx, unk_2017
ja short loc_15F8
comisd xmm0, cs:qword_2148
lea rcx, unk_2019
ja short loc_15F8
comisd xmm0, cs:qword_2150
lea rcx, unk_201C
ja short loc_15F8
comisd xmm0, cs:qword_2158
lea rcx, unk_201F
ja short loc_15F8
comisd xmm0, cs:qword_2160
lea rcx, unk_2021
lea r10, unk_2024
cmovbe rcx, r10
jmp loc_15F8
|
_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 )
{
v4 = &unk_2007;
if ( v5 <= 3.7001 )
{
v4 = &unk_2009;
if ( v5 <= 3.3001 )
{
v4 = &unk_200C;
if ( v5 <= 3.0001 )
{
v4 = &unk_200F;
if ( v5 <= 2.7001 )
{
v4 = &unk_2011;
if ( v5 <= 2.3001 )
{
v4 = &unk_2014;
if ( v5 <= 2.0001 )
{
v4 = &unk_2017;
if ( v5 <= 1.7001 )
{
v4 = &unk_2019;
if ( v5 <= 1.3001 )
{
v4 = &unk_201C;
if ( v5 <= 1.0001 )
{
v4 = &unk_201F;
if ( v5 <= 0.7000999999999999 )
{
v4 = &unk_2021;
if ( v5 <= 0.0001 )
v4 = &unk_2024;
}
}
}
}
}
}
}
}
}
}
}
}
}
return result;
}
|
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]
NOP dword ptr [RAX]
LAB_001015b0:
PXOR XMM0,XMM0
MOV RCX,RSI
CVTSS2SD XMM0,dword ptr [RBX + RDX*0x4]
COMISD XMM0,XMM1
JNC 0x001015f8
COMISD XMM0,XMM2
MOV RCX,RDI
JA 0x001015f8
COMISD XMM0,XMM3
MOV RCX,R8
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102120]
MOV RCX,R9
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102128]
LEA RCX,[0x10200f]
JBE 0x00101610
NOP word ptr [RAX + RAX*0x1]
LAB_001015f8:
MOV qword ptr [RAX + RDX*0x8],RCX
ADD RDX,0x1
CMP RBP,RDX
JNZ 0x001015b0
LAB_00101605:
POP RBX
POP RBP
POP R12
RET
LAB_00101610:
COMISD XMM0,qword ptr [0x00102130]
LEA RCX,[0x102011]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102138]
LEA RCX,[0x102014]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102140]
LEA RCX,[0x102017]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102148]
LEA RCX,[0x102019]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102150]
LEA RCX,[0x10201c]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102158]
LEA RCX,[0x10201f]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102160]
LEA RCX,[0x102021]
LEA R10,[0x102024]
CMOVBE RCX,R10
JMP 0x001015f8
|
/* 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_00102110;
dVar1 = DAT_00102108;
if (0 < param_2) {
lVar6 = 0;
do {
puVar5 = &DAT_00102004;
dVar7 = (double)*(float *)(param_1 + lVar6 * 4);
if (((((dVar7 < dVar1) && (puVar5 = &DAT_00102007, dVar7 <= dVar2)) &&
(puVar5 = &DAT_00102009, dVar7 <= dVar3)) &&
((((puVar5 = &DAT_0010200c, dVar7 <= _DAT_00102120 &&
(puVar5 = &DAT_0010200f, dVar7 <= _DAT_00102128)) &&
((puVar5 = &DAT_00102011, dVar7 <= _DAT_00102130 &&
((puVar5 = &DAT_00102014, dVar7 <= _DAT_00102138 &&
(puVar5 = &DAT_00102017, dVar7 <= _DAT_00102140)))))) &&
(puVar5 = &DAT_00102019, dVar7 <= _DAT_00102148)))) &&
(((puVar5 = &DAT_0010201c, dVar7 <= _DAT_00102150 &&
(puVar5 = &DAT_0010201f, dVar7 <= _DAT_00102158)) &&
(puVar5 = &DAT_00102021, dVar7 <= _DAT_00102160)))) {
puVar5 = &DAT_00102024;
}
*(int **)((long)pvVar4 + lVar6 * 8) = puVar5;
lVar6 = lVar6 + 1;
} while (param_2 != lVar6);
}
return;
}
|
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] = "B+";
else if (grades[i] > 2.7001) out[i] = "B";
else if (grades[i] > 2.3001) out[i] = "B-";
else if (grades[i] > 2.0001) out[i] = "C+";
else if (grades[i] > 1.7001) out[i] = "C";
else if (grades[i] > 1.3001) out[i] = "C-";
else if (grades[i] > 1.0001) out[i] = "D+";
else if (grades[i] > 0.7001) out[i] = "D";
else if (grades[i] > 0.0001) out[i] = "D-";
else out[i] = "E";
}
return out;
}
|
#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-", "C", "A-"};
char** result1 = func0(grades1, 5);
assert(issame(result1, expected1, 5));
free(result1);
float grades2[] = {1.2};
char* expected2[] = {"D+"};
char** result2 = func0(grades2, 1);
assert(issame(result2, expected2, 1));
free(result2);
float grades3[] = {0.5};
char* expected3[] = {"D-"};
char** result3 = func0(grades3, 1);
assert(issame(result3, expected3, 1));
free(result3);
float grades4[] = {0.0};
char* expected4[] = {"E"};
char** result4 = func0(grades4, 1);
assert(issame(result4, expected4, 1));
free(result4);
float grades5[] = {1, 0.3, 1.5, 2.8, 3.3};
char* expected5[] = {"D", "D-", "C-", "B", "B+"};
char** result5 = func0(grades5, 5);
assert(issame(result5, expected5, 5));
free(result5);
float grades6[] = {0, 0.7};
char* expected6[] = {"E", "D-"};
char** result6 = func0(grades6, 2);
assert(issame(result6, expected6, 2));
free(result6);
return 0;
}
|
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 <func0+0x57>
lea 0xa9d(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
lea 0x1(%rdx),%rcx
cmp %rdx,%rsi
je 15a0 <func0+0x80>
mov %rcx,%rdx
pxor %xmm0,%xmm0
cvtss2sd (%rbx,%rdx,4),%xmm0
comisd %xmm1,%xmm0
jae 1560 <func0+0x40>
comisd %xmm2,%xmm0
jbe 15b0 <func0+0x90>
lea 0xa74(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
lea 0x1(%rdx),%rcx
cmp %rdx,%rsi
jne 1574 <func0+0x54>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
comisd %xmm3,%xmm0
jbe 15c8 <func0+0xa8>
lea 0xa4c(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 156b <func0+0x4b>
nopl 0x0(%rax,%rax,1)
comisd 0xb70(%rip),%xmm0
jbe 15e0 <func0+0xc0>
lea 0xa33(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmp 156b <func0+0x4b>
comisd 0xb60(%rip),%xmm0
jbe 1600 <func0+0xe0>
lea 0xa1e(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
nopw 0x0(%rax,%rax,1)
comisd 0xb48(%rip),%xmm0
ja 1628 <func0+0x108>
comisd 0xb46(%rip),%xmm0
jbe 1638 <func0+0x118>
lea 0x9f9(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
nopl 0x0(%rax)
lea 0x9e2(%rip),%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
comisd 0xb20(%rip),%xmm0
ja 165c <func0+0x13c>
comisd 0xb1e(%rip),%xmm0
jbe 166c <func0+0x14c>
lea 0x9c6(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
lea 0x9b4(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
comisd 0xafc(%rip),%xmm0
jbe 1686 <func0+0x166>
lea 0x99f(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
comisd 0xaea(%rip),%xmm0
jbe 16a0 <func0+0x180>
lea 0x988(%rip),%rdi
mov %rdi,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
movsd 0xad8(%rip),%xmm4
lea 0x972(%rip),%rcx
lea 0x96e(%rip),%rdi
comisd %xmm4,%xmm0
cmovbe %rdi,%rcx
mov %rcx,(%rax,%rdx,8)
jmpq 156b <func0+0x4b>
nopw 0x0(%rax,%rax,1)
|
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 r8, unk_2009
lea r9, unk_200C
nop dword ptr [rax+00000000h]
loc_15B0:
pxor xmm0, xmm0
mov rcx, rsi
cvtss2sd xmm0, dword ptr [rbx+rdx*4]
comisd xmm0, xmm1
jnb short loc_15F8
comisd xmm0, xmm2
mov rcx, rdi
ja short loc_15F8
comisd xmm0, xmm3
mov rcx, r8
ja short loc_15F8
comisd xmm0, cs:qword_2120
mov rcx, r9
ja short loc_15F8
comisd xmm0, cs:qword_2128
lea rcx, unk_200F
jbe short loc_1610
nop word ptr [rax+rax+00h]
loc_15F8:
mov [rax+rdx*8], rcx
add rdx, 1
cmp rbp, rdx
jnz short loc_15B0
loc_1605:
pop rbx
pop rbp
pop r12
retn
loc_1610:
comisd xmm0, cs:qword_2130
lea rcx, unk_2011
ja short loc_15F8
comisd xmm0, cs:qword_2138
lea rcx, unk_2014
ja short loc_15F8
comisd xmm0, cs:qword_2140
lea rcx, unk_2017
ja short loc_15F8
comisd xmm0, cs:qword_2148
lea rcx, unk_2019
ja short loc_15F8
comisd xmm0, cs:qword_2150
lea rcx, unk_201C
ja short loc_15F8
comisd xmm0, cs:qword_2158
lea rcx, unk_201F
ja short loc_15F8
comisd xmm0, cs:qword_2160
lea rcx, unk_2021
lea r10, unk_2024
cmovbe rcx, r10
jmp loc_15F8
|
_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 )
{
v4 = &unk_2007;
if ( v5 <= 3.7001 )
{
v4 = &unk_2009;
if ( v5 <= 3.3001 )
{
v4 = &unk_200C;
if ( v5 <= 3.0001 )
{
v4 = &unk_200F;
if ( v5 <= 2.7001 )
{
v4 = &unk_2011;
if ( v5 <= 2.3001 )
{
v4 = &unk_2014;
if ( v5 <= 2.0001 )
{
v4 = &unk_2017;
if ( v5 <= 1.7001 )
{
v4 = &unk_2019;
if ( v5 <= 1.3001 )
{
v4 = &unk_201C;
if ( v5 <= 1.0001 )
{
v4 = &unk_201F;
if ( v5 <= 0.7000999999999999 )
{
v4 = &unk_2021;
if ( v5 <= 0.0001 )
v4 = &unk_2024;
}
}
}
}
}
}
}
}
}
}
}
}
}
return result;
}
|
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]
NOP dword ptr [RAX]
LAB_001015b0:
PXOR XMM0,XMM0
MOV RCX,RSI
CVTSS2SD XMM0,dword ptr [RBX + RDX*0x4]
COMISD XMM0,XMM1
JNC 0x001015f8
COMISD XMM0,XMM2
MOV RCX,RDI
JA 0x001015f8
COMISD XMM0,XMM3
MOV RCX,R8
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102120]
MOV RCX,R9
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102128]
LEA RCX,[0x10200f]
JBE 0x00101610
NOP word ptr [RAX + RAX*0x1]
LAB_001015f8:
MOV qword ptr [RAX + RDX*0x8],RCX
ADD RDX,0x1
CMP RBP,RDX
JNZ 0x001015b0
LAB_00101605:
POP RBX
POP RBP
POP R12
RET
LAB_00101610:
COMISD XMM0,qword ptr [0x00102130]
LEA RCX,[0x102011]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102138]
LEA RCX,[0x102014]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102140]
LEA RCX,[0x102017]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102148]
LEA RCX,[0x102019]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102150]
LEA RCX,[0x10201c]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102158]
LEA RCX,[0x10201f]
JA 0x001015f8
COMISD XMM0,qword ptr [0x00102160]
LEA RCX,[0x102021]
LEA R10,[0x102024]
CMOVBE RCX,R10
JMP 0x001015f8
|
/* 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_00102110;
dVar1 = DAT_00102108;
if (0 < param_2) {
lVar6 = 0;
do {
puVar5 = &DAT_00102004;
dVar7 = (double)*(float *)(param_1 + lVar6 * 4);
if (((((dVar7 < dVar1) && (puVar5 = &DAT_00102007, dVar7 <= dVar2)) &&
(puVar5 = &DAT_00102009, dVar7 <= dVar3)) &&
((((puVar5 = &DAT_0010200c, dVar7 <= _DAT_00102120 &&
(puVar5 = &DAT_0010200f, dVar7 <= _DAT_00102128)) &&
((puVar5 = &DAT_00102011, dVar7 <= _DAT_00102130 &&
((puVar5 = &DAT_00102014, dVar7 <= _DAT_00102138 &&
(puVar5 = &DAT_00102017, dVar7 <= _DAT_00102140)))))) &&
(puVar5 = &DAT_00102019, dVar7 <= _DAT_00102148)))) &&
(((puVar5 = &DAT_0010201c, dVar7 <= _DAT_00102150 &&
(puVar5 = &DAT_0010201f, dVar7 <= _DAT_00102158)) &&
(puVar5 = &DAT_00102021, dVar7 <= _DAT_00102160)))) {
puVar5 = &DAT_00102024;
}
*(int **)((long)pvVar4 + lVar6 * 8) = puVar5;
lVar6 = lVar6 + 1;
} while (param_2 != lVar6);
}
return;
}
|
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") == true);
assert(func0("") == false);
assert(func0("HI") == true);
assert(func0("go") == true);
assert(func0("gogo") == false);
assert(func0("aaaaaaaaaaaaaaa") == false);
assert(func0("Madam") == true);
assert(func0("M") == false);
assert(func0("0") == false);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jg 1195 <func0+0x2c>
mov $0x0,%eax
jmp 11c6 <func0+0x5d>
movl $0x2,-0x8(%rbp)
jmp 11b6 <func0+0x4d>
mov -0x4(%rbp),%eax
cltd
idivl -0x8(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11b2 <func0+0x49>
mov $0x0,%eax
jmp 11c6 <func0+0x5d>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x4(%rbp)
jge 119e <func0+0x35>
mov $0x1,%eax
leaveq
retq
|
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 eax, [rbp+var_4]
cdq
idiv [rbp+var_8]
mov eax, edx
test eax, eax
jnz short loc_11B2
mov eax, 0
jmp short locret_11C6
loc_11B2:
add [rbp+var_8], 1
loc_11B6:
mov eax, [rbp+var_8]
imul eax, eax
cmp [rbp+var_4], eax
jge short loc_119E
mov eax, 1
locret_11C6:
leave
retn
|
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:
MOV EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x8]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011b2
MOV EAX,0x0
JMP 0x001011c6
LAB_001011b2:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011b6:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x4],EAX
JGE 0x0010119e
MOV EAX,0x1
LAB_001011c6:
LEAVE
RET
|
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;
}
}
uVar3 = 1;
}
return uVar3;
}
|
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") == true);
assert(func0("") == false);
assert(func0("HI") == true);
assert(func0("go") == true);
assert(func0("gogo") == false);
assert(func0("aaaaaaaaaaaaaaa") == false);
assert(func0("Madam") == true);
assert(func0("M") == false);
assert(func0("0") == false);
return 0;
}
|
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 %ecx,%eax
cmp %esi,%eax
jg 1193 <func0+0x4a>
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1178 <func0+0x2f>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
|
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, esi
cdq
idiv ecx
test edx, edx
jnz short loc_1190
mov edx, 0
jmp short loc_11B1
loc_11AC:
mov edx, 1
loc_11B1:
mov eax, edx
add rsp, 8
retn
loc_11B8:
mov edx, 1
jmp short loc_11B1
loc_11BF:
mov edx, 0
jmp short loc_11B1
|
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 )
break;
if ( !(v1 % v3) )
return 0;
}
return 1;
}
else
{
return 0;
}
}
return v2;
}
|
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_001011ac:
MOV EDX,0x1
LAB_001011b1:
MOV EAX,EDX
ADD RSP,0x8
RET
LAB_001011b8:
MOV EDX,0x1
JMP 0x001011b1
LAB_001011bf:
MOV EDX,0x0
JMP 0x001011b1
|
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 {
iVar3 = iVar3 + 1;
if (iVar1 < iVar3 * iVar3) {
return 1;
}
} while ((int)((long)((ulong)(uint)(iVar1 >> 0x1f) << 0x20 | sVar2 & 0xffffffff) % (long)iVar3
) != 0);
uVar4 = 0;
}
}
return uVar4;
}
|
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") == true);
assert(func0("") == false);
assert(func0("HI") == true);
assert(func0("go") == true);
assert(func0("gogo") == false);
assert(func0("aaaaaaaaaaaaaaa") == false);
assert(func0("Madam") == true);
assert(func0("M") == false);
assert(func0("0") == false);
return 0;
}
|
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 %edx,%edx
je 1508 <func0+0x58>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jle 14e0 <func0+0x30>
mov $0x1,%r8d
mov %r8d,%eax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
add $0x8,%rsp
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
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_14E9:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jle short loc_14E0
loc_14F5:
mov edx, 1
loc_14FA:
mov eax, edx
add rsp, 8
retn
loc_1508:
xor edx, edx
add rsp, 8
mov eax, edx
retn
|
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 % v3) )
return 0LL;
}
return 1;
}
return v2;
}
|
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
LAB_001014f5:
MOV EDX,0x1
LAB_001014fa:
MOV EAX,EDX
ADD RSP,0x8
RET
LAB_00101508:
XOR EDX,EDX
ADD RSP,0x8
MOV EAX,EDX
RET
|
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) {
if ((int)((long)((ulong)(uint)(iVar1 >> 0x1f) << 0x20 | sVar2 & 0xffffffff) % (long)iVar3)
== 0) {
return 0;
}
}
}
uVar4 = 1;
}
return uVar4;
}
|
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") == true);
assert(func0("") == false);
assert(func0("HI") == true);
assert(func0("go") == true);
assert(func0("gogo") == false);
assert(func0("aaaaaaaaaaaaaaa") == false);
assert(func0("Madam") == true);
assert(func0("M") == false);
assert(func0("0") == false);
return 0;
}
|
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 %edx,%edx
je 1508 <func0+0x58>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jle 14e0 <func0+0x30>
mov $0x1,%r8d
mov %r8d,%eax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
add $0x8,%rsp
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
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_14E9:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jle short loc_14E0
loc_14F5:
mov edx, 1
loc_14FA:
mov eax, edx
add rsp, 8
retn
loc_1508:
xor edx, edx
add rsp, 8
mov eax, edx
retn
|
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 % v3) )
return 0LL;
}
return 1;
}
return v2;
}
|
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
LAB_001014f5:
MOV EDX,0x1
LAB_001014fa:
MOV EAX,EDX
ADD RSP,0x8
RET
LAB_00101508:
XOR EDX,EDX
ADD RSP,0x8
MOV EAX,EDX
RET
|
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) {
if ((int)((long)((ulong)(uint)(iVar1 >> 0x1f) << 0x20 | sVar2 & 0xffffffff) % (long)iVar3)
== 0) {
return 0;
}
}
}
uVar4 = 1;
}
return uVar4;
}
|
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>
mov -0x8(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 117e <func0+0x35>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
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 short loc_1191
loc_117E:
mov edx, [rbp+var_8]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov [rbp+var_8], eax
add [rbp+var_4], 1
loc_1191:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_14]
jl short loc_117E
mov eax, [rbp+var_8]
loc_119C:
pop rbp
retn
|
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
LAB_0010117e:
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x0010117e
MOV EAX,dword ptr [RBP + -0x8]
LAB_0010119c:
POP RBP
RET
|
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 $0x12,%eax
retq
|
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_1179:
mov eax, 12h
locret_117E:
retn
|
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
{
result = (unsigned int)(10 * result);
++v2;
}
while ( a1 != v2 );
}
}
}
return result;
}
|
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;
}
iVar1 = 0x12;
}
return iVar1;
}
|
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 1168 <func0+0x28>
retq
nopl (%rax)
mov $0x12,%eax
retq
xchg %ax,%ax
|
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 short loc_1168
retn
loc_1178:
mov eax, 12h
locret_117D:
retn
|
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;
result = (unsigned int)(10 * result);
}
while ( a1 != v2 );
}
}
}
return result;
}
|
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 = 0x12;
}
return iVar1;
}
|
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 1168 <func0+0x28>
retq
nopl (%rax)
mov $0x12,%eax
retq
xchg %ax,%ax
|
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 short loc_1168
retn
loc_1178:
mov eax, 12h
locret_117D:
retn
|
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;
result = (unsigned int)(10 * result);
}
while ( a1 != v2 );
}
}
}
return result;
}
|
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 = 0x12;
}
return iVar1;
}
|
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) + '0';
sum /= 2;
}
}
bi[index] = '\0';
for (int i = 0; i < index / 2; i++) {
char temp = bi[i];
bi[i] = bi[index - i - 1];
bi[index - i - 1] = temp;
}
return bi;
}
|
#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(result);
result = func0(333);
assert(strcmp(result, "1001") == 0);
free(result);
result = func0(963);
assert(strcmp(result, "10010") == 0);
free(result);
return 0;
}
|
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(%rbp)
jmp 1249 <func0+0x60>
mov -0x24(%rbp),%eax
cltq
movzbl -0xe(%rbp,%rax,1),%eax
movsbl %al,%eax
sub $0x30,%eax
add %eax,-0x28(%rbp)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
movzbl -0xe(%rbp,%rax,1),%eax
test %al,%al
jne 1232 <func0+0x49>
mov $0x21,%edi
callq 10e0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x20(%rbp)
cmpl $0x0,-0x28(%rbp)
jne 12c1 <func0+0xd8>
mov -0x20(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x20(%rbp)
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x30,(%rax)
jmp 12c7 <func0+0xde>
mov -0x28(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
lea 0x30(%rax),%ecx
mov -0x20(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x20(%rbp)
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
mov -0x28(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x28(%rbp)
cmpl $0x0,-0x28(%rbp)
jg 128a <func0+0xa1>
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
movl $0x0,-0x1c(%rbp)
jmp 1335 <func0+0x14c>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x29(%rbp)
mov -0x20(%rbp),%eax
sub -0x1c(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
mov -0x20(%rbp),%eax
sub -0x1c(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
movzbl -0x29(%rbp),%eax
mov %al,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x20(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x1c(%rbp)
jl 12e0 <func0+0xf7>
mov -0x18(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 135e <func0+0x175>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
|
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], 0
mov [rbp+var_24], 0
jmp short loc_124C
loc_1235:
mov eax, [rbp+var_24]
cdqe
movzx eax, [rbp+rax+s]
movsx eax, al
sub eax, 30h ; '0'
add [rbp+var_28], eax
add [rbp+var_24], 1
loc_124C:
mov eax, [rbp+var_24]
cdqe
movzx eax, [rbp+rax+s]
test al, al
jnz short loc_1235
mov edi, 21h ; '!'; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_20], 0
cmp [rbp+var_28], 0
jnz short loc_12CA
mov eax, [rbp+var_20]
lea edx, [rax+1]
mov [rbp+var_20], edx
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
mov byte ptr [rax], 30h ; '0'
jmp short loc_12D0
loc_128D:
mov edx, [rbp+var_28]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
lea ecx, [rax+30h]
mov eax, [rbp+var_20]
lea edx, [rax+1]
mov [rbp+var_20], edx
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
mov edx, ecx
mov [rax], dl
mov eax, [rbp+var_28]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_28], eax
loc_12CA:
cmp [rbp+var_28], 0
jg short loc_128D
loc_12D0:
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
mov byte ptr [rax], 0
mov [rbp+var_1C], 0
jmp short loc_133E
loc_12E9:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_29], al
mov eax, [rbp+var_20]
sub eax, [rbp+var_1C]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_1C]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
mov eax, [rbp+var_20]
sub eax, [rbp+var_1C]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+var_18]
add rdx, rax
movzx eax, [rbp+var_29]
mov [rdx], al
add [rbp+var_1C], 1
loc_133E:
mov eax, [rbp+var_20]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_1C], eax
jl short loc_12E9
mov rax, [rbp+var_18]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1367
call ___stack_chk_fail
locret_1367:
leave
retn
|
_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] [rbp-8h]
v10 = __readfsqword(0x28u);
sprintf(s, "%d", a1);
v4 = 0;
for ( i = 0; s[i]; ++i )
v4 += s[i] - 48;
v8 = malloc(0x21uLL);
v6 = 0;
if ( v4 )
{
while ( v4 > 0 )
{
v1 = v6++;
v8[v1] = v4 % 2 + 48;
v4 /= 2;
}
}
else
{
v6 = 1;
*v8 = 48;
}
v8[v6] = 0;
for ( j = 0; j < v6 / 2; ++j )
{
v3 = v8[j];
v8[j] = v8[v6 - j - 1];
v8[v6 - j - 1] = v3;
}
return v8;
}
|
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 ptr [RBP + -0x24],0x0
JMP 0x0010124c
LAB_00101235:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0xe]
MOVSX EAX,AL
SUB EAX,0x30
ADD dword ptr [RBP + -0x28],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_0010124c:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0xe]
TEST AL,AL
JNZ 0x00101235
MOV EDI,0x21
CALL 0x001010e0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x20],0x0
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x001012ca
MOV EAX,dword ptr [RBP + -0x20]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x20],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x30
JMP 0x001012d0
LAB_0010128d:
MOV EDX,dword ptr [RBP + -0x28]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
LEA ECX,[RAX + 0x30]
MOV EAX,dword ptr [RBP + -0x20]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x20],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
MOV EAX,dword ptr [RBP + -0x28]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_001012ca:
CMP dword ptr [RBP + -0x28],0x0
JG 0x0010128d
LAB_001012d0:
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010133e
LAB_001012e9:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x29],AL
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOVZX EAX,byte ptr [RBP + -0x29]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010133e:
MOV EAX,dword ptr [RBP + -0x20]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JL 0x001012e9
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101367
CALL 0x001010b0
LAB_00101367:
LEAVE
RET
|
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; local_16[local_2c] != '\0'; local_2c = local_2c + 1) {
local_30 = local_30 + local_16[local_2c] + -0x30;
}
puVar3 = (int *)malloc(0x21);
local_28 = 0;
if (local_30 == 0) {
local_28 = 1;
*puVar3 = 0x30;
}
else {
for (; 0 < local_30; local_30 = local_30 / 2) {
cVar2 = (char)(local_30 >> 0x1f);
puVar3[local_28] = ((char)local_30 - cVar2 & 1U) + cVar2 + '0';
local_28 = local_28 + 1;
}
}
puVar3[local_28] = 0;
for (local_24 = 0; local_24 < local_28 / 2; local_24 = local_24 + 1) {
uVar1 = puVar3[local_24];
puVar3[local_24] = puVar3[(long)(local_28 - local_24) + -1];
puVar3[(long)(local_28 - local_24) + -1] = uVar1;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar3;
}
|
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) + '0';
sum /= 2;
}
}
bi[index] = '\0';
for (int i = 0; i < index / 2; i++) {
char temp = bi[i];
bi[i] = bi[index - i - 1];
bi[index - i - 1] = temp;
}
return bi;
}
|
#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(result);
result = func0(333);
assert(strcmp(result, "1001") == 0);
free(result);
result = func0(963);
assert(strcmp(result, "10010") == 0);
free(result);
return 0;
}
|
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
mov $0x0,%ebx
movsbl %al,%eax
lea -0x30(%rbx,%rax,1),%ebx
add $0x1,%rdx
movzbl (%rdx),%eax
test %al,%al
jne 1217 <func0+0x4e>
mov $0x21,%edi
callq 10c0 <malloc@plt>
test %ebx,%ebx
je 12d3 <func0+0x10a>
mov $0x1,%ecx
mov $0x0,%edx
jle 12db <func0+0x112>
mov %ecx,%edi
mov %ebx,%esi
shr $0x1f,%esi
lea (%rbx,%rsi,1),%edx
and $0x1,%edx
sub %esi,%edx
add $0x30,%edx
mov %dl,-0x1(%rax,%rcx,1)
mov %ebx,%esi
mov %ebx,%edx
shr $0x1f,%edx
add %edx,%ebx
sar %ebx
add $0x1,%rcx
cmp $0x1,%esi
jg 124b <func0+0x82>
movslq %edi,%rdx
movb $0x0,(%rax,%rdx,1)
mov %edi,%r8d
shr $0x1f,%r8d
add %edi,%r8d
sar %r8d
cmp $0x1,%edi
jle 12b3 <func0+0xea>
lea -0x1(%rax,%rdx,1),%rcx
mov $0x0,%edx
movzbl (%rax,%rdx,1),%esi
movzbl (%rcx),%edi
mov %dil,(%rax,%rdx,1)
mov %sil,(%rcx)
add $0x1,%rdx
sub $0x1,%rcx
cmp %edx,%r8d
jg 1298 <func0+0xcf>
mov 0x8(%rsp),%rdi
xor %fs:0x28,%rdi
jne 12e4 <func0+0x11b>
add $0x10,%rsp
pop %rbx
retq
mov $0x21,%edi
callq 10c0 <malloc@plt>
movb $0x30,(%rax)
mov $0x1,%edx
movslq %edx,%rdx
movb $0x0,(%rax,%rdx,1)
jmp 12b3 <func0+0xea>
callq 10a0 <__stack_chk_fail@plt>
|
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_16]
mov ebx, 0
loc_1237:
movsx eax, al
lea ebx, [rbx+rax-30h]
add rdx, 1
movzx eax, byte ptr [rdx]
test al, al
jnz short loc_1237
mov edi, 21h ; '!'; size
call _malloc
mov rcx, rax
test ebx, ebx
jz loc_12FF
mov edx, 1
mov eax, 0
jle loc_1307
loc_126E:
mov esi, ebx
shr esi, 1Fh
lea eax, [rbx+rsi]
and eax, 1
sub eax, esi
add eax, 30h ; '0'
mov [rcx+rdx-1], al
mov esi, ebx
mov eax, ebx
shr eax, 1Fh
add eax, ebx
sar eax, 1
mov ebx, eax
mov rax, rdx
add rdx, 1
cmp esi, 1
jg short loc_126E
movsxd rdx, eax
mov byte ptr [rcx+rdx], 0
mov r8d, eax
shr r8d, 1Fh
add r8d, eax
sar r8d, 1
cmp eax, 1
jle short loc_12D9
lea rdx, [rcx+rdx-1]
mov eax, 0
loc_12BE:
movzx esi, byte ptr [rcx+rax]
movzx edi, byte ptr [rdx]
mov [rcx+rax], dil
mov [rdx], sil
add rax, 1
sub rdx, 1
cmp r8d, eax
jg short loc_12BE
loc_12D9:
mov rax, [rsp+18h+var_10]
sub rax, fs:28h
jnz short loc_130F
mov rax, rcx
add rsp, 10h
pop rbx
retn
loc_12F2:
mov edi, 21h ; '!'; size
call _malloc
mov rcx, rax
loc_12FF:
mov byte ptr [rcx], 30h ; '0'
mov eax, 1
loc_1307:
cdqe
mov byte ptr [rcx+rax], 0
jmp short loc_12D9
loc_130F:
call ___stack_chk_fail
|
_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 long v15; // [rsp+8h] [rbp-10h]
v15 = __readfsqword(0x28u);
__sprintf_chk(v14, 2LL, 6LL, &unk_2004, a1);
v1 = v14[0];
if ( !v14[0] )
{
v4 = malloc(0x21uLL);
LABEL_12:
*v4 = 48;
v6 = 1;
goto LABEL_13;
}
v2 = v14;
v3 = 0;
do
{
v3 = v3 + v1 - 48;
v1 = *++v2;
}
while ( *v2 );
v4 = malloc(0x21uLL);
if ( !v3 )
goto LABEL_12;
v5 = 1LL;
v6 = 0;
if ( v3 <= 0 )
{
LABEL_13:
v4[v6] = 0;
return v4;
}
do
{
v4[v5 - 1] = v3 % 2 + 48;
v7 = v3;
v3 /= 2;
v8 = v5++;
}
while ( v7 > 1 );
v4[v8] = 0;
v9 = v8 / 2;
if ( v8 > 1 )
{
v10 = &v4[v8 - 1];
v11 = 0LL;
do
{
v12 = v4[v11];
v4[v11] = *v10;
*v10 = v12;
++v11;
--v10;
}
while ( v9 > (int)v11 );
}
return v4;
}
|
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,[RBX + RAX*0x1 + -0x30]
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x00101237
MOV EDI,0x21
CALL 0x001010e0
MOV RCX,RAX
TEST EBX,EBX
JZ 0x001012ff
MOV EDX,0x1
MOV EAX,0x0
JLE 0x00101307
LAB_0010126e:
MOV ESI,EBX
SHR ESI,0x1f
LEA EAX,[RBX + RSI*0x1]
AND EAX,0x1
SUB EAX,ESI
ADD EAX,0x30
MOV byte ptr [RCX + RDX*0x1 + -0x1],AL
MOV ESI,EBX
MOV EAX,EBX
SHR EAX,0x1f
ADD EAX,EBX
SAR EAX,0x1
MOV EBX,EAX
MOV RAX,RDX
ADD RDX,0x1
CMP ESI,0x1
JG 0x0010126e
MOVSXD RDX,EAX
MOV byte ptr [RCX + RDX*0x1],0x0
MOV R8D,EAX
SHR R8D,0x1f
ADD R8D,EAX
SAR R8D,0x1
CMP EAX,0x1
JLE 0x001012d9
LEA RDX,[RCX + RDX*0x1 + -0x1]
MOV EAX,0x0
LAB_001012be:
MOVZX ESI,byte ptr [RCX + RAX*0x1]
MOVZX EDI,byte ptr [RDX]
MOV byte ptr [RCX + RAX*0x1],DIL
MOV byte ptr [RDX],SIL
ADD RAX,0x1
SUB RDX,0x1
CMP R8D,EAX
JG 0x001012be
LAB_001012d9:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010130f
MOV RAX,RCX
ADD RSP,0x10
POP RBX
RET
LAB_001012f2:
MOV EDI,0x21
CALL 0x001010e0
MOV RCX,RAX
LAB_001012ff:
MOV byte ptr [RCX],0x30
MOV EAX,0x1
LAB_00101307:
CDQE
MOV byte ptr [RCX + RAX*0x1],0x0
JMP 0x001012d9
LAB_0010130f:
CALL 0x001010b0
|
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);
__sprintf_chk(&local_16,2,6,&DAT_00102004,param_1);
if (local_16 == '\0') {
puVar7 = (int *)malloc(0x21);
LAB_001012ff:
*puVar7 = 0x30;
iVar5 = 1;
}
else {
pcVar9 = &local_16;
iVar6 = 0;
do {
iVar6 = iVar6 + -0x30 + (int)local_16;
pcVar9 = pcVar9 + 1;
local_16 = *pcVar9;
} while (local_16 != '\0');
puVar7 = (int *)malloc(0x21);
if (iVar6 == 0) goto LAB_001012ff;
iVar5 = 0;
uVar4 = 1;
if (0 < iVar6) {
do {
uVar10 = uVar4;
cVar3 = (char)(iVar6 >> 0x1f);
puVar7[uVar10 - 1] = ((char)iVar6 - cVar3 & 1U) + cVar3 + '0';
bVar2 = 1 < iVar6;
uVar4 = uVar10 + 1;
iVar6 = iVar6 / 2;
} while (bVar2);
iVar6 = (int)uVar10;
puVar7[iVar6] = 0;
if (1 < iVar6) {
puVar11 = puVar7 + (long)iVar6 + -1;
lVar8 = 0;
do {
uVar1 = puVar7[lVar8];
puVar7[lVar8] = *puVar11;
*puVar11 = uVar1;
lVar8 = lVar8 + 1;
puVar11 = puVar11 + -1;
} while ((int)lVar8 < (int)(((uint)(uVar10 >> 0x1f) & 1) + iVar6) >> 1);
}
goto LAB_001012d9;
}
}
puVar7[iVar5] = 0;
LAB_001012d9:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar7;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.