index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
1,194 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *txt) {
int len = strlen(txt);
if (len == 0) return 0;
char last_char = txt[len - 1];
if (!isalpha((unsigned char)last_char)) return 0;
if (len == 1) return 1;
char second_last_char = txt[len - 2];
if (isalpha((unsigned char)second_last_char)) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("apple") == 0);
assert(func0("apple pi e") == 1);
assert(func0("eeeee") == 0);
assert(func0("A") == 1);
assert(func0("Pumpkin pie ") == 0);
assert(func0("Pumpkin pie 1") == 0);
assert(func0("") == 0);
assert(func0("eeeee e ") == 0);
assert(func0("apple pie") == 0);
assert(func0("apple pi e ") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %eax,%r12d
test %eax,%eax
je 13f3 <func0+0x53>
movslq %eax,%r13
callq 1090 <__ctype_b_loc@plt>
movzbl -0x1(%rbp,%r13,1),%edx
mov (%rax),%rax
testb $0x4,0x1(%rax,%rdx,2)
je 1408 <func0+0x68>
cmp $0x1,%r12d
je 13f3 <func0+0x53>
movzbl -0x2(%rbp,%r13,1),%edx
movzwl (%rax,%rdx,2),%r12d
shr $0xa,%r12w
xor $0x1,%r12d
and $0x1,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
add $0x8,%rsp
xor %r12d,%r12d
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
|
func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
call _strlen
mov r12d, eax
test eax, eax
jz short loc_13F2
movsxd r14, eax
call ___ctype_b_loc
movzx r13d, byte ptr [rbp+r14-1]
mov rax, [rax]
test byte ptr [rax+r13*2+1], 4
jz short loc_1400
cmp r12d, 1
jz short loc_13F2
movzx edx, byte ptr [rbp+r14-2]
movzx r12d, word ptr [rax+rdx*2]
shr r12w, 0Ah
xor r12d, 1
and r12d, 1
loc_13F2:
pop rbx
mov eax, r12d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1400:
xor r12d, r12d
pop rbx
pop rbp
mov eax, r12d
pop r12
pop r13
pop r14
retn
|
long long func0(const char *a1)
{
unsigned int v1; // eax
unsigned int v2; // r12d
long long v3; // r14
const unsigned __int16 *v4; // rax
v1 = strlen(a1);
v2 = v1;
if ( !v1 )
return v2;
v3 = (int)v1;
v4 = *__ctype_b_loc();
if ( (v4[(unsigned __int8)a1[v3 - 1]] & 0x400) != 0 )
{
if ( v2 != 1 )
return ((v4[(unsigned __int8)a1[v3 - 2]] >> 10) ^ 1) & 1;
return v2;
}
return 0LL;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV R12D,EAX
TEST EAX,EAX
JZ 0x001013f2
MOVSXD R14,EAX
CALL 0x00101090
MOVZX R13D,byte ptr [RBP + R14*0x1 + -0x1]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + R13*0x2 + 0x1],0x4
JZ 0x00101400
CMP R12D,0x1
JZ 0x001013f2
MOVZX EDX,byte ptr [RBP + R14*0x1 + -0x2]
MOVZX R12D,word ptr [RAX + RDX*0x2]
SHR R12W,0xa
XOR R12D,0x1
AND R12D,0x1
LAB_001013f2:
POP RBX
MOV EAX,R12D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101400:
XOR R12D,R12D
POP RBX
POP RBP
MOV EAX,R12D
POP R12
POP R13
POP R14
RET
|
ulong func0(char *param_1)
{
int iVar1;
size_t sVar2;
ushort **ppuVar3;
ulong uVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
uVar4 = sVar2 & 0xffffffff;
if (iVar1 != 0) {
ppuVar3 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar3 + (ulong)(byte)param_1[(long)iVar1 + -1] * 2 + 1) & 4) == 0) {
return 0;
}
if (iVar1 != 1) {
uVar4 = (ulong)(((*ppuVar3)[(byte)param_1[(long)iVar1 + -2]] >> 10 ^ 1) & 1);
}
}
return uVar4;
}
|
1,195 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *txt) {
int len = strlen(txt);
if (len == 0) return 0;
char last_char = txt[len - 1];
if (!isalpha((unsigned char)last_char)) return 0;
if (len == 1) return 1;
char second_last_char = txt[len - 2];
if (isalpha((unsigned char)second_last_char)) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("apple") == 0);
assert(func0("apple pi e") == 1);
assert(func0("eeeee") == 0);
assert(func0("A") == 1);
assert(func0("Pumpkin pie ") == 0);
assert(func0("Pumpkin pie 1") == 0);
assert(func0("") == 0);
assert(func0("eeeee e ") == 0);
assert(func0("apple pie") == 0);
assert(func0("apple pi e ") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %eax,%r12d
test %eax,%eax
je 13f3 <func0+0x53>
movslq %eax,%r13
callq 1090 <__ctype_b_loc@plt>
movzbl -0x1(%rbp,%r13,1),%edx
mov (%rax),%rax
testb $0x4,0x1(%rax,%rdx,2)
je 1408 <func0+0x68>
cmp $0x1,%r12d
je 13f3 <func0+0x53>
movzbl -0x2(%rbp,%r13,1),%edx
movzwl (%rax,%rdx,2),%r12d
shr $0xa,%r12w
xor $0x1,%r12d
and $0x1,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
add $0x8,%rsp
xor %r12d,%r12d
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
|
func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
call _strlen
mov r12d, eax
test eax, eax
jz short loc_13F2
movsxd r14, eax
call ___ctype_b_loc
movzx r13d, byte ptr [rbp+r14-1]
mov rax, [rax]
test byte ptr [rax+r13*2+1], 4
jz short loc_1400
cmp r12d, 1
jz short loc_13F2
movzx edx, byte ptr [rbp+r14-2]
movzx r12d, word ptr [rax+rdx*2]
shr r12w, 0Ah
xor r12d, 1
and r12d, 1
loc_13F2:
pop rbx
mov eax, r12d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1400:
xor r12d, r12d
pop rbx
pop rbp
mov eax, r12d
pop r12
pop r13
pop r14
retn
|
long long func0(const char *a1)
{
unsigned int v1; // eax
unsigned int v2; // r12d
long long v3; // r14
const unsigned __int16 *v4; // rax
v1 = strlen(a1);
v2 = v1;
if ( !v1 )
return v2;
v3 = (int)v1;
v4 = *__ctype_b_loc();
if ( (v4[(unsigned __int8)a1[v3 - 1]] & 0x400) != 0 )
{
if ( v2 != 1 )
return ((v4[(unsigned __int8)a1[v3 - 2]] >> 10) ^ 1) & 1;
return v2;
}
return 0LL;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV R12D,EAX
TEST EAX,EAX
JZ 0x001013f2
MOVSXD R14,EAX
CALL 0x00101090
MOVZX R13D,byte ptr [RBP + R14*0x1 + -0x1]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + R13*0x2 + 0x1],0x4
JZ 0x00101400
CMP R12D,0x1
JZ 0x001013f2
MOVZX EDX,byte ptr [RBP + R14*0x1 + -0x2]
MOVZX R12D,word ptr [RAX + RDX*0x2]
SHR R12W,0xa
XOR R12D,0x1
AND R12D,0x1
LAB_001013f2:
POP RBX
MOV EAX,R12D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101400:
XOR R12D,R12D
POP RBX
POP RBP
MOV EAX,R12D
POP R12
POP R13
POP R14
RET
|
ulong func0(char *param_1)
{
int iVar1;
size_t sVar2;
ushort **ppuVar3;
ulong uVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
uVar4 = sVar2 & 0xffffffff;
if (iVar1 != 0) {
ppuVar3 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar3 + (ulong)(byte)param_1[(long)iVar1 + -1] * 2 + 1) & 4) == 0) {
return 0;
}
if (iVar1 != 1) {
uVar4 = (ulong)(((*ppuVar3)[(byte)param_1[(long)iVar1 + -2]] >> 10 ^ 1) & 1);
}
}
return uVar4;
}
|
1,196 |
func0
|
#include <stdio.h>
|
int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
}
|
#include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
assert(func0(NULL, 0) == -1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11c2 <func0+0x59>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 11be <func0+0x55>
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
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], 0FFFFFFFFh
mov [rbp+var_4], 1
jmp short loc_11C2
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_11BE
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
loc_11BE:
add [rbp+var_4], 1
loc_11C2:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
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 = -1;
for ( i = 1; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) < *(_DWORD *)(4LL * i - 4 + a1) )
v3 = i;
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011c2
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001011be
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011be:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c2:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
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 = -1;
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < *(int *)(param_1 + (long)local_c * 4 + -4)) {
local_10 = local_c;
}
}
return local_10;
}
|
1,197 |
func0
|
#include <stdio.h>
|
int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
}
|
#include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
assert(func0(NULL, 0) == -1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 1199 <func0+0x30>
lea -0x2(%rsi),%ecx
add $0x2,%rcx
mov $0x1,%eax
mov $0xffffffff,%edx
mov -0x4(%rdi,%rax,4),%esi
cmp %esi,(%rdi,%rax,4)
cmovl %eax,%edx
add $0x1,%rax
cmp %rcx,%rax
jne 1183 <func0+0x1a>
mov %edx,%eax
retq
mov $0xffffffff,%edx
jmp 1196 <func0+0x2d>
|
func0:
endbr64
cmp esi, 1
jle short loc_1194
mov esi, esi
mov eax, 1
mov edx, 0FFFFFFFFh
loc_117E:
mov ecx, [rdi+rax*4-4]
cmp [rdi+rax*4], ecx
cmovl edx, eax
add rax, 1
cmp rax, rsi
jnz short loc_117E
loc_1191:
mov eax, edx
retn
loc_1194:
mov edx, 0FFFFFFFFh
jmp short loc_1191
|
long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // edx
if ( a2 <= 1 )
{
return (unsigned int)-1;
}
else
{
v2 = 1LL;
v3 = -1;
do
{
if ( *(_DWORD *)(a1 + 4 * v2) < *(_DWORD *)(a1 + 4 * v2 - 4) )
v3 = v2;
++v2;
}
while ( v2 != a2 );
}
return v3;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101194
MOV ESI,ESI
MOV EAX,0x1
MOV EDX,0xffffffff
LAB_0010117e:
MOV ECX,dword ptr [RDI + RAX*0x4 + -0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
CMOVL EDX,EAX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x0010117e
LAB_00101191:
MOV EAX,EDX
RET
LAB_00101194:
MOV EDX,0xffffffff
JMP 0x00101191
|
ulong func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if ((int)param_2 < 2) {
uVar2 = 0xffffffff;
}
else {
uVar1 = 1;
uVar2 = 0xffffffff;
do {
if (*(int *)(param_1 + uVar1 * 4) < *(int *)(param_1 + -4 + uVar1 * 4)) {
uVar2 = uVar1 & 0xffffffff;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return uVar2;
}
|
1,198 |
func0
|
#include <stdio.h>
|
int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
}
|
#include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
assert(func0(NULL, 0) == -1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 1280 <func0+0x40>
lea -0x2(%rsi),%edx
mov $0x1,%eax
mov $0xffffffff,%r8d
add $0x2,%rdx
nopl 0x0(%rax,%rax,1)
mov -0x4(%rdi,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
cmovl %eax,%r8d
add $0x1,%rax
cmp %rdx,%rax
jne 1260 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
cmp esi, 1
jle short loc_1350
mov edx, [rdi]
mov esi, esi
mov eax, 1
mov ecx, 0FFFFFFFFh
nop word ptr [rax+rax+00000000h]
loc_1330:
mov r8d, edx
mov edx, [rdi+rax*4]
cmp r8d, edx
cmovg ecx, eax
add rax, 1
cmp rax, rsi
jnz short loc_1330
mov eax, ecx
retn
loc_1350:
mov ecx, 0FFFFFFFFh
mov eax, ecx
retn
|
long long func0(int *a1, int a2)
{
int v2; // edx
long long v3; // rax
unsigned int v4; // ecx
int v5; // r8d
if ( a2 <= 1 )
return 0xFFFFFFFFLL;
v2 = *a1;
v3 = 1LL;
v4 = -1;
do
{
v5 = v2;
v2 = a1[v3];
if ( v5 > v2 )
v4 = v3;
++v3;
}
while ( v3 != a2 );
return v4;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101350
MOV EDX,dword ptr [RDI]
MOV ESI,ESI
MOV EAX,0x1
MOV ECX,0xffffffff
NOP word ptr [RAX + RAX*0x1]
LAB_00101330:
MOV R8D,EDX
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP R8D,EDX
CMOVG ECX,EAX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101330
MOV EAX,ECX
RET
LAB_00101350:
MOV ECX,0xffffffff
MOV EAX,ECX
RET
|
ulong func0(int *param_1,uint param_2)
{
int *piVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
if (1 < (int)param_2) {
uVar2 = 1;
uVar3 = 0xffffffff;
iVar4 = *param_1;
do {
piVar1 = param_1 + uVar2;
if (*piVar1 < iVar4) {
uVar3 = uVar2 & 0xffffffff;
}
uVar2 = uVar2 + 1;
iVar4 = *piVar1;
} while (uVar2 != param_2);
return uVar3;
}
return 0xffffffff;
}
|
1,199 |
func0
|
#include <stdio.h>
|
int func0(int *arr, int size) {
int max = -1;
for (int i = 1; i < size; ++i) {
if (arr[i] < arr[i - 1]) max = i;
}
return max;
}
|
#include <assert.h>
int main() {
int arr1[] = {1, 2, 4, 3, 5};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4) == -1);
int arr3[] = {1, 4, 2, 5, 6, 7, 8, 9, 10};
assert(func0(arr3, 9) == 2);
int arr4[] = {4, 8, 5, 7, 3};
assert(func0(arr4, 5) == 4);
assert(func0(NULL, 0) == -1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 1408 <func0+0x1a8>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%ecx
cmp $0x2,%eax
jbe 140e <func0+0x1ae>
mov %ecx,%edx
movdqa 0xdea(%rip),%xmm2
mov %rdi,%rax
pxor %xmm3,%xmm3
shr $0x2,%edx
movdqa 0xde8(%rip),%xmm4
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm0
movdqu 0x4(%rax),%xmm5
movdqa %xmm2,%xmm1
add $0x10,%rax
paddd %xmm4,%xmm2
pcmpgtd %xmm5,%xmm0
pand %xmm0,%xmm1
pandn %xmm3,%xmm0
movdqa %xmm0,%xmm3
por %xmm1,%xmm3
cmp %rdx,%rax
jne 12a0 <func0+0x40>
movdqa %xmm3,%xmm1
mov $0xffffffff,%edx
mov %ecx,%r8d
psrldq $0x8,%xmm1
movdqa %xmm1,%xmm0
pcmpgtd %xmm3,%xmm0
pand %xmm0,%xmm1
pandn %xmm3,%xmm0
por %xmm0,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
test %eax,%eax
cmove %edx,%eax
and $0xfffffffc,%r8d
lea 0x1(%r8),%edx
cmp %r8d,%ecx
je 1400 <func0+0x1a0>
movslq %edx,%r8
lea 0x1(%rdx),%r9d
push %rbx
shl $0x2,%r8
lea (%rdi,%r8,1),%r10
cmp %r9d,%ecx
jle 141d <func0+0x1bd>
cmp %edx,%esi
jle 141d <func0+0x1bd>
mov (%r10),%r11d
cmp %r11d,-0x4(%r10)
mov 0x4(%rdi,%r8,1),%r10d
cmovg %edx,%eax
lea 0x2(%rdx),%r8d
cmp %r10d,%r11d
cmovg %r9d,%eax
lea 0x3(%rdx),%r9d
cmp %r9d,%ecx
jg 13b0 <func0+0x150>
movslq %r8d,%rdx
mov -0x4(%rdi,%rdx,4),%ebx
cmp %ebx,(%rdi,%rdx,4)
lea 0x1(%r8),%edx
cmovl %r8d,%eax
cmp %edx,%esi
jle 13aa <func0+0x14a>
movslq %edx,%rcx
mov -0x4(%rdi,%rcx,4),%ebx
cmp %ebx,(%rdi,%rcx,4)
cmovge %eax,%edx
lea 0x2(%r8),%eax
cmp %eax,%esi
jle 1425 <func0+0x1c5>
movslq %eax,%rcx
mov (%rdi,%rcx,4),%ebx
cmp %ebx,-0x4(%rdi,%rcx,4)
cmovle %edx,%eax
pop %rbx
retq
nopl 0x0(%rax)
movslq %r8d,%rbx
mov (%rdi,%rbx,4),%r11d
cmp %r11d,%r10d
mov 0x4(%rdi,%rbx,4),%r10d
cmovg %r8d,%eax
lea 0x4(%rdx),%r8d
cmp %r10d,%r11d
cmovg %r9d,%eax
lea 0x5(%rdx),%r9d
cmp %r9d,%ecx
jle 136e <func0+0x10e>
movslq %r8d,%rcx
mov (%rdi,%rcx,4),%r11d
cmp %r10d,%r11d
cmovge %eax,%r8d
cmp 0x4(%rdi,%rcx,4),%r11d
mov %r8d,%eax
lea 0x6(%rdx),%r8d
cmovg %r9d,%eax
jmpq 136e <func0+0x10e>
nopw 0x0(%rax,%rax,1)
retq
nopl 0x0(%rax)
mov $0xffffffff,%eax
retq
mov $0x1,%edx
mov $0xffffffff,%eax
jmpq 132a <func0+0xca>
mov %edx,%r8d
jmpq 136e <func0+0x10e>
mov %edx,%eax
pop %rbx
retq
nopl 0x0(%rax)
|
func0:
endbr64
cmp esi, 1
jle loc_12E8
lea eax, [rsi-2]
mov rcx, rdi
lea edi, [rsi-1]
cmp eax, 2
jbe loc_12EE
mov edx, edi
movdqa xmm2, cs:xmmword_2010
mov rax, rcx
pxor xmm3, xmm3
shr edx, 2
movdqa xmm4, cs:xmmword_2020
shl rdx, 4
add rdx, rcx
nop word ptr [rax+rax+00h]
loc_1188:
movdqu xmm0, xmmword ptr [rax]
movdqu xmm5, xmmword ptr [rax+4]
movdqa xmm1, xmm2
add rax, 10h
paddd xmm2, xmm4
pcmpgtd xmm0, xmm5
pand xmm1, xmm0
pandn xmm0, xmm3
movdqa xmm3, xmm0
por xmm3, xmm1
cmp rax, rdx
jnz short loc_1188
movdqa xmm0, xmm3
mov edx, 0FFFFFFFFh
psrldq xmm0, 8
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm3
pand xmm0, xmm1
pandn xmm1, xmm3
por xmm1, xmm0
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
test eax, eax
cmovz eax, edx
mov edx, edi
and edx, 0FFFFFFFCh
add edx, 1
test dil, 3
jz locret_12E0
loc_1210:
movsxd r8, edx
lea r9d, [rdx+1]
push rbx
shl r8, 2
lea r10, [rcx+r8]
cmp r9d, edi
jge loc_12FD
cmp esi, edx
jle loc_12FD
mov r11d, [r10]
cmp [r10-4], r11d
mov r10d, [rcx+r8+4]
cmovg eax, edx
cmp r11d, r10d
lea r11d, [rdx+2]
cmovg eax, r9d
lea r9d, [rdx+3]
cmp edi, r9d
jg short loc_1298
loc_1254:
movsxd rdi, r11d
lea edx, [r11+1]
mov r9d, [rcx+rdi*4]
cmp r9d, [rcx+rdi*4-4]
lea r8, ds:0[rdi*4]
cmovl eax, r11d
cmp esi, edx
jle short loc_1291
cmp r9d, [rcx+r8+4]
cmovg eax, edx
lea edx, [r11+2]
cmp esi, edx
jle short loc_1291
mov ebx, [rcx+r8+8]
cmp [rcx+r8+4], ebx
cmovg eax, edx
loc_1291:
pop rbx
retn
loc_1298:
mov ebx, [rcx+r8+8]
cmp r10d, ebx
mov r10d, [rcx+r8+0Ch]
cmovg eax, r11d
lea r11d, [rdx+4]
cmp ebx, r10d
cmovg eax, r9d
lea r9d, [rdx+5]
cmp edi, r9d
jle short loc_1254
mov edi, [rcx+r8+10h]
cmp edi, r10d
cmovl eax, r11d
cmp edi, [rcx+r8+14h]
lea r11d, [rdx+6]
cmovg eax, r9d
jmp loc_1254
locret_12E0:
retn
loc_12E8:
mov eax, 0FFFFFFFFh
retn
loc_12EE:
mov edx, 1
mov eax, 0FFFFFFFFh
jmp loc_1210
loc_12FD:
mov r11d, edx
jmp loc_1254
|
long long func0(long long a1, int a2)
{
int v3; // edi
__m128i si128; // xmm2
long long v5; // rax
__m128i v6; // xmm3
__m128i v7; // xmm4
__m128i v8; // xmm0
__m128i v9; // xmm5
__m128i v10; // xmm1
__m128i v11; // xmm0
__m128i v12; // xmm0
__m128i v13; // xmm1
__m128i v14; // xmm1
__m128i v15; // xmm2
__m128i v16; // xmm0
long long result; // rax
signed int v18; // edx
long long v19; // r8
int *v20; // r10
int v21; // r11d
bool v22; // cc
int v23; // r10d
unsigned int v24; // r11d
int v25; // edx
int v26; // r9d
long long v27; // r8
int v28; // ebx
int v29; // r10d
int v30; // edi
if ( a2 <= 1 )
return 0xFFFFFFFFLL;
v3 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v18 = 1;
result = 0xFFFFFFFFLL;
LABEL_8:
v19 = 4LL * v18;
v20 = (int *)(a1 + v19);
if ( v18 + 1 >= v3 || a2 <= v18 )
{
v24 = v18;
}
else
{
v21 = *v20;
v22 = *(v20 - 1) <= *v20;
v23 = *(_DWORD *)(a1 + v19 + 4);
if ( !v22 )
result = (unsigned int)v18;
v22 = v21 <= v23;
v24 = v18 + 2;
if ( !v22 )
result = (unsigned int)(v18 + 1);
if ( v3 > v18 + 3 )
{
v28 = *(_DWORD *)(a1 + v19 + 8);
v22 = v23 <= v28;
v29 = *(_DWORD *)(a1 + v19 + 12);
if ( !v22 )
result = v24;
v24 = v18 + 4;
if ( v28 > v29 )
result = (unsigned int)(v18 + 3);
if ( v3 > v18 + 5 )
{
v30 = *(_DWORD *)(a1 + v19 + 16);
if ( v30 < v29 )
result = v24;
v24 = v18 + 6;
if ( v30 > *(_DWORD *)(a1 + v19 + 20) )
result = (unsigned int)(v18 + 5);
}
}
}
v25 = v24 + 1;
v26 = *(_DWORD *)(a1 + 4LL * (int)v24);
v27 = 4LL * (int)v24;
if ( v26 < *(_DWORD *)(a1 + v27 - 4) )
result = v24;
if ( a2 > v25 )
{
if ( v26 > *(_DWORD *)(a1 + v27 + 4) )
result = (unsigned int)v25;
if ( a2 > (int)(v24 + 2) && *(_DWORD *)(a1 + v27 + 4) > *(_DWORD *)(a1 + v27 + 8) )
return v24 + 2;
}
return result;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v5 = a1;
v6 = 0LL;
v7 = _mm_load_si128((const __m128i *)&xmmword_2020);
do
{
v8 = _mm_loadu_si128((const __m128i *)v5);
v9 = _mm_loadu_si128((const __m128i *)(v5 + 4));
v10 = si128;
v5 += 16LL;
si128 = _mm_add_epi32(si128, v7);
v11 = _mm_cmpgt_epi32(v8, v9);
v6 = _mm_or_si128(_mm_andnot_si128(v11, v6), _mm_and_si128(v10, v11));
}
while ( v5 != a1 + 16LL * ((unsigned int)v3 >> 2) );
v12 = _mm_srli_si128(v6, 8);
v13 = _mm_cmpgt_epi32(v12, v6);
v14 = _mm_or_si128(_mm_andnot_si128(v13, v6), _mm_and_si128(v12, v13));
v15 = _mm_srli_si128(v14, 4);
v16 = _mm_cmpgt_epi32(v15, v14);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v16, v14), _mm_and_si128(v15, v16)));
if ( !(_DWORD)result )
result = 0xFFFFFFFFLL;
v18 = (v3 & 0xFFFFFFFC) + 1;
if ( (v3 & 3) != 0 )
goto LABEL_8;
return result;
}
|
func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012e8
LEA EAX,[RSI + -0x2]
MOV RCX,RDI
LEA EDI,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001012ee
MOV EDX,EDI
MOVDQA XMM2,xmmword ptr [0x00102010]
MOV RAX,RCX
PXOR XMM3,XMM3
SHR EDX,0x2
MOVDQA XMM4,xmmword ptr [0x00102020]
SHL RDX,0x4
ADD RDX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_00101188:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM5,xmmword ptr [RAX + 0x4]
MOVDQA XMM1,XMM2
ADD RAX,0x10
PADDD XMM2,XMM4
PCMPGTD XMM0,XMM5
PAND XMM1,XMM0
PANDN XMM0,XMM3
MOVDQA XMM3,XMM0
POR XMM3,XMM1
CMP RAX,RDX
JNZ 0x00101188
MOVDQA XMM0,XMM3
MOV EDX,0xffffffff
PSRLDQ XMM0,0x8
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM3
PAND XMM0,XMM1
PANDN XMM1,XMM3
POR XMM1,XMM0
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
TEST EAX,EAX
CMOVZ EAX,EDX
MOV EDX,EDI
AND EDX,0xfffffffc
ADD EDX,0x1
TEST DIL,0x3
JZ 0x001012e0
LAB_00101210:
MOVSXD R8,EDX
LEA R9D,[RDX + 0x1]
PUSH RBX
SHL R8,0x2
LEA R10,[RCX + R8*0x1]
CMP R9D,EDI
JGE 0x001012fd
CMP ESI,EDX
JLE 0x001012fd
MOV R11D,dword ptr [R10]
CMP dword ptr [R10 + -0x4],R11D
MOV R10D,dword ptr [RCX + R8*0x1 + 0x4]
CMOVG EAX,EDX
CMP R11D,R10D
LEA R11D,[RDX + 0x2]
CMOVG EAX,R9D
LEA R9D,[RDX + 0x3]
CMP EDI,R9D
JG 0x00101298
LAB_00101254:
MOVSXD RDI,R11D
LEA EDX,[R11 + 0x1]
MOV R9D,dword ptr [RCX + RDI*0x4]
CMP R9D,dword ptr [RCX + RDI*0x4 + -0x4]
LEA R8,[RDI*0x4]
CMOVL EAX,R11D
CMP ESI,EDX
JLE 0x00101291
CMP R9D,dword ptr [RCX + R8*0x1 + 0x4]
CMOVG EAX,EDX
LEA EDX,[R11 + 0x2]
CMP ESI,EDX
JLE 0x00101291
MOV EBX,dword ptr [RCX + R8*0x1 + 0x8]
CMP dword ptr [RCX + R8*0x1 + 0x4],EBX
CMOVG EAX,EDX
LAB_00101291:
POP RBX
RET
LAB_00101298:
MOV EBX,dword ptr [RCX + R8*0x1 + 0x8]
CMP R10D,EBX
MOV R10D,dword ptr [RCX + R8*0x1 + 0xc]
CMOVG EAX,R11D
LEA R11D,[RDX + 0x4]
CMP EBX,R10D
CMOVG EAX,R9D
LEA R9D,[RDX + 0x5]
CMP EDI,R9D
JLE 0x00101254
MOV EDI,dword ptr [RCX + R8*0x1 + 0x10]
CMP EDI,R10D
CMOVL EAX,R11D
CMP EDI,dword ptr [RCX + R8*0x1 + 0x14]
LEA R11D,[RDX + 0x6]
CMOVG EAX,R9D
JMP 0x00101254
LAB_001012e0:
RET
LAB_001012e8:
MOV EAX,0xffffffff
RET
LAB_001012ee:
MOV EDX,0x1
MOV EAX,0xffffffff
JMP 0x00101210
LAB_001012fd:
MOV R11D,EDX
JMP 0x00101254
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int *piVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
if (param_2 < 2) {
return 0xffffffff;
}
uVar11 = param_2 - 1;
if (param_2 - 2U < 3) {
uVar10 = 1;
uVar13 = 0xffffffff;
}
else {
uVar15 = 0;
uVar16 = 0;
uVar17 = 0;
uVar18 = 0;
piVar9 = param_1;
uVar13 = _DAT_00102010;
uVar10 = _UNK_00102014;
uVar12 = _UNK_00102018;
uVar14 = _UNK_0010201c;
do {
iVar2 = *piVar9;
piVar3 = piVar9 + 1;
piVar4 = piVar9 + 2;
piVar5 = piVar9 + 3;
piVar1 = piVar9 + 1;
piVar6 = piVar9 + 2;
piVar7 = piVar9 + 3;
piVar8 = piVar9 + 4;
piVar9 = piVar9 + 4;
uVar15 = ~-(uint)(*piVar1 < iVar2) & uVar15 | uVar13 & -(uint)(*piVar1 < iVar2);
uVar16 = ~-(uint)(*piVar6 < *piVar3) & uVar16 | uVar10 & -(uint)(*piVar6 < *piVar3);
uVar17 = ~-(uint)(*piVar7 < *piVar4) & uVar17 | uVar12 & -(uint)(*piVar7 < *piVar4);
uVar18 = ~-(uint)(*piVar8 < *piVar5) & uVar18 | uVar14 & -(uint)(*piVar8 < *piVar5);
uVar13 = uVar13 + _DAT_00102020;
uVar10 = uVar10 + _UNK_00102024;
uVar12 = uVar12 + _UNK_00102028;
uVar14 = uVar14 + _UNK_0010202c;
} while (piVar9 != param_1 + (ulong)(uVar11 >> 2) * 4);
uVar10 = ~-(uint)((int)uVar15 < (int)uVar17) & uVar15 |
uVar17 & -(uint)((int)uVar15 < (int)uVar17);
uVar12 = ~-(uint)((int)uVar16 < (int)uVar18) & uVar16 |
uVar18 & -(uint)((int)uVar16 < (int)uVar18);
uVar13 = -(uint)((int)uVar10 < (int)uVar12);
uVar13 = ~uVar13 & uVar10 | uVar12 & uVar13;
if (uVar13 == 0) {
uVar13 = 0xffffffff;
}
uVar10 = (uVar11 & 0xfffffffc) + 1;
if ((uVar11 & 3) == 0) {
return uVar13;
}
}
uVar12 = uVar10;
if (((int)(uVar10 + 1) < (int)uVar11) && ((int)uVar10 < param_2)) {
iVar2 = param_1[(int)uVar10];
if (iVar2 < (param_1 + (int)uVar10)[-1]) {
uVar13 = uVar10;
}
if (param_1[(long)(int)uVar10 + 1] < iVar2) {
uVar13 = uVar10 + 1;
}
uVar12 = uVar10 + 2;
if ((int)(uVar10 + 3) < (int)uVar11) {
if (param_1[(long)(int)uVar10 + 2] < param_1[(long)(int)uVar10 + 1]) {
uVar13 = uVar10 + 2;
}
if (param_1[(long)(int)uVar10 + 3] < param_1[(long)(int)uVar10 + 2]) {
uVar13 = uVar10 + 3;
}
uVar12 = uVar10 + 4;
if ((int)(uVar10 + 5) < (int)uVar11) {
if (param_1[(long)(int)uVar10 + 4] < param_1[(long)(int)uVar10 + 3]) {
uVar13 = uVar10 + 4;
}
uVar12 = uVar10 + 6;
if (param_1[(long)(int)uVar10 + 5] < param_1[(long)(int)uVar10 + 4]) {
uVar13 = uVar10 + 5;
}
}
}
}
if (param_1[(int)uVar12] < param_1[(long)(int)uVar12 + -1]) {
uVar13 = uVar12;
}
if ((int)(uVar12 + 1) < param_2) {
if (param_1[(long)(int)uVar12 + 1] < param_1[(int)uVar12]) {
uVar13 = uVar12 + 1;
}
if (((int)(uVar12 + 2) < param_2) &&
(param_1[(long)(int)uVar12 + 2] < param_1[(long)(int)uVar12 + 1])) {
uVar13 = uVar12 + 2;
}
}
return uVar13;
}
|
1,200 |
func0
|
#include <stdio.h>
|
void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
result[1] = minpos;
}
|
#include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){1, 3, 2, 4, 5, 6, -2}, 7, result);
assert(issame(result, (const int[]){-2, 1}));
func0((const int[]){4, 5, 3, 6, 2, 7, -7}, 7, result);
assert(issame(result, (const int[]){-7, 2}));
func0((const int[]){7, 3, 8, 4, 9, 2, 5, -9}, 8, result);
assert(issame(result, (const int[]){-9, 2}));
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){0}, 1, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){-1, -3, -5, -6}, 4, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-1, -3, -5, -6, 0}, 5, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-6, -4, -4, -3, 1}, 5, result);
assert(issame(result, (const int[]){-3, 1}));
func0((const int[]){-6, -4, -4, -3, -100, 1}, 6, result);
assert(issame(result, (const int[]){-3, 1}));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1242 <func0+0xd9>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jns 11ea <func0+0x81>
cmpl $0x0,-0xc(%rbp)
je 11d1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jge 11ea <func0+0x81>
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
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 123e <func0+0xd5>
cmpl $0x0,-0x8(%rbp)
je 1225 <func0+0xbc>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jle 123e <func0+0xd5>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1196 <func0+0x2d>
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)
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], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_1242
loc_1196:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jns short loc_11EA
cmp [rbp+var_C], 0
jz short 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]
cmp [rbp+var_C], eax
jge short loc_11EA
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
loc_11EA:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short loc_123E
cmp [rbp+var_8], 0
jz short loc_1225
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_8], eax
jle short loc_123E
loc_1225:
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_8], eax
loc_123E:
add [rbp+var_4], 1
loc_1242:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_1196
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
nop
pop rbp
retn
|
long long func0(long long a1, int a2, _DWORD *a3)
{
long long result; // rax
int v4; // [rsp+1Ch] [rbp-Ch]
unsigned int v5; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
v4 = 0;
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) < 0 && (!v4 || v4 < *(_DWORD *)(4LL * i + a1)) )
v4 = *(_DWORD *)(4LL * i + a1);
if ( *(int *)(4LL * i + a1) > 0 && (!v5 || (signed int)v5 > *(_DWORD *)(4LL * i + a1)) )
v5 = *(_DWORD *)(4LL * i + a1);
}
*a3 = v4;
result = v5;
a3[1] = v5;
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 + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101242
LAB_00101196:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNS 0x001011ea
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001011d1
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
JGE 0x001011ea
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
LAB_001011ea:
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]
TEST EAX,EAX
JLE 0x0010123e
CMP dword ptr [RBP + -0x8],0x0
JZ 0x00101225
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 + -0x8],EAX
JLE 0x0010123e
LAB_00101225:
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 + -0x8],EAX
LAB_0010123e:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101242:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101196
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
NOP
POP RBP
RET
|
void func0(long param_1,int param_2,int *param_3)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(int *)(param_1 + (long)local_c * 4) < 0) &&
((local_14 == 0 || (local_14 < *(int *)(param_1 + (long)local_c * 4))))) {
local_14 = *(int *)(param_1 + (long)local_c * 4);
}
if ((0 < *(int *)(param_1 + (long)local_c * 4)) &&
((local_10 == 0 || (*(int *)(param_1 + (long)local_c * 4) < local_10)))) {
local_10 = *(int *)(param_1 + (long)local_c * 4);
}
}
*param_3 = local_14;
param_3[1] = local_10;
return;
}
|
1,201 |
func0
|
#include <stdio.h>
|
void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
result[1] = minpos;
}
|
#include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){1, 3, 2, 4, 5, 6, -2}, 7, result);
assert(issame(result, (const int[]){-2, 1}));
func0((const int[]){4, 5, 3, 6, 2, 7, -7}, 7, result);
assert(issame(result, (const int[]){-7, 2}));
func0((const int[]){7, 3, 8, 4, 9, 2, 5, -9}, 8, result);
assert(issame(result, (const int[]){-9, 2}));
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){0}, 1, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){-1, -3, -5, -6}, 4, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-1, -3, -5, -6, 0}, 5, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-6, -4, -4, -3, 1}, 5, result);
assert(issame(result, (const int[]){-3, 1}));
func0((const int[]){-6, -4, -4, -3, -100, 1}, 6, result);
assert(issame(result, (const int[]){-3, 1}));
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11b1 <func0+0x48>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r8
mov $0x0,%esi
mov $0x0,%edi
jmp 119f <func0+0x36>
cmp %edi,%eax
jg 1190 <func0+0x27>
test %edi,%edi
jne 1196 <func0+0x2d>
mov %eax,%edi
jmp 1196 <func0+0x2d>
mov %eax,%esi
add $0x4,%rcx
cmp %r8,%rcx
je 11bb <func0+0x52>
mov (%rcx),%eax
test %eax,%eax
js 1188 <func0+0x1f>
jle 1196 <func0+0x2d>
cmp %esi,%eax
jl 1194 <func0+0x2b>
test %esi,%esi
je 1194 <func0+0x2b>
jmp 1196 <func0+0x2d>
mov $0x0,%esi
mov $0x0,%edi
mov %edi,(%rdx)
mov %esi,0x4(%rdx)
retq
|
func0:
endbr64
test esi, esi
jle short loc_11BE
mov rcx, rdi
movsxd rsi, esi
lea r9, [rdi+rsi*4]
mov esi, 0
mov edi, 0
jmp short loc_11B4
loc_1187:
cmp edi, eax
mov r8d, eax
cmovge r8d, edi
test edi, edi
cmovnz eax, r8d
mov edi, eax
jmp short loc_11AB
loc_119A:
cmp esi, eax
mov r8d, eax
cmovle r8d, esi
test esi, esi
cmovnz eax, r8d
mov esi, eax
loc_11AB:
add rcx, 4
cmp rcx, r9
jz short loc_11C8
loc_11B4:
mov eax, [rcx]
test eax, eax
js short loc_1187
jg short loc_119A
jmp short loc_11AB
loc_11BE:
mov esi, 0
mov edi, 0
loc_11C8:
mov [rdx], edi
mov [rdx+4], esi
retn
|
void func0(int *a1, int a2, int *a3)
{
int *v3; // rcx
int *v4; // r9
int v5; // esi
int v6; // edi
int v7; // r8d
int v8; // eax
int v9; // r8d
if ( a2 <= 0 )
{
v5 = 0;
v6 = 0;
}
else
{
v3 = a1;
v4 = &a1[a2];
v5 = 0;
v6 = 0;
do
{
v8 = *v3;
if ( *v3 < 0 )
{
v7 = *v3;
if ( v6 >= v8 )
v7 = v6;
if ( v6 )
v8 = v7;
v6 = v8;
}
else if ( v8 > 0 )
{
v9 = *v3;
if ( v5 <= v8 )
v9 = v5;
if ( v5 )
v8 = v9;
v5 = v8;
}
++v3;
}
while ( v3 != v4 );
}
*a3 = v6;
a3[1] = v5;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011be
MOV RCX,RDI
MOVSXD RSI,ESI
LEA R9,[RDI + RSI*0x4]
MOV ESI,0x0
MOV EDI,0x0
JMP 0x001011b4
LAB_00101187:
CMP EDI,EAX
MOV R8D,EAX
CMOVGE R8D,EDI
TEST EDI,EDI
CMOVNZ EAX,R8D
MOV EDI,EAX
JMP 0x001011ab
LAB_0010119a:
CMP ESI,EAX
MOV R8D,EAX
CMOVLE R8D,ESI
TEST ESI,ESI
CMOVNZ EAX,R8D
MOV ESI,EAX
LAB_001011ab:
ADD RCX,0x4
CMP RCX,R9
JZ 0x001011c8
LAB_001011b4:
MOV EAX,dword ptr [RCX]
TEST EAX,EAX
JS 0x00101187
JG 0x0010119a
JMP 0x001011ab
LAB_001011be:
MOV ESI,0x0
MOV EDI,0x0
LAB_001011c8:
MOV dword ptr [RDX],EDI
MOV dword ptr [RDX + 0x4],ESI
RET
|
void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
bool bVar6;
if (param_2 < 1) {
iVar3 = 0;
iVar4 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar3 = 0;
iVar4 = 0;
do {
iVar2 = *param_1;
if (iVar2 < 0) {
iVar5 = iVar2;
if (iVar2 <= iVar4) {
iVar5 = iVar4;
}
bVar6 = iVar4 != 0;
iVar4 = iVar2;
if (bVar6) {
iVar4 = iVar5;
}
}
else if (0 < iVar2) {
iVar5 = iVar2;
if (iVar3 <= iVar2) {
iVar5 = iVar3;
}
bVar6 = iVar3 != 0;
iVar3 = iVar2;
if (bVar6) {
iVar3 = iVar5;
}
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
*param_3 = iVar4;
param_3[1] = iVar3;
return;
}
|
1,202 |
func0
|
#include <stdio.h>
|
void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
result[1] = minpos;
}
|
#include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){1, 3, 2, 4, 5, 6, -2}, 7, result);
assert(issame(result, (const int[]){-2, 1}));
func0((const int[]){4, 5, 3, 6, 2, 7, -7}, 7, result);
assert(issame(result, (const int[]){-7, 2}));
func0((const int[]){7, 3, 8, 4, 9, 2, 5, -9}, 8, result);
assert(issame(result, (const int[]){-9, 2}));
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){0}, 1, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){-1, -3, -5, -6}, 4, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-1, -3, -5, -6, 0}, 5, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-6, -4, -4, -3, 1}, 5, result);
assert(issame(result, (const int[]){-3, 1}));
func0((const int[]){-6, -4, -4, -3, -100, 1}, 6, result);
assert(issame(result, (const int[]){-3, 1}));
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1620 <func0+0x50>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%r8
nopl 0x0(%rax)
mov (%rdi),%eax
test %eax,%eax
js 1610 <func0+0x40>
je 15fa <func0+0x2a>
test %ecx,%ecx
je 15f8 <func0+0x28>
cmp %ecx,%eax
jge 15fa <func0+0x2a>
mov %eax,%ecx
add $0x4,%rdi
cmp %rdi,%r8
jne 15e8 <func0+0x18>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
retq
nopl 0x0(%rax)
cmp %esi,%eax
jg 1618 <func0+0x48>
test %esi,%esi
jne 15fa <func0+0x2a>
mov %eax,%esi
jmp 15fa <func0+0x2a>
nopl 0x0(%rax)
xor %ecx,%ecx
xor %esi,%esi
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_15A0
movsxd rsi, esi
xor ecx, ecx
lea r9, [rdi+rsi*4]
xor esi, esi
jmp short loc_1574
loc_1558:
jz short loc_156B
cmp ecx, eax
mov r8d, eax
cmovle r8d, ecx
test ecx, ecx
cmovnz eax, r8d
mov ecx, eax
loc_156B:
add rdi, 4
cmp rdi, r9
jz short loc_1594
loc_1574:
mov eax, [rdi]
test eax, eax
jns short loc_1558
cmp esi, eax
mov r8d, eax
cmovge r8d, esi
test esi, esi
cmovnz eax, r8d
add rdi, 4
mov esi, eax
cmp rdi, r9
jnz short loc_1574
loc_1594:
mov [rdx], esi
mov [rdx+4], ecx
retn
loc_15A0:
xor ecx, ecx
xor esi, esi
mov [rdx], esi
mov [rdx+4], ecx
retn
|
void func0(int *a1, int a2, int *a3)
{
int v3; // ecx
int *v4; // r9
int v5; // esi
int v6; // r8d
int v7; // eax
int v8; // r8d
if ( a2 <= 0 )
{
*a3 = 0;
a3[1] = 0;
}
else
{
v3 = 0;
v4 = &a1[a2];
v5 = 0;
do
{
while ( 1 )
{
v7 = *a1;
if ( *a1 >= 0 )
break;
v8 = *a1;
if ( v5 >= v7 )
v8 = v5;
if ( v5 )
v7 = v8;
++a1;
v5 = v7;
if ( a1 == v4 )
goto LABEL_16;
}
if ( v7 )
{
v6 = *a1;
if ( v3 <= v7 )
v6 = v3;
if ( v3 )
v7 = v6;
v3 = v7;
}
++a1;
}
while ( a1 != v4 );
LABEL_16:
*a3 = v5;
a3[1] = v3;
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001015a0
MOVSXD RSI,ESI
XOR ECX,ECX
LEA R9,[RDI + RSI*0x4]
XOR ESI,ESI
JMP 0x00101574
LAB_00101558:
JZ 0x0010156b
CMP ECX,EAX
MOV R8D,EAX
CMOVLE R8D,ECX
TEST ECX,ECX
CMOVNZ EAX,R8D
MOV ECX,EAX
LAB_0010156b:
ADD RDI,0x4
CMP RDI,R9
JZ 0x00101594
LAB_00101574:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JNS 0x00101558
CMP ESI,EAX
MOV R8D,EAX
CMOVGE R8D,ESI
TEST ESI,ESI
CMOVNZ EAX,R8D
ADD RDI,0x4
MOV ESI,EAX
CMP RDI,R9
JNZ 0x00101574
LAB_00101594:
MOV dword ptr [RDX],ESI
MOV dword ptr [RDX + 0x4],ECX
RET
LAB_001015a0:
XOR ECX,ECX
XOR ESI,ESI
MOV dword ptr [RDX],ESI
MOV dword ptr [RDX + 0x4],ECX
RET
|
void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
bool bVar6;
if (param_2 < 1) {
*param_3 = 0;
param_3[1] = 0;
return;
}
iVar3 = 0;
piVar1 = param_1 + param_2;
iVar4 = 0;
do {
while( true ) {
iVar2 = *param_1;
if (-1 < iVar2) break;
iVar5 = iVar2;
if (iVar2 <= iVar4) {
iVar5 = iVar4;
}
bVar6 = iVar4 != 0;
iVar4 = iVar2;
if (bVar6) {
iVar4 = iVar5;
}
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_00101594;
}
if (iVar2 != 0) {
iVar5 = iVar2;
if (iVar3 <= iVar2) {
iVar5 = iVar3;
}
bVar6 = iVar3 != 0;
iVar3 = iVar2;
if (bVar6) {
iVar3 = iVar5;
}
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
LAB_00101594:
*param_3 = iVar4;
param_3[1] = iVar3;
return;
}
|
1,203 |
func0
|
#include <stdio.h>
|
void func0(const int *lst, int size, int result[2]) {
int maxneg = 0;
int minpos = 0;
for (int i = 0; i < size; i++) {
if (lst[i] < 0 && (maxneg == 0 || lst[i] > maxneg)) maxneg = lst[i];
if (lst[i] > 0 && (minpos == 0 || lst[i] < minpos)) minpos = lst[i];
}
result[0] = maxneg;
result[1] = minpos;
}
|
#include <assert.h>
int issame(const int a[2], const int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0((const int[]){2, 4, 1, 3, 5, 7}, 6, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){2, 4, 1, 3, 5, 7, 0}, 7, result);
assert(issame(result, (const int[]){0, 1}));
func0((const int[]){1, 3, 2, 4, 5, 6, -2}, 7, result);
assert(issame(result, (const int[]){-2, 1}));
func0((const int[]){4, 5, 3, 6, 2, 7, -7}, 7, result);
assert(issame(result, (const int[]){-7, 2}));
func0((const int[]){7, 3, 8, 4, 9, 2, 5, -9}, 8, result);
assert(issame(result, (const int[]){-9, 2}));
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){0}, 1, result);
assert(issame(result, (const int[]){0, 0}));
func0((const int[]){-1, -3, -5, -6}, 4, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-1, -3, -5, -6, 0}, 5, result);
assert(issame(result, (const int[]){-1, 0}));
func0((const int[]){-6, -4, -4, -3, 1}, 5, result);
assert(issame(result, (const int[]){-3, 1}));
func0((const int[]){-6, -4, -4, -3, -100, 1}, 6, result);
assert(issame(result, (const int[]){-3, 1}));
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 15a0 <func0+0x50>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%r8
nopl 0x0(%rax)
mov (%rdi),%eax
test %eax,%eax
js 1590 <func0+0x40>
je 157a <func0+0x2a>
test %ecx,%ecx
je 1578 <func0+0x28>
cmp %ecx,%eax
jge 157a <func0+0x2a>
mov %eax,%ecx
add $0x4,%rdi
cmp %r8,%rdi
jne 1568 <func0+0x18>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
retq
nopl 0x0(%rax)
cmp %esi,%eax
jg 1598 <func0+0x48>
test %esi,%esi
jne 157a <func0+0x2a>
mov %eax,%esi
jmp 157a <func0+0x2a>
nopl 0x0(%rax)
xor %ecx,%ecx
xor %esi,%esi
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1590
movsxd rsi, esi
xor ecx, ecx
lea r9, [rdi+rsi*4]
xor esi, esi
jmp short loc_1564
loc_1548:
jz short loc_155B
cmp ecx, eax
mov r8d, eax
cmovle r8d, ecx
test ecx, ecx
cmovnz eax, r8d
mov ecx, eax
loc_155B:
add rdi, 4
cmp rdi, r9
jz short loc_1584
loc_1564:
mov eax, [rdi]
test eax, eax
jns short loc_1548
cmp esi, eax
mov r8d, eax
cmovge r8d, esi
test esi, esi
cmovnz eax, r8d
add rdi, 4
mov esi, eax
cmp rdi, r9
jnz short loc_1564
loc_1584:
mov [rdx], esi
mov [rdx+4], ecx
retn
loc_1590:
xor ecx, ecx
xor esi, esi
mov [rdx], esi
mov [rdx+4], ecx
retn
|
void func0(int *a1, int a2, int *a3)
{
int v3; // ecx
int *v4; // r9
int v5; // esi
int v6; // r8d
int v7; // eax
int v8; // r8d
if ( a2 <= 0 )
{
*a3 = 0;
a3[1] = 0;
}
else
{
v3 = 0;
v4 = &a1[a2];
v5 = 0;
do
{
while ( 1 )
{
v7 = *a1;
if ( *a1 >= 0 )
break;
v8 = *a1;
if ( v5 >= v7 )
v8 = v5;
if ( v5 )
v7 = v8;
++a1;
v5 = v7;
if ( a1 == v4 )
goto LABEL_16;
}
if ( v7 )
{
v6 = *a1;
if ( v3 <= v7 )
v6 = v3;
if ( v3 )
v7 = v6;
v3 = v7;
}
++a1;
}
while ( a1 != v4 );
LABEL_16:
*a3 = v5;
a3[1] = v3;
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101590
MOVSXD RSI,ESI
XOR ECX,ECX
LEA R9,[RDI + RSI*0x4]
XOR ESI,ESI
JMP 0x00101564
LAB_00101548:
JZ 0x0010155b
CMP ECX,EAX
MOV R8D,EAX
CMOVLE R8D,ECX
TEST ECX,ECX
CMOVNZ EAX,R8D
MOV ECX,EAX
LAB_0010155b:
ADD RDI,0x4
CMP RDI,R9
JZ 0x00101584
LAB_00101564:
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JNS 0x00101548
CMP ESI,EAX
MOV R8D,EAX
CMOVGE R8D,ESI
TEST ESI,ESI
CMOVNZ EAX,R8D
ADD RDI,0x4
MOV ESI,EAX
CMP RDI,R9
JNZ 0x00101564
LAB_00101584:
MOV dword ptr [RDX],ESI
MOV dword ptr [RDX + 0x4],ECX
RET
LAB_00101590:
XOR ECX,ECX
XOR ESI,ESI
MOV dword ptr [RDX],ESI
MOV dword ptr [RDX + 0x4],ECX
RET
|
void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
bool bVar6;
if (param_2 < 1) {
*param_3 = 0;
param_3[1] = 0;
return;
}
iVar3 = 0;
piVar1 = param_1 + param_2;
iVar4 = 0;
do {
while( true ) {
iVar2 = *param_1;
if (-1 < iVar2) break;
iVar5 = iVar2;
if (iVar2 <= iVar4) {
iVar5 = iVar4;
}
bVar6 = iVar4 != 0;
iVar4 = iVar2;
if (bVar6) {
iVar4 = iVar5;
}
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_00101584;
}
if (iVar2 != 0) {
iVar5 = iVar2;
if (iVar3 <= iVar2) {
iVar5 = iVar3;
}
bVar6 = iVar3 != 0;
iVar3 = iVar2;
if (bVar6) {
iVar3 = iVar5;
}
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
LAB_00101584:
*param_3 = iVar4;
param_3[1] = iVar3;
return;
}
|
1,204 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_modified[i] == ',') b_modified[i] = '.';
double numa = strtod(a_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
double numb = strtod(b_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
free(a_modified);
free(b_modified);
if (numa == numb) return "None";
return numa > numb ? (char*)a : (char*)b;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3"), "2,3") == 0);
assert(strcmp(func0("5,1", "6"), "6") == 0);
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "1"), "None") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strdup@plt>
mov %rax,-0x28(%rbp)
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strdup@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x38(%rbp)
jmp 125d <func0+0x74>
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2c,%al
jne 1259 <func0+0x70>
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movb $0x2e,(%rax)
addl $0x1,-0x38(%rbp)
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1235 <func0+0x4c>
movl $0x0,-0x34(%rbp)
jmp 12a2 <func0+0xb9>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2c,%al
jne 129e <func0+0xb5>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x2e,(%rax)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 127a <func0+0x91>
lea -0x30(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strtod@plt>
movq %xmm0,%rax
mov %rax,-0x18(%rbp)
mov -0x30(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 1301 <func0+0x118>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
lea 0xd0c(%rip),%rax
jmpq 1398 <func0+0x1af>
lea -0x30(%rbp),%rdx
mov -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strtod@plt>
movq %xmm0,%rax
mov %rax,-0x10(%rbp)
mov -0x30(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 1349 <func0+0x160>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
lea 0xcc1(%rip),%rax
jmp 1398 <func0+0x1af>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
movsd -0x18(%rbp),%xmm0
ucomisd -0x10(%rbp),%xmm0
jp 1382 <func0+0x199>
movsd -0x18(%rbp),%xmm0
ucomisd -0x10(%rbp),%xmm0
jne 1382 <func0+0x199>
lea 0xc96(%rip),%rax
jmp 1398 <func0+0x1af>
movsd -0x18(%rbp),%xmm0
comisd -0x10(%rbp),%xmm0
jbe 1394 <func0+0x1ab>
mov -0x48(%rbp),%rax
jmp 1398 <func0+0x1af>
mov -0x50(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 13ac <func0+0x1c3>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+s], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+nptr], rax
mov rax, [rbp+var_50]
mov rdi, rax; s
call _strdup
mov [rbp+ptr], rax
mov [rbp+var_38], 0
jmp short loc_125D
loc_1235:
mov eax, [rbp+var_38]
movsxd rdx, eax
mov rax, [rbp+nptr]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Ch ; ','
jnz short loc_1259
mov eax, [rbp+var_38]
movsxd rdx, eax
mov rax, [rbp+nptr]
add rax, rdx
mov byte ptr [rax], 2Eh ; '.'
loc_1259:
add [rbp+var_38], 1
loc_125D:
mov eax, [rbp+var_38]
movsxd rdx, eax
mov rax, [rbp+nptr]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1235
mov [rbp+var_34], 0
jmp short loc_12A2
loc_127A:
mov eax, [rbp+var_34]
movsxd rdx, eax
mov rax, [rbp+ptr]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Ch ; ','
jnz short loc_129E
mov eax, [rbp+var_34]
movsxd rdx, eax
mov rax, [rbp+ptr]
add rax, rdx
mov byte ptr [rax], 2Eh ; '.'
loc_129E:
add [rbp+var_34], 1
loc_12A2:
mov eax, [rbp+var_34]
movsxd rdx, eax
mov rax, [rbp+ptr]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_127A
lea rdx, [rbp+endptr]
mov rax, [rbp+nptr]
mov rsi, rdx; endptr
mov rdi, rax; nptr
call _strtod
movq rax, xmm0
mov [rbp+var_18], rax
mov rax, [rbp+endptr]
movzx eax, byte ptr [rax]
test al, al
jz short loc_1301
mov rax, [rbp+nptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
lea rax, aInvalidInput; "Invalid input"
jmp loc_1398
loc_1301:
lea rdx, [rbp+endptr]
mov rax, [rbp+ptr]
mov rsi, rdx; endptr
mov rdi, rax; nptr
call _strtod
movq rax, xmm0
mov [rbp+var_10], rax
mov rax, [rbp+endptr]
movzx eax, byte ptr [rax]
test al, al
jz short loc_1349
mov rax, [rbp+nptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
lea rax, aInvalidInput; "Invalid input"
jmp short loc_1398
loc_1349:
mov rax, [rbp+nptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
movsd xmm0, [rbp+var_18]
ucomisd xmm0, [rbp+var_10]
jp short loc_1382
movsd xmm0, [rbp+var_18]
ucomisd xmm0, [rbp+var_10]
jnz short loc_1382
lea rax, aNone; "None"
jmp short loc_1398
loc_1382:
movsd xmm0, [rbp+var_18]
comisd xmm0, [rbp+var_10]
jbe short loc_1394
mov rax, [rbp+s]
jmp short loc_1398
loc_1394:
mov rax, [rbp+var_50]
loc_1398:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13AC
call ___stack_chk_fail
locret_13AC:
leave
retn
|
const char * func0(const char *a1, const char *a2)
{
int i; // [rsp+18h] [rbp-38h]
int j; // [rsp+1Ch] [rbp-34h]
char *endptr; // [rsp+20h] [rbp-30h] BYREF
char *nptr; // [rsp+28h] [rbp-28h]
void *ptr; // [rsp+30h] [rbp-20h]
double v8; // [rsp+38h] [rbp-18h]
double v9; // [rsp+40h] [rbp-10h]
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
nptr = strdup(a1);
ptr = strdup(a2);
for ( i = 0; nptr[i]; ++i )
{
if ( nptr[i] == 44 )
nptr[i] = 46;
}
for ( j = 0; *((_BYTE *)ptr + j); ++j )
{
if ( *((_BYTE *)ptr + j) == 44 )
*((_BYTE *)ptr + j) = 46;
}
v8 = strtod(nptr, &endptr);
if ( *endptr || (v9 = strtod((const char *)ptr, &endptr), *endptr) )
{
free(nptr);
free(ptr);
return "Invalid input";
}
else
{
free(nptr);
free(ptr);
if ( v8 == v9 )
{
return "None";
}
else if ( v8 <= v9 )
{
return a2;
}
else
{
return a1;
}
}
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x38],0x0
JMP 0x0010125d
LAB_00101235:
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2c
JNZ 0x00101259
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV byte ptr [RAX],0x2e
LAB_00101259:
ADD dword ptr [RBP + -0x38],0x1
LAB_0010125d:
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101235
MOV dword ptr [RBP + -0x34],0x0
JMP 0x001012a2
LAB_0010127a:
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2c
JNZ 0x0010129e
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x2e
LAB_0010129e:
ADD dword ptr [RBP + -0x34],0x1
LAB_001012a2:
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010127a
LEA RDX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x00101301
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010a0
LEA RAX,[0x102008]
JMP 0x00101398
LAB_00101301:
LEA RDX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x00101349
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010a0
LEA RAX,[0x102008]
JMP 0x00101398
LAB_00101349:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010a0
MOVSD XMM0,qword ptr [RBP + -0x18]
UCOMISD XMM0,qword ptr [RBP + -0x10]
JP 0x00101382
MOVSD XMM0,qword ptr [RBP + -0x18]
UCOMISD XMM0,qword ptr [RBP + -0x10]
JNZ 0x00101382
LEA RAX,[0x102016]
JMP 0x00101398
LAB_00101382:
MOVSD XMM0,qword ptr [RBP + -0x18]
COMISD XMM0,qword ptr [RBP + -0x10]
JBE 0x00101394
MOV RAX,qword ptr [RBP + -0x48]
JMP 0x00101398
LAB_00101394:
MOV RAX,qword ptr [RBP + -0x50]
LAB_00101398:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013ac
CALL 0x001010c0
LAB_001013ac:
LEAVE
RET
|
char * func0(char *param_1,char *param_2)
{
long in_FS_OFFSET;
int local_40;
int local_3c;
char *local_38;
char *local_30;
char *local_28;
double local_20;
double local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = strdup(param_1);
local_28 = strdup(param_2);
for (local_40 = 0; local_30[local_40] != '\0'; local_40 = local_40 + 1) {
if (local_30[local_40] == ',') {
local_30[local_40] = '.';
}
}
for (local_3c = 0; local_28[local_3c] != '\0'; local_3c = local_3c + 1) {
if (local_28[local_3c] == ',') {
local_28[local_3c] = '.';
}
}
local_20 = strtod(local_30,&local_38);
if (*local_38 == '\0') {
local_18 = strtod(local_28,&local_38);
if (*local_38 == '\0') {
free(local_30);
free(local_28);
if (local_20 == local_18) {
param_2 = "None";
}
else if (local_18 < local_20) {
param_2 = param_1;
}
}
else {
free(local_30);
free(local_28);
param_2 = "Invalid input";
}
}
else {
free(local_30);
free(local_28);
param_2 = "Invalid input";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_2;
}
|
1,205 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_modified[i] == ',') b_modified[i] = '.';
double numa = strtod(a_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
double numb = strtod(b_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
free(a_modified);
free(b_modified);
if (numa == numb) return "None";
return numa > numb ? (char*)a : (char*)b;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3"), "2,3") == 0);
assert(strcmp(func0("5,1", "6"), "6") == 0);
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "1"), "None") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %rsi,%r13
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10d0 <strdup@plt>
mov %rax,%rbx
mov %r13,%rdi
callq 10d0 <strdup@plt>
mov %rax,%rbp
movzbl (%rbx),%edx
test %dl,%dl
je 1221 <func0+0x58>
mov %rbx,%rax
jmp 1217 <func0+0x4e>
add $0x1,%rax
movzbl (%rax),%edx
test %dl,%dl
je 1221 <func0+0x58>
cmp $0x2c,%dl
jne 120c <func0+0x43>
movb $0x2e,(%rax)
jmp 120c <func0+0x43>
movzbl 0x0(%rbp),%edx
test %dl,%dl
je 1243 <func0+0x7a>
mov %rbp,%rax
jmp 1239 <func0+0x70>
add $0x1,%rax
movzbl (%rax),%edx
test %dl,%dl
je 1243 <func0+0x7a>
cmp $0x2c,%dl
jne 122e <func0+0x65>
movb $0x2e,(%rax)
jmp 122e <func0+0x65>
lea 0x10(%rsp),%rsi
mov %rbx,%rdi
callq 10a0 <strtod@plt>
movsd %xmm0,(%rsp)
mov 0x10(%rsp),%rax
cmpb $0x0,(%rax)
jne 12ad <func0+0xe4>
lea 0x10(%rsp),%rsi
mov %rbp,%rdi
callq 10a0 <strtod@plt>
movsd %xmm0,0x8(%rsp)
mov 0x10(%rsp),%rax
cmpb $0x0,(%rax)
jne 12df <func0+0x116>
mov %rbx,%rdi
callq 1090 <free@plt>
mov %rbp,%rdi
callq 1090 <free@plt>
movsd (%rsp),%xmm1
ucomisd 0x8(%rsp),%xmm1
jnp 12f8 <func0+0x12f>
movsd (%rsp),%xmm3
comisd 0x8(%rsp),%xmm3
mov %r13,%rax
cmova %r12,%rax
jmp 12c4 <func0+0xfb>
mov %rbx,%rdi
callq 1090 <free@plt>
mov %rbp,%rdi
callq 1090 <free@plt>
lea 0xd40(%rip),%rax
mov 0x18(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1303 <func0+0x13a>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %rbx,%rdi
callq 1090 <free@plt>
mov %rbp,%rdi
callq 1090 <free@plt>
lea 0xd0e(%rip),%rax
jmp 12c4 <func0+0xfb>
jne 1299 <func0+0xd0>
lea 0xd11(%rip),%rax
jmp 12c4 <func0+0xfb>
callq 10b0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r13, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
call _strdup
mov rbx, rax
mov rdi, r12; s
call _strdup
mov rbp, rax
movzx edx, byte ptr [rbx]
test dl, dl
jz short loc_1241
mov rax, rbx
jmp short loc_1237
loc_122C:
add rax, 1
movzx edx, byte ptr [rax]
test dl, dl
jz short loc_1241
loc_1237:
cmp dl, 2Ch ; ','
jnz short loc_122C
mov byte ptr [rax], 2Eh ; '.'
jmp short loc_122C
loc_1241:
movzx edx, byte ptr [rbp+0]
test dl, dl
jz short loc_1263
mov rax, rbp
jmp short loc_1259
loc_124E:
add rax, 1
movzx edx, byte ptr [rax]
test dl, dl
jz short loc_1263
loc_1259:
cmp dl, 2Ch ; ','
jnz short loc_124E
mov byte ptr [rax], 2Eh ; '.'
jmp short loc_124E
loc_1263:
lea rsi, [rsp+48h+endptr]; endptr
mov rdi, rbx; nptr
call _strtod
movsd [rsp+48h+var_48], xmm0
mov rax, [rsp+48h+endptr]
cmp byte ptr [rax], 0
jnz short loc_12DA
lea rsi, [rsp+48h+endptr]; endptr
mov rdi, rbp; nptr
call _strtod
movsd [rsp+48h+var_40], xmm0
mov rax, [rsp+48h+endptr]
cmp byte ptr [rax], 0
jnz short loc_130C
mov rdi, rbx; ptr
call _free
mov rdi, rbp; ptr
call _free
movsd xmm1, [rsp+48h+var_48]
movsd xmm2, [rsp+48h+var_40]
ucomisd xmm1, xmm2
jp short loc_12C6
lea rax, aNone; "None"
jz short loc_12F1
loc_12C6:
movsd xmm3, [rsp+48h+var_48]
comisd xmm3, [rsp+48h+var_40]
mov rax, r12
cmova rax, r13
jmp short loc_12F1
loc_12DA:
mov rdi, rbx; ptr
call _free
mov rdi, rbp; ptr
call _free
lea rax, aInvalidInput; "Invalid input"
loc_12F1:
mov rdx, [rsp+48h+var_30]
sub rdx, fs:28h
jnz short loc_1325
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_130C:
mov rdi, rbx; ptr
call _free
mov rdi, rbp; ptr
call _free
lea rax, aInvalidInput; "Invalid input"
jmp short loc_12F1
loc_1325:
call ___stack_chk_fail
|
const char * func0(const char *a1, const char *a2)
{
char *v2; // rbx
char *v3; // rbp
char v4; // dl
char *v5; // rax
char v6; // dl
char *v7; // rax
const char *result; // rax
double v9; // [rsp+0h] [rbp-48h]
double v10; // [rsp+8h] [rbp-40h]
char *endptr[7]; // [rsp+10h] [rbp-38h] BYREF
endptr[1] = (char *)__readfsqword(0x28u);
v2 = strdup(a1);
v3 = strdup(a2);
v4 = *v2;
if ( *v2 )
{
v5 = v2;
do
{
if ( v4 == 44 )
*v5 = 46;
v4 = *++v5;
}
while ( *v5 );
}
v6 = *v3;
if ( *v3 )
{
v7 = v3;
do
{
if ( v6 == 44 )
*v7 = 46;
v6 = *++v7;
}
while ( *v7 );
}
v9 = strtod(v2, endptr);
if ( *endptr[0] || (v10 = strtod(v3, endptr), *endptr[0]) )
{
free(v2);
free(v3);
return "Invalid input";
}
else
{
free(v2);
free(v3);
result = "None";
if ( v9 != v10 )
{
result = a2;
if ( v9 > v10 )
return a1;
}
}
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R13,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBX,RAX
MOV RDI,R12
CALL 0x001010f0
MOV RBP,RAX
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x00101241
MOV RAX,RBX
JMP 0x00101237
LAB_0010122c:
ADD RAX,0x1
MOVZX EDX,byte ptr [RAX]
TEST DL,DL
JZ 0x00101241
LAB_00101237:
CMP DL,0x2c
JNZ 0x0010122c
MOV byte ptr [RAX],0x2e
JMP 0x0010122c
LAB_00101241:
MOVZX EDX,byte ptr [RBP]
TEST DL,DL
JZ 0x00101263
MOV RAX,RBP
JMP 0x00101259
LAB_0010124e:
ADD RAX,0x1
MOVZX EDX,byte ptr [RAX]
TEST DL,DL
JZ 0x00101263
LAB_00101259:
CMP DL,0x2c
JNZ 0x0010124e
MOV byte ptr [RAX],0x2e
JMP 0x0010124e
LAB_00101263:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x001010b0
MOVSD qword ptr [RSP],XMM0
MOV RAX,qword ptr [RSP + 0x10]
CMP byte ptr [RAX],0x0
JNZ 0x001012da
LEA RSI,[RSP + 0x10]
MOV RDI,RBP
CALL 0x001010b0
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RAX,qword ptr [RSP + 0x10]
CMP byte ptr [RAX],0x0
JNZ 0x0010130c
MOV RDI,RBX
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010a0
MOVSD XMM1,qword ptr [RSP]
MOVSD XMM2,qword ptr [RSP + 0x8]
UCOMISD XMM1,XMM2
JP 0x001012c6
LEA RAX,[0x102012]
JZ 0x001012f1
LAB_001012c6:
MOVSD XMM3,qword ptr [RSP]
COMISD XMM3,qword ptr [RSP + 0x8]
MOV RAX,R12
CMOVA RAX,R13
JMP 0x001012f1
LAB_001012da:
MOV RDI,RBX
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010a0
LEA RAX,[0x102004]
LAB_001012f1:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101325
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010130c:
MOV RDI,RBX
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010a0
LEA RAX,[0x102004]
JMP 0x001012f1
LAB_00101325:
CALL 0x001010c0
|
char * func0(char *param_1,char *param_2)
{
char cVar1;
char *__nptr;
char *__nptr_00;
char *pcVar2;
long in_FS_OFFSET;
double dVar3;
double dVar4;
char *local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__nptr = strdup(param_1);
__nptr_00 = strdup(param_2);
cVar1 = *__nptr;
pcVar2 = __nptr;
while (cVar1 != '\0') {
if (cVar1 == ',') {
*pcVar2 = '.';
}
pcVar2 = pcVar2 + 1;
cVar1 = *pcVar2;
}
cVar1 = *__nptr_00;
pcVar2 = __nptr_00;
while (cVar1 != '\0') {
if (cVar1 == ',') {
*pcVar2 = '.';
}
pcVar2 = pcVar2 + 1;
cVar1 = *pcVar2;
}
dVar3 = strtod(__nptr,&local_38);
if (*local_38 == '\0') {
dVar4 = strtod(__nptr_00,&local_38);
if (*local_38 == '\0') {
free(__nptr);
free(__nptr_00);
pcVar2 = "None";
if ((dVar3 != dVar4) && (pcVar2 = param_2, dVar4 < dVar3)) {
pcVar2 = param_1;
}
}
else {
free(__nptr);
free(__nptr_00);
pcVar2 = "Invalid input";
}
}
else {
free(__nptr);
free(__nptr_00);
pcVar2 = "Invalid input";
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
}
|
1,206 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_modified[i] == ',') b_modified[i] = '.';
double numa = strtod(a_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
double numb = strtod(b_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
free(a_modified);
free(b_modified);
if (numa == numb) return "None";
return numa > numb ? (char*)a : (char*)b;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3"), "2,3") == 0);
assert(strcmp(func0("5,1", "6"), "6") == 0);
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "1"), "None") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10d0 <strdup@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10d0 <strdup@plt>
movzbl (%r12),%edx
mov %rax,%r13
test %dl,%dl
je 145c <func0+0x5c>
mov %r12,%rax
nopl (%rax)
cmp $0x2c,%dl
jne 1450 <func0+0x50>
movb $0x2e,(%rax)
movzbl 0x1(%rax),%edx
add $0x1,%rax
test %dl,%dl
jne 1448 <func0+0x48>
movzbl 0x0(%r13),%edx
test %dl,%dl
je 1484 <func0+0x84>
mov %r13,%rax
nopl 0x0(%rax,%rax,1)
cmp $0x2c,%dl
jne 1478 <func0+0x78>
movb $0x2e,(%rax)
movzbl 0x1(%rax),%edx
add $0x1,%rax
test %dl,%dl
jne 1470 <func0+0x70>
lea 0x10(%rsp),%r14
mov %r12,%rdi
mov %r14,%rsi
callq 10a0 <strtod@plt>
mov 0x10(%rsp),%rax
movsd %xmm0,(%rsp)
cmpb $0x0,(%rax)
jne 14f8 <func0+0xf8>
mov %r14,%rsi
mov %r13,%rdi
callq 10a0 <strtod@plt>
mov 0x10(%rsp),%rax
cmpb $0x0,(%rax)
jne 14f8 <func0+0xf8>
mov %r12,%rdi
movsd %xmm0,0x8(%rsp)
callq 1090 <free@plt>
mov %r13,%rdi
callq 1090 <free@plt>
movsd (%rsp),%xmm1
movsd 0x8(%rsp),%xmm0
ucomisd %xmm0,%xmm1
jnp 1530 <func0+0x130>
movsd (%rsp),%xmm2
mov %rbp,%rax
comisd %xmm0,%xmm2
cmova %rbx,%rax
jmp 150f <func0+0x10f>
nopl 0x0(%rax)
mov %r12,%rdi
callq 1090 <free@plt>
mov %r13,%rdi
callq 1090 <free@plt>
lea 0xaf5(%rip),%rax
mov 0x18(%rsp),%rcx
xor %fs:0x28,%rcx
jne 153b <func0+0x13b>
add $0x20,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
jne 14df <func0+0xdf>
lea 0xad9(%rip),%rax
jmp 150f <func0+0x10f>
callq 10b0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strdup
mov rdi, r13; s
mov rbx, rax
call _strdup
movzx edx, byte ptr [rbx]
mov rbp, rax
test dl, dl
jz short loc_146C
mov rax, rbx
nop dword ptr [rax]
loc_1458:
cmp dl, 2Ch ; ','
jnz short loc_1460
mov byte ptr [rax], 2Eh ; '.'
loc_1460:
movzx edx, byte ptr [rax+1]
add rax, 1
test dl, dl
jnz short loc_1458
loc_146C:
movzx edx, byte ptr [rbp+0]
test dl, dl
jz short loc_1494
mov rax, rbp
nop word ptr [rax+rax+00000000h]
loc_1480:
cmp dl, 2Ch ; ','
jnz short loc_1488
mov byte ptr [rax], 2Eh ; '.'
loc_1488:
movzx edx, byte ptr [rax+1]
add rax, 1
test dl, dl
jnz short loc_1480
loc_1494:
lea r14, [rsp+58h+endptr]
mov rdi, rbx; nptr
mov rsi, r14; endptr
call _strtod
mov rax, [rsp+58h+endptr]
movq r15, xmm0
cmp byte ptr [rax], 0
jnz short loc_1508
mov rsi, r14; endptr
mov rdi, rbp; nptr
call _strtod
mov rax, [rsp+58h+endptr]
cmp byte ptr [rax], 0
jnz short loc_1508
mov rdi, rbx; ptr
movsd [rsp+58h+var_50], xmm0
call _free
mov rdi, rbp; ptr
call _free
movsd xmm0, [rsp+58h+var_50]
movq xmm1, r15
comisd xmm1, xmm0
jp short loc_14FD
lea rax, aNone; "None"
jz short loc_151F
mov rax, r12
ja short loc_151F
loc_14FD:
mov rax, r13
jmp short loc_151F
loc_1508:
mov rdi, rbx; ptr
call _free
mov rdi, rbp; ptr
call _free
lea rax, aInvalidInput; "Invalid input"
loc_151F:
mov rdx, [rsp+58h+var_40]
sub rdx, fs:28h
jnz short loc_153E
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_153E:
call ___stack_chk_fail
|
const char * func0(const char *a1, const char *a2)
{
char *v2; // rbx
char *v3; // rax
char v4; // dl
char *v5; // rbp
char *v6; // rax
char v7; // dl
char *v8; // rax
double v9; // r15
double v10; // xmm0_8
const char *result; // rax
char *endptr[9]; // [rsp+10h] [rbp-48h] BYREF
endptr[1] = (char *)__readfsqword(0x28u);
v2 = strdup(a1);
v3 = strdup(a2);
v4 = *v2;
v5 = v3;
if ( *v2 )
{
v6 = v2;
do
{
if ( v4 == 44 )
*v6 = 46;
v4 = *++v6;
}
while ( v4 );
}
v7 = *v5;
if ( *v5 )
{
v8 = v5;
do
{
if ( v7 == 44 )
*v8 = 46;
v7 = *++v8;
}
while ( v7 );
}
v9 = strtod(v2, endptr);
if ( *endptr[0] || (v10 = strtod(v5, endptr), *endptr[0]) )
{
free(v2);
free(v5);
return "Invalid input";
}
else
{
free(v2);
free(v5);
result = "None";
if ( v9 != v10 )
{
result = a1;
if ( v9 <= v10 )
return a2;
}
}
return result;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RDI,R13
MOV RBX,RAX
CALL 0x001010f0
MOVZX EDX,byte ptr [RBX]
MOV RBP,RAX
TEST DL,DL
JZ 0x0010146c
MOV RAX,RBX
NOP dword ptr [RAX]
LAB_00101458:
CMP DL,0x2c
JNZ 0x00101460
MOV byte ptr [RAX],0x2e
LAB_00101460:
MOVZX EDX,byte ptr [RAX + 0x1]
ADD RAX,0x1
TEST DL,DL
JNZ 0x00101458
LAB_0010146c:
MOVZX EDX,byte ptr [RBP]
TEST DL,DL
JZ 0x00101494
MOV RAX,RBP
NOP word ptr [RAX + RAX*0x1]
LAB_00101480:
CMP DL,0x2c
JNZ 0x00101488
MOV byte ptr [RAX],0x2e
LAB_00101488:
MOVZX EDX,byte ptr [RAX + 0x1]
ADD RAX,0x1
TEST DL,DL
JNZ 0x00101480
LAB_00101494:
LEA R14,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R14
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x10]
MOVQ R15,XMM0
CMP byte ptr [RAX],0x0
JNZ 0x00101508
MOV RSI,R14
MOV RDI,RBP
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x10]
CMP byte ptr [RAX],0x0
JNZ 0x00101508
MOV RDI,RBX
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010a0
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVQ XMM1,R15
COMISD XMM1,XMM0
JP 0x001014fd
LEA RAX,[0x102012]
JZ 0x0010151f
MOV RAX,R12
JA 0x0010151f
LAB_001014fd:
MOV RAX,R13
JMP 0x0010151f
LAB_00101508:
MOV RDI,RBX
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010a0
LEA RAX,[0x102004]
LAB_0010151f:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010153e
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010153e:
CALL 0x001010c0
|
char * func0(char *param_1,char *param_2)
{
char *pcVar1;
char cVar2;
char *__nptr;
char *__nptr_00;
char *pcVar3;
long in_FS_OFFSET;
double dVar4;
double dVar5;
char *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__nptr = strdup(param_1);
__nptr_00 = strdup(param_2);
cVar2 = *__nptr;
pcVar3 = __nptr;
while (cVar2 != '\0') {
if (cVar2 == ',') {
*pcVar3 = '.';
}
pcVar1 = pcVar3 + 1;
pcVar3 = pcVar3 + 1;
cVar2 = *pcVar1;
}
cVar2 = *__nptr_00;
pcVar3 = __nptr_00;
while (cVar2 != '\0') {
if (cVar2 == ',') {
*pcVar3 = '.';
}
pcVar1 = pcVar3 + 1;
pcVar3 = pcVar3 + 1;
cVar2 = *pcVar1;
}
dVar4 = strtod(__nptr,&local_48);
if ((*local_48 == '\0') && (dVar5 = strtod(__nptr_00,&local_48), *local_48 == '\0')) {
free(__nptr);
free(__nptr_00);
if ((NAN(dVar4) || NAN(dVar5)) ||
((pcVar3 = "None", dVar4 != dVar5 &&
(pcVar3 = param_1, dVar4 < dVar5 || ((NAN(dVar4) || NAN(dVar5)) || dVar4 == dVar5))))) {
pcVar3 = param_2;
}
}
else {
free(__nptr);
free(__nptr_00);
pcVar3 = "Invalid input";
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,207 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char* func0(const char* a, const char* b) {
char *end;
char *a_modified = strdup(a);
char *b_modified = strdup(b);
// Replace ',' with '.' if present for atof conversion
for (int i = 0; a_modified[i]; ++i) if (a_modified[i] == ',') a_modified[i] = '.';
for (int i = 0; b_modified[i]; ++i) if (b_modified[i] == ',') b_modified[i] = '.';
double numa = strtod(a_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
double numb = strtod(b_modified, &end);
if (*end) { free(a_modified); free(b_modified); return "Invalid input"; } // Not a valid number
free(a_modified);
free(b_modified);
if (numa == numb) return "None";
return numa > numb ? (char*)a : (char*)b;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main() {
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "2.5"), "2.5") == 0);
assert(strcmp(func0("2", "3"), "3") == 0);
assert(strcmp(func0("5", "6"), "6") == 0);
assert(strcmp(func0("1", "2,3"), "2,3") == 0);
assert(strcmp(func0("5,1", "6"), "6") == 0);
assert(strcmp(func0("1", "2"), "2") == 0);
assert(strcmp(func0("1", "1"), "None") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 10d0 <strdup@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10d0 <strdup@plt>
movzbl (%r12),%edx
mov %rax,%r13
test %dl,%dl
je 145d <func0+0x5d>
mov %r12,%rax
nopl (%rax)
cmp $0x2c,%dl
je 1538 <func0+0x138>
movzbl 0x1(%rax),%edx
add $0x1,%rax
test %dl,%dl
jne 1448 <func0+0x48>
movzbl 0x0(%r13),%edx
test %dl,%dl
je 1485 <func0+0x85>
mov %r13,%rax
nopl 0x0(%rax)
cmp $0x2c,%dl
je 1550 <func0+0x150>
movzbl 0x1(%rax),%edx
add $0x1,%rax
test %dl,%dl
jne 1470 <func0+0x70>
lea 0x10(%rsp),%r14
mov %r12,%rdi
mov %r14,%rsi
callq 10a0 <strtod@plt>
mov 0x10(%rsp),%rax
movsd %xmm0,(%rsp)
cmpb $0x0,(%rax)
jne 1500 <func0+0x100>
mov %r14,%rsi
mov %r13,%rdi
callq 10a0 <strtod@plt>
mov 0x10(%rsp),%rax
cmpb $0x0,(%rax)
jne 1500 <func0+0x100>
mov %r12,%rdi
movsd %xmm0,0x8(%rsp)
callq 1090 <free@plt>
mov %r13,%rdi
callq 1090 <free@plt>
movsd (%rsp),%xmm1
movsd 0x8(%rsp),%xmm0
ucomisd %xmm0,%xmm1
jnp 1570 <func0+0x170>
movsd (%rsp),%xmm2
mov %rbp,%rax
comisd %xmm0,%xmm2
cmova %rbx,%rax
jmp 1517 <func0+0x117>
nopw %cs:0x0(%rax,%rax,1)
mov %r12,%rdi
callq 1090 <free@plt>
mov %r13,%rdi
callq 1090 <free@plt>
lea 0xaed(%rip),%rax
mov 0x18(%rsp),%rcx
xor %fs:0x28,%rcx
jne 157f <func0+0x17f>
add $0x20,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
movb $0x2e,(%rax)
movzbl 0x1(%rax),%edx
add $0x1,%rax
test %dl,%dl
jne 1448 <func0+0x48>
jmpq 145d <func0+0x5d>
movb $0x2e,(%rax)
movzbl 0x1(%rax),%edx
add $0x1,%rax
test %dl,%dl
jne 1470 <func0+0x70>
jmpq 1485 <func0+0x85>
nopl 0x0(%rax,%rax,1)
jne 14e4 <func0+0xe4>
lea 0xa95(%rip),%rax
jmp 1517 <func0+0x117>
callq 10b0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
call _strdup
mov rdi, r13; s
mov rbx, rax
call _strdup
movzx edx, byte ptr [rbx]
mov rbp, rax
test dl, dl
jz short loc_146D
mov rax, rbx
nop dword ptr [rax]
loc_1458:
cmp dl, 2Ch ; ','
jz loc_1540
movzx edx, byte ptr [rax+1]
add rax, 1
test dl, dl
jnz short loc_1458
loc_146D:
movzx edx, byte ptr [rbp+0]
test dl, dl
jz short loc_1495
mov rax, rbp
nop dword ptr [rax+rax+00000000h]
loc_1480:
cmp dl, 2Ch ; ','
jz loc_1560
movzx edx, byte ptr [rax+1]
add rax, 1
test dl, dl
jnz short loc_1480
loc_1495:
lea r14, [rsp+58h+endptr]
mov rdi, rbx; nptr
mov rsi, r14; endptr
call _strtod
mov rax, [rsp+58h+endptr]
movq r15, xmm0
cmp byte ptr [rax], 0
jnz short loc_1508
mov rsi, r14; endptr
mov rdi, rbp; nptr
call _strtod
mov rax, [rsp+58h+endptr]
cmp byte ptr [rax], 0
jnz short loc_1508
mov rdi, rbx; ptr
movsd [rsp+58h+var_50], xmm0
call _free
mov rdi, rbp; ptr
call _free
movsd xmm0, [rsp+58h+var_50]
movq xmm1, r15
comisd xmm1, xmm0
jp short loc_14FE
lea rax, aNone; "None"
jz short loc_151F
mov rax, r12
ja short loc_151F
loc_14FE:
mov rax, r13
jmp short loc_151F
loc_1508:
mov rdi, rbx; ptr
call _free
mov rdi, rbp; ptr
call _free
lea rax, aInvalidInput; "Invalid input"
loc_151F:
mov rdx, [rsp+58h+var_40]
sub rdx, fs:28h
jnz short loc_1578
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1540:
mov byte ptr [rax], 2Eh ; '.'
movzx edx, byte ptr [rax+1]
add rax, 1
test dl, dl
jnz loc_1458
jmp loc_146D
loc_1560:
mov byte ptr [rax], 2Eh ; '.'
movzx edx, byte ptr [rax+1]
add rax, 1
test dl, dl
jnz loc_1480
jmp loc_1495
loc_1578:
call ___stack_chk_fail
|
const char * func0(const char *a1, const char *a2)
{
char *v2; // rbx
char *v3; // rax
char v4; // dl
char *v5; // rbp
char *v6; // rax
char v7; // dl
char *v8; // rax
double v9; // r15
double v10; // xmm0_8
const char *result; // rax
char *endptr[9]; // [rsp+10h] [rbp-48h] BYREF
endptr[1] = (char *)__readfsqword(0x28u);
v2 = strdup(a1);
v3 = strdup(a2);
v4 = *v2;
v5 = v3;
if ( *v2 )
{
v6 = v2;
do
{
while ( v4 != 44 )
{
v4 = *++v6;
if ( !v4 )
goto LABEL_5;
}
*v6 = 46;
v4 = *++v6;
}
while ( v4 );
}
LABEL_5:
v7 = *v5;
if ( *v5 )
{
v8 = v5;
do
{
while ( v7 != 44 )
{
v7 = *++v8;
if ( !v7 )
goto LABEL_9;
}
*v8 = 46;
v7 = *++v8;
}
while ( v7 );
}
LABEL_9:
v9 = strtod(v2, endptr);
if ( *endptr[0] || (v10 = strtod(v5, endptr), *endptr[0]) )
{
free(v2);
free(v5);
return "Invalid input";
}
else
{
free(v2);
free(v5);
result = "None";
if ( v9 != v10 )
{
result = a1;
if ( v9 <= v10 )
return a2;
}
}
return result;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RDI,R13
MOV RBX,RAX
CALL 0x001010f0
MOVZX EDX,byte ptr [RBX]
MOV RBP,RAX
TEST DL,DL
JZ 0x0010146d
MOV RAX,RBX
NOP dword ptr [RAX]
LAB_00101458:
CMP DL,0x2c
JZ 0x00101540
MOVZX EDX,byte ptr [RAX + 0x1]
ADD RAX,0x1
TEST DL,DL
JNZ 0x00101458
LAB_0010146d:
MOVZX EDX,byte ptr [RBP]
TEST DL,DL
JZ 0x00101495
MOV RAX,RBP
NOP dword ptr [RAX + RAX*0x1]
LAB_00101480:
CMP DL,0x2c
JZ 0x00101560
MOVZX EDX,byte ptr [RAX + 0x1]
ADD RAX,0x1
TEST DL,DL
JNZ 0x00101480
LAB_00101495:
LEA R14,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R14
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x10]
MOVQ R15,XMM0
CMP byte ptr [RAX],0x0
JNZ 0x00101508
MOV RSI,R14
MOV RDI,RBP
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x10]
CMP byte ptr [RAX],0x0
JNZ 0x00101508
MOV RDI,RBX
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010a0
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVQ XMM1,R15
COMISD XMM1,XMM0
JP 0x001014fe
LEA RAX,[0x102012]
JZ 0x0010151f
MOV RAX,R12
JA 0x0010151f
LAB_001014fe:
MOV RAX,R13
JMP 0x0010151f
LAB_00101508:
MOV RDI,RBX
CALL 0x001010a0
MOV RDI,RBP
CALL 0x001010a0
LEA RAX,[0x102004]
LAB_0010151f:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101578
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101540:
MOV byte ptr [RAX],0x2e
MOVZX EDX,byte ptr [RAX + 0x1]
ADD RAX,0x1
TEST DL,DL
JNZ 0x00101458
JMP 0x0010146d
LAB_00101560:
MOV byte ptr [RAX],0x2e
MOVZX EDX,byte ptr [RAX + 0x1]
ADD RAX,0x1
TEST DL,DL
JNZ 0x00101480
JMP 0x00101495
LAB_00101578:
CALL 0x001010c0
|
char * func0(char *param_1,char *param_2)
{
char *pcVar1;
char *__nptr;
char *__nptr_00;
char *pcVar2;
char cVar3;
long in_FS_OFFSET;
double dVar4;
double dVar5;
char *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__nptr = strdup(param_1);
__nptr_00 = strdup(param_2);
cVar3 = *__nptr;
pcVar2 = __nptr;
while (cVar3 != '\0') {
while (cVar3 == ',') {
*pcVar2 = '.';
cVar3 = pcVar2[1];
pcVar2 = pcVar2 + 1;
if (cVar3 == '\0') goto LAB_0010146d;
}
pcVar1 = pcVar2 + 1;
pcVar2 = pcVar2 + 1;
cVar3 = *pcVar1;
}
LAB_0010146d:
cVar3 = *__nptr_00;
pcVar2 = __nptr_00;
while (cVar3 != '\0') {
while (cVar3 == ',') {
*pcVar2 = '.';
cVar3 = pcVar2[1];
pcVar2 = pcVar2 + 1;
if (cVar3 == '\0') goto LAB_00101495;
}
pcVar1 = pcVar2 + 1;
pcVar2 = pcVar2 + 1;
cVar3 = *pcVar1;
}
LAB_00101495:
dVar4 = strtod(__nptr,&local_48);
if ((*local_48 == '\0') && (dVar5 = strtod(__nptr_00,&local_48), *local_48 == '\0')) {
free(__nptr);
free(__nptr_00);
if ((NAN(dVar4) || NAN(dVar5)) ||
((pcVar2 = "None", dVar4 != dVar5 &&
(pcVar2 = param_1, dVar4 < dVar5 || ((NAN(dVar4) || NAN(dVar5)) || dVar4 == dVar5))))) {
pcVar2 = param_2;
}
}
else {
free(__nptr);
free(__nptr_00);
pcVar2 = "Invalid input";
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,208 |
func0
|
#include <stdio.h>
|
int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 116b <func0+0x22>
cmpl $0x7,-0x4(%rbp)
jle 116b <func0+0x22>
mov $0x1,%eax
jmp 1170 <func0+0x27>
mov $0x0,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
jnz short loc_116B
cmp [rbp+var_4], 7
jle short loc_116B
mov eax, 1
jmp short loc_1170
loc_116B:
mov eax, 0
loc_1170:
pop rbp
retn
|
_BOOL8 func0(int a1)
{
return (a1 & 1) == 0 && a1 > 7;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x0010116b
CMP dword ptr [RBP + -0x4],0x7
JLE 0x0010116b
MOV EAX,0x1
JMP 0x00101170
LAB_0010116b:
MOV EAX,0x0
LAB_00101170:
POP RBP
RET
|
int8 func0(uint param_1)
{
int8 uVar1;
if (((param_1 & 1) == 0) && (7 < (int)param_1)) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
}
|
1,209 |
func0
|
#include <stdio.h>
|
int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %edi,%edx
xor $0x1,%edx
cmp $0x7,%edi
setg %al
movzbl %al,%eax
and %edx,%eax
retq
|
func0:
endbr64
mov edx, edi
xor edx, 1
cmp edi, 7
setnle al
movzx eax, al
and eax, edx
retn
|
long long func0(int a1)
{
return ((unsigned __int8)a1 ^ 1u) & (a1 > 7);
}
|
func0:
ENDBR64
MOV EDX,EDI
XOR EDX,0x1
CMP EDI,0x7
SETG AL
MOVZX EAX,AL
AND EAX,EDX
RET
|
uint func0(uint param_1)
{
return (uint)(7 < (int)param_1) & (param_1 ^ 1);
}
|
1,210 |
func0
|
#include <stdio.h>
|
int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp $0x7,%edi
not %edi
setg %al
and %eax,%edi
movzbl %dil,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
cmp edi, 7
not edi
setnle al
and eax, edi
movzx eax, al
retn
|
long long func0(int a1)
{
return (unsigned __int8)~(_BYTE)a1 & (a1 > 7);
}
|
func0:
ENDBR64
CMP EDI,0x7
NOT EDI
SETG AL
AND EAX,EDI
MOVZX EAX,AL
RET
|
uint func0(uint param_1)
{
return (uint)(7 < (int)param_1) & ~param_1;
}
|
1,211 |
func0
|
#include <stdio.h>
|
int func0(int n) {
if (n % 2 == 0 && n >= 8) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 0);
assert(func0(6) == 0);
assert(func0(8) == 1);
assert(func0(10) == 1);
assert(func0(11) == 0);
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(16) == 1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x7,%edi
not %edi
setg %al
and %eax,%edi
movzbl %dil,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
cmp edi, 7
not edi
setnle al
and eax, edi
movzx eax, al
retn
|
long long func0(int a1)
{
return (unsigned __int8)~(_BYTE)a1 & (a1 > 7);
}
|
func0:
ENDBR64
CMP EDI,0x7
NOT EDI
SETG AL
AND EAX,EDI
MOVZX EAX,AL
RET
|
uint func0(uint param_1)
{
return (uint)(7 < (int)param_1) & ~param_1;
}
|
1,212 |
func0
|
#include <stdio.h>
|
long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movq $0x1,-0x10(%rbp)
movq $0x1,-0x8(%rbp)
movl $0x1,-0x14(%rbp)
jmp 118f <func0+0x46>
mov -0x14(%rbp),%eax
cltq
mov -0x10(%rbp),%rdx
imul %rdx,%rax
mov %rax,-0x10(%rbp)
mov -0x8(%rbp),%rax
imul -0x10(%rbp),%rax
mov %rax,-0x8(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 116d <func0+0x24>
mov -0x8(%rbp),%rax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_10], 1
mov [rbp+var_8], 1
mov [rbp+var_14], 1
jmp short loc_118F
loc_116D:
mov eax, [rbp+var_14]
cdqe
mov rdx, [rbp+var_10]
imul rax, rdx
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
imul rax, [rbp+var_10]
mov [rbp+var_8], rax
add [rbp+var_14], 1
loc_118F:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_24]
jle short loc_116D
mov rax, [rbp+var_8]
pop rbp
retn
|
long long func0(int a1)
{
int i; // [rsp+10h] [rbp-14h]
long long v3; // [rsp+14h] [rbp-10h]
long long v4; // [rsp+1Ch] [rbp-8h]
v3 = 1LL;
v4 = 1LL;
for ( i = 1; i <= a1; ++i )
{
v3 *= i;
v4 *= v3;
}
return v4;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x10],0x1
MOV qword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x14],0x1
JMP 0x0010118f
LAB_0010116d:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV RDX,qword ptr [RBP + -0x10]
IMUL RAX,RDX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
IMUL RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
ADD dword ptr [RBP + -0x14],0x1
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x0010116d
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long func0(int param_1)
{
int4 local_1c;
int8 local_18;
int8 local_10;
local_18 = 1;
local_10 = 1;
for (local_1c = 1; local_1c <= param_1; local_1c = local_1c + 1) {
local_18 = local_1c * local_18;
local_10 = local_10 * local_18;
}
return local_10;
}
|
1,213 |
func0
|
#include <stdio.h>
|
long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %edi,%edi
jle 117c <func0+0x33>
lea -0x1(%rdi),%esi
add $0x2,%rsi
mov $0x1,%eax
mov $0x1,%ecx
mov $0x1,%edx
imul %rax,%rdx
imul %rdx,%rcx
add $0x1,%rax
cmp %rsi,%rax
jne 1167 <func0+0x1e>
mov %rcx,%rax
retq
mov $0x1,%ecx
jmp 1178 <func0+0x2f>
|
func0:
endbr64
test edi, edi
jle short loc_1178
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
loc_1163:
imul rdx, rax
imul rcx, rdx
add rax, 1
cmp rax, rsi
jnz short loc_1163
loc_1174:
mov rax, rcx
retn
loc_1178:
mov ecx, 1
jmp short loc_1174
|
long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1;
v2 *= v3;
++v1;
}
while ( v1 != a1 + 1 );
return v2;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
LAB_00101163:
IMUL RDX,RAX
IMUL RCX,RDX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101163
LAB_00101174:
MOV RAX,RCX
RET
LAB_00101178:
MOV ECX,0x1
JMP 0x00101174
|
long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (param_1 < 1) {
lVar2 = 1;
}
else {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
lVar2 = lVar2 * lVar3;
uVar1 = uVar1 + 1;
} while (uVar1 != param_1 + 1);
}
return lVar2;
}
|
1,214 |
func0
|
#include <stdio.h>
|
long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %edi,%edi
jle 11e8 <func0+0x38>
lea -0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%edx
add $0x2,%rcx
imul %rax,%rdx
add $0x1,%rax
imul %rdx,%r8
cmp %rcx,%rax
jne 11d0 <func0+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov $0x1,%r8d
mov %r8,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
test edi, edi
jle short loc_11E8
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
nop word ptr [rax+rax+00h]
loc_11D0:
imul rdx, rax
add rax, 1
imul rcx, rdx
cmp rax, rsi
jnz short loc_11D0
mov rax, rcx
retn
loc_11E8:
mov ecx, 1
mov rax, rcx
retn
|
long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1++;
v2 *= v3;
}
while ( v1 != a1 + 1 );
return v2;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011e8
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001011d0:
IMUL RDX,RAX
ADD RAX,0x1
IMUL RCX,RDX
CMP RAX,RSI
JNZ 0x001011d0
MOV RAX,RCX
RET
LAB_001011e8:
MOV ECX,0x1
MOV RAX,RCX
RET
|
long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (0 < param_1) {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
uVar1 = uVar1 + 1;
lVar2 = lVar2 * lVar3;
} while (uVar1 != param_1 + 1);
return lVar2;
}
return 1;
}
|
1,215 |
func0
|
#include <stdio.h>
|
long long func0(int n) {
long long fact = 1, bfact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
bfact = bfact * fact;
}
return bfact;
}
|
#include <assert.h>
int main() {
assert(func0(4) == 288);
assert(func0(5) == 34560);
assert(func0(7) == 125411328000);
assert(func0(1) == 1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %edi,%edi
jle 1178 <func0+0x38>
lea -0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%edx
add $0x2,%rcx
imul %rax,%rdx
add $0x1,%rax
imul %rdx,%r8
cmp %rcx,%rax
jne 1160 <func0+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov $0x1,%r8d
mov %r8,%rax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
test edi, edi
jle short loc_1178
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
nop word ptr [rax+rax+00h]
loc_1160:
imul rdx, rax
add rax, 1
imul rcx, rdx
cmp rax, rsi
jnz short loc_1160
mov rax, rcx
retn
loc_1178:
mov ecx, 1
mov rax, rcx
retn
|
long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1++;
v2 *= v3;
}
while ( v1 != a1 + 1 );
return v2;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
IMUL RDX,RAX
ADD RAX,0x1
IMUL RCX,RDX
CMP RAX,RSI
JNZ 0x00101160
MOV RAX,RCX
RET
LAB_00101178:
MOV ECX,0x1
MOV RAX,RCX
RET
|
long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (0 < param_1) {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
uVar1 = uVar1 + 1;
lVar2 = lVar2 * lVar3;
} while (uVar1 != param_1 + 1);
return lVar2;
}
return 1;
}
|
1,216 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
space_len = 0;
out[j++] = text[i];
}
}
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
out[j] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Yellow_Yellow__Dirty__Fellow") == 0);
func0("Exa mple", output);
assert(strcmp(output, "Exa-mple") == 0);
func0(" Exa 1 2 2 mple", output);
assert(strcmp(output, "-Exa_1_2_2_mple") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 1290 <func0+0xe7>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
jne 11f5 <func0+0x4c>
addl $0x1,-0x1c(%rbp)
jmpq 128c <func0+0xe3>
cmpl $0x1,-0x1c(%rbp)
jne 1211 <func0+0x68>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
cmpl $0x2,-0x1c(%rbp)
jne 1243 <func0+0x9a>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
cmpl $0x2,-0x1c(%rbp)
jle 125f <func0+0xb6>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x2d,(%rax)
movl $0x0,-0x1c(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
cmp %rax,%rbx
jb 11d8 <func0+0x2f>
cmpl $0x1,-0x1c(%rbp)
jne 12c7 <func0+0x11e>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
cmpl $0x2,-0x1c(%rbp)
jne 12f9 <func0+0x150>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x5f,(%rax)
cmpl $0x2,-0x1c(%rbp)
jle 1315 <func0+0x16c>
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x2d,(%rax)
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
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_30], rsi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_1290
loc_11D8:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jnz short loc_11F5
add [rbp+var_1C], 1
jmp loc_128C
loc_11F5:
cmp [rbp+var_1C], 1
jnz short loc_1211
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
loc_1211:
cmp [rbp+var_1C], 2
jnz short loc_1243
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
loc_1243:
cmp [rbp+var_1C], 2
jle short loc_125F
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 2Dh ; '-'
loc_125F:
mov [rbp+var_1C], 0
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
loc_128C:
add [rbp+var_14], 1
loc_1290:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb loc_11D8
cmp [rbp+var_1C], 1
jnz short loc_12C7
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
loc_12C7:
cmp [rbp+var_1C], 2
jnz short loc_12F9
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 5Fh ; '_'
loc_12F9:
cmp [rbp+var_1C], 2
jle short loc_1315
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 2Dh ; '-'
loc_1315:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 0
nop
mov rbx, [rbp+var_8]
leave
retn
|
_BYTE * func0(const char *a1, long long a2)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
_BYTE *result; // rax
int v10; // [rsp+14h] [rbp-1Ch]
int v11; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v10 = 0;
v11 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] == 32 )
{
++v10;
}
else
{
if ( v10 == 1 )
{
v2 = v11++;
*(_BYTE *)(v2 + a2) = 95;
}
if ( v10 == 2 )
{
*(_BYTE *)(v11 + a2) = 95;
v3 = v11 + 1;
v11 += 2;
*(_BYTE *)(v3 + a2) = 95;
}
if ( v10 > 2 )
{
v4 = v11++;
*(_BYTE *)(v4 + a2) = 45;
}
v10 = 0;
v5 = v11++;
*(_BYTE *)(a2 + v5) = a1[i];
}
}
if ( v10 == 1 )
{
v6 = v11++;
*(_BYTE *)(v6 + a2) = 95;
}
if ( v10 == 2 )
{
*(_BYTE *)(v11 + a2) = 95;
v7 = v11 + 1;
v11 += 2;
*(_BYTE *)(v7 + a2) = 95;
}
if ( v10 > 2 )
{
v8 = v11++;
*(_BYTE *)(v8 + a2) = 45;
}
result = (_BYTE *)(v11 + a2);
*result = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101290
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JNZ 0x001011f5
ADD dword ptr [RBP + -0x1c],0x1
JMP 0x0010128c
LAB_001011f5:
CMP dword ptr [RBP + -0x1c],0x1
JNZ 0x00101211
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
LAB_00101211:
CMP dword ptr [RBP + -0x1c],0x2
JNZ 0x00101243
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
LAB_00101243:
CMP dword ptr [RBP + -0x1c],0x2
JLE 0x0010125f
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x2d
LAB_0010125f:
MOV dword ptr [RBP + -0x1c],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
LAB_0010128c:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101290:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101080
CMP RBX,RAX
JC 0x001011d8
CMP dword ptr [RBP + -0x1c],0x1
JNZ 0x001012c7
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
LAB_001012c7:
CMP dword ptr [RBP + -0x1c],0x2
JNZ 0x001012f9
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x5f
LAB_001012f9:
CMP dword ptr [RBP + -0x1c],0x2
JLE 0x00101315
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x2d
LAB_00101315:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
NOP
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= (ulong)(long)local_1c) break;
if (param_1[local_1c] == ' ') {
local_24 = local_24 + 1;
}
else {
if (local_24 == 1) {
*(int *)(param_2 + local_20) = 0x5f;
local_20 = local_20 + 1;
}
if (local_24 == 2) {
iVar1 = local_20 + 1;
*(int *)(param_2 + local_20) = 0x5f;
local_20 = local_20 + 2;
*(int *)(param_2 + iVar1) = 0x5f;
}
if (2 < local_24) {
*(int *)(param_2 + local_20) = 0x2d;
local_20 = local_20 + 1;
}
local_24 = 0;
*(char *)(local_20 + param_2) = param_1[local_1c];
local_20 = local_20 + 1;
}
local_1c = local_1c + 1;
}
if (local_24 == 1) {
*(int *)(param_2 + local_20) = 0x5f;
local_20 = local_20 + 1;
}
if (local_24 == 2) {
iVar1 = local_20 + 1;
*(int *)(param_2 + local_20) = 0x5f;
local_20 = local_20 + 2;
*(int *)(param_2 + iVar1) = 0x5f;
}
if (2 < local_24) {
*(int *)(param_2 + local_20) = 0x2d;
local_20 = local_20 + 1;
}
*(int *)(param_2 + local_20) = 0;
return;
}
|
1,217 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
space_len = 0;
out[j++] = text[i];
}
}
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
out[j] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Yellow_Yellow__Dirty__Fellow") == 0);
func0("Exa mple", output);
assert(strcmp(output, "Exa-mple") == 0);
func0(" Exa 1 2 2 mple", output);
assert(strcmp(output, "-Exa_1_2_2_mple") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%r9
mov $0x0,%r8d
mov $0x0,%edx
mov $0x0,%r10d
mov $0xffffffffffffffff,%r11
mov $0x0,%eax
jmp 11c6 <func0+0x5d>
add $0x1,%r10d
jmp 11c2 <func0+0x59>
lea 0x1(%rdx),%ecx
movslq %edx,%rdx
movb $0x5f,(%rsi,%rdx,1)
jmp 11ad <func0+0x44>
jle 1203 <func0+0x9a>
lea 0x1(%rdx),%ecx
movslq %edx,%rdx
movb $0x2d,(%rsi,%rdx,1)
lea 0x1(%rcx),%edx
movzbl (%r9,%r8,1),%edi
movslq %ecx,%rcx
mov %dil,(%rsi,%rcx,1)
mov $0x0,%r10d
add $0x1,%r8
mov %r11,%rcx
mov %r9,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp %r8,%rcx
jbe 1207 <func0+0x9e>
cmpb $0x20,(%r9,%r8,1)
je 118f <func0+0x26>
cmp $0x1,%r10d
je 1195 <func0+0x2c>
cmp $0x2,%r10d
jne 11a1 <func0+0x38>
movslq %edx,%rcx
movb $0x5f,(%rsi,%rcx,1)
lea 0x2(%rdx),%ecx
add $0x1,%edx
movslq %edx,%rdx
movb $0x5f,(%rsi,%rdx,1)
jmp 11ad <func0+0x44>
mov %edx,%ecx
jmp 11ad <func0+0x44>
cmp $0x1,%r10d
je 1229 <func0+0xc0>
cmp $0x2,%r10d
jne 1235 <func0+0xcc>
movslq %edx,%rax
movb $0x5f,(%rsi,%rax,1)
lea 0x2(%rdx),%eax
add $0x1,%edx
movslq %edx,%rdx
movb $0x5f,(%rsi,%rdx,1)
jmp 1241 <func0+0xd8>
lea 0x1(%rdx),%eax
movslq %edx,%rdx
movb $0x5f,(%rsi,%rdx,1)
jmp 1241 <func0+0xd8>
jle 1248 <func0+0xdf>
lea 0x1(%rdx),%eax
movslq %edx,%rdx
movb $0x2d,(%rsi,%rdx,1)
cltq
movb $0x0,(%rsi,%rax,1)
retq
mov %edx,%eax
jmp 1241 <func0+0xd8>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13, rsi
mov ebp, 0
mov ebx, 0
mov r14d, 0
jmp short loc_1208
loc_11CD:
add r14d, 1
jmp short loc_1204
loc_11D3:
lea eax, [rbx+1]
movsxd rbx, ebx
mov byte ptr [r13+rbx+0], 5Fh ; '_'
jmp short loc_11EF
loc_11E1:
jle short loc_1242
lea eax, [rbx+1]
movsxd rbx, ebx
mov byte ptr [r13+rbx+0], 2Dh ; '-'
loc_11EF:
lea ebx, [rax+1]
movzx edx, byte ptr [r12+rbp]
cdqe
mov [r13+rax+0], dl
mov r14d, 0
loc_1204:
add rbp, 1
loc_1208:
mov rdi, r12; s
call _strlen
cmp rbp, rax
jnb short loc_1246
cmp byte ptr [r12+rbp], 20h ; ' '
jz short loc_11CD
cmp r14d, 1
jz short loc_11D3
cmp r14d, 2
jnz short loc_11E1
movsxd rax, ebx
mov byte ptr [r13+rax+0], 5Fh ; '_'
lea eax, [rbx+2]
add ebx, 1
movsxd rbx, ebx
mov byte ptr [r13+rbx+0], 5Fh ; '_'
jmp short loc_11EF
loc_1242:
mov eax, ebx
jmp short loc_11EF
loc_1246:
cmp r14d, 1
jz short loc_126C
cmp r14d, 2
jnz short loc_127A
movsxd rax, ebx
mov byte ptr [r13+rax+0], 5Fh ; '_'
lea eax, [rbx+2]
add ebx, 1
movsxd rbx, ebx
mov byte ptr [r13+rbx+0], 5Fh ; '_'
jmp short loc_1288
loc_126C:
lea eax, [rbx+1]
movsxd rbx, ebx
mov byte ptr [r13+rbx+0], 5Fh ; '_'
jmp short loc_1288
loc_127A:
jle short loc_1299
lea eax, [rbx+1]
movsxd rbx, ebx
mov byte ptr [r13+rbx+0], 2Dh ; '-'
loc_1288:
cdqe
mov byte ptr [r13+rax+0], 0
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1299:
mov eax, ebx
jmp short loc_1288
|
long long func0(char *s, long long a2)
{
size_t v2; // rbp
int v3; // ebx
int v4; // r14d
int v5; // eax
long long result; // rax
v2 = 0LL;
v3 = 0;
v4 = 0;
while ( v2 < strlen(s) )
{
if ( s[v2] == 32 )
{
++v4;
}
else
{
if ( v4 == 1 )
{
v5 = v3 + 1;
*(_BYTE *)(a2 + v3) = 95;
}
else if ( v4 == 2 )
{
*(_BYTE *)(a2 + v3) = 95;
v5 = v3 + 2;
*(_BYTE *)(a2 + v3 + 1) = 95;
}
else if ( v4 <= 2 )
{
v5 = v3;
}
else
{
v5 = v3 + 1;
*(_BYTE *)(a2 + v3) = 45;
}
v3 = v5 + 1;
*(_BYTE *)(a2 + v5) = s[v2];
v4 = 0;
}
++v2;
}
if ( v4 == 1 )
{
LODWORD(result) = v3 + 1;
*(_BYTE *)(a2 + v3) = 95;
}
else if ( v4 == 2 )
{
*(_BYTE *)(a2 + v3) = 95;
LODWORD(result) = v3 + 2;
*(_BYTE *)(a2 + v3 + 1) = 95;
}
else if ( v4 <= 2 )
{
LODWORD(result) = v3;
}
else
{
LODWORD(result) = v3 + 1;
*(_BYTE *)(a2 + v3) = 45;
}
result = (int)result;
*(_BYTE *)(a2 + (int)result) = 0;
return result;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13,RSI
MOV EBP,0x0
MOV EBX,0x0
MOV R14D,0x0
JMP 0x00101208
LAB_001011cd:
ADD R14D,0x1
JMP 0x00101204
LAB_001011d3:
LEA EAX,[RBX + 0x1]
MOVSXD RBX,EBX
MOV byte ptr [R13 + RBX*0x1],0x5f
JMP 0x001011ef
LAB_001011e1:
JLE 0x00101242
LEA EAX,[RBX + 0x1]
MOVSXD RBX,EBX
MOV byte ptr [R13 + RBX*0x1],0x2d
LAB_001011ef:
LEA EBX,[RAX + 0x1]
MOVZX EDX,byte ptr [R12 + RBP*0x1]
CDQE
MOV byte ptr [R13 + RAX*0x1],DL
MOV R14D,0x0
LAB_00101204:
ADD RBP,0x1
LAB_00101208:
MOV RDI,R12
CALL 0x00101080
CMP RBP,RAX
JNC 0x00101246
CMP byte ptr [R12 + RBP*0x1],0x20
JZ 0x001011cd
CMP R14D,0x1
JZ 0x001011d3
CMP R14D,0x2
JNZ 0x001011e1
MOVSXD RAX,EBX
MOV byte ptr [R13 + RAX*0x1],0x5f
LEA EAX,[RBX + 0x2]
ADD EBX,0x1
MOVSXD RBX,EBX
MOV byte ptr [R13 + RBX*0x1],0x5f
JMP 0x001011ef
LAB_00101242:
MOV EAX,EBX
JMP 0x001011ef
LAB_00101246:
CMP R14D,0x1
JZ 0x0010126c
CMP R14D,0x2
JNZ 0x0010127a
MOVSXD RAX,EBX
MOV byte ptr [R13 + RAX*0x1],0x5f
LEA EAX,[RBX + 0x2]
ADD EBX,0x1
MOVSXD RBX,EBX
MOV byte ptr [R13 + RBX*0x1],0x5f
JMP 0x00101288
LAB_0010126c:
LEA EAX,[RBX + 0x1]
MOVSXD RBX,EBX
MOV byte ptr [R13 + RBX*0x1],0x5f
JMP 0x00101288
LAB_0010127a:
JLE 0x00101299
LEA EAX,[RBX + 0x1]
MOVSXD RBX,EBX
MOV byte ptr [R13 + RBX*0x1],0x2d
LAB_00101288:
CDQE
MOV byte ptr [R13 + RAX*0x1],0x0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101299:
MOV EAX,EBX
JMP 0x00101288
|
void func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
iVar1 = 0;
iVar4 = 0;
for (uVar3 = 0; sVar2 = strlen(param_1), uVar3 < sVar2; uVar3 = uVar3 + 1) {
if (param_1[uVar3] == ' ') {
iVar4 = iVar4 + 1;
}
else {
if (iVar4 == 1) {
*(int *)(param_2 + iVar1) = 0x5f;
iVar1 = iVar1 + 1;
}
else if (iVar4 == 2) {
*(int *)(param_2 + iVar1) = 0x5f;
*(int *)(param_2 + (iVar1 + 1)) = 0x5f;
iVar1 = iVar1 + 2;
}
else if (2 < iVar4) {
*(int *)(param_2 + iVar1) = 0x2d;
iVar1 = iVar1 + 1;
}
*(char *)(param_2 + iVar1) = param_1[uVar3];
iVar4 = 0;
iVar1 = iVar1 + 1;
}
}
if (iVar4 == 1) {
*(int *)(param_2 + iVar1) = 0x5f;
iVar1 = iVar1 + 1;
}
else if (iVar4 == 2) {
*(int *)(param_2 + iVar1) = 0x5f;
*(int *)(param_2 + (iVar1 + 1)) = 0x5f;
iVar1 = iVar1 + 2;
}
else if (2 < iVar4) {
*(int *)(param_2 + iVar1) = 0x2d;
iVar1 = iVar1 + 1;
}
*(int *)(param_2 + iVar1) = 0;
return;
}
|
1,218 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
space_len = 0;
out[j++] = text[i];
}
}
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
out[j] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Yellow_Yellow__Dirty__Fellow") == 0);
func0("Exa mple", output);
assert(strcmp(output, "Exa-mple") == 0);
func0(" Exa 1 2 2 mple", output);
assert(strcmp(output, "-Exa_1_2_2_mple") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
xor %r12d,%r12d
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
callq 1070 <strlen@plt>
xor %edx,%edx
xor %ecx,%ecx
jmp 13da <func0+0x6a>
nopl 0x0(%rax)
lea 0x1(%r12),%ecx
movslq %ecx,%rax
add %r13,%rax
cmp $0x1,%edx
je 1400 <func0+0x90>
cmp $0x2,%edx
jne 13f0 <func0+0x80>
lea 0x2(%r12),%ecx
movb $0x5f,(%rsi)
movb $0x5f,(%rax)
movslq %ecx,%rax
add %r13,%rax
movzbl 0x0(%rbp,%rbx,1),%edx
lea 0x1(%rcx),%r12d
mov %rbp,%rdi
mov %dl,(%rax)
callq 1070 <strlen@plt>
xor %edx,%edx
movslq %r12d,%rcx
add $0x1,%rbx
lea 0x0(%r13,%rcx,1),%rsi
cmp %rbx,%rax
jbe 1408 <func0+0x98>
cmpb $0x20,0x0(%rbp,%rbx,1)
jne 1398 <func0+0x28>
add $0x1,%edx
jmp 13d6 <func0+0x66>
jle 145c <func0+0xec>
movb $0x2d,(%rsi)
jmp 13be <func0+0x4e>
nopw 0x0(%rax,%rax,1)
movb $0x5f,(%rsi)
jmp 13be <func0+0x4e>
nopl (%rax)
cmp $0x1,%edx
je 1450 <func0+0xe0>
cmp $0x2,%edx
jne 1440 <func0+0xd0>
lea 0x1(%r12),%eax
movb $0x5f,(%rsi)
add $0x2,%r12d
cltq
movslq %r12d,%rcx
movb $0x5f,0x0(%r13,%rax,1)
movb $0x0,0x0(%r13,%rcx,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
jle 1429 <func0+0xb9>
add $0x1,%r12d
movb $0x2d,(%rsi)
movslq %r12d,%rcx
jmp 1429 <func0+0xb9>
xchg %ax,%ax
add $0x1,%r12d
movb $0x5f,(%rsi)
movslq %r12d,%rcx
jmp 1429 <func0+0xb9>
mov %rsi,%rax
mov %r12d,%ecx
jmpq 13be <func0+0x4e>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
xor r15d, r15d
push r14
xor r14d, r14d
push r13
mov r13, rdi
push r12
xor r12d, r12d
push rbp
mov rbp, rsi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_13C0
loc_1388:
lea eax, [r15+1]
cmp r12d, 1
jz short loc_13E8
cmp r12d, 2
jnz short loc_13F8
movzx ecx, cs:word_2194
lea eax, [r15+2]
mov [rsi], cx
movzx edx, byte ptr [r13+rbx+0]
loc_13AC:
lea r15d, [rax+1]
cdqe
xor r12d, r12d
mov [rbp+rax+0], dl
movsxd r14, r15d
loc_13BC:
add rbx, 1
loc_13C0:
mov rdi, r13; s
call _strlen
lea rsi, [rbp+r14+0]
cmp rbx, rax
jnb short loc_1408
movzx edx, byte ptr [r13+rbx+0]
cmp dl, 20h ; ' '
jnz short loc_1388
add r12d, 1
jmp short loc_13BC
loc_13E8:
mov byte ptr [rsi], 5Fh ; '_'
movzx edx, byte ptr [r13+rbx+0]
jmp short loc_13AC
loc_13F8:
jle short loc_1460
mov byte ptr [rsi], 2Dh ; '-'
movzx edx, byte ptr [r13+rbx+0]
jmp short loc_13AC
loc_1408:
cmp r12d, 1
jz short loc_1450
cmp r12d, 2
jz short loc_1438
jle short loc_1420
mov byte ptr [rsi], 2Dh ; '-'
add r15d, 1
movsxd r14, r15d
loc_1420:
mov byte ptr [rbp+r14+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1438:
lea eax, [r15+1]
add r15d, 2
mov byte ptr [rsi], 5Fh ; '_'
cdqe
movsxd r14, r15d
mov byte ptr [rbp+rax+0], 5Fh ; '_'
jmp short loc_1420
loc_1450:
add r15d, 1
mov byte ptr [rsi], 5Fh ; '_'
movsxd r14, r15d
jmp short loc_1420
loc_1460:
mov eax, r15d
jmp loc_13AC
|
size_t func0(char *s, long long a2)
{
int v2; // r15d
long long v3; // r14
int v4; // r12d
unsigned long long i; // rbx
int v7; // eax
char v8; // dl
size_t result; // rax
_BYTE *v10; // rsi
v2 = 0;
v3 = 0LL;
v4 = 0;
for ( i = 0LL; ; ++i )
{
result = strlen(s);
v10 = (_BYTE *)(a2 + v3);
if ( i >= result )
break;
v8 = s[i];
if ( v8 == 32 )
{
++v4;
}
else
{
v7 = v2 + 1;
if ( v4 == 1 )
{
*v10 = 95;
v8 = s[i];
}
else if ( v4 == 2 )
{
v7 = v2 + 2;
*(_WORD *)v10 = 24415;
v8 = s[i];
}
else if ( v4 <= 2 )
{
v7 = v2;
}
else
{
*v10 = 45;
v8 = s[i];
}
v2 = v7 + 1;
v4 = 0;
*(_BYTE *)(a2 + v7) = v8;
v3 = v7 + 1;
}
}
if ( v4 == 1 )
{
*v10 = 95;
v3 = v2 + 1;
}
else if ( v4 == 2 )
{
*v10 = 95;
result = v2 + 1;
v3 = v2 + 2;
*(_BYTE *)(a2 + (int)result) = 95;
}
else if ( v4 > 2 )
{
*v10 = 45;
v3 = v2 + 1;
}
*(_BYTE *)(a2 + v3) = 0;
return result;
}
|
func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
XOR R14D,R14D
PUSH R13
MOV R13,RDI
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RSI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001013c0
LAB_00101388:
LEA EAX,[R15 + 0x1]
CMP R12D,0x1
JZ 0x001013e8
CMP R12D,0x2
JNZ 0x001013f8
MOVZX ECX,word ptr [0x00102194]
LEA EAX,[R15 + 0x2]
MOV word ptr [RSI],CX
MOVZX EDX,byte ptr [R13 + RBX*0x1]
LAB_001013ac:
LEA R15D,[RAX + 0x1]
CDQE
XOR R12D,R12D
MOV byte ptr [RBP + RAX*0x1],DL
MOVSXD R14,R15D
LAB_001013bc:
ADD RBX,0x1
LAB_001013c0:
MOV RDI,R13
CALL 0x00101070
LEA RSI,[RBP + R14*0x1]
CMP RBX,RAX
JNC 0x00101408
MOVZX EDX,byte ptr [R13 + RBX*0x1]
CMP DL,0x20
JNZ 0x00101388
ADD R12D,0x1
JMP 0x001013bc
LAB_001013e8:
MOV byte ptr [RSI],0x5f
MOVZX EDX,byte ptr [R13 + RBX*0x1]
JMP 0x001013ac
LAB_001013f8:
JLE 0x00101460
MOV byte ptr [RSI],0x2d
MOVZX EDX,byte ptr [R13 + RBX*0x1]
JMP 0x001013ac
LAB_00101408:
CMP R12D,0x1
JZ 0x00101450
CMP R12D,0x2
JZ 0x00101438
JLE 0x00101420
MOV byte ptr [RSI],0x2d
ADD R15D,0x1
MOVSXD R14,R15D
LAB_00101420:
MOV byte ptr [RBP + R14*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101438:
LEA EAX,[R15 + 0x1]
ADD R15D,0x2
MOV byte ptr [RSI],0x5f
CDQE
MOVSXD R14,R15D
MOV byte ptr [RBP + RAX*0x1],0x5f
JMP 0x00101420
LAB_00101450:
ADD R15D,0x1
MOV byte ptr [RSI],0x5f
MOVSXD R14,R15D
JMP 0x00101420
LAB_00101460:
MOV EAX,R15D
JMP 0x001013ac
|
void func0(char *param_1,long param_2)
{
int2 *puVar1;
int iVar2;
size_t sVar3;
char cVar4;
ulong uVar5;
int iVar6;
long lVar7;
iVar2 = 0;
lVar7 = 0;
iVar6 = 0;
uVar5 = 0;
while( true ) {
sVar3 = strlen(param_1);
puVar1 = (int2 *)(param_2 + lVar7);
if (sVar3 <= uVar5) break;
cVar4 = param_1[uVar5];
if (cVar4 == ' ') {
iVar6 = iVar6 + 1;
}
else {
if (iVar6 == 1) {
*(int *)puVar1 = 0x5f;
cVar4 = param_1[uVar5];
iVar2 = iVar2 + 1;
}
else if (iVar6 == 2) {
*puVar1 = DAT_00102194;
cVar4 = param_1[uVar5];
iVar2 = iVar2 + 2;
}
else if (2 < iVar6) {
*(int *)puVar1 = 0x2d;
cVar4 = param_1[uVar5];
iVar2 = iVar2 + 1;
}
iVar6 = 0;
*(char *)(param_2 + iVar2) = cVar4;
lVar7 = (long)(iVar2 + 1);
iVar2 = iVar2 + 1;
}
uVar5 = uVar5 + 1;
}
if (iVar6 == 1) {
*(int *)puVar1 = 0x5f;
lVar7 = (long)(iVar2 + 1);
}
else if (iVar6 == 2) {
*(int *)puVar1 = 0x5f;
lVar7 = (long)(iVar2 + 2);
*(int *)(param_2 + (iVar2 + 1)) = 0x5f;
}
else if (2 < iVar6) {
*(int *)puVar1 = 0x2d;
lVar7 = (long)(iVar2 + 1);
}
*(int *)(param_2 + lVar7) = 0;
return;
}
|
1,219 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char *text, char *out) {
int space_len = 0;
int j = 0;
for (int i = 0; i < strlen(text); i++) {
if (text[i] == ' ') {
space_len++;
} else {
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
space_len = 0;
out[j++] = text[i];
}
}
if (space_len == 1) out[j++] = '_';
if (space_len == 2) out[j++] = '_', out[j++] = '_';
if (space_len > 2) out[j++] = '-';
out[j] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[100];
func0("Example", output);
assert(strcmp(output, "Example") == 0);
func0("Mudasir Hanif ", output);
assert(strcmp(output, "Mudasir_Hanif_") == 0);
func0("Yellow Yellow Dirty Fellow", output);
assert(strcmp(output, "Yellow_Yellow__Dirty__Fellow") == 0);
func0("Exa mple", output);
assert(strcmp(output, "Exa-mple") == 0);
func0(" Exa 1 2 2 mple", output);
assert(strcmp(output, "-Exa_1_2_2_mple") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %rax,%rax
je 1460 <func0+0xf0>
mov %r13,%rsi
xor %ebx,%ebx
xor %ebp,%ebp
xor %edx,%edx
jmp 13e7 <func0+0x77>
nopl (%rax)
lea 0x1(%rbp),%ecx
movslq %ecx,%rax
add %r13,%rax
cmp $0x1,%edx
je 1400 <func0+0x90>
cmp $0x2,%edx
jne 13f8 <func0+0x88>
lea 0x2(%rbp),%ecx
movb $0x5f,(%rsi)
movb $0x5f,(%rax)
movslq %ecx,%rax
add %r13,%rax
movzbl (%r12,%rbx,1),%edx
mov %r12,%rdi
lea 0x1(%rcx),%ebp
mov %dl,(%rax)
callq 1070 <strlen@plt>
xor %edx,%edx
movslq %ebp,%rcx
add $0x1,%rbx
lea 0x0(%r13,%rcx,1),%rsi
cmp %rax,%rbx
jae 1408 <func0+0x98>
cmpb $0x20,(%r12,%rbx,1)
jne 13a0 <func0+0x30>
add $0x1,%edx
jmp 13d6 <func0+0x66>
nopl 0x0(%rax,%rax,1)
jle 1464 <func0+0xf4>
movb $0x2d,(%rsi)
jmp 13c2 <func0+0x52>
movb $0x5f,(%rsi)
jmp 13c2 <func0+0x52>
nopl (%rax)
cmp $0x1,%edx
je 1450 <func0+0xe0>
cmp $0x2,%edx
jne 1440 <func0+0xd0>
lea 0x1(%rbp),%eax
movb $0x5f,(%rsi)
add $0x2,%ebp
cltq
movslq %ebp,%rcx
movb $0x5f,0x0(%r13,%rax,1)
movb $0x0,0x0(%r13,%rcx,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
jle 1426 <func0+0xb6>
add $0x1,%ebp
movb $0x2d,(%rsi)
movslq %ebp,%rcx
jmp 1426 <func0+0xb6>
nopl (%rax)
add $0x1,%ebp
movb $0x5f,(%rsi)
movslq %ebp,%rcx
jmp 1426 <func0+0xb6>
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
jmp 1426 <func0+0xb6>
mov %rsi,%rax
mov %ebp,%ecx
jmpq 13c2 <func0+0x52>
xchg %ax,%ax
|
func0:
endbr64
push r15
xor r15d, r15d
push r14
xor r14d, r14d
push r13
mov r13, rdi
push r12
xor r12d, r12d
push rbp
mov rbp, rsi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_13C0
loc_1388:
lea eax, [r15+1]
cmp r12d, 1
jz short loc_13E8
cmp r12d, 2
jnz short loc_13F8
movzx ecx, cs:word_2194
lea eax, [r15+2]
mov [rsi], cx
movzx edx, byte ptr [r13+rbx+0]
loc_13AC:
lea r15d, [rax+1]
cdqe
xor r12d, r12d
mov [rbp+rax+0], dl
movsxd r14, r15d
loc_13BC:
add rbx, 1
loc_13C0:
mov rdi, r13; s
call _strlen
lea rsi, [rbp+r14+0]
cmp rbx, rax
jnb short loc_1408
movzx edx, byte ptr [r13+rbx+0]
cmp dl, 20h ; ' '
jnz short loc_1388
add r12d, 1
jmp short loc_13BC
loc_13E8:
mov byte ptr [rsi], 5Fh ; '_'
movzx edx, byte ptr [r13+rbx+0]
jmp short loc_13AC
loc_13F8:
jle short loc_1460
mov byte ptr [rsi], 2Dh ; '-'
movzx edx, byte ptr [r13+rbx+0]
jmp short loc_13AC
loc_1408:
cmp r12d, 1
jz short loc_1450
cmp r12d, 2
jz short loc_1438
jle short loc_1420
mov byte ptr [rsi], 2Dh ; '-'
add r15d, 1
movsxd r14, r15d
loc_1420:
mov byte ptr [rbp+r14+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1438:
lea eax, [r15+1]
add r15d, 2
mov byte ptr [rsi], 5Fh ; '_'
cdqe
movsxd r14, r15d
mov byte ptr [rbp+rax+0], 5Fh ; '_'
jmp short loc_1420
loc_1450:
add r15d, 1
mov byte ptr [rsi], 5Fh ; '_'
movsxd r14, r15d
jmp short loc_1420
loc_1460:
mov eax, r15d
jmp loc_13AC
|
size_t func0(char *s, long long a2)
{
int v2; // r15d
long long v3; // r14
int v4; // r12d
unsigned long long i; // rbx
int v7; // eax
char v8; // dl
size_t result; // rax
_BYTE *v10; // rsi
v2 = 0;
v3 = 0LL;
v4 = 0;
for ( i = 0LL; ; ++i )
{
result = strlen(s);
v10 = (_BYTE *)(a2 + v3);
if ( i >= result )
break;
v8 = s[i];
if ( v8 == 32 )
{
++v4;
}
else
{
v7 = v2 + 1;
if ( v4 == 1 )
{
*v10 = 95;
v8 = s[i];
}
else if ( v4 == 2 )
{
v7 = v2 + 2;
*(_WORD *)v10 = 24415;
v8 = s[i];
}
else if ( v4 <= 2 )
{
v7 = v2;
}
else
{
*v10 = 45;
v8 = s[i];
}
v2 = v7 + 1;
v4 = 0;
*(_BYTE *)(a2 + v7) = v8;
v3 = v7 + 1;
}
}
if ( v4 == 1 )
{
*v10 = 95;
v3 = v2 + 1;
}
else if ( v4 == 2 )
{
*v10 = 95;
result = v2 + 1;
v3 = v2 + 2;
*(_BYTE *)(a2 + (int)result) = 95;
}
else if ( v4 > 2 )
{
*v10 = 45;
v3 = v2 + 1;
}
*(_BYTE *)(a2 + v3) = 0;
return result;
}
|
func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
XOR R14D,R14D
PUSH R13
MOV R13,RDI
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RSI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001013c0
LAB_00101388:
LEA EAX,[R15 + 0x1]
CMP R12D,0x1
JZ 0x001013e8
CMP R12D,0x2
JNZ 0x001013f8
MOVZX ECX,word ptr [0x00102194]
LEA EAX,[R15 + 0x2]
MOV word ptr [RSI],CX
MOVZX EDX,byte ptr [R13 + RBX*0x1]
LAB_001013ac:
LEA R15D,[RAX + 0x1]
CDQE
XOR R12D,R12D
MOV byte ptr [RBP + RAX*0x1],DL
MOVSXD R14,R15D
LAB_001013bc:
ADD RBX,0x1
LAB_001013c0:
MOV RDI,R13
CALL 0x00101070
LEA RSI,[RBP + R14*0x1]
CMP RBX,RAX
JNC 0x00101408
MOVZX EDX,byte ptr [R13 + RBX*0x1]
CMP DL,0x20
JNZ 0x00101388
ADD R12D,0x1
JMP 0x001013bc
LAB_001013e8:
MOV byte ptr [RSI],0x5f
MOVZX EDX,byte ptr [R13 + RBX*0x1]
JMP 0x001013ac
LAB_001013f8:
JLE 0x00101460
MOV byte ptr [RSI],0x2d
MOVZX EDX,byte ptr [R13 + RBX*0x1]
JMP 0x001013ac
LAB_00101408:
CMP R12D,0x1
JZ 0x00101450
CMP R12D,0x2
JZ 0x00101438
JLE 0x00101420
MOV byte ptr [RSI],0x2d
ADD R15D,0x1
MOVSXD R14,R15D
LAB_00101420:
MOV byte ptr [RBP + R14*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101438:
LEA EAX,[R15 + 0x1]
ADD R15D,0x2
MOV byte ptr [RSI],0x5f
CDQE
MOVSXD R14,R15D
MOV byte ptr [RBP + RAX*0x1],0x5f
JMP 0x00101420
LAB_00101450:
ADD R15D,0x1
MOV byte ptr [RSI],0x5f
MOVSXD R14,R15D
JMP 0x00101420
LAB_00101460:
MOV EAX,R15D
JMP 0x001013ac
|
void func0(char *param_1,long param_2)
{
int2 *puVar1;
int iVar2;
size_t sVar3;
char cVar4;
ulong uVar5;
int iVar6;
long lVar7;
iVar2 = 0;
lVar7 = 0;
iVar6 = 0;
uVar5 = 0;
while( true ) {
sVar3 = strlen(param_1);
puVar1 = (int2 *)(param_2 + lVar7);
if (sVar3 <= uVar5) break;
cVar4 = param_1[uVar5];
if (cVar4 == ' ') {
iVar6 = iVar6 + 1;
}
else {
if (iVar6 == 1) {
*(int *)puVar1 = 0x5f;
cVar4 = param_1[uVar5];
iVar2 = iVar2 + 1;
}
else if (iVar6 == 2) {
*puVar1 = DAT_00102194;
cVar4 = param_1[uVar5];
iVar2 = iVar2 + 2;
}
else if (2 < iVar6) {
*(int *)puVar1 = 0x2d;
cVar4 = param_1[uVar5];
iVar2 = iVar2 + 1;
}
iVar6 = 0;
*(char *)(param_2 + iVar2) = cVar4;
lVar7 = (long)(iVar2 + 1);
iVar2 = iVar2 + 1;
}
uVar5 = uVar5 + 1;
}
if (iVar6 == 1) {
*(int *)puVar1 = 0x5f;
lVar7 = (long)(iVar2 + 1);
}
else if (iVar6 == 2) {
*(int *)puVar1 = 0x5f;
lVar7 = (long)(iVar2 + 2);
*(int *)(param_2 + (iVar2 + 1)) = 0x5f;
}
else if (2 < iVar6) {
*(int *)puVar1 = 0x2d;
lVar7 = (long)(iVar2 + 1);
}
*(int *)(param_2 + lVar7) = 0;
return;
}
|
1,220 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0 && strcmp(last, ".exe") != 0 && strcmp(last, ".dll") != 0) return "No";
for (int i = 0; i < length; i++) {
if (file_name[i] >= '0' && file_name[i] <= '9') num_digit++;
if (file_name[i] == '.') num_dot++;
}
if (num_digit > 3 || num_dot != 1) return "No";
return "Yes";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
assert(strcmp(func0("His12FILE94.exe"), "No") == 0);
assert(strcmp(func0("_Y.txt"), "No") == 0);
assert(strcmp(func0("?aREYA.exe"), "No") == 0);
assert(strcmp(func0("/this_is_valid.dll"), "No") == 0);
assert(strcmp(func0("this_is_valid.wow"), "No") == 0);
assert(strcmp(func0("this_is_valid.txt"), "Yes") == 0);
assert(strcmp(func0("this_is_valid.txtexe"), "No") == 0);
assert(strcmp(func0("#this2_i4s_5valid.ten"), "No") == 0);
assert(strcmp(func0("@this1_is6_valid.exe"), "No") == 0);
assert(strcmp(func0("this_is_12valid.6exe4.txt"), "No") == 0);
assert(strcmp(func0("all.exe.txt"), "No") == 0);
assert(strcmp(func0("I563_No.exe"), "Yes") == 0);
assert(strcmp(func0("Is3youfault.txt"), "Yes") == 0);
assert(strcmp(func0("no_one#knows.dll"), "Yes") == 0);
assert(strcmp(func0("1I563_Yes3.exe"), "No") == 0);
assert(strcmp(func0("I563_Yes3.txtt"), "No") == 0);
assert(strcmp(func0("final..txt"), "No") == 0);
assert(strcmp(func0("final132"), "No") == 0);
assert(strcmp(func0("_f4indsartal132."), "No") == 0);
assert(strcmp(func0(".txt"), "No") == 0);
assert(strcmp(func0("s."), "No") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0xc(%rbp)
cmpl $0x4,-0xc(%rbp)
jg 11c8 <func0+0x3f>
lea 0xe45(%rip),%rax
jmpq 12cd <func0+0x144>
mov -0x28(%rbp),%rax
movzbl (%rax),%eax
mov %al,-0x19(%rbp)
cmpb $0x40,-0x19(%rbp)
jle 11ea <func0+0x61>
cmpb $0x5a,-0x19(%rbp)
jle 11e4 <func0+0x5b>
cmpb $0x60,-0x19(%rbp)
jle 11ea <func0+0x61>
cmpb $0x7a,-0x19(%rbp)
jle 11f6 <func0+0x6d>
lea 0xe17(%rip),%rax
jmpq 12cd <func0+0x144>
mov -0xc(%rbp),%eax
cltq
lea -0x4(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
lea 0xdf6(%rip),%rsi
mov %rax,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1258 <func0+0xcf>
mov -0x8(%rbp),%rax
lea 0xde4(%rip),%rsi
mov %rax,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1258 <func0+0xcf>
mov -0x8(%rbp),%rax
lea 0xdd2(%rip),%rsi
mov %rax,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1258 <func0+0xcf>
lea 0xdb2(%rip),%rax
jmp 12cd <func0+0x144>
movl $0x0,-0x10(%rbp)
jmp 12a9 <func0+0x120>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jle 128d <func0+0x104>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x39,%al
jg 128d <func0+0x104>
addl $0x1,-0x18(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2e,%al
jne 12a5 <func0+0x11c>
addl $0x1,-0x14(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jl 1261 <func0+0xd8>
cmpl $0x3,-0x18(%rbp)
jg 12bd <func0+0x134>
cmpl $0x1,-0x14(%rbp)
je 12c6 <func0+0x13d>
lea 0xd44(%rip),%rax
jmp 12cd <func0+0x144>
lea 0xd4d(%rip),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
cmp [rbp+var_C], 4
jg short loc_11C8
lea rax, aNo; "No"
jmp locret_12D6
loc_11C8:
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
mov [rbp+var_19], al
cmp [rbp+var_19], 40h ; '@'
jle short loc_11EA
cmp [rbp+var_19], 5Ah ; 'Z'
jle short loc_11E4
cmp [rbp+var_19], 60h ; '`'
jle short loc_11EA
loc_11E4:
cmp [rbp+var_19], 7Ah ; 'z'
jle short loc_11F6
loc_11EA:
lea rax, aNo; "No"
jmp locret_12D6
loc_11F6:
mov eax, [rbp+var_C]
cdqe
lea rdx, [rax-4]
mov rax, [rbp+s]
add rax, rdx
mov [rbp+s1], rax
mov rax, [rbp+s1]
lea rdx, s2; ".txt"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1261
mov rax, [rbp+s1]
lea rdx, aExe; ".exe"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1261
mov rax, [rbp+s1]
lea rdx, aDll; ".dll"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1261
lea rax, aNo; "No"
jmp short locret_12D6
loc_1261:
mov [rbp+var_10], 0
jmp short loc_12B2
loc_126A:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jle short loc_1296
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 39h ; '9'
jg short loc_1296
add [rbp+var_18], 1
loc_1296:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Eh ; '.'
jnz short loc_12AE
add [rbp+var_14], 1
loc_12AE:
add [rbp+var_10], 1
loc_12B2:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jl short loc_126A
cmp [rbp+var_18], 3
jg short loc_12C6
cmp [rbp+var_14], 1
jz short loc_12CF
loc_12C6:
lea rax, aNo; "No"
jmp short locret_12D6
loc_12CF:
lea rax, aYes; "Yes"
locret_12D6:
leave
retn
|
const char * func0(const char *a1)
{
char v2; // [rsp+17h] [rbp-19h]
int v3; // [rsp+18h] [rbp-18h]
int v4; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v6; // [rsp+24h] [rbp-Ch]
char *s1; // [rsp+28h] [rbp-8h]
v3 = 0;
v4 = 0;
v6 = strlen(a1);
if ( v6 <= 4 )
return "No";
v2 = *a1;
if ( *a1 <= 64 || v2 > 90 && v2 <= 96 || v2 > 122 )
return "No";
s1 = (char *)&a1[v6 - 4];
if ( strcmp(s1, ".txt") && strcmp(s1, ".exe") && strcmp(s1, ".dll") )
return "No";
for ( i = 0; i < v6; ++i )
{
if ( a1[i] > 47 && a1[i] <= 57 )
++v3;
if ( a1[i] == 46 )
++v4;
}
if ( v3 <= 3 && v4 == 1 )
return "Yes";
else
return "No";
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0x4
JG 0x001011c8
LEA RAX,[0x102008]
JMP 0x001012d6
LAB_001011c8:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
CMP byte ptr [RBP + -0x19],0x40
JLE 0x001011ea
CMP byte ptr [RBP + -0x19],0x5a
JLE 0x001011e4
CMP byte ptr [RBP + -0x19],0x60
JLE 0x001011ea
LAB_001011e4:
CMP byte ptr [RBP + -0x19],0x7a
JLE 0x001011f6
LAB_001011ea:
LEA RAX,[0x102008]
JMP 0x001012d6
LAB_001011f6:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x10200b]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101261
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102010]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101261
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102015]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101261
LEA RAX,[0x102008]
JMP 0x001012d6
LAB_00101261:
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012b2
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JLE 0x00101296
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x39
JG 0x00101296
ADD dword ptr [RBP + -0x18],0x1
LAB_00101296:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2e
JNZ 0x001012ae
ADD dword ptr [RBP + -0x14],0x1
LAB_001012ae:
ADD dword ptr [RBP + -0x10],0x1
LAB_001012b2:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JL 0x0010126a
CMP dword ptr [RBP + -0x18],0x3
JG 0x001012c6
CMP dword ptr [RBP + -0x14],0x1
JZ 0x001012cf
LAB_001012c6:
LEA RAX,[0x102008]
JMP 0x001012d6
LAB_001012cf:
LEA RAX,[0x10201a]
LAB_001012d6:
LEAVE
RET
|
int * func0(char *param_1)
{
char cVar1;
int iVar2;
int iVar3;
size_t sVar4;
int *puVar5;
char *__s1;
int local_20;
int local_1c;
int local_18;
local_20 = 0;
local_1c = 0;
sVar4 = strlen(param_1);
iVar2 = (int)sVar4;
if (iVar2 < 5) {
puVar5 = &DAT_00102008;
}
else {
cVar1 = *param_1;
if ((cVar1 < 'A') || ((('Z' < cVar1 && (cVar1 < 'a')) || ('z' < cVar1)))) {
puVar5 = &DAT_00102008;
}
else {
__s1 = param_1 + (long)iVar2 + -4;
iVar3 = strcmp(__s1,".txt");
if (((iVar3 != 0) && (iVar3 = strcmp(__s1,".exe"), iVar3 != 0)) &&
(iVar3 = strcmp(__s1,".dll"), iVar3 != 0)) {
return &DAT_00102008;
}
for (local_18 = 0; local_18 < iVar2; local_18 = local_18 + 1) {
if (('/' < param_1[local_18]) && (param_1[local_18] < ':')) {
local_20 = local_20 + 1;
}
if (param_1[local_18] == '.') {
local_1c = local_1c + 1;
}
}
if ((local_20 < 4) && (local_1c == 1)) {
puVar5 = &DAT_0010201a;
}
else {
puVar5 = &DAT_00102008;
}
}
}
return puVar5;
}
|
1,221 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0 && strcmp(last, ".exe") != 0 && strcmp(last, ".dll") != 0) return "No";
for (int i = 0; i < length; i++) {
if (file_name[i] >= '0' && file_name[i] <= '9') num_digit++;
if (file_name[i] == '.') num_dot++;
}
if (num_digit > 3 || num_dot != 1) return "No";
return "Yes";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
assert(strcmp(func0("His12FILE94.exe"), "No") == 0);
assert(strcmp(func0("_Y.txt"), "No") == 0);
assert(strcmp(func0("?aREYA.exe"), "No") == 0);
assert(strcmp(func0("/this_is_valid.dll"), "No") == 0);
assert(strcmp(func0("this_is_valid.wow"), "No") == 0);
assert(strcmp(func0("this_is_valid.txt"), "Yes") == 0);
assert(strcmp(func0("this_is_valid.txtexe"), "No") == 0);
assert(strcmp(func0("#this2_i4s_5valid.ten"), "No") == 0);
assert(strcmp(func0("@this1_is6_valid.exe"), "No") == 0);
assert(strcmp(func0("this_is_12valid.6exe4.txt"), "No") == 0);
assert(strcmp(func0("all.exe.txt"), "No") == 0);
assert(strcmp(func0("I563_No.exe"), "Yes") == 0);
assert(strcmp(func0("Is3youfault.txt"), "Yes") == 0);
assert(strcmp(func0("no_one#knows.dll"), "Yes") == 0);
assert(strcmp(func0("1I563_Yes3.exe"), "No") == 0);
assert(strcmp(func0("I563_Yes3.txtt"), "No") == 0);
assert(strcmp(func0("final..txt"), "No") == 0);
assert(strcmp(func0("final132"), "No") == 0);
assert(strcmp(func0("_f4indsartal132."), "No") == 0);
assert(strcmp(func0(".txt"), "No") == 0);
assert(strcmp(func0("s."), "No") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
lea 0xe95(%rip),%rdx
cmp $0x4,%eax
jle 124f <func0+0x106>
movzbl (%r8),%edx
lea -0x5b(%rdx),%ecx
cmp $0x5,%cl
jbe 1248 <func0+0xff>
sub $0x41,%edx
cmp $0x39,%dl
ja 1248 <func0+0xff>
movslq %eax,%rdx
lea -0x4(%r8,%rdx,1),%r9
mov $0x5,%ecx
lea 0xfab(%rip),%rdi
mov %r9,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 11f4 <func0+0xab>
mov $0x5,%ecx
lea 0xe7b(%rip),%rdi
mov %r9,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 11f4 <func0+0xab>
mov $0x5,%ecx
lea 0xe52(%rip),%rdi
mov %r9,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %cl
sbb $0x0,%cl
lea 0xe14(%rip),%rdx
test %cl,%cl
jne 124f <func0+0x106>
mov %r8,%rdx
lea -0x1(%rax),%eax
lea 0x1(%r8,%rax,1),%r8
mov $0x0,%edi
mov $0x0,%esi
jmp 121e <func0+0xd5>
cmp $0x2e,%al
sete %al
movzbl %al,%eax
add %eax,%edi
add $0x1,%rdx
cmp %r8,%rdx
je 122e <func0+0xe5>
movzbl (%rdx),%eax
lea -0x30(%rax),%ecx
cmp $0x9,%cl
ja 120b <func0+0xc2>
add $0x1,%esi
jmp 1215 <func0+0xcc>
cmp $0x3,%esi
jg 123f <func0+0xf6>
lea 0xdcd(%rip),%rdx
cmp $0x1,%edi
je 124f <func0+0x106>
lea 0xdbe(%rip),%rdx
jmp 124f <func0+0x106>
lea 0xdb5(%rip),%rdx
mov %rdx,%rax
retq
|
func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
mov rbp, rax
lea rax, aNo; "No"
cmp ebp, 4
jle loc_126C
movzx eax, byte ptr [rbx]
lea edx, [rax-5Bh]
cmp dl, 5
jbe loc_1265
sub eax, 41h ; 'A'
cmp al, 39h ; '9'
ja loc_1265
movsxd rax, ebp
lea r12, [rbx+rax-4]
lea rsi, aFinalTxt+6; s2
mov rdi, r12; s1
call _strcmp
test eax, eax
jz short loc_1210
lea rsi, aMy16file3Exe+9; s2
mov rdi, r12; s1
call _strcmp
test eax, eax
jz short loc_1210
lea rsi, aKDll+1; s2
mov rdi, r12; s1
call _strcmp
mov edx, eax
lea rax, aNo; "No"
test edx, edx
jnz short loc_126C
loc_1210:
mov rax, rbx
lea edx, [rbp-1]
lea r8, [rbx+rdx+1]
mov edi, 0
mov esi, 0
jmp short loc_123B
loc_1227:
cmp dl, 2Eh ; '.'
setz dl
movzx edx, dl
add edi, edx
loc_1232:
add rax, 1
cmp rax, r8
jz short loc_124B
loc_123B:
movzx edx, byte ptr [rax]
lea ecx, [rdx-30h]
cmp cl, 9
ja short loc_1227
add esi, 1
jmp short loc_1232
loc_124B:
cmp esi, 3
jg short loc_125C
lea rax, s2; "Yes"
cmp edi, 1
jz short loc_126C
loc_125C:
lea rax, aNo; "No"
jmp short loc_126C
loc_1265:
lea rax, aNo; "No"
loc_126C:
pop rbx
pop rbp
pop r12
retn
|
const char * func0(const char *a1)
{
int v2; // ebp
const char *result; // rax
int v4; // edx
const char *v5; // rax
int v6; // edi
int v7; // esi
v2 = strlen(a1);
result = "No";
if ( v2 > 4 )
{
if ( (unsigned __int8)(*a1 - 91) <= 5u || (unsigned __int8)(*a1 - 65) > 0x39u )
{
return "No";
}
else if ( !strcmp(&a1[v2 - 4], ".txt")
|| !strcmp(&a1[v2 - 4], ".exe")
|| (v4 = strcmp(&a1[v2 - 4], ".dll"), result = "No", !v4) )
{
v5 = a1;
v6 = 0;
v7 = 0;
do
{
if ( (unsigned __int8)(*v5 - 48) > 9u )
v6 += *v5 == 46;
else
++v7;
++v5;
}
while ( v5 != &a1[v2 - 1 + 1] );
if ( v7 > 3 )
return "No";
result = "Yes";
if ( v6 != 1 )
return "No";
}
}
return result;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x00101070
MOV RBP,RAX
LEA RAX,[0x102004]
CMP EBP,0x4
JLE 0x0010126c
MOVZX EAX,byte ptr [RBX]
LEA EDX,[RAX + -0x5b]
CMP DL,0x5
JBE 0x00101265
SUB EAX,0x41
CMP AL,0x39
JA 0x00101265
MOVSXD RAX,EBP
LEA R12,[RBX + RAX*0x1 + -0x4]
LEA RSI,[0x102153]
MOV RDI,R12
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101210
LEA RSI,[0x10203e]
MOV RDI,R12
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101210
LEA RSI,[0x102030]
MOV RDI,R12
CALL 0x00101090
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JNZ 0x0010126c
LAB_00101210:
MOV RAX,RBX
LEA EDX,[RBP + -0x1]
LEA R8,[RBX + RDX*0x1 + 0x1]
MOV EDI,0x0
MOV ESI,0x0
JMP 0x0010123b
LAB_00101227:
CMP DL,0x2e
SETZ DL
MOVZX EDX,DL
ADD EDI,EDX
LAB_00101232:
ADD RAX,0x1
CMP RAX,R8
JZ 0x0010124b
LAB_0010123b:
MOVZX EDX,byte ptr [RAX]
LEA ECX,[RDX + -0x30]
CMP CL,0x9
JA 0x00101227
ADD ESI,0x1
JMP 0x00101232
LAB_0010124b:
CMP ESI,0x3
JG 0x0010125c
LEA RAX,[0x102007]
CMP EDI,0x1
JZ 0x0010126c
LAB_0010125c:
LEA RAX,[0x102004]
JMP 0x0010126c
LAB_00101265:
LEA RAX,[0x102004]
LAB_0010126c:
POP RBX
POP RBP
POP R12
RET
|
int * func0(char *param_1)
{
char *pcVar1;
int iVar2;
size_t sVar3;
int *puVar4;
int iVar5;
sVar3 = strlen(param_1);
puVar4 = &DAT_00102004;
iVar5 = (int)sVar3;
if (4 < iVar5) {
if (((byte)(*param_1 + 0xa5U) < 6) || (0x39 < (byte)(*param_1 + 0xbfU))) {
puVar4 = &DAT_00102004;
}
else {
pcVar1 = param_1 + (long)iVar5 + -4;
iVar2 = strcmp(pcVar1,".txt");
if (((iVar2 != 0) && (iVar2 = strcmp(pcVar1,".exe"), iVar2 != 0)) &&
(iVar2 = strcmp(pcVar1,".dll"), iVar2 != 0)) {
return &DAT_00102004;
}
pcVar1 = param_1 + (ulong)(iVar5 - 1) + 1;
iVar2 = 0;
iVar5 = 0;
do {
if ((byte)(*param_1 - 0x30U) < 10) {
iVar5 = iVar5 + 1;
}
else {
iVar2 = iVar2 + (uint)(*param_1 == '.');
}
param_1 = param_1 + 1;
} while (param_1 != pcVar1);
if ((3 < iVar5) || (puVar4 = &DAT_00102007, iVar2 != 1)) {
puVar4 = &DAT_00102004;
}
}
}
return puVar4;
}
|
1,222 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0 && strcmp(last, ".exe") != 0 && strcmp(last, ".dll") != 0) return "No";
for (int i = 0; i < length; i++) {
if (file_name[i] >= '0' && file_name[i] <= '9') num_digit++;
if (file_name[i] == '.') num_dot++;
}
if (num_digit > 3 || num_dot != 1) return "No";
return "Yes";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
assert(strcmp(func0("His12FILE94.exe"), "No") == 0);
assert(strcmp(func0("_Y.txt"), "No") == 0);
assert(strcmp(func0("?aREYA.exe"), "No") == 0);
assert(strcmp(func0("/this_is_valid.dll"), "No") == 0);
assert(strcmp(func0("this_is_valid.wow"), "No") == 0);
assert(strcmp(func0("this_is_valid.txt"), "Yes") == 0);
assert(strcmp(func0("this_is_valid.txtexe"), "No") == 0);
assert(strcmp(func0("#this2_i4s_5valid.ten"), "No") == 0);
assert(strcmp(func0("@this1_is6_valid.exe"), "No") == 0);
assert(strcmp(func0("this_is_12valid.6exe4.txt"), "No") == 0);
assert(strcmp(func0("all.exe.txt"), "No") == 0);
assert(strcmp(func0("I563_No.exe"), "Yes") == 0);
assert(strcmp(func0("Is3youfault.txt"), "Yes") == 0);
assert(strcmp(func0("no_one#knows.dll"), "Yes") == 0);
assert(strcmp(func0("1I563_Yes3.exe"), "No") == 0);
assert(strcmp(func0("I563_Yes3.txtt"), "No") == 0);
assert(strcmp(func0("final..txt"), "No") == 0);
assert(strcmp(func0("final132"), "No") == 0);
assert(strcmp(func0("_f4indsartal132."), "No") == 0);
assert(strcmp(func0(".txt"), "No") == 0);
assert(strcmp(func0("s."), "No") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
lea 0x810(%rip),%r8
cmp $0x4,%eax
jle 188b <func0+0xab>
movzbl (%rbx),%edx
lea -0x5b(%rdx),%ecx
cmp $0x5,%cl
jbe 1890 <func0+0xb0>
sub $0x41,%edx
cmp $0x39,%dl
ja 1890 <func0+0xb0>
movslq %eax,%rdx
mov $0x5,%ecx
lea 0x930(%rip),%rdi
lea -0x4(%rbx,%rdx,1),%r9
mov %r9,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
jne 18a0 <func0+0xc0>
sub $0x1,%eax
mov %rbx,%rdi
xor %esi,%esi
xor %ecx,%ecx
lea 0x1(%rbx,%rax,1),%r8
jmp 185c <func0+0x7c>
nopl 0x0(%rax,%rax,1)
add $0x1,%rdi
add $0x1,%ecx
cmp %rdi,%r8
je 187a <func0+0x9a>
movzbl (%rdi),%eax
lea -0x30(%rax),%edx
cmp $0x9,%dl
jbe 1850 <func0+0x70>
cmp $0x2e,%al
sete %al
add $0x1,%rdi
movzbl %al,%eax
add %eax,%esi
cmp %rdi,%r8
jne 185c <func0+0x7c>
cmp $0x3,%ecx
jg 1890 <func0+0xb0>
lea 0x781(%rip),%r8
cmp $0x1,%esi
jne 1890 <func0+0xb0>
mov %r8,%rax
pop %rbx
retq
lea 0x76d(%rip),%r8
pop %rbx
mov %r8,%rax
retq
nopl 0x0(%rax)
mov $0x5,%ecx
lea 0x792(%rip),%rdi
mov %r9,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 1837 <func0+0x57>
mov $0x5,%ecx
lea 0x765(%rip),%rdi
mov %r9,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 1837 <func0+0x57>
jmp 188b <func0+0xab>
|
func0:
endbr64
push r13
push r12
lea r12, unk_2004
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
cmp eax, 4
jle loc_187C
mov rbp, rax
movzx eax, byte ptr [rbx]
lea edx, [rax-5Bh]
cmp dl, 5
jbe loc_1890
sub eax, 41h ; 'A'
cmp al, 39h ; '9'
ja loc_1890
movsxd rax, ebp
lea rsi, aFinalTxt+6; s2
lea r13, [rbx+rax-4]
mov rdi, r13; s1
call _strcmp
test eax, eax
jnz short loc_18A8
loc_182E:
lea edx, [rbp-1]
mov rax, rbx
xor edi, edi
xor esi, esi
lea r8, [rbx+rdx+1]
jmp short loc_1854
loc_1840:
cmp dl, 2Eh ; '.'
setz dl
add rax, 1
movzx edx, dl
add edi, edx
cmp r8, rax
jz short loc_186B
loc_1854:
movzx edx, byte ptr [rax]
lea ecx, [rdx-30h]
cmp cl, 9
ja short loc_1840
add rax, 1
add esi, 1
cmp r8, rax
jnz short loc_1854
loc_186B:
cmp esi, 3
jg short loc_1890
lea r12, s2; "Yes"
cmp edi, 1
jnz short loc_1890
loc_187C:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1890:
add rsp, 8
lea r12, unk_2004
pop rbx
mov rax, r12
pop rbp
pop r12
pop r13
retn
loc_18A8:
lea rsi, aMy16file3Exe+9; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jz loc_182E
lea rsi, aKDll+1; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jz loc_182E
jmp short loc_187C
|
const char * func0(const char *a1)
{
const char *v1; // r12
int v3; // eax
int v4; // ebp
const char *v5; // rax
int v6; // edi
int v7; // esi
long long v8; // r8
char v9; // dl
v1 = (const char *)&unk_2004;
v3 = strlen(a1);
if ( v3 <= 4 )
return v1;
v4 = v3;
if ( (unsigned __int8)(*a1 - 91) <= 5u || (unsigned __int8)(*a1 - 65) > 0x39u )
return (const char *)&unk_2004;
if ( strcmp(&a1[v3 - 4], ".txt") && strcmp(&a1[v4 - 4], ".exe") && strcmp(&a1[v4 - 4], ".dll") )
return v1;
v5 = a1;
v6 = 0;
v7 = 0;
v8 = (long long)&a1[v4 - 1 + 1];
do
{
while ( 1 )
{
v9 = *v5;
if ( (unsigned __int8)(*v5 - 48) <= 9u )
break;
++v5;
v6 += v9 == 46;
if ( (const char *)v8 == v5 )
goto LABEL_9;
}
++v5;
++v7;
}
while ( (const char *)v8 != v5 );
LABEL_9:
if ( v7 > 3 )
return (const char *)&unk_2004;
v1 = "Yes";
if ( v6 != 1 )
return (const char *)&unk_2004;
else
return v1;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
LEA R12,[0x102004]
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
CMP EAX,0x4
JLE 0x0010187c
MOV RBP,RAX
MOVZX EAX,byte ptr [RBX]
LEA EDX,[RAX + -0x5b]
CMP DL,0x5
JBE 0x00101890
SUB EAX,0x41
CMP AL,0x39
JA 0x00101890
MOVSXD RAX,EBP
LEA RSI,[0x102153]
LEA R13,[RBX + RAX*0x1 + -0x4]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JNZ 0x001018a8
LAB_0010182e:
LEA EDX,[RBP + -0x1]
MOV RAX,RBX
XOR EDI,EDI
XOR ESI,ESI
LEA R8,[RBX + RDX*0x1 + 0x1]
JMP 0x00101854
LAB_00101840:
CMP DL,0x2e
SETZ DL
ADD RAX,0x1
MOVZX EDX,DL
ADD EDI,EDX
CMP R8,RAX
JZ 0x0010186b
LAB_00101854:
MOVZX EDX,byte ptr [RAX]
LEA ECX,[RDX + -0x30]
CMP CL,0x9
JA 0x00101840
ADD RAX,0x1
ADD ESI,0x1
CMP R8,RAX
JNZ 0x00101854
LAB_0010186b:
CMP ESI,0x3
JG 0x00101890
LEA R12,[0x102007]
CMP EDI,0x1
JNZ 0x00101890
LAB_0010187c:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101890:
ADD RSP,0x8
LEA R12,[0x102004]
POP RBX
MOV RAX,R12
POP RBP
POP R12
POP R13
RET
LAB_001018a8:
LEA RSI,[0x10203e]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JZ 0x0010182e
LEA RSI,[0x102030]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JZ 0x0010182e
JMP 0x0010187c
|
int * func0(char *param_1)
{
char *pcVar1;
char cVar2;
int iVar3;
int iVar4;
size_t sVar5;
int iVar6;
int *puVar7;
puVar7 = &DAT_00102004;
sVar5 = strlen(param_1);
iVar3 = (int)sVar5;
if (4 < iVar3) {
if (((byte)(*param_1 + 0xa5U) < 6) || (0x39 < (byte)(*param_1 + 0xbfU))) {
LAB_00101890:
return &DAT_00102004;
}
pcVar1 = param_1 + (long)iVar3 + -4;
iVar4 = strcmp(pcVar1,".txt");
if ((iVar4 == 0) ||
((iVar4 = strcmp(pcVar1,".exe"), iVar4 == 0 || (iVar4 = strcmp(pcVar1,".dll"), iVar4 == 0))))
{
iVar6 = 0;
iVar4 = 0;
pcVar1 = param_1 + (ulong)(iVar3 - 1) + 1;
do {
while (cVar2 = *param_1, 9 < (byte)(cVar2 - 0x30U)) {
param_1 = param_1 + 1;
iVar6 = iVar6 + (uint)(cVar2 == '.');
if (pcVar1 == param_1) goto LAB_0010186b;
}
param_1 = param_1 + 1;
iVar4 = iVar4 + 1;
} while (pcVar1 != param_1);
LAB_0010186b:
if ((3 < iVar4) || (puVar7 = &DAT_00102007, iVar6 != 1)) goto LAB_00101890;
}
}
return puVar7;
}
|
1,223 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char* func0(const char* file_name) {
int num_digit = 0, num_dot = 0;
int length = strlen(file_name);
if (length < 5) return "No";
char w = file_name[0];
if (w < 'A' || (w > 'Z' && w < 'a') || w > 'z') return "No";
const char* last = file_name + length - 4;
if (strcmp(last, ".txt") != 0 && strcmp(last, ".exe") != 0 && strcmp(last, ".dll") != 0) return "No";
for (int i = 0; i < length; i++) {
if (file_name[i] >= '0' && file_name[i] <= '9') num_digit++;
if (file_name[i] == '.') num_dot++;
}
if (num_digit > 3 || num_dot != 1) return "No";
return "Yes";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("example.txt"), "Yes") == 0);
assert(strcmp(func0("1example.dll"), "No") == 0);
assert(strcmp(func0("s1sdf3.asd"), "No") == 0);
assert(strcmp(func0("K.dll"), "Yes") == 0);
assert(strcmp(func0("MY16FILE3.exe"), "Yes") == 0);
assert(strcmp(func0("His12FILE94.exe"), "No") == 0);
assert(strcmp(func0("_Y.txt"), "No") == 0);
assert(strcmp(func0("?aREYA.exe"), "No") == 0);
assert(strcmp(func0("/this_is_valid.dll"), "No") == 0);
assert(strcmp(func0("this_is_valid.wow"), "No") == 0);
assert(strcmp(func0("this_is_valid.txt"), "Yes") == 0);
assert(strcmp(func0("this_is_valid.txtexe"), "No") == 0);
assert(strcmp(func0("#this2_i4s_5valid.ten"), "No") == 0);
assert(strcmp(func0("@this1_is6_valid.exe"), "No") == 0);
assert(strcmp(func0("this_is_12valid.6exe4.txt"), "No") == 0);
assert(strcmp(func0("all.exe.txt"), "No") == 0);
assert(strcmp(func0("I563_No.exe"), "Yes") == 0);
assert(strcmp(func0("Is3youfault.txt"), "Yes") == 0);
assert(strcmp(func0("no_one#knows.dll"), "Yes") == 0);
assert(strcmp(func0("1I563_Yes3.exe"), "No") == 0);
assert(strcmp(func0("I563_Yes3.txtt"), "No") == 0);
assert(strcmp(func0("final..txt"), "No") == 0);
assert(strcmp(func0("final132"), "No") == 0);
assert(strcmp(func0("_f4indsartal132."), "No") == 0);
assert(strcmp(func0(".txt"), "No") == 0);
assert(strcmp(func0("s."), "No") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
lea 0x810(%rip),%r9
cmp $0x4,%eax
jle 1c8f <func0+0x4af>
movzbl (%rbx),%edx
lea -0x5b(%rdx),%ecx
cmp $0x5,%cl
jbe 1c88 <func0+0x4a8>
lea -0x41(%rdx),%ecx
cmp $0x39,%cl
ja 1c88 <func0+0x4a8>
movslq %eax,%rcx
lea 0x931(%rip),%rdi
lea -0x4(%rbx,%rcx,1),%r8
mov $0x5,%ecx
mov %r8,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %cl
sbb $0x0,%cl
test %cl,%cl
jne 1c98 <func0+0x4b8>
lea -0x1(%rax),%ecx
cmp $0xe,%ecx
jbe 1d90 <func0+0x5b0>
mov %eax,%ecx
pxor %xmm2,%xmm2
movdqa 0xe26(%rip),%xmm8
movdqa 0xe2e(%rip),%xmm7
shr $0x4,%ecx
movdqa %xmm2,%xmm10
pxor %xmm4,%xmm4
mov %rbx,%rdx
shl $0x4,%rcx
movdqa 0xe23(%rip),%xmm6
movdqa 0xe2b(%rip),%xmm5
pxor %xmm3,%xmm3
add %rbx,%rcx
nopl 0x0(%rax)
movdqu (%rdx),%xmm0
movdqu (%rdx),%xmm9
movdqa %xmm4,%xmm11
add $0x10,%rdx
paddb %xmm8,%xmm0
pcmpeqb %xmm6,%xmm9
psubusb %xmm7,%xmm0
pcmpeqb %xmm4,%xmm0
movdqa %xmm0,%xmm1
pand %xmm5,%xmm0
pcmpeqb %xmm4,%xmm1
pand %xmm9,%xmm1
pcmpgtb %xmm1,%xmm11
movdqa %xmm1,%xmm9
punpcklbw %xmm11,%xmm9
punpckhbw %xmm11,%xmm1
movdqa %xmm3,%xmm11
pcmpgtw %xmm9,%xmm11
movdqa %xmm9,%xmm12
punpcklwd %xmm11,%xmm12
punpckhwd %xmm11,%xmm9
movdqa %xmm1,%xmm11
psubd %xmm12,%xmm2
psubd %xmm9,%xmm2
movdqa %xmm3,%xmm9
pcmpgtw %xmm1,%xmm9
punpcklwd %xmm9,%xmm11
punpckhwd %xmm9,%xmm1
movdqa %xmm0,%xmm9
psubd %xmm11,%xmm2
movdqa %xmm3,%xmm11
psubd %xmm1,%xmm2
movdqa %xmm4,%xmm1
pcmpgtb %xmm0,%xmm1
punpcklbw %xmm1,%xmm9
punpckhbw %xmm1,%xmm0
pcmpgtw %xmm9,%xmm11
movdqa %xmm9,%xmm1
punpcklwd %xmm11,%xmm1
punpckhwd %xmm11,%xmm9
paddd %xmm10,%xmm1
movdqa %xmm0,%xmm10
paddd %xmm9,%xmm1
movdqa %xmm3,%xmm9
pcmpgtw %xmm0,%xmm9
punpcklwd %xmm9,%xmm10
punpckhwd %xmm9,%xmm0
paddd %xmm10,%xmm1
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm10
cmp %rcx,%rdx
jne 1890 <func0+0xb0>
movdqa %xmm2,%xmm0
psrldq $0x8,%xmm1
mov %eax,%esi
psrldq $0x8,%xmm0
paddd %xmm10,%xmm1
and $0xfffffff0,%esi
paddd %xmm0,%xmm2
movdqa %xmm1,%xmm10
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm10
psrldq $0x4,%xmm0
paddd %xmm10,%xmm1
paddd %xmm0,%xmm2
movd %xmm1,%edx
movd %xmm2,%ecx
test $0xf,%al
je 1c70 <func0+0x490>
movslq %esi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1a00 <func0+0x220>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
jmp 1a03 <func0+0x223>
xor %esi,%esi
xor %ecx,%ecx
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
add $0x1,%edx
add $0x1,%esi
cmp %esi,%eax
jle 1c70 <func0+0x490>
movslq %esi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1ce0 <func0+0x500>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x1(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1cf0 <func0+0x510>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x2(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d00 <func0+0x520>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x3(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d10 <func0+0x530>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x4(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d20 <func0+0x540>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x5(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d30 <func0+0x550>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x6(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d40 <func0+0x560>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x7(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d50 <func0+0x570>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x8(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d60 <func0+0x580>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x9(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d70 <func0+0x590>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0xa(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1d80 <func0+0x5a0>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0xb(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1db0 <func0+0x5d0>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0xc(%rsi),%edi
cmp %edi,%eax
jle 1c70 <func0+0x490>
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
lea -0x30(%rdi),%r8d
cmp $0x9,%r8b
jbe 1db8 <func0+0x5d8>
cmp $0x2e,%dil
sete %dil
movzbl %dil,%edi
add %edi,%ecx
add $0xd,%esi
cmp %esi,%eax
jle 1c70 <func0+0x490>
movslq %esi,%rsi
movzbl (%rbx,%rsi,1),%eax
lea -0x30(%rax),%esi
cmp $0x9,%sil
ja 1dc0 <func0+0x5e0>
add $0x1,%edx
cmp $0x3,%edx
jg 1c88 <func0+0x4a8>
lea 0x38b(%rip),%r9
cmp $0x1,%ecx
je 1c8f <func0+0x4af>
nopl 0x0(%rax)
lea 0x375(%rip),%r9
mov %r9,%rax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x5,%ecx
lea 0x39a(%rip),%rdi
mov %r8,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %cl
sbb $0x0,%cl
test %cl,%cl
je 183f <func0+0x5f>
mov $0x5,%ecx
lea 0x36d(%rip),%rdi
mov %r8,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %cl
sbb $0x0,%cl
test %cl,%cl
je 183f <func0+0x5f>
jmp 1c8f <func0+0x4af>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1a31 <func0+0x251>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1a5f <func0+0x27f>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1a8d <func0+0x2ad>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1abb <func0+0x2db>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1ae9 <func0+0x309>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1b17 <func0+0x337>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1b45 <func0+0x365>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1b73 <func0+0x393>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1ba1 <func0+0x3c1>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1bcf <func0+0x3ef>
nopl 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1bfd <func0+0x41d>
nopl 0x0(%rax,%rax,1)
sub $0x30,%edx
cmp $0x9,%dl
jbe 19f1 <func0+0x211>
xor %ecx,%ecx
xor %edx,%edx
mov $0x1,%esi
jmpq 1a0e <func0+0x22e>
nopw 0x0(%rax,%rax,1)
add $0x1,%edx
jmpq 1c27 <func0+0x447>
add $0x1,%edx
jmpq 1c51 <func0+0x471>
cmp $0x2e,%al
sete %al
movzbl %al,%eax
add %eax,%ecx
jmpq 1c70 <func0+0x490>
|
func0:
endbr64
push r13
push r12
lea r12, unk_2004
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
cmp eax, 4
jle loc_1C31
mov rbp, rax
movzx eax, byte ptr [rbx]
lea edx, [rax-5Bh]
cmp dl, 5
jbe loc_1C40
sub eax, 41h ; 'A'
cmp al, 39h ; '9'
ja loc_1C40
movsxd rax, ebp
lea rsi, aFinalTxt+6; s2
lea r13, [rbx+rax-4]
mov rdi, r13; s1
call _strcmp
test eax, eax
jnz loc_1C58
loc_1832:
lea eax, [rbp-1]
cmp eax, 0Eh
jbe loc_1D00
mov edx, ebp
pxor xmm2, xmm2
pxor xmm4, xmm4
mov rax, rbx
shr edx, 4
movdqa xmm3, xmm2
pxor xmm5, xmm5
movdqa xmm9, cs:xmmword_2650
shl rdx, 4
movdqa xmm7, cs:xmmword_2670
movdqa xmm8, cs:xmmword_2660
movdqa xmm6, cs:xmmword_2680
add rdx, rbx
nop
loc_1880:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm1, xmm8
movdqu xmm10, xmmword ptr [rax]
movdqa xmm11, xmm4
add rax, 10h
paddb xmm0, xmm9
pcmpeqb xmm10, xmm6
psubusb xmm1, xmm0
psubusb xmm0, xmm7
pcmpeqb xmm0, xmm4
pcmpeqb xmm1, xmm4
pcmpeqb xmm0, xmm4
pcmpeqb xmm1, xmm4
pand xmm0, xmm10
pcmpgtb xmm11, xmm0
movdqa xmm10, xmm0
punpcklbw xmm10, xmm11
punpckhbw xmm0, xmm11
movdqa xmm11, xmm5
pcmpgtw xmm11, xmm10
movdqa xmm12, xmm10
punpcklwd xmm12, xmm11
punpckhwd xmm10, xmm11
movdqa xmm11, xmm0
psubd xmm2, xmm12
psubd xmm2, xmm10
movdqa xmm10, xmm5
pcmpgtw xmm10, xmm0
punpcklwd xmm11, xmm10
punpckhwd xmm0, xmm10
movdqa xmm10, xmm4
pcmpgtb xmm10, xmm1
psubd xmm2, xmm11
psubd xmm2, xmm0
movdqa xmm0, xmm1
punpcklbw xmm0, xmm10
punpckhbw xmm1, xmm10
movdqa xmm10, xmm5
pcmpgtw xmm10, xmm0
movdqa xmm11, xmm0
punpcklwd xmm11, xmm10
punpckhwd xmm0, xmm10
movdqa xmm10, xmm1
psubd xmm3, xmm11
psubd xmm3, xmm0
movdqa xmm0, xmm5
pcmpgtw xmm0, xmm1
punpcklwd xmm10, xmm0
punpckhwd xmm1, xmm0
psubd xmm3, xmm10
psubd xmm3, xmm1
cmp rax, rdx
jnz loc_1880
movdqa xmm0, xmm3
mov edi, ebp
movhlps xmm6, xmm3
psrldq xmm0, 8
and edi, 0FFFFFFF0h
paddd xmm6, xmm3
paddd xmm0, xmm3
mov edx, edi
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
movdqa xmm0, xmm2
psrldq xmm0, 8
paddd xmm0, xmm2
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movdqa xmm1, xmm2
psrldq xmm2, 8
paddd xmm1, xmm2
movd esi, xmm0
test bpl, 0Fh
jz loc_1C20
loc_19DA:
mov ecx, ebp
sub ecx, edi
lea r8d, [rcx-1]
cmp r8d, 6
jbe loc_1B18
movq xmm0, qword ptr cs:xmmword_2650
movq xmm3, qword ptr [rbx+rdi]
movq xmm4, qword ptr cs:xmmword_2670
movq xmm5, qword ptr cs:xmmword_2680
paddb xmm0, xmm3
pcmpeqb xmm3, xmm5
movdqa xmm2, xmm0
pminub xmm2, xmm4
pcmpeqb xmm2, xmm0
psubusb xmm0, xmm4
pxor xmm4, xmm4
pcmpeqb xmm0, xmm4
pcmpeqb xmm0, xmm4
pand xmm0, xmm3
movdqa xmm3, xmm4
pcmpgtb xmm3, xmm0
pcmpgtb xmm4, xmm2
movdqa xmm5, xmm0
punpcklbw xmm5, xmm3
punpcklbw xmm0, xmm3
pxor xmm3, xmm3
movdqa xmm7, xmm3
movdqa xmm8, xmm5
pshufd xmm0, xmm0, 4Eh ; 'N'
pcmpgtw xmm7, xmm5
punpcklwd xmm8, xmm7
punpcklwd xmm5, xmm7
movdqa xmm7, xmm0
psubd xmm1, xmm8
pshufd xmm5, xmm5, 4Eh ; 'N'
psubd xmm1, xmm5
movdqa xmm5, xmm3
pcmpgtw xmm5, xmm0
punpcklwd xmm7, xmm5
punpcklwd xmm0, xmm5
movdqa xmm5, xmm2
punpcklbw xmm5, xmm4
punpcklbw xmm2, xmm4
movdqa xmm4, xmm3
pcmpgtw xmm4, xmm5
psubd xmm1, xmm7
movdqa xmm7, xmm5
pshufd xmm2, xmm2, 4Eh ; 'N'
pshufd xmm0, xmm0, 4Eh ; 'N'
pcmpgtw xmm3, xmm2
punpcklwd xmm7, xmm4
punpcklwd xmm5, xmm4
psubd xmm1, xmm0
psubd xmm6, xmm7
pshufd xmm5, xmm5, 4Eh ; 'N'
movdqa xmm4, xmm2
punpcklwd xmm4, xmm3
punpcklwd xmm2, xmm3
pshufd xmm2, xmm2, 4Eh ; 'N'
movdqa xmm0, xmm6
psubd xmm0, xmm5
psubd xmm0, xmm4
psubd xmm0, xmm2
movd esi, xmm0
pshufd xmm6, xmm0, 0E5h
movd eax, xmm6
pshufd xmm6, xmm1, 0E5h
add eax, esi
movd edi, xmm6
movd esi, xmm1
add esi, edi
mov edi, ecx
and edi, 0FFFFFFF8h
add edx, edi
and ecx, 7
jz loc_1C20
loc_1B18:
movsxd rcx, edx
movzx ecx, byte ptr [rbx+rcx]
lea edi, [rcx-30h]
cmp dil, 9
jbe loc_1C90
cmp cl, 2Eh ; '.'
setz cl
movzx ecx, cl
add esi, ecx
loc_1B37:
lea ecx, [rdx+1]
cmp ebp, ecx
jle loc_1C20
movsxd rcx, ecx
movzx ecx, byte ptr [rbx+rcx]
lea edi, [rcx-30h]
cmp dil, 9
jbe loc_1CA0
cmp cl, 2Eh ; '.'
setz cl
movzx ecx, cl
add esi, ecx
loc_1B61:
lea ecx, [rdx+2]
cmp ebp, ecx
jle loc_1C20
movsxd rcx, ecx
movzx ecx, byte ptr [rbx+rcx]
lea edi, [rcx-30h]
cmp dil, 9
jbe loc_1CB0
cmp cl, 2Eh ; '.'
setz cl
movzx ecx, cl
add esi, ecx
loc_1B8B:
lea ecx, [rdx+3]
cmp ebp, ecx
jle loc_1C20
movsxd rcx, ecx
movzx ecx, byte ptr [rbx+rcx]
lea edi, [rcx-30h]
cmp dil, 9
jbe loc_1CC0
cmp cl, 2Eh ; '.'
setz cl
movzx ecx, cl
add esi, ecx
loc_1BB5:
lea ecx, [rdx+4]
cmp ecx, ebp
jge short loc_1C20
movsxd rcx, ecx
movzx ecx, byte ptr [rbx+rcx]
lea edi, [rcx-30h]
cmp dil, 9
jbe loc_1CD0
cmp cl, 2Eh ; '.'
setz cl
movzx ecx, cl
add esi, ecx
loc_1BDB:
lea ecx, [rdx+5]
cmp ebp, ecx
jle short loc_1C20
movsxd rcx, ecx
movzx ecx, byte ptr [rbx+rcx]
lea edi, [rcx-30h]
cmp dil, 9
jbe loc_1CE0
cmp cl, 2Eh ; '.'
setz cl
movzx ecx, cl
add esi, ecx
loc_1C01:
add edx, 6
cmp ebp, edx
jle short loc_1C20
movsxd rdx, edx
movzx edx, byte ptr [rbx+rdx]
lea ecx, [rdx-30h]
cmp cl, 9
ja loc_1CF0
add eax, 1
xchg ax, ax
loc_1C20:
cmp eax, 3
jg short loc_1C40
lea r12, s2; "Yes"
cmp esi, 1
jnz short loc_1C40
loc_1C31:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1C40:
add rsp, 8
lea r12, unk_2004
pop rbx
mov rax, r12
pop rbp
pop r12
pop r13
retn
loc_1C58:
lea rsi, aMy16file3Exe+9; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jz loc_1832
lea rsi, aKDll+1; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jz loc_1832
jmp short loc_1C31
loc_1C90:
add eax, 1
jmp loc_1B37
loc_1CA0:
add eax, 1
jmp loc_1B61
loc_1CB0:
add eax, 1
jmp loc_1B8B
loc_1CC0:
add eax, 1
jmp loc_1BB5
loc_1CD0:
add eax, 1
jmp loc_1BDB
loc_1CE0:
add eax, 1
jmp loc_1C01
loc_1CF0:
cmp dl, 2Eh ; '.'
setz dl
movzx edx, dl
add esi, edx
jmp loc_1C20
loc_1D00:
pxor xmm1, xmm1
xor edi, edi
xor edx, edx
xor esi, esi
movdqa xmm6, xmm1
xor eax, eax
jmp loc_19DA
|
const char * func0(const char *a1)
{
const char *v1; // r12
int v3; // eax
int v4; // ebp
__m128i v5; // xmm2
const __m128i *v6; // rax
__m128 v7; // xmm3
__m128i si128; // xmm9
__m128i v9; // xmm7
__m128i v10; // xmm8
__m128 v11; // xmm6
__m128i v12; // xmm0
__m128i v13; // xmm10
__m128i v14; // xmm0
__m128i v15; // xmm1
__m128i v16; // xmm0
__m128i v17; // xmm11
__m128i v18; // xmm10
__m128i v19; // xmm0
__m128i v20; // xmm11
__m128i v21; // xmm2
__m128i v22; // xmm10
__m128i v23; // xmm11
__m128i v24; // xmm0
__m128i v25; // xmm10
__m128i v26; // xmm0
__m128i v27; // xmm1
__m128i v28; // xmm10
__m128i v29; // xmm3
__m128i v30; // xmm0
long long v31; // rdi
__m128i v32; // xmm6
__m128i v33; // xmm0
signed int v34; // edx
int v35; // eax
__m128i v36; // xmm0
__m128i v37; // xmm1
int v38; // esi
int v39; // ecx
__m128i v40; // xmm3
__m128i v41; // xmm4
__m128i v42; // xmm0
__m128i v43; // xmm2
__m128i v44; // xmm0
__m128i v45; // xmm5
__m128i v46; // xmm0
__m128i v47; // xmm5
__m128i v48; // xmm1
__m128i v49; // xmm0
__m128i v50; // xmm5
__m128i v51; // xmm2
__m128i v52; // xmm5
__m128i v53; // xmm1
__m128i v54; // xmm4
__m128i v55; // xmm0
char v56; // cl
char v57; // cl
char v58; // cl
char v59; // cl
char v60; // cl
char v61; // cl
int v62; // edx
char v63; // dl
v1 = (const char *)&unk_2004;
v3 = strlen(a1);
if ( v3 <= 4 )
return v1;
v4 = v3;
if ( (unsigned __int8)(*a1 - 91) <= 5u || (unsigned __int8)(*a1 - 65) > 0x39u )
return (const char *)&unk_2004;
if ( strcmp(&a1[v3 - 4], ".txt") && strcmp(&a1[v4 - 4], ".exe") && strcmp(&a1[v4 - 4], ".dll") )
return v1;
if ( (unsigned int)(v4 - 1) <= 0xE )
{
v37 = 0LL;
v31 = 0LL;
v34 = 0;
v38 = 0;
v32 = 0LL;
v35 = 0;
}
else
{
v5 = 0LL;
v6 = (const __m128i *)a1;
v7 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2650);
v9 = _mm_load_si128((const __m128i *)&xmmword_2670);
v10 = _mm_load_si128((const __m128i *)&xmmword_2660);
v11 = (__m128)_mm_load_si128((const __m128i *)&xmmword_2680);
do
{
v12 = _mm_loadu_si128(v6);
v13 = v12;
++v6;
v14 = _mm_add_epi8(v12, si128);
v15 = _mm_cmpeq_epi8(_mm_cmpeq_epi8(_mm_subs_epu8(v10, v14), (__m128i)0LL), (__m128i)0LL);
v16 = _mm_and_si128(
_mm_cmpeq_epi8(_mm_cmpeq_epi8(_mm_subs_epu8(v14, v9), (__m128i)0LL), (__m128i)0LL),
_mm_cmpeq_epi8(v13, (__m128i)v11));
v17 = _mm_cmpgt_epi8((__m128i)0LL, v16);
v18 = _mm_unpacklo_epi8(v16, v17);
v19 = _mm_unpackhi_epi8(v16, v17);
v20 = _mm_cmpgt_epi16((__m128i)0LL, v18);
v21 = _mm_sub_epi32(_mm_sub_epi32(v5, _mm_unpacklo_epi16(v18, v20)), _mm_unpackhi_epi16(v18, v20));
v22 = _mm_cmpgt_epi16((__m128i)0LL, v19);
v23 = _mm_unpacklo_epi16(v19, v22);
v24 = _mm_unpackhi_epi16(v19, v22);
v25 = _mm_cmpgt_epi8((__m128i)0LL, v15);
v5 = _mm_sub_epi32(_mm_sub_epi32(v21, v23), v24);
v26 = _mm_unpacklo_epi8(v15, v25);
v27 = _mm_unpackhi_epi8(v15, v25);
v28 = _mm_cmpgt_epi16((__m128i)0LL, v26);
v29 = _mm_sub_epi32(_mm_sub_epi32((__m128i)v7, _mm_unpacklo_epi16(v26, v28)), _mm_unpackhi_epi16(v26, v28));
v30 = _mm_cmpgt_epi16((__m128i)0LL, v27);
v7 = (__m128)_mm_sub_epi32(_mm_sub_epi32(v29, _mm_unpacklo_epi16(v27, v30)), _mm_unpackhi_epi16(v27, v30));
}
while ( v6 != (const __m128i *)&a1[16 * ((unsigned int)v4 >> 4)] );
v31 = v4 & 0xFFFFFFF0;
v32 = _mm_add_epi32((__m128i)_mm_movehl_ps(v11, v7), (__m128i)v7);
v33 = _mm_add_epi32(_mm_srli_si128((__m128i)v7, 8), (__m128i)v7);
v34 = v4 & 0xFFFFFFF0;
v35 = _mm_cvtsi128_si32(_mm_add_epi32(v33, _mm_srli_si128(v33, 4)));
v36 = _mm_add_epi32(_mm_srli_si128(v5, 8), v5);
v37 = _mm_add_epi32(v5, _mm_srli_si128(v5, 8));
v38 = _mm_cvtsi128_si32(_mm_add_epi32(v36, _mm_srli_si128(v36, 4)));
if ( (v4 & 0xF) == 0 )
goto LABEL_31;
}
v39 = v4 - v31;
if ( (unsigned int)(v4 - v31 - 1) <= 6 )
goto LABEL_25;
v40 = _mm_loadl_epi64((const __m128i *)&a1[v31]);
v41 = _mm_loadl_epi64((const __m128i *)&xmmword_2670);
v42 = _mm_add_epi8(_mm_loadl_epi64((const __m128i *)&xmmword_2650), v40);
v43 = _mm_cmpeq_epi8(_mm_min_epu8(v42, v41), v42);
v44 = _mm_and_si128(
_mm_cmpeq_epi8(_mm_cmpeq_epi8(_mm_subs_epu8(v42, v41), (__m128i)0LL), (__m128i)0LL),
_mm_cmpeq_epi8(v40, _mm_loadl_epi64((const __m128i *)&xmmword_2680)));
v45 = _mm_unpacklo_epi8(v44, _mm_cmpgt_epi8((__m128i)0LL, v44));
v46 = _mm_shuffle_epi32(v45, 78);
v47 = _mm_unpacklo_epi16(v45, _mm_cmpgt_epi16((__m128i)0LL, v45));
v48 = _mm_sub_epi32(_mm_sub_epi32(v37, v47), _mm_shuffle_epi32(v47, 78));
v49 = _mm_unpacklo_epi16(v46, _mm_cmpgt_epi16((__m128i)0LL, v46));
v50 = _mm_unpacklo_epi8(v43, _mm_cmpgt_epi8((__m128i)0LL, v43));
v51 = _mm_shuffle_epi32(v50, 78);
v52 = _mm_unpacklo_epi16(v50, _mm_cmpgt_epi16((__m128i)0LL, v50));
v53 = _mm_sub_epi32(_mm_sub_epi32(v48, v49), _mm_shuffle_epi32(v49, 78));
v54 = _mm_unpacklo_epi16(v51, _mm_cmpgt_epi16((__m128i)0LL, v51));
v55 = _mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(_mm_sub_epi32(v32, v52), _mm_shuffle_epi32(v52, 78)), v54),
_mm_shuffle_epi32(v54, 78));
v35 = _mm_cvtsi128_si32(v55) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v55, 229));
v38 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v53, 229)) + _mm_cvtsi128_si32(v53);
v34 += v39 & 0xFFFFFFF8;
if ( (v39 & 7) != 0 )
{
LABEL_25:
v56 = a1[v34];
if ( (unsigned __int8)(v56 - 48) <= 9u )
++v35;
else
v38 += v56 == 46;
if ( v4 > v34 + 1 )
{
v57 = a1[v34 + 1];
if ( (unsigned __int8)(v57 - 48) <= 9u )
++v35;
else
v38 += v57 == 46;
if ( v4 > v34 + 2 )
{
v58 = a1[v34 + 2];
if ( (unsigned __int8)(v58 - 48) <= 9u )
++v35;
else
v38 += v58 == 46;
if ( v4 > v34 + 3 )
{
v59 = a1[v34 + 3];
if ( (unsigned __int8)(v59 - 48) <= 9u )
++v35;
else
v38 += v59 == 46;
if ( v34 + 4 < v4 )
{
v60 = a1[v34 + 4];
if ( (unsigned __int8)(v60 - 48) <= 9u )
++v35;
else
v38 += v60 == 46;
if ( v4 > v34 + 5 )
{
v61 = a1[v34 + 5];
if ( (unsigned __int8)(v61 - 48) <= 9u )
++v35;
else
v38 += v61 == 46;
v62 = v34 + 6;
if ( v4 > v62 )
{
v63 = a1[v62];
if ( (unsigned __int8)(v63 - 48) > 9u )
v38 += v63 == 46;
else
++v35;
}
}
}
}
}
}
}
LABEL_31:
if ( v35 <= 3 )
{
v1 = "Yes";
if ( v38 == 1 )
return v1;
}
return (const char *)&unk_2004;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
LEA R12,[0x102004]
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
CMP EAX,0x4
JLE 0x00101c31
MOV RBP,RAX
MOVZX EAX,byte ptr [RBX]
LEA EDX,[RAX + -0x5b]
CMP DL,0x5
JBE 0x00101c40
SUB EAX,0x41
CMP AL,0x39
JA 0x00101c40
MOVSXD RAX,EBP
LEA RSI,[0x102153]
LEA R13,[RBX + RAX*0x1 + -0x4]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JNZ 0x00101c58
LAB_00101832:
LEA EAX,[RBP + -0x1]
CMP EAX,0xe
JBE 0x00101d00
MOV EDX,EBP
PXOR XMM2,XMM2
PXOR XMM4,XMM4
MOV RAX,RBX
SHR EDX,0x4
MOVDQA XMM3,XMM2
PXOR XMM5,XMM5
MOVDQA XMM9,xmmword ptr [0x00102650]
SHL RDX,0x4
MOVDQA XMM7,xmmword ptr [0x00102670]
MOVDQA XMM8,xmmword ptr [0x00102660]
MOVDQA XMM6,xmmword ptr [0x00102680]
ADD RDX,RBX
NOP
LAB_00101880:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM1,XMM8
MOVDQU XMM10,xmmword ptr [RAX]
MOVDQA XMM11,XMM4
ADD RAX,0x10
PADDB XMM0,XMM9
PCMPEQB XMM10,XMM6
PSUBUSB XMM1,XMM0
PSUBUSB XMM0,XMM7
PCMPEQB XMM0,XMM4
PCMPEQB XMM1,XMM4
PCMPEQB XMM0,XMM4
PCMPEQB XMM1,XMM4
PAND XMM0,XMM10
PCMPGTB XMM11,XMM0
MOVDQA XMM10,XMM0
PUNPCKLBW XMM10,XMM11
PUNPCKHBW XMM0,XMM11
MOVDQA XMM11,XMM5
PCMPGTW XMM11,XMM10
MOVDQA XMM12,XMM10
PUNPCKLWD XMM12,XMM11
PUNPCKHWD XMM10,XMM11
MOVDQA XMM11,XMM0
PSUBD XMM2,XMM12
PSUBD XMM2,XMM10
MOVDQA XMM10,XMM5
PCMPGTW XMM10,XMM0
PUNPCKLWD XMM11,XMM10
PUNPCKHWD XMM0,XMM10
MOVDQA XMM10,XMM4
PCMPGTB XMM10,XMM1
PSUBD XMM2,XMM11
PSUBD XMM2,XMM0
MOVDQA XMM0,XMM1
PUNPCKLBW XMM0,XMM10
PUNPCKHBW XMM1,XMM10
MOVDQA XMM10,XMM5
PCMPGTW XMM10,XMM0
MOVDQA XMM11,XMM0
PUNPCKLWD XMM11,XMM10
PUNPCKHWD XMM0,XMM10
MOVDQA XMM10,XMM1
PSUBD XMM3,XMM11
PSUBD XMM3,XMM0
MOVDQA XMM0,XMM5
PCMPGTW XMM0,XMM1
PUNPCKLWD XMM10,XMM0
PUNPCKHWD XMM1,XMM0
PSUBD XMM3,XMM10
PSUBD XMM3,XMM1
CMP RAX,RDX
JNZ 0x00101880
MOVDQA XMM0,XMM3
MOV EDI,EBP
MOVHLPS XMM6,XMM3
PSRLDQ XMM0,0x8
AND EDI,0xfffffff0
PADDD XMM6,XMM3
PADDD XMM0,XMM3
MOV EDX,EDI
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
MOVDQA XMM0,XMM2
PSRLDQ XMM0,0x8
PADDD XMM0,XMM2
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVDQA XMM1,XMM2
PSRLDQ XMM2,0x8
PADDD XMM1,XMM2
MOVD ESI,XMM0
TEST BPL,0xf
JZ 0x00101c20
LAB_001019da:
MOV ECX,EBP
SUB ECX,EDI
LEA R8D,[RCX + -0x1]
CMP R8D,0x6
JBE 0x00101b18
MOVQ XMM0,qword ptr [0x00102650]
MOVQ XMM3,qword ptr [RBX + RDI*0x1]
MOVQ XMM4,qword ptr [0x00102670]
MOVQ XMM5,qword ptr [0x00102680]
PADDB XMM0,XMM3
PCMPEQB XMM3,XMM5
MOVDQA XMM2,XMM0
PMINUB XMM2,XMM4
PCMPEQB XMM2,XMM0
PSUBUSB XMM0,XMM4
PXOR XMM4,XMM4
PCMPEQB XMM0,XMM4
PCMPEQB XMM0,XMM4
PAND XMM0,XMM3
MOVDQA XMM3,XMM4
PCMPGTB XMM3,XMM0
PCMPGTB XMM4,XMM2
MOVDQA XMM5,XMM0
PUNPCKLBW XMM5,XMM3
PUNPCKLBW XMM0,XMM3
PXOR XMM3,XMM3
MOVDQA XMM7,XMM3
MOVDQA XMM8,XMM5
PSHUFD XMM0,XMM0,0x4e
PCMPGTW XMM7,XMM5
PUNPCKLWD XMM8,XMM7
PUNPCKLWD XMM5,XMM7
MOVDQA XMM7,XMM0
PSUBD XMM1,XMM8
PSHUFD XMM5,XMM5,0x4e
PSUBD XMM1,XMM5
MOVDQA XMM5,XMM3
PCMPGTW XMM5,XMM0
PUNPCKLWD XMM7,XMM5
PUNPCKLWD XMM0,XMM5
MOVDQA XMM5,XMM2
PUNPCKLBW XMM5,XMM4
PUNPCKLBW XMM2,XMM4
MOVDQA XMM4,XMM3
PCMPGTW XMM4,XMM5
PSUBD XMM1,XMM7
MOVDQA XMM7,XMM5
PSHUFD XMM2,XMM2,0x4e
PSHUFD XMM0,XMM0,0x4e
PCMPGTW XMM3,XMM2
PUNPCKLWD XMM7,XMM4
PUNPCKLWD XMM5,XMM4
PSUBD XMM1,XMM0
PSUBD XMM6,XMM7
PSHUFD XMM5,XMM5,0x4e
MOVDQA XMM4,XMM2
PUNPCKLWD XMM4,XMM3
PUNPCKLWD XMM2,XMM3
PSHUFD XMM2,XMM2,0x4e
MOVDQA XMM0,XMM6
PSUBD XMM0,XMM5
PSUBD XMM0,XMM4
PSUBD XMM0,XMM2
MOVD ESI,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD EAX,XMM6
PSHUFD XMM6,XMM1,0xe5
ADD EAX,ESI
MOVD EDI,XMM6
MOVD ESI,XMM1
ADD ESI,EDI
MOV EDI,ECX
AND EDI,0xfffffff8
ADD EDX,EDI
AND ECX,0x7
JZ 0x00101c20
LAB_00101b18:
MOVSXD RCX,EDX
MOVZX ECX,byte ptr [RBX + RCX*0x1]
LEA EDI,[RCX + -0x30]
CMP DIL,0x9
JBE 0x00101c90
CMP CL,0x2e
SETZ CL
MOVZX ECX,CL
ADD ESI,ECX
LAB_00101b37:
LEA ECX,[RDX + 0x1]
CMP EBP,ECX
JLE 0x00101c20
MOVSXD RCX,ECX
MOVZX ECX,byte ptr [RBX + RCX*0x1]
LEA EDI,[RCX + -0x30]
CMP DIL,0x9
JBE 0x00101ca0
CMP CL,0x2e
SETZ CL
MOVZX ECX,CL
ADD ESI,ECX
LAB_00101b61:
LEA ECX,[RDX + 0x2]
CMP EBP,ECX
JLE 0x00101c20
MOVSXD RCX,ECX
MOVZX ECX,byte ptr [RBX + RCX*0x1]
LEA EDI,[RCX + -0x30]
CMP DIL,0x9
JBE 0x00101cb0
CMP CL,0x2e
SETZ CL
MOVZX ECX,CL
ADD ESI,ECX
LAB_00101b8b:
LEA ECX,[RDX + 0x3]
CMP EBP,ECX
JLE 0x00101c20
MOVSXD RCX,ECX
MOVZX ECX,byte ptr [RBX + RCX*0x1]
LEA EDI,[RCX + -0x30]
CMP DIL,0x9
JBE 0x00101cc0
CMP CL,0x2e
SETZ CL
MOVZX ECX,CL
ADD ESI,ECX
LAB_00101bb5:
LEA ECX,[RDX + 0x4]
CMP ECX,EBP
JGE 0x00101c20
MOVSXD RCX,ECX
MOVZX ECX,byte ptr [RBX + RCX*0x1]
LEA EDI,[RCX + -0x30]
CMP DIL,0x9
JBE 0x00101cd0
CMP CL,0x2e
SETZ CL
MOVZX ECX,CL
ADD ESI,ECX
LAB_00101bdb:
LEA ECX,[RDX + 0x5]
CMP EBP,ECX
JLE 0x00101c20
MOVSXD RCX,ECX
MOVZX ECX,byte ptr [RBX + RCX*0x1]
LEA EDI,[RCX + -0x30]
CMP DIL,0x9
JBE 0x00101ce0
CMP CL,0x2e
SETZ CL
MOVZX ECX,CL
ADD ESI,ECX
LAB_00101c01:
ADD EDX,0x6
CMP EBP,EDX
JLE 0x00101c20
MOVSXD RDX,EDX
MOVZX EDX,byte ptr [RBX + RDX*0x1]
LEA ECX,[RDX + -0x30]
CMP CL,0x9
JA 0x00101cf0
ADD EAX,0x1
NOP
LAB_00101c20:
CMP EAX,0x3
JG 0x00101c40
LEA R12,[0x102007]
CMP ESI,0x1
JNZ 0x00101c40
LAB_00101c31:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101c40:
ADD RSP,0x8
LEA R12,[0x102004]
POP RBX
MOV RAX,R12
POP RBP
POP R12
POP R13
RET
LAB_00101c58:
LEA RSI,[0x10203e]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101832
LEA RSI,[0x102030]
MOV RDI,R13
CALL 0x00101090
TEST EAX,EAX
JZ 0x00101832
JMP 0x00101c31
LAB_00101c90:
ADD EAX,0x1
JMP 0x00101b37
LAB_00101ca0:
ADD EAX,0x1
JMP 0x00101b61
LAB_00101cb0:
ADD EAX,0x1
JMP 0x00101b8b
LAB_00101cc0:
ADD EAX,0x1
JMP 0x00101bb5
LAB_00101cd0:
ADD EAX,0x1
JMP 0x00101bdb
LAB_00101ce0:
ADD EAX,0x1
JMP 0x00101c01
LAB_00101cf0:
CMP DL,0x2e
SETZ DL
MOVZX EDX,DL
ADD ESI,EDX
JMP 0x00101c20
LAB_00101d00:
PXOR XMM1,XMM1
XOR EDI,EDI
XOR EDX,EDX
XOR ESI,ESI
MOVDQA XMM6,XMM1
XOR EAX,EAX
JMP 0x001019da
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int * func0(char *param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12;
bool bVar13;
bool bVar14;
bool bVar15;
bool bVar16;
byte bVar17;
byte bVar18;
byte bVar19;
byte bVar20;
byte bVar21;
byte bVar22;
byte bVar23;
char *pcVar24;
char *pcVar25;
char *pcVar26;
char *pcVar27;
char *pcVar28;
char *pcVar29;
char *pcVar30;
char *pcVar31;
char *pcVar32;
char *pcVar33;
char *pcVar34;
char *pcVar35;
char *pcVar36;
char *pcVar37;
char *pcVar38;
char *pcVar39;
char *pcVar40;
char *pcVar41;
char *pcVar42;
char *pcVar43;
char *pcVar44;
char *pcVar45;
char *pcVar46;
char *pcVar47;
char *pcVar48;
char *pcVar49;
char *pcVar50;
char *pcVar51;
char *pcVar52;
char *pcVar53;
int auVar54 [14];
int auVar55 [12];
unkbyte10 Var56;
int auVar57 [12];
int auVar58 [14];
int auVar59 [12];
int auVar60 [12];
int auVar61 [14];
int auVar62 [12];
int auVar63 [16];
int auVar64 [16];
int auVar65 [16];
int auVar66 [12];
int auVar67 [14];
int auVar68 [12];
int auVar69 [16];
int auVar70 [16];
int auVar71 [16];
int auVar72 [12];
unkbyte9 Var73;
uint uVar74;
int iVar75;
size_t sVar76;
char *pcVar77;
uint uVar78;
uint uVar79;
char cVar81;
int2 uVar82;
int auVar87 [12];
int auVar89 [12];
char cVar110;
short sVar111;
char cVar113;
char cVar114;
short sVar115;
short sVar118;
int auVar91 [16];
int auVar94 [16];
short sVar117;
int auVar88 [12];
int auVar96 [16];
int auVar97 [16];
int auVar98 [16];
char cVar112;
int auVar99 [16];
int auVar107 [16];
int4 uVar119;
int auVar122 [12];
char cVar127;
int auVar124 [16];
int iVar128;
int auVar131 [12];
int iVar145;
int auVar129 [11];
int iVar149;
int iVar150;
int auVar134 [16];
int auVar141 [16];
char cVar151;
char cVar153;
int iVar154;
int iVar155;
int iVar156;
int auVar152 [16];
char cVar162;
char cVar163;
char cVar164;
char cVar165;
char cVar166;
char cVar167;
int auVar157 [16];
int auVar158 [16];
int auVar168 [16];
int auVar176 [16];
int auVar179 [16];
int auVar186 [16];
int iVar189;
int iVar190;
int auVar191 [16];
int auVar195 [16];
int auVar198 [16];
int auVar201 [12];
int auVar202 [16];
int auVar203 [16];
int auVar212 [16];
int auVar217 [16];
int auVar222 [16];
int auVar225 [16];
ulong uVar80;
int4 uVar83;
int6 uVar84;
int8 uVar85;
int auVar100 [16];
int auVar101 [16];
int auVar86 [12];
int auVar102 [16];
int auVar108 [16];
int auVar103 [16];
int auVar90 [14];
int auVar93 [16];
int auVar95 [16];
int auVar104 [16];
int auVar109 [16];
int auVar105 [16];
int auVar92 [16];
int auVar106 [16];
long lVar116;
int6 uVar120;
int auVar121 [12];
int auVar123 [14];
int auVar126 [16];
int auVar125 [16];
int auVar135 [16];
int auVar136 [16];
int auVar142 [16];
int auVar130 [12];
int auVar137 [16];
int auVar132 [13];
int auVar138 [16];
int auVar143 [16];
int auVar133 [14];
int auVar139 [16];
int auVar140 [16];
char cVar144;
char cVar146;
char cVar147;
byte bVar148;
int auVar159 [16];
int auVar160 [16];
int auVar161 [16];
int auVar169 [16];
int auVar170 [16];
int auVar180 [16];
int auVar171 [16];
int auVar177 [16];
int auVar181 [16];
int auVar187 [16];
int auVar172 [16];
int auVar182 [16];
int auVar173 [16];
int auVar178 [16];
int auVar183 [16];
int auVar188 [16];
int auVar174 [16];
int auVar184 [16];
int auVar175 [16];
int auVar185 [16];
int auVar192 [16];
int auVar193 [16];
int auVar196 [16];
int auVar194 [16];
int auVar197 [16];
int auVar199 [16];
int auVar200 [16];
int auVar213 [16];
int auVar204 [16];
int auVar214 [16];
int auVar205 [16];
int auVar206 [16];
int auVar215 [16];
int auVar207 [16];
int auVar208 [16];
int auVar211 [16];
int auVar216 [16];
int auVar209 [16];
int auVar210 [16];
int auVar218 [16];
int auVar219 [16];
int auVar220 [16];
int auVar223 [16];
int auVar221 [16];
int auVar224 [16];
int auVar226 [16];
int auVar227 [16];
sVar76 = strlen(param_1);
uVar74 = (uint)sVar76;
if ((int)uVar74 < 5) {
return &DAT_00102004;
}
if (((byte)(*param_1 + 0xa5U) < 6) || (0x39 < (byte)(*param_1 + 0xbfU))) goto LAB_00101c40;
pcVar77 = param_1 + (long)(int)uVar74 + -4;
iVar75 = strcmp(pcVar77,".txt");
if ((iVar75 != 0) &&
((iVar75 = strcmp(pcVar77,".exe"), iVar75 != 0 &&
(iVar75 = strcmp(pcVar77,".dll"), iVar75 != 0)))) {
return &DAT_00102004;
}
if (uVar74 - 1 < 0xf) {
iVar189 = 0;
iVar190 = 0;
iVar128 = 0;
iVar145 = 0;
uVar80 = 0;
uVar79 = 0;
iVar154 = 0;
iVar75 = 0;
LAB_001019da:
uVar78 = uVar74 - (int)uVar80;
if (6 < uVar78 - 1) {
uVar85 = *(int8 *)(param_1 + uVar80);
auVar157._8_8_ = 0;
auVar157._0_8_ = DAT_00102670;
auVar96[0] = (char)DAT_00102650 + (char)uVar85;
cVar81 = (char)((ulong)uVar85 >> 8);
auVar96[1] = DAT_00102650._1_1_ + cVar81;
cVar110 = (char)((ulong)uVar85 >> 0x10);
auVar96[2] = DAT_00102650._2_1_ + cVar110;
cVar112 = (char)((ulong)uVar85 >> 0x18);
auVar96[3] = DAT_00102650._3_1_ + cVar112;
cVar113 = (char)((ulong)uVar85 >> 0x20);
auVar96[4] = DAT_00102650._4_1_ + cVar113;
cVar114 = (char)((ulong)uVar85 >> 0x28);
auVar96[5] = DAT_00102650._5_1_ + cVar114;
cVar127 = (char)((ulong)uVar85 >> 0x30);
auVar96[6] = DAT_00102650._6_1_ + cVar127;
cVar144 = (char)((ulong)uVar85 >> 0x38);
auVar96[7] = DAT_00102650._7_1_ + cVar144;
auVar96._8_8_ = 0;
auVar152[0] = -((char)uVar85 == (char)DAT_00102680);
auVar152[1] = -(cVar81 == DAT_00102680._1_1_);
auVar152[2] = -(cVar110 == DAT_00102680._2_1_);
auVar152[3] = -(cVar112 == DAT_00102680._3_1_);
auVar152[4] = -(cVar113 == DAT_00102680._4_1_);
auVar152[5] = -(cVar114 == DAT_00102680._5_1_);
auVar152[6] = -(cVar127 == DAT_00102680._6_1_);
auVar152[7] = -(cVar144 == DAT_00102680._7_1_);
auVar152[8] = 0xff;
auVar152[9] = 0xff;
auVar152[10] = 0xff;
auVar152[0xb] = 0xff;
auVar152[0xc] = 0xff;
auVar152[0xd] = 0xff;
auVar152[0xe] = 0xff;
auVar152[0xf] = 0xff;
bVar148 = (byte)DAT_00102670;
bVar17 = (byte)(DAT_00102670 >> 8);
bVar18 = (byte)(DAT_00102670 >> 0x10);
bVar19 = (byte)(DAT_00102670 >> 0x18);
bVar20 = (byte)(DAT_00102670 >> 0x20);
bVar21 = (byte)(DAT_00102670 >> 0x28);
bVar22 = (byte)(DAT_00102670 >> 0x30);
bVar23 = (byte)(DAT_00102670 >> 0x38);
bVar1 = (byte)((bVar148 < auVar96[0]) * bVar148 | (bVar148 >= auVar96[0]) * auVar96[0]) ==
auVar96[0];
auVar134[0] = -bVar1;
bVar2 = (byte)((bVar17 < auVar96[1]) * bVar17 | (bVar17 >= auVar96[1]) * auVar96[1]) ==
auVar96[1];
cVar127 = -bVar2;
bVar3 = (byte)((bVar18 < auVar96[2]) * bVar18 | (bVar18 >= auVar96[2]) * auVar96[2]) ==
auVar96[2];
bVar4 = (byte)((bVar19 < auVar96[3]) * bVar19 | (bVar19 >= auVar96[3]) * auVar96[3]) ==
auVar96[3];
bVar5 = (byte)((bVar20 < auVar96[4]) * bVar20 | (bVar20 >= auVar96[4]) * auVar96[4]) ==
auVar96[4];
cVar144 = -bVar5;
bVar6 = (byte)((bVar21 < auVar96[5]) * bVar21 | (bVar21 >= auVar96[5]) * auVar96[5]) ==
auVar96[5];
cVar146 = -bVar6;
bVar7 = (byte)((bVar22 < auVar96[6]) * bVar22 | (bVar22 >= auVar96[6]) * auVar96[6]) ==
auVar96[6];
cVar147 = -bVar7;
bVar8 = (byte)((bVar23 < auVar96[7]) * bVar23 | (bVar23 >= auVar96[7]) * auVar96[7]) ==
auVar96[7];
bVar148 = -bVar8;
auVar135._0_9_ = CONCAT18(0xff,(ulong)bVar148 << 0x38);
auVar129._0_10_ = CONCAT19(0xff,auVar135._0_9_);
auVar129[10] = 0xff;
auVar130[0xb] = 0xff;
auVar130._0_11_ = auVar129;
auVar132[0xc] = 0xff;
auVar132._0_12_ = auVar130;
auVar133[0xd] = 0xff;
auVar133._0_13_ = auVar132;
auVar97 = psubusb(auVar96,auVar157);
auVar98[0] = -(auVar97[0] != '\0');
auVar98[1] = -(auVar97[1] != '\0');
auVar98[2] = -(auVar97[2] != '\0');
auVar98[3] = -(auVar97[3] != '\0');
auVar98[4] = -(auVar97[4] != '\0');
auVar98[5] = -(auVar97[5] != '\0');
auVar98[6] = -(auVar97[6] != '\0');
auVar98[7] = -(auVar97[7] != '\0');
auVar98[8] = -(auVar97[8] != '\0');
auVar98[9] = -(auVar97[9] != '\0');
auVar98[10] = -(auVar97[10] != '\0');
auVar98[0xb] = -(auVar97[0xb] != '\0');
auVar98[0xc] = -(auVar97[0xc] != '\0');
auVar98[0xd] = -(auVar97[0xd] != '\0');
auVar98[0xe] = -(auVar97[0xe] != '\0');
auVar98[0xf] = -(auVar97[0xf] != '\0');
auVar98 = auVar98 & auVar152;
auVar99[0] = auVar98[0];
cVar151 = -(auVar99[0] < '\0');
cVar81 = auVar98[1];
cVar153 = -(auVar98[3] < '\0');
cVar110 = auVar98[4];
cVar112 = auVar98[5];
cVar113 = auVar98[6];
cVar114 = auVar98[7];
cVar162 = -bVar2;
cVar163 = -bVar4;
cVar164 = -bVar5;
cVar165 = -bVar6;
cVar166 = -bVar7;
cVar167 = -bVar8;
auVar175._0_14_ = auVar98._0_14_;
auVar175[0xe] = cVar114;
auVar175[0xf] = -(cVar114 < '\0');
auVar174._14_2_ = auVar175._14_2_;
auVar174._0_13_ = auVar98._0_13_;
auVar174[0xd] = -(cVar113 < '\0');
auVar173._13_3_ = auVar174._13_3_;
auVar173._0_12_ = auVar98._0_12_;
auVar173[0xc] = cVar113;
auVar172._12_4_ = auVar173._12_4_;
auVar172._0_11_ = auVar98._0_11_;
auVar172[0xb] = -(cVar112 < '\0');
auVar171._11_5_ = auVar172._11_5_;
auVar171._0_10_ = auVar98._0_10_;
auVar171[10] = cVar112;
auVar170._10_6_ = auVar171._10_6_;
auVar170._0_9_ = auVar98._0_9_;
auVar170[9] = -(cVar110 < '\0');
auVar169._9_7_ = auVar170._9_7_;
auVar169._0_8_ = auVar98._0_8_;
auVar169[8] = cVar110;
Var56 = CONCAT91(CONCAT81(auVar169._8_8_,cVar153),auVar98[3]);
auVar62._2_10_ = Var56;
auVar62[1] = -(auVar98[2] < '\0');
auVar62[0] = auVar98[2];
auVar61._2_12_ = auVar62;
auVar61[1] = -(cVar81 < '\0');
auVar61[0] = cVar81;
auVar168._0_2_ = CONCAT11(cVar151,auVar99[0]);
auVar168._2_14_ = auVar61;
auVar106[0xe] = cVar114;
auVar106._0_14_ = auVar175._0_14_;
auVar106[0xf] = -(cVar114 < '\0');
auVar105._14_2_ = auVar106._14_2_;
auVar105[0xd] = -(cVar113 < '\0');
auVar105._0_13_ = auVar174._0_13_;
auVar104._13_3_ = auVar105._13_3_;
auVar104[0xc] = cVar113;
auVar104._0_12_ = auVar173._0_12_;
auVar103._12_4_ = auVar104._12_4_;
auVar103[0xb] = -(cVar112 < '\0');
auVar103._0_11_ = auVar172._0_11_;
auVar102._11_5_ = auVar103._11_5_;
auVar102[10] = cVar112;
auVar102._0_10_ = auVar171._0_10_;
auVar101._10_6_ = auVar102._10_6_;
auVar101[9] = -(cVar110 < '\0');
auVar101._0_9_ = auVar170._0_9_;
auVar100._9_7_ = auVar101._9_7_;
auVar100[8] = cVar110;
auVar100._0_8_ = auVar169._0_8_;
lVar116 = auVar100._8_8_;
auVar65._1_8_ = lVar116;
auVar65[0] = cVar153;
auVar65._9_7_ = 0;
auVar64._10_6_ = 0;
auVar64._0_10_ = SUB1610(auVar65 << 0x38,6);
auVar63._11_5_ = 0;
auVar63._0_11_ = SUB1611(auVar64 << 0x30,5);
auVar99._4_12_ = SUB1612(auVar63 << 0x28,4);
auVar99[3] = -(cVar81 < '\0');
auVar99[2] = cVar81;
auVar99[1] = cVar151;
auVar89._8_4_ = auVar99._0_4_;
auVar89._0_8_ = lVar116;
sVar111 = auVar62._0_2_;
sVar115 = (short)Var56;
auVar200._0_12_ = auVar168._0_12_;
auVar200._12_2_ = sVar115;
auVar200._14_2_ = -(ushort)(sVar115 < 0);
auVar199._12_4_ = auVar200._12_4_;
auVar199._0_10_ = auVar168._0_10_;
auVar199._10_2_ = -(ushort)(sVar111 < 0);
auVar198._10_6_ = auVar199._10_6_;
auVar198._0_8_ = auVar168._0_8_;
auVar198._8_2_ = sVar111;
auVar66._4_8_ = auVar198._8_8_;
auVar66._2_2_ = -(ushort)(auVar61._0_2_ < 0);
auVar66._0_2_ = auVar61._0_2_;
auVar178._12_2_ = sVar115;
auVar178._0_12_ = auVar200._0_12_;
auVar178._14_2_ = -(ushort)(sVar115 < 0);
auVar177._12_4_ = auVar178._12_4_;
auVar177._10_2_ = -(ushort)(sVar111 < 0);
auVar177._0_10_ = auVar199._0_10_;
auVar176._10_6_ = auVar177._10_6_;
auVar176._8_2_ = sVar111;
auVar176._0_8_ = auVar198._0_8_;
sVar111 = auVar104._12_2_;
auVar194._12_2_ = auVar105._14_2_;
auVar194._0_12_ = auVar89;
auVar194._14_2_ = -(ushort)(lVar116 < 0);
auVar193._12_4_ = auVar194._12_4_;
auVar193._0_10_ = auVar89._0_10_;
auVar193._10_2_ = -(ushort)(sVar111 < 0);
auVar192._10_6_ = auVar193._10_6_;
auVar192._8_2_ = sVar111;
auVar192._0_8_ = lVar116;
auVar191._8_8_ = auVar192._8_8_;
auVar191._6_2_ = -(ushort)(auVar100._8_4_ < 0);
auVar191._4_2_ = auVar102._10_2_;
auVar191._0_4_ = auVar100._8_4_;
auVar109._12_2_ = auVar105._14_2_;
auVar109._0_12_ = auVar89;
auVar109._14_2_ = -(ushort)(lVar116 < 0);
auVar108._12_4_ = auVar109._12_4_;
auVar108._10_2_ = -(ushort)(sVar111 < 0);
auVar108._0_10_ = auVar193._0_10_;
auVar107._10_6_ = auVar108._10_6_;
auVar107._8_2_ = sVar111;
auVar107._0_8_ = lVar116;
auVar185[0xe] = bVar148;
auVar185._0_14_ = auVar133;
auVar185[0xf] = cVar167;
auVar184._14_2_ = auVar185._14_2_;
auVar184[0xd] = cVar166;
auVar184._0_13_ = auVar132;
auVar183._13_3_ = auVar184._13_3_;
auVar183[0xc] = cVar147;
auVar183._0_12_ = auVar130;
auVar182._12_4_ = auVar183._12_4_;
auVar182[0xb] = cVar165;
auVar182._0_11_ = auVar129;
auVar181._11_5_ = auVar182._11_5_;
auVar181[10] = cVar146;
auVar181._0_10_ = auVar129._0_10_;
auVar180._10_6_ = auVar181._10_6_;
auVar180[9] = cVar164;
auVar180._0_9_ = auVar135._0_9_;
Var56 = CONCAT91(CONCAT81((long)(CONCAT72(auVar180._9_7_,CONCAT11(cVar144,bVar148)) >> 8),
cVar163),-bVar4);
auVar68._2_10_ = Var56;
auVar68[1] = -bVar3;
auVar68[0] = -bVar3;
auVar67._2_12_ = auVar68;
auVar67[1] = cVar162;
auVar67[0] = cVar127;
auVar179._0_2_ = CONCAT11(-bVar1,auVar134[0]);
auVar179._2_14_ = auVar67;
auVar140[0xe] = bVar148;
auVar140._0_14_ = auVar133;
auVar140[0xf] = cVar167;
auVar139._14_2_ = auVar140._14_2_;
auVar139[0xd] = cVar166;
auVar139._0_13_ = auVar132;
auVar138._13_3_ = auVar139._13_3_;
auVar138[0xc] = cVar147;
auVar138._0_12_ = auVar130;
auVar137._12_4_ = auVar138._12_4_;
auVar137[0xb] = cVar165;
auVar137._0_11_ = auVar129;
auVar136._11_5_ = auVar137._11_5_;
auVar136[10] = cVar146;
auVar136._0_10_ = auVar129._0_10_;
auVar135._10_6_ = auVar136._10_6_;
auVar135[9] = cVar164;
Var73 = CONCAT72(auVar135._9_7_,CONCAT11(cVar144,bVar148));
lVar116 = (long)((unkuint9)Var73 >> 8);
auVar71._1_8_ = lVar116;
auVar71[0] = cVar163;
auVar71._9_7_ = 0;
auVar70._10_6_ = 0;
auVar70._0_10_ = SUB1610(auVar71 << 0x38,6);
auVar69._11_5_ = 0;
auVar69._0_11_ = SUB1611(auVar70 << 0x30,5);
auVar134._4_12_ = SUB1612(auVar69 << 0x28,4);
auVar134[3] = cVar162;
auVar134[2] = cVar127;
auVar134[1] = -bVar1;
sVar117 = auVar68._0_2_;
sVar118 = (short)Var56;
iVar75 = (int)((unkuint9)Var73 >> 8);
auVar131._8_4_ = auVar134._0_4_;
auVar131._0_8_ = lVar116;
sVar111 = (short)((unkuint9)Var73 >> 8);
sVar115 = auVar138._12_2_;
auVar197._0_12_ = auVar179._0_12_;
auVar197._12_2_ = sVar118;
auVar197._14_2_ = -(ushort)(sVar118 < 0);
auVar196._12_4_ = auVar197._12_4_;
auVar196._0_10_ = auVar179._0_10_;
auVar196._10_2_ = -(ushort)(sVar117 < 0);
auVar195._10_6_ = auVar196._10_6_;
auVar195._0_8_ = auVar179._0_8_;
auVar195._8_2_ = sVar117;
auVar72._4_8_ = auVar195._8_8_;
auVar72._2_2_ = -(ushort)(auVar67._0_2_ < 0);
auVar72._0_2_ = auVar67._0_2_;
auVar188._12_2_ = sVar118;
auVar188._0_12_ = auVar197._0_12_;
auVar188._14_2_ = -(ushort)(sVar118 < 0);
auVar187._12_4_ = auVar188._12_4_;
auVar187._10_2_ = -(ushort)(sVar117 < 0);
auVar187._0_10_ = auVar196._0_10_;
auVar186._10_6_ = auVar187._10_6_;
auVar186._8_2_ = sVar117;
auVar186._0_8_ = auVar195._0_8_;
auVar161._12_2_ = auVar139._14_2_;
auVar161._0_12_ = auVar131;
auVar161._14_2_ = -(ushort)(lVar116 < 0);
auVar160._12_4_ = auVar161._12_4_;
auVar160._0_10_ = auVar131._0_10_;
auVar160._10_2_ = -(ushort)(sVar115 < 0);
auVar159._10_6_ = auVar160._10_6_;
auVar159._8_2_ = sVar115;
auVar159._0_8_ = lVar116;
auVar158._8_8_ = auVar159._8_8_;
auVar158._6_2_ = -(ushort)(iVar75 < 0);
auVar158._4_2_ = auVar136._10_2_;
auVar158._0_4_ = iVar75;
auVar143._12_2_ = auVar139._14_2_;
auVar143._0_12_ = auVar131;
auVar143._14_2_ = -(ushort)(lVar116 < 0);
auVar142._12_4_ = auVar143._12_4_;
auVar142._10_2_ = -(ushort)(sVar115 < 0);
auVar142._0_10_ = auVar160._0_10_;
auVar141._10_6_ = auVar142._10_6_;
auVar141._8_2_ = sVar115;
auVar141._0_8_ = lVar116;
iVar75 = ((((iVar190 - auVar72._0_4_) - auVar187._12_4_) - auVar158._4_4_) - auVar142._12_4_)
+ ((((iVar189 - CONCAT22(-(ushort)bVar1,auVar179._0_2_)) - auVar186._8_4_) -
CONCAT22(-(ushort)(sVar111 < 0),sVar111)) - auVar141._8_4_);
iVar154 = ((((iVar128 - CONCAT22(-(ushort)(auVar99[0] < '\0'),auVar168._0_2_)) -
auVar176._8_4_) - CONCAT22(-(ushort)(auVar100._8_2_ < 0),auVar100._8_2_)) -
auVar107._8_4_) +
((((iVar145 - auVar66._0_4_) - auVar177._12_4_) - auVar191._4_4_) - auVar108._12_4_)
;
uVar79 = uVar79 + (uVar78 & 0xfffffff8);
if ((uVar78 & 7) == 0) goto LAB_00101c20;
}
if ((byte)(param_1[(int)uVar79] - 0x30U) < 10) {
iVar75 = iVar75 + 1;
}
else {
iVar154 = iVar154 + (uint)(param_1[(int)uVar79] == '.');
}
if ((int)(uVar79 + 1) < (int)uVar74) {
if ((byte)(param_1[(int)(uVar79 + 1)] - 0x30U) < 10) {
iVar75 = iVar75 + 1;
}
else {
iVar154 = iVar154 + (uint)(param_1[(int)(uVar79 + 1)] == '.');
}
if ((int)(uVar79 + 2) < (int)uVar74) {
if ((byte)(param_1[(int)(uVar79 + 2)] - 0x30U) < 10) {
iVar75 = iVar75 + 1;
}
else {
iVar154 = iVar154 + (uint)(param_1[(int)(uVar79 + 2)] == '.');
}
if ((int)(uVar79 + 3) < (int)uVar74) {
if ((byte)(param_1[(int)(uVar79 + 3)] - 0x30U) < 10) {
iVar75 = iVar75 + 1;
}
else {
iVar154 = iVar154 + (uint)(param_1[(int)(uVar79 + 3)] == '.');
}
if ((int)(uVar79 + 4) < (int)uVar74) {
if ((byte)(param_1[(int)(uVar79 + 4)] - 0x30U) < 10) {
iVar75 = iVar75 + 1;
}
else {
iVar154 = iVar154 + (uint)(param_1[(int)(uVar79 + 4)] == '.');
}
if ((int)(uVar79 + 5) < (int)uVar74) {
if ((byte)(param_1[(int)(uVar79 + 5)] - 0x30U) < 10) {
iVar75 = iVar75 + 1;
}
else {
iVar154 = iVar154 + (uint)(param_1[(int)(uVar79 + 5)] == '.');
}
if ((int)(uVar79 + 6) < (int)uVar74) {
if ((byte)(param_1[(int)(uVar79 + 6)] - 0x30U) < 10) {
iVar75 = iVar75 + 1;
}
else {
iVar154 = iVar154 + (uint)(param_1[(int)(uVar79 + 6)] == '.');
}
}
}
}
}
}
}
}
else {
iVar128 = 0;
iVar145 = 0;
iVar149 = 0;
iVar150 = 0;
iVar75 = 0;
iVar154 = 0;
iVar155 = 0;
iVar156 = 0;
auVar97._8_8_ = _UNK_00102678;
auVar97._0_8_ = DAT_00102670;
pcVar77 = param_1;
do {
cVar81 = *pcVar77;
pcVar24 = pcVar77 + 1;
pcVar25 = pcVar77 + 2;
pcVar26 = pcVar77 + 3;
pcVar27 = pcVar77 + 4;
pcVar28 = pcVar77 + 5;
pcVar29 = pcVar77 + 6;
pcVar30 = pcVar77 + 7;
pcVar31 = pcVar77 + 8;
pcVar32 = pcVar77 + 9;
pcVar33 = pcVar77 + 10;
pcVar34 = pcVar77 + 0xb;
pcVar35 = pcVar77 + 0xc;
pcVar36 = pcVar77 + 0xd;
pcVar37 = pcVar77 + 0xe;
pcVar38 = pcVar77 + 0xf;
cVar110 = *pcVar77;
pcVar39 = pcVar77 + 1;
pcVar40 = pcVar77 + 2;
pcVar41 = pcVar77 + 3;
pcVar42 = pcVar77 + 4;
pcVar43 = pcVar77 + 5;
pcVar44 = pcVar77 + 6;
pcVar45 = pcVar77 + 7;
pcVar46 = pcVar77 + 8;
pcVar47 = pcVar77 + 9;
pcVar48 = pcVar77 + 10;
pcVar49 = pcVar77 + 0xb;
pcVar50 = pcVar77 + 0xc;
pcVar51 = pcVar77 + 0xd;
pcVar52 = pcVar77 + 0xe;
pcVar53 = pcVar77 + 0xf;
pcVar77 = pcVar77 + 0x10;
auVar91[0] = cVar81 + (char)DAT_00102650;
auVar91[1] = *pcVar24 + DAT_00102650._1_1_;
auVar91[2] = *pcVar25 + DAT_00102650._2_1_;
auVar91[3] = *pcVar26 + DAT_00102650._3_1_;
auVar91[4] = *pcVar27 + DAT_00102650._4_1_;
auVar91[5] = *pcVar28 + DAT_00102650._5_1_;
auVar91[6] = *pcVar29 + DAT_00102650._6_1_;
auVar91[7] = *pcVar30 + DAT_00102650._7_1_;
auVar91[8] = *pcVar31 + UNK_00102658;
auVar91[9] = *pcVar32 + UNK_00102659;
auVar91[10] = *pcVar33 + UNK_0010265a;
auVar91[0xb] = *pcVar34 + UNK_0010265b;
auVar91[0xc] = *pcVar35 + UNK_0010265c;
auVar91[0xd] = *pcVar36 + UNK_0010265d;
auVar91[0xe] = *pcVar37 + UNK_0010265e;
auVar91[0xf] = *pcVar38 + UNK_0010265f;
auVar202[0] = -(cVar110 == (char)DAT_00102680);
auVar202[1] = -(*pcVar39 == DAT_00102680._1_1_);
auVar202[2] = -(*pcVar40 == DAT_00102680._2_1_);
auVar202[3] = -(*pcVar41 == DAT_00102680._3_1_);
auVar202[4] = -(*pcVar42 == DAT_00102680._4_1_);
auVar202[5] = -(*pcVar43 == DAT_00102680._5_1_);
auVar202[6] = -(*pcVar44 == DAT_00102680._6_1_);
auVar202[7] = -(*pcVar45 == DAT_00102680._7_1_);
auVar202[8] = -(*pcVar46 == UNK_00102688);
auVar202[9] = -(*pcVar47 == UNK_00102689);
auVar202[10] = -(*pcVar48 == UNK_0010268a);
auVar202[0xb] = -(*pcVar49 == UNK_0010268b);
auVar202[0xc] = -(*pcVar50 == UNK_0010268c);
auVar202[0xd] = -(*pcVar51 == UNK_0010268d);
auVar202[0xe] = -(*pcVar52 == UNK_0010268e);
auVar202[0xf] = -(*pcVar53 == UNK_0010268f);
auVar124 = psubusb(_DAT_00102660,auVar91);
auVar91 = psubusb(auVar91,auVar97);
bVar1 = auVar124[0] != '\0';
bVar2 = auVar124[1] != '\0';
bVar3 = auVar124[2] != '\0';
bVar4 = auVar124[3] != '\0';
bVar5 = auVar124[4] != '\0';
bVar6 = auVar124[5] != '\0';
bVar7 = auVar124[6] != '\0';
bVar8 = auVar124[7] != '\0';
bVar9 = auVar124[8] != '\0';
bVar10 = auVar124[9] != '\0';
bVar11 = auVar124[10] != '\0';
bVar12 = auVar124[0xb] != '\0';
bVar13 = auVar124[0xc] != '\0';
bVar14 = auVar124[0xd] != '\0';
bVar15 = auVar124[0xe] != '\0';
bVar16 = auVar124[0xf] != '\0';
auVar124[0] = -(auVar91[0] != '\0');
auVar124[1] = -(auVar91[1] != '\0');
auVar124[2] = -(auVar91[2] != '\0');
auVar124[3] = -(auVar91[3] != '\0');
auVar124[4] = -(auVar91[4] != '\0');
auVar124[5] = -(auVar91[5] != '\0');
auVar124[6] = -(auVar91[6] != '\0');
auVar124[7] = -(auVar91[7] != '\0');
auVar124[8] = -(auVar91[8] != '\0');
auVar124[9] = -(auVar91[9] != '\0');
auVar124[10] = -(auVar91[10] != '\0');
auVar124[0xb] = -(auVar91[0xb] != '\0');
auVar124[0xc] = -(auVar91[0xc] != '\0');
auVar124[0xd] = -(auVar91[0xd] != '\0');
auVar124[0xe] = -(auVar91[0xe] != '\0');
auVar124[0xf] = -(auVar91[0xf] != '\0');
cVar127 = -bVar8;
auVar124 = auVar124 & auVar202;
cVar81 = auVar124[0];
cVar110 = auVar124[8];
cVar112 = auVar124[9];
cVar113 = auVar124[10];
cVar114 = auVar124[0xb];
auVar210._0_14_ = auVar124._0_14_;
auVar210[0xe] = auVar124[7];
auVar210[0xf] = -(auVar124[7] < '\0');
auVar209._14_2_ = auVar210._14_2_;
auVar209._0_13_ = auVar124._0_13_;
auVar209[0xd] = -(auVar124[6] < '\0');
auVar208._13_3_ = auVar209._13_3_;
auVar208._0_12_ = auVar124._0_12_;
auVar208[0xc] = auVar124[6];
auVar207._12_4_ = auVar208._12_4_;
auVar207._0_11_ = auVar124._0_11_;
auVar207[0xb] = -(auVar124[5] < '\0');
auVar206._11_5_ = auVar207._11_5_;
auVar206._0_10_ = auVar124._0_10_;
auVar206[10] = auVar124[5];
auVar205._10_6_ = auVar206._10_6_;
auVar205._0_9_ = auVar124._0_9_;
auVar205[9] = -(auVar124[4] < '\0');
auVar204._9_7_ = auVar205._9_7_;
auVar204._0_8_ = auVar124._0_8_;
auVar204[8] = auVar124[4];
Var56 = CONCAT91(CONCAT81(auVar204._8_8_,-(auVar124[3] < '\0')),auVar124[3]);
auVar55._2_10_ = Var56;
auVar55[1] = -(auVar124[2] < '\0');
auVar55[0] = auVar124[2];
auVar54._2_12_ = auVar55;
auVar54[1] = -(auVar124[1] < '\0');
auVar54[0] = auVar124[1];
auVar203._0_2_ = CONCAT11(-(cVar81 < '\0'),cVar81);
auVar203._2_14_ = auVar54;
uVar82 = CONCAT11(-(cVar110 < '\0'),cVar110);
uVar83 = CONCAT13(-(cVar112 < '\0'),CONCAT12(cVar112,uVar82));
uVar84 = CONCAT15(-(cVar113 < '\0'),CONCAT14(cVar113,uVar83));
uVar85 = CONCAT17(-(cVar114 < '\0'),CONCAT16(cVar114,uVar84));
auVar86._0_10_ = CONCAT19(-(auVar124[0xc] < '\0'),CONCAT18(auVar124[0xc],uVar85));
auVar86[10] = auVar124[0xd];
auVar86[0xb] = -(auVar124[0xd] < '\0');
auVar90[0xc] = auVar124[0xe];
auVar90._0_12_ = auVar86;
auVar90[0xd] = -(auVar124[0xe] < '\0');
auVar92[0xe] = auVar124[0xf];
auVar92._0_14_ = auVar90;
auVar92[0xf] = -(auVar124[0xf] < '\0');
sVar111 = (short)Var56;
auVar227._0_12_ = auVar203._0_12_;
auVar227._12_2_ = sVar111;
auVar227._14_2_ = -(ushort)(sVar111 < 0);
auVar226._12_4_ = auVar227._12_4_;
auVar226._0_10_ = auVar203._0_10_;
auVar226._10_2_ = -(ushort)(auVar55._0_2_ < 0);
auVar225._10_6_ = auVar226._10_6_;
auVar225._0_8_ = auVar203._0_8_;
auVar225._8_2_ = auVar55._0_2_;
auVar57._4_8_ = auVar225._8_8_;
auVar57._2_2_ = -(ushort)(auVar54._0_2_ < 0);
auVar57._0_2_ = auVar54._0_2_;
iVar190 = CONCAT22(-(ushort)(auVar204._8_2_ < 0),auVar204._8_2_);
auVar201._0_8_ = CONCAT26(-(ushort)(auVar206._10_2_ < 0),CONCAT24(auVar206._10_2_,iVar190));
auVar201._8_2_ = auVar208._12_2_;
auVar201._10_2_ = -(ushort)(auVar208._12_2_ < 0);
auVar211._12_2_ = auVar209._14_2_;
auVar211._0_12_ = auVar201;
auVar211._14_2_ = -(ushort)(auVar204._8_8_ < 0);
sVar111 = (short)((unkuint10)auVar86._0_10_ >> 0x40);
auVar221._12_2_ = (short)((ulong)uVar85 >> 0x30);
auVar221._0_12_ = auVar86;
auVar221._14_2_ = -(ushort)(cVar114 < '\0');
auVar220._12_4_ = auVar221._12_4_;
auVar220._10_2_ = -(ushort)(cVar113 < '\0');
auVar220._0_10_ = auVar86._0_10_;
auVar219._10_6_ = auVar220._10_6_;
auVar219._8_2_ = (short)((uint6)uVar84 >> 0x20);
auVar219._0_8_ = uVar85;
auVar218._8_8_ = auVar219._8_8_;
auVar218._6_2_ = -(ushort)(cVar112 < '\0');
auVar218._0_6_ = uVar84;
auVar217._6_10_ = auVar218._6_10_;
auVar217._4_2_ = (short)((uint)uVar83 >> 0x10);
auVar217._0_4_ = uVar83;
iVar189 = CONCAT22(-(ushort)(sVar111 < 0),sVar111);
auVar87._0_8_ = CONCAT26(-(ushort)(auVar86._10_2_ < 0),CONCAT24(auVar86._10_2_,iVar189));
auVar87._8_2_ = auVar90._12_2_;
auVar87._10_2_ = -(ushort)(auVar90._12_2_ < 0);
auVar93._12_2_ = auVar92._14_2_;
auVar93._0_12_ = auVar87;
auVar93._14_2_ = -(ushort)(auVar92._14_2_ < 0);
iVar128 = (((iVar128 - CONCAT22(-(ushort)(cVar81 < '\0'),auVar203._0_2_)) - iVar190) -
CONCAT22(-(ushort)(cVar110 < '\0'),uVar82)) - iVar189;
iVar145 = (((iVar145 - auVar57._0_4_) - (int)((ulong)auVar201._0_8_ >> 0x20)) - auVar217._4_4_
) - (int)((ulong)auVar87._0_8_ >> 0x20);
iVar149 = (((iVar149 - auVar225._8_4_) - auVar201._8_4_) - auVar219._8_4_) - auVar87._8_4_;
iVar150 = (((iVar150 - auVar226._12_4_) - auVar211._12_4_) - auVar220._12_4_) - auVar93._12_4_
;
uVar82 = CONCAT11(-bVar8,cVar127);
uVar83 = CONCAT31(CONCAT21(uVar82,-bVar7),-bVar7);
uVar84 = CONCAT51(CONCAT41(uVar83,-bVar6),-bVar6);
Var73 = CONCAT72(CONCAT61(uVar84,-bVar5),CONCAT11(-bVar5,cVar127));
lVar116 = (long)((unkuint9)Var73 >> 8);
Var56 = CONCAT91(CONCAT81(lVar116,-bVar4),-bVar4);
auVar59._2_10_ = Var56;
auVar59[1] = -bVar3;
auVar59[0] = -bVar3;
auVar58._2_12_ = auVar59;
auVar58[1] = -bVar2;
auVar58[0] = -bVar2;
auVar94._0_2_ = CONCAT11(-bVar1,-bVar1);
auVar94._2_14_ = auVar58;
uVar119 = CONCAT13(-bVar10,CONCAT12(-bVar10,CONCAT11(-bVar9,-bVar9)));
uVar120 = CONCAT15(-bVar11,CONCAT14(-bVar11,uVar119));
uVar85 = CONCAT17(-bVar12,CONCAT16(-bVar12,uVar120));
auVar121._0_10_ = CONCAT19(-bVar13,CONCAT18(-bVar13,uVar85));
auVar121[10] = -bVar14;
auVar121[0xb] = -bVar14;
auVar123[0xc] = -bVar15;
auVar123._0_12_ = auVar121;
auVar123[0xd] = -bVar15;
auVar125[0xe] = -bVar16;
auVar125._0_14_ = auVar123;
auVar125[0xf] = -bVar16;
sVar111 = (short)Var56;
sVar115 = (short)((unkuint9)Var73 >> 8);
sVar117 = (short)uVar84;
sVar118 = (short)uVar83;
auVar224._0_12_ = auVar94._0_12_;
auVar224._12_2_ = sVar111;
auVar224._14_2_ = -(ushort)(sVar111 < 0);
auVar223._12_4_ = auVar224._12_4_;
auVar223._0_10_ = auVar94._0_10_;
auVar223._10_2_ = -(ushort)(auVar59._0_2_ < 0);
auVar222._10_6_ = auVar223._10_6_;
auVar222._0_8_ = auVar94._0_8_;
auVar222._8_2_ = auVar59._0_2_;
auVar60._4_8_ = auVar222._8_8_;
auVar60._2_2_ = -(ushort)(auVar58._0_2_ < 0);
auVar60._0_2_ = auVar58._0_2_;
iVar189 = CONCAT22(-(ushort)(sVar115 < 0),sVar115);
auVar88._0_8_ = CONCAT26(-(ushort)(sVar117 < 0),CONCAT24(sVar117,iVar189));
auVar88._8_2_ = sVar118;
auVar88._10_2_ = -(ushort)(sVar118 < 0);
auVar95._12_2_ = uVar82;
auVar95._0_12_ = auVar88;
auVar95._14_2_ = -(ushort)(lVar116 < 0);
sVar111 = (short)((unkuint10)auVar121._0_10_ >> 0x40);
auVar216._12_2_ = (short)((ulong)uVar85 >> 0x30);
auVar216._0_12_ = auVar121;
auVar216._14_2_ = -(ushort)bVar12;
auVar215._12_4_ = auVar216._12_4_;
auVar215._10_2_ = -(ushort)bVar11;
auVar215._0_10_ = auVar121._0_10_;
auVar214._10_6_ = auVar215._10_6_;
auVar214._8_2_ = (short)((uint6)uVar120 >> 0x20);
auVar214._0_8_ = uVar85;
auVar213._8_8_ = auVar214._8_8_;
auVar213._6_2_ = -(ushort)bVar10;
auVar213._0_6_ = uVar120;
auVar212._6_10_ = auVar213._6_10_;
auVar212._4_2_ = (short)((uint)uVar119 >> 0x10);
auVar212._0_4_ = uVar119;
iVar190 = CONCAT22(-(ushort)(sVar111 < 0),sVar111);
auVar122._0_8_ = CONCAT26(-(ushort)(auVar121._10_2_ < 0),CONCAT24(auVar121._10_2_,iVar190));
auVar122._8_2_ = auVar123._12_2_;
auVar122._10_2_ = -(ushort)(auVar123._12_2_ < 0);
auVar126._12_2_ = auVar125._14_2_;
auVar126._0_12_ = auVar122;
auVar126._14_2_ = -(ushort)(auVar125._14_2_ < 0);
iVar75 = (((iVar75 - CONCAT22(-(ushort)bVar1,auVar94._0_2_)) - iVar189) -
CONCAT22(-(ushort)bVar9,CONCAT11(-bVar9,-bVar9))) - iVar190;
iVar154 = (((iVar154 - auVar60._0_4_) - (int)((ulong)auVar88._0_8_ >> 0x20)) - auVar212._4_4_)
- (int)((ulong)auVar122._0_8_ >> 0x20);
iVar155 = (((iVar155 - auVar222._8_4_) - auVar88._8_4_) - auVar214._8_4_) - auVar122._8_4_;
iVar156 = (((iVar156 - auVar223._12_4_) - auVar95._12_4_) - auVar215._12_4_) - auVar126._12_4_
;
} while (pcVar77 != param_1 + (sVar76 >> 4 & 0xfffffff) * 0x10);
uVar79 = uVar74 & 0xfffffff0;
uVar80 = (ulong)uVar79;
iVar189 = iVar155 + iVar75;
iVar190 = iVar156 + iVar154;
iVar75 = iVar155 + iVar75 + iVar156 + iVar154;
iVar154 = iVar149 + iVar128 + iVar150 + iVar145;
iVar128 = iVar128 + iVar149;
iVar145 = iVar145 + iVar150;
if ((sVar76 & 0xf) != 0) goto LAB_001019da;
}
LAB_00101c20:
if ((iVar75 < 4) && (iVar154 == 1)) {
return &DAT_00102007;
}
LAB_00101c40:
return &DAT_00102004;
}
|
1,224 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
}
|
#include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 9);
}
{
int lst[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -3);
}
{
int lst[] = {0};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-1, -5, 2, -1, -5};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -126);
}
{
int lst[] = {-56, -99, 1, 0, -2};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 3030);
}
{
int lst[] = {-1, 0, 0, 0, 0, 0, 0, 0, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -14196);
}
{
int lst[] = {-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -1448);
}
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)
jmpq 1260 <func0+0xf7>
mov -0x4(%rbp),%ecx
movslq %ecx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %rax,%rdx
mov %ecx,%eax
sar $0x1f,%eax
mov %edx,%esi
sub %eax,%esi
mov %esi,%eax
mov %eax,%edx
add %edx,%edx
add %eax,%edx
mov %ecx,%eax
sub %edx,%eax
test %eax,%eax
jne 11ec <func0+0x83>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
imul %edx,%eax
add %eax,-0x8(%rbp)
jmp 125c <func0+0xf3>
mov -0x4(%rbp),%eax
and $0x3,%eax
test %eax,%eax
jne 1243 <func0+0xda>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
imul %eax,%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
imul %edx,%eax
add %eax,-0x8(%rbp)
jmp 125c <func0+0xf3>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118b <func0+0x22>
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 loc_125C
loc_118B:
mov ecx, [rbp+var_4]
movsxd rax, ecx
imul rax, 55555556h
shr rax, 20h
mov rdx, rax
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
add eax, eax
add eax, edx
sub ecx, eax
mov edx, ecx
test edx, edx
jnz short loc_11E8
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
imul eax, edx
add [rbp+var_8], eax
jmp short loc_1258
loc_11E8:
mov eax, [rbp+var_4]
and eax, 3
test eax, eax
jnz short loc_123F
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
imul edx, eax
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
imul eax, edx
add [rbp+var_8], eax
jmp short loc_1258
loc_123F:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_1258:
add [rbp+var_4], 1
loc_125C:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_118B
mov eax, [rbp+var_8]
pop rbp
retn
|
long long func0(long long a1, int a2)
{
int v2; // eax
unsigned int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( i % 3 )
{
if ( (i & 3) != 0 )
v2 = *(_DWORD *)(4LL * i + a1);
else
v2 = *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4LL * i + a1);
v4 += v2;
}
else
{
v4 += *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4LL * i + a1);
}
}
return v4;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010125c
LAB_0010118b:
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV RDX,RAX
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
SUB ECX,EAX
MOV EDX,ECX
TEST EDX,EDX
JNZ 0x001011e8
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
ADD dword ptr [RBP + -0x8],EAX
JMP 0x00101258
LAB_001011e8:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x3
TEST EAX,EAX
JNZ 0x0010123f
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
IMUL EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
ADD dword ptr [RBP + -0x8],EAX
JMP 0x00101258
LAB_0010123f:
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]
ADD dword ptr [RBP + -0x8],EAX
LAB_00101258:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010125c:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118b
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; (int)local_c < param_2; local_c = local_c + 1) {
if ((int)local_c % 3 == 0) {
local_10 = local_10 +
*(int *)(param_1 + (long)(int)local_c * 4) *
*(int *)(param_1 + (long)(int)local_c * 4);
}
else if ((local_c & 3) == 0) {
local_10 = local_10 +
*(int *)(param_1 + (long)(int)local_c * 4) *
*(int *)(param_1 + (long)(int)local_c * 4) *
*(int *)(param_1 + (long)(int)local_c * 4);
}
else {
local_10 = local_10 + *(int *)(param_1 + (long)(int)local_c * 4);
}
}
return local_10;
}
|
1,225 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
}
|
#include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 9);
}
{
int lst[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -3);
}
{
int lst[] = {0};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-1, -5, 2, -1, -5};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -126);
}
{
int lst[] = {-56, -99, 1, 0, -2};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 3030);
}
{
int lst[] = {-1, 0, 0, 0, 0, 0, 0, 0, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -14196);
}
{
int lst[] = {-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -1448);
}
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11ca <func0+0x61>
lea -0x1(%rsi),%r8d
mov $0x0,%edx
mov $0x0,%ecx
jmp 119f <func0+0x36>
test $0x3,%dl
jne 11c5 <func0+0x5c>
mov (%rdi,%rdx,4),%esi
mov %esi,%eax
imul %esi,%eax
imul %esi,%eax
add %eax,%ecx
lea 0x1(%rdx),%rax
cmp %r8,%rdx
je 11cf <func0+0x66>
mov %rax,%rdx
movslq %edx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %edx,%esi
sar $0x1f,%esi
sub %esi,%eax
lea (%rax,%rax,2),%eax
cmp %edx,%eax
jne 1181 <func0+0x18>
mov (%rdi,%rdx,4),%eax
imul %eax,%eax
add %eax,%ecx
jmp 1193 <func0+0x2a>
add (%rdi,%rdx,4),%ecx
jmp 1193 <func0+0x2a>
mov $0x0,%ecx
mov %ecx,%eax
retq
|
func0:
endbr64
mov r8, rdi
test esi, esi
jle short loc_11CC
movsxd rsi, esi
mov edx, 0
mov ecx, 0
jmp short loc_119F
loc_1183:
test dl, 3
jnz short loc_11C6
mov edi, [r8+rdx*4]
mov eax, edi
imul eax, edi
imul eax, edi
add ecx, eax
loc_1196:
add rdx, 1
cmp rdx, rsi
jz short loc_11D1
loc_119F:
movsxd rax, edx
imul rax, 55555556h
shr rax, 20h
mov edi, edx
sar edi, 1Fh
sub eax, edi
lea eax, [rax+rax*2]
cmp eax, edx
jnz short loc_1183
mov eax, [r8+rdx*4]
imul eax, eax
add ecx, eax
jmp short loc_1196
loc_11C6:
add ecx, [r8+rdx*4]
jmp short loc_1196
loc_11CC:
mov ecx, 0
loc_11D1:
mov eax, ecx
retn
|
long long func0(long long a1, int a2)
{
long long v2; // rdx
unsigned int v3; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 0LL;
v3 = 0;
do
{
if ( 3 * ((int)v2 / 3) == (_DWORD)v2 )
{
v3 += *(_DWORD *)(a1 + 4 * v2) * *(_DWORD *)(a1 + 4 * v2);
}
else if ( (v2 & 3) != 0 )
{
v3 += *(_DWORD *)(a1 + 4 * v2);
}
else
{
v3 += *(_DWORD *)(a1 + 4 * v2) * *(_DWORD *)(a1 + 4 * v2) * *(_DWORD *)(a1 + 4 * v2);
}
++v2;
}
while ( v2 != a2 );
}
return v3;
}
|
func0:
ENDBR64
MOV R8,RDI
TEST ESI,ESI
JLE 0x001011cc
MOVSXD RSI,ESI
MOV EDX,0x0
MOV ECX,0x0
JMP 0x0010119f
LAB_00101183:
TEST DL,0x3
JNZ 0x001011c6
MOV EDI,dword ptr [R8 + RDX*0x4]
MOV EAX,EDI
IMUL EAX,EDI
IMUL EAX,EDI
ADD ECX,EAX
LAB_00101196:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x001011d1
LAB_0010119f:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV EDI,EDX
SAR EDI,0x1f
SUB EAX,EDI
LEA EAX,[RAX + RAX*0x2]
CMP EAX,EDX
JNZ 0x00101183
MOV EAX,dword ptr [R8 + RDX*0x4]
IMUL EAX,EAX
ADD ECX,EAX
JMP 0x00101196
LAB_001011c6:
ADD ECX,dword ptr [R8 + RDX*0x4]
JMP 0x00101196
LAB_001011cc:
MOV ECX,0x0
LAB_001011d1:
MOV EAX,ECX
RET
|
int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
ulong uVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
uVar3 = 0;
iVar2 = 0;
do {
if (((int)uVar3 / 3) * 3 == (int)uVar3) {
iVar1 = *(int *)(param_1 + uVar3 * 4);
iVar2 = iVar2 + iVar1 * iVar1;
}
else if ((uVar3 & 3) == 0) {
iVar1 = *(int *)(param_1 + uVar3 * 4);
iVar2 = iVar2 + iVar1 * iVar1 * iVar1;
}
else {
iVar2 = iVar2 + *(int *)(param_1 + uVar3 * 4);
}
uVar3 = uVar3 + 1;
} while (uVar3 != (long)param_2);
}
return iVar2;
}
|
1,226 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
}
|
#include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 9);
}
{
int lst[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -3);
}
{
int lst[] = {0};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-1, -5, 2, -1, -5};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -126);
}
{
int lst[] = {-56, -99, 1, 0, -2};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 3030);
}
{
int lst[] = {-1, 0, 0, 0, 0, 0, 0, 0, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -14196);
}
{
int lst[] = {-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -1448);
}
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1628 <func0+0x68>
sub $0x1,%esi
xor %eax,%eax
xor %r8d,%r8d
jmp 15ea <func0+0x2a>
nopw 0x0(%rax,%rax,1)
imul %edx,%edx
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 1613 <func0+0x53>
mov %rdx,%rax
imul $0xaaaaaaab,%eax,%ecx
mov (%rdi,%rax,4),%edx
cmp $0x55555555,%ecx
jbe 15d8 <func0+0x18>
test $0x3,%al
jne 1620 <func0+0x60>
mov %edx,%ecx
imul %edx,%ecx
imul %ecx,%edx
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rsi,%rax
jne 15e7 <func0+0x27>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
add %edx,%r8d
jmp 15de <func0+0x1e>
nopl (%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_1540
movsxd rsi, esi
xor eax, eax
xor ecx, ecx
jmp short loc_1506
loc_14F8:
imul edx, edx
add ecx, edx
loc_14FD:
add rax, 1
cmp rax, rsi
jz short loc_1531
loc_1506:
imul edx, eax, 0AAAAAAABh
cmp edx, 55555555h
mov edx, [rdi+rax*4]
jbe short loc_14F8
test al, 3
jnz short loc_1538
mov r8d, edx
add rax, 1
imul r8d, edx
imul edx, r8d
add ecx, edx
cmp rax, rsi
jnz short loc_1506
loc_1531:
mov eax, ecx
retn
loc_1538:
add ecx, edx
jmp short loc_14FD
loc_1540:
xor ecx, ecx
mov eax, ecx
retn
|
long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // ecx
int v4; // edx
if ( a2 > 0 )
{
v2 = 0LL;
v3 = 0;
while ( 1 )
{
while ( 1 )
{
v4 = *(_DWORD *)(a1 + 4 * v2);
if ( (unsigned int)(-1431655765 * v2) > 0x55555555 )
break;
v3 += v4 * v4;
LABEL_4:
if ( ++v2 == a2 )
return v3;
}
if ( (v2 & 3) != 0 )
{
v3 += v4;
goto LABEL_4;
}
++v2;
v3 += v4 * v4 * v4;
if ( v2 == a2 )
return v3;
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101540
MOVSXD RSI,ESI
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101506
LAB_001014f8:
IMUL EDX,EDX
ADD ECX,EDX
LAB_001014fd:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101531
LAB_00101506:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
MOV EDX,dword ptr [RDI + RAX*0x4]
JBE 0x001014f8
TEST AL,0x3
JNZ 0x00101538
MOV R8D,EDX
ADD RAX,0x1
IMUL R8D,EDX
IMUL EDX,R8D
ADD ECX,EDX
CMP RAX,RSI
JNZ 0x00101506
LAB_00101531:
MOV EAX,ECX
RET
LAB_00101538:
ADD ECX,EDX
JMP 0x001014fd
LAB_00101540:
XOR ECX,ECX
MOV EAX,ECX
RET
|
int func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
uVar1 = 0;
iVar2 = 0;
do {
iVar3 = *(int *)(param_1 + uVar1 * 4);
if ((uint)((int)uVar1 * -0x55555555) < 0x55555556) {
iVar3 = iVar3 * iVar3;
}
else if ((uVar1 & 3) == 0) {
iVar3 = iVar3 * iVar3 * iVar3;
}
iVar2 = iVar2 + iVar3;
uVar1 = uVar1 + 1;
} while (uVar1 != (long)param_2);
return iVar2;
}
return 0;
}
|
1,227 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
if (i % 3 == 0) sum += lst[i] * lst[i];
else if (i % 4 == 0) sum += lst[i] * lst[i] * lst[i];
else sum += lst[i];
}
return sum;
}
|
#include <assert.h>
int main() {
{
int lst[] = {1, 2, 3};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 6);
}
{
int lst[] = {1, 4, 9};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 14);
}
{
int lst[] = {};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 9);
}
{
int lst[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -3);
}
{
int lst[] = {0};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-1, -5, 2, -1, -5};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -126);
}
{
int lst[] = {-56, -99, 1, 0, -2};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 3030);
}
{
int lst[] = {-1, 0, 0, 0, 0, 0, 0, 0, -1};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == 0);
}
{
int lst[] = {-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -14196);
}
{
int lst[] = {-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10};
assert(func0(lst, sizeof(lst)/sizeof(lst[0])) == -1448);
}
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 1558 <func0+0x68>
sub $0x1,%esi
xor %eax,%eax
xor %r8d,%r8d
jmp 151a <func0+0x2a>
nopw 0x0(%rax,%rax,1)
imul %edx,%edx
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 1543 <func0+0x53>
mov %rdx,%rax
imul $0xaaaaaaab,%eax,%ecx
mov (%rdi,%rax,4),%edx
cmp $0x55555555,%ecx
jbe 1508 <func0+0x18>
test $0x3,%al
jne 1550 <func0+0x60>
mov %edx,%ecx
imul %edx,%ecx
imul %ecx,%edx
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rsi,%rax
jne 1517 <func0+0x27>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
add %edx,%r8d
jmp 150e <func0+0x1e>
nopl (%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_1540
movsxd rsi, esi
xor eax, eax
xor ecx, ecx
jmp short loc_1506
loc_14F8:
imul edx, edx
add ecx, edx
loc_14FD:
add rax, 1
cmp rsi, rax
jz short loc_1531
loc_1506:
imul edx, eax, 0AAAAAAABh
cmp edx, 55555555h
mov edx, [rdi+rax*4]
jbe short loc_14F8
test al, 3
jnz short loc_1538
mov r8d, edx
add rax, 1
imul r8d, edx
imul edx, r8d
add ecx, edx
cmp rsi, rax
jnz short loc_1506
loc_1531:
mov eax, ecx
retn
loc_1538:
add ecx, edx
jmp short loc_14FD
loc_1540:
xor ecx, ecx
mov eax, ecx
retn
|
long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // ecx
int v4; // edx
if ( a2 > 0 )
{
v2 = 0LL;
v3 = 0;
while ( 1 )
{
while ( 1 )
{
v4 = *(_DWORD *)(a1 + 4 * v2);
if ( (unsigned int)(-1431655765 * v2) > 0x55555555 )
break;
v3 += v4 * v4;
LABEL_4:
if ( a2 == ++v2 )
return v3;
}
if ( (v2 & 3) != 0 )
{
v3 += v4;
goto LABEL_4;
}
++v2;
v3 += v4 * v4 * v4;
if ( a2 == v2 )
return v3;
}
}
return 0LL;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101540
MOVSXD RSI,ESI
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101506
LAB_001014f8:
IMUL EDX,EDX
ADD ECX,EDX
LAB_001014fd:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101531
LAB_00101506:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
MOV EDX,dword ptr [RDI + RAX*0x4]
JBE 0x001014f8
TEST AL,0x3
JNZ 0x00101538
MOV R8D,EDX
ADD RAX,0x1
IMUL R8D,EDX
IMUL EDX,R8D
ADD ECX,EDX
CMP RSI,RAX
JNZ 0x00101506
LAB_00101531:
MOV EAX,ECX
RET
LAB_00101538:
ADD ECX,EDX
JMP 0x001014fd
LAB_00101540:
XOR ECX,ECX
MOV EAX,ECX
RET
|
int func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
uVar1 = 0;
iVar2 = 0;
do {
iVar3 = *(int *)(param_1 + uVar1 * 4);
if ((uint)((int)uVar1 * -0x55555555) < 0x55555556) {
iVar3 = iVar3 * iVar3;
}
else if ((uVar1 & 3) == 0) {
iVar3 = iVar3 * iVar3 * iVar3;
}
iVar2 = iVar2 + iVar3;
uVar1 = uVar1 + 1;
} while ((long)param_2 != uVar1);
return iVar2;
}
return 0;
}
|
1,228 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
word_len = 0;
}
}
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
out[out_index] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output, "there is no place") == 0);
func0("Hi I am Hussein", output);
assert(strcmp(output, "Hi am Hussein") == 0);
func0("go for it", output);
assert(strcmp(output, "go for it") == 0);
func0("here", output);
assert(strcmp(output, "") == 0);
func0("here is", output);
assert(strcmp(output, "is") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 129d <func0+0xf4>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 11fb <func0+0x52>
addl $0x1,-0x14(%rbp)
jmpq 1299 <func0+0xf0>
cmpl $0x1,-0x14(%rbp)
jle 1232 <func0+0x89>
movb $0x1,-0x15(%rbp)
movl $0x2,-0x8(%rbp)
jmp 1225 <func0+0x7c>
mov -0x14(%rbp),%eax
cltd
idivl -0x8(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1221 <func0+0x78>
movb $0x0,-0x15(%rbp)
jmp 1236 <func0+0x8d>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 120e <func0+0x65>
jmp 1236 <func0+0x8d>
movb $0x0,-0x15(%rbp)
cmpb $0x0,-0x15(%rbp)
je 1292 <func0+0xe9>
cmpl $0x0,-0x10(%rbp)
jle 1258 <func0+0xaf>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x20,(%rax)
mov -0x14(%rbp),%eax
cltq
mov -0xc(%rbp),%edx
movslq %edx,%rcx
mov -0x14(%rbp),%edx
movslq %edx,%rdx
sub %rdx,%rcx
mov -0x28(%rbp),%rdx
lea (%rcx,%rdx,1),%rsi
mov -0x10(%rbp),%edx
movslq %edx,%rcx
mov -0x30(%rbp),%rdx
add %rdx,%rcx
mov %rax,%rdx
mov %rcx,%rdi
callq 10b0 <memcpy@plt>
mov -0x14(%rbp),%eax
add %eax,-0x10(%rbp)
movl $0x0,-0x14(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11de <func0+0x35>
cmpl $0x1,-0x14(%rbp)
jle 12ec <func0+0x143>
movb $0x1,-0x15(%rbp)
movl $0x2,-0x8(%rbp)
jmp 12df <func0+0x136>
mov -0x14(%rbp),%eax
cltd
idivl -0x8(%rbp)
mov %edx,%eax
test %eax,%eax
jne 12db <func0+0x132>
movb $0x0,-0x15(%rbp)
jmp 12f0 <func0+0x147>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 12c8 <func0+0x11f>
jmp 12f0 <func0+0x147>
movb $0x0,-0x15(%rbp)
cmpb $0x0,-0x15(%rbp)
je 134c <func0+0x1a3>
cmpl $0x0,-0x10(%rbp)
jle 1312 <func0+0x169>
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x20,(%rax)
mov -0x14(%rbp),%eax
cltq
mov -0xc(%rbp),%edx
movslq %edx,%rcx
mov -0x14(%rbp),%edx
movslq %edx,%rdx
sub %rdx,%rcx
mov -0x28(%rbp),%rdx
lea (%rcx,%rdx,1),%rsi
mov -0x10(%rbp),%edx
movslq %edx,%rcx
mov -0x30(%rbp),%rdx
add %rdx,%rcx
mov %rax,%rdx
mov %rcx,%rdi
callq 10b0 <memcpy@plt>
mov -0x14(%rbp),%eax
add %eax,-0x10(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_4], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_129D
loc_11DE:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_11FB
add [rbp+var_14], 1
jmp loc_1299
loc_11FB:
cmp [rbp+var_14], 1
jle short loc_1232
mov [rbp+var_15], 1
mov [rbp+var_8], 2
jmp short loc_1225
loc_120E:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_8]
mov eax, edx
test eax, eax
jnz short loc_1221
mov [rbp+var_15], 0
jmp short loc_1236
loc_1221:
add [rbp+var_8], 1
loc_1225:
mov eax, [rbp+var_8]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_120E
jmp short loc_1236
loc_1232:
mov [rbp+var_15], 0
loc_1236:
cmp [rbp+var_15], 0
jz short loc_1292
cmp [rbp+var_10], 0
jle short loc_1258
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 20h ; ' '
loc_1258:
mov eax, [rbp+var_14]
cdqe
mov edx, [rbp+var_C]
movsxd rcx, edx
mov edx, [rbp+var_14]
movsxd rdx, edx
sub rcx, rdx
mov rdx, [rbp+var_28]
lea rsi, [rcx+rdx]; src
mov edx, [rbp+var_10]
movsxd rcx, edx
mov rdx, [rbp+var_30]
add rcx, rdx
mov rdx, rax; n
mov rdi, rcx; dest
call _memcpy
mov eax, [rbp+var_14]
add [rbp+var_10], eax
loc_1292:
mov [rbp+var_14], 0
loc_1299:
add [rbp+var_C], 1
loc_129D:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_28]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11DE
cmp [rbp+var_14], 1
jle short loc_12EC
mov [rbp+var_15], 1
mov [rbp+var_8], 2
jmp short loc_12DF
loc_12C8:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_8]
mov eax, edx
test eax, eax
jnz short loc_12DB
mov [rbp+var_15], 0
jmp short loc_12F0
loc_12DB:
add [rbp+var_8], 1
loc_12DF:
mov eax, [rbp+var_8]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_12C8
jmp short loc_12F0
loc_12EC:
mov [rbp+var_15], 0
loc_12F0:
cmp [rbp+var_15], 0
jz short loc_134C
cmp [rbp+var_10], 0
jle short loc_1312
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 20h ; ' '
loc_1312:
mov eax, [rbp+var_14]
cdqe
mov edx, [rbp+var_C]
movsxd rcx, edx
mov edx, [rbp+var_14]
movsxd rdx, edx
sub rcx, rdx
mov rdx, [rbp+var_28]
lea rsi, [rcx+rdx]; src
mov edx, [rbp+var_10]
movsxd rcx, edx
mov rdx, [rbp+var_30]
add rcx, rdx
mov rdx, rax; n
mov rdi, rcx; dest
call _memcpy
mov eax, [rbp+var_14]
add [rbp+var_10], eax
loc_134C:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
mov byte ptr [rax], 0
nop
leave
retn
|
_BYTE * func0(long long a1, long long a2)
{
int v2; // eax
int v3; // eax
_BYTE *result; // rax
char v5; // [rsp+1Bh] [rbp-15h]
char v6; // [rsp+1Bh] [rbp-15h]
int v7; // [rsp+1Ch] [rbp-14h]
int v8; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int j; // [rsp+28h] [rbp-8h]
int k; // [rsp+28h] [rbp-8h]
v7 = 0;
v8 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(_BYTE *)(i + a1) == 32 )
{
if ( v7 <= 1 )
{
v5 = 0;
}
else
{
v5 = 1;
for ( j = 2; v7 >= j * j; ++j )
{
if ( !(v7 % j) )
{
v5 = 0;
break;
}
}
}
if ( v5 )
{
if ( v8 > 0 )
{
v2 = v8++;
*(_BYTE *)(v2 + a2) = 32;
}
memcpy((void *)(a2 + v8), (const void *)(i - (long long)v7 + a1), v7);
v8 += v7;
}
v7 = 0;
}
else
{
++v7;
}
}
if ( v7 <= 1 )
{
v6 = 0;
}
else
{
v6 = 1;
for ( k = 2; v7 >= k * k; ++k )
{
if ( !(v7 % k) )
{
v6 = 0;
break;
}
}
}
if ( v6 )
{
if ( v8 > 0 )
{
v3 = v8++;
*(_BYTE *)(v3 + a2) = 32;
}
memcpy((void *)(a2 + v8), (const void *)(i - (long long)v7 + a1), v7);
v8 += v7;
}
result = (_BYTE *)(v8 + a2);
*result = 0;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010129d
LAB_001011de:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x001011fb
ADD dword ptr [RBP + -0x14],0x1
JMP 0x00101299
LAB_001011fb:
CMP dword ptr [RBP + -0x14],0x1
JLE 0x00101232
MOV byte ptr [RBP + -0x15],0x1
MOV dword ptr [RBP + -0x8],0x2
JMP 0x00101225
LAB_0010120e:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x8]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101221
MOV byte ptr [RBP + -0x15],0x0
JMP 0x00101236
LAB_00101221:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101225:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x0010120e
JMP 0x00101236
LAB_00101232:
MOV byte ptr [RBP + -0x15],0x0
LAB_00101236:
CMP byte ptr [RBP + -0x15],0x0
JZ 0x00101292
CMP dword ptr [RBP + -0x10],0x0
JLE 0x00101258
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x20
LAB_00101258:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SUB RCX,RDX
MOV RDX,qword ptr [RBP + -0x28]
LEA RSI,[RCX + RDX*0x1]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x30]
ADD RCX,RDX
MOV RDX,RAX
MOV RDI,RCX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0x14]
ADD dword ptr [RBP + -0x10],EAX
LAB_00101292:
MOV dword ptr [RBP + -0x14],0x0
LAB_00101299:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010129d:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011de
CMP dword ptr [RBP + -0x14],0x1
JLE 0x001012ec
MOV byte ptr [RBP + -0x15],0x1
MOV dword ptr [RBP + -0x8],0x2
JMP 0x001012df
LAB_001012c8:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x8]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001012db
MOV byte ptr [RBP + -0x15],0x0
JMP 0x001012f0
LAB_001012db:
ADD dword ptr [RBP + -0x8],0x1
LAB_001012df:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x001012c8
JMP 0x001012f0
LAB_001012ec:
MOV byte ptr [RBP + -0x15],0x0
LAB_001012f0:
CMP byte ptr [RBP + -0x15],0x0
JZ 0x0010134c
CMP dword ptr [RBP + -0x10],0x0
JLE 0x00101312
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x20
LAB_00101312:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SUB RCX,RDX
MOV RDX,qword ptr [RBP + -0x28]
LEA RSI,[RCX + RDX*0x1]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x30]
ADD RCX,RDX
MOV RDX,RAX
MOV RDI,RCX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0x14]
ADD dword ptr [RBP + -0x10],EAX
LAB_0010134c:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
NOP
LEAVE
RET
|
void func0(long param_1,long param_2)
{
bool bVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
local_1c = 0;
local_18 = 0;
for (local_14 = 0; *(char *)(param_1 + local_14) != '\0'; local_14 = local_14 + 1) {
if (*(char *)(param_1 + local_14) == ' ') {
if (local_1c < 2) {
bVar1 = false;
}
else {
bVar1 = true;
for (local_10 = 2; local_10 * local_10 <= local_1c; local_10 = local_10 + 1) {
if (local_1c % local_10 == 0) {
bVar1 = false;
break;
}
}
}
if (bVar1) {
if (0 < local_18) {
*(int *)(param_2 + local_18) = 0x20;
local_18 = local_18 + 1;
}
memcpy((void *)(local_18 + param_2),(void *)(((long)local_14 - (long)local_1c) + param_1),
(long)local_1c);
local_18 = local_18 + local_1c;
}
local_1c = 0;
}
else {
local_1c = local_1c + 1;
}
}
if (local_1c < 2) {
bVar1 = false;
}
else {
bVar1 = true;
for (local_10 = 2; local_10 * local_10 <= local_1c; local_10 = local_10 + 1) {
if (local_1c % local_10 == 0) {
bVar1 = false;
break;
}
}
}
if (bVar1) {
if (0 < local_18) {
*(int *)(param_2 + local_18) = 0x20;
local_18 = local_18 + 1;
}
memcpy((void *)(local_18 + param_2),(void *)(((long)local_14 - (long)local_1c) + param_1),
(long)local_1c);
local_18 = local_18 + local_1c;
}
*(int *)(param_2 + local_18) = 0;
return;
}
|
1,229 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
word_len = 0;
}
}
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
out[out_index] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output, "there is no place") == 0);
func0("Hi I am Hussein", output);
assert(strcmp(output, "Hi am Hussein") == 0);
func0("go for it", output);
assert(strcmp(output, "go for it") == 0);
func0("here", output);
assert(strcmp(output, "") == 0);
func0("here is", output);
assert(strcmp(output, "is") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rsi,%r14
movzbl (%rdi),%eax
test %al,%al
je 123a <func0+0xb1>
mov %rdi,%r12
mov $0x0,%r13d
mov $0x0,%ebx
mov $0x0,%ebp
jmp 11c8 <func0+0x3f>
add $0x1,%ebx
add $0x1,%rbp
movzbl (%r12,%rbp,1),%eax
test %al,%al
je 120f <func0+0x86>
cmp $0x20,%al
jne 11b8 <func0+0x2f>
cmp $0x1,%ebx
jg 11d8 <func0+0x4f>
mov $0x0,%ebx
jmp 11bb <func0+0x32>
cmp $0x3,%ebx
jle 127c <func0+0xf3>
test $0x1,%bl
je 1208 <func0+0x7f>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %ebx,%eax
jg 127c <func0+0xf3>
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 11eb <func0+0x62>
mov %edx,%ebx
jmp 11bb <func0+0x32>
mov $0x0,%ebx
jmp 11bb <func0+0x32>
cmp $0x1,%ebx
jle 126b <func0+0xe2>
cmp $0x3,%ebx
jle 1242 <func0+0xb9>
test $0x1,%bl
je 126b <func0+0xe2>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %ebx,%eax
jg 1242 <func0+0xb9>
mov %ebx,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1223 <func0+0x9a>
jmp 126b <func0+0xe2>
mov $0x0,%r13d
jmp 126b <func0+0xe2>
test %r13d,%r13d
jle 1253 <func0+0xca>
movslq %r13d,%rax
movb $0x20,(%r14,%rax,1)
lea 0x1(%r13),%r13d
movslq %ebx,%rdx
movslq %r13d,%rdi
add %r14,%rdi
sub %rdx,%rbp
lea (%r12,%rbp,1),%rsi
callq 1090 <memcpy@plt>
add %ebx,%r13d
movslq %r13d,%r13
movb $0x0,(%r14,%r13,1)
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
test %r13d,%r13d
jle 128d <func0+0x104>
movslq %r13d,%rax
movb $0x20,(%r14,%rax,1)
lea 0x1(%r13),%r13d
movslq %ebx,%rdx
movslq %r13d,%rdi
add %r14,%rdi
mov %rbp,%rsi
sub %rdx,%rsi
add %r12,%rsi
callq 1090 <memcpy@plt>
add %ebx,%r13d
mov $0x0,%ebx
jmpq 11bb <func0+0x32>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rsi
movzx eax, byte ptr [rdi]
test al, al
jz loc_12BD
mov r12, rdi
mov r13d, 0
mov ebx, 0
mov ebp, 0
jmp short loc_11EF
loc_11D8:
cmp ebx, 1
jg short loc_11F8
mov ebx, 0
loc_11E2:
add rbp, 1
movzx eax, byte ptr [r12+rbp]
test al, al
jz short loc_1258
loc_11EF:
cmp al, 20h ; ' '
jz short loc_11D8
add ebx, 1
jmp short loc_11E2
loc_11F8:
cmp ebx, 3
jle short loc_1222
mov eax, ebx
and eax, 1
jz short loc_1254
mov ecx, 2
loc_1209:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jg short loc_1222
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_1209
mov ebx, edx
jmp short loc_11E2
loc_1222:
test r13d, r13d
jle short loc_1233
movsxd rax, r13d
mov byte ptr [r14+rax], 20h ; ' '
lea r13d, [r13+1]
loc_1233:
movsxd rdx, ebx; n
movsxd rdi, r13d
add rdi, r14; dest
mov rsi, rbp
sub rsi, rdx
add rsi, r12; src
call _memcpy
add r13d, ebx
mov ebx, 0
jmp short loc_11E2
loc_1254:
mov ebx, eax
jmp short loc_11E2
loc_1258:
cmp ebx, 1
jle short loc_12AC
cmp ebx, 3
jle short loc_1283
test bl, 1
jz short loc_12AC
mov ecx, 2
loc_126C:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jg short loc_1283
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_126C
jmp short loc_12AC
loc_1283:
test r13d, r13d
jle short loc_1294
movsxd rax, r13d
mov byte ptr [r14+rax], 20h ; ' '
lea r13d, [r13+1]
loc_1294:
movsxd rdx, ebx; n
movsxd rdi, r13d
add rdi, r14; dest
sub rbp, rdx
lea rsi, [r12+rbp]; src
call _memcpy
add r13d, ebx
loc_12AC:
movsxd r13, r13d
mov byte ptr [r14+r13], 0
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12BD:
mov r13d, 0
jmp short loc_12AC
|
unsigned long long func0(unsigned __int8 *a1, long long a2)
{
unsigned long long result; // rax
int v3; // r13d
int v4; // ebx
long long v5; // rbp
int v6; // ecx
int v7; // ecx
result = *a1;
if ( !(_BYTE)result )
{
v3 = 0;
goto LABEL_28;
}
v3 = 0;
v4 = 0;
v5 = 0LL;
do
{
if ( (_BYTE)result != 32 )
{
++v4;
goto LABEL_5;
}
if ( v4 <= 1 )
{
v4 = 0;
goto LABEL_5;
}
if ( v4 > 3 )
{
if ( (v4 & 1) == 0 )
{
v4 &= 1u;
goto LABEL_5;
}
v6 = 2;
while ( 1 )
{
++v6;
if ( v6 * v6 > v4 )
break;
if ( !(v4 % v6) )
{
v4 = 0;
goto LABEL_5;
}
}
}
if ( v3 > 0 )
*(_BYTE *)(a2 + v3++) = 32;
memcpy((void *)(a2 + v3), &a1[v5 - v4], v4);
v3 += v4;
v4 = 0;
LABEL_5:
result = a1[++v5];
}
while ( (_BYTE)result );
if ( v4 > 1 )
{
if ( v4 <= 3 )
goto LABEL_25;
if ( (v4 & 1) != 0 )
{
v7 = 2;
while ( 1 )
{
++v7;
if ( v7 * v7 > v4 )
break;
result = (unsigned int)(v4 / v7);
if ( !(v4 % v7) )
goto LABEL_28;
}
LABEL_25:
if ( v3 > 0 )
*(_BYTE *)(a2 + v3++) = 32;
result = (unsigned long long)memcpy((void *)(a2 + v3), &a1[v5 - v4], v4);
v3 += v4;
}
}
LABEL_28:
*(_BYTE *)(a2 + v3) = 0;
return result;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RSI
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001012bd
MOV R12,RDI
MOV R13D,0x0
MOV EBX,0x0
MOV EBP,0x0
JMP 0x001011ef
LAB_001011d8:
CMP EBX,0x1
JG 0x001011f8
MOV EBX,0x0
LAB_001011e2:
ADD RBP,0x1
MOVZX EAX,byte ptr [R12 + RBP*0x1]
TEST AL,AL
JZ 0x00101258
LAB_001011ef:
CMP AL,0x20
JZ 0x001011d8
ADD EBX,0x1
JMP 0x001011e2
LAB_001011f8:
CMP EBX,0x3
JLE 0x00101222
MOV EAX,EBX
AND EAX,0x1
JZ 0x00101254
MOV ECX,0x2
LAB_00101209:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JG 0x00101222
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101209
MOV EBX,EDX
JMP 0x001011e2
LAB_00101222:
TEST R13D,R13D
JLE 0x00101233
MOVSXD RAX,R13D
MOV byte ptr [R14 + RAX*0x1],0x20
LEA R13D,[R13 + 0x1]
LAB_00101233:
MOVSXD RDX,EBX
MOVSXD RDI,R13D
ADD RDI,R14
MOV RSI,RBP
SUB RSI,RDX
ADD RSI,R12
CALL 0x001010b0
ADD R13D,EBX
MOV EBX,0x0
JMP 0x001011e2
LAB_00101254:
MOV EBX,EAX
JMP 0x001011e2
LAB_00101258:
CMP EBX,0x1
JLE 0x001012ac
CMP EBX,0x3
JLE 0x00101283
TEST BL,0x1
JZ 0x001012ac
MOV ECX,0x2
LAB_0010126c:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JG 0x00101283
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010126c
JMP 0x001012ac
LAB_00101283:
TEST R13D,R13D
JLE 0x00101294
MOVSXD RAX,R13D
MOV byte ptr [R14 + RAX*0x1],0x20
LEA R13D,[R13 + 0x1]
LAB_00101294:
MOVSXD RDX,EBX
MOVSXD RDI,R13D
ADD RDI,R14
SUB RBP,RDX
LEA RSI,[R12 + RBP*0x1]
CALL 0x001010b0
ADD R13D,EBX
LAB_001012ac:
MOVSXD R13,R13D
MOV byte ptr [R14 + R13*0x1],0x0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012bd:
MOV R13D,0x0
JMP 0x001012ac
|
void * func0(byte *param_1,long param_2)
{
void *pvVar1;
int iVar2;
uint uVar3;
long lVar4;
int iVar5;
pvVar1 = (void *)(ulong)*param_1;
if (*param_1 == 0) {
iVar5 = 0;
}
else {
iVar5 = 0;
uVar3 = 0;
lVar4 = 0;
do {
if ((char)pvVar1 == ' ') {
if ((int)uVar3 < 2) {
uVar3 = 0;
}
else if ((int)uVar3 < 4) {
LAB_00101222:
if (0 < iVar5) {
*(int *)(param_2 + iVar5) = 0x20;
iVar5 = iVar5 + 1;
}
memcpy((void *)(iVar5 + param_2),param_1 + (lVar4 - (int)uVar3),(long)(int)uVar3);
iVar5 = iVar5 + uVar3;
uVar3 = 0;
}
else if ((uVar3 & 1) == 0) {
uVar3 = 0;
}
else {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_00101222;
} while ((int)uVar3 % iVar2 != 0);
uVar3 = 0;
}
}
else {
uVar3 = uVar3 + 1;
}
lVar4 = lVar4 + 1;
pvVar1 = (void *)(ulong)param_1[lVar4];
} while (param_1[lVar4] != 0);
if (1 < (int)uVar3) {
if ((int)uVar3 < 4) {
LAB_00101283:
if (0 < iVar5) {
*(int *)(param_2 + iVar5) = 0x20;
iVar5 = iVar5 + 1;
}
pvVar1 = memcpy((void *)(iVar5 + param_2),param_1 + (lVar4 - (int)uVar3),(long)(int)uVar3);
iVar5 = iVar5 + uVar3;
}
else if ((uVar3 & 1) != 0) {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_00101283;
pvVar1 = (void *)((long)(int)uVar3 / (long)iVar2 & 0xffffffff);
} while ((int)uVar3 % iVar2 != 0);
}
}
}
*(int *)(param_2 + iVar5) = 0;
return pvVar1;
}
|
1,230 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
word_len = 0;
}
}
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
out[out_index] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output, "there is no place") == 0);
func0("Hi I am Hussein", output);
assert(strcmp(output, "Hi am Hussein") == 0);
func0("go for it", output);
assert(strcmp(output, "go for it") == 0);
func0("here", output);
assert(strcmp(output, "") == 0);
func0("here is", output);
assert(strcmp(output, "is") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%eax
test %al,%al
je 1482 <func0+0xc2>
mov %rdi,%rbp
xor %r13d,%r13d
xor %ecx,%ecx
xor %ebx,%ebx
jmp 1400 <func0+0x40>
nopl 0x0(%rax,%rax,1)
add $0x1,%ecx
add $0x1,%rbx
movzbl 0x0(%rbp,%rbx,1),%eax
test %al,%al
je 141c <func0+0x5c>
cmp $0x20,%al
jne 13f0 <func0+0x30>
cmp $0x1,%ecx
jg 1498 <func0+0xd8>
add $0x1,%rbx
xor %ecx,%ecx
movzbl 0x0(%rbp,%rbx,1),%eax
test %al,%al
jne 1400 <func0+0x40>
cmp $0x1,%ecx
jle 147c <func0+0xbc>
cmp $0x3,%ecx
jle 144d <func0+0x8d>
mov $0x2,%esi
test $0x1,%cl
jne 1441 <func0+0x81>
jmp 147c <func0+0xbc>
nopw 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %esi
test %edx,%edx
je 147c <func0+0xbc>
add $0x1,%esi
mov %esi,%eax
imul %esi,%eax
cmp %ecx,%eax
jle 1438 <func0+0x78>
test %r13d,%r13d
je 1500 <func0+0x140>
lea 0x1(%r13),%eax
movslq %r13d,%r13
movslq %eax,%rdi
movb $0x20,(%r12,%r13,1)
lea (%rcx,%rax,1),%r13d
add %r12,%rdi
movslq %ecx,%rdx
sub %rdx,%rbx
lea 0x0(%rbp,%rbx,1),%rsi
callq 1090 <memcpy@plt>
movslq %r13d,%r13
add %r13,%r12
movb $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
cmp $0x3,%ecx
jle 14c9 <func0+0x109>
test $0x1,%cl
je 140d <func0+0x4d>
mov $0x2,%esi
jmp 14bd <func0+0xfd>
nopl (%rax)
mov %ecx,%eax
cltd
idiv %esi
test %edx,%edx
je 140d <func0+0x4d>
add $0x1,%esi
mov %esi,%eax
imul %esi,%eax
cmp %ecx,%eax
jle 14b0 <func0+0xf0>
test %r13d,%r13d
je 1510 <func0+0x150>
lea 0x1(%r13),%eax
movslq %r13d,%r13
movslq %eax,%rdi
movb $0x20,(%r12,%r13,1)
lea (%rax,%rcx,1),%r13d
add %r12,%rdi
movslq %ecx,%rdx
mov %rbx,%rsi
sub %rdx,%rsi
add %rbp,%rsi
callq 1090 <memcpy@plt>
xor %ecx,%ecx
jmpq 13f3 <func0+0x33>
nopl 0x0(%rax)
mov %ecx,%r13d
mov %r12,%rdi
jmpq 146c <func0+0xac>
nopl 0x0(%rax,%rax,1)
mov %ecx,%r13d
mov %r12,%rdi
jmp 14e4 <func0+0x124>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
movzx eax, byte ptr [rdi]
test al, al
jz loc_1471
mov r13, rdi
xor r14d, r14d
xor ebx, ebx
xor ebp, ebp
jmp short loc_13F1
loc_13E0:
add ebx, 1
loc_13E3:
add rbp, 1
movzx eax, byte ptr [r13+rbp+0]
test al, al
jz short loc_140E
loc_13F1:
cmp al, 20h ; ' '
jnz short loc_13E0
cmp ebx, 1
jg loc_1480
loc_13FE:
add rbp, 1
xor ebx, ebx
movzx eax, byte ptr [r13+rbp+0]
test al, al
jnz short loc_13F1
loc_140E:
movsxd rdi, r14d
lea rsi, [r12+rdi]
cmp ebx, 1
jle short loc_1471
cmp ebx, 3
jle short loc_1445
test bl, 1
jz short loc_1471
mov ecx, 2
jmp short loc_1439
loc_1430:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jz short loc_1471
loc_1439:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jle short loc_1430
loc_1445:
test r14d, r14d
jle short loc_1454
mov byte ptr [rsi], 20h ; ' '
add r14d, 1
movsxd rdi, r14d
loc_1454:
movsxd rdx, ebx; n
add ebx, r14d
add rdi, r12; dest
sub rbp, rdx
movsxd rbx, ebx
lea rsi, [r13+rbp+0]; src
call _memcpy
lea rsi, [r12+rbx]
loc_1471:
mov byte ptr [rsi], 0
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1480:
cmp ebx, 3
jle short loc_14B1
test bl, 1
jz loc_13FE
mov ecx, 2
jmp short loc_14A5
loc_1498:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jz loc_13FE
loc_14A5:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jle short loc_1498
loc_14B1:
test r14d, r14d
jle short loc_14C2
movsxd rax, r14d
add r14d, 1
mov byte ptr [r12+rax], 20h ; ' '
loc_14C2:
movsxd rdx, ebx; n
mov rsi, rbp
movsxd rdi, r14d
add r14d, ebx
sub rsi, rdx
add rdi, r12; dest
xor ebx, ebx
add rsi, r13; src
call _memcpy
jmp loc_13E3
|
unsigned long long func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // r12
unsigned long long result; // rax
int v5; // r14d
int v6; // ebx
long long v7; // rbp
long long v8; // rdi
int v9; // ecx
int v10; // ecx
long long v11; // rax
size_t v12; // rdx
long long v13; // rdi
long long v14; // rsi
v2 = a2;
result = *a1;
if ( !(_BYTE)result )
goto LABEL_17;
v5 = 0;
v6 = 0;
v7 = 0LL;
do
{
while ( (_BYTE)result != 32 )
{
++v6;
LABEL_4:
result = a1[++v7];
if ( !(_BYTE)result )
goto LABEL_8;
}
if ( v6 <= 1 )
goto LABEL_7;
if ( v6 <= 3 )
goto LABEL_23;
if ( (v6 & 1) != 0 )
{
v10 = 2;
while ( 1 )
{
++v10;
if ( v10 * v10 > v6 )
break;
if ( !(v6 % v10) )
goto LABEL_7;
}
LABEL_23:
if ( v5 > 0 )
{
v11 = v5++;
v2[v11] = 32;
}
v12 = v6;
v13 = v5;
v5 += v6;
v14 = v7 - v6;
v6 = 0;
memcpy(&v2[v13], &a1[v14], v12);
goto LABEL_4;
}
LABEL_7:
++v7;
v6 = 0;
result = a1[v7];
}
while ( (_BYTE)result );
LABEL_8:
v8 = v5;
a2 = &v2[v5];
if ( v6 > 1 )
{
if ( v6 <= 3 )
goto LABEL_14;
if ( (v6 & 1) != 0 )
{
v9 = 2;
while ( 1 )
{
++v9;
if ( v9 * v9 > v6 )
break;
result = (unsigned int)(v6 / v9);
if ( !(v6 % v9) )
goto LABEL_17;
}
LABEL_14:
if ( v5 > 0 )
{
*a2 = 32;
v8 = ++v5;
}
result = (unsigned long long)memcpy(&v2[v8], &a1[v7 - v6], v6);
a2 = &v2[v5 + v6];
}
}
LABEL_17:
*a2 = 0;
return result;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101471
MOV R13,RDI
XOR R14D,R14D
XOR EBX,EBX
XOR EBP,EBP
JMP 0x001013f1
LAB_001013e0:
ADD EBX,0x1
LAB_001013e3:
ADD RBP,0x1
MOVZX EAX,byte ptr [R13 + RBP*0x1]
TEST AL,AL
JZ 0x0010140e
LAB_001013f1:
CMP AL,0x20
JNZ 0x001013e0
CMP EBX,0x1
JG 0x00101480
LAB_001013fe:
ADD RBP,0x1
XOR EBX,EBX
MOVZX EAX,byte ptr [R13 + RBP*0x1]
TEST AL,AL
JNZ 0x001013f1
LAB_0010140e:
MOVSXD RDI,R14D
LEA RSI,[R12 + RDI*0x1]
CMP EBX,0x1
JLE 0x00101471
CMP EBX,0x3
JLE 0x00101445
TEST BL,0x1
JZ 0x00101471
MOV ECX,0x2
JMP 0x00101439
LAB_00101430:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101471
LAB_00101439:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JLE 0x00101430
LAB_00101445:
TEST R14D,R14D
JLE 0x00101454
MOV byte ptr [RSI],0x20
ADD R14D,0x1
MOVSXD RDI,R14D
LAB_00101454:
MOVSXD RDX,EBX
ADD EBX,R14D
ADD RDI,R12
SUB RBP,RDX
MOVSXD RBX,EBX
LEA RSI,[R13 + RBP*0x1]
CALL 0x00101090
LEA RSI,[R12 + RBX*0x1]
LAB_00101471:
MOV byte ptr [RSI],0x0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101480:
CMP EBX,0x3
JLE 0x001014b1
TEST BL,0x1
JZ 0x001013fe
MOV ECX,0x2
JMP 0x001014a5
LAB_00101498:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013fe
LAB_001014a5:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JLE 0x00101498
LAB_001014b1:
TEST R14D,R14D
JLE 0x001014c2
MOVSXD RAX,R14D
ADD R14D,0x1
MOV byte ptr [R12 + RAX*0x1],0x20
LAB_001014c2:
MOVSXD RDX,EBX
MOV RSI,RBP
MOVSXD RDI,R14D
ADD R14D,EBX
SUB RSI,RDX
ADD RDI,R12
XOR EBX,EBX
ADD RSI,R13
CALL 0x00101090
JMP 0x001013e3
|
void * func0(byte *param_1,int *param_2)
{
void *pvVar1;
int iVar2;
size_t __n;
uint uVar3;
long lVar4;
int *puVar5;
long lVar6;
int iVar7;
pvVar1 = (void *)(ulong)*param_1;
puVar5 = param_2;
if (*param_1 != 0) {
iVar7 = 0;
uVar3 = 0;
lVar6 = 0;
do {
while (lVar4 = lVar6, (char)pvVar1 == ' ') {
if (1 < (int)uVar3) {
if ((int)uVar3 < 4) {
LAB_001014b1:
if (0 < iVar7) {
lVar6 = (long)iVar7;
iVar7 = iVar7 + 1;
param_2[lVar6] = 0x20;
}
__n = (size_t)(int)uVar3;
lVar6 = (long)iVar7;
iVar7 = iVar7 + uVar3;
uVar3 = 0;
memcpy(param_2 + lVar6,param_1 + (lVar4 - __n),__n);
goto LAB_001013e3;
}
if ((uVar3 & 1) != 0) {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_001014b1;
} while ((int)uVar3 % iVar2 != 0);
}
}
uVar3 = 0;
pvVar1 = (void *)(ulong)param_1[lVar4 + 1];
lVar6 = lVar4 + 1;
if (param_1[lVar4 + 1] == 0) goto LAB_0010140e;
}
uVar3 = uVar3 + 1;
LAB_001013e3:
pvVar1 = (void *)(ulong)param_1[lVar4 + 1];
lVar6 = lVar4 + 1;
} while (param_1[lVar4 + 1] != 0);
LAB_0010140e:
lVar6 = (long)iVar7;
puVar5 = param_2 + lVar6;
if (1 < (int)uVar3) {
if ((int)uVar3 < 4) {
LAB_00101445:
if (0 < iVar7) {
*puVar5 = 0x20;
iVar7 = iVar7 + 1;
lVar6 = (long)iVar7;
}
pvVar1 = memcpy(param_2 + lVar6,param_1 + ((lVar4 + 1) - (long)(int)uVar3),(long)(int)uVar3)
;
puVar5 = param_2 + (int)(uVar3 + iVar7);
}
else if ((uVar3 & 1) != 0) {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_00101445;
pvVar1 = (void *)((long)(int)uVar3 / (long)iVar2 & 0xffffffff);
} while ((int)uVar3 % iVar2 != 0);
}
}
}
*puVar5 = 0;
return pvVar1;
}
|
1,231 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char* sentence, char* out) {
int index = 0, word_len = 0;
int out_index = 0;
bool is_prime;
int i, j;
for (i = 0; sentence[i] != '\0'; ++i) {
if (sentence[i] != ' ') {
word_len++;
} else {
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
word_len = 0;
}
}
if (word_len > 1) {
is_prime = true;
for (j = 2; j * j <= word_len; ++j) {
if (word_len % j == 0) {
is_prime = false;
break;
}
}
} else {
is_prime = false;
}
if (is_prime) {
if (out_index > 0) {
out[out_index++] = ' ';
}
memcpy(out + out_index, sentence + i - word_len, word_len);
out_index += word_len;
}
out[out_index] = '\0';
}
|
#include <assert.h>
#include <string.h>
int main() {
char output[101];
func0("This is a test", output);
assert(strcmp(output, "is") == 0);
func0("lets go for swimming", output);
assert(strcmp(output, "go for") == 0);
func0("there is no place available here", output);
assert(strcmp(output, "there is no place") == 0);
func0("Hi I am Hussein", output);
assert(strcmp(output, "Hi am Hussein") == 0);
func0("go for it", output);
assert(strcmp(output, "go for it") == 0);
func0("here", output);
assert(strcmp(output, "") == 0);
func0("here is", output);
assert(strcmp(output, "is") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%eax
test %al,%al
je 1482 <func0+0xc2>
mov %rdi,%rbp
xor %r13d,%r13d
xor %ecx,%ecx
xor %ebx,%ebx
jmp 1400 <func0+0x40>
nopl 0x0(%rax,%rax,1)
add $0x1,%ecx
add $0x1,%rbx
movzbl 0x0(%rbp,%rbx,1),%eax
test %al,%al
je 141c <func0+0x5c>
cmp $0x20,%al
jne 13f0 <func0+0x30>
cmp $0x1,%ecx
jg 1498 <func0+0xd8>
add $0x1,%rbx
xor %ecx,%ecx
movzbl 0x0(%rbp,%rbx,1),%eax
test %al,%al
jne 1400 <func0+0x40>
cmp $0x1,%ecx
jle 147c <func0+0xbc>
cmp $0x3,%ecx
jle 144d <func0+0x8d>
mov $0x2,%esi
test $0x1,%cl
jne 1441 <func0+0x81>
jmp 147c <func0+0xbc>
nopw 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %esi
test %edx,%edx
je 147c <func0+0xbc>
add $0x1,%esi
mov %esi,%eax
imul %esi,%eax
cmp %ecx,%eax
jle 1438 <func0+0x78>
test %r13d,%r13d
je 1500 <func0+0x140>
lea 0x1(%r13),%eax
movslq %r13d,%r13
movslq %eax,%rdi
movb $0x20,(%r12,%r13,1)
lea (%rcx,%rax,1),%r13d
add %r12,%rdi
movslq %ecx,%rdx
sub %rdx,%rbx
lea 0x0(%rbp,%rbx,1),%rsi
callq 1090 <memcpy@plt>
movslq %r13d,%r13
add %r13,%r12
movb $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
cmp $0x3,%ecx
jle 14c9 <func0+0x109>
test $0x1,%cl
je 140d <func0+0x4d>
mov $0x2,%esi
jmp 14bd <func0+0xfd>
nopl (%rax)
mov %ecx,%eax
cltd
idiv %esi
test %edx,%edx
je 140d <func0+0x4d>
add $0x1,%esi
mov %esi,%eax
imul %esi,%eax
cmp %ecx,%eax
jle 14b0 <func0+0xf0>
test %r13d,%r13d
je 1510 <func0+0x150>
lea 0x1(%r13),%eax
movslq %r13d,%r13
movslq %eax,%rdi
movb $0x20,(%r12,%r13,1)
lea (%rax,%rcx,1),%r13d
add %r12,%rdi
movslq %ecx,%rdx
mov %rbx,%rsi
sub %rdx,%rsi
add %rbp,%rsi
callq 1090 <memcpy@plt>
xor %ecx,%ecx
jmpq 13f3 <func0+0x33>
nopl 0x0(%rax)
mov %ecx,%r13d
mov %r12,%rdi
jmpq 146c <func0+0xac>
nopl 0x0(%rax,%rax,1)
mov %ecx,%r13d
mov %r12,%rdi
jmp 14e4 <func0+0x124>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
movzx eax, byte ptr [rdi]
test al, al
jz loc_1471
mov r13, rdi
xor r14d, r14d
xor ebx, ebx
xor ebp, ebp
jmp short loc_13F1
loc_13E0:
add ebx, 1
loc_13E3:
add rbp, 1
movzx eax, byte ptr [r13+rbp+0]
test al, al
jz short loc_140E
loc_13F1:
cmp al, 20h ; ' '
jnz short loc_13E0
cmp ebx, 1
jg loc_1480
loc_13FE:
add rbp, 1
xor ebx, ebx
movzx eax, byte ptr [r13+rbp+0]
test al, al
jnz short loc_13F1
loc_140E:
movsxd rdi, r14d
lea rsi, [r12+rdi]
cmp ebx, 1
jle short loc_1471
cmp ebx, 3
jle short loc_1445
test bl, 1
jz short loc_1471
mov ecx, 2
jmp short loc_1439
loc_1430:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jz short loc_1471
loc_1439:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jle short loc_1430
loc_1445:
test r14d, r14d
jle short loc_1454
mov byte ptr [rsi], 20h ; ' '
add r14d, 1
movsxd rdi, r14d
loc_1454:
movsxd rdx, ebx; n
add ebx, r14d
add rdi, r12; dest
sub rbp, rdx
movsxd rbx, ebx
lea rsi, [r13+rbp+0]; src
call _memcpy
lea rsi, [r12+rbx]
loc_1471:
mov byte ptr [rsi], 0
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1480:
cmp ebx, 3
jle short loc_14B1
test bl, 1
jz loc_13FE
mov ecx, 2
jmp short loc_14A5
loc_1498:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jz loc_13FE
loc_14A5:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, ebx
jle short loc_1498
loc_14B1:
test r14d, r14d
jle short loc_14C2
movsxd rax, r14d
add r14d, 1
mov byte ptr [r12+rax], 20h ; ' '
loc_14C2:
movsxd rdx, ebx; n
mov rsi, rbp
movsxd rdi, r14d
add r14d, ebx
sub rsi, rdx
add rdi, r12; dest
xor ebx, ebx
add rsi, r13; src
call _memcpy
jmp loc_13E3
|
unsigned long long func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // r12
unsigned long long result; // rax
int v5; // r14d
int v6; // ebx
long long v7; // rbp
long long v8; // rdi
int v9; // ecx
int v10; // ecx
long long v11; // rax
size_t v12; // rdx
long long v13; // rdi
long long v14; // rsi
v2 = a2;
result = *a1;
if ( !(_BYTE)result )
goto LABEL_17;
v5 = 0;
v6 = 0;
v7 = 0LL;
do
{
while ( (_BYTE)result != 32 )
{
++v6;
LABEL_4:
result = a1[++v7];
if ( !(_BYTE)result )
goto LABEL_8;
}
if ( v6 <= 1 )
goto LABEL_7;
if ( v6 <= 3 )
goto LABEL_23;
if ( (v6 & 1) != 0 )
{
v10 = 2;
while ( 1 )
{
++v10;
if ( v10 * v10 > v6 )
break;
if ( !(v6 % v10) )
goto LABEL_7;
}
LABEL_23:
if ( v5 > 0 )
{
v11 = v5++;
v2[v11] = 32;
}
v12 = v6;
v13 = v5;
v5 += v6;
v14 = v7 - v6;
v6 = 0;
memcpy(&v2[v13], &a1[v14], v12);
goto LABEL_4;
}
LABEL_7:
++v7;
v6 = 0;
result = a1[v7];
}
while ( (_BYTE)result );
LABEL_8:
v8 = v5;
a2 = &v2[v5];
if ( v6 > 1 )
{
if ( v6 <= 3 )
goto LABEL_14;
if ( (v6 & 1) != 0 )
{
v9 = 2;
while ( 1 )
{
++v9;
if ( v9 * v9 > v6 )
break;
result = (unsigned int)(v6 / v9);
if ( !(v6 % v9) )
goto LABEL_17;
}
LABEL_14:
if ( v5 > 0 )
{
*a2 = 32;
v8 = ++v5;
}
result = (unsigned long long)memcpy(&v2[v8], &a1[v7 - v6], v6);
a2 = &v2[v5 + v6];
}
}
LABEL_17:
*a2 = 0;
return result;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101471
MOV R13,RDI
XOR R14D,R14D
XOR EBX,EBX
XOR EBP,EBP
JMP 0x001013f1
LAB_001013e0:
ADD EBX,0x1
LAB_001013e3:
ADD RBP,0x1
MOVZX EAX,byte ptr [R13 + RBP*0x1]
TEST AL,AL
JZ 0x0010140e
LAB_001013f1:
CMP AL,0x20
JNZ 0x001013e0
CMP EBX,0x1
JG 0x00101480
LAB_001013fe:
ADD RBP,0x1
XOR EBX,EBX
MOVZX EAX,byte ptr [R13 + RBP*0x1]
TEST AL,AL
JNZ 0x001013f1
LAB_0010140e:
MOVSXD RDI,R14D
LEA RSI,[R12 + RDI*0x1]
CMP EBX,0x1
JLE 0x00101471
CMP EBX,0x3
JLE 0x00101445
TEST BL,0x1
JZ 0x00101471
MOV ECX,0x2
JMP 0x00101439
LAB_00101430:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101471
LAB_00101439:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JLE 0x00101430
LAB_00101445:
TEST R14D,R14D
JLE 0x00101454
MOV byte ptr [RSI],0x20
ADD R14D,0x1
MOVSXD RDI,R14D
LAB_00101454:
MOVSXD RDX,EBX
ADD EBX,R14D
ADD RDI,R12
SUB RBP,RDX
MOVSXD RBX,EBX
LEA RSI,[R13 + RBP*0x1]
CALL 0x00101090
LEA RSI,[R12 + RBX*0x1]
LAB_00101471:
MOV byte ptr [RSI],0x0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101480:
CMP EBX,0x3
JLE 0x001014b1
TEST BL,0x1
JZ 0x001013fe
MOV ECX,0x2
JMP 0x001014a5
LAB_00101498:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013fe
LAB_001014a5:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EBX
JLE 0x00101498
LAB_001014b1:
TEST R14D,R14D
JLE 0x001014c2
MOVSXD RAX,R14D
ADD R14D,0x1
MOV byte ptr [R12 + RAX*0x1],0x20
LAB_001014c2:
MOVSXD RDX,EBX
MOV RSI,RBP
MOVSXD RDI,R14D
ADD R14D,EBX
SUB RSI,RDX
ADD RDI,R12
XOR EBX,EBX
ADD RSI,R13
CALL 0x00101090
JMP 0x001013e3
|
void * func0(byte *param_1,int *param_2)
{
void *pvVar1;
int iVar2;
size_t __n;
uint uVar3;
long lVar4;
int *puVar5;
long lVar6;
int iVar7;
pvVar1 = (void *)(ulong)*param_1;
puVar5 = param_2;
if (*param_1 != 0) {
iVar7 = 0;
uVar3 = 0;
lVar6 = 0;
do {
while (lVar4 = lVar6, (char)pvVar1 == ' ') {
if (1 < (int)uVar3) {
if ((int)uVar3 < 4) {
LAB_001014b1:
if (0 < iVar7) {
lVar6 = (long)iVar7;
iVar7 = iVar7 + 1;
param_2[lVar6] = 0x20;
}
__n = (size_t)(int)uVar3;
lVar6 = (long)iVar7;
iVar7 = iVar7 + uVar3;
uVar3 = 0;
memcpy(param_2 + lVar6,param_1 + (lVar4 - __n),__n);
goto LAB_001013e3;
}
if ((uVar3 & 1) != 0) {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_001014b1;
} while ((int)uVar3 % iVar2 != 0);
}
}
uVar3 = 0;
pvVar1 = (void *)(ulong)param_1[lVar4 + 1];
lVar6 = lVar4 + 1;
if (param_1[lVar4 + 1] == 0) goto LAB_0010140e;
}
uVar3 = uVar3 + 1;
LAB_001013e3:
pvVar1 = (void *)(ulong)param_1[lVar4 + 1];
lVar6 = lVar4 + 1;
} while (param_1[lVar4 + 1] != 0);
LAB_0010140e:
lVar6 = (long)iVar7;
puVar5 = param_2 + lVar6;
if (1 < (int)uVar3) {
if ((int)uVar3 < 4) {
LAB_00101445:
if (0 < iVar7) {
*puVar5 = 0x20;
iVar7 = iVar7 + 1;
lVar6 = (long)iVar7;
}
pvVar1 = memcpy(param_2 + lVar6,param_1 + ((lVar4 + 1) - (long)(int)uVar3),(long)(int)uVar3)
;
puVar5 = param_2 + (int)(uVar3 + iVar7);
}
else if ((uVar3 & 1) != 0) {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if ((int)uVar3 < iVar2 * iVar2) goto LAB_00101445;
pvVar1 = (void *)((long)(int)uVar3 / (long)iVar2 & 0xffffffff);
} while ((int)uVar3 % iVar2 != 0);
}
}
}
*puVar5 = 0;
return pvVar1;
}
|
1,232 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);
for (i = 0; n[i] != '/'; i++) {
num[i] = n[i];
}
num[i] = '\0';
c = atoi(num);
for (j = 0, i = i + 1; n[i] != '\0'; i++, j++) {
den[j] = n[i];
}
den[j] = '\0';
d = atoi(den);
if ((a * c) % (b * d) == 0) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(func0("2/3", "5/2") == 0);
assert(func0("5/2", "3/5") == 0);
assert(func0("2/4", "8/4") == 1);
assert(func0("2/4", "4/2") == 1);
assert(func0("1/5", "5/1") == 1);
assert(func0("1/5", "1/5") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x110,%rsp
mov %rdi,-0x108(%rbp)
mov %rsi,-0x110(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0xf8(%rbp)
jmp 11ed <func0+0x64>
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x108(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0xf8(%rbp),%eax
cltq
mov %dl,-0xe0(%rbp,%rax,1)
addl $0x1,-0xf8(%rbp)
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x108(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jne 11c1 <func0+0x38>
mov -0xf8(%rbp),%eax
cltq
movb $0x0,-0xe0(%rbp,%rax,1)
lea -0xe0(%rbp),%rax
mov %rax,%rdi
callq 1090 <atoi@plt>
mov %eax,-0xf0(%rbp)
movl $0x0,-0xf4(%rbp)
addl $0x1,-0xf8(%rbp)
jmp 126f <func0+0xe6>
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x108(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0xf4(%rbp),%eax
cltq
mov %dl,-0x70(%rbp,%rax,1)
addl $0x1,-0xf8(%rbp)
addl $0x1,-0xf4(%rbp)
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x108(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 123f <func0+0xb6>
mov -0xf4(%rbp),%eax
cltq
movb $0x0,-0x70(%rbp,%rax,1)
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 1090 <atoi@plt>
mov %eax,-0xec(%rbp)
movl $0x0,-0xf8(%rbp)
jmp 12e0 <func0+0x157>
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x110(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0xf8(%rbp),%eax
cltq
mov %dl,-0xe0(%rbp,%rax,1)
addl $0x1,-0xf8(%rbp)
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x110(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jne 12b4 <func0+0x12b>
mov -0xf8(%rbp),%eax
cltq
movb $0x0,-0xe0(%rbp,%rax,1)
lea -0xe0(%rbp),%rax
mov %rax,%rdi
callq 1090 <atoi@plt>
mov %eax,-0xe8(%rbp)
movl $0x0,-0xf4(%rbp)
addl $0x1,-0xf8(%rbp)
jmp 1362 <func0+0x1d9>
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x110(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0xf4(%rbp),%eax
cltq
mov %dl,-0x70(%rbp,%rax,1)
addl $0x1,-0xf8(%rbp)
addl $0x1,-0xf4(%rbp)
mov -0xf8(%rbp),%eax
movslq %eax,%rdx
mov -0x110(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1332 <func0+0x1a9>
mov -0xf4(%rbp),%eax
cltq
movb $0x0,-0x70(%rbp,%rax,1)
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 1090 <atoi@plt>
mov %eax,-0xe4(%rbp)
mov -0xf0(%rbp),%eax
imul -0xe8(%rbp),%eax
mov -0xec(%rbp),%edx
mov %edx,%ecx
imul -0xe4(%rbp),%ecx
cltd
idiv %ecx
mov %edx,%eax
test %eax,%eax
jne 13c7 <func0+0x23e>
mov $0x1,%eax
jmp 13cc <func0+0x243>
mov $0x0,%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 13e0 <func0+0x257>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 110h
mov [rbp+var_108], rdi
mov [rbp+var_110], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_F8], 0
jmp short loc_11ED
loc_11C1:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_108]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_F8]
cdqe
mov [rbp+rax+nptr], dl
add [rbp+var_F8], 1
loc_11ED:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_108]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jnz short loc_11C1
mov eax, [rbp+var_F8]
cdqe
mov [rbp+rax+nptr], 0
lea rax, [rbp+nptr]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_F0], eax
mov [rbp+var_F4], 0
add [rbp+var_F8], 1
jmp short loc_126F
loc_123F:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_108]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_F4]
cdqe
mov [rbp+rax+var_70], dl
add [rbp+var_F8], 1
add [rbp+var_F4], 1
loc_126F:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_108]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_123F
mov eax, [rbp+var_F4]
cdqe
mov [rbp+rax+var_70], 0
lea rax, [rbp+var_70]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_EC], eax
mov [rbp+var_F8], 0
jmp short loc_12E0
loc_12B4:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_110]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_F8]
cdqe
mov [rbp+rax+nptr], dl
add [rbp+var_F8], 1
loc_12E0:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_110]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jnz short loc_12B4
mov eax, [rbp+var_F8]
cdqe
mov [rbp+rax+nptr], 0
lea rax, [rbp+nptr]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_E8], eax
mov [rbp+var_F4], 0
add [rbp+var_F8], 1
jmp short loc_1362
loc_1332:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_110]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_F4]
cdqe
mov [rbp+rax+var_70], dl
add [rbp+var_F8], 1
add [rbp+var_F4], 1
loc_1362:
mov eax, [rbp+var_F8]
movsxd rdx, eax
mov rax, [rbp+var_110]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1332
mov eax, [rbp+var_F4]
cdqe
mov [rbp+rax+var_70], 0
lea rax, [rbp+var_70]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_E4], eax
mov eax, [rbp+var_F0]
imul eax, [rbp+var_E8]
mov edx, [rbp+var_EC]
mov esi, edx
imul esi, [rbp+var_E4]
cdq
idiv esi
mov ecx, edx
mov eax, ecx
test eax, eax
jnz short loc_13C9
mov eax, 1
jmp short loc_13CE
loc_13C9:
mov eax, 0
loc_13CE:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13E2
call ___stack_chk_fail
locret_13E2:
leave
retn
|
_BOOL8 func0(long long a1, long long a2)
{
int i; // [rsp+18h] [rbp-F8h]
int j; // [rsp+18h] [rbp-F8h]
int k; // [rsp+18h] [rbp-F8h]
int m; // [rsp+18h] [rbp-F8h]
int v7; // [rsp+1Ch] [rbp-F4h]
int v8; // [rsp+1Ch] [rbp-F4h]
int v9; // [rsp+20h] [rbp-F0h]
int v10; // [rsp+24h] [rbp-ECh]
int v11; // [rsp+28h] [rbp-E8h]
char nptr[112]; // [rsp+30h] [rbp-E0h] BYREF
char v13[104]; // [rsp+A0h] [rbp-70h] BYREF
unsigned long long v14; // [rsp+108h] [rbp-8h]
v14 = __readfsqword(0x28u);
for ( i = 0; *(_BYTE *)(i + a1) != 47; ++i )
nptr[i] = *(_BYTE *)(i + a1);
nptr[i] = 0;
v9 = atoi(nptr);
v7 = 0;
for ( j = i + 1; *(_BYTE *)(j + a1); ++j )
v13[v7++] = *(_BYTE *)(j + a1);
v13[v7] = 0;
v10 = atoi(v13);
for ( k = 0; *(_BYTE *)(k + a2) != 47; ++k )
nptr[k] = *(_BYTE *)(k + a2);
nptr[k] = 0;
v11 = atoi(nptr);
v8 = 0;
for ( m = k + 1; *(_BYTE *)(m + a2); ++m )
v13[v8++] = *(_BYTE *)(m + a2);
v13[v8] = 0;
return v11 * v9 % (atoi(v13) * v10) == 0;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
MOV qword ptr [RBP + -0x108],RDI
MOV qword ptr [RBP + -0x110],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xf8],0x0
JMP 0x001011ed
LAB_001011c1:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x108]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xf8]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0xe0],DL
ADD dword ptr [RBP + -0xf8],0x1
LAB_001011ed:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x108]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JNZ 0x001011c1
MOV EAX,dword ptr [RBP + -0xf8]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0xe0],0x0
LEA RAX,[RBP + -0xe0]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0xf0],EAX
MOV dword ptr [RBP + -0xf4],0x0
ADD dword ptr [RBP + -0xf8],0x1
JMP 0x0010126f
LAB_0010123f:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x108]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xf4]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x70],DL
ADD dword ptr [RBP + -0xf8],0x1
ADD dword ptr [RBP + -0xf4],0x1
LAB_0010126f:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x108]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010123f
MOV EAX,dword ptr [RBP + -0xf4]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x70],0x0
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0xec],EAX
MOV dword ptr [RBP + -0xf8],0x0
JMP 0x001012e0
LAB_001012b4:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x110]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xf8]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0xe0],DL
ADD dword ptr [RBP + -0xf8],0x1
LAB_001012e0:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x110]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JNZ 0x001012b4
MOV EAX,dword ptr [RBP + -0xf8]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0xe0],0x0
LEA RAX,[RBP + -0xe0]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0xe8],EAX
MOV dword ptr [RBP + -0xf4],0x0
ADD dword ptr [RBP + -0xf8],0x1
JMP 0x00101362
LAB_00101332:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x110]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0xf4]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x70],DL
ADD dword ptr [RBP + -0xf8],0x1
ADD dword ptr [RBP + -0xf4],0x1
LAB_00101362:
MOV EAX,dword ptr [RBP + -0xf8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x110]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101332
MOV EAX,dword ptr [RBP + -0xf4]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x70],0x0
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0xe4],EAX
MOV EAX,dword ptr [RBP + -0xf0]
IMUL EAX,dword ptr [RBP + -0xe8]
MOV EDX,dword ptr [RBP + -0xec]
MOV ESI,EDX
IMUL ESI,dword ptr [RBP + -0xe4]
CDQ
IDIV ESI
MOV ECX,EDX
MOV EAX,ECX
TEST EAX,EAX
JNZ 0x001013c9
MOV EAX,0x1
JMP 0x001013ce
LAB_001013c9:
MOV EAX,0x0
LAB_001013ce:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013e2
CALL 0x00101070
LAB_001013e2:
LEAVE
RET
|
bool func0(long param_1,long param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
int local_100;
int local_fc;
char local_e8 [112];
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
for (local_100 = 0; *(char *)(param_1 + local_100) != '/'; local_100 = local_100 + 1) {
local_e8[local_100] = *(char *)(param_1 + local_100);
}
local_e8[local_100] = '\0';
iVar1 = atoi(local_e8);
local_fc = 0;
while (local_100 = local_100 + 1, *(char *)(param_1 + local_100) != '\0') {
local_78[local_fc] = *(char *)(param_1 + local_100);
local_fc = local_fc + 1;
}
local_78[local_fc] = '\0';
iVar2 = atoi(local_78);
for (local_100 = 0; *(char *)(param_2 + local_100) != '/'; local_100 = local_100 + 1) {
local_e8[local_100] = *(char *)(param_2 + local_100);
}
local_e8[local_100] = '\0';
iVar3 = atoi(local_e8);
local_fc = 0;
while (local_100 = local_100 + 1, *(char *)(param_2 + local_100) != '\0') {
local_78[local_fc] = *(char *)(param_2 + local_100);
local_fc = local_fc + 1;
}
local_78[local_fc] = '\0';
iVar4 = atoi(local_78);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (iVar1 * iVar3) % (iVar2 * iVar4) == 0;
}
|
1,233 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);
for (i = 0; n[i] != '/'; i++) {
num[i] = n[i];
}
num[i] = '\0';
c = atoi(num);
for (j = 0, i = i + 1; n[i] != '\0'; i++, j++) {
den[j] = n[i];
}
den[j] = '\0';
d = atoi(den);
if ((a * c) % (b * d) == 0) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(func0("2/3", "5/2") == 0);
assert(func0("5/2", "3/5") == 0);
assert(func0("2/4", "8/4") == 1);
assert(func0("2/4", "4/2") == 1);
assert(func0("1/5", "5/1") == 1);
assert(func0("1/5", "1/5") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xe0,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0xd8(%rsp)
xor %eax,%eax
movzbl (%rdi),%edx
cmp $0x2f,%dl
je 131d <func0+0x194>
mov $0x1,%eax
lea -0x1(%rsp),%rcx
mov %dl,(%rcx,%rax,1)
mov %eax,%r13d
add $0x1,%rax
movzbl -0x1(%rbp,%rax,1),%edx
cmp $0x2f,%dl
jne 11cb <func0+0x42>
movslq %r13d,%rax
movb $0x0,(%rsp,%rax,1)
mov %rsp,%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
mov %rax,%r12
lea 0x1(%r13),%eax
cltq
movzbl 0x0(%rbp,%rax,1),%eax
test %al,%al
je 1328 <func0+0x19f>
mov $0x1,%ecx
lea 0x6f(%rsp),%rsi
movslq %r13d,%r13
add %r13,%rbp
mov %al,(%rsi,%rcx,1)
mov %ecx,%edx
add $0x1,%rcx
movzbl 0x0(%rbp,%rcx,1),%eax
test %al,%al
jne 121e <func0+0x95>
movslq %edx,%rdx
movb $0x0,0x70(%rsp,%rdx,1)
lea 0x70(%rsp),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
mov %rax,%r13
movzbl (%rbx),%eax
cmp $0x2f,%al
je 1332 <func0+0x1a9>
mov $0x1,%ecx
lea -0x1(%rsp),%rdx
mov %al,(%rdx,%rcx,1)
mov %ecx,%ebp
add $0x1,%rcx
movzbl -0x1(%rbx,%rcx,1),%eax
cmp $0x2f,%al
jne 1264 <func0+0xdb>
movslq %ebp,%rax
movb $0x0,(%rsp,%rax,1)
mov %rsp,%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
mov %rax,%r14
lea 0x1(%rbp),%eax
cltq
movzbl (%rbx,%rax,1),%eax
test %al,%al
je 133c <func0+0x1b3>
mov $0x1,%ecx
lea 0x6f(%rsp),%rsi
movslq %ebp,%rbp
add %rbp,%rbx
mov %al,(%rsi,%rcx,1)
mov %ecx,%edx
add $0x1,%rcx
movzbl (%rbx,%rcx,1),%eax
test %al,%al
jne 12b3 <func0+0x12a>
movslq %edx,%rdx
movb $0x0,0x70(%rsp,%rdx,1)
lea 0x70(%rsp),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
mov %rax,%rdx
mov %r14d,%eax
imul %r12d,%eax
imul %edx,%r13d
cltd
idiv %r13d
test %edx,%edx
sete %al
movzbl %al,%eax
mov 0xd8(%rsp),%rdi
xor %fs:0x28,%rdi
jne 1343 <func0+0x1ba>
add $0xe0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x0,%r13d
jmpq 11df <func0+0x56>
mov $0x0,%edx
jmpq 1230 <func0+0xa7>
mov $0x0,%ebp
jmpq 1276 <func0+0xed>
mov $0x0,%edx
jmp 12c4 <func0+0x13b>
callq 1070 <__stack_chk_fail@plt>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0E0h
mov rbp, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+108h+var_30], rax
xor eax, eax
movzx edx, byte ptr [rdi]
cmp dl, 2Fh ; '/'
jz loc_1320
mov eax, 1
lea rcx, [rsp+108h+var_109]
loc_11CB:
mov [rcx+rax], dl
mov r13, rax
add rax, 1
movzx edx, byte ptr [rbp+rax-1]
cmp dl, 2Fh ; '/'
jnz short loc_11CB
loc_11DF:
movsxd rax, r13d
mov [rsp+rax+108h+var_108], 0
mov rdi, rsp; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
mov r12, rax
lea eax, [r13+1]
cdqe
movzx eax, byte ptr [rbp+rax+0]
test al, al
jz loc_132B
mov edx, 1
lea rsi, [rsp+108h+var_99]
movsxd r13, r13d
add rbp, r13
loc_121E:
mov [rsi+rdx], al
mov rcx, rdx
add rdx, 1
movzx eax, byte ptr [rbp+rdx+0]
test al, al
jnz short loc_121E
loc_1231:
movsxd rcx, ecx
mov [rsp+rcx+108h+nptr], 0
lea rdi, [rsp+108h+nptr]; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
mov r13, rax
movzx eax, byte ptr [rbx]
cmp al, 2Fh ; '/'
jz loc_1335
mov edx, 1
lea rcx, [rsp+108h+var_109]
loc_1265:
mov [rcx+rdx], al
mov rbp, rdx
add rdx, 1
movzx eax, byte ptr [rbx+rdx-1]
cmp al, 2Fh ; '/'
jnz short loc_1265
loc_1278:
movsxd rax, ebp
mov [rsp+rax+108h+var_108], 0
mov rdi, rsp; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
mov r14, rax
lea eax, [rbp+1]
cdqe
movzx eax, byte ptr [rbx+rax]
test al, al
jz loc_133F
mov edx, 1
lea rsi, [rsp+108h+var_99]
movsxd rbp, ebp
add rbx, rbp
loc_12B5:
mov [rsi+rdx], al
mov rcx, rdx
add rdx, 1
movzx eax, byte ptr [rbx+rdx]
test al, al
jnz short loc_12B5
loc_12C7:
movsxd rcx, ecx
mov [rsp+rcx+108h+nptr], 0
lea rdi, [rsp+108h+nptr]; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
mov rdx, rax
mov eax, r14d
imul eax, r12d
imul r13d, edx
cdq
idiv r13d
test edx, edx
setz al
movzx eax, al
mov rdx, [rsp+108h+var_30]
sub rdx, fs:28h
jnz short loc_1346
add rsp, 0E0h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1320:
mov r13d, 0
jmp loc_11DF
loc_132B:
mov ecx, 0
jmp loc_1231
loc_1335:
mov ebp, 0
jmp loc_1278
loc_133F:
mov ecx, 0
jmp short loc_12C7
loc_1346:
call ___stack_chk_fail
|
_BOOL8 func0(char *a1, char *a2)
{
char v2; // dl
long long v3; // rax
int v4; // r13d
int v5; // r12d
char v6; // al
long long v7; // rdx
int v8; // ecx
int v9; // r13d
char v10; // al
long long v11; // rdx
int v12; // ebp
int v13; // r14d
char v14; // al
long long v15; // rdx
int v16; // ecx
char v19[112]; // [rsp+2h] [rbp-108h] BYREF
char nptr[104]; // [rsp+72h] [rbp-98h] BYREF
unsigned long long v21; // [rsp+DAh] [rbp-30h]
v21 = __readfsqword(0x28u);
v2 = *a1;
if ( *a1 == 47 )
{
v4 = 0;
}
else
{
v3 = 1LL;
do
{
v19[v3 - 1] = v2;
v4 = v3++;
v2 = a1[v3 - 1];
}
while ( v2 != 47 );
}
v19[v4] = 0;
v5 = strtol(v19, 0LL, 10);
v6 = a1[v4 + 1];
if ( v6 )
{
v7 = 1LL;
do
{
v19[v7 + 111] = v6;
v8 = v7++;
v6 = a1[v4 + v7];
}
while ( v6 );
}
else
{
v8 = 0;
}
nptr[v8] = 0;
v9 = strtol(nptr, 0LL, 10);
v10 = *a2;
if ( *a2 == 47 )
{
v12 = 0;
}
else
{
v11 = 1LL;
do
{
v19[v11 - 1] = v10;
v12 = v11++;
v10 = a2[v11 - 1];
}
while ( v10 != 47 );
}
v19[v12] = 0;
v13 = strtol(v19, 0LL, 10);
v14 = a2[v12 + 1];
if ( v14 )
{
v15 = 1LL;
do
{
v19[v15 + 111] = v14;
v16 = v15++;
v14 = a2[v12 + v15];
}
while ( v14 );
}
else
{
v16 = 0;
}
nptr[v16] = 0;
return v5 * v13 % (int)(strtol(nptr, 0LL, 10) * v9) == 0;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xe0
MOV RBP,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
XOR EAX,EAX
MOVZX EDX,byte ptr [RDI]
CMP DL,0x2f
JZ 0x00101320
MOV EAX,0x1
LEA RCX,[RSP + -0x1]
LAB_001011cb:
MOV byte ptr [RCX + RAX*0x1],DL
MOV R13,RAX
ADD RAX,0x1
MOVZX EDX,byte ptr [RBP + RAX*0x1 + -0x1]
CMP DL,0x2f
JNZ 0x001011cb
LAB_001011df:
MOVSXD RAX,R13D
MOV byte ptr [RSP + RAX*0x1],0x0
MOV RDI,RSP
MOV EDX,0xa
MOV ESI,0x0
CALL 0x00101090
MOV R12,RAX
LEA EAX,[R13 + 0x1]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1]
TEST AL,AL
JZ 0x0010132b
MOV EDX,0x1
LEA RSI,[RSP + 0x6f]
MOVSXD R13,R13D
ADD RBP,R13
LAB_0010121e:
MOV byte ptr [RSI + RDX*0x1],AL
MOV RCX,RDX
ADD RDX,0x1
MOVZX EAX,byte ptr [RBP + RDX*0x1]
TEST AL,AL
JNZ 0x0010121e
LAB_00101231:
MOVSXD RCX,ECX
MOV byte ptr [RSP + RCX*0x1 + 0x70],0x0
LEA RDI,[RSP + 0x70]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x00101090
MOV R13,RAX
MOVZX EAX,byte ptr [RBX]
CMP AL,0x2f
JZ 0x00101335
MOV EDX,0x1
LEA RCX,[RSP + -0x1]
LAB_00101265:
MOV byte ptr [RCX + RDX*0x1],AL
MOV RBP,RDX
ADD RDX,0x1
MOVZX EAX,byte ptr [RBX + RDX*0x1 + -0x1]
CMP AL,0x2f
JNZ 0x00101265
LAB_00101278:
MOVSXD RAX,EBP
MOV byte ptr [RSP + RAX*0x1],0x0
MOV RDI,RSP
MOV EDX,0xa
MOV ESI,0x0
CALL 0x00101090
MOV R14,RAX
LEA EAX,[RBP + 0x1]
CDQE
MOVZX EAX,byte ptr [RBX + RAX*0x1]
TEST AL,AL
JZ 0x0010133f
MOV EDX,0x1
LEA RSI,[RSP + 0x6f]
MOVSXD RBP,EBP
ADD RBX,RBP
LAB_001012b5:
MOV byte ptr [RSI + RDX*0x1],AL
MOV RCX,RDX
ADD RDX,0x1
MOVZX EAX,byte ptr [RBX + RDX*0x1]
TEST AL,AL
JNZ 0x001012b5
LAB_001012c7:
MOVSXD RCX,ECX
MOV byte ptr [RSP + RCX*0x1 + 0x70],0x0
LEA RDI,[RSP + 0x70]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x00101090
MOV RDX,RAX
MOV EAX,R14D
IMUL EAX,R12D
IMUL R13D,EDX
CDQ
IDIV R13D
TEST EDX,EDX
SETZ AL
MOVZX EAX,AL
MOV RDX,qword ptr [RSP + 0xd8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101346
ADD RSP,0xe0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101320:
MOV R13D,0x0
JMP 0x001011df
LAB_0010132b:
MOV ECX,0x0
JMP 0x00101231
LAB_00101335:
MOV EBP,0x0
JMP 0x00101278
LAB_0010133f:
MOV ECX,0x0
JMP 0x001012c7
LAB_00101346:
CALL 0x00101070
|
bool func0(char *param_1,char *param_2)
{
long lVar1;
long lVar2;
int iVar3;
char cVar4;
long lVar5;
long lVar6;
int iVar7;
long in_FS_OFFSET;
int8 uStack_110;
char local_108 [111];
char local_99 [105];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
cVar4 = *param_1;
if (cVar4 == '/') {
lVar1 = 0;
}
else {
lVar5 = 1;
do {
lVar1 = lVar5;
local_108[lVar1 + -1] = cVar4;
cVar4 = param_1[lVar1];
lVar5 = lVar1 + 1;
} while (cVar4 != '/');
}
iVar7 = (int)lVar1;
local_108[iVar7] = '\0';
uStack_110 = (code *)0x1011f8;
lVar1 = strtol(local_108,(char **)0x0,10);
cVar4 = param_1[iVar7 + 1];
if (cVar4 == '\0') {
iVar3 = 0;
}
else {
lVar5 = 1;
do {
local_99[lVar5] = cVar4;
iVar3 = (int)lVar5;
lVar5 = lVar5 + 1;
cVar4 = param_1[lVar5 + iVar7];
} while (cVar4 != '\0');
}
local_99[(long)iVar3 + 1] = '\0';
uStack_110 = (code *)0x10124d;
lVar5 = strtol(local_99 + 1,(char **)0x0,10);
cVar4 = *param_2;
if (cVar4 == '/') {
lVar2 = 0;
}
else {
lVar6 = 1;
do {
lVar2 = lVar6;
local_108[lVar2 + -1] = cVar4;
cVar4 = param_2[lVar2];
lVar6 = lVar2 + 1;
} while (cVar4 != '/');
}
iVar7 = (int)lVar2;
local_108[iVar7] = '\0';
uStack_110 = (code *)0x101291;
lVar2 = strtol(local_108,(char **)0x0,10);
cVar4 = param_2[iVar7 + 1];
if (cVar4 == '\0') {
iVar3 = 0;
}
else {
lVar6 = 1;
do {
local_99[lVar6] = cVar4;
iVar3 = (int)lVar6;
lVar6 = lVar6 + 1;
cVar4 = param_2[lVar6 + iVar7];
} while (cVar4 != '\0');
}
local_99[(long)iVar3 + 1] = '\0';
uStack_110 = (code *)0x1012e3;
lVar6 = strtol(local_99 + 1,(char **)0x0,10);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return ((int)lVar2 * (int)lVar1) % ((int)lVar5 * (int)lVar6) == 0;
}
/* WARNING: Subroutine does not return */
uStack_110 = main;
__stack_chk_fail();
}
|
1,234 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);
for (i = 0; n[i] != '/'; i++) {
num[i] = n[i];
}
num[i] = '\0';
c = atoi(num);
for (j = 0, i = i + 1; n[i] != '\0'; i++, j++) {
den[j] = n[i];
}
den[j] = '\0';
d = atoi(den);
if ((a * c) % (b * d) == 0) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(func0("2/3", "5/2") == 0);
assert(func0("5/2", "3/5") == 0);
assert(func0("2/4", "8/4") == 1);
assert(func0("2/4", "4/2") == 1);
assert(func0("1/5", "5/1") == 1);
assert(func0("1/5", "1/5") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0xf8,%rsp
movzbl (%rdi),%edx
mov %fs:0x28,%rax
mov %rax,0xe8(%rsp)
xor %eax,%eax
cmp $0x2f,%dl
je 1648 <func0+0x1b8>
mov $0x1,%eax
lea 0xf(%rsp),%rdi
nopl 0x0(%rax)
mov %dl,(%rdi,%rax,1)
movslq %eax,%rcx
add $0x1,%rax
movzbl -0x1(%rbp,%rax,1),%edx
cmp $0x2f,%dl
jne 14d8 <func0+0x48>
lea 0x1(%rcx),%r15d
movslq %r15d,%r14
lea 0x10(%rsp),%r13
mov $0xa,%edx
xor %esi,%esi
movb $0x0,0x10(%rsp,%rcx,1)
mov %r13,%rdi
callq 1090 <strtol@plt>
mov %rax,0x8(%rsp)
movzbl 0x0(%rbp,%r14,1),%eax
test %al,%al
je 1660 <func0+0x1d0>
movslq %r15d,%r15
mov $0x1,%ecx
lea 0x7f(%rsp),%rdx
add %r15,%rbp
mov %al,(%rdx,%rcx,1)
movslq %ecx,%rsi
add $0x1,%rcx
movzbl -0x1(%rbp,%rcx,1),%eax
test %al,%al
jne 1530 <func0+0xa0>
lea 0x80(%rsp),%r14
movb $0x0,0x80(%rsp,%rsi,1)
mov $0xa,%edx
xor %esi,%esi
mov %r14,%rdi
callq 1090 <strtol@plt>
movzbl (%r12),%esi
mov %rax,%rbp
cmp $0x2f,%sil
je 1670 <func0+0x1e0>
mov $0x1,%ecx
lea 0xf(%rsp),%rdi
xchg %ax,%ax
mov %sil,(%rdi,%rcx,1)
movslq %ecx,%rax
add $0x1,%rcx
movzbl -0x1(%r12,%rcx,1),%esi
cmp $0x2f,%sil
jne 1580 <func0+0xf0>
lea 0x1(%rax),%ebx
movslq %ebx,%r15
xor %esi,%esi
mov %r13,%rdi
mov $0xa,%edx
movb $0x0,0x10(%rsp,%rax,1)
callq 1090 <strtol@plt>
movzbl (%r12,%r15,1),%esi
mov %rax,%r13
test %sil,%sil
je 1688 <func0+0x1f8>
movslq %ebx,%r8
mov $0x1,%ecx
lea 0x7f(%rsp),%rdx
add %r8,%r12
nopw 0x0(%rax,%rax,1)
mov %sil,(%rdx,%rcx,1)
movslq %ecx,%rax
add $0x1,%rcx
movzbl -0x1(%r12,%rcx,1),%esi
test %sil,%sil
jne 15d8 <func0+0x148>
mov $0xa,%edx
xor %esi,%esi
mov %r14,%rdi
movb $0x0,0x80(%rsp,%rax,1)
callq 1090 <strtol@plt>
mov %rax,%r8
mov 0x8(%rsp),%eax
imul %r8d,%ebp
imul %r13d,%eax
cltd
idiv %ebp
xor %eax,%eax
test %edx,%edx
sete %al
mov 0xe8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 168f <func0+0x1ff>
add $0xf8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%r14d
mov $0x1,%r15d
xor %ecx,%ecx
jmpq 14f3 <func0+0x63>
nopl 0x0(%rax,%rax,1)
xor %esi,%esi
jmpq 1543 <func0+0xb3>
nopw 0x0(%rax,%rax,1)
mov $0x1,%r15d
mov $0x1,%ebx
xor %eax,%eax
jmpq 159d <func0+0x10d>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
jmpq 15ee <func0+0x15e>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0F8h
movzx edx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
cmp dl, 2Fh ; '/'
jz loc_1650
mov eax, 1
lea rcx, [rsp+128h+var_119]
nop dword ptr [rax+00h]
loc_14D8:
mov [rcx+rax], dl
mov rsi, rax
add rax, 1
movzx edx, byte ptr [rbx+rax-1]
cmp dl, 2Fh ; '/'
jnz short loc_14D8
lea r12d, [rsi+1]
movsxd rax, esi
movsxd r15, r12d
loc_14F6:
lea r13, [rsp+128h+nptr]
mov edx, 0Ah; base
xor esi, esi; endptr
mov [rsp+rax+128h+nptr], 0
mov rdi, r13; nptr
call _strtol
mov rbp, rax
movzx eax, byte ptr [rbx+r15]
test al, al
jz loc_1668
movsxd r12, r12d
mov edx, 1
lea rsi, [rsp+128h+var_A9]
add rbx, r12
nop
loc_1530:
mov [rsi+rdx], al
mov rcx, rdx
add rdx, 1
movzx eax, byte ptr [rbx+rdx-1]
test al, al
jnz short loc_1530
loc_1543:
lea r12, [rsp+128h+var_A8]
movsxd rcx, ecx
mov edx, 0Ah; base
xor esi, esi; endptr
mov rdi, r12; nptr
mov [rsp+rcx+128h+var_A8], 0
call _strtol
mov rbx, rax
movzx eax, byte ptr [r14]
cmp al, 2Fh ; '/'
jz loc_1670
mov edx, 1
lea rcx, [rsp+128h+var_119]
xchg ax, ax
loc_1580:
mov [rcx+rdx], al
mov rsi, rdx
add rdx, 1
movzx eax, byte ptr [r14+rdx-1]
cmp al, 2Fh ; '/'
jnz short loc_1580
lea r8d, [rsi+1]
movsxd rax, esi
movsxd r15, r8d
loc_159E:
mov rdi, r13; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
mov [rsp+0Ch], r8d
mov [rsp+rax+128h+nptr], 0
call _strtol
movzx ecx, byte ptr [r14+r15]
mov r13, rax
test cl, cl
jz loc_1688
movsxd r8, dword ptr [rsp+0Ch]
mov edx, 1
lea rsi, [rsp+128h+var_A9]
add r14, r8
nop dword ptr [rax+00000000h]
loc_15E0:
mov [rsi+rdx], cl
mov rdi, rdx
add rdx, 1
movzx ecx, byte ptr [r14+rdx-1]
test cl, cl
jnz short loc_15E0
loc_15F4:
movsxd rdi, edi
mov edx, 0Ah; base
xor esi, esi; endptr
mov [rsp+rdi+128h+var_A8], 0
mov rdi, r12; nptr
call _strtol
mov rdx, rax
mov eax, r13d
imul eax, ebp
imul ebx, edx
cdq
idiv ebx
xor eax, eax
test edx, edx
setz al
mov rdx, [rsp+128h+var_40]
sub rdx, fs:28h
jnz short loc_168F
add rsp, 0F8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1650:
mov r15d, 1
mov r12d, 1
xor eax, eax
jmp loc_14F6
loc_1668:
xor ecx, ecx
jmp loc_1543
loc_1670:
mov r15d, 1
mov r8d, 1
xor eax, eax
jmp loc_159E
loc_1688:
xor edi, edi
jmp loc_15F4
loc_168F:
call ___stack_chk_fail
|
_BOOL8 func0(char *a1, char *a2)
{
char v3; // dl
long long v4; // rax
int v5; // esi
int v6; // r12d
long long v7; // rax
long long v8; // r15
int v9; // ebp
char v10; // al
long long v11; // rdx
int v12; // ecx
int v13; // ebx
char v14; // al
long long v15; // rdx
int v16; // esi
int v17; // r8d
long long v18; // rax
long long v19; // r15
int v20; // eax
char v21; // cl
long long v22; // rdx
char *v23; // r14
int v24; // edi
int v26; // [rsp+Ch] [rbp-11Ch]
char nptr[112]; // [rsp+10h] [rbp-118h] BYREF
char v28[104]; // [rsp+80h] [rbp-A8h] BYREF
unsigned long long v29; // [rsp+E8h] [rbp-40h]
v3 = *a1;
v29 = __readfsqword(0x28u);
if ( v3 == 47 )
{
v8 = 1LL;
v6 = 1;
v7 = 0LL;
}
else
{
v4 = 1LL;
do
{
nptr[v4 - 1] = v3;
v5 = v4++;
v3 = a1[v4 - 1];
}
while ( v3 != 47 );
v6 = v5 + 1;
v7 = v5;
v8 = v5 + 1;
}
nptr[v7] = 0;
v9 = strtol(nptr, 0LL, 10);
v10 = a1[v8];
if ( v10 )
{
v11 = 1LL;
do
{
nptr[v11 + 111] = v10;
v12 = v11++;
v10 = a1[v6 - 1 + v11];
}
while ( v10 );
}
else
{
v12 = 0;
}
v28[v12] = 0;
v13 = strtol(v28, 0LL, 10);
v14 = *a2;
if ( *a2 == 47 )
{
v19 = 1LL;
v17 = 1;
v18 = 0LL;
}
else
{
v15 = 1LL;
do
{
nptr[v15 - 1] = v14;
v16 = v15++;
v14 = a2[v15 - 1];
}
while ( v14 != 47 );
v17 = v16 + 1;
v18 = v16;
v19 = v16 + 1;
}
v26 = v17;
nptr[v18] = 0;
v20 = strtol(nptr, 0LL, 10);
v21 = a2[v19];
if ( v21 )
{
v22 = 1LL;
v23 = &a2[v26];
do
{
nptr[v22 + 111] = v21;
v24 = v22++;
v21 = v23[v22 - 1];
}
while ( v21 );
}
else
{
v24 = 0;
}
v28[v24] = 0;
return v9 * v20 % (int)(strtol(v28, 0LL, 10) * v13) == 0;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xf8
MOVZX EDX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
CMP DL,0x2f
JZ 0x00101650
MOV EAX,0x1
LEA RCX,[RSP + 0xf]
NOP dword ptr [RAX]
LAB_001014d8:
MOV byte ptr [RCX + RAX*0x1],DL
MOV RSI,RAX
ADD RAX,0x1
MOVZX EDX,byte ptr [RBX + RAX*0x1 + -0x1]
CMP DL,0x2f
JNZ 0x001014d8
LEA R12D,[RSI + 0x1]
MOVSXD RAX,ESI
MOVSXD R15,R12D
LAB_001014f6:
LEA R13,[RSP + 0x10]
MOV EDX,0xa
XOR ESI,ESI
MOV byte ptr [RSP + RAX*0x1 + 0x10],0x0
MOV RDI,R13
CALL 0x00101090
MOV RBP,RAX
MOVZX EAX,byte ptr [RBX + R15*0x1]
TEST AL,AL
JZ 0x00101668
MOVSXD R12,R12D
MOV EDX,0x1
LEA RSI,[RSP + 0x7f]
ADD RBX,R12
NOP
LAB_00101530:
MOV byte ptr [RSI + RDX*0x1],AL
MOV RCX,RDX
ADD RDX,0x1
MOVZX EAX,byte ptr [RBX + RDX*0x1 + -0x1]
TEST AL,AL
JNZ 0x00101530
LAB_00101543:
LEA R12,[RSP + 0x80]
MOVSXD RCX,ECX
MOV EDX,0xa
XOR ESI,ESI
MOV RDI,R12
MOV byte ptr [RSP + RCX*0x1 + 0x80],0x0
CALL 0x00101090
MOV RBX,RAX
MOVZX EAX,byte ptr [R14]
CMP AL,0x2f
JZ 0x00101670
MOV EDX,0x1
LEA RCX,[RSP + 0xf]
NOP
LAB_00101580:
MOV byte ptr [RCX + RDX*0x1],AL
MOV RSI,RDX
ADD RDX,0x1
MOVZX EAX,byte ptr [R14 + RDX*0x1 + -0x1]
CMP AL,0x2f
JNZ 0x00101580
LEA R8D,[RSI + 0x1]
MOVSXD RAX,ESI
MOVSXD R15,R8D
LAB_0010159e:
MOV RDI,R13
MOV EDX,0xa
XOR ESI,ESI
MOV dword ptr [RSP + 0xc],R8D
MOV byte ptr [RSP + RAX*0x1 + 0x10],0x0
CALL 0x00101090
MOVZX ECX,byte ptr [R14 + R15*0x1]
MOV R13,RAX
TEST CL,CL
JZ 0x00101688
MOVSXD R8,dword ptr [RSP + 0xc]
MOV EDX,0x1
LEA RSI,[RSP + 0x7f]
ADD R14,R8
NOP dword ptr [RAX]
LAB_001015e0:
MOV byte ptr [RSI + RDX*0x1],CL
MOV RDI,RDX
ADD RDX,0x1
MOVZX ECX,byte ptr [R14 + RDX*0x1 + -0x1]
TEST CL,CL
JNZ 0x001015e0
LAB_001015f4:
MOVSXD RDI,EDI
MOV EDX,0xa
XOR ESI,ESI
MOV byte ptr [RSP + RDI*0x1 + 0x80],0x0
MOV RDI,R12
CALL 0x00101090
MOV RDX,RAX
MOV EAX,R13D
IMUL EAX,EBP
IMUL EBX,EDX
CDQ
IDIV EBX
XOR EAX,EAX
TEST EDX,EDX
SETZ AL
MOV RDX,qword ptr [RSP + 0xe8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010168f
ADD RSP,0xf8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101650:
MOV R15D,0x1
MOV R12D,0x1
XOR EAX,EAX
JMP 0x001014f6
LAB_00101668:
XOR ECX,ECX
JMP 0x00101543
LAB_00101670:
MOV R15D,0x1
MOV R8D,0x1
XOR EAX,EAX
JMP 0x0010159e
LAB_00101688:
XOR EDI,EDI
JMP 0x001015f4
LAB_0010168f:
CALL 0x00101070
|
bool func0(char *param_1,char *param_2)
{
long lVar1;
long lVar2;
char cVar3;
int iVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
int4 local_11c;
char local_118 [111];
char local_a9 [105];
long local_40;
cVar3 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar3 == '/') {
lVar5 = 1;
iVar4 = 1;
lVar1 = 0;
}
else {
lVar1 = 1;
do {
lVar5 = lVar1;
local_118[lVar5 + -1] = cVar3;
cVar3 = param_1[lVar5];
lVar1 = lVar5 + 1;
} while (cVar3 != '/');
iVar4 = (int)lVar5 + 1;
lVar1 = (long)(int)lVar5;
lVar5 = (long)iVar4;
}
local_118[lVar1] = '\0';
lVar1 = strtol(local_118,(char **)0x0,10);
cVar3 = param_1[lVar5];
if (cVar3 == '\0') {
lVar5 = 0;
}
else {
lVar2 = 1;
do {
lVar5 = lVar2;
local_a9[lVar5] = cVar3;
cVar3 = param_1[lVar5 + 1 + (long)iVar4 + -1];
lVar2 = lVar5 + 1;
} while (cVar3 != '\0');
}
local_a9[(long)(int)lVar5 + 1] = '\0';
lVar5 = strtol(local_a9 + 1,(char **)0x0,10);
cVar3 = *param_2;
if (cVar3 == '/') {
lVar6 = 1;
local_11c = 1;
lVar2 = 0;
}
else {
lVar2 = 1;
do {
lVar6 = lVar2;
local_118[lVar6 + -1] = cVar3;
cVar3 = param_2[lVar6];
lVar2 = lVar6 + 1;
} while (cVar3 != '/');
local_11c = (int)lVar6 + 1;
lVar2 = (long)(int)lVar6;
lVar6 = (long)local_11c;
}
local_118[lVar2] = '\0';
lVar2 = strtol(local_118,(char **)0x0,10);
cVar3 = param_2[lVar6];
if (cVar3 == '\0') {
iVar4 = 0;
}
else {
lVar6 = 1;
do {
local_a9[lVar6] = cVar3;
iVar4 = (int)lVar6;
lVar6 = lVar6 + 1;
cVar3 = param_2[lVar6 + (long)local_11c + -1];
} while (cVar3 != '\0');
}
local_a9[(long)iVar4 + 1] = '\0';
lVar6 = strtol(local_a9 + 1,(char **)0x0,10);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return ((int)lVar2 * (int)lVar1) % ((int)lVar5 * (int)lVar6) == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,235 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(const char* x, const char* n){
int a, b, c, d, i, j;
char num[101], den[101];
for (i = 0; x[i] != '/'; i++) {
num[i] = x[i];
}
num[i] = '\0';
a = atoi(num);
for (j = 0, i = i + 1; x[i] != '\0'; i++, j++) {
den[j] = x[i];
}
den[j] = '\0';
b = atoi(den);
for (i = 0; n[i] != '/'; i++) {
num[i] = n[i];
}
num[i] = '\0';
c = atoi(num);
for (j = 0, i = i + 1; n[i] != '\0'; i++, j++) {
den[j] = n[i];
}
den[j] = '\0';
d = atoi(den);
if ((a * c) % (b * d) == 0) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0("1/5", "5/1") == 1);
assert(func0("1/6", "2/1") == 0);
assert(func0("5/1", "3/1") == 1);
assert(func0("7/10", "10/2") == 0);
assert(func0("2/10", "50/10") == 1);
assert(func0("7/2", "4/2") == 1);
assert(func0("11/6", "6/1") == 1);
assert(func0("2/3", "5/2") == 0);
assert(func0("5/2", "3/5") == 0);
assert(func0("2/4", "8/4") == 1);
assert(func0("2/4", "4/2") == 1);
assert(func0("1/5", "5/1") == 1);
assert(func0("1/5", "1/5") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0xf8,%rsp
movzbl (%rdi),%edx
mov %fs:0x28,%rax
mov %rax,0xe8(%rsp)
xor %eax,%eax
cmp $0x2f,%dl
je 1648 <func0+0x1b8>
mov $0x1,%eax
lea 0xf(%rsp),%rdi
nopl 0x0(%rax)
mov %dl,(%rdi,%rax,1)
movslq %eax,%rcx
add $0x1,%rax
movzbl -0x1(%rbp,%rax,1),%edx
cmp $0x2f,%dl
jne 14d8 <func0+0x48>
lea 0x1(%rcx),%r15d
movslq %r15d,%r14
lea 0x10(%rsp),%r13
mov $0xa,%edx
xor %esi,%esi
movb $0x0,0x10(%rsp,%rcx,1)
mov %r13,%rdi
callq 1090 <strtol@plt>
mov %rax,0x8(%rsp)
movzbl 0x0(%rbp,%r14,1),%eax
test %al,%al
je 1660 <func0+0x1d0>
movslq %r15d,%r15
mov $0x1,%ecx
lea 0x7f(%rsp),%rdx
add %r15,%rbp
mov %al,(%rdx,%rcx,1)
movslq %ecx,%rsi
add $0x1,%rcx
movzbl -0x1(%rbp,%rcx,1),%eax
test %al,%al
jne 1530 <func0+0xa0>
lea 0x80(%rsp),%r14
movb $0x0,0x80(%rsp,%rsi,1)
mov $0xa,%edx
xor %esi,%esi
mov %r14,%rdi
callq 1090 <strtol@plt>
movzbl (%r12),%esi
mov %rax,%rbp
cmp $0x2f,%sil
je 1670 <func0+0x1e0>
mov $0x1,%ecx
lea 0xf(%rsp),%rdi
xchg %ax,%ax
mov %sil,(%rdi,%rcx,1)
movslq %ecx,%rax
add $0x1,%rcx
movzbl -0x1(%r12,%rcx,1),%esi
cmp $0x2f,%sil
jne 1580 <func0+0xf0>
lea 0x1(%rax),%ebx
movslq %ebx,%r15
xor %esi,%esi
mov %r13,%rdi
mov $0xa,%edx
movb $0x0,0x10(%rsp,%rax,1)
callq 1090 <strtol@plt>
movzbl (%r12,%r15,1),%esi
mov %rax,%r13
test %sil,%sil
je 1688 <func0+0x1f8>
movslq %ebx,%r8
mov $0x1,%ecx
lea 0x7f(%rsp),%rdx
add %r8,%r12
nopw 0x0(%rax,%rax,1)
mov %sil,(%rdx,%rcx,1)
movslq %ecx,%rax
add $0x1,%rcx
movzbl -0x1(%r12,%rcx,1),%esi
test %sil,%sil
jne 15d8 <func0+0x148>
mov $0xa,%edx
xor %esi,%esi
mov %r14,%rdi
movb $0x0,0x80(%rsp,%rax,1)
callq 1090 <strtol@plt>
mov %rax,%r8
mov 0x8(%rsp),%eax
imul %r8d,%ebp
imul %r13d,%eax
cltd
idiv %ebp
xor %eax,%eax
test %edx,%edx
sete %al
mov 0xe8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 168f <func0+0x1ff>
add $0xf8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%r14d
mov $0x1,%r15d
xor %ecx,%ecx
jmpq 14f3 <func0+0x63>
nopl 0x0(%rax,%rax,1)
xor %esi,%esi
jmpq 1543 <func0+0xb3>
nopw 0x0(%rax,%rax,1)
mov $0x1,%r15d
mov $0x1,%ebx
xor %eax,%eax
jmpq 159d <func0+0x10d>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
jmpq 15ee <func0+0x15e>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
|
func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0F8h
movzx edx, byte ptr [rdi]
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
cmp dl, 2Fh ; '/'
jz loc_1650
mov eax, 1
lea rcx, [rsp+128h+var_119]
nop dword ptr [rax+00h]
loc_14D8:
mov [rcx+rax], dl
mov rsi, rax
add rax, 1
movzx edx, byte ptr [rbx+rax-1]
cmp dl, 2Fh ; '/'
jnz short loc_14D8
lea r12d, [rsi+1]
movsxd rax, esi
movsxd r15, r12d
loc_14F6:
lea r13, [rsp+128h+nptr]
mov edx, 0Ah; base
xor esi, esi; endptr
mov [rsp+rax+128h+nptr], 0
mov rdi, r13; nptr
call _strtol
mov rbp, rax
movzx eax, byte ptr [rbx+r15]
test al, al
jz loc_1668
movsxd r12, r12d
mov edx, 1
lea rsi, [rsp+128h+var_A9]
add rbx, r12
nop
loc_1530:
mov [rsi+rdx], al
mov rcx, rdx
add rdx, 1
movzx eax, byte ptr [rbx+rdx-1]
test al, al
jnz short loc_1530
loc_1543:
lea r12, [rsp+128h+var_A8]
movsxd rcx, ecx
mov edx, 0Ah; base
xor esi, esi; endptr
mov rdi, r12; nptr
mov [rsp+rcx+128h+var_A8], 0
call _strtol
mov rbx, rax
movzx eax, byte ptr [r14]
cmp al, 2Fh ; '/'
jz loc_1670
mov edx, 1
lea rcx, [rsp+128h+var_119]
xchg ax, ax
loc_1580:
mov [rcx+rdx], al
mov rsi, rdx
add rdx, 1
movzx eax, byte ptr [r14+rdx-1]
cmp al, 2Fh ; '/'
jnz short loc_1580
lea r8d, [rsi+1]
movsxd rax, esi
movsxd r15, r8d
loc_159E:
mov rdi, r13; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
mov [rsp+0Ch], r8d
mov [rsp+rax+128h+nptr], 0
call _strtol
movzx ecx, byte ptr [r14+r15]
mov r13, rax
test cl, cl
jz loc_1688
movsxd r8, dword ptr [rsp+0Ch]
mov edx, 1
lea rsi, [rsp+128h+var_A9]
add r14, r8
nop dword ptr [rax+00000000h]
loc_15E0:
mov [rsi+rdx], cl
mov rdi, rdx
add rdx, 1
movzx ecx, byte ptr [r14+rdx-1]
test cl, cl
jnz short loc_15E0
loc_15F4:
movsxd rdi, edi
mov edx, 0Ah; base
xor esi, esi; endptr
mov [rsp+rdi+128h+var_A8], 0
mov rdi, r12; nptr
call _strtol
mov rdx, rax
mov eax, r13d
imul eax, ebp
imul ebx, edx
cdq
idiv ebx
xor eax, eax
test edx, edx
setz al
mov rdx, [rsp+128h+var_40]
sub rdx, fs:28h
jnz short loc_168F
add rsp, 0F8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1650:
mov r15d, 1
mov r12d, 1
xor eax, eax
jmp loc_14F6
loc_1668:
xor ecx, ecx
jmp loc_1543
loc_1670:
mov r15d, 1
mov r8d, 1
xor eax, eax
jmp loc_159E
loc_1688:
xor edi, edi
jmp loc_15F4
loc_168F:
call ___stack_chk_fail
|
_BOOL8 func0(char *a1, char *a2)
{
char v3; // dl
long long v4; // rax
int v5; // esi
int v6; // r12d
long long v7; // rax
long long v8; // r15
int v9; // ebp
char v10; // al
long long v11; // rdx
int v12; // ecx
int v13; // ebx
char v14; // al
long long v15; // rdx
int v16; // esi
int v17; // r8d
long long v18; // rax
long long v19; // r15
int v20; // eax
char v21; // cl
long long v22; // rdx
char *v23; // r14
int v24; // edi
int v26; // [rsp+Ch] [rbp-11Ch]
char nptr[112]; // [rsp+10h] [rbp-118h] BYREF
char v28[104]; // [rsp+80h] [rbp-A8h] BYREF
unsigned long long v29; // [rsp+E8h] [rbp-40h]
v3 = *a1;
v29 = __readfsqword(0x28u);
if ( v3 == 47 )
{
v8 = 1LL;
v6 = 1;
v7 = 0LL;
}
else
{
v4 = 1LL;
do
{
nptr[v4 - 1] = v3;
v5 = v4++;
v3 = a1[v4 - 1];
}
while ( v3 != 47 );
v6 = v5 + 1;
v7 = v5;
v8 = v5 + 1;
}
nptr[v7] = 0;
v9 = strtol(nptr, 0LL, 10);
v10 = a1[v8];
if ( v10 )
{
v11 = 1LL;
do
{
nptr[v11 + 111] = v10;
v12 = v11++;
v10 = a1[v6 - 1 + v11];
}
while ( v10 );
}
else
{
v12 = 0;
}
v28[v12] = 0;
v13 = strtol(v28, 0LL, 10);
v14 = *a2;
if ( *a2 == 47 )
{
v19 = 1LL;
v17 = 1;
v18 = 0LL;
}
else
{
v15 = 1LL;
do
{
nptr[v15 - 1] = v14;
v16 = v15++;
v14 = a2[v15 - 1];
}
while ( v14 != 47 );
v17 = v16 + 1;
v18 = v16;
v19 = v16 + 1;
}
v26 = v17;
nptr[v18] = 0;
v20 = strtol(nptr, 0LL, 10);
v21 = a2[v19];
if ( v21 )
{
v22 = 1LL;
v23 = &a2[v26];
do
{
nptr[v22 + 111] = v21;
v24 = v22++;
v21 = v23[v22 - 1];
}
while ( v21 );
}
else
{
v24 = 0;
}
v28[v24] = 0;
return v9 * v20 % (int)(strtol(v28, 0LL, 10) * v13) == 0;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xf8
MOVZX EDX,byte ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
CMP DL,0x2f
JZ 0x00101650
MOV EAX,0x1
LEA RCX,[RSP + 0xf]
NOP dword ptr [RAX]
LAB_001014d8:
MOV byte ptr [RCX + RAX*0x1],DL
MOV RSI,RAX
ADD RAX,0x1
MOVZX EDX,byte ptr [RBX + RAX*0x1 + -0x1]
CMP DL,0x2f
JNZ 0x001014d8
LEA R12D,[RSI + 0x1]
MOVSXD RAX,ESI
MOVSXD R15,R12D
LAB_001014f6:
LEA R13,[RSP + 0x10]
MOV EDX,0xa
XOR ESI,ESI
MOV byte ptr [RSP + RAX*0x1 + 0x10],0x0
MOV RDI,R13
CALL 0x00101090
MOV RBP,RAX
MOVZX EAX,byte ptr [RBX + R15*0x1]
TEST AL,AL
JZ 0x00101668
MOVSXD R12,R12D
MOV EDX,0x1
LEA RSI,[RSP + 0x7f]
ADD RBX,R12
NOP
LAB_00101530:
MOV byte ptr [RSI + RDX*0x1],AL
MOV RCX,RDX
ADD RDX,0x1
MOVZX EAX,byte ptr [RBX + RDX*0x1 + -0x1]
TEST AL,AL
JNZ 0x00101530
LAB_00101543:
LEA R12,[RSP + 0x80]
MOVSXD RCX,ECX
MOV EDX,0xa
XOR ESI,ESI
MOV RDI,R12
MOV byte ptr [RSP + RCX*0x1 + 0x80],0x0
CALL 0x00101090
MOV RBX,RAX
MOVZX EAX,byte ptr [R14]
CMP AL,0x2f
JZ 0x00101670
MOV EDX,0x1
LEA RCX,[RSP + 0xf]
NOP
LAB_00101580:
MOV byte ptr [RCX + RDX*0x1],AL
MOV RSI,RDX
ADD RDX,0x1
MOVZX EAX,byte ptr [R14 + RDX*0x1 + -0x1]
CMP AL,0x2f
JNZ 0x00101580
LEA R8D,[RSI + 0x1]
MOVSXD RAX,ESI
MOVSXD R15,R8D
LAB_0010159e:
MOV RDI,R13
MOV EDX,0xa
XOR ESI,ESI
MOV dword ptr [RSP + 0xc],R8D
MOV byte ptr [RSP + RAX*0x1 + 0x10],0x0
CALL 0x00101090
MOVZX ECX,byte ptr [R14 + R15*0x1]
MOV R13,RAX
TEST CL,CL
JZ 0x00101688
MOVSXD R8,dword ptr [RSP + 0xc]
MOV EDX,0x1
LEA RSI,[RSP + 0x7f]
ADD R14,R8
NOP dword ptr [RAX]
LAB_001015e0:
MOV byte ptr [RSI + RDX*0x1],CL
MOV RDI,RDX
ADD RDX,0x1
MOVZX ECX,byte ptr [R14 + RDX*0x1 + -0x1]
TEST CL,CL
JNZ 0x001015e0
LAB_001015f4:
MOVSXD RDI,EDI
MOV EDX,0xa
XOR ESI,ESI
MOV byte ptr [RSP + RDI*0x1 + 0x80],0x0
MOV RDI,R12
CALL 0x00101090
MOV RDX,RAX
MOV EAX,R13D
IMUL EAX,EBP
IMUL EBX,EDX
CDQ
IDIV EBX
XOR EAX,EAX
TEST EDX,EDX
SETZ AL
MOV RDX,qword ptr [RSP + 0xe8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010168f
ADD RSP,0xf8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101650:
MOV R15D,0x1
MOV R12D,0x1
XOR EAX,EAX
JMP 0x001014f6
LAB_00101668:
XOR ECX,ECX
JMP 0x00101543
LAB_00101670:
MOV R15D,0x1
MOV R8D,0x1
XOR EAX,EAX
JMP 0x0010159e
LAB_00101688:
XOR EDI,EDI
JMP 0x001015f4
LAB_0010168f:
CALL 0x00101070
|
bool func0(char *param_1,char *param_2)
{
long lVar1;
long lVar2;
char cVar3;
int iVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
int4 local_11c;
char local_118 [111];
char local_a9 [105];
long local_40;
cVar3 = *param_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (cVar3 == '/') {
lVar5 = 1;
iVar4 = 1;
lVar1 = 0;
}
else {
lVar1 = 1;
do {
lVar5 = lVar1;
local_118[lVar5 + -1] = cVar3;
cVar3 = param_1[lVar5];
lVar1 = lVar5 + 1;
} while (cVar3 != '/');
iVar4 = (int)lVar5 + 1;
lVar1 = (long)(int)lVar5;
lVar5 = (long)iVar4;
}
local_118[lVar1] = '\0';
lVar1 = strtol(local_118,(char **)0x0,10);
cVar3 = param_1[lVar5];
if (cVar3 == '\0') {
lVar5 = 0;
}
else {
lVar2 = 1;
do {
lVar5 = lVar2;
local_a9[lVar5] = cVar3;
cVar3 = param_1[lVar5 + 1 + (long)iVar4 + -1];
lVar2 = lVar5 + 1;
} while (cVar3 != '\0');
}
local_a9[(long)(int)lVar5 + 1] = '\0';
lVar5 = strtol(local_a9 + 1,(char **)0x0,10);
cVar3 = *param_2;
if (cVar3 == '/') {
lVar6 = 1;
local_11c = 1;
lVar2 = 0;
}
else {
lVar2 = 1;
do {
lVar6 = lVar2;
local_118[lVar6 + -1] = cVar3;
cVar3 = param_2[lVar6];
lVar2 = lVar6 + 1;
} while (cVar3 != '/');
local_11c = (int)lVar6 + 1;
lVar2 = (long)(int)lVar6;
lVar6 = (long)local_11c;
}
local_118[lVar2] = '\0';
lVar2 = strtol(local_118,(char **)0x0,10);
cVar3 = param_2[lVar6];
if (cVar3 == '\0') {
iVar4 = 0;
}
else {
lVar6 = 1;
do {
local_a9[lVar6] = cVar3;
iVar4 = (int)lVar6;
lVar6 = lVar6 + 1;
cVar3 = param_2[lVar6 + (long)local_11c + -1];
} while (cVar3 != '\0');
}
local_a9[(long)iVar4 + 1] = '\0';
lVar6 = strtol(local_a9 + 1,(char **)0x0,10);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return ((int)lVar2 * (int)lVar1) % ((int)lVar5 * (int)lVar6) == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,236 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j = 1; j < length; j++)
sum += w[j] - '0';
if (nums[i] > 0) sum += w[0] - '0';
else sum -= w[0] - '0';
sumdigit[i] = sum;
}
int m;
for (int i = 0; i < size; i++)
for (int j = 1; j < size; j++)
if (sumdigit[j - 1] > sumdigit[j]) {
m = sumdigit[j]; sumdigit[j] = sumdigit[j - 1]; sumdigit[j - 1] = m;
m = nums[j]; nums[j] = nums[j - 1]; nums[j - 1] = m;
}
free(sumdigit);
return nums;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12, 11};
assert(issame(func0(test1, 5), expected1, 5, 5));
int test2[] = {1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46};
int expected2[] = {0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457};
assert(issame(func0(test2, 15), expected2, 15, 15));
int test3[] = {};
int expected3[] = {};
assert(issame(func0(test3, 0), expected3, 0, 0));
int test4[] = {1, -11, -32, 43, 54, -98, 2, -3};
int expected4[] = {-3, -32, -98, -11, 1, 2, 43, 54};
assert(issame(func0(test4, 8), expected4, 8, 8));
int test5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int expected5[] = {1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9};
assert(issame(func0(test5, 11), expected5, 11, 11));
int test6[] = {0, 6, 6, -76, -21, 23, 4};
int expected6[] = {-76, -21, 0, 4, 23, 6, 6};
assert(issame(func0(test6, 7), expected6, 7, 7));
printf("All tests passed!\n");
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x4c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 1100 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x3c(%rbp)
jmpq 1312 <func0+0x109>
mov -0x3c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
xor %edx,%eax
sub %edx,%eax
lea -0x14(%rbp),%rcx
mov %eax,%edx
lea 0xd94(%rip),%rsi
mov %rcx,%rdi
mov $0x0,%eax
callq 1110 <sprintf@plt>
movl $0x0,-0x38(%rbp)
lea -0x14(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %eax,-0x24(%rbp)
movl $0x1,-0x34(%rbp)
jmp 12b7 <func0+0xae>
mov -0x34(%rbp),%eax
cltq
movzbl -0x14(%rbp,%rax,1),%eax
movsbl %al,%eax
sub $0x30,%eax
add %eax,-0x38(%rbp)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 12a0 <func0+0x97>
mov -0x3c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jle 12e8 <func0+0xdf>
movzbl -0x14(%rbp),%eax
movsbl %al,%eax
sub $0x30,%eax
add %eax,-0x38(%rbp)
jmp 12f5 <func0+0xec>
movzbl -0x14(%rbp),%eax
movsbl %al,%eax
sub $0x30,%eax
sub %eax,-0x38(%rbp)
mov -0x3c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x38(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 124c <func0+0x43>
movl $0x0,-0x30(%rbp)
jmpq 143c <func0+0x233>
movl $0x1,-0x2c(%rbp)
jmpq 142c <func0+0x223>
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1428 <func0+0x21f>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x28(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x28(%rbp),%eax
mov %eax,(%rdx)
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x28(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x48(%rbp),%rax
add %rax,%rdx
mov -0x28(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1336 <func0+0x12d>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 132a <func0+0x121>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 10b0 <free@plt>
mov -0x48(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 146c <func0+0x263>
callq 10e0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_4C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_3C], 0
jmp loc_1315
loc_124C:
mov eax, [rbp+var_3C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
mov edx, eax
neg edx
cmovs edx, eax
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
mov [rbp+var_38], 0
lea rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_24], eax
mov [rbp+var_34], 1
jmp short loc_12BA
loc_12A3:
mov eax, [rbp+var_34]
cdqe
movzx eax, [rbp+rax+s]
movsx eax, al
sub eax, 30h ; '0'
add [rbp+var_38], eax
add [rbp+var_34], 1
loc_12BA:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_24]
jl short loc_12A3
mov eax, [rbp+var_3C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
test eax, eax
jle short loc_12EB
movzx eax, [rbp+s]
movsx eax, al
sub eax, 30h ; '0'
add [rbp+var_38], eax
jmp short loc_12F8
loc_12EB:
movzx eax, [rbp+s]
movsx eax, al
sub eax, 30h ; '0'
sub [rbp+var_38], eax
loc_12F8:
mov eax, [rbp+var_3C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_38]
mov [rdx], eax
add [rbp+var_3C], 1
loc_1315:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_4C]
jl loc_124C
mov [rbp+var_30], 0
jmp loc_143F
loc_132D:
mov [rbp+var_2C], 1
jmp loc_142F
loc_1339:
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_2C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle loc_142B
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_28], eax
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_2C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_28]
mov [rdx], eax
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
mov [rbp+var_28], eax
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rbp+var_2C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_48]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_48]
add rdx, rax
mov eax, [rbp+var_28]
mov [rdx], eax
loc_142B:
add [rbp+var_2C], 1
loc_142F:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_4C]
jl loc_1339
add [rbp+var_30], 1
loc_143F:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_4C]
jl loc_132D
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_48]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_146F
call ___stack_chk_fail
locret_146F:
leave
retn
|
long long func0(long long a1, int a2)
{
int v2; // edx
int i; // [rsp+14h] [rbp-3Ch]
int v5; // [rsp+18h] [rbp-38h]
int v6; // [rsp+18h] [rbp-38h]
int j; // [rsp+1Ch] [rbp-34h]
int k; // [rsp+20h] [rbp-30h]
int m; // [rsp+24h] [rbp-2Ch]
int v10; // [rsp+28h] [rbp-28h]
int v11; // [rsp+28h] [rbp-28h]
int v12; // [rsp+2Ch] [rbp-24h]
_DWORD *ptr; // [rsp+30h] [rbp-20h]
char s[12]; // [rsp+3Ch] [rbp-14h] BYREF
unsigned long long v15; // [rsp+48h] [rbp-8h]
v15 = __readfsqword(0x28u);
ptr = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
{
v2 = -*(_DWORD *)(4LL * i + a1);
if ( *(int *)(4LL * i + a1) > 0 )
v2 = *(_DWORD *)(4LL * i + a1);
sprintf(s, "%d", v2);
v5 = 0;
v12 = strlen(s);
for ( j = 1; j < v12; ++j )
v5 += s[j] - 48;
if ( *(int *)(4LL * i + a1) <= 0 )
v6 = v5 - (s[0] - 48);
else
v6 = s[0] - 48 + v5;
ptr[i] = v6;
}
for ( k = 0; k < a2; ++k )
{
for ( m = 1; m < a2; ++m )
{
if ( ptr[m - 1] > ptr[m] )
{
v10 = ptr[m];
ptr[m] = ptr[m - 1];
ptr[m - 1] = v10;
v11 = *(_DWORD *)(4LL * m + a1);
*(_DWORD *)(4LL * m + a1) = *(_DWORD *)(4LL * m - 4 + a1);
*(_DWORD *)(a1 + 4LL * m - 4) = v11;
}
}
}
free(ptr);
return a1;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x00101315
LAB_0010124c:
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
LEA RAX,[RBP + -0x14]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101110
MOV dword ptr [RBP + -0x38],0x0
LEA RAX,[RBP + -0x14]
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x34],0x1
JMP 0x001012ba
LAB_001012a3:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x14]
MOVSX EAX,AL
SUB EAX,0x30
ADD dword ptr [RBP + -0x38],EAX
ADD dword ptr [RBP + -0x34],0x1
LAB_001012ba:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001012a3
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x001012eb
MOVZX EAX,byte ptr [RBP + -0x14]
MOVSX EAX,AL
SUB EAX,0x30
ADD dword ptr [RBP + -0x38],EAX
JMP 0x001012f8
LAB_001012eb:
MOVZX EAX,byte ptr [RBP + -0x14]
MOVSX EAX,AL
SUB EAX,0x30
SUB dword ptr [RBP + -0x38],EAX
LAB_001012f8:
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x3c],0x1
LAB_00101315:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x0010124c
MOV dword ptr [RBP + -0x30],0x0
JMP 0x0010143f
LAB_0010132d:
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x0010142f
LAB_00101339:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x0010142b
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RDX],EAX
LAB_0010142b:
ADD dword ptr [RBP + -0x2c],0x1
LAB_0010142f:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x00101339
ADD dword ptr [RBP + -0x30],0x1
LAB_0010143f:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x0010132d
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x001010b0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010146f
CALL 0x001010e0
LAB_0010146f:
LEAVE
RET
|
long func0(long param_1,int param_2)
{
uint uVar1;
int4 uVar2;
uint uVar3;
int iVar4;
void *__ptr;
size_t sVar5;
long in_FS_OFFSET;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
char local_1c [12];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = malloc((long)param_2 << 2);
for (local_44 = 0; local_44 < param_2; local_44 = local_44 + 1) {
uVar1 = *(uint *)(param_1 + (long)local_44 * 4);
uVar3 = -uVar1;
if (0 < (int)uVar1) {
uVar3 = uVar1;
}
sprintf(local_1c,"%d",(ulong)uVar3);
local_40 = 0;
sVar5 = strlen(local_1c);
for (local_3c = 1; local_3c < (int)sVar5; local_3c = local_3c + 1) {
local_40 = local_40 + local_1c[local_3c] + -0x30;
}
if (*(int *)(param_1 + (long)local_44 * 4) < 1) {
iVar4 = -(local_1c[0] + -0x30);
}
else {
iVar4 = local_1c[0] + -0x30;
}
local_40 = local_40 + iVar4;
*(int *)((long)local_44 * 4 + (long)__ptr) = local_40;
}
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
for (local_34 = 1; local_34 < param_2; local_34 = local_34 + 1) {
if (*(int *)((long)__ptr + (long)local_34 * 4) <
*(int *)((long)__ptr + (long)local_34 * 4 + -4)) {
uVar2 = *(int4 *)((long)__ptr + (long)local_34 * 4);
*(int4 *)((long)__ptr + (long)local_34 * 4) =
*(int4 *)((long)__ptr + (long)local_34 * 4 + -4);
*(int4 *)((long)local_34 * 4 + -4 + (long)__ptr) = uVar2;
uVar2 = *(int4 *)(param_1 + (long)local_34 * 4);
*(int4 *)(param_1 + (long)local_34 * 4) =
*(int4 *)(param_1 + (long)local_34 * 4 + -4);
*(int4 *)((long)local_34 * 4 + -4 + param_1) = uVar2;
}
}
}
free(__ptr);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
|
1,237 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j = 1; j < length; j++)
sum += w[j] - '0';
if (nums[i] > 0) sum += w[0] - '0';
else sum -= w[0] - '0';
sumdigit[i] = sum;
}
int m;
for (int i = 0; i < size; i++)
for (int j = 1; j < size; j++)
if (sumdigit[j - 1] > sumdigit[j]) {
m = sumdigit[j]; sumdigit[j] = sumdigit[j - 1]; sumdigit[j - 1] = m;
m = nums[j]; nums[j] = nums[j - 1]; nums[j - 1] = m;
}
free(sumdigit);
return nums;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12, 11};
assert(issame(func0(test1, 5), expected1, 5, 5));
int test2[] = {1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46};
int expected2[] = {0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457};
assert(issame(func0(test2, 15), expected2, 15, 15));
int test3[] = {};
int expected3[] = {};
assert(issame(func0(test3, 0), expected3, 0, 0));
int test4[] = {1, -11, -32, 43, 54, -98, 2, -3};
int expected4[] = {-3, -32, -98, -11, 1, 2, 43, 54};
assert(issame(func0(test4, 8), expected4, 8, 8));
int test5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int expected5[] = {1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9};
assert(issame(func0(test5, 11), expected5, 11, 11));
int test6[] = {0, 6, 6, -76, -21, 23, 4};
int expected6[] = {-76, -21, 0, 4, 23, 6, 6};
assert(issame(func0(test6, 7), expected6, 7, 7));
printf("All tests passed!\n");
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbp
mov %esi,%r14d
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movslq %esi,%rdi
shl $0x2,%rdi
callq 10e0 <malloc@plt>
mov %rax,%rbx
test %r14d,%r14d
jle 135a <func0+0x171>
mov %rbp,%r12
mov %rax,%r13
mov %r14d,0x1c(%rsp)
lea -0x1(%r14),%eax
lea 0x4(%rbp,%rax,4),%rax
mov %rax,0x10(%rsp)
lea 0x2c(%rsp),%r15
jmp 1274 <func0+0x8b>
mov $0x0,%edx
jmpq 12e7 <func0+0xfe>
movsbl 0x2c(%rsp),%eax
sub $0x30,%eax
sub %eax,%edx
mov %edx,0x0(%r13)
add $0x4,%r12
add $0x4,%r13
cmp 0x10(%rsp),%r12
je 1303 <func0+0x11a>
mov %r12,0x8(%rsp)
mov (%r12),%eax
sar $0x1f,%eax
mov %eax,%r8d
xor (%r12),%r8d
sub %eax,%r8d
lea 0xd73(%rip),%rcx
mov $0xc,%edx
mov $0x1,%esi
mov %r15,%rdi
mov $0x0,%eax
callq 10f0 <__sprintf_chk@plt>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %r15,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp $0x1,%ecx
jle 1249 <func0+0x60>
lea 0x2d(%rsp),%rax
lea -0x2(%rcx),%edx
lea 0x2e(%rsp,%rdx,1),%rsi
mov $0x0,%edx
movsbl (%rax),%ecx
lea -0x30(%rdx,%rcx,1),%edx
add $0x1,%rax
cmp %rsi,%rax
jne 12d7 <func0+0xee>
mov 0x8(%rsp),%rax
cmpl $0x0,(%rax)
jle 1253 <func0+0x6a>
movsbl 0x2c(%rsp),%eax
lea -0x30(%rdx,%rax,1),%edx
jmpq 125d <func0+0x74>
mov $0x0,%edi
mov 0x1c(%rsp),%eax
lea -0x2(%rax),%esi
mov $0x0,%r8d
jmp 134f <func0+0x166>
lea 0x1(%rax),%rdx
cmp %rax,%rsi
je 1347 <func0+0x15e>
mov %rdx,%rax
mov (%rbx,%rax,4),%ecx
mov 0x4(%rbx,%rax,4),%edx
cmp %edx,%ecx
jle 1317 <func0+0x12e>
mov %ecx,0x4(%rbx,%rax,4)
mov %edx,(%rbx,%rax,4)
mov 0x4(%rbp,%rax,4),%edx
mov 0x0(%rbp,%rax,4),%ecx
mov %ecx,0x4(%rbp,%rax,4)
mov %edx,0x0(%rbp,%rax,4)
jmp 1317 <func0+0x12e>
add $0x1,%edi
cmp %edi,%r14d
je 135a <func0+0x171>
mov %r8,%rax
cmp $0x1,%r14d
jg 1323 <func0+0x13a>
jmp 1347 <func0+0x15e>
mov %rbx,%rdi
callq 10a0 <free@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1384 <func0+0x19b>
mov %rbp,%rax
add $0x48,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10c0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r14, rdi
mov r13d, esi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movsxd rbp, esi
shl rbp, 2
mov rdi, rbp; size
call _malloc
mov r15, rax
test r13d, r13d
jle loc_1355
mov rbx, r14
lea rax, [rbp+r14+0]
mov [rsp+68h+var_60], rax
mov rbp, r15
jmp short loc_1287
loc_125E:
mov eax, 0
jmp loc_12E9
loc_1268:
movsx edx, [rsp+68h+s]
sub edx, 30h ; '0'
sub eax, edx
loc_1272:
mov [rbp+0], eax
add rbx, 4
add rbp, 4
mov rax, [rsp+68h+var_60]
cmp rbx, rax
jz short loc_1304
loc_1287:
mov [rsp+68h+var_68], rbx
lea r12, [rsp+68h+s]
mov eax, [rbx]
mov r8d, eax
neg r8d
cmovs r8d, eax
lea rcx, unk_2004
mov edx, 0Ch
mov esi, 2
mov rdi, r12
mov eax, 0
call ___sprintf_chk
mov rdi, r12; s
call _strlen
cmp eax, 1
jle short loc_125E
lea rdx, [rsp+68h+var_4B]
lea eax, [rax-2]
lea rsi, [rsp+rax+68h+var_4A]
mov eax, 0
loc_12D9:
movsx ecx, byte ptr [rdx]
lea eax, [rax+rcx-30h]
add rdx, 1
cmp rdx, rsi
jnz short loc_12D9
loc_12E9:
mov rdi, [rsp+68h+var_68]
cmp dword ptr [rdi], 0
jle loc_1268
movsx edx, [rsp+68h+s]
lea eax, [rax+rdx-30h]
jmp loc_1272
loc_1304:
lea eax, [r13-2]
lea rdi, [r15+rax*4+8]
mov r8d, 0
jmp short loc_1345
loc_1315:
add rax, 4
add rdx, 4
cmp rax, rdi
jz short loc_133C
loc_1322:
mov esi, [rax-4]
mov ecx, [rax]
cmp esi, ecx
jle short loc_1315
mov [rax], esi
mov [rax-4], ecx
mov ecx, [rdx]
mov esi, [rdx-4]
mov [rdx], esi
mov [rdx-4], ecx
jmp short loc_1315
loc_133C:
add r8d, 1
cmp r13d, r8d
jz short loc_1355
loc_1345:
lea rax, [r15+4]
lea rdx, [r14+4]
cmp r13d, 1
jg short loc_1322
jmp short loc_133C
loc_1355:
mov rdi, r15; ptr
call _free
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_137F
mov rax, r14
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_137F:
call ___stack_chk_fail
|
int * func0(int *a1, int a2)
{
int *v3; // r15
int *v4; // rbx
int *v5; // rbp
int v6; // eax
int v7; // eax
long long v8; // r8
int v9; // eax
char *v10; // rdx
char *v11; // rsi
int v12; // r8d
int *v13; // rax
int *v14; // rdx
int v15; // esi
int v16; // ecx
int v17; // ecx
int *v19; // [rsp+8h] [rbp-60h]
char s; // [rsp+1Ch] [rbp-4Ch] BYREF
_BYTE v21[11]; // [rsp+1Dh] [rbp-4Bh] BYREF
unsigned long long v22; // [rsp+28h] [rbp-40h]
v22 = __readfsqword(0x28u);
v3 = (int *)malloc(4LL * a2);
if ( a2 > 0 )
{
v4 = a1;
v19 = &a1[a2];
v5 = v3;
do
{
v8 = (unsigned int)-*v4;
if ( *v4 > 0 )
v8 = (unsigned int)*v4;
__sprintf_chk(&s, 2LL, 12LL, &unk_2004, v8);
v9 = strlen(&s);
if ( v9 <= 1 )
{
v6 = 0;
}
else
{
v10 = v21;
v11 = &v21[v9 - 2 + 1];
v6 = 0;
do
v6 = v6 + *v10++ - 48;
while ( v10 != v11 );
}
if ( *v4 <= 0 )
v7 = v6 - (s - 48);
else
v7 = v6 + s - 48;
*v5 = v7;
++v4;
++v5;
}
while ( v4 != v19 );
v12 = 0;
do
{
v13 = v3 + 1;
v14 = a1 + 1;
if ( a2 > 1 )
{
do
{
v15 = *(v13 - 1);
v16 = *v13;
if ( v15 > *v13 )
{
*v13 = v15;
*(v13 - 1) = v16;
v17 = *v14;
*v14 = *(v14 - 1);
*(v14 - 1) = v17;
}
++v13;
++v14;
}
while ( v13 != &v3[a2 - 2 + 2] );
}
++v12;
}
while ( a2 != v12 );
}
free(v3);
return a1;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R14,RDI
MOV R13D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVSXD RBP,ESI
SHL RBP,0x2
MOV RDI,RBP
CALL 0x00101100
MOV R15,RAX
TEST R13D,R13D
JLE 0x00101355
MOV RBX,R14
LEA RAX,[RBP + R14*0x1]
MOV qword ptr [RSP + 0x8],RAX
MOV RBP,R15
JMP 0x00101287
LAB_0010125e:
MOV EAX,0x0
JMP 0x001012e9
LAB_00101268:
MOVSX EDX,byte ptr [RSP + 0x1c]
SUB EDX,0x30
SUB EAX,EDX
LAB_00101272:
MOV dword ptr [RBP],EAX
ADD RBX,0x4
ADD RBP,0x4
MOV RAX,qword ptr [RSP + 0x8]
CMP RBX,RAX
JZ 0x00101304
LAB_00101287:
MOV qword ptr [RSP],RBX
LEA R12,[RSP + 0x1c]
MOV EAX,dword ptr [RBX]
MOV R8D,EAX
NEG R8D
CMOVS R8D,EAX
LEA RCX,[0x102004]
MOV EDX,0xc
MOV ESI,0x2
MOV RDI,R12
MOV EAX,0x0
CALL 0x00101110
MOV RDI,R12
CALL 0x001010d0
CMP EAX,0x1
JLE 0x0010125e
LEA RDX,[RSP + 0x1d]
LEA EAX,[RAX + -0x2]
LEA RSI,[RSP + RAX*0x1 + 0x1e]
MOV EAX,0x0
LAB_001012d9:
MOVSX ECX,byte ptr [RDX]
LEA EAX,[RAX + RCX*0x1 + -0x30]
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x001012d9
LAB_001012e9:
MOV RDI,qword ptr [RSP]
CMP dword ptr [RDI],0x0
JLE 0x00101268
MOVSX EDX,byte ptr [RSP + 0x1c]
LEA EAX,[RAX + RDX*0x1 + -0x30]
JMP 0x00101272
LAB_00101304:
LEA EAX,[R13 + -0x2]
LEA RDI,[R15 + RAX*0x4 + 0x8]
MOV R8D,0x0
JMP 0x00101345
LAB_00101315:
ADD RAX,0x4
ADD RDX,0x4
CMP RAX,RDI
JZ 0x0010133c
LAB_00101322:
MOV ESI,dword ptr [RAX + -0x4]
MOV ECX,dword ptr [RAX]
CMP ESI,ECX
JLE 0x00101315
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + -0x4],ECX
MOV ECX,dword ptr [RDX]
MOV ESI,dword ptr [RDX + -0x4]
MOV dword ptr [RDX],ESI
MOV dword ptr [RDX + -0x4],ECX
JMP 0x00101315
LAB_0010133c:
ADD R8D,0x1
CMP R13D,R8D
JZ 0x00101355
LAB_00101345:
LEA RAX,[R15 + 0x4]
LEA RDX,[R14 + 0x4]
CMP R13D,0x1
JG 0x00101322
JMP 0x0010133c
LAB_00101355:
MOV RDI,R15
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010137f
MOV RAX,R14
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010137f:
CALL 0x001010e0
|
int * func0(int *param_1,int param_2)
{
int iVar1;
int *__ptr;
size_t sVar2;
int *piVar3;
char *pcVar4;
int *piVar5;
int iVar6;
long in_FS_OFFSET;
char local_4c;
char local_4b [11];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)malloc((long)param_2 * 4);
if (0 < param_2) {
piVar3 = param_1;
piVar5 = __ptr;
do {
iVar6 = *piVar3;
iVar1 = -iVar6;
if (0 < iVar6) {
iVar1 = iVar6;
}
__sprintf_chk(&local_4c,2,0xc,&DAT_00102004,iVar1);
sVar2 = strlen(&local_4c);
if ((int)sVar2 < 2) {
iVar6 = 0;
}
else {
pcVar4 = local_4b;
iVar6 = 0;
do {
iVar6 = iVar6 + -0x30 + (int)*pcVar4;
pcVar4 = pcVar4 + 1;
} while (pcVar4 != local_4b + (ulong)((int)sVar2 - 2) + 1);
}
if (*piVar3 < 1) {
iVar6 = iVar6 - (local_4c + -0x30);
}
else {
iVar6 = iVar6 + -0x30 + (int)local_4c;
}
*piVar5 = iVar6;
piVar3 = piVar3 + 1;
piVar5 = piVar5 + 1;
} while (piVar3 != param_1 + param_2);
iVar6 = 0;
do {
piVar3 = __ptr + 1;
piVar5 = param_1 + 1;
if (1 < param_2) {
do {
iVar1 = *piVar3;
if (iVar1 < piVar3[-1]) {
*piVar3 = piVar3[-1];
piVar3[-1] = iVar1;
iVar1 = *piVar5;
*piVar5 = piVar5[-1];
piVar5[-1] = iVar1;
}
piVar3 = piVar3 + 1;
piVar5 = piVar5 + 1;
} while (piVar3 != __ptr + (ulong)(param_2 - 2) + 2);
}
iVar6 = iVar6 + 1;
} while (param_2 != iVar6);
}
free(__ptr);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
|
1,238 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j = 1; j < length; j++)
sum += w[j] - '0';
if (nums[i] > 0) sum += w[0] - '0';
else sum -= w[0] - '0';
sumdigit[i] = sum;
}
int m;
for (int i = 0; i < size; i++)
for (int j = 1; j < size; j++)
if (sumdigit[j - 1] > sumdigit[j]) {
m = sumdigit[j]; sumdigit[j] = sumdigit[j - 1]; sumdigit[j - 1] = m;
m = nums[j]; nums[j] = nums[j - 1]; nums[j - 1] = m;
}
free(sumdigit);
return nums;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12, 11};
assert(issame(func0(test1, 5), expected1, 5, 5));
int test2[] = {1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46};
int expected2[] = {0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457};
assert(issame(func0(test2, 15), expected2, 15, 15));
int test3[] = {};
int expected3[] = {};
assert(issame(func0(test3, 0), expected3, 0, 0));
int test4[] = {1, -11, -32, 43, 54, -98, 2, -3};
int expected4[] = {-3, -32, -98, -11, 1, 2, 43, 54};
assert(issame(func0(test4, 8), expected4, 8, 8));
int test5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int expected5[] = {1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9};
assert(issame(func0(test5, 11), expected5, 11, 11));
int test6[] = {0, 6, 6, -76, -21, 23, 4};
int expected6[] = {-76, -21, 0, 4, 23, 6, 6};
assert(issame(func0(test6, 7), expected6, 7, 7));
printf("All tests passed!\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
callq 10e0 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
jle 1891 <func0+0x171>
mov %rax,%r12
lea -0x1(%rbx),%eax
lea 0x1c(%rsp),%r13
mov %r14,%r15
lea 0x4(%r14,%rax,4),%rax
mov %rax,(%rsp)
lea 0x1e(%rsp),%rax
mov %rax,0x8(%rsp)
mov (%r15),%eax
mov (%r15),%r8d
mov $0xc,%edx
mov $0x1,%esi
lea 0x86d(%rip),%rcx
mov %r13,%rdi
sar $0x1f,%eax
xor %eax,%r8d
sub %eax,%r8d
xor %eax,%eax
callq 10f0 <__sprintf_chk@plt>
mov %r13,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 17ad <func0+0x8d>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%edi
add %al,%dil
sbb $0x3,%rdx
sub %r13,%rdx
cmp $0x1,%rdx
jbe 18c0 <func0+0x1a0>
lea -0x2(%rdx),%esi
lea 0x1d(%rsp),%rax
add 0x8(%rsp),%rsi
xor %edx,%edx
xchg %ax,%ax
movsbl (%rax),%ecx
add $0x1,%rax
lea -0x30(%rdx,%rcx,1),%edx
cmp %rax,%rsi
jne 1800 <func0+0xe0>
movsbl 0x1c(%rsp),%eax
sub $0x30,%eax
lea (%rdx,%rax,1),%ecx
sub %eax,%edx
mov (%r15),%eax
test %eax,%eax
cmovg %ecx,%edx
add $0x4,%r15
add $0x4,%r12
mov %edx,-0x4(%r12)
cmp %r15,(%rsp)
jne 1780 <func0+0x60>
xor %edi,%edi
lea -0x2(%rbx),%esi
nopl 0x0(%rax)
xor %eax,%eax
cmp $0x1,%ebx
jne 185b <func0+0x13b>
jmp 188a <func0+0x16a>
nopl 0x0(%rax)
mov %rdx,%rax
mov 0x0(%rbp,%rax,4),%ecx
mov 0x4(%rbp,%rax,4),%edx
cmp %edx,%ecx
jle 1881 <func0+0x161>
mov %ecx,0x4(%rbp,%rax,4)
mov (%r14,%rax,4),%ecx
mov %edx,0x0(%rbp,%rax,4)
mov 0x4(%r14,%rax,4),%edx
mov %ecx,0x4(%r14,%rax,4)
mov %edx,(%r14,%rax,4)
lea 0x1(%rax),%rdx
cmp %rax,%rsi
jne 1858 <func0+0x138>
add $0x1,%edi
cmp %edi,%ebx
jne 1848 <func0+0x128>
mov %rbp,%rdi
callq 10a0 <free@plt>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 18c7 <func0+0x1a7>
add $0x38,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
xor %edx,%edx
jmpq 1810 <func0+0xf0>
callq 10c0 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
movsxd rbp, esi
push rbx
mov r12, rbp
shl rbp, 2
mov rdi, rbp; size
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _malloc
mov r14, rax
test r12d, r12d
jle loc_1758
lea rax, [rbp+r13+0]
mov r15, r13
lea rbx, [rsp+68h+s]
mov rbp, r14
mov [rsp+68h+var_68], rax
lea rax, [rsp+68h+var_4A]
mov [rsp+68h+var_60], rax
nop dword ptr [rax+00000000h]
loc_1668:
mov eax, [r15]
mov rdi, rbx
mov edx, 0Ch
mov esi, 2
lea rcx, unk_2004
mov r8d, eax
neg r8d
cmovs r8d, eax
xor eax, eax
call ___sprintf_chk
mov rdi, rbx; s
call _strlen
cmp rax, 1
jbe loc_1788
lea esi, [rax-2]
mov rax, [rsp+68h+var_60]
lea rdx, [rsp+68h+var_4B]
add rsi, rax
xor eax, eax
nop dword ptr [rax+00h]
loc_16B8:
movsx ecx, byte ptr [rdx]
add rdx, 1
lea eax, [rax+rcx-30h]
cmp rdx, rsi
jnz short loc_16B8
loc_16C8:
movsx edx, [rsp+68h+s]
mov esi, [r15]
mov ecx, eax
sub edx, 30h ; '0'
sub ecx, edx
test esi, esi
jle short loc_16DE
lea ecx, [rax+rdx]
loc_16DE:
mov rax, [rsp+68h+var_68]
add r15, 4
mov [rbp+0], ecx
add rbp, 4
cmp r15, rax
jnz loc_1668
cmp r12d, 1
jz short loc_1758
lea eax, [r12-2]
xor r8d, r8d
lea rdi, [r14+rax*4+4]
nop dword ptr [rax+00000000h]
loc_1710:
mov rdx, r13
mov rax, r14
nop word ptr [rax+rax+00000000h]
loc_1720:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd esi, xmm0
movd ecx, xmm1
cmp esi, ecx
jle short loc_1742
pshufd xmm0, xmm0, 0E1h
rol qword ptr [rdx], 20h
movq qword ptr [rax], xmm0
loc_1742:
add rax, 4
add rdx, 4
cmp rax, rdi
jnz short loc_1720
add r8d, 1
cmp r12d, r8d
jnz short loc_1710
loc_1758:
mov rdi, r14; ptr
call _free
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_178F
add rsp, 38h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1788:
xor eax, eax
jmp loc_16C8
loc_178F:
call ___stack_chk_fail
|
int * func0(int *a1, int a2)
{
__m128i *v3; // r14
int *v4; // r15
__m128i *v5; // rbp
long long v6; // r8
size_t v7; // rax
char *v8; // rdx
char *v9; // rsi
int v10; // eax
int v11; // ecx
int v12; // edx
int v13; // ecx
int v14; // r8d
int *v15; // rdx
__m128i *v16; // rax
__m128i v17; // xmm0
int *v19; // [rsp+0h] [rbp-68h]
char s; // [rsp+1Ch] [rbp-4Ch] BYREF
_BYTE v21[11]; // [rsp+1Dh] [rbp-4Bh] BYREF
unsigned long long v22; // [rsp+28h] [rbp-40h]
v22 = __readfsqword(0x28u);
v3 = (__m128i *)malloc(4LL * a2);
if ( a2 > 0 )
{
v4 = a1;
v5 = v3;
v19 = &a1[a2];
do
{
v6 = (unsigned int)-*v4;
if ( *v4 > 0 )
v6 = (unsigned int)*v4;
__sprintf_chk(&s, 2LL, 12LL, &unk_2004, v6);
v7 = strlen(&s);
if ( v7 <= 1 )
{
v10 = 0;
}
else
{
v8 = v21;
v9 = &v21[(unsigned int)(v7 - 2) + 1];
v10 = 0;
do
{
v11 = *v8++;
v10 = v10 + v11 - 48;
}
while ( v8 != v9 );
}
v12 = s - 48;
v13 = v10 - v12;
if ( *v4 > 0 )
v13 = v10 + v12;
++v4;
v5->m128i_i32[0] = v13;
v5 = (__m128i *)((char *)v5 + 4);
}
while ( v4 != v19 );
if ( a2 != 1 )
{
v14 = 0;
do
{
v15 = a1;
v16 = v3;
do
{
v17 = _mm_loadl_epi64(v16);
if ( _mm_cvtsi128_si32(v17) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v17, 229)) )
{
*(_QWORD *)v15 = __ROL8__(*(_QWORD *)v15, 32);
v16->m128i_i64[0] = _mm_shuffle_epi32(v17, 225).m128i_u64[0];
}
v16 = (__m128i *)((char *)v16 + 4);
++v15;
}
while ( v16 != (__m128i *)((char *)v3->m128i_i64 + 4 * (unsigned int)(a2 - 2) + 4) );
++v14;
}
while ( a2 != v14 );
}
}
free(v3);
return a1;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV R12,RBP
SHL RBP,0x2
MOV RDI,RBP
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x00101100
MOV R14,RAX
TEST R12D,R12D
JLE 0x00101758
LEA RAX,[RBP + R13*0x1]
MOV R15,R13
LEA RBX,[RSP + 0x1c]
MOV RBP,R14
MOV qword ptr [RSP],RAX
LEA RAX,[RSP + 0x1e]
MOV qword ptr [RSP + 0x8],RAX
NOP dword ptr [RAX]
LAB_00101668:
MOV EAX,dword ptr [R15]
MOV RDI,RBX
MOV EDX,0xc
MOV ESI,0x2
LEA RCX,[0x102004]
MOV R8D,EAX
NEG R8D
CMOVS R8D,EAX
XOR EAX,EAX
CALL 0x00101110
MOV RDI,RBX
CALL 0x001010d0
CMP RAX,0x1
JBE 0x00101788
LEA ESI,[RAX + -0x2]
MOV RAX,qword ptr [RSP + 0x8]
LEA RDX,[RSP + 0x1d]
ADD RSI,RAX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001016b8:
MOVSX ECX,byte ptr [RDX]
ADD RDX,0x1
LEA EAX,[RAX + RCX*0x1 + -0x30]
CMP RDX,RSI
JNZ 0x001016b8
LAB_001016c8:
MOVSX EDX,byte ptr [RSP + 0x1c]
MOV ESI,dword ptr [R15]
MOV ECX,EAX
SUB EDX,0x30
SUB ECX,EDX
TEST ESI,ESI
JLE 0x001016de
LEA ECX,[RAX + RDX*0x1]
LAB_001016de:
MOV RAX,qword ptr [RSP]
ADD R15,0x4
MOV dword ptr [RBP],ECX
ADD RBP,0x4
CMP R15,RAX
JNZ 0x00101668
CMP R12D,0x1
JZ 0x00101758
LEA EAX,[R12 + -0x2]
XOR R8D,R8D
LEA RDI,[R14 + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101710:
MOV RDX,R13
MOV RAX,R14
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101720:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ESI,XMM0
MOVD ECX,XMM1
CMP ESI,ECX
JLE 0x00101742
PSHUFD XMM0,XMM0,0xe1
ROL qword ptr [RDX],0x20
MOVQ qword ptr [RAX],XMM0
LAB_00101742:
ADD RAX,0x4
ADD RDX,0x4
CMP RAX,RDI
JNZ 0x00101720
ADD R8D,0x1
CMP R12D,R8D
JNZ 0x00101710
LAB_00101758:
MOV RDI,R14
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010178f
ADD RSP,0x38
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101788:
XOR EAX,EAX
JMP 0x001016c8
LAB_0010178f:
CALL 0x001010e0
|
ulong * func0(ulong *param_1,int param_2)
{
char cVar1;
int *__ptr;
size_t sVar2;
int *piVar3;
char *pcVar4;
int iVar5;
ulong *puVar6;
long in_FS_OFFSET;
int iVar7;
int iVar8;
char local_4c;
char local_4b [11];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)malloc((long)param_2 * 4);
if (0 < param_2) {
piVar3 = __ptr;
puVar6 = param_1;
do {
__sprintf_chk(&local_4c,2,0xc,&DAT_00102004);
sVar2 = strlen(&local_4c);
if (sVar2 < 2) {
iVar5 = 0;
}
else {
pcVar4 = local_4b;
iVar5 = 0;
do {
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
iVar5 = iVar5 + -0x30 + (int)cVar1;
} while (pcVar4 != local_4b + (ulong)((int)sVar2 - 2) + 1);
}
iVar7 = -(local_4c + -0x30);
if (0 < *(int *)puVar6) {
iVar7 = local_4c + -0x30;
}
puVar6 = (ulong *)((long)puVar6 + 4);
*piVar3 = iVar5 + iVar7;
piVar3 = piVar3 + 1;
} while (puVar6 != (ulong *)((long)param_2 * 4 + (long)param_1));
if (param_2 != 1) {
iVar5 = 0;
piVar3 = __ptr;
puVar6 = param_1;
do {
iVar7 = (int)*(int8 *)piVar3;
iVar8 = (int)((ulong)*(int8 *)piVar3 >> 0x20);
if (iVar8 < iVar7) {
*puVar6 = *puVar6 << 0x20 | *puVar6 >> 0x20;
*(ulong *)piVar3 = CONCAT44(iVar7,iVar8);
}
piVar3 = piVar3 + 1;
puVar6 = (ulong *)((long)puVar6 + 4);
} while ((piVar3 != __ptr + (ulong)(param_2 - 2) + 1) ||
(iVar5 = iVar5 + 1, piVar3 = __ptr, puVar6 = param_1, param_2 != iVar5));
}
}
free(__ptr);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,239 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
int* func0(int nums[], int size) {
int* sumdigit = (int*)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
char w[12]; // Assuming the integer won't exceed the length of an int in string form.
sprintf(w, "%d", abs(nums[i]));
int sum = 0, length = strlen(w);
for (int j = 1; j < length; j++)
sum += w[j] - '0';
if (nums[i] > 0) sum += w[0] - '0';
else sum -= w[0] - '0';
sumdigit[i] = sum;
}
int m;
for (int i = 0; i < size; i++)
for (int j = 1; j < size; j++)
if (sumdigit[j - 1] > sumdigit[j]) {
m = sumdigit[j]; sumdigit[j] = sumdigit[j - 1]; sumdigit[j - 1] = m;
m = nums[j]; nums[j] = nums[j - 1]; nums[j - 1] = m;
}
free(sumdigit);
return nums;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int* a, int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 11, -1, -11, -12};
int expected1[] = {-1, -11, 1, -12, 11};
assert(issame(func0(test1, 5), expected1, 5, 5));
int test2[] = {1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46};
int expected2[] = {0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457};
assert(issame(func0(test2, 15), expected2, 15, 15));
int test3[] = {};
int expected3[] = {};
assert(issame(func0(test3, 0), expected3, 0, 0));
int test4[] = {1, -11, -32, 43, 54, -98, 2, -3};
int expected4[] = {-3, -32, -98, -11, 1, 2, 43, 54};
assert(issame(func0(test4, 8), expected4, 8, 8));
int test5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int expected5[] = {1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9};
assert(issame(func0(test5, 11), expected5, 11, 11));
int test6[] = {0, 6, 6, -76, -21, 23, 4};
int expected6[] = {-76, -21, 0, 4, 23, 6, 6};
assert(issame(func0(test6, 7), expected6, 7, 7));
printf("All tests passed!\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x38,%rsp
mov %edi,0xc(%rsp)
shl $0x2,%rdi
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
callq 10e0 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
jle 17e3 <func0+0x1e3>
mov %ebx,%eax
mov %r14,%r15
mov %rbp,%rbx
sub $0x1,%eax
lea 0x1c(%rsp),%r13
lea 0x9aa(%rip),%r12
lea 0x4(%r14,%rax,4),%rax
mov %rax,(%rsp)
jmpq 171c <func0+0x11c>
nopl 0x0(%rax,%rax,1)
movsbl 0x1d(%rsp),%eax
sub $0x30,%eax
cmp $0x2,%edx
je 16f6 <func0+0xf6>
movsbl 0x1e(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0x3,%ecx
je 16f6 <func0+0xf6>
movsbl 0x1f(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0x4,%ecx
je 16f6 <func0+0xf6>
movsbl 0x20(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0x5,%ecx
je 16f6 <func0+0xf6>
movsbl 0x21(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0x6,%ecx
je 16f6 <func0+0xf6>
movsbl 0x22(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0x7,%ecx
je 16f6 <func0+0xf6>
movsbl 0x23(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0x8,%ecx
je 16f6 <func0+0xf6>
movsbl 0x24(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0x9,%ecx
je 16f6 <func0+0xf6>
movsbl 0x25(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
cmp $0xb,%ecx
jne 16f6 <func0+0xf6>
movsbl 0x26(%rsp),%edx
lea -0x30(%rax,%rdx,1),%eax
movsbl 0x1c(%rsp),%edx
sub $0x30,%edx
lea (%rax,%rdx,1),%ecx
sub %edx,%eax
mov (%r15),%edx
test %edx,%edx
cmovg %ecx,%eax
add $0x4,%r15
add $0x4,%rbx
mov %eax,-0x4(%rbx)
cmp (%rsp),%r15
je 1790 <func0+0x190>
mov (%r15),%eax
mov (%r15),%r8d
mov $0xc,%edx
mov %r12,%rcx
mov $0x1,%esi
mov %r13,%rdi
sar $0x1f,%eax
xor %eax,%r8d
sub %eax,%r8d
xor %eax,%eax
callq 10f0 <__sprintf_chk@plt>
mov %r13,%rdx
mov (%rdx),%ecx
add $0x4,%rdx
lea -0x1010101(%rcx),%eax
not %ecx
and %ecx,%eax
and $0x80808080,%eax
je 1745 <func0+0x145>
mov %eax,%ecx
shr $0x10,%ecx
test $0x8080,%eax
cmove %ecx,%eax
lea 0x2(%rdx),%rcx
cmove %rcx,%rdx
mov %eax,%edi
add %al,%dil
sbb $0x3,%rdx
sub %r13,%rdx
mov %edx,%ecx
cmp $0x1,%rdx
ja 1670 <func0+0x70>
xor %eax,%eax
jmpq 16f6 <func0+0xf6>
mov 0xc(%rsp),%eax
xor %edi,%edi
lea -0x2(%rax),%esi
cmp $0x1,%eax
je 17e3 <func0+0x1e3>
xchg %ax,%ax
xor %eax,%eax
jmp 17ab <func0+0x1ab>
nopl 0x0(%rax)
mov %rdx,%rax
mov 0x0(%rbp,%rax,4),%ecx
mov 0x4(%rbp,%rax,4),%edx
cmp %edx,%ecx
jle 17d1 <func0+0x1d1>
mov %ecx,0x4(%rbp,%rax,4)
mov (%r14,%rax,4),%ecx
mov %edx,0x0(%rbp,%rax,4)
mov 0x4(%r14,%rax,4),%edx
mov %ecx,0x4(%r14,%rax,4)
mov %edx,(%r14,%rax,4)
lea 0x1(%rax),%rdx
cmp %rax,%rsi
jne 17a8 <func0+0x1a8>
add $0x1,%edi
cmp %edi,0xc(%rsp)
jne 17a0 <func0+0x1a0>
mov %rbp,%rdi
callq 10a0 <free@plt>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 180d <func0+0x20d>
add $0x38,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10c0 <__stack_chk_fail@plt>
data16 nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
push r15
push r14
movsxd r14, esi
push r13
push r12
mov r12, rdi
push rbp
mov rbp, r14
shl r14, 2
push rbx
mov rdi, r14; size
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _malloc
mov r13, rax
test ebp, ebp
jle loc_1828
lea rax, [r14+r12]
mov r15, r12
lea rbx, [rsp+68h+s]
mov r14, r13
mov [rsp+68h+var_60], rax
jmp loc_1779
loc_1660:
lea eax, [rax-2]
cmp eax, 6
jbe loc_1852
movq xmm1, [rsp+68h+var_4F]
pxor xmm2, xmm2
pcmpgtb xmm2, xmm1
movdqa xmm0, xmm1
punpcklbw xmm0, xmm2
punpcklbw xmm1, xmm2
pxor xmm2, xmm2
paddw xmm0, xmm4
movdqa xmm3, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
paddw xmm1, xmm4
pcmpgtw xmm3, xmm0
movdqa xmm5, xmm0
pcmpgtw xmm2, xmm1
punpcklwd xmm0, xmm3
punpcklwd xmm5, xmm3
movdqa xmm3, xmm1
pshufd xmm0, xmm0, 4Eh ; 'N'
punpcklwd xmm3, xmm2
punpcklwd xmm1, xmm2
paddd xmm0, xmm5
pshufd xmm1, xmm1, 4Eh ; 'N'
paddd xmm0, xmm3
paddd xmm0, xmm1
movd ecx, xmm0
pshufd xmm7, xmm0, 0E5h
movd eax, xmm7
add eax, ecx
mov ecx, 9
cmp edx, 9
jz short loc_1751
loc_16EA:
movsxd rsi, ecx
movsx esi, [rsp+rsi+68h+s]
lea eax, [rax+rsi-30h]
lea esi, [rcx+1]
cmp edx, esi
jle short loc_1751
movsxd rsi, esi
add ecx, 2
movsx esi, [rsp+rsi+68h+s]
lea eax, [rax+rsi-30h]
cmp edx, ecx
jle short loc_1751
movsx ecx, byte ptr [rsp+68h+var_4F+2]
lea eax, [rax+rcx-30h]
cmp edx, 4
jz short loc_1751
movsx ecx, byte ptr [rsp+68h+var_4F+3]
lea eax, [rax+rcx-30h]
cmp edx, 5
jz short loc_1751
movsx ecx, byte ptr [rsp+68h+var_4F+4]
lea eax, [rax+rcx-30h]
cmp edx, 6
jz short loc_1751
movsx ecx, byte ptr [rsp+68h+var_4F+5]
lea eax, [rax+rcx-30h]
cmp edx, 7
jz short loc_1751
movsx edx, byte ptr [rsp+68h+var_4F+6]
lea eax, [rax+rdx-30h]
loc_1751:
movsx edx, [rsp+68h+s]
mov esi, [r15]
mov ecx, eax
sub edx, 30h ; '0'
sub ecx, edx
test esi, esi
jle short loc_1767
lea ecx, [rax+rdx]
loc_1767:
mov [r14], ecx
add r15, 4
add r14, 4
cmp [rsp+68h+var_60], r15
jz short loc_17C8
loc_1779:
mov eax, [r15]
mov edx, 0Ch
mov esi, 2
mov rdi, rbx
lea rcx, unk_2004
mov r8d, eax
neg r8d
cmovs r8d, eax
xor eax, eax
call ___sprintf_chk
mov rdi, rbx; s
call _strlen
movq xmm4, cs:qword_2160
cmp rax, 1
mov rdx, rax
ja loc_1660
xor eax, eax
jmp short loc_1751
loc_17C8:
cmp ebp, 1
jz short loc_1828
lea eax, [rbp-2]
xor r8d, r8d
lea rdi, [r13+rax*4+4]
nop dword ptr [rax+rax+00000000h]
loc_17E0:
mov rdx, r12
mov rax, r13
nop word ptr [rax+rax+00000000h]
loc_17F0:
movq xmm0, qword ptr [rax]
pshufd xmm6, xmm0, 0E5h
movd esi, xmm0
movd ecx, xmm6
cmp esi, ecx
jle short loc_1812
pshufd xmm0, xmm0, 0E1h
rol qword ptr [rdx], 20h
movq qword ptr [rax], xmm0
loc_1812:
add rax, 4
add rdx, 4
cmp rdi, rax
jnz short loc_17F0
add r8d, 1
cmp ebp, r8d
jnz short loc_17E0
loc_1828:
mov rdi, r13; ptr
call _free
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_185E
add rsp, 38h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1852:
mov ecx, 1
xor eax, eax
jmp loc_16EA
loc_185E:
call ___stack_chk_fail
|
int * func0(int *a1, int a2)
{
__m128i *v2; // r13
int *v3; // r15
__m128i *v4; // r14
__m128i v5; // xmm1
__m128i v6; // xmm1
__m128i v7; // xmm0
__m128i v8; // xmm1
__m128i v9; // xmm5
__m128i v10; // xmm3
__m128i v11; // xmm0
int v12; // eax
int v13; // ecx
int v14; // edx
int v15; // ecx
long long v16; // r8
size_t v17; // rax
__m128i v18; // xmm4
int v19; // edx
int i; // r8d
int *v21; // rdx
__m128i *v22; // rax
__m128i v23; // xmm0
char s; // [rsp+18h] [rbp-50h] BYREF
_BYTE v26[15]; // [rsp+19h] [rbp-4Fh] BYREF
unsigned long long v27; // [rsp+28h] [rbp-40h]
v27 = __readfsqword(0x28u);
v2 = (__m128i *)malloc(4LL * a2);
if ( a2 <= 0 )
goto LABEL_26;
v3 = a1;
v4 = v2;
do
{
v16 = (unsigned int)-*v3;
if ( *v3 > 0 )
v16 = (unsigned int)*v3;
__sprintf_chk(&s, 2LL, 12LL, &unk_2004, v16);
v17 = strlen(&s);
v18 = _mm_loadl_epi64((const __m128i *)&qword_2160);
v19 = v17;
if ( v17 > 1 )
{
if ( (unsigned int)(v17 - 2) <= 6 )
{
v13 = 1;
v12 = 0;
}
else
{
v5 = _mm_loadl_epi64((const __m128i *)v26);
v6 = _mm_unpacklo_epi8(v5, _mm_cmpgt_epi8((__m128i)0LL, v5));
v7 = _mm_add_epi16(v6, v18);
v8 = _mm_add_epi16(_mm_shuffle_epi32(v6, 78), v18);
v9 = _mm_unpacklo_epi16(v7, _mm_cmpgt_epi16((__m128i)0LL, v7));
v10 = _mm_unpacklo_epi16(v8, _mm_cmpgt_epi16((__m128i)0LL, v8));
v11 = _mm_add_epi32(
_mm_add_epi32(_mm_add_epi32(_mm_shuffle_epi32(v9, 78), v9), v10),
_mm_shuffle_epi32(v10, 78));
v12 = _mm_cvtsi128_si32(v11) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v11, 229));
v13 = 9;
if ( v19 == 9 )
goto LABEL_12;
}
v12 = v12 + v26[v13 - 1] - 48;
if ( v19 > v13 + 1 )
{
v12 = v12 + v26[v13] - 48;
if ( v19 > v13 + 2 )
{
v12 = v12 + v26[2] - 48;
if ( v19 != 4 )
{
v12 = v12 + v26[3] - 48;
if ( v19 != 5 )
{
v12 = v12 + v26[4] - 48;
if ( v19 != 6 )
{
v12 = v12 + v26[5] - 48;
if ( v19 != 7 )
v12 = v12 + v26[6] - 48;
}
}
}
}
}
}
else
{
v12 = 0;
}
LABEL_12:
v14 = s - 48;
v15 = v12 - v14;
if ( *v3 > 0 )
v15 = v12 + v14;
v4->m128i_i32[0] = v15;
++v3;
v4 = (__m128i *)((char *)v4 + 4);
}
while ( &a1[a2] != v3 );
if ( a2 != 1 )
{
for ( i = 0; i != a2; ++i )
{
v21 = a1;
v22 = v2;
do
{
v23 = _mm_loadl_epi64(v22);
if ( _mm_cvtsi128_si32(v23) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v23, 229)) )
{
*(_QWORD *)v21 = __ROL8__(*(_QWORD *)v21, 32);
v22->m128i_i64[0] = _mm_shuffle_epi32(v23, 225).m128i_u64[0];
}
v22 = (__m128i *)((char *)v22 + 4);
++v21;
}
while ( (__m128i *)((char *)v2->m128i_i64 + 4 * (unsigned int)(a2 - 2) + 4) != v22 );
}
}
LABEL_26:
free(v2);
return a1;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOVSXD R14,ESI
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,R14
SHL R14,0x2
PUSH RBX
MOV RDI,R14
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x00101100
MOV R13,RAX
TEST EBP,EBP
JLE 0x00101828
LEA RAX,[R14 + R12*0x1]
MOV R15,R12
LEA RBX,[RSP + 0x18]
MOV R14,R13
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00101779
LAB_00101660:
LEA EAX,[RAX + -0x2]
CMP EAX,0x6
JBE 0x00101852
MOVQ XMM1,qword ptr [RSP + 0x19]
PXOR XMM2,XMM2
PCMPGTB XMM2,XMM1
MOVDQA XMM0,XMM1
PUNPCKLBW XMM0,XMM2
PUNPCKLBW XMM1,XMM2
PXOR XMM2,XMM2
PADDW XMM0,XMM4
MOVDQA XMM3,XMM2
PSHUFD XMM1,XMM1,0x4e
PADDW XMM1,XMM4
PCMPGTW XMM3,XMM0
MOVDQA XMM5,XMM0
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM0,XMM3
PUNPCKLWD XMM5,XMM3
MOVDQA XMM3,XMM1
PSHUFD XMM0,XMM0,0x4e
PUNPCKLWD XMM3,XMM2
PUNPCKLWD XMM1,XMM2
PADDD XMM0,XMM5
PSHUFD XMM1,XMM1,0x4e
PADDD XMM0,XMM3
PADDD XMM0,XMM1
MOVD ECX,XMM0
PSHUFD XMM7,XMM0,0xe5
MOVD EAX,XMM7
ADD EAX,ECX
MOV ECX,0x9
CMP EDX,0x9
JZ 0x00101751
LAB_001016ea:
MOVSXD RSI,ECX
MOVSX ESI,byte ptr [RSP + RSI*0x1 + 0x18]
LEA EAX,[RAX + RSI*0x1 + -0x30]
LEA ESI,[RCX + 0x1]
CMP EDX,ESI
JLE 0x00101751
MOVSXD RSI,ESI
ADD ECX,0x2
MOVSX ESI,byte ptr [RSP + RSI*0x1 + 0x18]
LEA EAX,[RAX + RSI*0x1 + -0x30]
CMP EDX,ECX
JLE 0x00101751
MOVSX ECX,byte ptr [RSP + 0x1b]
LEA EAX,[RAX + RCX*0x1 + -0x30]
CMP EDX,0x4
JZ 0x00101751
MOVSX ECX,byte ptr [RSP + 0x1c]
LEA EAX,[RAX + RCX*0x1 + -0x30]
CMP EDX,0x5
JZ 0x00101751
MOVSX ECX,byte ptr [RSP + 0x1d]
LEA EAX,[RAX + RCX*0x1 + -0x30]
CMP EDX,0x6
JZ 0x00101751
MOVSX ECX,byte ptr [RSP + 0x1e]
LEA EAX,[RAX + RCX*0x1 + -0x30]
CMP EDX,0x7
JZ 0x00101751
MOVSX EDX,byte ptr [RSP + 0x1f]
LEA EAX,[RAX + RDX*0x1 + -0x30]
LAB_00101751:
MOVSX EDX,byte ptr [RSP + 0x18]
MOV ESI,dword ptr [R15]
MOV ECX,EAX
SUB EDX,0x30
SUB ECX,EDX
TEST ESI,ESI
JLE 0x00101767
LEA ECX,[RAX + RDX*0x1]
LAB_00101767:
MOV dword ptr [R14],ECX
ADD R15,0x4
ADD R14,0x4
CMP qword ptr [RSP + 0x8],R15
JZ 0x001017c8
LAB_00101779:
MOV EAX,dword ptr [R15]
MOV EDX,0xc
MOV ESI,0x2
MOV RDI,RBX
LEA RCX,[0x102004]
MOV R8D,EAX
NEG R8D
CMOVS R8D,EAX
XOR EAX,EAX
CALL 0x00101110
MOV RDI,RBX
CALL 0x001010d0
MOVQ XMM4,qword ptr [0x00102160]
CMP RAX,0x1
MOV RDX,RAX
JA 0x00101660
XOR EAX,EAX
JMP 0x00101751
LAB_001017c8:
CMP EBP,0x1
JZ 0x00101828
LEA EAX,[RBP + -0x2]
XOR R8D,R8D
LEA RDI,[R13 + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001017e0:
MOV RDX,R12
MOV RAX,R13
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017f0:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM6,XMM0,0xe5
MOVD ESI,XMM0
MOVD ECX,XMM6
CMP ESI,ECX
JLE 0x00101812
PSHUFD XMM0,XMM0,0xe1
ROL qword ptr [RDX],0x20
MOVQ qword ptr [RAX],XMM0
LAB_00101812:
ADD RAX,0x4
ADD RDX,0x4
CMP RDI,RAX
JNZ 0x001017f0
ADD R8D,0x1
CMP EBP,R8D
JNZ 0x001017e0
LAB_00101828:
MOV RDI,R13
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010185e
ADD RSP,0x38
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101852:
MOV ECX,0x1
XOR EAX,EAX
JMP 0x001016ea
LAB_0010185e:
CALL 0x001010e0
|
ulong * func0(ulong *param_1,int param_2)
{
int auVar1 [14];
int auVar2 [12];
unkbyte10 Var3;
int auVar4 [12];
int auVar5 [12];
int iVar6;
int *__ptr;
size_t sVar7;
int *piVar8;
int iVar9;
ulong *puVar10;
long in_FS_OFFSET;
short sVar11;
short sVar18;
short sVar19;
short sVar21;
int iVar20;
int auVar12 [16];
short sVar22;
short sVar29;
short sVar30;
short sVar31;
int auVar23 [16];
char local_50;
short local_4f;
char cStack_4d;
char cStack_4c;
char cStack_4b;
char cStack_4a;
char cStack_49;
byte bStack_48;
long local_40;
int auVar13 [16];
int auVar14 [16];
int auVar15 [16];
int auVar16 [16];
int auVar17 [16];
int auVar24 [16];
int auVar25 [16];
int auVar26 [16];
int auVar27 [16];
int auVar28 [16];
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__ptr = (int *)malloc((long)param_2 * 4);
if (0 < param_2) {
piVar8 = __ptr;
puVar10 = param_1;
do {
__sprintf_chk(&local_50,2,0xc,&DAT_00102004);
sVar7 = strlen(&local_50);
if (sVar7 < 2) {
iVar6 = 0;
}
else {
iVar9 = (int)sVar7;
if (iVar9 - 2U < 7) {
iVar20 = 1;
iVar6 = 0;
}
else {
auVar17._0_14_ = ZEXT114(bStack_48) << 0x38;
auVar17[0xe] = bStack_48;
auVar17[0xf] = -((char)bStack_48 < '\0');
auVar16._14_2_ = auVar17._14_2_;
auVar16._0_13_ = ZEXT113(bStack_48) << 0x38;
auVar16[0xd] = -(cStack_49 < '\0');
auVar15._13_3_ = auVar16._13_3_;
auVar15._0_12_ = ZEXT112(bStack_48) << 0x38;
auVar15[0xc] = cStack_49;
auVar14._12_4_ = auVar15._12_4_;
auVar14._0_11_ = ZEXT111(bStack_48) << 0x38;
auVar14[0xb] = -(cStack_4a < '\0');
auVar13._11_5_ = auVar14._11_5_;
auVar13._0_10_ = (unkuint10)bStack_48 << 0x38;
auVar13[10] = cStack_4a;
auVar12._10_6_ = auVar13._10_6_;
auVar12._0_9_ = (unkuint9)bStack_48 << 0x38;
auVar12[9] = -(cStack_4b < '\0');
Var3 = CONCAT91(CONCAT81((long)(((unkuint9)auVar12._9_7_ << 0x10) >> 8),
-(cStack_4c < '\0')),cStack_4c);
auVar2._2_10_ = Var3;
auVar2[1] = -(cStack_4d < '\0');
auVar2[0] = cStack_4d;
auVar1._2_12_ = auVar2;
auVar1[1] = -(local_4f < 0);
auVar1[0] = (char)((ushort)local_4f >> 8);
auVar28._0_14_ = ZEXT114(bStack_48) << 0x38;
auVar28[0xe] = bStack_48;
auVar28[0xf] = -((char)bStack_48 < '\0');
auVar27._14_2_ = auVar28._14_2_;
auVar27._0_13_ = ZEXT113(bStack_48) << 0x38;
auVar27[0xd] = -(cStack_49 < '\0');
auVar26._13_3_ = auVar27._13_3_;
auVar26._0_12_ = ZEXT112(bStack_48) << 0x38;
auVar26[0xc] = cStack_49;
auVar25._12_4_ = auVar26._12_4_;
auVar25._0_11_ = ZEXT111(bStack_48) << 0x38;
auVar25[0xb] = -(cStack_4a < '\0');
auVar24._11_5_ = auVar25._11_5_;
auVar24._0_10_ = (unkuint10)bStack_48 << 0x38;
auVar24[10] = cStack_4a;
auVar23._10_6_ = auVar24._10_6_;
auVar23._0_9_ = (unkuint9)bStack_48 << 0x38;
auVar23[9] = -(cStack_4b < '\0');
sVar11 = CONCAT11(-((char)local_4f < '\0'),(char)local_4f) + (short)DAT_00102160;
sVar18 = auVar1._0_2_ + DAT_00102160._2_2_;
sVar19 = auVar2._0_2_ + DAT_00102160._4_2_;
sVar21 = (short)Var3 + DAT_00102160._6_2_;
sVar22 = (short)(CONCAT72(auVar23._9_7_,CONCAT11(cStack_4b,bStack_48)) >> 8) +
(short)DAT_00102160;
sVar29 = auVar24._10_2_ + DAT_00102160._2_2_;
sVar30 = auVar26._12_2_ + DAT_00102160._4_2_;
sVar31 = auVar27._14_2_ + DAT_00102160._6_2_;
iVar6 = CONCAT22(-(ushort)(sVar21 < 0),sVar21);
auVar4._4_8_ = (long)(((unkuint10)
(uint6)(((unkuint10)CONCAT22(-(ushort)(sVar21 < 0),sVar21) << 0x30)
>> 0x20) << 0x20) >> 0x10);
auVar4._2_2_ = -(ushort)(sVar18 < 0);
auVar4._0_2_ = sVar18;
auVar5._4_8_ = (long)(((unkuint10)
(uint6)(((unkuint10)CONCAT22(-(ushort)(sVar31 < 0),sVar31) << 0x30)
>> 0x20) << 0x20) >> 0x10);
auVar5._2_2_ = -(ushort)(sVar29 < 0);
auVar5._0_2_ = sVar29;
iVar20 = CONCAT22(-(ushort)(sVar31 < 0),sVar31);
iVar6 = iVar6 + auVar4._0_4_ + auVar5._0_4_ + iVar20 +
(int)(CONCAT64(CONCAT42(iVar6,-(ushort)(sVar19 < 0)),CONCAT22(sVar19,sVar21)) >>
0x10) + CONCAT22(-(ushort)(sVar11 < 0),sVar11) +
CONCAT22(-(ushort)(sVar22 < 0),sVar22) +
(int)(CONCAT64(CONCAT42(iVar20,-(ushort)(sVar30 < 0)),CONCAT22(sVar30,sVar31)) >>
0x10);
iVar20 = 9;
if (iVar9 == 9) goto LAB_00101751;
}
iVar6 = iVar6 + -0x30 + (int)(&local_50)[iVar20];
if (((((iVar20 + 1 < iVar9) &&
(iVar6 = iVar6 + -0x30 + (int)(&local_50)[iVar20 + 1], iVar20 + 2 < iVar9)) &&
(iVar6 = iVar6 + -0x30 + (int)cStack_4d, iVar9 != 4)) &&
((iVar6 = iVar6 + -0x30 + (int)cStack_4c, iVar9 != 5 &&
(iVar6 = iVar6 + -0x30 + (int)cStack_4b, iVar9 != 6)))) &&
(iVar6 = iVar6 + -0x30 + (int)cStack_4a, iVar9 != 7)) {
iVar6 = iVar6 + -0x30 + (int)cStack_49;
}
}
LAB_00101751:
iVar9 = -(local_50 + -0x30);
if (0 < *(int *)puVar10) {
iVar9 = local_50 + -0x30;
}
*piVar8 = iVar6 + iVar9;
puVar10 = (ulong *)((long)puVar10 + 4);
piVar8 = piVar8 + 1;
} while ((ulong *)((long)param_2 * 4 + (long)param_1) != puVar10);
if (param_2 != 1) {
iVar9 = 0;
piVar8 = __ptr;
puVar10 = param_1;
do {
iVar6 = (int)*(int8 *)piVar8;
iVar20 = (int)((ulong)*(int8 *)piVar8 >> 0x20);
if (iVar20 < iVar6) {
*puVar10 = *puVar10 << 0x20 | *puVar10 >> 0x20;
*(ulong *)piVar8 = CONCAT44(iVar6,iVar20);
}
piVar8 = piVar8 + 1;
puVar10 = (ulong *)((long)puVar10 + 4);
} while ((__ptr + (ulong)(param_2 - 2) + 1 != piVar8) ||
(iVar9 = iVar9 + 1, piVar8 = __ptr, puVar10 = param_1, param_2 != iVar9));
}
}
free(__ptr);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,240 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first % 2 == 1 && last % 2 == 1) {
num += 1;
}
}
}
return num;
}
|
#include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 2);
}
{
int nums[] = {43, -12, 93, 125, 121, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 4);
}
{
int nums[] = {71, -2, -33, 75, 21, 19};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 3);
}
{
int nums[] = {1};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 1265 <func0+0xfc>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0xa,%eax
jle 1261 <func0+0xf8>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
mov %eax,-0x8(%rbp)
mov -0x8(%rbp),%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
jmp 122b <func0+0xc2>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0xc(%rbp)
cmpl $0x9,-0xc(%rbp)
jg 120d <func0+0xa4>
mov -0xc(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 1261 <func0+0xf8>
mov -0x8(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 1261 <func0+0xf8>
addl $0x1,-0x14(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 118b <func0+0x22>
mov -0x14(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp loc_126B
loc_118B:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cmp eax, 0Ah
jle loc_1267
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
sar eax, 2
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
mov [rbp+var_8], eax
mov ecx, [rbp+var_8]
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_8], edx
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
jmp short loc_1225
loc_1207:
mov eax, [rbp+var_C]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_C], eax
loc_1225:
cmp [rbp+var_C], 9
jg short loc_1207
mov eax, [rbp+var_C]
mov [rbp+var_4], eax
mov edx, [rbp+var_4]
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_1267
mov edx, [rbp+var_8]
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_1267
add [rbp+var_14], 1
loc_1267:
add [rbp+var_10], 1
loc_126B:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl loc_118B
mov eax, [rbp+var_14]
pop rbp
retn
|
long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-14h]
int i; // [rsp+1Ch] [rbp-10h]
int j; // [rsp+20h] [rbp-Ch]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) > 10 )
{
for ( j = *(_DWORD *)(4LL * i + a1); j > 9; j /= 10 )
;
if ( j % 2 == 1 && *(_DWORD *)(4LL * i + a1) % 10 % 2 == 1 )
++v3;
}
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010126b
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,0xa
JLE 0x00101267
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
SAR EAX,0x2
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
MOV dword ptr [RBP + -0x8],EAX
MOV ECX,dword ptr [RBP + -0x8]
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x8],EDX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101225
LAB_00101207:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
LAB_00101225:
CMP dword ptr [RBP + -0xc],0x9
JG 0x00101207
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0x4]
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 0x00101267
MOV EDX,dword ptr [RBP + -0x8]
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 0x00101267
ADD dword ptr [RBP + -0x14],0x1
LAB_00101267:
ADD dword ptr [RBP + -0x10],0x1
LAB_0010126b:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010118b
MOV EAX,dword ptr [RBP + -0x14]
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int4 local_1c;
int4 local_18;
int4 local_14;
local_1c = 0;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
if (10 < *(int *)(param_1 + (long)local_18 * 4)) {
for (local_14 = *(int *)(param_1 + (long)local_18 * 4); 9 < local_14; local_14 = local_14 / 10
) {
}
if ((local_14 % 2 == 1) && ((*(int *)(param_1 + (long)local_18 * 4) % 10) % 2 == 1)) {
local_1c = local_1c + 1;
}
}
}
return local_1c;
}
|
1,241 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first % 2 == 1 && last % 2 == 1) {
num += 1;
}
}
}
return num;
}
|
#include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 2);
}
{
int nums[] = {43, -12, 93, 125, 121, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 4);
}
{
int nums[] = {71, -2, -33, 75, 21, 19};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 3);
}
{
int nums[] = {1};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11fc <func0+0x93>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%r9d
jmp 1191 <func0+0x28>
add $0x4,%r8
cmp %rdi,%r8
je 1202 <func0+0x99>
mov (%r8),%esi
cmp $0xa,%esi
jle 1188 <func0+0x1f>
mov %esi,%eax
mov %eax,%ecx
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
cmp $0x63,%ecx
jg 119b <func0+0x32>
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 1188 <func0+0x1f>
movslq %esi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %esi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%esi
mov %esi,%eax
shr $0x1f,%eax
add %eax,%esi
and $0x1,%esi
sub %eax,%esi
cmp $0x1,%esi
sete %al
movzbl %al,%eax
add %eax,%r9d
jmp 1188 <func0+0x1f>
mov $0x0,%r9d
mov %r9d,%eax
retq
|
func0:
endbr64
test esi, esi
jle loc_11FB
mov r8, rdi
movsxd rsi, esi
lea rdi, [rdi+rsi*4]
mov r9d, 0
jmp short loc_1190
loc_1187:
add r8, 4
cmp r8, rdi
jz short loc_1201
loc_1190:
mov esi, [r8]
cmp esi, 0Ah
jle short loc_1187
mov edx, esi
loc_119A:
mov ecx, edx
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
sar edx, 1Fh
sub eax, edx
mov edx, eax
cmp ecx, 63h ; 'c'
jg short loc_119A
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
cmp eax, 1
jnz short loc_1187
movsxd rax, esi
imul rax, 66666667h
sar rax, 22h
mov edx, esi
sar edx, 1Fh
sub eax, edx
lea eax, [rax+rax*4]
add eax, eax
sub esi, eax
mov eax, esi
shr eax, 1Fh
add esi, eax
and esi, 1
sub esi, eax
cmp esi, 1
setz al
movzx eax, al
add r9d, eax
jmp short loc_1187
loc_11FB:
mov r9d, 0
loc_1201:
mov eax, r9d
retn
|
long long func0(int *a1, int a2)
{
int *v2; // r8
int *v3; // rdi
unsigned int v4; // r9d
int v5; // edx
int v6; // ecx
int v7; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
if ( *v2 > 10 )
{
v5 = *v2;
do
{
v6 = v5;
v7 = v5 / 10;
v5 /= 10;
}
while ( v6 > 99 );
if ( (((v5 < 0) + (_BYTE)v7) & 1) - ((unsigned int)v5 >> 31) == 1 )
v4 += *v2 % 10 % 2 == 1;
}
++v2;
}
while ( v2 != v3 );
}
return v4;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011fb
MOV R8,RDI
MOVSXD RSI,ESI
LEA RDI,[RDI + RSI*0x4]
MOV R9D,0x0
JMP 0x00101190
LAB_00101187:
ADD R8,0x4
CMP R8,RDI
JZ 0x00101201
LAB_00101190:
MOV ESI,dword ptr [R8]
CMP ESI,0xa
JLE 0x00101187
MOV EDX,ESI
LAB_0010119a:
MOV ECX,EDX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
SAR EDX,0x1f
SUB EAX,EDX
MOV EDX,EAX
CMP ECX,0x63
JG 0x0010119a
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
JNZ 0x00101187
MOVSXD RAX,ESI
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,ESI
SAR EDX,0x1f
SUB EAX,EDX
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
SUB ESI,EAX
MOV EAX,ESI
SHR EAX,0x1f
ADD ESI,EAX
AND ESI,0x1
SUB ESI,EAX
CMP ESI,0x1
SETZ AL
MOVZX EAX,AL
ADD R9D,EAX
JMP 0x00101187
LAB_001011fb:
MOV R9D,0x0
LAB_00101201:
MOV EAX,R9D
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
iVar6 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar6 = 0;
do {
iVar2 = *param_1;
iVar5 = iVar2;
if (10 < iVar2) {
do {
iVar4 = iVar5 / 10;
bVar3 = 99 < iVar5;
iVar5 = iVar4;
} while (bVar3);
if (iVar4 % 2 == 1) {
iVar6 = iVar6 + (uint)((iVar2 % 10) % 2 == 1);
}
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar6;
}
|
1,242 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first % 2 == 1 && last % 2 == 1) {
num += 1;
}
}
}
return num;
}
|
#include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 2);
}
{
int nums[] = {43, -12, 93, 125, 121, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 4);
}
{
int nums[] = {71, -2, -33, 75, 21, 19};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 3);
}
{
int nums[] = {1};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1445 <func0+0x65>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r8
jmp 1409 <func0+0x29>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %r8,%rdi
je 1441 <func0+0x61>
mov (%rdi),%ecx
cmp $0xa,%ecx
jle 1400 <func0+0x20>
mov %ecx,%eax
nopw 0x0(%rax,%rax,1)
mov %eax,%eax
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp $0x63,%edx
jg 1418 <func0+0x38>
test $0x1,%al
je 1400 <func0+0x20>
and $0x1,%ecx
cmp $0x1,%ecx
sbb $0xffffffff,%r9d
add $0x4,%rdi
cmp %r8,%rdi
jne 1409 <func0+0x29>
mov %r9d,%eax
retq
xor %r9d,%r9d
mov %r9d,%eax
retq
nopl 0x0(%rax)
|
func0:
endbr64
test esi, esi
jle short loc_13E5
movsxd rsi, esi
xor r9d, r9d
lea r8, [rdi+rsi*4]
mov esi, 0CCCCCCCDh
jmp short loc_13A9
loc_13A0:
add rdi, 4
cmp rdi, r8
jz short loc_13E1
loc_13A9:
mov ecx, [rdi]
cmp ecx, 0Ah
jle short loc_13A0
mov eax, ecx
nop word ptr [rax+rax+00h]
loc_13B8:
mov eax, eax
mov rdx, rax
imul rax, rsi
shr rax, 23h
cmp edx, 63h ; 'c'
jg short loc_13B8
test al, 1
jz short loc_13A0
and ecx, 1
cmp ecx, 1
sbb r9d, 0FFFFFFFFh
add rdi, 4
cmp rdi, r8
jnz short loc_13A9
loc_13E1:
mov eax, r9d
retn
loc_13E5:
xor r9d, r9d
mov eax, r9d
retn
|
long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r9d
unsigned int *v3; // r8
unsigned int v4; // eax
int v5; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
if ( (int)*a1 > 10 )
{
v4 = *a1;
do
{
v5 = v4;
v4 /= 0xAu;
}
while ( v5 > 99 );
if ( (v4 & 1) != 0 )
break;
}
if ( ++a1 == v3 )
return v2;
}
v2 -= ((*a1++ & 1) == 0) - 1;
}
while ( a1 != v3 );
return v2;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013e5
MOVSXD RSI,ESI
XOR R9D,R9D
LEA R8,[RDI + RSI*0x4]
MOV ESI,0xcccccccd
JMP 0x001013a9
LAB_001013a0:
ADD RDI,0x4
CMP RDI,R8
JZ 0x001013e1
LAB_001013a9:
MOV ECX,dword ptr [RDI]
CMP ECX,0xa
JLE 0x001013a0
MOV EAX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV EAX,EAX
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x63
JG 0x001013b8
TEST AL,0x1
JZ 0x001013a0
AND ECX,0x1
CMP ECX,0x1
SBB R9D,-0x1
ADD RDI,0x4
CMP RDI,R8
JNZ 0x001013a9
LAB_001013e1:
MOV EAX,R9D
RET
LAB_001013e5:
XOR R9D,R9D
MOV EAX,R9D
RET
|
int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int iVar6;
if (0 < param_2) {
iVar6 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (10 < (int)uVar2) {
uVar3 = (ulong)uVar2;
do {
uVar4 = uVar3 / 10;
iVar5 = (int)uVar3;
uVar3 = uVar4;
} while (99 < iVar5);
if ((uVar4 & 1) != 0) {
iVar6 = (iVar6 + 1) - (uint)((uVar2 & 1) == 0);
}
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return iVar6;
}
return 0;
}
|
1,243 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int nums[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > 10) {
int first, last;
last = nums[i] % 10;
int n = nums[i];
while (n >= 10) {
n /= 10;
}
first = n;
if (first % 2 == 1 && last % 2 == 1) {
num += 1;
}
}
}
return num;
}
|
#include <assert.h>
int main() {
{
int nums[] = {5, -2, 1, -5};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {15, -73, 14, -15};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 1);
}
{
int nums[] = {33, -2, -3, 45, 21, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 2);
}
{
int nums[] = {43, -12, 93, 125, 121, 109};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 4);
}
{
int nums[] = {71, -2, -33, 75, 21, 19};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 3);
}
{
int nums[] = {1};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
{
int nums[] = {};
assert(func0(nums, sizeof(nums) / sizeof(nums[0])) == 0);
}
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 13e5 <func0+0x65>
lea -0x1(%rsi),%eax
xor %r9d,%r9d
mov $0xcccccccd,%esi
lea 0x4(%rdi,%rax,4),%r8
jmp 13a9 <func0+0x29>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %r8,%rdi
je 13e1 <func0+0x61>
mov (%rdi),%ecx
cmp $0xa,%ecx
jle 13a0 <func0+0x20>
mov %ecx,%eax
nopw 0x0(%rax,%rax,1)
mov %eax,%eax
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp $0x63,%edx
jg 13b8 <func0+0x38>
test $0x1,%al
je 13a0 <func0+0x20>
and $0x1,%ecx
cmp $0x1,%ecx
sbb $0xffffffff,%r9d
add $0x4,%rdi
cmp %r8,%rdi
jne 13a9 <func0+0x29>
mov %r9d,%eax
retq
xor %r9d,%r9d
mov %r9d,%eax
retq
nopl 0x0(%rax)
|
func0:
endbr64
test esi, esi
jle short loc_13E5
movsxd rsi, esi
xor r9d, r9d
lea r8, [rdi+rsi*4]
mov esi, 0CCCCCCCDh
jmp short loc_13A9
loc_13A0:
add rdi, 4
cmp rdi, r8
jz short loc_13E1
loc_13A9:
mov ecx, [rdi]
cmp ecx, 0Ah
jle short loc_13A0
mov eax, ecx
nop word ptr [rax+rax+00h]
loc_13B8:
mov eax, eax
mov rdx, rax
imul rax, rsi
shr rax, 23h
cmp edx, 63h ; 'c'
jg short loc_13B8
test al, 1
jz short loc_13A0
and ecx, 1
cmp ecx, 1
sbb r9d, 0FFFFFFFFh
add rdi, 4
cmp rdi, r8
jnz short loc_13A9
loc_13E1:
mov eax, r9d
retn
loc_13E5:
xor r9d, r9d
mov eax, r9d
retn
|
long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // r9d
unsigned int *v3; // r8
unsigned int v4; // eax
int v5; // edx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
while ( 1 )
{
if ( (int)*a1 > 10 )
{
v4 = *a1;
do
{
v5 = v4;
v4 /= 0xAu;
}
while ( v5 > 99 );
if ( (v4 & 1) != 0 )
break;
}
if ( ++a1 == v3 )
return v2;
}
v2 -= ((*a1++ & 1) == 0) - 1;
}
while ( a1 != v3 );
return v2;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013e5
MOVSXD RSI,ESI
XOR R9D,R9D
LEA R8,[RDI + RSI*0x4]
MOV ESI,0xcccccccd
JMP 0x001013a9
LAB_001013a0:
ADD RDI,0x4
CMP RDI,R8
JZ 0x001013e1
LAB_001013a9:
MOV ECX,dword ptr [RDI]
CMP ECX,0xa
JLE 0x001013a0
MOV EAX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV EAX,EAX
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x63
JG 0x001013b8
TEST AL,0x1
JZ 0x001013a0
AND ECX,0x1
CMP ECX,0x1
SBB R9D,-0x1
ADD RDI,0x4
CMP RDI,R8
JNZ 0x001013a9
LAB_001013e1:
MOV EAX,R9D
RET
LAB_001013e5:
XOR R9D,R9D
MOV EAX,R9D
RET
|
int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int iVar6;
if (0 < param_2) {
iVar6 = 0;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if (10 < (int)uVar2) {
uVar3 = (ulong)uVar2;
do {
uVar4 = uVar3 / 10;
iVar5 = (int)uVar3;
uVar3 = uVar4;
} while (99 < iVar5);
if ((uVar4 & 1) != 0) {
iVar6 = (iVar6 + 1) - (uint)((uVar2 & 1) == 0);
}
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
return iVar6;
}
return 0;
}
|
1,244 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
sum[0][0] = sum[0][1] = sum[0][2] = 0;
sum2[0][0] = sum2[0][1] = sum2[0][2] = 0;
for (int i = 1; i <= n; i++) {
a[i - 1] = (i * i - i + 1) % 3;
for (int j = 0; j < 3; j++) {
sum[i][j] = sum[i - 1][j];
}
sum[i][a[i - 1]] += 1;
}
for (int times = 1; times < 3; times++) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum2[i][j] = sum2[i - 1][j];
}
if (i >= 1) {
for (int j = 0; j <= 2; j++) {
sum2[i][(a[i - 1] + j) % 3] += sum[i - 1][j];
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum[i][j] = sum2[i][j];
sum2[i][j] = 0;
}
}
}
int result = sum[n][0];
for (int i = 0; i <= n; ++i) {
free(sum[i]);
free(sum2[i]);
}
free(sum);
free(sum2);
free(a);
return result;
}
|
#include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %edi,-0x64(%rbp)
mov -0x64(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x28(%rbp)
mov -0x64(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x64(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x54(%rbp)
jmp 1259 <func0+0xb0>
mov -0x54(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov $0x4,%esi
mov $0x3,%edi
callq 10a0 <calloc@plt>
mov %rax,(%rbx)
mov -0x54(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov $0x4,%esi
mov $0x3,%edi
callq 10a0 <calloc@plt>
mov %rax,(%rbx)
addl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 1207 <func0+0x5e>
mov -0x20(%rbp),%rax
mov (%rax),%rax
lea 0x8(%rax),%rdx
movl $0x0,(%rdx)
mov -0x20(%rbp),%rax
mov (%rax),%rax
add $0x4,%rax
mov (%rdx),%edx
mov %edx,(%rax)
mov -0x20(%rbp),%rdx
mov (%rdx),%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x18(%rbp),%rax
mov (%rax),%rax
lea 0x8(%rax),%rdx
movl $0x0,(%rdx)
mov -0x18(%rbp),%rax
mov (%rax),%rax
add $0x4,%rax
mov (%rdx),%edx
mov %edx,(%rax)
mov -0x18(%rbp),%rdx
mov (%rdx),%rdx
mov (%rax),%eax
mov %eax,(%rdx)
movl $0x1,-0x50(%rbp)
jmpq 13e7 <func0+0x23e>
mov -0x50(%rbp),%eax
imul %eax,%eax
sub -0x50(%rbp),%eax
lea 0x1(%rax),%ecx
mov -0x50(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rsi
movslq %ecx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %rax,%rdx
mov %ecx,%eax
sar $0x1f,%eax
mov %edx,%ebx
sub %eax,%ebx
mov %ebx,%eax
mov %eax,%edx
add %edx,%edx
add %eax,%edx
mov %ecx,%eax
sub %edx,%eax
mov %eax,(%rsi)
movl $0x0,-0x4c(%rbp)
jmp 1366 <func0+0x1bd>
mov -0x50(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x4c(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x4c(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x4c(%rbp)
cmpl $0x2,-0x4c(%rbp)
jle 1315 <func0+0x16c>
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x50(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea -0x4(%rdx),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x50(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov -0x50(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
lea -0x4(%rcx),%rsi
mov -0x28(%rbp),%rcx
add %rsi,%rcx
mov (%rcx),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rax
add $0x1,%edx
mov %edx,(%rax)
addl $0x1,-0x50(%rbp)
mov -0x50(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 12c3 <func0+0x11a>
movl $0x1,-0x48(%rbp)
jmpq 15fe <func0+0x455>
movl $0x1,-0x44(%rbp)
jmpq 1544 <func0+0x39b>
movl $0x0,-0x40(%rbp)
jmp 1465 <func0+0x2bc>
mov -0x44(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x40(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0x44(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x40(%rbp)
cmpl $0x2,-0x40(%rbp)
jle 1414 <func0+0x26b>
cmpl $0x0,-0x44(%rbp)
jle 1540 <func0+0x397>
movl $0x0,-0x3c(%rbp)
jmpq 1536 <func0+0x38d>
mov -0x44(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rsi
mov -0x44(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x3c(%rbp),%eax
lea (%rdx,%rax,1),%ecx
movslq %ecx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %rax,%rdx
mov %ecx,%eax
sar $0x1f,%eax
mov %edx,%ebx
sub %eax,%ebx
mov %ebx,%eax
mov %eax,%edx
add %edx,%edx
add %eax,%edx
mov %ecx,%eax
sub %edx,%eax
movslq %eax,%rdx
shl $0x2,%rdx
add %rsi,%rdx
mov (%rdx),%ecx
mov -0x44(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
lea -0x8(%rdx),%rsi
mov -0x20(%rbp),%rdx
add %rsi,%rdx
mov (%rdx),%rdx
mov -0x3c(%rbp),%esi
movslq %esi,%rsi
shl $0x2,%rsi
add %rsi,%rdx
mov (%rdx),%edx
mov -0x44(%rbp),%esi
movslq %esi,%rsi
lea 0x0(,%rsi,8),%rdi
mov -0x18(%rbp),%rsi
add %rdi,%rsi
mov (%rsi),%rsi
cltq
shl $0x2,%rax
add %rsi,%rax
add %ecx,%edx
mov %edx,(%rax)
addl $0x1,-0x3c(%rbp)
cmpl $0x2,-0x3c(%rbp)
jle 1481 <func0+0x2d8>
addl $0x1,-0x44(%rbp)
mov -0x44(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 140b <func0+0x262>
movl $0x0,-0x38(%rbp)
jmpq 15ee <func0+0x445>
movl $0x0,-0x34(%rbp)
jmp 15e0 <func0+0x437>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
movl $0x0,(%rax)
addl $0x1,-0x34(%rbp)
cmpl $0x2,-0x34(%rbp)
jle 1565 <func0+0x3bc>
addl $0x1,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 155c <func0+0x3b3>
addl $0x1,-0x48(%rbp)
cmpl $0x2,-0x48(%rbp)
jle 13ff <func0+0x256>
mov -0x64(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov (%rax),%eax
mov %eax,-0x2c(%rbp)
movl $0x0,-0x30(%rbp)
jmp 166f <func0+0x4c6>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1080 <free@plt>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 162d <func0+0x484>
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x2c(%rbp),%eax
add $0x68,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_64], edi
mov eax, [rbp+var_64]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_28], rax
mov eax, [rbp+var_64]
add eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov eax, [rbp+var_64]
add eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_54], 0
jmp short loc_1259
loc_1207:
mov eax, [rbp+var_54]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
lea rbx, [rdx+rax]
mov esi, 4; size
mov edi, 3; nmemb
call _calloc
mov [rbx], rax
mov eax, [rbp+var_54]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rbx, [rdx+rax]
mov esi, 4; size
mov edi, 3; nmemb
call _calloc
mov [rbx], rax
add [rbp+var_54], 1
loc_1259:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_64]
jle short loc_1207
mov rax, [rbp+ptr]
mov rax, [rax]
lea rdx, [rax+8]
mov dword ptr [rdx], 0
mov rax, [rbp+ptr]
mov rax, [rax]
add rax, 4
mov edx, [rdx]
mov [rax], edx
mov rdx, [rbp+ptr]
mov rdx, [rdx]
mov eax, [rax]
mov [rdx], eax
mov rax, [rbp+var_18]
mov rax, [rax]
lea rdx, [rax+8]
mov dword ptr [rdx], 0
mov rax, [rbp+var_18]
mov rax, [rax]
add rax, 4
mov edx, [rdx]
mov [rax], edx
mov rdx, [rbp+var_18]
mov rdx, [rdx]
mov eax, [rax]
mov [rdx], eax
mov [rbp+var_50], 1
jmp loc_13E3
loc_12C3:
mov eax, [rbp+var_50]
imul eax, eax
sub eax, [rbp+var_50]
lea ecx, [rax+1]
mov eax, [rbp+var_50]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_28]
lea rsi, [rdx+rax]
movsxd rax, ecx
imul rax, 55555556h
shr rax, 20h
mov rdx, rax
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
add eax, eax
add eax, edx
sub ecx, eax
mov edx, ecx
mov [rsi], edx
mov [rbp+var_4C], 0
jmp short loc_1362
loc_1311:
mov eax, [rbp+var_50]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_4C]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_50]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+ptr]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_4C]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_4C], 1
loc_1362:
cmp [rbp+var_4C], 2
jle short loc_1311
mov eax, [rbp+var_50]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_50]
movsxd rdx, edx
shl rdx, 2
lea rcx, [rdx-4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov edx, [rdx]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_50]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rcx
mov rax, [rax]
mov ecx, [rbp+var_50]
movsxd rcx, ecx
shl rcx, 2
lea rsi, [rcx-4]
mov rcx, [rbp+var_28]
add rcx, rsi
mov ecx, [rcx]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
add edx, 1
mov [rax], edx
add [rbp+var_50], 1
loc_13E3:
mov eax, [rbp+var_50]
cmp eax, [rbp+var_64]
jle loc_12C3
mov [rbp+var_48], 1
jmp loc_15F3
loc_13FB:
mov [rbp+var_44], 1
jmp loc_1539
loc_1407:
mov [rbp+var_40], 0
jmp short loc_1461
loc_1410:
mov eax, [rbp+var_44]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_40]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_44]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_40]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_40], 1
loc_1461:
cmp [rbp+var_40], 2
jle short loc_1410
cmp [rbp+var_44], 0
jle loc_1535
mov [rbp+var_3C], 0
jmp loc_152B
loc_147D:
mov eax, [rbp+var_44]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rsi, [rax]
mov eax, [rbp+var_44]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_3C]
lea ecx, [rdx+rax]
movsxd rax, ecx
imul rax, 55555556h
shr rax, 20h
mov edx, ecx
sar edx, 1Fh
sub eax, edx
mov edx, eax
add edx, edx
add edx, eax
mov eax, ecx
sub eax, edx
movsxd rdx, eax
shl rdx, 2
add rdx, rsi
mov ecx, [rdx]
mov edx, [rbp+var_44]
movsxd rdx, edx
shl rdx, 3
lea rsi, [rdx-8]
mov rdx, [rbp+ptr]
add rdx, rsi
mov rdx, [rdx]
mov esi, [rbp+var_3C]
movsxd rsi, esi
shl rsi, 2
add rdx, rsi
mov edx, [rdx]
mov esi, [rbp+var_44]
movsxd rsi, esi
lea rdi, ds:0[rsi*8]
mov rsi, [rbp+var_18]
add rsi, rdi
mov rsi, [rsi]
cdqe
shl rax, 2
add rax, rsi
add edx, ecx
mov [rax], edx
add [rbp+var_3C], 1
loc_152B:
cmp [rbp+var_3C], 2
jle loc_147D
loc_1535:
add [rbp+var_44], 1
loc_1539:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_64]
jle loc_1407
mov [rbp+var_38], 0
jmp loc_15E3
loc_1551:
mov [rbp+var_34], 0
jmp short loc_15D5
loc_155A:
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_34]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_38]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+ptr]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_34]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_34]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov dword ptr [rax], 0
add [rbp+var_34], 1
loc_15D5:
cmp [rbp+var_34], 2
jle loc_155A
add [rbp+var_38], 1
loc_15E3:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_64]
jle loc_1551
add [rbp+var_48], 1
loc_15F3:
cmp [rbp+var_48], 2
jle loc_13FB
mov eax, [rbp+var_64]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_2C], eax
mov [rbp+var_30], 0
jmp short loc_1664
loc_1622:
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov rdi, rax; ptr
call _free
add [rbp+var_30], 1
loc_1664:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_64]
jle short loc_1622
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_18]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_28]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_2C]
mov rbx, [rbp+var_8]
leave
retn
|
long long func0(int a1)
{
_DWORD *v1; // rdx
_DWORD *v2; // rax
_DWORD *v3; // rdx
_DWORD *v4; // rax
int v5; // eax
int i; // [rsp+1Ch] [rbp-54h]
int j; // [rsp+20h] [rbp-50h]
int k; // [rsp+24h] [rbp-4Ch]
int m; // [rsp+28h] [rbp-48h]
int n; // [rsp+2Ch] [rbp-44h]
int ii; // [rsp+30h] [rbp-40h]
int jj; // [rsp+34h] [rbp-3Ch]
int kk; // [rsp+38h] [rbp-38h]
int mm; // [rsp+3Ch] [rbp-34h]
int nn; // [rsp+40h] [rbp-30h]
unsigned int v17; // [rsp+44h] [rbp-2Ch]
int *v18; // [rsp+48h] [rbp-28h]
_QWORD *ptr; // [rsp+50h] [rbp-20h]
_QWORD *v20; // [rsp+58h] [rbp-18h]
v18 = (int *)malloc(4LL * a1);
ptr = malloc(8LL * (a1 + 1));
v20 = malloc(8LL * (a1 + 1));
for ( i = 0; i <= a1; ++i )
{
ptr[i] = calloc(3uLL, 4uLL);
v20[i] = calloc(3uLL, 4uLL);
}
v1 = (_DWORD *)(*ptr + 8LL);
*v1 = 0;
v2 = (_DWORD *)(*ptr + 4LL);
*v2 = *v1;
*(_DWORD *)*ptr = *v2;
v3 = (_DWORD *)(*v20 + 8LL);
*v3 = 0;
v4 = (_DWORD *)(*v20 + 4LL);
*v4 = *v3;
*(_DWORD *)*v20 = *v4;
for ( j = 1; j <= a1; ++j )
{
v18[j - 1] = (j * j - j + 1) % 3;
for ( k = 0; k <= 2; ++k )
*(_DWORD *)(4LL * k + ptr[j]) = *(_DWORD *)(4LL * k + ptr[j - 1]);
++*(_DWORD *)(4LL * v18[j - 1] + ptr[j]);
}
for ( m = 1; m <= 2; ++m )
{
for ( n = 1; n <= a1; ++n )
{
for ( ii = 0; ii <= 2; ++ii )
*(_DWORD *)(4LL * ii + v20[n]) = *(_DWORD *)(4LL * ii + v20[n - 1]);
if ( n > 0 )
{
for ( jj = 0; jj <= 2; ++jj )
{
v5 = (v18[n - 1] + jj) % 3;
*(_DWORD *)(v20[n] + 4LL * v5) += *(_DWORD *)(4LL * jj + ptr[n - 1]);
}
}
}
for ( kk = 0; kk <= a1; ++kk )
{
for ( mm = 0; mm <= 2; ++mm )
{
*(_DWORD *)(4LL * mm + ptr[kk]) = *(_DWORD *)(4LL * mm + v20[kk]);
*(_DWORD *)(4LL * mm + v20[kk]) = 0;
}
}
}
v17 = *(_DWORD *)ptr[a1];
for ( nn = 0; nn <= a1; ++nn )
{
free((void *)ptr[nn]);
free((void *)v20[nn]);
}
free(ptr);
free(v20);
free(v18);
return v17;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RBP + -0x64],EDI
MOV EAX,dword ptr [RBP + -0x64]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x64]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x64]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x54],0x0
JMP 0x00101259
LAB_00101207:
MOV EAX,dword ptr [RBP + -0x54]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
LEA RBX,[RDX + RAX*0x1]
MOV ESI,0x4
MOV EDI,0x3
CALL 0x001010a0
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x54]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RBX,[RDX + RAX*0x1]
MOV ESI,0x4
MOV EDI,0x3
CALL 0x001010a0
MOV qword ptr [RBX],RAX
ADD dword ptr [RBP + -0x54],0x1
LAB_00101259:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x64]
JLE 0x00101207
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
LEA RDX,[RAX + 0x8]
MOV dword ptr [RDX],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
ADD RAX,0x4
MOV EDX,dword ptr [RDX]
MOV dword ptr [RAX],EDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RDX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
LEA RDX,[RAX + 0x8]
MOV dword ptr [RDX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
ADD RAX,0x4
MOV EDX,dword ptr [RDX]
MOV dword ptr [RAX],EDX
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV dword ptr [RBP + -0x50],0x1
JMP 0x001013e3
LAB_001012c3:
MOV EAX,dword ptr [RBP + -0x50]
IMUL EAX,EAX
SUB EAX,dword ptr [RBP + -0x50]
LEA ECX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x50]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RSI,[RDX + RAX*0x1]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV RDX,RAX
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
SUB ECX,EAX
MOV EDX,ECX
MOV dword ptr [RSI],EDX
MOV dword ptr [RBP + -0x4c],0x0
JMP 0x00101362
LAB_00101311:
MOV EAX,dword ptr [RBP + -0x50]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4c]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x50]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x4c]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4c],0x1
LAB_00101362:
CMP dword ptr [RBP + -0x4c],0x2
JLE 0x00101311
MOV EAX,dword ptr [RBP + -0x50]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x50]
MOVSXD RDX,EDX
SHL RDX,0x2
LEA RCX,[RDX + -0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EDX,dword ptr [RDX]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x50]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x50]
MOVSXD RCX,ECX
SHL RCX,0x2
LEA RSI,[RCX + -0x4]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,RSI
MOV ECX,dword ptr [RCX]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
ADD EDX,0x1
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x50],0x1
LAB_001013e3:
MOV EAX,dword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x64]
JLE 0x001012c3
MOV dword ptr [RBP + -0x48],0x1
JMP 0x001015f3
LAB_001013fb:
MOV dword ptr [RBP + -0x44],0x1
JMP 0x00101539
LAB_00101407:
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101461
LAB_00101410:
MOV EAX,dword ptr [RBP + -0x44]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x40]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x40],0x1
LAB_00101461:
CMP dword ptr [RBP + -0x40],0x2
JLE 0x00101410
CMP dword ptr [RBP + -0x44],0x0
JLE 0x00101535
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x0010152b
LAB_0010147d:
MOV EAX,dword ptr [RBP + -0x44]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x44]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x3c]
LEA ECX,[RDX + RAX*0x1]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV EDX,ECX
SAR EDX,0x1f
SUB EAX,EDX
MOV EDX,EAX
ADD EDX,EDX
ADD EDX,EAX
MOV EAX,ECX
SUB EAX,EDX
MOVSXD RDX,EAX
SHL RDX,0x2
ADD RDX,RSI
MOV ECX,dword ptr [RDX]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
SHL RDX,0x3
LEA RSI,[RDX + -0x8]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RSI
MOV RDX,qword ptr [RDX]
MOV ESI,dword ptr [RBP + -0x3c]
MOVSXD RSI,ESI
SHL RSI,0x2
ADD RDX,RSI
MOV EDX,dword ptr [RDX]
MOV ESI,dword ptr [RBP + -0x44]
MOVSXD RSI,ESI
LEA RDI,[RSI*0x8]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,RDI
MOV RSI,qword ptr [RSI]
CDQE
SHL RAX,0x2
ADD RAX,RSI
ADD EDX,ECX
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x3c],0x1
LAB_0010152b:
CMP dword ptr [RBP + -0x3c],0x2
JLE 0x0010147d
LAB_00101535:
ADD dword ptr [RBP + -0x44],0x1
LAB_00101539:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x64]
JLE 0x00101407
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001015e3
LAB_00101551:
MOV dword ptr [RBP + -0x34],0x0
JMP 0x001015d5
LAB_0010155a:
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x34]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV dword ptr [RAX],0x0
ADD dword ptr [RBP + -0x34],0x1
LAB_001015d5:
CMP dword ptr [RBP + -0x34],0x2
JLE 0x0010155a
ADD dword ptr [RBP + -0x38],0x1
LAB_001015e3:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x64]
JLE 0x00101551
ADD dword ptr [RBP + -0x48],0x1
LAB_001015f3:
CMP dword ptr [RBP + -0x48],0x2
JLE 0x001013fb
MOV EAX,dword ptr [RBP + -0x64]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00101664
LAB_00101622:
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101080
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101080
ADD dword ptr [RBP + -0x30],0x1
LAB_00101664:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x64]
JLE 0x00101622
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101080
MOV EAX,dword ptr [RBP + -0x2c]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int4 func0(int param_1)
{
int4 uVar1;
long lVar2;
long lVar3;
int iVar4;
void *__ptr;
long *__ptr_00;
long *__ptr_01;
void *pvVar5;
int local_5c;
int local_58;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
__ptr = malloc((long)param_1 << 2);
__ptr_00 = (long *)malloc((long)(param_1 + 1) << 3);
__ptr_01 = (long *)malloc((long)(param_1 + 1) << 3);
for (local_5c = 0; local_5c <= param_1; local_5c = local_5c + 1) {
pvVar5 = calloc(3,4);
__ptr_00[local_5c] = (long)pvVar5;
pvVar5 = calloc(3,4);
__ptr_01[local_5c] = (long)pvVar5;
}
lVar2 = *__ptr_00;
*(int4 *)(lVar2 + 8) = 0;
lVar3 = *__ptr_00;
*(int4 *)(lVar3 + 4) = *(int4 *)(lVar2 + 8);
*(int4 *)*__ptr_00 = *(int4 *)(lVar3 + 4);
lVar2 = *__ptr_01;
*(int4 *)(lVar2 + 8) = 0;
lVar3 = *__ptr_01;
*(int4 *)(lVar3 + 4) = *(int4 *)(lVar2 + 8);
*(int4 *)*__ptr_01 = *(int4 *)(lVar3 + 4);
for (local_58 = 1; local_58 <= param_1; local_58 = local_58 + 1) {
*(int *)((long)local_58 * 4 + -4 + (long)__ptr) = ((local_58 * local_58 - local_58) + 1) % 3;
for (local_54 = 0; local_54 < 3; local_54 = local_54 + 1) {
*(int4 *)(__ptr_00[local_58] + (long)local_54 * 4) =
*(int4 *)(__ptr_00[(long)local_58 + -1] + (long)local_54 * 4);
}
*(int *)(__ptr_00[local_58] + (long)*(int *)((long)__ptr + (long)local_58 * 4 + -4) * 4) =
*(int *)(__ptr_00[local_58] + (long)*(int *)((long)__ptr + (long)local_58 * 4 + -4) * 4) +
1;
}
for (local_50 = 1; local_50 < 3; local_50 = local_50 + 1) {
for (local_4c = 1; local_4c <= param_1; local_4c = local_4c + 1) {
for (local_48 = 0; local_48 < 3; local_48 = local_48 + 1) {
*(int4 *)(__ptr_01[local_4c] + (long)local_48 * 4) =
*(int4 *)(__ptr_01[(long)local_4c + -1] + (long)local_48 * 4);
}
if (0 < local_4c) {
for (local_44 = 0; local_44 < 3; local_44 = local_44 + 1) {
iVar4 = (*(int *)((long)__ptr + (long)local_4c * 4 + -4) + local_44) % 3;
*(int *)((long)iVar4 * 4 + __ptr_01[local_4c]) =
*(int *)(__ptr_00[(long)local_4c + -1] + (long)local_44 * 4) +
*(int *)((long)iVar4 * 4 + __ptr_01[local_4c]);
}
}
}
for (local_40 = 0; local_40 <= param_1; local_40 = local_40 + 1) {
for (local_3c = 0; local_3c < 3; local_3c = local_3c + 1) {
*(int4 *)(__ptr_00[local_40] + (long)local_3c * 4) =
*(int4 *)(__ptr_01[local_40] + (long)local_3c * 4);
*(int4 *)(__ptr_01[local_40] + (long)local_3c * 4) = 0;
}
}
}
uVar1 = *(int4 *)__ptr_00[param_1];
for (local_38 = 0; local_38 <= param_1; local_38 = local_38 + 1) {
free((void *)__ptr_00[local_38]);
free((void *)__ptr_01[local_38]);
}
free(__ptr_00);
free(__ptr_01);
free(__ptr);
return uVar1;
}
|
1,245 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
sum[0][0] = sum[0][1] = sum[0][2] = 0;
sum2[0][0] = sum2[0][1] = sum2[0][2] = 0;
for (int i = 1; i <= n; i++) {
a[i - 1] = (i * i - i + 1) % 3;
for (int j = 0; j < 3; j++) {
sum[i][j] = sum[i - 1][j];
}
sum[i][a[i - 1]] += 1;
}
for (int times = 1; times < 3; times++) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum2[i][j] = sum2[i - 1][j];
}
if (i >= 1) {
for (int j = 0; j <= 2; j++) {
sum2[i][(a[i - 1] + j) % 3] += sum[i - 1][j];
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum[i][j] = sum2[i][j];
sum2[i][j] = 0;
}
}
}
int result = sum[n][0];
for (int i = 0; i <= n; ++i) {
free(sum[i]);
free(sum2[i]);
}
free(sum);
free(sum2);
free(a);
return result;
}
|
#include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%r13d
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
lea 0x1(%r13),%eax
cltq
lea 0x0(,%rax,8),%rbx
mov %rbx,0x8(%rsp)
mov %rbx,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbp
mov %rbx,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbx
test %r13d,%r13d
js 123c <func0+0x93>
mov %r13d,%eax
lea 0x8(,%rax,8),%r15
mov $0x0,%r12d
mov $0x4,%esi
mov $0x3,%edi
callq 10a0 <calloc@plt>
mov %rax,0x0(%rbp,%r12,1)
mov $0x4,%esi
mov $0x3,%edi
callq 10a0 <calloc@plt>
mov %rax,(%rbx,%r12,1)
add $0x8,%r12
cmp %r12,%r15
jne 120c <func0+0x63>
mov 0x0(%rbp),%rax
movl $0x0,0x8(%rax)
movl $0x0,0x4(%rax)
movl $0x0,(%rax)
mov (%rbx),%rax
movl $0x0,0x8(%rax)
movl $0x0,0x4(%rax)
movl $0x0,(%rax)
test %r13d,%r13d
jle 12d5 <func0+0x12c>
lea -0x1(%r13),%esi
add $0x2,%rsi
mov $0x1,%edx
mov %edx,%ecx
imul %edx,%ecx
sub %edx,%ecx
add $0x1,%ecx
movslq %ecx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %ecx,%edi
sar $0x1f,%edi
sub %edi,%eax
lea (%rax,%rax,2),%eax
sub %eax,%ecx
mov %ecx,%eax
mov %ecx,-0x4(%r14,%rdx,4)
mov -0x8(%rbp,%rdx,8),%rdi
mov 0x0(%rbp,%rdx,8),%rcx
mov (%rdi),%r8d
mov %r8d,(%rcx)
mov 0x4(%rdi),%r8d
mov %r8d,0x4(%rcx)
mov 0x8(%rdi),%edi
mov %edi,0x8(%rcx)
cltq
addl $0x1,(%rcx,%rax,4)
add $0x1,%rdx
cmp %rdx,%rsi
jne 127d <func0+0xd4>
mov $0x2,%r10d
lea -0x1(%r13),%r9d
add $0x2,%r9
jmpq 1399 <func0+0x1f0>
add $0x1,%rcx
cmp %rcx,%r9
je 1358 <func0+0x1af>
mov -0x8(%rbx,%rcx,8),%rax
mov (%rbx,%rcx,8),%rsi
mov (%rax),%edx
mov %edx,(%rsi)
mov 0x4(%rax),%edx
mov %edx,0x4(%rsi)
mov 0x8(%rax),%eax
mov %eax,0x8(%rsi)
test %ecx,%ecx
jle 12e8 <func0+0x13f>
mov -0x4(%r14,%rcx,4),%r8d
mov -0x8(%rbp,%rcx,8),%rdi
mov $0x0,%edx
lea (%r8,%rdx,1),%eax
movslq %eax,%r11
imul $0x55555556,%r11,%r11
shr $0x20,%r11
mov %eax,%r12d
sar $0x1f,%r12d
sub %r12d,%r11d
lea (%r11,%r11,2),%r11d
sub %r11d,%eax
cltq
mov (%rdi,%rdx,4),%r11d
add %r11d,(%rsi,%rax,4)
add $0x1,%rdx
cmp $0x3,%rdx
jne 131d <func0+0x174>
jmp 12e8 <func0+0x13f>
jne 1393 <func0+0x1ea>
mov $0x0,%edx
mov (%rbx,%rdx,8),%rax
mov 0x0(%rbp,%rdx,8),%rcx
mov (%rax),%esi
mov %esi,(%rcx)
movl $0x0,(%rax)
mov 0x4(%rax),%esi
mov %esi,0x4(%rcx)
movl $0x0,0x4(%rax)
mov 0x8(%rax),%esi
mov %esi,0x8(%rcx)
movl $0x0,0x8(%rax)
add $0x1,%rdx
cmp %edx,%r13d
jge 135d <func0+0x1b4>
sub $0x1,%r10d
je 13a8 <func0+0x1ff>
test %r13d,%r13d
jle 1356 <func0+0x1ad>
mov $0x1,%ecx
jmpq 12f1 <func0+0x148>
mov 0x8(%rsp),%rax
mov -0x8(%rbp,%rax,1),%rax
mov (%rax),%r15d
test %r13d,%r13d
js 13e7 <func0+0x23e>
mov %r13d,%r13d
lea 0x8(,%r13,8),%r13
mov $0x0,%r12d
mov 0x0(%rbp,%r12,1),%rdi
callq 1080 <free@plt>
mov (%rbx,%r12,1),%rdi
callq 1080 <free@plt>
add $0x8,%r12
cmp %r13,%r12
jne 13cb <func0+0x222>
mov %rbp,%rdi
callq 1080 <free@plt>
mov %rbx,%rdi
callq 1080 <free@plt>
mov %r14,%rdi
callq 1080 <free@plt>
mov %r15d,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13d, edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov r12, rax
lea eax, [r13+1]
cdqe
lea rbx, ds:0[rax*8]
mov [rsp+48h+var_40], rbx
mov rdi, rbx; size
call _malloc
mov rbp, rax
mov rdi, rbx; size
call _malloc
mov rbx, rax
test r13d, r13d
js loc_1406
lea r15d, [r13+1]
shl r15, 3
mov r14d, 0
loc_120D:
mov esi, 4; size
mov edi, 3; nmemb
call _calloc
mov [rbp+r14+0], rax
mov esi, 4; size
mov edi, 3; nmemb
call _calloc
mov [rbx+r14], rax
add r14, 8
cmp r14, r15
jnz short loc_120D
mov rax, [rbp+0]
mov dword ptr [rax+8], 0
mov dword ptr [rax+4], 0
mov dword ptr [rax], 0
mov rax, [rbx]
mov dword ptr [rax+8], 0
mov dword ptr [rax+4], 0
mov dword ptr [rax], 0
test r13d, r13d
jle short loc_12CF
mov esi, r13d
mov ecx, 0
loc_1279:
lea edx, [rcx+1]
imul edx, ecx
add edx, 1
movsxd rax, edx
imul rax, 55555556h
shr rax, 20h
mov edi, edx
sar edi, 1Fh
sub eax, edi
lea edi, [rax+rax*2]
mov eax, edx
sub eax, edi
mov [r12+rcx*4], eax
mov rdi, [rbp+rcx*8+0]
mov rdx, [rbp+rcx*8+8]
mov r8d, [rdi]
mov [rdx], r8d
mov r8d, [rdi+4]
mov [rdx+4], r8d
mov edi, [rdi+8]
mov [rdx+8], edi
cdqe
add dword ptr [rdx+rax*4], 1
add rcx, 1
cmp rsi, rcx
jnz short loc_1279
loc_12CF:
mov eax, r13d
lea r14, ds:8[rax*8]
mov ecx, 2
lea r8d, [r13+1]
jmp loc_139C
loc_12E8:
mov r10d, [r12+rdi*4-4]
mov r9, [rbp+rdi*8-8]
mov edx, 0
loc_12F7:
lea eax, [r10+rdx]
movsxd r11, eax
imul r11, 55555556h
shr r11, 20h
mov r15d, eax
sar r15d, 1Fh
sub r11d, r15d
lea r11d, [r11+r11*2]
sub eax, r11d
cdqe
mov r11d, [r9+rdx*4]
add [rsi+rax*4], r11d
add rdx, 1
cmp rdx, 3
jnz short loc_12F7
add rdi, 1
cmp r8, rdi
jz short loc_135C
loc_1337:
mov rax, [rbx+rdi*8-8]
mov rsi, [rbx+rdi*8]
mov edx, [rax]
mov [rsi], edx
mov edx, [rax+4]
mov [rsi+4], edx
mov eax, [rax+8]
mov [rsi+8], eax
test edi, edi
jg short loc_12E8
add rdi, 1
jmp short loc_1337
loc_135A:
js short loc_1397
loc_135C:
mov edx, 0
loc_1361:
mov rax, [rbx+rdx]
mov rsi, [rbp+rdx+0]
mov edi, [rax]
mov [rsi], edi
mov dword ptr [rax], 0
mov edi, [rax+4]
mov [rsi+4], edi
mov dword ptr [rax+4], 0
mov edi, [rax+8]
mov [rsi+8], edi
mov dword ptr [rax+8], 0
add rdx, 8
cmp rdx, r14
jnz short loc_1361
loc_1397:
sub ecx, 1
jz short loc_13A8
loc_139C:
test r13d, r13d
jle short loc_135A
mov edi, 1
jmp short loc_1337
loc_13A8:
mov rax, [rsp+48h+var_40]
mov rax, [rbp+rax-8]
mov r15d, [rax]
test r13d, r13d
js short loc_13DC
mov r13d, 0
loc_13C0:
mov rdi, [rbp+r13+0]; ptr
call _free
mov rdi, [rbx+r13]; ptr
call _free
add r13, 8
cmp r13, r14
jnz short loc_13C0
loc_13DC:
mov rdi, rbp; ptr
call _free
mov rdi, rbx; ptr
call _free
mov rdi, r12; ptr
call _free
mov eax, r15d
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1406:
mov rax, [rbp+0]
mov dword ptr [rax+8], 0
mov dword ptr [rax+4], 0
mov dword ptr [rax], 0
mov rax, [rbx]
mov dword ptr [rax+8], 0
mov dword ptr [rax+4], 0
mov dword ptr [rax], 0
jmp loc_12CF
|
long long func0(int a1)
{
_DWORD *v2; // r12
_QWORD *v3; // rbp
_QWORD *v4; // rbx
long long v5; // r14
_DWORD *v6; // rax
_DWORD *v7; // rax
long long i; // rcx
int v9; // eax
_DWORD *v10; // rdi
_DWORD *v11; // rdx
long long v12; // r14
int v13; // ecx
int v14; // r10d
long long v15; // r9
long long j; // rdx
long long v17; // rdi
_DWORD *v18; // rax
_DWORD *v19; // rsi
unsigned long long v20; // rdx
_DWORD *v21; // rax
_DWORD *v22; // rsi
unsigned int v23; // r15d
unsigned long long v24; // r13
_DWORD *v26; // rax
_DWORD *v27; // rax
size_t v28; // [rsp+8h] [rbp-40h]
v2 = malloc(4LL * a1);
v28 = 8LL * (a1 + 1);
v3 = malloc(v28);
v4 = malloc(v28);
if ( a1 < 0 )
{
v26 = (_DWORD *)*v3;
v26[2] = 0;
v26[1] = 0;
*v26 = 0;
v27 = (_DWORD *)*v4;
v27[2] = 0;
v27[1] = 0;
*v27 = 0;
}
else
{
v5 = 0LL;
do
{
v3[v5] = calloc(3uLL, 4uLL);
v4[v5++] = calloc(3uLL, 4uLL);
}
while ( v5 != a1 + 1 );
v6 = (_DWORD *)*v3;
v6[2] = 0;
v6[1] = 0;
*v6 = 0;
v7 = (_DWORD *)*v4;
v7[2] = 0;
v7[1] = 0;
*v7 = 0;
if ( a1 > 0 )
{
for ( i = 0LL; i != a1; ++i )
{
v9 = ((int)i * ((int)i + 1) + 1) % 3;
v2[i] = v9;
v10 = (_DWORD *)v3[i];
v11 = (_DWORD *)v3[i + 1];
*v11 = *v10;
v11[1] = v10[1];
v11[2] = v10[2];
++v11[v9];
}
}
}
v12 = 8LL * (unsigned int)a1 + 8;
v13 = 2;
do
{
if ( a1 <= 0 )
{
if ( a1 < 0 )
goto LABEL_16;
}
else
{
v17 = 1LL;
do
{
while ( 1 )
{
v18 = (_DWORD *)v4[v17 - 1];
v19 = (_DWORD *)v4[v17];
*v19 = *v18;
v19[1] = v18[1];
v19[2] = v18[2];
if ( (int)v17 > 0 )
break;
++v17;
}
v14 = v2[v17 - 1];
v15 = v3[v17 - 1];
for ( j = 0LL; j != 3; ++j )
v19[(v14 + (int)j) % 3] += *(_DWORD *)(v15 + 4 * j);
++v17;
}
while ( a1 + 1 != v17 );
}
v20 = 0LL;
do
{
v21 = (_DWORD *)v4[v20 / 8];
v22 = (_DWORD *)v3[v20 / 8];
*v22 = *v21;
*v21 = 0;
v22[1] = v21[1];
v21[1] = 0;
v22[2] = v21[2];
v21[2] = 0;
v20 += 8LL;
}
while ( v20 != v12 );
LABEL_16:
--v13;
}
while ( v13 );
v23 = *(_DWORD *)v3[v28 / 8 - 1];
if ( a1 >= 0 )
{
v24 = 0LL;
do
{
free((void *)v3[v24 / 8]);
free((void *)v4[v24 / 8]);
v24 += 8LL;
}
while ( v24 != v12 );
}
free(v3);
free(v4);
free(v2);
return v23;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13D,EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R12,RAX
LEA EAX,[R13 + 0x1]
CDQE
LEA RBX,[RAX*0x8]
MOV qword ptr [RSP + 0x8],RBX
MOV RDI,RBX
CALL 0x001010b0
MOV RBP,RAX
MOV RDI,RBX
CALL 0x001010b0
MOV RBX,RAX
TEST R13D,R13D
JS 0x00101406
LEA R15D,[R13 + 0x1]
SHL R15,0x3
MOV R14D,0x0
LAB_0010120d:
MOV ESI,0x4
MOV EDI,0x3
CALL 0x001010a0
MOV qword ptr [RBP + R14*0x1],RAX
MOV ESI,0x4
MOV EDI,0x3
CALL 0x001010a0
MOV qword ptr [RBX + R14*0x1],RAX
ADD R14,0x8
CMP R14,R15
JNZ 0x0010120d
MOV RAX,qword ptr [RBP]
MOV dword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0x4],0x0
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBX]
MOV dword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0x4],0x0
MOV dword ptr [RAX],0x0
TEST R13D,R13D
JLE 0x001012cf
MOV ESI,R13D
MOV ECX,0x0
LAB_00101279:
LEA EDX,[RCX + 0x1]
IMUL EDX,ECX
ADD EDX,0x1
MOVSXD RAX,EDX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV EDI,EDX
SAR EDI,0x1f
SUB EAX,EDI
LEA EDI,[RAX + RAX*0x2]
MOV EAX,EDX
SUB EAX,EDI
MOV dword ptr [R12 + RCX*0x4],EAX
MOV RDI,qword ptr [RBP + RCX*0x8]
MOV RDX,qword ptr [RBP + RCX*0x8 + 0x8]
MOV R8D,dword ptr [RDI]
MOV dword ptr [RDX],R8D
MOV R8D,dword ptr [RDI + 0x4]
MOV dword ptr [RDX + 0x4],R8D
MOV EDI,dword ptr [RDI + 0x8]
MOV dword ptr [RDX + 0x8],EDI
CDQE
ADD dword ptr [RDX + RAX*0x4],0x1
ADD RCX,0x1
CMP RSI,RCX
JNZ 0x00101279
LAB_001012cf:
MOV EAX,R13D
LEA R14,[0x8 + RAX*0x8]
MOV ECX,0x2
LEA R8D,[R13 + 0x1]
JMP 0x0010139c
LAB_001012e8:
MOV R10D,dword ptr [R12 + RDI*0x4 + -0x4]
MOV R9,qword ptr [RBP + RDI*0x8 + -0x8]
MOV EDX,0x0
LAB_001012f7:
LEA EAX,[R10 + RDX*0x1]
MOVSXD R11,EAX
IMUL R11,R11,0x55555556
SHR R11,0x20
MOV R15D,EAX
SAR R15D,0x1f
SUB R11D,R15D
LEA R11D,[R11 + R11*0x2]
SUB EAX,R11D
CDQE
MOV R11D,dword ptr [R9 + RDX*0x4]
ADD dword ptr [RSI + RAX*0x4],R11D
ADD RDX,0x1
CMP RDX,0x3
JNZ 0x001012f7
ADD RDI,0x1
CMP R8,RDI
JZ 0x0010135c
LAB_00101337:
MOV RAX,qword ptr [RBX + RDI*0x8 + -0x8]
MOV RSI,qword ptr [RBX + RDI*0x8]
MOV EDX,dword ptr [RAX]
MOV dword ptr [RSI],EDX
MOV EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RSI + 0x4],EDX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RSI + 0x8],EAX
TEST EDI,EDI
JG 0x001012e8
ADD RDI,0x1
JMP 0x00101337
LAB_0010135a:
JS 0x00101397
LAB_0010135c:
MOV EDX,0x0
LAB_00101361:
MOV RAX,qword ptr [RBX + RDX*0x1]
MOV RSI,qword ptr [RBP + RDX*0x1]
MOV EDI,dword ptr [RAX]
MOV dword ptr [RSI],EDI
MOV dword ptr [RAX],0x0
MOV EDI,dword ptr [RAX + 0x4]
MOV dword ptr [RSI + 0x4],EDI
MOV dword ptr [RAX + 0x4],0x0
MOV EDI,dword ptr [RAX + 0x8]
MOV dword ptr [RSI + 0x8],EDI
MOV dword ptr [RAX + 0x8],0x0
ADD RDX,0x8
CMP RDX,R14
JNZ 0x00101361
LAB_00101397:
SUB ECX,0x1
JZ 0x001013a8
LAB_0010139c:
TEST R13D,R13D
JLE 0x0010135a
MOV EDI,0x1
JMP 0x00101337
LAB_001013a8:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RBP + RAX*0x1 + -0x8]
MOV R15D,dword ptr [RAX]
TEST R13D,R13D
JS 0x001013dc
MOV R13D,0x0
LAB_001013c0:
MOV RDI,qword ptr [RBP + R13*0x1]
CALL 0x00101080
MOV RDI,qword ptr [RBX + R13*0x1]
CALL 0x00101080
ADD R13,0x8
CMP R13,R14
JNZ 0x001013c0
LAB_001013dc:
MOV RDI,RBP
CALL 0x00101080
MOV RDI,RBX
CALL 0x00101080
MOV RDI,R12
CALL 0x00101080
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101406:
MOV RAX,qword ptr [RBP]
MOV dword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0x4],0x0
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBX]
MOV dword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0x4],0x0
MOV dword ptr [RAX],0x0
JMP 0x001012cf
|
int4 func0(uint param_1)
{
size_t __size;
int iVar1;
int4 uVar2;
int4 *puVar3;
int4 *puVar4;
int iVar5;
void *__ptr;
int8 *__ptr_00;
int8 *__ptr_01;
void *pvVar6;
ulong uVar7;
long lVar8;
long lVar9;
long lVar10;
__ptr = malloc((long)(int)param_1 << 2);
__size = (long)(int)(param_1 + 1) * 8;
__ptr_00 = (int8 *)malloc(__size);
__ptr_01 = (int8 *)malloc(__size);
if ((int)param_1 < 0) {
puVar3 = (int4 *)*__ptr_00;
puVar3[2] = 0;
puVar3[1] = 0;
*puVar3 = 0;
puVar3 = (int4 *)*__ptr_01;
puVar3[2] = 0;
puVar3[1] = 0;
*puVar3 = 0;
}
else {
lVar10 = 0;
do {
pvVar6 = calloc(3,4);
*(void **)((long)__ptr_00 + lVar10) = pvVar6;
pvVar6 = calloc(3,4);
*(void **)((long)__ptr_01 + lVar10) = pvVar6;
lVar10 = lVar10 + 8;
} while (lVar10 != (ulong)(param_1 + 1) << 3);
puVar3 = (int4 *)*__ptr_00;
puVar3[2] = 0;
puVar3[1] = 0;
*puVar3 = 0;
puVar3 = (int4 *)*__ptr_01;
puVar3[2] = 0;
puVar3[1] = 0;
*puVar3 = 0;
if (0 < (int)param_1) {
uVar7 = 0;
do {
iVar5 = (((int)uVar7 + 1) * (int)uVar7 + 1) % 3;
*(int *)((long)__ptr + uVar7 * 4) = iVar5;
puVar3 = (int4 *)__ptr_00[uVar7];
puVar4 = (int4 *)__ptr_00[uVar7 + 1];
*puVar4 = *puVar3;
puVar4[1] = puVar3[1];
puVar4[2] = puVar3[2];
puVar4[iVar5] = puVar4[iVar5] + 1;
uVar7 = uVar7 + 1;
} while (param_1 != uVar7);
}
}
lVar10 = (ulong)param_1 * 8 + 8;
iVar5 = 2;
do {
if ((int)param_1 < 1) {
if (-1 < (int)param_1) goto LAB_0010135c;
}
else {
uVar7 = 1;
do {
while( true ) {
puVar3 = (int4 *)__ptr_01[uVar7 - 1];
puVar4 = (int4 *)__ptr_01[uVar7];
*puVar4 = *puVar3;
puVar4[1] = puVar3[1];
puVar4[2] = puVar3[2];
if (0 < (int)uVar7) break;
uVar7 = uVar7 + 1;
}
iVar1 = *(int *)((long)__ptr + uVar7 * 4 + -4);
lVar9 = __ptr_00[uVar7 - 1];
lVar8 = 0;
do {
puVar4[(iVar1 + (int)lVar8) % 3] =
puVar4[(iVar1 + (int)lVar8) % 3] + *(int *)(lVar9 + lVar8 * 4);
lVar8 = lVar8 + 1;
} while (lVar8 != 3);
uVar7 = uVar7 + 1;
} while (param_1 + 1 != uVar7);
LAB_0010135c:
lVar9 = 0;
do {
puVar3 = *(int4 **)((long)__ptr_01 + lVar9);
puVar4 = *(int4 **)((long)__ptr_00 + lVar9);
*puVar4 = *puVar3;
*puVar3 = 0;
puVar4[1] = puVar3[1];
puVar3[1] = 0;
puVar4[2] = puVar3[2];
puVar3[2] = 0;
lVar9 = lVar9 + 8;
} while (lVar9 != lVar10);
}
iVar5 = iVar5 + -1;
if (iVar5 == 0) {
uVar2 = *(int4 *)__ptr_00[(long)(int)(param_1 + 1) + -1];
if (-1 < (int)param_1) {
lVar9 = 0;
do {
free(*(void **)((long)__ptr_00 + lVar9));
free(*(void **)((long)__ptr_01 + lVar9));
lVar9 = lVar9 + 8;
} while (lVar9 != lVar10);
}
free(__ptr_00);
free(__ptr_01);
free(__ptr);
return uVar2;
}
} while( true );
}
|
1,246 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
sum[0][0] = sum[0][1] = sum[0][2] = 0;
sum2[0][0] = sum2[0][1] = sum2[0][2] = 0;
for (int i = 1; i <= n; i++) {
a[i - 1] = (i * i - i + 1) % 3;
for (int j = 0; j < 3; j++) {
sum[i][j] = sum[i - 1][j];
}
sum[i][a[i - 1]] += 1;
}
for (int times = 1; times < 3; times++) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum2[i][j] = sum2[i - 1][j];
}
if (i >= 1) {
for (int j = 0; j <= 2; j++) {
sum2[i][(a[i - 1] + j) % 3] += sum[i - 1][j];
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum[i][j] = sum2[i][j];
sum2[i][j] = 0;
}
}
}
int result = sum[n][0];
for (int i = 0; i <= n; ++i) {
free(sum[i]);
free(sum2[i]);
}
free(sum);
free(sum2);
free(a);
return result;
}
|
#include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
movslq %edi,%r14
push %r13
lea 0x0(,%r14,4),%rdi
push %r12
push %rbp
push %rbx
mov %r14,%rbx
sub $0x28,%rsp
mov %r14,0x18(%rsp)
callq 10b0 <malloc@plt>
mov %rax,%rbp
lea 0x1(%r14),%eax
lea 0x8(,%r14,8),%r14
cltq
lea 0x0(,%rax,8),%r15
mov %r15,%rdi
mov %r15,0x10(%rsp)
callq 10b0 <malloc@plt>
mov %r15,%rdi
xor %r15d,%r15d
mov %rax,%r12
callq 10b0 <malloc@plt>
mov %rax,%r13
test %ebx,%ebx
js 1526 <func0+0x2a6>
nopl 0x0(%rax)
mov $0x4,%esi
mov $0x3,%edi
callq 10a0 <calloc@plt>
mov $0x4,%esi
mov $0x3,%edi
mov %rax,(%r12,%r15,1)
callq 10a0 <calloc@plt>
mov %rax,0x0(%r13,%r15,1)
add $0x8,%r15
cmp %r15,%r14
jne 12f0 <func0+0x70>
mov (%r12),%r11
mov 0x0(%r13),%r15
movq $0x0,(%r11)
movl $0x0,0x8(%r11)
movq $0x0,(%r15)
movl $0x0,0x8(%r15)
test %ebx,%ebx
jle 13aa <func0+0x12a>
lea -0x1(%rbx),%esi
mov %r11,%r8
mov $0x1,%ecx
mov $0xaaaaaaab,%edi
add $0x1,%rsi
jmp 1367 <func0+0xe7>
add $0x1,%rcx
mov %rdx,%r8
lea -0x1(%rcx),%edx
mov (%r8),%r9d
imul %ecx,%edx
lea 0x1(%rdx),%eax
mov %rax,%rdx
imul %rdi,%rax
shr $0x21,%rax
lea (%rax,%rax,2),%eax
sub %eax,%edx
movslq %edx,%rax
mov (%r12,%rcx,8),%rdx
mov %eax,-0x4(%rbp,%rcx,4)
mov %r9d,(%rdx)
mov 0x4(%r8),%r9d
mov %r9d,0x4(%rdx)
mov 0x8(%r8),%r8d
mov %r8d,0x8(%rdx)
addl $0x1,(%rdx,%rax,4)
cmp %rcx,%rsi
jne 1360 <func0+0xe0>
lea -0x1(%rbx),%r14d
movl $0x2,0xc(%rsp)
add $0x1,%r14
test %ebx,%ebx
jle 148a <func0+0x20a>
mov %r11,%r10
mov %r15,%rax
mov $0x1,%r8d
xchg %ax,%ax
mov (%rax),%edx
mov 0x0(%r13,%r8,8),%rcx
mov -0x4(%rbp,%r8,4),%esi
mov %edx,(%rcx)
mov 0x4(%rax),%edx
mov %edx,0x4(%rcx)
mov 0x8(%rax),%eax
xor %edx,%edx
mov %eax,0x8(%rcx)
lea (%rsi,%rdx,1),%eax
movslq %eax,%rdi
mov %eax,%r9d
imul $0x55555556,%rdi,%rdi
sar $0x1f,%r9d
shr $0x20,%rdi
sub %r9d,%edi
lea (%rdi,%rdi,2),%edi
sub %edi,%eax
mov (%r10,%rdx,4),%edi
add $0x1,%rdx
cltq
add %edi,(%rcx,%rax,4)
cmp $0x3,%rdx
jne 13ec <func0+0x16c>
cmp %r8,%r14
je 1438 <func0+0x1b8>
mov (%r12,%r8,8),%r10
mov %rcx,%rax
add $0x1,%r8
jmp 13d0 <func0+0x150>
nopl 0x0(%rax)
mov %r11,%rcx
mov %r15,%rax
xor %edx,%edx
jmp 1451 <func0+0x1d1>
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13,%rdx,8),%rax
mov (%r12,%rdx,8),%rcx
mov 0x8(%rax),%esi
mov (%rax),%rdi
add $0x1,%rdx
movq $0x0,(%rax)
movl $0x0,0x8(%rax)
mov %rdi,(%rcx)
mov %esi,0x8(%rcx)
cmp %edx,%ebx
jge 1448 <func0+0x1c8>
cmpl $0x1,0xc(%rsp)
je 14b0 <func0+0x230>
movl $0x1,0xc(%rsp)
test %ebx,%ebx
jg 13c2 <func0+0x142>
jne 1473 <func0+0x1f3>
mov 0x8(%r15),%eax
mov (%r15),%rdx
movl $0x0,0x8(%r15)
movq $0x0,(%r15)
mov %rdx,(%r11)
mov %eax,0x8(%r11)
jmp 1473 <func0+0x1f3>
nopl 0x0(%rax,%rax,1)
mov 0x10(%rsp),%rax
mov -0x8(%r12,%rax,1),%rax
mov (%rax),%r14d
test %ebx,%ebx
js 14fc <func0+0x27c>
mov 0x18(%rsp),%rax
xor %r15d,%r15d
mov %r11,%rdi
lea 0x8(,%rax,8),%rbx
jmp 14e4 <func0+0x264>
nopw %cs:0x0(%rax,%rax,1)
mov (%r12,%r15,1),%rdi
callq 1080 <free@plt>
mov 0x0(%r13,%r15,1),%rdi
add $0x8,%r15
callq 1080 <free@plt>
cmp %r15,%rbx
jne 14e0 <func0+0x260>
mov %r12,%rdi
callq 1080 <free@plt>
mov %r13,%rdi
callq 1080 <free@plt>
mov %rbp,%rdi
callq 1080 <free@plt>
add $0x28,%rsp
mov %r14d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov (%r12),%r11
mov (%rax),%r15
movq $0x0,(%r11)
movl $0x0,0x8(%r11)
movq $0x0,(%r15)
movl $0x0,0x8(%r15)
jmpq 13aa <func0+0x12a>
|
func0:
endbr64
push r15
push r14
movsxd r14, edi
push r13
lea rdi, ds:0[r14*4]; size
mov r13, r14
push r12
push rbp
push rbx
sub rsp, 18h
call _malloc
mov r12, rax
lea eax, [r14+1]
cdqe
lea r15, ds:0[rax*8]
mov rdi, r15; size
mov [rsp+48h+var_40], r15
call _malloc
mov rdi, r15; size
mov rbx, rax
call _malloc
mov rbp, rax
test r14d, r14d
js loc_14B6
lea r14, ds:8[r14*8]
xor r15d, r15d
nop dword ptr [rax]
loc_12E8:
mov esi, 4; size
mov edi, 3; nmemb
call _calloc
mov esi, 4; size
mov edi, 3; nmemb
mov [rbx+r15], rax
call _calloc
mov [rbp+r15+0], rax
add r15, 8
cmp r15, r14
jnz short loc_12E8
mov rax, [rbx]
mov dword ptr [rax+8], 0
mov qword ptr [rax], 0
mov rax, [rbp+0]
mov dword ptr [rax+8], 0
mov qword ptr [rax], 0
test r13d, r13d
jz loc_14F6
mov r8d, r13d
xor edx, edx
mov edi, 0AAAAAAABh
xchg ax, ax
loc_1350:
lea ecx, [rdx+1]
imul ecx, edx
lea eax, [rcx+1]
mov rcx, rax
imul rax, rdi
shr rax, 21h
lea esi, [rax+rax*2]
mov eax, ecx
mov rcx, [rbx+rdx*8+8]
sub eax, esi
mov rsi, [rbx+rdx*8]
mov [r12+rdx*4], eax
cdqe
add rdx, 1
mov r9d, [rsi]
mov [rcx], r9d
mov r9d, [rsi+4]
mov [rcx+4], r9d
mov esi, [rsi+8]
mov [rcx+8], esi
add dword ptr [rcx+rax*4], 1
cmp rdx, r8
jnz short loc_1350
loc_139B:
lea r14, ds:8[r8*8]
mov esi, 2
loc_13A8:
test r13d, r13d
jle loc_14E1
xor edi, edi
nop dword ptr [rax+rax+00h]
loc_13B8:
mov rax, [rbp+rdi*8+0]
mov rcx, [rbp+rdi*8+8]
mov r10d, [r12+rdi*4]
mov r9, [rbx+rdi*8]
mov edx, [rax]
mov [rcx], edx
mov edx, [rax+4]
mov [rcx+4], edx
mov eax, [rax+8]
xor edx, edx
mov [rcx+8], eax
loc_13DC:
lea eax, [r10+rdx]
movsxd r11, eax
mov r15d, eax
imul r11, 55555556h
sar r15d, 1Fh
shr r11, 20h
sub r11d, r15d
lea r11d, [r11+r11*2]
sub eax, r11d
mov r11d, [r9+rdx*4]
add rdx, 1
cdqe
add [rcx+rax*4], r11d
cmp rdx, 3
jnz short loc_13DC
add rdi, 1
cmp r8, rdi
jnz short loc_13B8
loc_141C:
xor eax, eax
xchg ax, ax
loc_1420:
mov rdx, [rbp+rax+0]
mov rcx, [rbx+rax]
add rax, 8
mov rdi, [rdx]
mov qword ptr [rdx], 0
mov [rcx], rdi
mov edi, [rdx+8]
mov dword ptr [rdx+8], 0
mov [rcx+8], edi
cmp r14, rax
jnz short loc_1420
cmp esi, 1
jz short loc_145B
mov esi, 1
jmp loc_13A8
loc_145B:
mov rax, [rsp+48h+var_40]
xor r13d, r13d
mov rax, [rbx+rax-8]
mov r15d, [rax]
nop dword ptr [rax+rax+00h]
loc_1470:
mov rdi, [rbx+r13]; ptr
call _free
mov rdi, [rbp+r13+0]; ptr
add r13, 8
call _free
cmp r13, r14
jnz short loc_1470
loc_148C:
mov rdi, rbx; ptr
call _free
mov rdi, rbp; ptr
call _free
mov rdi, r12; ptr
call _free
add rsp, 18h
mov eax, r15d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14B6:
mov rax, [rbx]
mov r8d, r14d
mov dword ptr [rax+8], 0
mov qword ptr [rax], 0
mov rax, [rbp+0]
mov dword ptr [rax+8], 0
mov qword ptr [rax], 0
jmp loc_139B
loc_14E1:
jz loc_141C
mov rax, [rsp+48h+var_40]
mov rax, [rbx+rax-8]
mov r15d, [rax]
jmp short loc_148C
loc_14F6:
xor r8d, r8d
jmp loc_139B
|
long long func0(int a1)
{
_DWORD *v2; // r12
size_t v3; // r15
long long *v4; // rbx
long long *v5; // rbp
unsigned long long v6; // r15
long long v7; // rax
long long v8; // rax
long long v9; // r8
long long v10; // rdx
_DWORD *v11; // rcx
signed int v12; // eax
_DWORD *v13; // rsi
long long v14; // r14
int i; // esi
long long v16; // rdi
_DWORD *v17; // rax
_DWORD *v18; // rcx
int v19; // r10d
long long v20; // r9
long long v21; // rdx
int v22; // eax
int v23; // r11d
unsigned long long v24; // rax
long long *v25; // rdx
long long v26; // rcx
long long v27; // rdi
unsigned long long v28; // r13
unsigned int v29; // r15d
void *v30; // rdi
long long v32; // rax
long long v33; // rax
size_t v34; // [rsp+8h] [rbp-40h]
v2 = malloc(4LL * a1);
v3 = 8LL * (a1 + 1);
v34 = v3;
v4 = (long long *)malloc(v3);
v5 = (long long *)malloc(v3);
if ( a1 < 0 )
{
v32 = *v4;
v9 = (unsigned int)a1;
*(_DWORD *)(v32 + 8) = 0;
*(_QWORD *)v32 = 0LL;
v33 = *v5;
*(_DWORD *)(v33 + 8) = 0;
*(_QWORD *)v33 = 0LL;
}
else
{
v6 = 0LL;
do
{
v4[v6 / 8] = (long long)calloc(3uLL, 4uLL);
v5[v6 / 8] = (long long)calloc(3uLL, 4uLL);
v6 += 8LL;
}
while ( v6 != 8LL * a1 + 8 );
v7 = *v4;
*(_DWORD *)(v7 + 8) = 0;
*(_QWORD *)v7 = 0LL;
v8 = *v5;
*(_DWORD *)(v8 + 8) = 0;
*(_QWORD *)v8 = 0LL;
if ( a1 )
{
v9 = (unsigned int)a1;
v10 = 0LL;
do
{
v11 = (_DWORD *)v4[v10 + 1];
v12 = ((int)v10 * ((int)v10 + 1) + 1) % 3u;
v13 = (_DWORD *)v4[v10];
v2[v10++] = v12;
*v11 = *v13;
v11[1] = v13[1];
v11[2] = v13[2];
++v11[v12];
}
while ( v10 != a1 );
}
else
{
v9 = 0LL;
}
}
v14 = 8 * v9 + 8;
for ( i = 2; ; i = 1 )
{
if ( a1 <= 0 )
{
if ( a1 )
{
v29 = **(_DWORD **)((char *)v4 + v34 - 8);
goto LABEL_19;
}
}
else
{
v16 = 0LL;
do
{
v17 = (_DWORD *)v5[v16];
v18 = (_DWORD *)v5[v16 + 1];
v19 = v2[v16];
v20 = v4[v16];
*v18 = *v17;
v18[1] = v17[1];
v21 = 0LL;
v18[2] = v17[2];
do
{
v22 = (v19 + (int)v21) % 3;
v23 = *(_DWORD *)(v20 + 4 * v21++);
v18[v22] += v23;
}
while ( v21 != 3 );
++v16;
}
while ( v9 != v16 );
}
v24 = 0LL;
do
{
v25 = (long long *)v5[v24 / 8];
v26 = v4[v24 / 8];
v24 += 8LL;
v27 = *v25;
*v25 = 0LL;
*(_QWORD *)v26 = v27;
LODWORD(v27) = *((_DWORD *)v25 + 2);
*((_DWORD *)v25 + 2) = 0;
*(_DWORD *)(v26 + 8) = v27;
}
while ( v14 != v24 );
if ( i == 1 )
break;
}
v28 = 0LL;
v29 = **(_DWORD **)((char *)v4 + v34 - 8);
do
{
free((void *)v4[v28 / 8]);
v30 = (void *)v5[v28 / 8];
v28 += 8LL;
free(v30);
}
while ( v28 != v14 );
LABEL_19:
free(v4);
free(v5);
free(v2);
return v29;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOVSXD R14,EDI
PUSH R13
LEA RDI,[R14*0x4]
MOV R13,R14
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
MOV R12,RAX
LEA EAX,[R14 + 0x1]
CDQE
LEA R15,[RAX*0x8]
MOV RDI,R15
MOV qword ptr [RSP + 0x8],R15
CALL 0x001010b0
MOV RDI,R15
MOV RBX,RAX
CALL 0x001010b0
MOV RBP,RAX
TEST R14D,R14D
JS 0x001014b6
LEA R14,[0x8 + R14*0x8]
XOR R15D,R15D
NOP dword ptr [RAX]
LAB_001012e8:
MOV ESI,0x4
MOV EDI,0x3
CALL 0x001010a0
MOV ESI,0x4
MOV EDI,0x3
MOV qword ptr [RBX + R15*0x1],RAX
CALL 0x001010a0
MOV qword ptr [RBP + R15*0x1],RAX
ADD R15,0x8
CMP R15,R14
JNZ 0x001012e8
MOV RAX,qword ptr [RBX]
MOV dword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP]
MOV dword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],0x0
TEST R13D,R13D
JZ 0x001014f6
MOV R8D,R13D
XOR EDX,EDX
MOV EDI,0xaaaaaaab
NOP
LAB_00101350:
LEA ECX,[RDX + 0x1]
IMUL ECX,EDX
LEA EAX,[RCX + 0x1]
MOV RCX,RAX
IMUL RAX,RDI
SHR RAX,0x21
LEA ESI,[RAX + RAX*0x2]
MOV EAX,ECX
MOV RCX,qword ptr [RBX + RDX*0x8 + 0x8]
SUB EAX,ESI
MOV RSI,qword ptr [RBX + RDX*0x8]
MOV dword ptr [R12 + RDX*0x4],EAX
CDQE
ADD RDX,0x1
MOV R9D,dword ptr [RSI]
MOV dword ptr [RCX],R9D
MOV R9D,dword ptr [RSI + 0x4]
MOV dword ptr [RCX + 0x4],R9D
MOV ESI,dword ptr [RSI + 0x8]
MOV dword ptr [RCX + 0x8],ESI
ADD dword ptr [RCX + RAX*0x4],0x1
CMP RDX,R8
JNZ 0x00101350
LAB_0010139b:
LEA R14,[0x8 + R8*0x8]
MOV ESI,0x2
LAB_001013a8:
TEST R13D,R13D
JLE 0x001014e1
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b8:
MOV RAX,qword ptr [RBP + RDI*0x8]
MOV RCX,qword ptr [RBP + RDI*0x8 + 0x8]
MOV R10D,dword ptr [R12 + RDI*0x4]
MOV R9,qword ptr [RBX + RDI*0x8]
MOV EDX,dword ptr [RAX]
MOV dword ptr [RCX],EDX
MOV EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RCX + 0x4],EDX
MOV EAX,dword ptr [RAX + 0x8]
XOR EDX,EDX
MOV dword ptr [RCX + 0x8],EAX
LAB_001013dc:
LEA EAX,[R10 + RDX*0x1]
MOVSXD R11,EAX
MOV R15D,EAX
IMUL R11,R11,0x55555556
SAR R15D,0x1f
SHR R11,0x20
SUB R11D,R15D
LEA R11D,[R11 + R11*0x2]
SUB EAX,R11D
MOV R11D,dword ptr [R9 + RDX*0x4]
ADD RDX,0x1
CDQE
ADD dword ptr [RCX + RAX*0x4],R11D
CMP RDX,0x3
JNZ 0x001013dc
ADD RDI,0x1
CMP R8,RDI
JNZ 0x001013b8
LAB_0010141c:
XOR EAX,EAX
NOP
LAB_00101420:
MOV RDX,qword ptr [RBP + RAX*0x1]
MOV RCX,qword ptr [RBX + RAX*0x1]
ADD RAX,0x8
MOV RDI,qword ptr [RDX]
MOV qword ptr [RDX],0x0
MOV qword ptr [RCX],RDI
MOV EDI,dword ptr [RDX + 0x8]
MOV dword ptr [RDX + 0x8],0x0
MOV dword ptr [RCX + 0x8],EDI
CMP R14,RAX
JNZ 0x00101420
CMP ESI,0x1
JZ 0x0010145b
MOV ESI,0x1
JMP 0x001013a8
LAB_0010145b:
MOV RAX,qword ptr [RSP + 0x8]
XOR R13D,R13D
MOV RAX,qword ptr [RBX + RAX*0x1 + -0x8]
MOV R15D,dword ptr [RAX]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101470:
MOV RDI,qword ptr [RBX + R13*0x1]
CALL 0x00101080
MOV RDI,qword ptr [RBP + R13*0x1]
ADD R13,0x8
CALL 0x00101080
CMP R13,R14
JNZ 0x00101470
LAB_0010148c:
MOV RDI,RBX
CALL 0x00101080
MOV RDI,RBP
CALL 0x00101080
MOV RDI,R12
CALL 0x00101080
ADD RSP,0x18
MOV EAX,R15D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014b6:
MOV RAX,qword ptr [RBX]
MOV R8D,R14D
MOV dword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP]
MOV dword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],0x0
JMP 0x0010139b
LAB_001014e1:
JZ 0x0010141c
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RBX + RAX*0x1 + -0x8]
MOV R15D,dword ptr [RAX]
JMP 0x0010148c
LAB_001014f6:
XOR R8D,R8D
JMP 0x0010139b
|
int4 func0(uint param_1)
{
long lVar1;
int iVar2;
int8 *puVar3;
int4 *puVar4;
int4 *puVar5;
int8 *puVar6;
int8 uVar7;
int iVar8;
uint uVar9;
void *__ptr;
long lVar10;
int8 *__ptr_00;
int8 *__ptr_01;
void *pvVar11;
long lVar12;
ulong uVar13;
long lVar14;
int iVar15;
ulong uVar16;
int4 uVar17;
long lVar18;
__ptr = malloc((long)(int)param_1 * 4);
lVar10 = (long)(int)(param_1 + 1);
__ptr_00 = (int8 *)malloc(lVar10 * 8);
__ptr_01 = (int8 *)malloc(lVar10 * 8);
if ((int)param_1 < 0) {
puVar3 = (int8 *)*__ptr_00;
uVar16 = (ulong)param_1;
*(int4 *)(puVar3 + 1) = 0;
*puVar3 = 0;
puVar3 = (int8 *)*__ptr_01;
*(int4 *)(puVar3 + 1) = 0;
*puVar3 = 0;
}
else {
lVar18 = 0;
do {
pvVar11 = calloc(3,4);
*(void **)((long)__ptr_00 + lVar18) = pvVar11;
pvVar11 = calloc(3,4);
*(void **)((long)__ptr_01 + lVar18) = pvVar11;
lVar18 = lVar18 + 8;
} while (lVar18 != (long)(int)param_1 * 8 + 8);
puVar3 = (int8 *)*__ptr_00;
*(int4 *)(puVar3 + 1) = 0;
*puVar3 = 0;
puVar3 = (int8 *)*__ptr_01;
*(int4 *)(puVar3 + 1) = 0;
*puVar3 = 0;
if (param_1 == 0) {
uVar16 = 0;
}
else {
uVar16 = (ulong)param_1;
uVar13 = 0;
do {
puVar4 = (int4 *)__ptr_00[uVar13 + 1];
uVar9 = (((int)uVar13 + 1) * (int)uVar13 + 1U) % 3;
puVar5 = (int4 *)__ptr_00[uVar13];
*(uint *)((long)__ptr + uVar13 * 4) = uVar9;
uVar13 = uVar13 + 1;
*puVar4 = *puVar5;
puVar4[1] = puVar5[1];
puVar4[2] = puVar5[2];
puVar4[(int)uVar9] = puVar4[(int)uVar9] + 1;
} while (uVar13 != uVar16);
}
}
lVar18 = uVar16 * 8 + 8;
iVar15 = 2;
while( true ) {
if ((int)param_1 < 1) {
if (param_1 != 0) {
uVar17 = *(int4 *)__ptr_00[lVar10 + -1];
goto LAB_0010148c;
}
}
else {
uVar13 = 0;
do {
puVar4 = (int4 *)__ptr_01[uVar13];
puVar5 = (int4 *)__ptr_01[uVar13 + 1];
iVar2 = *(int *)((long)__ptr + uVar13 * 4);
lVar12 = __ptr_00[uVar13];
*puVar5 = *puVar4;
puVar5[1] = puVar4[1];
lVar14 = 0;
puVar5[2] = puVar4[2];
do {
iVar8 = (int)lVar14;
lVar1 = lVar14 * 4;
lVar14 = lVar14 + 1;
puVar5[(iVar2 + iVar8) % 3] = puVar5[(iVar2 + iVar8) % 3] + *(int *)(lVar12 + lVar1);
} while (lVar14 != 3);
uVar13 = uVar13 + 1;
} while (uVar16 != uVar13);
}
lVar12 = 0;
do {
puVar3 = *(int8 **)((long)__ptr_01 + lVar12);
puVar6 = *(int8 **)((long)__ptr_00 + lVar12);
lVar12 = lVar12 + 8;
uVar7 = *puVar3;
*puVar3 = 0;
*puVar6 = uVar7;
uVar17 = *(int4 *)(puVar3 + 1);
*(int4 *)(puVar3 + 1) = 0;
*(int4 *)(puVar6 + 1) = uVar17;
} while (lVar18 != lVar12);
if (iVar15 == 1) break;
iVar15 = 1;
}
lVar12 = 0;
uVar17 = *(int4 *)__ptr_00[lVar10 + -1];
do {
free(*(void **)((long)__ptr_00 + lVar12));
puVar3 = (int8 *)((long)__ptr_01 + lVar12);
lVar12 = lVar12 + 8;
free((void *)*puVar3);
} while (lVar12 != lVar18);
LAB_0010148c:
free(__ptr_00);
free(__ptr_01);
free(__ptr);
return uVar17;
}
|
1,247 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int n) {
int *a = (int *)malloc(n * sizeof(int));
int **sum = (int **)malloc((n + 1) * sizeof(int *));
int **sum2 = (int **)malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
sum[i] = (int *)calloc(3, sizeof(int));
sum2[i] = (int *)calloc(3, sizeof(int));
}
sum[0][0] = sum[0][1] = sum[0][2] = 0;
sum2[0][0] = sum2[0][1] = sum2[0][2] = 0;
for (int i = 1; i <= n; i++) {
a[i - 1] = (i * i - i + 1) % 3;
for (int j = 0; j < 3; j++) {
sum[i][j] = sum[i - 1][j];
}
sum[i][a[i - 1]] += 1;
}
for (int times = 1; times < 3; times++) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum2[i][j] = sum2[i - 1][j];
}
if (i >= 1) {
for (int j = 0; j <= 2; j++) {
sum2[i][(a[i - 1] + j) % 3] += sum[i - 1][j];
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
sum[i][j] = sum2[i][j];
sum2[i][j] = 0;
}
}
}
int result = sum[n][0];
for (int i = 0; i <= n; ++i) {
free(sum[i]);
free(sum2[i]);
}
free(sum);
free(sum2);
free(a);
return result;
}
|
#include <assert.h>
int main() {
assert(func0(5) == 1);
assert(func0(6) == 4);
assert(func0(10) == 36);
assert(func0(100) == 53361);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
movslq %edi,%rbp
push %rbx
lea 0x1(%rbp),%ebx
lea 0x0(,%rbp,4),%rdi
mov %rbp,%r15
movslq %ebx,%rbx
shl $0x3,%rbx
sub $0x18,%rsp
mov %rbp,0x8(%rsp)
callq 10b0 <malloc@plt>
mov %rbx,%rdi
mov %rbx,(%rsp)
mov %rax,%r14
callq 10b0 <malloc@plt>
mov %rbx,%rdi
lea 0x8(,%rbp,8),%rbx
xor %ebp,%ebp
mov %rax,%r12
callq 10b0 <malloc@plt>
mov %rax,%r13
test %r15d,%r15d
js 1556 <func0+0x2d6>
nopl 0x0(%rax)
mov $0x4,%esi
mov $0x3,%edi
callq 10a0 <calloc@plt>
mov $0x4,%esi
mov $0x3,%edi
mov %rax,(%r12,%rbp,1)
callq 10a0 <calloc@plt>
mov %rax,0x0(%r13,%rbp,1)
add $0x8,%rbp
cmp %rbx,%rbp
jne 12e8 <func0+0x68>
mov (%r12),%rax
mov 0x0(%r13),%rbx
movq $0x0,(%rax)
movl $0x0,0x8(%rax)
movq $0x0,(%rbx)
movl $0x0,0x8(%rbx)
test %r15d,%r15d
jle 13ab <func0+0x12b>
lea -0x1(%r15),%edi
xor %ecx,%ecx
xor %r9d,%r9d
mov $0xaaaaaaab,%esi
jmp 1362 <func0+0xe2>
nopl 0x0(%rax)
mov (%r12,%rax,8),%rdx
mov %rax,%rcx
mov (%rdx),%r9d
lea 0x1(%rcx),%edx
mov (%r12,%rcx,8),%r8
imul %ecx,%edx
lea 0x1(%rdx),%eax
mov %rax,%rdx
imul %rsi,%rax
shr $0x21,%rax
lea (%rax,%rax,2),%eax
sub %eax,%edx
movslq %edx,%rax
mov 0x8(%r12,%rcx,8),%rdx
mov %eax,(%r14,%rcx,4)
mov %r9d,(%rdx)
mov 0x4(%r8),%r9d
mov %r9d,0x4(%rdx)
mov 0x8(%r8),%r8d
mov %r8d,0x8(%rdx)
addl $0x1,(%rdx,%rax,4)
lea 0x1(%rcx),%rax
cmp %rdi,%rcx
jne 1358 <func0+0xd8>
mov $0x2,%r8d
lea -0x1(%r15),%r11d
mov %rbx,%rdx
xor %esi,%esi
test %r15d,%r15d
jle 14be <func0+0x23e>
nopl 0x0(%rax,%rax,1)
mov %rdx,%rax
mov 0x8(%r13,%rsi,8),%rdx
mov (%rax),%ecx
mov %ecx,(%rdx)
mov 0x4(%rax),%ecx
mov %ecx,0x4(%rdx)
movslq (%r14,%rsi,4),%rcx
mov 0x8(%rax),%eax
mov %eax,0x8(%rdx)
mov %rcx,%rax
imul $0x55555556,%rcx,%rcx
mov %eax,%edi
sar $0x1f,%edi
shr $0x20,%rcx
sub %edi,%ecx
mov %eax,%edi
lea (%rcx,%rcx,2),%ecx
sub %ecx,%edi
movslq %edi,%rcx
mov (%r12,%rsi,8),%rdi
mov (%rdi),%r9d
add %r9d,(%rdx,%rcx,4)
lea 0x1(%rax),%ecx
add $0x2,%eax
movslq %ecx,%r9
mov %ecx,%r10d
imul $0x55555556,%r9,%r9
sar $0x1f,%r10d
shr $0x20,%r9
sub %r10d,%r9d
lea (%r9,%r9,2),%r9d
sub %r9d,%ecx
mov 0x4(%rdi),%r9d
movslq %ecx,%rcx
add %r9d,(%rdx,%rcx,4)
movslq %eax,%rcx
mov %eax,%r9d
imul $0x55555556,%rcx,%rcx
sar $0x1f,%r9d
shr $0x20,%rcx
sub %r9d,%ecx
lea (%rcx,%rcx,2),%ecx
sub %ecx,%eax
mov 0x8(%rdi),%ecx
cltq
add %ecx,(%rdx,%rax,4)
mov %rsi,%rax
add $0x1,%rsi
cmp %r11,%rax
jne 13c8 <func0+0x148>
xor %eax,%eax
nopl (%rax)
mov 0x0(%r13,%rax,8),%rdx
mov (%r12,%rax,8),%rcx
add $0x1,%rax
mov 0x8(%rdx),%esi
mov (%rdx),%rdi
movl $0x0,0x8(%rdx)
movq $0x0,(%rdx)
mov %rdi,(%rcx)
mov %esi,0x8(%rcx)
cmp %eax,%r15d
jge 1478 <func0+0x1f8>
cmp $0x1,%r8d
je 14e8 <func0+0x268>
mov $0x1,%r8d
mov %rbx,%rdx
xor %esi,%esi
test %r15d,%r15d
jg 13c8 <func0+0x148>
jne 14a4 <func0+0x224>
mov 0x0(%r13),%rax
mov (%r12),%rdx
mov 0x8(%rax),%ecx
mov (%rax),%rsi
movl $0x0,0x8(%rax)
movq $0x0,(%rax)
mov %rsi,(%rdx)
mov %ecx,0x8(%rdx)
jmp 14a4 <func0+0x224>
nopl 0x0(%rax)
mov (%rsp),%rax
xor %ebp,%ebp
mov -0x8(%r12,%rax,1),%rax
mov (%rax),%eax
mov %eax,(%rsp)
mov 0x8(%rsp),%rax
lea 0x8(,%rax,8),%rbx
test %r15d,%r15d
js 152c <func0+0x2ac>
nopw 0x0(%rax,%rax,1)
mov (%r12,%rbp,1),%rdi
callq 1080 <free@plt>
mov 0x0(%r13,%rbp,1),%rdi
add $0x8,%rbp
callq 1080 <free@plt>
cmp %rbx,%rbp
jne 1510 <func0+0x290>
mov %r12,%rdi
callq 1080 <free@plt>
mov %r13,%rdi
callq 1080 <free@plt>
mov %r14,%rdi
callq 1080 <free@plt>
mov (%rsp),%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov (%r12),%rax
mov 0x0(%r13),%rbx
movq $0x0,(%rax)
movl $0x0,0x8(%rax)
movq $0x0,(%rbx)
movl $0x0,0x8(%rbx)
jmpq 13ab <func0+0x12b>
|
func0:
endbr64
push r15
push r14
push r13
movsxd r13, edi
push r12
lea rdi, ds:0[r13*4]; size
mov r14, r13
push rbp
push rbx
sub rsp, 18h
call _malloc
mov r12, rax
lea eax, [r13+1]
cdqe
lea r15, ds:0[rax*8]
mov rdi, r15; size
mov [rsp+48h+var_40], r15
call _malloc
mov rdi, r15; size
mov rbx, rax
call _malloc
mov rbp, rax
test r13d, r13d
js loc_150E
lea r13, ds:8[r13*8]
xor r15d, r15d
nop dword ptr [rax]
loc_12E8:
mov esi, 4; size
mov edi, 3; nmemb
call _calloc
mov esi, 4; size
mov edi, 3; nmemb
mov [rbx+r15], rax
call _calloc
mov [rbp+r15+0], rax
add r15, 8
cmp r15, r13
jnz short loc_12E8
mov rax, [rbx]
mov r9, [rbp+0]
mov dword ptr [rax+8], 0
mov qword ptr [rax], 0
mov dword ptr [r9+8], 0
mov qword ptr [r9], 0
test r14d, r14d
jz loc_154F
mov r10d, r14d
xor edx, edx
xor edi, edi
mov esi, 0AAAAAAABh
jmp short loc_135E
loc_1358:
mov rax, [rbx+rdx*8]
mov edi, [rax]
loc_135E:
lea ecx, [rdx+1]
imul ecx, edx
lea eax, [rcx+1]
mov rcx, rax
imul rax, rsi
shr rax, 21h
lea r8d, [rax+rax*2]
mov eax, ecx
mov rcx, [rbx+rdx*8+8]
sub eax, r8d
mov r8, [rbx+rdx*8]
mov [rcx], edi
mov edi, [r8+4]
mov [r12+rdx*4], eax
cdqe
add rdx, 1
mov [rcx+4], edi
mov edi, [r8+8]
mov [rcx+8], edi
add dword ptr [rcx+rax*4], 1
cmp rdx, r10
jnz short loc_1358
loc_13A7:
lea r13, ds:8[r10*8]
mov r11d, 2
loc_13B5:
mov rdx, r9
xor esi, esi
test r14d, r14d
jle loc_153A
nop dword ptr [rax+rax+00h]
loc_13C8:
mov rax, rdx
mov rdx, [rbp+rsi*8+8]
mov ecx, [rax]
mov [rdx], ecx
mov ecx, [rax+4]
mov [rdx+4], ecx
movsxd rcx, dword ptr [r12+rsi*4]
mov eax, [rax+8]
mov [rdx+8], eax
mov rax, rcx
imul rcx, 55555556h
mov edi, eax
sar edi, 1Fh
shr rcx, 20h
sub ecx, edi
lea edi, [rcx+rcx*2]
mov ecx, eax
sub ecx, edi
mov rdi, [rbx+rsi*8]
add rsi, 1
movsxd rcx, ecx
mov r8d, [rdi]
add [rdx+rcx*4], r8d
lea ecx, [rax+1]
add eax, 2
movsxd r8, ecx
mov r15d, ecx
imul r8, 55555556h
sar r15d, 1Fh
shr r8, 20h
sub r8d, r15d
lea r8d, [r8+r8*2]
sub ecx, r8d
mov r8d, [rdi+4]
movsxd rcx, ecx
add [rdx+rcx*4], r8d
movsxd rcx, eax
mov r8d, eax
imul rcx, 55555556h
sar r8d, 1Fh
shr rcx, 20h
sub ecx, r8d
lea ecx, [rcx+rcx*2]
sub eax, ecx
mov ecx, [rdi+8]
cdqe
add [rdx+rax*4], ecx
cmp rsi, r10
jnz loc_13C8
loc_1470:
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1478:
mov rdx, [rbp+rax+0]
mov rcx, [rbx+rax]
add rax, 8
mov rsi, [rdx]
mov qword ptr [rdx], 0
mov [rcx], rsi
mov esi, [rdx+8]
mov dword ptr [rdx+8], 0
mov [rcx+8], esi
cmp rax, r13
jnz short loc_1478
cmp r11d, 1
jz short loc_14B5
mov r11d, 1
jmp loc_13B5
loc_14B5:
mov rax, [rsp+48h+var_40]
xor r14d, r14d
mov rax, [rbx+rax-8]
mov r15d, [rax]
nop dword ptr [rax]
loc_14C8:
mov rdi, [rbx+r14]; ptr
call _free
mov rdi, [rbp+r14+0]; ptr
add r14, 8
call _free
cmp r14, r13
jnz short loc_14C8
loc_14E4:
mov rdi, rbx; ptr
call _free
mov rdi, rbp; ptr
call _free
mov rdi, r12; ptr
call _free
add rsp, 18h
mov eax, r15d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_150E:
mov rax, [rbx]
mov r9, [rbp+0]
mov r10d, r13d
mov dword ptr [rax+8], 0
mov qword ptr [rax], 0
mov dword ptr [r9+8], 0
mov qword ptr [r9], 0
jmp loc_13A7
loc_153A:
jz loc_1470
mov rax, [rsp+48h+var_40]
mov rax, [rbx+rax-8]
mov r15d, [rax]
jmp short loc_14E4
loc_154F:
xor r10d, r10d
jmp loc_13A7
|
long long func0(int a1)
{
_DWORD *v2; // r12
size_t v3; // r15
long long *v4; // rbx
_QWORD *v5; // rbp
unsigned long long v6; // r15
long long v7; // rax
_DWORD *v8; // r9
long long v9; // r10
long long v10; // rdx
int i; // edi
_DWORD *v12; // rcx
signed int v13; // eax
long long v14; // r8
int v15; // edi
long long v16; // r13
int j; // r11d
_DWORD *v18; // rdx
long long v19; // rsi
_DWORD *v20; // rax
int v21; // ecx
_DWORD *v22; // rdi
unsigned long long v23; // rax
long long *v24; // rdx
long long v25; // rcx
long long v26; // rsi
unsigned long long v27; // r14
unsigned int v28; // r15d
void *v29; // rdi
long long v31; // rax
size_t v32; // [rsp+8h] [rbp-40h]
v2 = malloc(4LL * a1);
v3 = 8LL * (a1 + 1);
v32 = v3;
v4 = (long long *)malloc(v3);
v5 = malloc(v3);
if ( a1 < 0 )
{
v31 = *v4;
v8 = (_DWORD *)*v5;
v9 = (unsigned int)a1;
*(_DWORD *)(v31 + 8) = 0;
*(_QWORD *)v31 = 0LL;
v8[2] = 0;
*(_QWORD *)v8 = 0LL;
}
else
{
v6 = 0LL;
do
{
v4[v6 / 8] = (long long)calloc(3uLL, 4uLL);
v5[v6 / 8] = calloc(3uLL, 4uLL);
v6 += 8LL;
}
while ( v6 != 8LL * a1 + 8 );
v7 = *v4;
v8 = (_DWORD *)*v5;
*(_DWORD *)(v7 + 8) = 0;
*(_QWORD *)v7 = 0LL;
v8[2] = 0;
*(_QWORD *)v8 = 0LL;
if ( a1 )
{
v9 = (unsigned int)a1;
v10 = 0LL;
for ( i = 0; ; i = *(_DWORD *)v4[v10] )
{
v12 = (_DWORD *)v4[v10 + 1];
v13 = ((int)v10 * ((int)v10 + 1) + 1) % 3u;
v14 = v4[v10];
*v12 = i;
v15 = *(_DWORD *)(v14 + 4);
v2[v10++] = v13;
v12[1] = v15;
v12[2] = *(_DWORD *)(v14 + 8);
++v12[v13];
if ( v10 == a1 )
break;
}
}
else
{
v9 = 0LL;
}
}
v16 = 8 * v9 + 8;
for ( j = 2; ; j = 1 )
{
v18 = v8;
v19 = 0LL;
if ( a1 <= 0 )
{
if ( a1 )
{
v28 = **(_DWORD **)((char *)v4 + v32 - 8);
goto LABEL_17;
}
}
else
{
do
{
v20 = v18;
v18 = (_DWORD *)v5[v19 + 1];
*v18 = *v20;
v18[1] = v20[1];
v21 = v2[v19];
v18[2] = v20[2];
v22 = (_DWORD *)v4[v19++];
v18[v21 % 3] += *v22;
v18[(v21 + 1) % 3] += v22[1];
v18[(v21 + 2) % 3] += v22[2];
}
while ( v19 != v9 );
}
v23 = 0LL;
do
{
v24 = (long long *)v5[v23 / 8];
v25 = v4[v23 / 8];
v23 += 8LL;
v26 = *v24;
*v24 = 0LL;
*(_QWORD *)v25 = v26;
LODWORD(v26) = *((_DWORD *)v24 + 2);
*((_DWORD *)v24 + 2) = 0;
*(_DWORD *)(v25 + 8) = v26;
}
while ( v23 != v16 );
if ( j == 1 )
break;
}
v27 = 0LL;
v28 = **(_DWORD **)((char *)v4 + v32 - 8);
do
{
free((void *)v4[v27 / 8]);
v29 = (void *)v5[v27 / 8];
v27 += 8LL;
free(v29);
}
while ( v27 != v16 );
LABEL_17:
free(v4);
free(v5);
free(v2);
return v28;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,EDI
PUSH R12
LEA RDI,[R13*0x4]
MOV R14,R13
PUSH RBP
PUSH RBX
SUB RSP,0x18
CALL 0x001010b0
MOV R12,RAX
LEA EAX,[R13 + 0x1]
CDQE
LEA R15,[RAX*0x8]
MOV RDI,R15
MOV qword ptr [RSP + 0x8],R15
CALL 0x001010b0
MOV RDI,R15
MOV RBX,RAX
CALL 0x001010b0
MOV RBP,RAX
TEST R13D,R13D
JS 0x0010150e
LEA R13,[0x8 + R13*0x8]
XOR R15D,R15D
NOP dword ptr [RAX]
LAB_001012e8:
MOV ESI,0x4
MOV EDI,0x3
CALL 0x001010a0
MOV ESI,0x4
MOV EDI,0x3
MOV qword ptr [RBX + R15*0x1],RAX
CALL 0x001010a0
MOV qword ptr [RBP + R15*0x1],RAX
ADD R15,0x8
CMP R15,R13
JNZ 0x001012e8
MOV RAX,qword ptr [RBX]
MOV R9,qword ptr [RBP]
MOV dword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],0x0
MOV dword ptr [R9 + 0x8],0x0
MOV qword ptr [R9],0x0
TEST R14D,R14D
JZ 0x0010154f
MOV R10D,R14D
XOR EDX,EDX
XOR EDI,EDI
MOV ESI,0xaaaaaaab
JMP 0x0010135e
LAB_00101358:
MOV RAX,qword ptr [RBX + RDX*0x8]
MOV EDI,dword ptr [RAX]
LAB_0010135e:
LEA ECX,[RDX + 0x1]
IMUL ECX,EDX
LEA EAX,[RCX + 0x1]
MOV RCX,RAX
IMUL RAX,RSI
SHR RAX,0x21
LEA R8D,[RAX + RAX*0x2]
MOV EAX,ECX
MOV RCX,qword ptr [RBX + RDX*0x8 + 0x8]
SUB EAX,R8D
MOV R8,qword ptr [RBX + RDX*0x8]
MOV dword ptr [RCX],EDI
MOV EDI,dword ptr [R8 + 0x4]
MOV dword ptr [R12 + RDX*0x4],EAX
CDQE
ADD RDX,0x1
MOV dword ptr [RCX + 0x4],EDI
MOV EDI,dword ptr [R8 + 0x8]
MOV dword ptr [RCX + 0x8],EDI
ADD dword ptr [RCX + RAX*0x4],0x1
CMP RDX,R10
JNZ 0x00101358
LAB_001013a7:
LEA R13,[0x8 + R10*0x8]
MOV R11D,0x2
LAB_001013b5:
MOV RDX,R9
XOR ESI,ESI
TEST R14D,R14D
JLE 0x0010153a
NOP dword ptr [RAX + RAX*0x1]
LAB_001013c8:
MOV RAX,RDX
MOV RDX,qword ptr [RBP + RSI*0x8 + 0x8]
MOV ECX,dword ptr [RAX]
MOV dword ptr [RDX],ECX
MOV ECX,dword ptr [RAX + 0x4]
MOV dword ptr [RDX + 0x4],ECX
MOVSXD RCX,dword ptr [R12 + RSI*0x4]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RDX + 0x8],EAX
MOV RAX,RCX
IMUL RCX,RCX,0x55555556
MOV EDI,EAX
SAR EDI,0x1f
SHR RCX,0x20
SUB ECX,EDI
LEA EDI,[RCX + RCX*0x2]
MOV ECX,EAX
SUB ECX,EDI
MOV RDI,qword ptr [RBX + RSI*0x8]
ADD RSI,0x1
MOVSXD RCX,ECX
MOV R8D,dword ptr [RDI]
ADD dword ptr [RDX + RCX*0x4],R8D
LEA ECX,[RAX + 0x1]
ADD EAX,0x2
MOVSXD R8,ECX
MOV R15D,ECX
IMUL R8,R8,0x55555556
SAR R15D,0x1f
SHR R8,0x20
SUB R8D,R15D
LEA R8D,[R8 + R8*0x2]
SUB ECX,R8D
MOV R8D,dword ptr [RDI + 0x4]
MOVSXD RCX,ECX
ADD dword ptr [RDX + RCX*0x4],R8D
MOVSXD RCX,EAX
MOV R8D,EAX
IMUL RCX,RCX,0x55555556
SAR R8D,0x1f
SHR RCX,0x20
SUB ECX,R8D
LEA ECX,[RCX + RCX*0x2]
SUB EAX,ECX
MOV ECX,dword ptr [RDI + 0x8]
CDQE
ADD dword ptr [RDX + RAX*0x4],ECX
CMP RSI,R10
JNZ 0x001013c8
LAB_00101470:
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101478:
MOV RDX,qword ptr [RBP + RAX*0x1]
MOV RCX,qword ptr [RBX + RAX*0x1]
ADD RAX,0x8
MOV RSI,qword ptr [RDX]
MOV qword ptr [RDX],0x0
MOV qword ptr [RCX],RSI
MOV ESI,dword ptr [RDX + 0x8]
MOV dword ptr [RDX + 0x8],0x0
MOV dword ptr [RCX + 0x8],ESI
CMP RAX,R13
JNZ 0x00101478
CMP R11D,0x1
JZ 0x001014b5
MOV R11D,0x1
JMP 0x001013b5
LAB_001014b5:
MOV RAX,qword ptr [RSP + 0x8]
XOR R14D,R14D
MOV RAX,qword ptr [RBX + RAX*0x1 + -0x8]
MOV R15D,dword ptr [RAX]
NOP dword ptr [RAX]
LAB_001014c8:
MOV RDI,qword ptr [RBX + R14*0x1]
CALL 0x00101080
MOV RDI,qword ptr [RBP + R14*0x1]
ADD R14,0x8
CALL 0x00101080
CMP R14,R13
JNZ 0x001014c8
LAB_001014e4:
MOV RDI,RBX
CALL 0x00101080
MOV RDI,RBP
CALL 0x00101080
MOV RDI,R12
CALL 0x00101080
ADD RSP,0x18
MOV EAX,R15D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010150e:
MOV RAX,qword ptr [RBX]
MOV R9,qword ptr [RBP]
MOV R10D,R13D
MOV dword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],0x0
MOV dword ptr [R9 + 0x8],0x0
MOV qword ptr [R9],0x0
JMP 0x001013a7
LAB_0010153a:
JZ 0x00101470
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RBX + RAX*0x1 + -0x8]
MOV R15D,dword ptr [RAX]
JMP 0x001014e4
LAB_0010154f:
XOR R10D,R10D
JMP 0x001013a7
|
int4 func0(uint param_1)
{
int *piVar1;
int iVar2;
int4 *puVar3;
int8 *puVar4;
int *piVar5;
int8 uVar6;
uint uVar7;
void *__ptr;
long lVar8;
int8 *__ptr_00;
int8 *__ptr_01;
void *pvVar9;
long lVar10;
ulong uVar11;
int8 *puVar12;
int4 uVar13;
int8 *puVar14;
ulong uVar15;
int iVar16;
long lVar17;
__ptr = malloc((long)(int)param_1 * 4);
lVar8 = (long)(int)(param_1 + 1);
__ptr_00 = (int8 *)malloc(lVar8 * 8);
__ptr_01 = (int8 *)malloc(lVar8 * 8);
if ((int)param_1 < 0) {
puVar12 = (int8 *)*__ptr_00;
puVar14 = (int8 *)*__ptr_01;
uVar15 = (ulong)param_1;
*(int4 *)(puVar12 + 1) = 0;
*puVar12 = 0;
*(int4 *)(puVar14 + 1) = 0;
*puVar14 = 0;
}
else {
lVar17 = 0;
do {
pvVar9 = calloc(3,4);
*(void **)((long)__ptr_00 + lVar17) = pvVar9;
pvVar9 = calloc(3,4);
*(void **)((long)__ptr_01 + lVar17) = pvVar9;
lVar17 = lVar17 + 8;
} while (lVar17 != (long)(int)param_1 * 8 + 8);
puVar12 = (int8 *)*__ptr_00;
puVar14 = (int8 *)*__ptr_01;
*(int4 *)(puVar12 + 1) = 0;
*puVar12 = 0;
*(int4 *)(puVar14 + 1) = 0;
*puVar14 = 0;
if (param_1 == 0) {
uVar15 = 0;
}
else {
uVar15 = (ulong)param_1;
uVar11 = 0;
uVar13 = 0;
while( true ) {
puVar3 = (int4 *)__ptr_00[uVar11 + 1];
uVar7 = (((int)uVar11 + 1) * (int)uVar11 + 1U) % 3;
lVar17 = __ptr_00[uVar11];
*puVar3 = uVar13;
uVar13 = *(int4 *)(lVar17 + 4);
*(uint *)((long)__ptr + uVar11 * 4) = uVar7;
uVar11 = uVar11 + 1;
puVar3[1] = uVar13;
puVar3[2] = *(int4 *)(lVar17 + 8);
puVar3[(int)uVar7] = puVar3[(int)uVar7] + 1;
if (uVar11 == uVar15) break;
uVar13 = *(int4 *)__ptr_00[uVar11];
}
}
}
lVar17 = uVar15 * 8 + 8;
iVar16 = 2;
while( true ) {
uVar11 = 0;
puVar12 = puVar14;
if ((int)param_1 < 1) {
if (param_1 != 0) {
uVar13 = *(int4 *)__ptr_00[lVar8 + -1];
goto LAB_001014e4;
}
}
else {
do {
puVar4 = (int8 *)__ptr_01[uVar11 + 1];
*(int4 *)puVar4 = *(int4 *)puVar12;
*(int4 *)((long)puVar4 + 4) = *(int4 *)((long)puVar12 + 4);
iVar2 = *(int *)((long)__ptr + uVar11 * 4);
*(int4 *)(puVar4 + 1) = *(int4 *)(puVar12 + 1);
piVar5 = (int *)__ptr_00[uVar11];
uVar11 = uVar11 + 1;
piVar1 = (int *)((long)puVar4 + (long)(iVar2 % 3) * 4);
*piVar1 = *piVar1 + *piVar5;
piVar1 = (int *)((long)puVar4 + (long)((iVar2 + 1) % 3) * 4);
*piVar1 = *piVar1 + piVar5[1];
piVar1 = (int *)((long)puVar4 + (long)((iVar2 + 2) % 3) * 4);
*piVar1 = *piVar1 + piVar5[2];
puVar12 = puVar4;
} while (uVar11 != uVar15);
}
lVar10 = 0;
do {
puVar12 = *(int8 **)((long)__ptr_01 + lVar10);
puVar4 = *(int8 **)((long)__ptr_00 + lVar10);
lVar10 = lVar10 + 8;
uVar6 = *puVar12;
*puVar12 = 0;
*puVar4 = uVar6;
uVar13 = *(int4 *)(puVar12 + 1);
*(int4 *)(puVar12 + 1) = 0;
*(int4 *)(puVar4 + 1) = uVar13;
} while (lVar10 != lVar17);
if (iVar16 == 1) break;
iVar16 = 1;
}
lVar10 = 0;
uVar13 = *(int4 *)__ptr_00[lVar8 + -1];
do {
free(*(void **)((long)__ptr_00 + lVar10));
puVar14 = (int8 *)((long)__ptr_01 + lVar10);
lVar10 = lVar10 + 8;
free((void *)*puVar14);
} while (lVar10 != lVar17);
LAB_001014e4:
free(__ptr_00);
free(__ptr_01);
free(__ptr);
return uVar13;
}
|
1,248 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp(planets[m], planet2) == 0) pos2 = m;
}
if (pos1 == -1 || pos2 == -1 || pos1 == pos2) {
*returnSize = 0;
return NULL;
}
if (pos1 > pos2) { int temp = pos1; pos1 = pos2; pos2 = temp; }
*returnSize = pos2 - pos1 - 1;
if (*returnSize <= 0) {
*returnSize = 0;
return NULL;
}
char** out = malloc(*returnSize * sizeof(char*));
for (m = pos1 + 1; m < pos2; m++) {
out[m - pos1 - 1] = (char*)planets[m];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char** result;
const char* test1[] = {"Saturn", "Uranus"};
result = func0("Jupiter", "Neptune", &size);
assert(issame(result, test1, size, 2));
free(result);
const char* test2[] = {"Venus"};
result = func0("Earth", "Mercury", &size);
assert(issame(result, test2, size, 1));
free(result);
const char* test3[] = {"Venus", "Earth", "Mars", "Jupiter", "Saturn"};
result = func0("Mercury", "Uranus", &size);
assert(issame(result, test3, size, 5));
free(result);
const char* test4[] = {"Earth", "Mars", "Jupiter", "Saturn", "Uranus"};
result = func0("Neptune", "Venus", &size);
assert(issame(result, test4, size, 5));
free(result);
result = func0("Earth", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Mars", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Jupiter", "Makemake", &size);
assert(size == 0 && result == NULL);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %rdx,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe0b(%rip),%rax
mov %rax,-0x50(%rbp)
lea 0xe08(%rip),%rax
mov %rax,-0x48(%rbp)
lea 0xe03(%rip),%rax
mov %rax,-0x40(%rbp)
lea 0xdfe(%rip),%rax
mov %rax,-0x38(%rbp)
lea 0xdf8(%rip),%rax
mov %rax,-0x30(%rbp)
lea 0xdf5(%rip),%rax
mov %rax,-0x28(%rbp)
lea 0xdf1(%rip),%rax
mov %rax,-0x20(%rbp)
lea 0xded(%rip),%rax
mov %rax,-0x18(%rbp)
movl $0xffffffff,-0x68(%rbp)
movl $0xffffffff,-0x64(%rbp)
movl $0x0,-0x60(%rbp)
jmp 12af <func0+0xe6>
mov -0x60(%rbp),%eax
cltq
mov -0x50(%rbp,%rax,8),%rax
mov -0x78(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
jne 1288 <func0+0xbf>
mov -0x60(%rbp),%eax
mov %eax,-0x68(%rbp)
mov -0x60(%rbp),%eax
cltq
mov -0x50(%rbp,%rax,8),%rax
mov -0x80(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
jne 12ab <func0+0xe2>
mov -0x60(%rbp),%eax
mov %eax,-0x64(%rbp)
addl $0x1,-0x60(%rbp)
cmpl $0x7,-0x60(%rbp)
jle 1265 <func0+0x9c>
cmpl $0xffffffff,-0x68(%rbp)
je 12c9 <func0+0x100>
cmpl $0xffffffff,-0x64(%rbp)
je 12c9 <func0+0x100>
mov -0x68(%rbp),%eax
cmp -0x64(%rbp),%eax
jne 12e0 <func0+0x117>
mov -0x88(%rbp),%rax
movl $0x0,(%rax)
mov $0x0,%eax
jmpq 1387 <func0+0x1be>
mov -0x68(%rbp),%eax
cmp -0x64(%rbp),%eax
jle 12fa <func0+0x131>
mov -0x68(%rbp),%eax
mov %eax,-0x5c(%rbp)
mov -0x64(%rbp),%eax
mov %eax,-0x68(%rbp)
mov -0x5c(%rbp),%eax
mov %eax,-0x64(%rbp)
mov -0x64(%rbp),%eax
sub -0x68(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x88(%rbp),%rax
mov %edx,(%rax)
mov -0x88(%rbp),%rax
mov (%rax),%eax
test %eax,%eax
jg 132d <func0+0x164>
mov -0x88(%rbp),%rax
movl $0x0,(%rax)
mov $0x0,%eax
jmp 1387 <func0+0x1be>
mov -0x88(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x58(%rbp)
mov -0x68(%rbp),%eax
add $0x1,%eax
mov %eax,-0x60(%rbp)
jmp 137b <func0+0x1b2>
mov -0x60(%rbp),%eax
sub -0x68(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x58(%rbp),%rax
add %rax,%rdx
mov -0x60(%rbp),%eax
cltq
mov -0x50(%rbp,%rax,8),%rax
mov %rax,(%rdx)
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x64(%rbp),%eax
jl 1353 <func0+0x18a>
mov -0x58(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 139b <func0+0x1d2>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+s2], rdi
mov [rbp+var_80], rsi
mov [rbp+var_88], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aMercury; "Mercury"
mov [rbp+s1], rax
lea rax, aVenus; "Venus"
mov [rbp+var_48], rax
lea rax, aEarth; "Earth"
mov [rbp+var_40], rax
lea rax, aMars; "Mars"
mov [rbp+var_38], rax
lea rax, aJupiter; "Jupiter"
mov [rbp+var_30], rax
lea rax, aSaturn; "Saturn"
mov [rbp+var_28], rax
lea rax, aUranus; "Uranus"
mov [rbp+var_20], rax
lea rax, aNeptune; "Neptune"
mov [rbp+var_18], rax
mov [rbp+var_68], 0FFFFFFFFh
mov [rbp+var_64], 0FFFFFFFFh
mov [rbp+var_60], 0
jmp short loc_12AF
loc_1265:
mov eax, [rbp+var_60]
cdqe
mov rax, [rbp+rax*8+s1]
mov rdx, [rbp+s2]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1288
mov eax, [rbp+var_60]
mov [rbp+var_68], eax
loc_1288:
mov eax, [rbp+var_60]
cdqe
mov rax, [rbp+rax*8+s1]
mov rdx, [rbp+var_80]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_12AB
mov eax, [rbp+var_60]
mov [rbp+var_64], eax
loc_12AB:
add [rbp+var_60], 1
loc_12AF:
cmp [rbp+var_60], 7
jle short loc_1265
cmp [rbp+var_68], 0FFFFFFFFh
jz short loc_12C9
cmp [rbp+var_64], 0FFFFFFFFh
jz short loc_12C9
mov eax, [rbp+var_68]
cmp eax, [rbp+var_64]
jnz short loc_12E0
loc_12C9:
mov rax, [rbp+var_88]
mov dword ptr [rax], 0
mov eax, 0
jmp loc_1387
loc_12E0:
mov eax, [rbp+var_68]
cmp eax, [rbp+var_64]
jle short loc_12FA
mov eax, [rbp+var_68]
mov [rbp+var_5C], eax
mov eax, [rbp+var_64]
mov [rbp+var_68], eax
mov eax, [rbp+var_5C]
mov [rbp+var_64], eax
loc_12FA:
mov eax, [rbp+var_64]
sub eax, [rbp+var_68]
lea edx, [rax-1]
mov rax, [rbp+var_88]
mov [rax], edx
mov rax, [rbp+var_88]
mov eax, [rax]
test eax, eax
jg short loc_132D
mov rax, [rbp+var_88]
mov dword ptr [rax], 0
mov eax, 0
jmp short loc_1387
loc_132D:
mov rax, [rbp+var_88]
mov eax, [rax]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_58], rax
mov eax, [rbp+var_68]
add eax, 1
mov [rbp+var_60], eax
jmp short loc_137B
loc_1353:
mov eax, [rbp+var_60]
sub eax, [rbp+var_68]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+var_58]
add rdx, rax
mov eax, [rbp+var_60]
cdqe
mov rax, [rbp+rax*8+s1]
mov [rdx], rax
add [rbp+var_60], 1
loc_137B:
mov eax, [rbp+var_60]
cmp eax, [rbp+var_64]
jl short loc_1353
mov rax, [rbp+var_58]
loc_1387:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_139B
call ___stack_chk_fail
locret_139B:
leave
retn
|
_QWORD * func0(const char *a1, const char *a2, int *a3)
{
int v5; // [rsp+28h] [rbp-68h]
int v6; // [rsp+2Ch] [rbp-64h]
int i; // [rsp+30h] [rbp-60h]
int j; // [rsp+30h] [rbp-60h]
int v9; // [rsp+34h] [rbp-5Ch]
_QWORD *v10; // [rsp+38h] [rbp-58h]
char *s1[10]; // [rsp+40h] [rbp-50h]
s1[9] = (char *)__readfsqword(0x28u);
s1[0] = "Mercury";
s1[1] = "Venus";
s1[2] = "Earth";
s1[3] = "Mars";
s1[4] = "Jupiter";
s1[5] = "Saturn";
s1[6] = "Uranus";
s1[7] = "Neptune";
v5 = -1;
v6 = -1;
for ( i = 0; i <= 7; ++i )
{
if ( !strcmp(s1[i], a1) )
v5 = i;
if ( !strcmp(s1[i], a2) )
v6 = i;
}
if ( v5 == -1 || v6 == -1 || v5 == v6 )
{
*a3 = 0;
return 0LL;
}
else
{
if ( v5 > v6 )
{
v9 = v5;
v5 = v6;
v6 = v9;
}
*a3 = v6 - v5 - 1;
if ( *a3 > 0 )
{
v10 = malloc(8LL * *a3);
for ( j = v5 + 1; j < v6; ++j )
v10[j - v5 - 1] = s1[j];
return v10;
}
else
{
*a3 = 0;
return 0LL;
}
}
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV qword ptr [RBP + -0x88],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0x102010]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[0x102016]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x10201c]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[0x102021]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x102029]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x102030]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x102037]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x68],0xffffffff
MOV dword ptr [RBP + -0x64],0xffffffff
MOV dword ptr [RBP + -0x60],0x0
JMP 0x001012af
LAB_00101265:
MOV EAX,dword ptr [RBP + -0x60]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x50]
MOV RDX,qword ptr [RBP + -0x78]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x00101288
MOV EAX,dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x68],EAX
LAB_00101288:
MOV EAX,dword ptr [RBP + -0x60]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x50]
MOV RDX,qword ptr [RBP + -0x80]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010c0
TEST EAX,EAX
JNZ 0x001012ab
MOV EAX,dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x64],EAX
LAB_001012ab:
ADD dword ptr [RBP + -0x60],0x1
LAB_001012af:
CMP dword ptr [RBP + -0x60],0x7
JLE 0x00101265
CMP dword ptr [RBP + -0x68],-0x1
JZ 0x001012c9
CMP dword ptr [RBP + -0x64],-0x1
JZ 0x001012c9
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,dword ptr [RBP + -0x64]
JNZ 0x001012e0
LAB_001012c9:
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX],0x0
MOV EAX,0x0
JMP 0x00101387
LAB_001012e0:
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,dword ptr [RBP + -0x64]
JLE 0x001012fa
MOV EAX,dword ptr [RBP + -0x68]
MOV dword ptr [RBP + -0x5c],EAX
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x68],EAX
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x64],EAX
LAB_001012fa:
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,dword ptr [RBP + -0x68]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JG 0x0010132d
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX],0x0
MOV EAX,0x0
JMP 0x00101387
LAB_0010132d:
MOV RAX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x68]
ADD EAX,0x1
MOV dword ptr [RBP + -0x60],EAX
JMP 0x0010137b
LAB_00101353:
MOV EAX,dword ptr [RBP + -0x60]
SUB EAX,dword ptr [RBP + -0x68]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x58]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x60]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x50]
MOV qword ptr [RDX],RAX
ADD dword ptr [RBP + -0x60],0x1
LAB_0010137b:
MOV EAX,dword ptr [RBP + -0x60]
CMP EAX,dword ptr [RBP + -0x64]
JL 0x00101353
MOV RAX,qword ptr [RBP + -0x58]
LAB_00101387:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010139b
CALL 0x001010a0
LAB_0010139b:
LEAVE
RET
|
void * func0(char *param_1,char *param_2,int *param_3)
{
int iVar1;
void *pvVar2;
long in_FS_OFFSET;
int local_70;
int local_6c;
int local_68;
char *local_58 [4];
char *local_38;
char *local_30;
char *local_28;
char *local_20;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_58[0] = "Mercury";
local_58[1] = "Venus";
local_58[2] = "Earth";
local_58[3] = "Mars";
local_38 = "Jupiter";
local_30 = "Saturn";
local_28 = "Uranus";
local_20 = "Neptune";
local_70 = -1;
local_6c = -1;
for (local_68 = 0; iVar1 = local_70, local_68 < 8; local_68 = local_68 + 1) {
iVar1 = strcmp(local_58[local_68],param_1);
if (iVar1 == 0) {
local_70 = local_68;
}
iVar1 = strcmp(local_58[local_68],param_2);
if (iVar1 == 0) {
local_6c = local_68;
}
}
if (((local_70 == -1) || (local_6c == -1)) || (local_70 == local_6c)) {
*param_3 = 0;
pvVar2 = (void *)0x0;
}
else {
if (local_6c < local_70) {
local_70 = local_6c;
local_6c = iVar1;
}
*param_3 = (local_6c - local_70) + -1;
if (*param_3 < 1) {
*param_3 = 0;
pvVar2 = (void *)0x0;
}
else {
pvVar2 = malloc((long)*param_3 << 3);
local_68 = local_70;
while (local_68 = local_68 + 1, local_68 < local_6c) {
*(char **)((long)(local_68 - local_70) * 8 + -8 + (long)pvVar2) = local_58[local_68];
}
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return pvVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,249 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp(planets[m], planet2) == 0) pos2 = m;
}
if (pos1 == -1 || pos2 == -1 || pos1 == pos2) {
*returnSize = 0;
return NULL;
}
if (pos1 > pos2) { int temp = pos1; pos1 = pos2; pos2 = temp; }
*returnSize = pos2 - pos1 - 1;
if (*returnSize <= 0) {
*returnSize = 0;
return NULL;
}
char** out = malloc(*returnSize * sizeof(char*));
for (m = pos1 + 1; m < pos2; m++) {
out[m - pos1 - 1] = (char*)planets[m];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char** result;
const char* test1[] = {"Saturn", "Uranus"};
result = func0("Jupiter", "Neptune", &size);
assert(issame(result, test1, size, 2));
free(result);
const char* test2[] = {"Venus"};
result = func0("Earth", "Mercury", &size);
assert(issame(result, test2, size, 1));
free(result);
const char* test3[] = {"Venus", "Earth", "Mars", "Jupiter", "Saturn"};
result = func0("Mercury", "Uranus", &size);
assert(issame(result, test3, size, 5));
free(result);
const char* test4[] = {"Earth", "Mars", "Jupiter", "Saturn", "Uranus"};
result = func0("Neptune", "Venus", &size);
assert(issame(result, test4, size, 5));
free(result);
result = func0("Earth", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Mars", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Jupiter", "Makemake", &size);
assert(size == 0 && result == NULL);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%r15
mov %rsi,(%rsp)
mov %rdx,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xe06(%rip),%rax
mov %rax,0x10(%rsp)
lea 0xe02(%rip),%rax
mov %rax,0x18(%rsp)
lea 0xdfc(%rip),%rax
mov %rax,0x20(%rsp)
lea 0xdf6(%rip),%rax
mov %rax,0x28(%rsp)
lea 0xdef(%rip),%rax
mov %rax,0x30(%rsp)
lea 0xdeb(%rip),%rax
mov %rax,0x38(%rsp)
lea 0xde6(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xde1(%rip),%rax
mov %rax,0x48(%rsp)
mov $0x0,%ebx
mov $0xffffffff,%ebp
mov $0xffffffff,%r13d
mov 0x10(%rsp,%rbx,8),%r12
mov %r15,%rsi
mov %r12,%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
cmove %ebx,%r13d
mov (%rsp),%rsi
mov %r12,%rdi
callq 10c0 <strcmp@plt>
test %eax,%eax
cmove %ebx,%ebp
add $0x1,%rbx
cmp $0x8,%rbx
jne 1267 <func0+0x9e>
cmp $0xffffffff,%r13d
sete %dl
cmp $0xffffffff,%ebp
sete %al
or %al,%dl
jne 132d <func0+0x164>
cmp %ebp,%r13d
je 132d <func0+0x164>
jle 12bc <func0+0xf3>
mov %r13d,%eax
mov %ebp,%r13d
mov %eax,%ebp
mov %ebp,%eax
sub %r13d,%eax
sub $0x1,%eax
mov 0x8(%rsp),%rcx
mov %eax,(%rcx)
test %eax,%eax
jle 133f <func0+0x176>
cltq
lea 0x0(,%rax,8),%rdi
callq 10d0 <malloc@plt>
lea 0x1(%r13),%edx
cmp %edx,%ebp
jle 130e <func0+0x145>
sub $0x2,%ebp
sub %r13d,%ebp
movslq %r13d,%r13
lea 0x10(%rsp,%r13,8),%rsi
mov $0x0,%edx
mov 0x8(%rsi,%rdx,8),%rcx
mov %rcx,(%rax,%rdx,8)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rbp,%rcx
jne 12f9 <func0+0x130>
mov 0x58(%rsp),%rcx
xor %fs:0x28,%rcx
jne 134c <func0+0x183>
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov 0x8(%rsp),%rax
movl $0x0,(%rax)
mov $0x0,%eax
jmp 130e <func0+0x145>
movl $0x0,(%rcx)
mov $0x0,%eax
jmp 130e <func0+0x145>
callq 10a0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov r15, rdi
mov [rsp+98h+s2], rsi
mov [rsp+98h+var_90], rdx
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea rax, aMercury; "Mercury"
mov [rsp+98h+s1], rax
lea rax, aVenus; "Venus"
mov [rsp+98h+var_80], rax
lea rax, aEarth; "Earth"
mov [rsp+98h+var_78], rax
lea rax, aMars; "Mars"
mov [rsp+98h+var_70], rax
lea rax, s2; "Jupiter"
mov [rsp+98h+var_68], rax
lea rax, aSaturn; "Saturn"
mov [rsp+98h+var_60], rax
lea rax, aUranus; "Uranus"
mov [rsp+98h+var_58], rax
lea rax, aNeptune; "Neptune"
mov [rsp+98h+var_50], rax
mov ebx, 0
mov r13d, 0FFFFFFFFh
mov ebp, 0FFFFFFFFh
loc_1267:
mov r12, [rsp+rbx*8+98h+s1]
mov rsi, r15; s2
mov rdi, r12; s1
call _strcmp
test eax, eax
cmovz ebp, ebx
mov rsi, [rsp+98h+s2]; s2
mov rdi, r12; s1
call _strcmp
test eax, eax
cmovz r13d, ebx
add rbx, 1
cmp rbx, 8
jnz short loc_1267
cmp r13d, 0FFFFFFFFh
setz al
cmp ebp, r13d
setz dl
or al, dl
jnz loc_1330
cmp ebp, 0FFFFFFFFh
jz short loc_1330
cmp ebp, r13d
jg short loc_12BF
mov eax, r13d
mov r13d, ebp
mov ebp, eax
loc_12BF:
mov eax, ebp
sub eax, r13d
sub eax, 1
mov rcx, [rsp+98h+var_90]
mov [rcx], eax
test eax, eax
jle short loc_1342
cdqe
lea rdi, ds:0[rax*8]; size
call _malloc
lea edx, [r13+1]
cmp ebp, edx
jle short loc_1311
sub ebp, 2
sub ebp, r13d
movsxd r13, r13d
lea rsi, [rsp+r13*8+98h+s1]
mov edx, 0
loc_12FC:
mov rcx, [rsi+rdx*8+8]
mov [rax+rdx*8], rcx
mov rcx, rdx
add rdx, 1
cmp rcx, rbp
jnz short loc_12FC
loc_1311:
mov rdx, [rsp+98h+var_40]
sub rdx, fs:28h
jnz short loc_134F
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1330:
mov rax, [rsp+98h+var_90]
mov dword ptr [rax], 0
mov eax, 0
jmp short loc_1311
loc_1342:
mov dword ptr [rcx], 0
mov eax, 0
jmp short loc_1311
loc_134F:
call ___stack_chk_fail
|
_QWORD * func0(char *s2, const char *a2, int *a3)
{
long long v3; // rbx
int v4; // r13d
int v5; // ebp
const char *v6; // r12
int v7; // eax
int v8; // eax
_QWORD *result; // rax
int v10; // ebp
long long v11; // rdx
long long v12; // rcx
char *s1[17]; // [rsp+10h] [rbp-88h] BYREF
s1[9] = (char *)__readfsqword(0x28u);
s1[0] = "Mercury";
s1[1] = "Venus";
s1[2] = "Earth";
s1[3] = "Mars";
s1[4] = "Jupiter";
s1[5] = "Saturn";
s1[6] = "Uranus";
s1[7] = "Neptune";
v3 = 0LL;
v4 = -1;
v5 = -1;
do
{
v6 = s1[v3];
if ( !strcmp(v6, s2) )
v5 = v3;
if ( !strcmp(v6, a2) )
v4 = v3;
++v3;
}
while ( v3 != 8 );
if ( v5 == v4 || v4 == -1 || v5 == -1 )
{
*a3 = 0;
return 0LL;
}
else
{
if ( v5 <= v4 )
{
v7 = v4;
v4 = v5;
v5 = v7;
}
v8 = v5 - v4 - 1;
*a3 = v8;
if ( v8 <= 0 )
{
*a3 = 0;
return 0LL;
}
else
{
result = malloc(8LL * v8);
if ( v5 > v4 + 1 )
{
v10 = v5 - 2 - v4;
v11 = 0LL;
do
{
result[v11] = (&s1[v4])[v11 + 1];
v12 = v11++;
}
while ( v12 != v10 );
}
}
}
return result;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV R15,RDI
MOV qword ptr [RSP],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[0x10200c]
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[0x102012]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[0x102018]
MOV qword ptr [RSP + 0x28],RAX
LEA RAX,[0x10201d]
MOV qword ptr [RSP + 0x30],RAX
LEA RAX,[0x102025]
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[0x10202c]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x102033]
MOV qword ptr [RSP + 0x48],RAX
MOV EBX,0x0
MOV R13D,0xffffffff
MOV EBP,0xffffffff
LAB_00101267:
MOV R12,qword ptr [RSP + RBX*0x8 + 0x10]
MOV RSI,R15
MOV RDI,R12
CALL 0x001010c0
TEST EAX,EAX
CMOVZ EBP,EBX
MOV RSI,qword ptr [RSP]
MOV RDI,R12
CALL 0x001010c0
TEST EAX,EAX
CMOVZ R13D,EBX
ADD RBX,0x1
CMP RBX,0x8
JNZ 0x00101267
CMP R13D,-0x1
SETZ AL
CMP EBP,R13D
SETZ DL
OR AL,DL
JNZ 0x00101330
CMP EBP,-0x1
JZ 0x00101330
CMP EBP,R13D
JG 0x001012bf
MOV EAX,R13D
MOV R13D,EBP
MOV EBP,EAX
LAB_001012bf:
MOV EAX,EBP
SUB EAX,R13D
SUB EAX,0x1
MOV RCX,qword ptr [RSP + 0x8]
MOV dword ptr [RCX],EAX
TEST EAX,EAX
JLE 0x00101342
CDQE
LEA RDI,[RAX*0x8]
CALL 0x001010d0
LEA EDX,[R13 + 0x1]
CMP EBP,EDX
JLE 0x00101311
SUB EBP,0x2
SUB EBP,R13D
MOVSXD R13,R13D
LEA RSI,[RSP + R13*0x8 + 0x10]
MOV EDX,0x0
LAB_001012fc:
MOV RCX,qword ptr [RSI + RDX*0x8 + 0x8]
MOV qword ptr [RAX + RDX*0x8],RCX
MOV RCX,RDX
ADD RDX,0x1
CMP RCX,RBP
JNZ 0x001012fc
LAB_00101311:
MOV RDX,qword ptr [RSP + 0x58]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010134f
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101330:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],0x0
MOV EAX,0x0
JMP 0x00101311
LAB_00101342:
MOV dword ptr [RCX],0x0
MOV EAX,0x0
JMP 0x00101311
LAB_0010134f:
CALL 0x001010a0
|
void * func0(char *param_1,char *param_2,int *param_3)
{
char *__s1;
int iVar1;
int iVar2;
void *pvVar3;
ulong uVar4;
ulong uVar5;
int iVar6;
ulong uVar7;
long in_FS_OFFSET;
bool bVar8;
char *local_88 [9];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "Mercury";
local_88[1] = "Venus";
local_88[2] = "Earth";
local_88[3] = "Mars";
local_88[4] = "Jupiter";
local_88[5] = "Saturn";
local_88[6] = "Uranus";
local_88[7] = "Neptune";
uVar4 = 0;
uVar7 = 0xffffffff;
uVar5 = 0xffffffff;
do {
__s1 = local_88[uVar4];
iVar1 = strcmp(__s1,param_1);
if (iVar1 == 0) {
uVar5 = uVar4 & 0xffffffff;
}
iVar1 = (int)uVar5;
iVar2 = strcmp(__s1,param_2);
if (iVar2 == 0) {
uVar7 = uVar4 & 0xffffffff;
}
iVar2 = (int)uVar7;
uVar4 = uVar4 + 1;
} while (uVar4 != 8);
if ((iVar2 == -1 || iVar1 == iVar2) || (iVar1 == -1)) {
*param_3 = 0;
pvVar3 = (void *)0x0;
}
else {
iVar6 = iVar2;
if (iVar1 <= iVar2) {
iVar6 = iVar1;
iVar1 = iVar2;
}
iVar2 = (iVar1 - iVar6) + -1;
*param_3 = iVar2;
if (iVar2 < 1) {
*param_3 = 0;
pvVar3 = (void *)0x0;
}
else {
pvVar3 = malloc((long)iVar2 * 8);
if (iVar6 + 1 < iVar1) {
uVar4 = 0;
do {
*(char **)((long)pvVar3 + uVar4 * 8) = local_88[(long)iVar6 + uVar4 + 1];
bVar8 = uVar4 != (uint)((iVar1 + -2) - iVar6);
uVar4 = uVar4 + 1;
} while (bVar8);
}
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return pvVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,250 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp(planets[m], planet2) == 0) pos2 = m;
}
if (pos1 == -1 || pos2 == -1 || pos1 == pos2) {
*returnSize = 0;
return NULL;
}
if (pos1 > pos2) { int temp = pos1; pos1 = pos2; pos2 = temp; }
*returnSize = pos2 - pos1 - 1;
if (*returnSize <= 0) {
*returnSize = 0;
return NULL;
}
char** out = malloc(*returnSize * sizeof(char*));
for (m = pos1 + 1; m < pos2; m++) {
out[m - pos1 - 1] = (char*)planets[m];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char** result;
const char* test1[] = {"Saturn", "Uranus"};
result = func0("Jupiter", "Neptune", &size);
assert(issame(result, test1, size, 2));
free(result);
const char* test2[] = {"Venus"};
result = func0("Earth", "Mercury", &size);
assert(issame(result, test2, size, 1));
free(result);
const char* test3[] = {"Venus", "Earth", "Mars", "Jupiter", "Saturn"};
result = func0("Mercury", "Uranus", &size);
assert(issame(result, test3, size, 5));
free(result);
const char* test4[] = {"Earth", "Mars", "Jupiter", "Saturn", "Uranus"};
result = func0("Neptune", "Venus", &size);
assert(issame(result, test4, size, 5));
free(result);
result = func0("Earth", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Mars", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Jupiter", "Makemake", &size);
assert(size == 0 && result == NULL);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
mov $0xffffffff,%r15d
push %r14
mov %rdi,%r14
lea 0xa6c(%rip),%rdi
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov $0xffffffff,%ebp
push %rbx
xor %ebx,%ebx
sub $0x68,%rsp
mov %rdx,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xa44(%rip),%rax
mov %rdi,0x10(%rsp)
mov %rax,0x18(%rsp)
lea 0xa39(%rip),%rax
mov %rax,0x20(%rsp)
lea 0xa33(%rip),%rax
mov %rax,0x28(%rsp)
lea 0xa2c(%rip),%rax
mov %rax,0x30(%rsp)
lea 0xa28(%rip),%rax
mov %rax,0x38(%rsp)
lea 0xa23(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xa1e(%rip),%rax
mov %rax,0x48(%rsp)
jmp 1625 <func0+0xa5>
nopl 0x0(%rax)
mov 0x10(%rsp,%rbx,8),%rdi
mov %r14,%rsi
mov %rdi,(%rsp)
callq 10c0 <strcmp@plt>
mov (%rsp),%rdi
mov %r13,%rsi
test %eax,%eax
cmove %ebx,%ebp
callq 10c0 <strcmp@plt>
test %eax,%eax
cmove %ebx,%r15d
add $0x1,%rbx
cmp $0x8,%rbx
jne 1620 <func0+0xa0>
cmp $0xffffffff,%ebp
sete %cl
cmp $0xffffffff,%r15d
sete %al
or %al,%cl
jne 16f8 <func0+0x178>
cmp %r15d,%ebp
je 16f8 <func0+0x178>
jg 16e8 <func0+0x168>
mov %r15d,%eax
mov 0x8(%rsp),%rdx
sub %ebp,%eax
sub $0x1,%eax
mov %eax,(%rdx)
test %eax,%eax
jle 16f8 <func0+0x178>
cltq
lea 0x0(,%rax,8),%rdi
callq 10d0 <malloc@plt>
lea 0x1(%rbp),%ecx
cmp %ecx,%r15d
jle 16c2 <func0+0x142>
movslq %ebp,%rbp
movslq %ecx,%rcx
lea 0x10(%rsp),%rdi
neg %rbp
lea (%rax,%rbp,8),%r8
xchg %ax,%ax
mov (%rdi,%rcx,8),%rsi
mov %rsi,-0x8(%r8,%rcx,8)
add $0x1,%rcx
cmp %ecx,%r15d
jg 16b0 <func0+0x130>
mov 0x58(%rsp),%rdx
xor %fs:0x28,%rdx
jne 1707 <func0+0x187>
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %ebp,%eax
mov %r15d,%ebp
mov %eax,%r15d
jmp 1672 <func0+0xf2>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rax
movl $0x0,(%rax)
xor %eax,%eax
jmp 16c2 <func0+0x142>
callq 10a0 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
func0:
endbr64
push r15
lea rcx, aMercury; "Mercury"
mov r15d, 0FFFFFFFFh
push r14
movq xmm0, rcx
lea rcx, aEarth; "Earth"
push r13
push r12
xor r12d, r12d
push rbp
push rbx
mov ebx, 0FFFFFFFFh
sub rsp, 78h
mov [rsp+0A8h+s2], rdi
lea r14, [rsp+0A8h+var_88]
mov [rsp+0A8h+var_98], rsi
mov [rsp+0A8h+var_90], rdx
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
lea rax, aVenus; "Venus"
movq xmm1, rax
lea rax, aMars; "Mars"
punpcklqdq xmm0, xmm1
movq xmm2, rax
lea rax, aSaturn; "Saturn"
movaps [rsp+0A8h+var_88], xmm0
movq xmm0, rcx
movq xmm3, rax
lea rcx, aJupiter; "Jupiter"
punpcklqdq xmm0, xmm2
lea rax, aNeptune; "Neptune"
movaps [rsp+0A8h+var_78], xmm0
movq xmm0, rcx
movq xmm4, rax
lea rcx, aUranus; "Uranus"
punpcklqdq xmm0, xmm3
movaps [rsp+0A8h+var_68], xmm0
movq xmm0, rcx
punpcklqdq xmm0, xmm4
movaps [rsp+0A8h+var_58], xmm0
nop word ptr [rax+rax+00000000h]
loc_1670:
mov r13, [r14+r12*8]
mov rsi, [rsp+0A8h+s2]; s2
mov rdi, r13; s1
call _strcmp
mov rsi, [rsp+0A8h+var_98]; s2
mov rdi, r13; s1
test eax, eax
cmovz ebx, r12d
call _strcmp
test eax, eax
cmovz r15d, r12d
add r12, 1
cmp r12, 8
jnz short loc_1670
cmp ebx, r15d
setz al
cmp r15d, 0FFFFFFFFh
setz dl
or al, dl
jnz loc_1748
cmp ebx, 0FFFFFFFFh
jz loc_1748
cmp ebx, r15d
jle short loc_1738
loc_16C7:
mov eax, ebx
mov rdx, [rsp+0A8h+var_90]
sub eax, r15d
sub eax, 1
mov [rdx], eax
test eax, eax
jle short loc_1748
cdqe
lea rdi, ds:0[rax*8]; size
call _malloc
mov rdi, rax; dest
lea eax, [r15+1]
cmp ebx, eax
jle short loc_1710
sub ebx, 2
cdqe
sub ebx, r15d
lea rsi, [r14+rax*8]; src
lea rdx, ds:8[rbx*8]; n
call _memcpy
mov rdi, rax
loc_1710:
mov rax, [rsp+0A8h+var_40]
sub rax, fs:28h
jnz short loc_1757
add rsp, 78h
mov rax, rdi
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1738:
mov eax, r15d
mov r15d, ebx
mov ebx, eax
jmp short loc_16C7
loc_1748:
mov rax, [rsp+0A8h+var_90]
xor edi, edi
mov dword ptr [rax], 0
jmp short loc_1710
loc_1757:
call ___stack_chk_fail
|
void * func0(const char *a1, const char *a2, int *a3)
{
int v3; // r15d
long long v4; // r12
int v5; // ebx
const char *v6; // rdi
int v7; // eax
void *v8; // rdi
int v10; // eax
_OWORD v13[4]; // [rsp+18h] [rbp-88h] BYREF
unsigned long long v14; // [rsp+60h] [rbp-40h]
v3 = -1;
v4 = 0LL;
v5 = -1;
v14 = __readfsqword(0x28u);
v13[0] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Mercury", (__m128i)(unsigned long long)"Venus");
v13[1] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Earth", (__m128i)(unsigned long long)"Mars");
v13[2] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Jupiter", (__m128i)(unsigned long long)"Saturn");
v13[3] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"Uranus", (__m128i)(unsigned long long)"Neptune");
do
{
v6 = (const char *)*((_QWORD *)v13 + v4);
if ( !strcmp(v6, a1) )
v5 = v4;
if ( !strcmp(v6, a2) )
v3 = v4;
++v4;
}
while ( v4 != 8 );
if ( v3 == -1 || v5 == v3 || v5 == -1 )
goto LABEL_15;
if ( v5 <= v3 )
{
v10 = v3;
v3 = v5;
v5 = v10;
}
v7 = v5 - v3 - 1;
*a3 = v7;
if ( v7 <= 0 )
{
LABEL_15:
v8 = 0LL;
*a3 = 0;
}
else
{
v8 = malloc(8LL * v7);
if ( v5 > v3 + 1 )
return memcpy(v8, (char *)v13 + 8 * v3 + 8, 8LL * (unsigned int)(v5 - 2 - v3) + 8);
}
return v8;
}
|
func0:
ENDBR64
PUSH R15
LEA RCX,[0x102004]
MOV R15D,0xffffffff
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x102012]
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
MOV EBX,0xffffffff
SUB RSP,0x78
MOV qword ptr [RSP + 0x8],RDI
LEA R14,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
LEA RAX,[0x10200c]
MOVQ XMM1,RAX
LEA RAX,[0x102018]
PUNPCKLQDQ XMM0,XMM1
MOVQ XMM2,RAX
LEA RAX,[0x102025]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVQ XMM0,RCX
MOVQ XMM3,RAX
LEA RCX,[0x10201d]
PUNPCKLQDQ XMM0,XMM2
LEA RAX,[0x102033]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVQ XMM0,RCX
MOVQ XMM4,RAX
LEA RCX,[0x10202c]
PUNPCKLQDQ XMM0,XMM3
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVQ XMM0,RCX
PUNPCKLQDQ XMM0,XMM4
MOVAPS xmmword ptr [RSP + 0x50],XMM0
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101670:
MOV R13,qword ptr [R14 + R12*0x8]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,R13
CALL 0x001010d0
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,R13
TEST EAX,EAX
CMOVZ EBX,R12D
CALL 0x001010d0
TEST EAX,EAX
CMOVZ R15D,R12D
ADD R12,0x1
CMP R12,0x8
JNZ 0x00101670
CMP EBX,R15D
SETZ AL
CMP R15D,-0x1
SETZ DL
OR AL,DL
JNZ 0x00101748
CMP EBX,-0x1
JZ 0x00101748
CMP EBX,R15D
JLE 0x00101738
LAB_001016c7:
MOV EAX,EBX
MOV RDX,qword ptr [RSP + 0x18]
SUB EAX,R15D
SUB EAX,0x1
MOV dword ptr [RDX],EAX
TEST EAX,EAX
JLE 0x00101748
CDQE
LEA RDI,[RAX*0x8]
CALL 0x001010f0
MOV RDI,RAX
LEA EAX,[R15 + 0x1]
CMP EBX,EAX
JLE 0x00101710
SUB EBX,0x2
CDQE
SUB EBX,R15D
LEA RSI,[R14 + RAX*0x8]
LEA RDX,[0x8 + RBX*0x8]
CALL 0x001010e0
MOV RDI,RAX
LAB_00101710:
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101757
ADD RSP,0x78
MOV RAX,RDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101738:
MOV EAX,R15D
MOV R15D,EBX
MOV EBX,EAX
JMP 0x001016c7
LAB_00101748:
MOV RAX,qword ptr [RSP + 0x18]
XOR EDI,EDI
MOV dword ptr [RAX],0x0
JMP 0x00101710
LAB_00101757:
CALL 0x001010b0
|
void * func0(char *param_1,char *param_2,int *param_3)
{
char *__s1;
int iVar1;
int iVar2;
void *__dest;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
long in_FS_OFFSET;
char *local_88 [9];
long local_40;
uVar6 = 0xffffffff;
uVar4 = 0;
uVar3 = 0xffffffff;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "Mercury";
local_88[1] = "Venus";
local_88[2] = "Earth";
local_88[3] = "Mars";
local_88[4] = "Jupiter";
local_88[5] = "Saturn";
local_88[6] = "Uranus";
local_88[7] = "Neptune";
do {
__s1 = local_88[uVar4];
iVar1 = strcmp(__s1,param_1);
if (iVar1 == 0) {
uVar3 = uVar4 & 0xffffffff;
}
iVar1 = (int)uVar3;
iVar2 = strcmp(__s1,param_2);
if (iVar2 == 0) {
uVar6 = uVar4 & 0xffffffff;
}
iVar2 = (int)uVar6;
uVar4 = uVar4 + 1;
} while (uVar4 != 8);
if ((iVar1 != iVar2 && iVar2 != -1) && (iVar1 != -1)) {
iVar5 = iVar2;
if (iVar1 <= iVar2) {
iVar5 = iVar1;
iVar1 = iVar2;
}
iVar2 = (iVar1 - iVar5) + -1;
*param_3 = iVar2;
if (0 < iVar2) {
__dest = malloc((long)iVar2 * 8);
if (iVar5 + 1 < iVar1) {
__dest = memcpy(__dest,local_88 + (iVar5 + 1),(ulong)(uint)((iVar1 + -2) - iVar5) * 8 + 8);
}
goto LAB_00101710;
}
}
__dest = (void *)0x0;
*param_3 = 0;
LAB_00101710:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return __dest;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,251 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
char** func0(const char* planet1, const char* planet2, int* returnSize) {
const char* planets[] = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
int pos1 = -1, pos2 = -1, m;
for (m = 0; m < 8; m++) {
if (strcmp(planets[m], planet1) == 0) pos1 = m;
if (strcmp(planets[m], planet2) == 0) pos2 = m;
}
if (pos1 == -1 || pos2 == -1 || pos1 == pos2) {
*returnSize = 0;
return NULL;
}
if (pos1 > pos2) { int temp = pos1; pos1 = pos2; pos2 = temp; }
*returnSize = pos2 - pos1 - 1;
if (*returnSize <= 0) {
*returnSize = 0;
return NULL;
}
char** out = malloc(*returnSize * sizeof(char*));
for (m = pos1 + 1; m < pos2; m++) {
out[m - pos1 - 1] = (char*)planets[m];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char** a, const char** b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char** result;
const char* test1[] = {"Saturn", "Uranus"};
result = func0("Jupiter", "Neptune", &size);
assert(issame(result, test1, size, 2));
free(result);
const char* test2[] = {"Venus"};
result = func0("Earth", "Mercury", &size);
assert(issame(result, test2, size, 1));
free(result);
const char* test3[] = {"Venus", "Earth", "Mars", "Jupiter", "Saturn"};
result = func0("Mercury", "Uranus", &size);
assert(issame(result, test3, size, 5));
free(result);
const char* test4[] = {"Earth", "Mars", "Jupiter", "Saturn", "Uranus"};
result = func0("Neptune", "Venus", &size);
assert(issame(result, test4, size, 5));
free(result);
result = func0("Earth", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Mars", "Earth", &size);
assert(size == 0 && result == NULL);
result = func0("Jupiter", "Makemake", &size);
assert(size == 0 && result == NULL);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
lea 0xa47(%rip),%rcx
mov $0x1,%r15d
push %r14
movq %rcx,%xmm0
lea 0xa41(%rip),%rcx
mov %rdx,%r14
push %r13
lea 0xa4f(%rip),%rdx
mov %rsi,%r13
mov %rdi,%rsi
push %r12
mov %rdi,%r12
push %rbp
push %rbx
xor %ebx,%ebx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0xa05(%rip),%rax
movq %rax,%xmm1
lea 0xa05(%rip),%rax
punpcklqdq %xmm1,%xmm0
movq %rax,%xmm2
lea 0xa02(%rip),%rax
movq %xmm0,%rbp
movaps %xmm0,0x10(%rsp)
movq %rcx,%xmm0
lea 0x9e4(%rip),%rcx
punpcklqdq %xmm2,%xmm0
movq %rax,%xmm3
lea 0x9ea(%rip),%rax
mov %rbp,%rdi
movaps %xmm0,0x20(%rsp)
movq %rcx,%xmm0
movq %rax,%xmm4
punpcklqdq %xmm3,%xmm0
movaps %xmm0,0x30(%rsp)
movq %rdx,%xmm0
punpcklqdq %xmm4,%xmm0
movaps %xmm0,0x40(%rsp)
callq 10d0 <strcmp@plt>
mov %rbp,%rdi
mov %r13,%rsi
test %eax,%eax
setne %bl
xor %ebp,%ebp
callq 10d0 <strcmp@plt>
mov 0x18(%rsp),%rdi
neg %ebx
mov %r12,%rsi
test %eax,%eax
setne %bpl
mov %rdi,0x8(%rsp)
callq 10d0 <strcmp@plt>
mov 0x8(%rsp),%rdi
neg %ebp
mov %r13,%rsi
test %eax,%eax
cmove %r15d,%ebx
callq 10d0 <strcmp@plt>
mov 0x20(%rsp),%rdi
mov %r12,%rsi
test %eax,%eax
cmove %r15d,%ebp
mov %rdi,0x8(%rsp)
mov $0x2,%r15d
callq 10d0 <strcmp@plt>
mov 0x8(%rsp),%rdi
mov %r13,%rsi
test %eax,%eax
cmove %r15d,%ebx
callq 10d0 <strcmp@plt>
mov 0x28(%rsp),%rdi
mov %r12,%rsi
test %eax,%eax
cmove %r15d,%ebp
mov %rdi,0x8(%rsp)
mov $0x3,%r15d
callq 10d0 <strcmp@plt>
mov 0x8(%rsp),%rdi
mov %r13,%rsi
test %eax,%eax
cmove %r15d,%ebx
callq 10d0 <strcmp@plt>
mov 0x30(%rsp),%rdi
mov %r12,%rsi
test %eax,%eax
cmove %r15d,%ebp
mov %rdi,0x8(%rsp)
mov $0x4,%r15d
callq 10d0 <strcmp@plt>
mov 0x8(%rsp),%rdi
mov %r13,%rsi
test %eax,%eax
cmove %r15d,%ebx
callq 10d0 <strcmp@plt>
mov 0x38(%rsp),%rdi
mov %r12,%rsi
test %eax,%eax
cmove %r15d,%ebp
mov %rdi,0x8(%rsp)
mov $0x5,%r15d
callq 10d0 <strcmp@plt>
mov 0x8(%rsp),%rdi
mov %r13,%rsi
test %eax,%eax
cmove %r15d,%ebx
callq 10d0 <strcmp@plt>
mov 0x40(%rsp),%rdi
mov %r12,%rsi
test %eax,%eax
cmove %r15d,%ebp
mov %rdi,0x8(%rsp)
mov $0x6,%r15d
callq 10d0 <strcmp@plt>
mov 0x8(%rsp),%rdi
mov %r13,%rsi
test %eax,%eax
cmove %r15d,%ebx
callq 10d0 <strcmp@plt>
mov %r12,%rsi
test %eax,%eax
cmove %r15d,%ebp
mov 0x48(%rsp),%r15
mov %r15,%rdi
callq 10d0 <strcmp@plt>
mov %r13,%rsi
mov %r15,%rdi
test %eax,%eax
je 1870 <func0+0x2c0>
callq 10d0 <strcmp@plt>
test %eax,%eax
jne 18c0 <func0+0x310>
cmp $0x7,%ebx
je 18af <func0+0x2ff>
cmp $0xffffffff,%ebx
je 18af <func0+0x2ff>
mov $0x7,%r12d
mov %r12d,%eax
sub %ebx,%eax
sub $0x1,%eax
mov %eax,(%r14)
test %eax,%eax
jle 18af <func0+0x2ff>
cltq
lea 0x0(,%rax,8),%rdi
callq 10f0 <malloc@plt>
mov %rax,%r8
lea 0x1(%rbx),%eax
cmp %eax,%r12d
jle 1844 <func0+0x294>
sub $0x2,%r12d
cltq
mov %r8,%rdi
sub %ebx,%r12d
lea 0x10(%rsp,%rax,8),%rsi
lea 0x8(,%r12,8),%rdx
callq 10e0 <memcpy@plt>
mov %rax,%r8
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 18c5 <func0+0x315>
add $0x68,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
callq 10d0 <strcmp@plt>
mov $0x7,%r12d
test %eax,%eax
je 18af <func0+0x2ff>
cmp $0xffffffff,%ebp
sete %dl
cmp %r12d,%ebp
sete %al
or %al,%dl
jne 18af <func0+0x2ff>
cmp $0xffffffff,%r12d
je 18af <func0+0x2ff>
cmp %r12d,%ebp
jge 18ca <func0+0x31a>
mov %ebp,%ebx
mov %r12d,%eax
sub %ebx,%eax
sub $0x1,%eax
mov %eax,(%r14)
test %eax,%eax
jg 1809 <func0+0x259>
movl $0x0,(%r14)
xor %r8d,%r8d
jmp 1844 <func0+0x294>
nopl 0x0(%rax,%rax,1)
mov %ebx,%r12d
jmp 187f <func0+0x2cf>
callq 10b0 <__stack_chk_fail@plt>
mov %r12d,%ebx
mov %ebp,%r12d
jmpq 17f6 <func0+0x246>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
lea r15, aEarth; "Earth"
push r14
lea r14, s2; "Jupiter"
push r13
lea r13, s1; "Mercury"
push r12
movq xmm0, r13
mov r12, rdi
push rbp
mov rbp, rsi
mov rsi, rdi; s2
mov rdi, r13; s1
push rbx
xor ebx, ebx
sub rsp, 68h
mov [rsp+98h+var_90], rdx
movhps xmm0, cs:off_3D70; "Venus"
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
movaps [rsp+98h+src], xmm0
movq xmm0, r15
movhps xmm0, cs:off_3D78; "Mars"
movaps [rsp+98h+var_78], xmm0
movq xmm0, r14
movhps xmm0, cs:off_3D80; "Saturn"
movaps [rsp+98h+var_68], xmm0
movq xmm0, cs:off_3D88; "Uranus"
movhps xmm0, cs:off_3D90; "Neptune"
movaps [rsp+98h+var_58], xmm0
call _strcmp
mov rdi, r13; s1
mov rsi, rbp; s2
mov r13d, 1
test eax, eax
setnz bl
call _strcmp
mov rsi, r12; s2
lea rdi, aVenus; "Venus"
test eax, eax
setnz al
neg ebx
movzx eax, al
mov [rsp+98h+var_94], eax
call _strcmp
mov rsi, rbp; s2
lea rdi, aVenus; "Venus"
test eax, eax
cmovz ebx, r13d
call _strcmp
mov edx, [rsp+98h+var_94]
mov rdi, r15; s1
mov rsi, r12; s2
neg edx
test eax, eax
cmovnz r13d, edx
call _strcmp
mov r8d, 2
mov rdi, r15; s1
mov rsi, rbp; s2
test eax, eax
mov r15d, 3
cmovz ebx, r8d
call _strcmp
mov r8d, 2
mov rsi, r12; s2
test eax, eax
lea rdi, aMars; "Mars"
cmovz r13d, r8d
call _strcmp
mov rsi, rbp; s2
lea rdi, aMars; "Mars"
test eax, eax
cmovz ebx, r15d
call _strcmp
mov rdi, r14; s1
mov rsi, r12; s2
test eax, eax
cmovz r13d, r15d
mov r15d, 4
call _strcmp
mov rdi, r14; s1
mov rsi, rbp; s2
mov r14d, 5
test eax, eax
cmovz ebx, r15d
call _strcmp
mov rsi, r12; s2
lea rdi, aSaturn; "Saturn"
test eax, eax
cmovz r13d, r15d
call _strcmp
mov rsi, rbp; s2
lea rdi, aSaturn; "Saturn"
test eax, eax
cmovz ebx, r14d
call _strcmp
mov rsi, r12; s2
lea rdi, aUranus; "Uranus"
test eax, eax
cmovz r13d, r14d
mov r14d, 6
call _strcmp
mov rsi, rbp; s2
lea rdi, aUranus; "Uranus"
test eax, eax
cmovz ebx, r14d
call _strcmp
mov rsi, r12; s2
lea rdi, aNeptune; "Neptune"
test eax, eax
cmovz r13d, r14d
call _strcmp
mov rsi, rbp; s2
lea rdi, aNeptune; "Neptune"
test eax, eax
mov eax, 7
cmovz ebx, eax
call _strcmp
mov rcx, [rsp+98h+var_90]
test eax, eax
jz short loc_17E0
cmp ebx, r13d
setz al
cmp r13d, 0FFFFFFFFh
setz sil
or al, sil
jnz short loc_17D4
cmp ebx, 0FFFFFFFFh
jz short loc_17D4
cmp ebx, r13d
jle short loc_17F0
mov eax, ebx
mov ebx, r13d
mov r13d, eax
mov eax, r13d
sub eax, ebx
sub eax, 1
mov [rcx], eax
test eax, eax
jg short loc_17FE
loc_17D4:
mov dword ptr [rcx], 0
xor ecx, ecx
jmp short loc_1838
loc_17E0:
cmp ebx, 0FFFFFFFFh
jz short loc_17D4
cmp ebx, 7
jz short loc_17D4
mov r13d, 7
loc_17F0:
mov eax, r13d
sub eax, ebx
sub eax, 1
mov [rcx], eax
test eax, eax
jle short loc_17D4
loc_17FE:
cdqe
lea rdi, ds:0[rax*8]; size
call _malloc
mov rcx, rax
lea eax, [rbx+1]
cmp r13d, eax
jle short loc_1838
lea edx, [r13-2]
cdqe
mov rdi, rcx; dest
sub edx, ebx
lea rsi, [rsp+rax*8+98h+src]; src
lea rdx, ds:8[rdx*8]; n
call _memcpy
mov rcx, rax
loc_1838:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_185A
add rsp, 68h
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_185A:
call ___stack_chk_fail
|
void * func0(char *s2, char *a2, int *a3)
{
int v3; // r13d
int v4; // ebx
int v5; // eax
int v6; // eax
void *v7; // rcx
int v9; // [rsp+0h] [rbp-94h]
_OWORD src[4]; // [rsp+Ch] [rbp-88h] BYREF
unsigned long long v12; // [rsp+54h] [rbp-40h]
v12 = __readfsqword(0x28u);
src[0] = _mm_loadh_ps((const double *)&off_3D70);
src[1] = _mm_loadh_ps((const double *)&off_3D78);
src[2] = _mm_loadh_ps((const double *)&off_3D80);
src[3] = _mm_loadh_ps((const double *)&off_3D90);
v3 = 1;
v4 = -(strcmp("Mercury", s2) != 0);
v9 = strcmp("Mercury", a2) != 0;
if ( !strcmp("Venus", s2) )
v4 = 1;
if ( strcmp("Venus", a2) )
v3 = -v9;
if ( !strcmp("Earth", s2) )
v4 = 2;
if ( !strcmp("Earth", a2) )
v3 = 2;
if ( !strcmp("Mars", s2) )
v4 = 3;
if ( !strcmp("Mars", a2) )
v3 = 3;
if ( !strcmp("Jupiter", s2) )
v4 = 4;
if ( !strcmp("Jupiter", a2) )
v3 = 4;
if ( !strcmp("Saturn", s2) )
v4 = 5;
if ( !strcmp("Saturn", a2) )
v3 = 5;
if ( !strcmp("Uranus", s2) )
v4 = 6;
if ( !strcmp("Uranus", a2) )
v3 = 6;
if ( !strcmp("Neptune", s2) )
v4 = 7;
if ( !strcmp("Neptune", a2) )
{
if ( v4 == -1 || v4 == 7 )
goto LABEL_32;
v3 = 7;
goto LABEL_36;
}
if ( v3 == -1 || v4 == v3 || v4 == -1 )
goto LABEL_32;
if ( v4 <= v3 )
{
LABEL_36:
v6 = v3 - v4 - 1;
*a3 = v6;
if ( v6 <= 0 )
goto LABEL_32;
goto LABEL_37;
}
v5 = v4;
v4 = v3;
v3 = v5;
v6 = v5 - v4 - 1;
*a3 = v6;
if ( v6 <= 0 )
{
LABEL_32:
*a3 = 0;
return 0LL;
}
LABEL_37:
v7 = malloc(8LL * v6);
if ( v3 > v4 + 1 )
return memcpy(v7, (char *)src + 8 * v4 + 8, 8LL * (unsigned int)(v3 - 2 - v4) + 8);
return v7;
}
|
func0:
ENDBR64
PUSH R15
LEA R15,[0x102012]
PUSH R14
LEA R14,[0x10201d]
PUSH R13
LEA R13,[0x102004]
PUSH R12
MOVQ XMM0,R13
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
MOV RSI,RDI
MOV RDI,R13
PUSH RBX
XOR EBX,EBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x8],RDX
MOVHPS XMM0,qword ptr [0x00103d70]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVQ XMM0,R15
MOVHPS XMM0,qword ptr [0x00103d78]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVQ XMM0,R14
MOVHPS XMM0,qword ptr [0x00103d80]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVQ XMM0,qword ptr [0x00103d88]
MOVHPS XMM0,qword ptr [0x00103d90]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
CALL 0x001010d0
MOV RDI,R13
MOV RSI,RBP
MOV R13D,0x1
TEST EAX,EAX
SETNZ BL
CALL 0x001010d0
MOV RSI,R12
LEA RDI,[0x10200c]
TEST EAX,EAX
SETNZ AL
NEG EBX
MOVZX EAX,AL
MOV dword ptr [RSP + 0x4],EAX
CALL 0x001010d0
MOV RSI,RBP
LEA RDI,[0x10200c]
TEST EAX,EAX
CMOVZ EBX,R13D
CALL 0x001010d0
MOV EDX,dword ptr [RSP + 0x4]
MOV RDI,R15
MOV RSI,R12
NEG EDX
TEST EAX,EAX
CMOVNZ R13D,EDX
CALL 0x001010d0
MOV R8D,0x2
MOV RDI,R15
MOV RSI,RBP
TEST EAX,EAX
MOV R15D,0x3
CMOVZ EBX,R8D
CALL 0x001010d0
MOV R8D,0x2
MOV RSI,R12
TEST EAX,EAX
LEA RDI,[0x102018]
CMOVZ R13D,R8D
CALL 0x001010d0
MOV RSI,RBP
LEA RDI,[0x102018]
TEST EAX,EAX
CMOVZ EBX,R15D
CALL 0x001010d0
MOV RDI,R14
MOV RSI,R12
TEST EAX,EAX
CMOVZ R13D,R15D
MOV R15D,0x4
CALL 0x001010d0
MOV RDI,R14
MOV RSI,RBP
MOV R14D,0x5
TEST EAX,EAX
CMOVZ EBX,R15D
CALL 0x001010d0
MOV RSI,R12
LEA RDI,[0x102025]
TEST EAX,EAX
CMOVZ R13D,R15D
CALL 0x001010d0
MOV RSI,RBP
LEA RDI,[0x102025]
TEST EAX,EAX
CMOVZ EBX,R14D
CALL 0x001010d0
MOV RSI,R12
LEA RDI,[0x10202c]
TEST EAX,EAX
CMOVZ R13D,R14D
MOV R14D,0x6
CALL 0x001010d0
MOV RSI,RBP
LEA RDI,[0x10202c]
TEST EAX,EAX
CMOVZ EBX,R14D
CALL 0x001010d0
MOV RSI,R12
LEA RDI,[0x102033]
TEST EAX,EAX
CMOVZ R13D,R14D
CALL 0x001010d0
MOV RSI,RBP
LEA RDI,[0x102033]
TEST EAX,EAX
MOV EAX,0x7
CMOVZ EBX,EAX
CALL 0x001010d0
MOV RCX,qword ptr [RSP + 0x8]
TEST EAX,EAX
JZ 0x001017e0
CMP EBX,R13D
SETZ AL
CMP R13D,-0x1
SETZ SIL
OR AL,SIL
JNZ 0x001017d4
CMP EBX,-0x1
JZ 0x001017d4
CMP EBX,R13D
JLE 0x001017f0
MOV EAX,EBX
MOV EBX,R13D
MOV R13D,EAX
MOV EAX,R13D
SUB EAX,EBX
SUB EAX,0x1
MOV dword ptr [RCX],EAX
TEST EAX,EAX
JG 0x001017fe
LAB_001017d4:
MOV dword ptr [RCX],0x0
XOR ECX,ECX
JMP 0x00101838
LAB_001017e0:
CMP EBX,-0x1
JZ 0x001017d4
CMP EBX,0x7
JZ 0x001017d4
MOV R13D,0x7
LAB_001017f0:
MOV EAX,R13D
SUB EAX,EBX
SUB EAX,0x1
MOV dword ptr [RCX],EAX
TEST EAX,EAX
JLE 0x001017d4
LAB_001017fe:
CDQE
LEA RDI,[RAX*0x8]
CALL 0x001010f0
MOV RCX,RAX
LEA EAX,[RBX + 0x1]
CMP R13D,EAX
JLE 0x00101838
LEA EDX,[R13 + -0x2]
CDQE
MOV RDI,RCX
SUB EDX,EBX
LEA RSI,[RSP + RAX*0x8 + 0x10]
LEA RDX,[0x8 + RDX*0x8]
CALL 0x001010e0
MOV RCX,RAX
LAB_00101838:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010185a
ADD RSP,0x68
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010185a:
CALL 0x001010b0
|
void * func0(char *param_1,char *param_2,int *param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
void *__dest;
long in_FS_OFFSET;
char *local_88 [4];
char *local_68;
int *puStack_60;
int *local_58;
int *puStack_50;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_88[0] = "Mercury";
local_88[1] = PTR_s_Venus_00103d70;
local_88[2] = "Earth";
local_88[3] = PTR_DAT_00103d78;
local_68 = "Jupiter";
puStack_60 = PTR_s_Saturn_00103d80;
local_58 = PTR_s_Uranus_00103d88;
puStack_50 = PTR_s_Neptune_00103d90;
iVar1 = strcmp("Mercury",param_1);
iVar2 = strcmp("Mercury",param_2);
iVar1 = -(uint)(iVar1 != 0);
iVar3 = strcmp("Venus",param_1);
if (iVar3 == 0) {
iVar1 = 1;
}
iVar4 = strcmp("Venus",param_2);
iVar3 = 1;
if (iVar4 != 0) {
iVar3 = -(uint)(iVar2 != 0);
}
iVar2 = strcmp("Earth",param_1);
if (iVar2 == 0) {
iVar1 = 2;
}
iVar2 = strcmp("Earth",param_2);
if (iVar2 == 0) {
iVar3 = 2;
}
iVar2 = strcmp("Mars",param_1);
if (iVar2 == 0) {
iVar1 = 3;
}
iVar2 = strcmp("Mars",param_2);
if (iVar2 == 0) {
iVar3 = 3;
}
iVar2 = strcmp("Jupiter",param_1);
if (iVar2 == 0) {
iVar1 = 4;
}
iVar2 = strcmp("Jupiter",param_2);
if (iVar2 == 0) {
iVar3 = 4;
}
iVar2 = strcmp("Saturn",param_1);
if (iVar2 == 0) {
iVar1 = 5;
}
iVar2 = strcmp("Saturn",param_2);
if (iVar2 == 0) {
iVar3 = 5;
}
iVar2 = strcmp("Uranus",param_1);
if (iVar2 == 0) {
iVar1 = 6;
}
iVar2 = strcmp("Uranus",param_2);
if (iVar2 == 0) {
iVar3 = 6;
}
iVar2 = strcmp("Neptune",param_1);
if (iVar2 == 0) {
iVar1 = 7;
}
iVar2 = strcmp("Neptune",param_2);
if (iVar2 == 0) {
if ((iVar1 != -1) && (iVar1 != 7)) {
iVar3 = 7;
LAB_001017f0:
iVar2 = (iVar3 - iVar1) + -1;
*param_3 = iVar2;
iVar4 = iVar1;
iVar1 = iVar3;
goto joined_r0x001017fc;
}
}
else if ((iVar1 != iVar3 && iVar3 != -1) && (iVar1 != -1)) {
if (iVar1 <= iVar3) goto LAB_001017f0;
iVar2 = (iVar1 - iVar3) + -1;
*param_3 = iVar2;
iVar4 = iVar3;
joined_r0x001017fc:
if (0 < iVar2) {
__dest = malloc((long)iVar2 * 8);
if (iVar4 + 1 < iVar1) {
__dest = memcpy(__dest,local_88 + (iVar4 + 1),(ulong)(uint)((iVar1 + -2) - iVar4) * 8 + 8);
}
goto LAB_00101838;
}
}
*param_3 = 0;
__dest = (void *)0x0;
LAB_00101838:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __dest;
}
|
1,252 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
for (j = 0; j < *return_size - i - 1; ++j) {
size_t len_j = strlen(lst[j]);
size_t len_j1 = strlen(lst[j + 1]);
if (len_j > len_j1 || (len_j == len_j1 && strcmp(lst[j], lst[j + 1]) > 0)) {
temp = lst[j];
lst[j] = lst[j + 1];
lst[j + 1] = temp;
}
}
}
char **out = malloc(*return_size * sizeof(char *));
for (i = 0; i < *return_size; ++i) {
out[i] = lst[i];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **result;
char *test1[] = {"aa", "a", "aaa"};
char *expected1[] = {"aa"};
result = func0(test1, 3, &size);
assert(issame(result, expected1, size, 1));
free(result);
char *test2[] = {"school", "AI", "asdf", "b"};
char *expected2[] = {"AI", "asdf", "school"};
result = func0(test2, 4, &size);
assert(issame(result, expected2, size, 3));
free(result);
char *test3[] = {"d", "b", "c", "a"};
result = func0(test3, 4, &size);
assert(size == 0);
free(result);
char *test4[] = {"d", "dcba", "abcd", "a"};
char *expected4[] = {"abcd", "dcba"};
result = func0(test4, 4, &size);
assert(issame(result, expected4, size, 2));
free(result);
char *test5[] = {"AI", "ai", "au"};
char *expected5[] = {"AI", "ai", "au"};
result = func0(test5, 3, &size);
assert(issame(result, expected5, size, 3));
free(result);
char *test6[] = {"a", "b", "b", "c", "c", "a"};
result = func0(test6, 6, &size);
assert(size == 0);
free(result);
char *test7[] = {"aaaa", "bbbb", "dd", "cc"};
char *expected7[] = {"cc", "dd", "aaaa", "bbbb"};
result = func0(test7, 4, &size);
assert(issame(result, expected7, size, 4));
free(result);
printf("All tests passed!\n");
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov -0x48(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0x28(%rbp)
jmp 129f <func0+0x96>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
and $0x1,%eax
test %rax,%rax
jne 129b <func0+0x92>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x48(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
mov -0x48(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x48(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1233 <func0+0x2a>
movl $0x0,-0x28(%rbp)
jmpq 13ec <func0+0x1e3>
movl $0x0,-0x24(%rbp)
jmpq 13d3 <func0+0x1ca>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %rax,-0x18(%rbp)
mov -0x24(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %rax,-0x10(%rbp)
mov -0x18(%rbp),%rax
cmp -0x10(%rbp),%rax
ja 1362 <func0+0x159>
mov -0x18(%rbp),%rax
cmp -0x10(%rbp),%rax
jne 13cf <func0+0x1c6>
mov -0x24(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1100 <strcmp@plt>
test %eax,%eax
jle 13cf <func0+0x1c6>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
mov -0x24(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%rax
mov %rax,(%rdx)
mov -0x24(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%rax
mov %rax,(%rdx)
addl $0x1,-0x24(%rbp)
mov -0x48(%rbp),%rax
mov (%rax),%eax
sub -0x28(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x24(%rbp)
jl 12bf <func0+0xb6>
addl $0x1,-0x28(%rbp)
mov -0x48(%rbp),%rax
mov (%rax),%eax
sub $0x1,%eax
cmp %eax,-0x28(%rbp)
jl 12b3 <func0+0xaa>
mov -0x48(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x28(%rbp)
jmp 1452 <func0+0x249>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%rax
mov %rax,(%rdx)
addl $0x1,-0x28(%rbp)
mov -0x48(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x28(%rbp)
jl 141f <func0+0x216>
mov -0x20(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov rax, [rbp+var_48]
mov dword ptr [rax], 0
mov [rbp+var_28], 0
jmp short loc_129F
loc_1233:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
and eax, 1
test rax, rax
jnz short loc_129B
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov rax, [rbp+var_48]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rdx, rax
mov rax, [rcx]
mov [rdx], rax
mov rax, [rbp+var_48]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_48]
mov [rax], edx
loc_129B:
add [rbp+var_28], 1
loc_129F:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_3C]
jl short loc_1233
mov [rbp+var_28], 0
jmp loc_13EC
loc_12B3:
mov [rbp+var_24], 0
jmp loc_13D3
loc_12BF:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], rax
mov eax, [rbp+var_24]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], rax
mov rax, [rbp+var_18]
cmp [rbp+var_10], rax
jb short loc_1362
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
jnz loc_13CF
mov eax, [rbp+var_24]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_24]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jle short loc_13CF
loc_1362:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov [rbp+var_8], rax
mov eax, [rbp+var_24]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_38]
add rdx, rcx
mov rax, [rax]
mov [rdx], rax
mov eax, [rbp+var_24]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rdx, rax
mov rax, [rbp+var_8]
mov [rdx], rax
loc_13CF:
add [rbp+var_24], 1
loc_13D3:
mov rax, [rbp+var_48]
mov eax, [rax]
sub eax, [rbp+var_28]
sub eax, 1
cmp [rbp+var_24], eax
jl loc_12BF
add [rbp+var_28], 1
loc_13EC:
mov rax, [rbp+var_48]
mov eax, [rax]
sub eax, 1
cmp [rbp+var_28], eax
jl loc_12B3
mov rax, [rbp+var_48]
mov eax, [rax]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov [rbp+var_28], 0
jmp short loc_1452
loc_141F:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rbp+var_28]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_20]
add rdx, rcx
mov rax, [rax]
mov [rdx], rax
add [rbp+var_28], 1
loc_1452:
mov rax, [rbp+var_48]
mov eax, [rax]
cmp [rbp+var_28], eax
jl short loc_141F
mov rax, [rbp+var_20]
leave
retn
|
_QWORD * func0(long long a1, int a2, int *a3)
{
int i; // [rsp+28h] [rbp-28h]
int j; // [rsp+28h] [rbp-28h]
int m; // [rsp+28h] [rbp-28h]
int k; // [rsp+2Ch] [rbp-24h]
_QWORD *v9; // [rsp+30h] [rbp-20h]
size_t v10; // [rsp+38h] [rbp-18h]
size_t v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
*a3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (strlen(*(const char **)(8LL * i + a1)) & 1) == 0 )
*(_QWORD *)(a1 + 8LL * (*a3)++) = *(_QWORD *)(8LL * i + a1);
}
for ( j = 0; j < *a3 - 1; ++j )
{
for ( k = 0; k < *a3 - j - 1; ++k )
{
v10 = strlen(*(const char **)(8LL * k + a1));
v11 = strlen(*(const char **)(8 * (k + 1LL) + a1));
if ( v11 < v10 || v10 == v11 && strcmp(*(const char **)(8LL * k + a1), *(const char **)(8 * (k + 1LL) + a1)) > 0 )
{
v12 = *(_QWORD *)(8LL * k + a1);
*(_QWORD *)(8LL * k + a1) = *(_QWORD *)(8 * (k + 1LL) + a1);
*(_QWORD *)(a1 + 8 * (k + 1LL)) = v12;
}
}
}
v9 = malloc(8LL * *a3);
for ( m = 0; m < *a3; ++m )
v9[m] = *(_QWORD *)(8LL * m + a1);
return v9;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x28],0x0
JMP 0x0010129f
LAB_00101233:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010d0
AND EAX,0x1
TEST RAX,RAX
JNZ 0x0010129b
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],EDX
LAB_0010129b:
ADD dword ptr [RBP + -0x28],0x1
LAB_0010129f:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101233
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001013ec
LAB_001012b3:
MOV dword ptr [RBP + -0x24],0x0
JMP 0x001013d3
LAB_001012bf:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RBP + -0x10],RAX
JC 0x00101362
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001013cf
MOV EAX,dword ptr [RBP + -0x24]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101100
TEST EAX,EAX
JLE 0x001013cf
LAB_00101362:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDX],RAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RDX],RAX
LAB_001013cf:
ADD dword ptr [RBP + -0x24],0x1
LAB_001013d3:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
SUB EAX,dword ptr [RBP + -0x28]
SUB EAX,0x1
CMP dword ptr [RBP + -0x24],EAX
JL 0x001012bf
ADD dword ptr [RBP + -0x28],0x1
LAB_001013ec:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
SUB EAX,0x1
CMP dword ptr [RBP + -0x28],EAX
JL 0x001012b3
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x00101452
LAB_0010141f:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDX],RAX
ADD dword ptr [RBP + -0x28],0x1
LAB_00101452:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x28],EAX
JL 0x0010141f
MOV RAX,qword ptr [RBP + -0x20]
LEAVE
RET
|
void * func0(long param_1,int param_2,int *param_3)
{
int8 uVar1;
int iVar2;
size_t sVar3;
size_t sVar4;
void *pvVar5;
int4 local_30;
int4 local_2c;
*param_3 = 0;
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
sVar3 = strlen(*(char **)(param_1 + (long)local_30 * 8));
if ((sVar3 & 1) == 0) {
*(int8 *)((long)*param_3 * 8 + param_1) = *(int8 *)((long)local_30 * 8 + param_1);
*param_3 = *param_3 + 1;
}
}
local_30 = 0;
do {
if (*param_3 + -1 <= local_30) {
pvVar5 = malloc((long)*param_3 << 3);
for (local_30 = 0; local_30 < *param_3; local_30 = local_30 + 1) {
*(int8 *)((long)pvVar5 + (long)local_30 * 8) =
*(int8 *)(param_1 + (long)local_30 * 8);
}
return pvVar5;
}
for (local_2c = 0; local_2c < (*param_3 - local_30) + -1; local_2c = local_2c + 1) {
sVar3 = strlen(*(char **)(param_1 + (long)local_2c * 8));
sVar4 = strlen(*(char **)(param_1 + ((long)local_2c + 1) * 8));
if (sVar4 < sVar3) {
LAB_00101362:
uVar1 = *(int8 *)(param_1 + (long)local_2c * 8);
*(int8 *)(param_1 + (long)local_2c * 8) =
*(int8 *)(param_1 + ((long)local_2c + 1) * 8);
*(int8 *)(((long)local_2c + 1) * 8 + param_1) = uVar1;
}
else if (sVar3 == sVar4) {
iVar2 = strcmp(*(char **)(param_1 + (long)local_2c * 8),
*(char **)(param_1 + ((long)local_2c + 1) * 8));
if (0 < iVar2) goto LAB_00101362;
}
}
local_30 = local_30 + 1;
} while( true );
}
|
1,253 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
for (j = 0; j < *return_size - i - 1; ++j) {
size_t len_j = strlen(lst[j]);
size_t len_j1 = strlen(lst[j + 1]);
if (len_j > len_j1 || (len_j == len_j1 && strcmp(lst[j], lst[j + 1]) > 0)) {
temp = lst[j];
lst[j] = lst[j + 1];
lst[j + 1] = temp;
}
}
}
char **out = malloc(*return_size * sizeof(char *));
for (i = 0; i < *return_size; ++i) {
out[i] = lst[i];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **result;
char *test1[] = {"aa", "a", "aaa"};
char *expected1[] = {"aa"};
result = func0(test1, 3, &size);
assert(issame(result, expected1, size, 1));
free(result);
char *test2[] = {"school", "AI", "asdf", "b"};
char *expected2[] = {"AI", "asdf", "school"};
result = func0(test2, 4, &size);
assert(issame(result, expected2, size, 3));
free(result);
char *test3[] = {"d", "b", "c", "a"};
result = func0(test3, 4, &size);
assert(size == 0);
free(result);
char *test4[] = {"d", "dcba", "abcd", "a"};
char *expected4[] = {"abcd", "dcba"};
result = func0(test4, 4, &size);
assert(issame(result, expected4, size, 2));
free(result);
char *test5[] = {"AI", "ai", "au"};
char *expected5[] = {"AI", "ai", "au"};
result = func0(test5, 3, &size);
assert(issame(result, expected5, size, 3));
free(result);
char *test6[] = {"a", "b", "b", "c", "c", "a"};
result = func0(test6, 6, &size);
assert(size == 0);
free(result);
char *test7[] = {"aaaa", "bbbb", "dd", "cc"};
char *expected7[] = {"cc", "dd", "aaaa", "bbbb"};
result = func0(test7, 4, &size);
assert(issame(result, expected7, size, 4));
free(result);
printf("All tests passed!\n");
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %rdx,%r15
movl $0x0,(%rdx)
test %esi,%esi
jle 12f2 <func0+0x109>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r9
mov $0xffffffffffffffff,%r8
mov $0x0,%eax
jmp 1231 <func0+0x48>
add $0x8,%rdx
cmp %r9,%rdx
je 124f <func0+0x66>
mov (%rdx),%rsi
mov %r8,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
test $0x1,%cl
jne 1228 <func0+0x3f>
movslq (%r15),%rcx
mov %rsi,0x0(%rbp,%rcx,8)
addl $0x1,(%r15)
jmp 1228 <func0+0x3f>
mov (%r15),%eax
cmp $0x1,%eax
jle 12f7 <func0+0x10e>
movl $0x0,0xc(%rsp)
mov $0xffffffffffffffff,%r14
jmp 12df <func0+0xf6>
mov %r13,0x0(%rbp,%rbx,8)
mov %r12,0x8(%rbp,%rbx,8)
add $0x1,%rbx
mov 0xc(%rsp),%eax
not %eax
add (%r15),%eax
cmp %ebx,%eax
jle 12cc <func0+0xe3>
mov 0x0(%rbp,%rbx,8),%r12
mov %r14,%rcx
mov %r12,%rdi
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rdx
mov 0x8(%rbp,%rbx,8),%r13
mov %r14,%rcx
mov %r13,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp %rcx,%rdx
ja 126c <func0+0x83>
jne 1276 <func0+0x8d>
mov %r13,%rsi
mov %r12,%rdi
callq 10e0 <strcmp@plt>
test %eax,%eax
jg 126c <func0+0x83>
jmp 1276 <func0+0x8d>
addl $0x1,0xc(%rsp)
mov 0xc(%rsp),%esi
mov (%r15),%eax
lea -0x1(%rax),%edx
cmp %esi,%edx
jle 12f7 <func0+0x10e>
mov (%r15),%eax
sub 0xc(%rsp),%eax
mov $0x0,%ebx
cmp $0x1,%eax
jg 1287 <func0+0x9e>
jmp 12cc <func0+0xe3>
mov $0x0,%eax
cltq
lea 0x0(,%rax,8),%rdi
callq 10f0 <malloc@plt>
mov (%r15),%edx
test %edx,%edx
jle 132a <func0+0x141>
lea -0x1(%rdx),%esi
mov $0x0,%edx
mov 0x0(%rbp,%rdx,8),%rcx
mov %rcx,(%rax,%rdx,8)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rsi
jne 1315 <func0+0x12c>
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov r15, rdx
mov dword ptr [rdx], 0
test esi, esi
jle loc_12EF
mov rbx, rdi
movsxd rsi, esi
lea r13, [rdi+rsi*8]
jmp short loc_1244
loc_123B:
add rbx, 8
cmp rbx, r13
jz short loc_1260
loc_1244:
mov rbp, [rbx]
mov rdi, rbp; s
call _strlen
test al, 1
jnz short loc_123B
movsxd rax, dword ptr [r15]
mov [r12+rax*8], rbp
add dword ptr [r15], 1
jmp short loc_123B
loc_1260:
mov eax, [r15]
cmp eax, 1
jle loc_12F4
mov [rsp+48h+var_3C], 0
jmp short loc_12DA
loc_1276:
mov [r12+rbx*8], r14
mov [r12+rbx*8+8], r13
loc_127F:
add rbx, 1
mov eax, [rsp+48h+var_3C]
not eax
add eax, [r15]
cmp eax, ebx
jle short loc_12C7
loc_1290:
mov r13, [r12+rbx*8]
mov rdi, r13; s
call _strlen
mov rbp, rax
mov r14, [r12+rbx*8+8]
mov rdi, r14; s
call _strlen
cmp rax, rbp
jb short loc_1276
cmp rbp, rax
jnz short loc_127F
mov rsi, r14; s2
mov rdi, r13; s1
call _strcmp
test eax, eax
jg short loc_1276
jmp short loc_127F
loc_12C7:
add [rsp+48h+var_3C], 1
mov ecx, [rsp+48h+var_3C]
mov eax, [r15]
lea edx, [rax-1]
cmp edx, ecx
jle short loc_12F4
loc_12DA:
mov eax, [r15]
mov esi, [rsp+48h+var_3C]
sub eax, esi
mov ebx, 0
cmp eax, 1
jg short loc_1290
jmp short loc_12C7
loc_12EF:
mov eax, 0
loc_12F4:
cdqe
lea rdi, ds:0[rax*8]; size
call _malloc
mov edx, [r15]
test edx, edx
jle short loc_132B
movsxd rdx, edx
lea rsi, ds:0[rdx*8]
mov edx, 0
loc_131A:
mov rcx, [r12+rdx]
mov [rax+rdx], rcx
add rdx, 8
cmp rdx, rsi
jnz short loc_131A
loc_132B:
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
char * func0(const char **a1, int a2, int *a3)
{
const char **v4; // rbx
const char *v5; // rbp
int v6; // eax
long long v7; // rbx
const char *v8; // r13
size_t v9; // rbp
const char *v10; // r14
size_t v11; // rax
char *result; // rax
long long v13; // rsi
unsigned long long v14; // rdx
int v15; // [rsp+Ch] [rbp-3Ch]
*a3 = 0;
if ( a2 <= 0 )
{
v6 = 0;
}
else
{
v4 = a1;
do
{
v5 = *v4;
if ( (strlen(*v4) & 1) == 0 )
a1[(*a3)++] = v5;
++v4;
}
while ( v4 != &a1[a2] );
v6 = *a3;
if ( *a3 > 1 )
{
v15 = 0;
do
{
v7 = 0LL;
if ( *a3 - v15 > 1 )
{
do
{
v8 = a1[v7];
v9 = strlen(v8);
v10 = a1[v7 + 1];
v11 = strlen(v10);
if ( v11 < v9 || v9 == v11 && strcmp(v8, v10) > 0 )
{
a1[v7] = v10;
a1[v7 + 1] = v8;
}
++v7;
}
while ( *a3 + ~v15 > (int)v7 );
}
++v15;
v6 = *a3;
}
while ( *a3 - 1 > v15 );
}
}
result = (char *)malloc(8LL * v6);
if ( *a3 > 0 )
{
v13 = 8LL * *a3;
v14 = 0LL;
do
{
*(_QWORD *)&result[v14] = a1[v14 / 8];
v14 += 8LL;
}
while ( v14 != v13 );
}
return result;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV R15,RDX
MOV dword ptr [RDX],0x0
TEST ESI,ESI
JLE 0x001012ef
MOV RBX,RDI
MOVSXD RSI,ESI
LEA R13,[RDI + RSI*0x8]
JMP 0x00101244
LAB_0010123b:
ADD RBX,0x8
CMP RBX,R13
JZ 0x00101260
LAB_00101244:
MOV RBP,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010d0
TEST AL,0x1
JNZ 0x0010123b
MOVSXD RAX,dword ptr [R15]
MOV qword ptr [R12 + RAX*0x8],RBP
ADD dword ptr [R15],0x1
JMP 0x0010123b
LAB_00101260:
MOV EAX,dword ptr [R15]
CMP EAX,0x1
JLE 0x001012f4
MOV dword ptr [RSP + 0xc],0x0
JMP 0x001012da
LAB_00101276:
MOV qword ptr [R12 + RBX*0x8],R14
MOV qword ptr [R12 + RBX*0x8 + 0x8],R13
LAB_0010127f:
ADD RBX,0x1
MOV EAX,dword ptr [RSP + 0xc]
NOT EAX
ADD EAX,dword ptr [R15]
CMP EAX,EBX
JLE 0x001012c7
LAB_00101290:
MOV R13,qword ptr [R12 + RBX*0x8]
MOV RDI,R13
CALL 0x001010d0
MOV RBP,RAX
MOV R14,qword ptr [R12 + RBX*0x8 + 0x8]
MOV RDI,R14
CALL 0x001010d0
CMP RAX,RBP
JC 0x00101276
CMP RBP,RAX
JNZ 0x0010127f
MOV RSI,R14
MOV RDI,R13
CALL 0x00101100
TEST EAX,EAX
JG 0x00101276
JMP 0x0010127f
LAB_001012c7:
ADD dword ptr [RSP + 0xc],0x1
MOV ECX,dword ptr [RSP + 0xc]
MOV EAX,dword ptr [R15]
LEA EDX,[RAX + -0x1]
CMP EDX,ECX
JLE 0x001012f4
LAB_001012da:
MOV EAX,dword ptr [R15]
MOV ESI,dword ptr [RSP + 0xc]
SUB EAX,ESI
MOV EBX,0x0
CMP EAX,0x1
JG 0x00101290
JMP 0x001012c7
LAB_001012ef:
MOV EAX,0x0
LAB_001012f4:
CDQE
LEA RDI,[RAX*0x8]
CALL 0x00101110
MOV EDX,dword ptr [R15]
TEST EDX,EDX
JLE 0x0010132b
MOVSXD RDX,EDX
LEA RSI,[RDX*0x8]
MOV EDX,0x0
LAB_0010131a:
MOV RCX,qword ptr [R12 + RDX*0x1]
MOV qword ptr [RAX + RDX*0x1],RCX
ADD RDX,0x8
CMP RDX,RSI
JNZ 0x0010131a
LAB_0010132b:
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
void func0(int8 *param_1,int param_2,int *param_3)
{
char *pcVar1;
char *__s;
int iVar2;
size_t sVar3;
size_t sVar4;
void *pvVar5;
int8 *puVar6;
long lVar7;
uint local_3c;
*param_3 = 0;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar6 = param_1;
do {
pcVar1 = (char *)*puVar6;
sVar3 = strlen(pcVar1);
if ((sVar3 & 1) == 0) {
param_1[*param_3] = pcVar1;
*param_3 = *param_3 + 1;
}
puVar6 = puVar6 + 1;
} while (puVar6 != param_1 + param_2);
iVar2 = *param_3;
if (1 < iVar2) {
local_3c = 0;
do {
lVar7 = 0;
if (1 < (int)(*param_3 - local_3c)) {
do {
pcVar1 = (char *)param_1[lVar7];
sVar3 = strlen(pcVar1);
__s = (char *)param_1[lVar7 + 1];
sVar4 = strlen(__s);
if ((sVar4 < sVar3) || ((sVar3 == sVar4 && (iVar2 = strcmp(pcVar1,__s), 0 < iVar2)))) {
param_1[lVar7] = __s;
param_1[lVar7 + 1] = pcVar1;
}
lVar7 = lVar7 + 1;
} while ((int)lVar7 < (int)(~local_3c + *param_3));
}
local_3c = local_3c + 1;
iVar2 = *param_3;
} while ((int)local_3c < iVar2 + -1);
}
}
pvVar5 = malloc((long)iVar2 * 8);
iVar2 = *param_3;
if (0 < iVar2) {
lVar7 = 0;
do {
*(int8 *)((long)pvVar5 + lVar7) = *(int8 *)((long)param_1 + lVar7);
lVar7 = lVar7 + 8;
} while (lVar7 != (long)iVar2 * 8);
}
return;
}
|
1,254 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
for (j = 0; j < *return_size - i - 1; ++j) {
size_t len_j = strlen(lst[j]);
size_t len_j1 = strlen(lst[j + 1]);
if (len_j > len_j1 || (len_j == len_j1 && strcmp(lst[j], lst[j + 1]) > 0)) {
temp = lst[j];
lst[j] = lst[j + 1];
lst[j + 1] = temp;
}
}
}
char **out = malloc(*return_size * sizeof(char *));
for (i = 0; i < *return_size; ++i) {
out[i] = lst[i];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **result;
char *test1[] = {"aa", "a", "aaa"};
char *expected1[] = {"aa"};
result = func0(test1, 3, &size);
assert(issame(result, expected1, size, 1));
free(result);
char *test2[] = {"school", "AI", "asdf", "b"};
char *expected2[] = {"AI", "asdf", "school"};
result = func0(test2, 4, &size);
assert(issame(result, expected2, size, 3));
free(result);
char *test3[] = {"d", "b", "c", "a"};
result = func0(test3, 4, &size);
assert(size == 0);
free(result);
char *test4[] = {"d", "dcba", "abcd", "a"};
char *expected4[] = {"abcd", "dcba"};
result = func0(test4, 4, &size);
assert(issame(result, expected4, size, 2));
free(result);
char *test5[] = {"AI", "ai", "au"};
char *expected5[] = {"AI", "ai", "au"};
result = func0(test5, 3, &size);
assert(issame(result, expected5, size, 3));
free(result);
char *test6[] = {"a", "b", "b", "c", "c", "a"};
result = func0(test6, 6, &size);
assert(size == 0);
free(result);
char *test7[] = {"aaaa", "bbbb", "dd", "cc"};
char *expected7[] = {"cc", "dd", "aaaa", "bbbb"};
result = func0(test7, 4, &size);
assert(issame(result, expected7, size, 4));
free(result);
printf("All tests passed!\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movl $0x0,(%rdx)
mov %rdx,0x18(%rsp)
test %esi,%esi
jle 1864 <func0+0x154>
lea 0x8(%rdi),%rdx
lea -0x1(%rsi),%eax
mov %rdi,%r12
xor %ebx,%ebx
mov %rdx,0x10(%rsp)
lea (%rdx,%rax,8),%rbp
nopl (%rax)
mov (%r12),%r14
mov %r14,%rdi
callq 10d0 <strlen@plt>
mov %rax,%r8
movslq %ebx,%rax
lea 0x0(,%rax,8),%rsi
and $0x1,%r8d
mov %rsi,0x8(%rsp)
jne 178d <func0+0x7d>
mov %r14,0x0(%r13,%rax,8)
mov 0x18(%rsp),%rax
add $0x1,%ebx
add $0x8,%rsi
mov %rsi,0x8(%rsp)
mov %ebx,(%rax)
add $0x8,%r12
cmp %r12,%rbp
jne 1750 <func0+0x40>
lea -0x1(%rbx),%ebp
test %ebp,%ebp
jle 17fe <func0+0xee>
nopl (%rax)
mov 0x10(%rsp),%rcx
lea -0x1(%rbp),%eax
mov %r13,%r15
mov %eax,0x4(%rsp)
lea (%rcx,%rax,8),%r12
jmp 17c7 <func0+0xb7>
nopl (%rax)
je 1848 <func0+0x138>
add $0x8,%r15
cmp %r15,%r12
je 17f6 <func0+0xe6>
mov (%r15),%r14
mov %r14,%rdi
callq 10d0 <strlen@plt>
mov 0x8(%r15),%rbp
mov %rax,%rbx
mov %rbp,%rdi
callq 10d0 <strlen@plt>
cmp %rax,%rbx
jbe 17b8 <func0+0xa8>
mov %rbp,(%r15)
mov %r14,0x8(%r15)
add $0x8,%r15
cmp %r15,%r12
jne 17c7 <func0+0xb7>
mov 0x4(%rsp),%ebp
test %ebp,%ebp
jne 17a0 <func0+0x90>
mov 0x8(%rsp),%rdi
callq 1110 <malloc@plt>
mov 0x18(%rsp),%rdx
mov (%rdx),%ecx
xor %edx,%edx
lea -0x1(%rcx),%esi
test %ecx,%ecx
jle 1835 <func0+0x125>
nopl 0x0(%rax,%rax,1)
mov 0x0(%r13,%rdx,8),%rcx
mov %rcx,(%rax,%rdx,8)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rsi
jne 1820 <func0+0x110>
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %rbp,%rsi
mov %r14,%rdi
callq 1100 <strcmp@plt>
test %eax,%eax
jle 17be <func0+0xae>
mov %rbp,(%r15)
mov %r14,0x8(%r15)
jmp 17ed <func0+0xdd>
movq $0x0,0x8(%rsp)
jmp 17fe <func0+0xee>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rdx], 0
mov [rsp+58h+src], rdi
mov [rsp+58h+var_48], rdx
test esi, esi
jle loc_1901
movsxd rsi, esi
mov rbx, rdi
xor r13d, r13d
lea r12, [rdi+rsi*8]
nop word ptr [rax+rax+00000000h]
loc_17D0:
mov rbp, [rbx]
mov rdi, rbp; s
call _strlen
test al, 1
jnz short loc_17F6
mov rdx, [rsp+58h+src]
movsxd rax, r13d
add r13d, 1
mov [rdx+rax*8], rbp
mov rax, [rsp+58h+var_48]
mov [rax], r13d
loc_17F6:
add rbx, 8
cmp r12, rbx
jnz short loc_17D0
movsxd rax, r13d
shl rax, 3
mov [rsp+58h+size], rax
cmp r13d, 1
jle loc_189F
mov rax, [rsp+58h+src]
add rax, 8
mov [rsp+58h+var_50], rax
nop word ptr [rax+rax+00h]
loc_1828:
cmp r13d, 1
jle loc_18F8
mov rcx, [rsp+58h+var_50]
lea eax, [r13-2]
mov r15, [rsp+58h+src]
lea r12, [rcx+rax*8]
jmp short loc_185A
loc_1848:
cmp r14, rax
jz loc_18E0
loc_1851:
add r15, 8
cmp r15, r12
jz short loc_1895
loc_185A:
mov rbp, [r15]
mov rdi, rbp; s
call _strlen
mov rbx, [r15+8]
mov r14, rax
mov rdi, rbx; s
call _strlen
cmp rax, r14
jnb short loc_1848
loc_1879:
movq xmm0, rbx
movq xmm1, rbp
add r15, 8
punpcklqdq xmm0, xmm1
movups xmmword ptr [r15-8], xmm0
cmp r15, r12
jnz short loc_185A
loc_1895:
sub r13d, 1
cmp r13d, 1
jnz short loc_1828
loc_189F:
mov rdi, [rsp+58h+size]; size
call _malloc
mov rcx, rax
mov rax, [rsp+58h+var_48]
mov eax, [rax]
test eax, eax
jle short loc_18CE
mov rsi, [rsp+58h+src]; src
mov rdi, rcx; dest
lea rdx, ds:0[rax*8]; n
call _memcpy
mov rcx, rax
loc_18CE:
add rsp, 28h
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_18E0:
mov rsi, rbx; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jg short loc_1879
jmp loc_1851
loc_18F8:
sub r13d, 1
jmp loc_1828
loc_1901:
mov [rsp+58h+size], 0
jmp short loc_189F
|
void * func0(const char **a1, int a2, int *a3)
{
const char **v3; // rbx
int v4; // r13d
const char *v5; // rbp
long long v6; // rax
const char **v7; // r15
long long v8; // r12
const char *v9; // rbp
size_t v10; // rax
const char *v11; // rbx
size_t v12; // r14
size_t v13; // rax
void *v14; // rax
void *v15; // rcx
long long v16; // rax
long long size; // [rsp+18h] [rbp-40h]
*a3 = 0;
if ( a2 <= 0 )
{
v14 = malloc(0LL);
}
else
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
if ( (strlen(*v3) & 1) == 0 )
{
v6 = v4++;
a1[v6] = v5;
*a3 = v4;
}
++v3;
}
while ( &a1[a2] != v3 );
size = 8LL * v4;
if ( v4 > 1 )
{
do
{
while ( v4 <= 1 )
--v4;
v7 = a1;
v8 = (long long)&a1[(unsigned int)(v4 - 2) + 1];
do
{
while ( 1 )
{
v9 = *v7;
v10 = strlen(*v7);
v11 = v7[1];
v12 = v10;
v13 = strlen(v11);
if ( v13 < v12 || v12 == v13 && strcmp(v9, v11) > 0 )
break;
if ( ++v7 == (const char **)v8 )
goto LABEL_13;
}
*(__m128i *)v7++ = _mm_unpacklo_epi64((__m128i)(unsigned long long)v11, (__m128i)(unsigned long long)v9);
}
while ( v7 != (const char **)v8 );
LABEL_13:
--v4;
}
while ( v4 != 1 );
}
v14 = malloc(size);
}
v15 = v14;
v16 = (unsigned int)*a3;
if ( (int)v16 > 0 )
return memcpy(v15, a1, 8 * v16);
return v15;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RDX],0x0
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x10],RDX
TEST ESI,ESI
JLE 0x00101901
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R13D,R13D
LEA R12,[RDI + RSI*0x8]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017d0:
MOV RBP,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010e0
TEST AL,0x1
JNZ 0x001017f6
MOV RDX,qword ptr [RSP]
MOVSXD RAX,R13D
ADD R13D,0x1
MOV qword ptr [RDX + RAX*0x8],RBP
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],R13D
LAB_001017f6:
ADD RBX,0x8
CMP R12,RBX
JNZ 0x001017d0
MOVSXD RAX,R13D
SHL RAX,0x3
MOV qword ptr [RSP + 0x18],RAX
CMP R13D,0x1
JLE 0x0010189f
MOV RAX,qword ptr [RSP]
ADD RAX,0x8
MOV qword ptr [RSP + 0x8],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101828:
CMP R13D,0x1
JLE 0x001018f8
MOV RCX,qword ptr [RSP + 0x8]
LEA EAX,[R13 + -0x2]
MOV R15,qword ptr [RSP]
LEA R12,[RCX + RAX*0x8]
JMP 0x0010185a
LAB_00101848:
CMP R14,RAX
JZ 0x001018e0
LAB_00101851:
ADD R15,0x8
CMP R15,R12
JZ 0x00101895
LAB_0010185a:
MOV RBP,qword ptr [R15]
MOV RDI,RBP
CALL 0x001010e0
MOV RBX,qword ptr [R15 + 0x8]
MOV R14,RAX
MOV RDI,RBX
CALL 0x001010e0
CMP RAX,R14
JNC 0x00101848
LAB_00101879:
MOVQ XMM0,RBX
MOVQ XMM1,RBP
ADD R15,0x8
PUNPCKLQDQ XMM0,XMM1
MOVUPS xmmword ptr [R15 + -0x8],XMM0
CMP R15,R12
JNZ 0x0010185a
LAB_00101895:
SUB R13D,0x1
CMP R13D,0x1
JNZ 0x00101828
LAB_0010189f:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00101130
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x001018ce
MOV RSI,qword ptr [RSP]
MOV RDI,RCX
LEA RDX,[RAX*0x8]
CALL 0x00101120
MOV RCX,RAX
LAB_001018ce:
ADD RSP,0x28
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001018e0:
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101110
TEST EAX,EAX
JG 0x00101879
JMP 0x00101851
LAB_001018f8:
SUB R13D,0x1
JMP 0x00101828
LAB_00101901:
MOV qword ptr [RSP + 0x18],0x0
JMP 0x0010189f
|
void * func0(int8 *param_1,int param_2,uint *param_3)
{
char *pcVar1;
char *__s;
int iVar2;
size_t sVar3;
long lVar4;
size_t sVar5;
void *__dest;
int8 *puVar6;
uint uVar7;
int8 *puVar8;
size_t local_40;
*param_3 = 0;
if (param_2 < 1) {
local_40 = 0;
}
else {
uVar7 = 0;
puVar6 = param_1;
do {
pcVar1 = (char *)*puVar6;
sVar3 = strlen(pcVar1);
if ((sVar3 & 1) == 0) {
lVar4 = (long)(int)uVar7;
uVar7 = uVar7 + 1;
param_1[lVar4] = pcVar1;
*param_3 = uVar7;
}
puVar6 = puVar6 + 1;
} while (param_1 + param_2 != puVar6);
local_40 = (long)(int)uVar7 << 3;
if (1 < (int)uVar7) {
do {
for (; (int)uVar7 < 2; uVar7 = uVar7 - 1) {
}
puVar6 = param_1;
do {
while( true ) {
pcVar1 = (char *)*puVar6;
sVar3 = strlen(pcVar1);
__s = (char *)puVar6[1];
sVar5 = strlen(__s);
if ((sVar3 <= sVar5) && ((sVar3 != sVar5 || (iVar2 = strcmp(pcVar1,__s), iVar2 < 1))))
break;
puVar8 = puVar6 + 1;
*puVar6 = __s;
puVar6[1] = pcVar1;
puVar6 = puVar8;
if (puVar8 == param_1 + (ulong)(uVar7 - 2) + 1) goto LAB_00101895;
}
puVar6 = puVar6 + 1;
} while (puVar6 != param_1 + (ulong)(uVar7 - 2) + 1);
LAB_00101895:
uVar7 = uVar7 - 1;
} while (uVar7 != 1);
}
}
__dest = malloc(local_40);
if (0 < (int)*param_3) {
__dest = memcpy(__dest,param_1,(ulong)*param_3 * 8);
}
return __dest;
}
|
1,255 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char** func0(char **lst, int lst_size, int *return_size) {
int i, j;
char *temp;
*return_size = 0;
for (i = 0; i < lst_size; ++i) {
if (strlen(lst[i]) % 2 == 0) {
lst[*return_size] = lst[i];
(*return_size)++;
}
}
for (i = 0; i < *return_size - 1; ++i) {
for (j = 0; j < *return_size - i - 1; ++j) {
size_t len_j = strlen(lst[j]);
size_t len_j1 = strlen(lst[j + 1]);
if (len_j > len_j1 || (len_j == len_j1 && strcmp(lst[j], lst[j + 1]) > 0)) {
temp = lst[j];
lst[j] = lst[j + 1];
lst[j + 1] = temp;
}
}
}
char **out = malloc(*return_size * sizeof(char *));
for (i = 0; i < *return_size; ++i) {
out[i] = lst[i];
}
return out;
}
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int a_size, int b_size) {
if (a_size != b_size) return 0;
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int size;
char **result;
char *test1[] = {"aa", "a", "aaa"};
char *expected1[] = {"aa"};
result = func0(test1, 3, &size);
assert(issame(result, expected1, size, 1));
free(result);
char *test2[] = {"school", "AI", "asdf", "b"};
char *expected2[] = {"AI", "asdf", "school"};
result = func0(test2, 4, &size);
assert(issame(result, expected2, size, 3));
free(result);
char *test3[] = {"d", "b", "c", "a"};
result = func0(test3, 4, &size);
assert(size == 0);
free(result);
char *test4[] = {"d", "dcba", "abcd", "a"};
char *expected4[] = {"abcd", "dcba"};
result = func0(test4, 4, &size);
assert(issame(result, expected4, size, 2));
free(result);
char *test5[] = {"AI", "ai", "au"};
char *expected5[] = {"AI", "ai", "au"};
result = func0(test5, 3, &size);
assert(issame(result, expected5, size, 3));
free(result);
char *test6[] = {"a", "b", "b", "c", "c", "a"};
result = func0(test6, 6, &size);
assert(size == 0);
free(result);
char *test7[] = {"aaaa", "bbbb", "dd", "cc"};
char *expected7[] = {"cc", "dd", "aaaa", "bbbb"};
result = func0(test7, 4, &size);
assert(issame(result, expected7, size, 4));
free(result);
printf("All tests passed!\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movl $0x0,(%rdx)
mov %rdi,(%rsp)
mov %rdx,0x18(%rsp)
test %esi,%esi
jle 18b4 <func0+0x154>
lea 0x8(%rdi),%rdx
lea -0x1(%rsi),%eax
mov %rdi,%r12
xor %ebx,%ebx
mov %rdx,0x10(%rsp)
lea (%rdx,%rax,8),%rbp
xchg %ax,%ax
mov (%r12),%r13
mov %r13,%rdi
callq 10e0 <strlen@plt>
mov %rax,%r8
movslq %ebx,%rax
lea 0x0(,%rax,8),%rcx
and $0x1,%r8d
mov %rcx,0x8(%rsp)
jne 17e0 <func0+0x80>
mov (%rsp),%rsi
add $0x1,%ebx
add $0x8,%rcx
mov %rcx,0x8(%rsp)
mov %r13,(%rsi,%rax,8)
mov 0x18(%rsp),%rax
mov %ebx,(%rax)
add $0x8,%r12
cmp %r12,%rbp
jne 17a0 <func0+0x40>
lea -0x1(%rbx),%ebp
test %ebp,%ebp
jle 1856 <func0+0xf6>
mov 0x10(%rsp),%rdx
lea -0x1(%rbp),%eax
mov (%rsp),%r15
mov %rax,%rbp
lea (%rdx,%rax,8),%r12
jmp 1817 <func0+0xb7>
nopl (%rax)
je 18a0 <func0+0x140>
add $0x8,%r15
cmp %r12,%r15
je 1852 <func0+0xf2>
mov (%r15),%r13
mov %r13,%rdi
callq 10e0 <strlen@plt>
mov 0x8(%r15),%r14
mov %rax,%rbx
mov %r14,%rdi
callq 10e0 <strlen@plt>
cmp %rax,%rbx
jbe 1808 <func0+0xa8>
movq %r14,%xmm0
movq %r13,%xmm1
add $0x8,%r15
punpcklqdq %xmm1,%xmm0
movups %xmm0,-0x8(%r15)
cmp %r12,%r15
jne 1817 <func0+0xb7>
test %ebp,%ebp
jne 17f0 <func0+0x90>
mov 0x8(%rsp),%rdi
callq 1130 <malloc@plt>
mov %rax,%r8
mov 0x18(%rsp),%rax
mov (%rax),%eax
test %eax,%eax
jle 1888 <func0+0x128>
sub $0x1,%eax
mov (%rsp),%rsi
mov %r8,%rdi
lea 0x8(,%rax,8),%rdx
callq 1120 <memcpy@plt>
mov %rax,%r8
add $0x28,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov %r14,%rsi
mov %r13,%rdi
callq 1110 <strcmp@plt>
test %eax,%eax
jg 1836 <func0+0xd6>
jmpq 180e <func0+0xae>
movq $0x0,0x8(%rsp)
jmp 1856 <func0+0xf6>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rdx], 0
mov [rsp+58h+src], rdi
mov [rsp+58h+var_48], rdx
test esi, esi
jle loc_1901
movsxd rsi, esi
mov rbx, rdi
xor r13d, r13d
lea r12, [rdi+rsi*8]
nop word ptr [rax+rax+00000000h]
loc_17D0:
mov rbp, [rbx]
mov rdi, rbp; s
call _strlen
test al, 1
jnz short loc_17F6
mov rdx, [rsp+58h+src]
movsxd rax, r13d
add r13d, 1
mov [rdx+rax*8], rbp
mov rax, [rsp+58h+var_48]
mov [rax], r13d
loc_17F6:
add rbx, 8
cmp r12, rbx
jnz short loc_17D0
movsxd rax, r13d
shl rax, 3
mov [rsp+58h+size], rax
cmp r13d, 1
jle loc_189F
mov rax, [rsp+58h+src]
add rax, 8
mov [rsp+58h+var_50], rax
nop word ptr [rax+rax+00h]
loc_1828:
cmp r13d, 1
jle loc_18F8
mov rcx, [rsp+58h+var_50]
lea eax, [r13-2]
mov r15, [rsp+58h+src]
lea r12, [rcx+rax*8]
jmp short loc_185A
loc_1848:
cmp r14, rax
jz loc_18E0
loc_1851:
add r15, 8
cmp r15, r12
jz short loc_1895
loc_185A:
mov rbp, [r15]
mov rdi, rbp; s
call _strlen
mov rbx, [r15+8]
mov r14, rax
mov rdi, rbx; s
call _strlen
cmp rax, r14
jnb short loc_1848
loc_1879:
movq xmm0, rbx
movq xmm1, rbp
add r15, 8
punpcklqdq xmm0, xmm1
movups xmmword ptr [r15-8], xmm0
cmp r15, r12
jnz short loc_185A
loc_1895:
sub r13d, 1
cmp r13d, 1
jnz short loc_1828
loc_189F:
mov rdi, [rsp+58h+size]; size
call _malloc
mov rcx, rax
mov rax, [rsp+58h+var_48]
mov eax, [rax]
test eax, eax
jle short loc_18CE
mov rsi, [rsp+58h+src]; src
mov rdi, rcx; dest
lea rdx, ds:0[rax*8]; n
call _memcpy
mov rcx, rax
loc_18CE:
add rsp, 28h
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_18E0:
mov rsi, rbx; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jg short loc_1879
jmp loc_1851
loc_18F8:
sub r13d, 1
jmp loc_1828
loc_1901:
mov [rsp+58h+size], 0
jmp short loc_189F
|
void * func0(const char **a1, int a2, int *a3)
{
const char **v3; // rbx
int v4; // r13d
const char *v5; // rbp
long long v6; // rax
const char **v7; // r15
long long v8; // r12
const char *v9; // rbp
size_t v10; // rax
const char *v11; // rbx
size_t v12; // r14
size_t v13; // rax
void *v14; // rax
void *v15; // rcx
long long v16; // rax
long long size; // [rsp+18h] [rbp-40h]
*a3 = 0;
if ( a2 <= 0 )
{
v14 = malloc(0LL);
}
else
{
v3 = a1;
v4 = 0;
do
{
v5 = *v3;
if ( (strlen(*v3) & 1) == 0 )
{
v6 = v4++;
a1[v6] = v5;
*a3 = v4;
}
++v3;
}
while ( &a1[a2] != v3 );
size = 8LL * v4;
if ( v4 > 1 )
{
do
{
while ( v4 <= 1 )
--v4;
v7 = a1;
v8 = (long long)&a1[(unsigned int)(v4 - 2) + 1];
do
{
while ( 1 )
{
v9 = *v7;
v10 = strlen(*v7);
v11 = v7[1];
v12 = v10;
v13 = strlen(v11);
if ( v13 < v12 || v12 == v13 && strcmp(v9, v11) > 0 )
break;
if ( ++v7 == (const char **)v8 )
goto LABEL_13;
}
*(__m128i *)v7++ = _mm_unpacklo_epi64((__m128i)(unsigned long long)v11, (__m128i)(unsigned long long)v9);
}
while ( v7 != (const char **)v8 );
LABEL_13:
--v4;
}
while ( v4 != 1 );
}
v14 = malloc(size);
}
v15 = v14;
v16 = (unsigned int)*a3;
if ( (int)v16 > 0 )
return memcpy(v15, a1, 8 * v16);
return v15;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RDX],0x0
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0x10],RDX
TEST ESI,ESI
JLE 0x00101901
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R13D,R13D
LEA R12,[RDI + RSI*0x8]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017d0:
MOV RBP,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010e0
TEST AL,0x1
JNZ 0x001017f6
MOV RDX,qword ptr [RSP]
MOVSXD RAX,R13D
ADD R13D,0x1
MOV qword ptr [RDX + RAX*0x8],RBP
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],R13D
LAB_001017f6:
ADD RBX,0x8
CMP R12,RBX
JNZ 0x001017d0
MOVSXD RAX,R13D
SHL RAX,0x3
MOV qword ptr [RSP + 0x18],RAX
CMP R13D,0x1
JLE 0x0010189f
MOV RAX,qword ptr [RSP]
ADD RAX,0x8
MOV qword ptr [RSP + 0x8],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101828:
CMP R13D,0x1
JLE 0x001018f8
MOV RCX,qword ptr [RSP + 0x8]
LEA EAX,[R13 + -0x2]
MOV R15,qword ptr [RSP]
LEA R12,[RCX + RAX*0x8]
JMP 0x0010185a
LAB_00101848:
CMP R14,RAX
JZ 0x001018e0
LAB_00101851:
ADD R15,0x8
CMP R15,R12
JZ 0x00101895
LAB_0010185a:
MOV RBP,qword ptr [R15]
MOV RDI,RBP
CALL 0x001010e0
MOV RBX,qword ptr [R15 + 0x8]
MOV R14,RAX
MOV RDI,RBX
CALL 0x001010e0
CMP RAX,R14
JNC 0x00101848
LAB_00101879:
MOVQ XMM0,RBX
MOVQ XMM1,RBP
ADD R15,0x8
PUNPCKLQDQ XMM0,XMM1
MOVUPS xmmword ptr [R15 + -0x8],XMM0
CMP R15,R12
JNZ 0x0010185a
LAB_00101895:
SUB R13D,0x1
CMP R13D,0x1
JNZ 0x00101828
LAB_0010189f:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00101130
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JLE 0x001018ce
MOV RSI,qword ptr [RSP]
MOV RDI,RCX
LEA RDX,[RAX*0x8]
CALL 0x00101120
MOV RCX,RAX
LAB_001018ce:
ADD RSP,0x28
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001018e0:
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101110
TEST EAX,EAX
JG 0x00101879
JMP 0x00101851
LAB_001018f8:
SUB R13D,0x1
JMP 0x00101828
LAB_00101901:
MOV qword ptr [RSP + 0x18],0x0
JMP 0x0010189f
|
void * func0(int8 *param_1,int param_2,uint *param_3)
{
char *pcVar1;
char *__s;
int iVar2;
size_t sVar3;
long lVar4;
size_t sVar5;
void *__dest;
int8 *puVar6;
uint uVar7;
int8 *puVar8;
size_t local_40;
*param_3 = 0;
if (param_2 < 1) {
local_40 = 0;
}
else {
uVar7 = 0;
puVar6 = param_1;
do {
pcVar1 = (char *)*puVar6;
sVar3 = strlen(pcVar1);
if ((sVar3 & 1) == 0) {
lVar4 = (long)(int)uVar7;
uVar7 = uVar7 + 1;
param_1[lVar4] = pcVar1;
*param_3 = uVar7;
}
puVar6 = puVar6 + 1;
} while (param_1 + param_2 != puVar6);
local_40 = (long)(int)uVar7 << 3;
if (1 < (int)uVar7) {
do {
for (; (int)uVar7 < 2; uVar7 = uVar7 - 1) {
}
puVar6 = param_1;
do {
while( true ) {
pcVar1 = (char *)*puVar6;
sVar3 = strlen(pcVar1);
__s = (char *)puVar6[1];
sVar5 = strlen(__s);
if ((sVar3 <= sVar5) && ((sVar3 != sVar5 || (iVar2 = strcmp(pcVar1,__s), iVar2 < 1))))
break;
puVar8 = puVar6 + 1;
*puVar6 = __s;
puVar6[1] = pcVar1;
puVar6 = puVar8;
if (puVar8 == param_1 + (ulong)(uVar7 - 2) + 1) goto LAB_00101895;
}
puVar6 = puVar6 + 1;
} while (puVar6 != param_1 + (ulong)(uVar7 - 2) + 1);
LAB_00101895:
uVar7 = uVar7 - 1;
} while (uVar7 != 1);
}
}
__dest = malloc(local_40);
if (0 < (int)*param_3) {
__dest = memcpy(__dest,param_1,(ulong)*param_3 * 8);
}
return __dest;
}
|
1,256 |
func0
|
#include <stdio.h>
|
int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, 34, 1234) == 1234);
assert(func0(1, 2, 0) == 0);
assert(func0(2, 2, 0) == 2);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
movl $0x1,-0x8(%rbp)
cmpl $0x1,-0x14(%rbp)
jg 116e <func0+0x25>
movl $0x0,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 118f <func0+0x46>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 118b <func0+0x42>
movl $0x0,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 1177 <func0+0x2e>
cmpl $0x0,-0x8(%rbp)
je 11a5 <func0+0x5c>
mov -0x18(%rbp),%eax
jmp 11a8 <func0+0x5f>
mov -0x1c(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_8], 1
cmp [rbp+var_14], 1
jg short loc_116E
mov [rbp+var_8], 0
loc_116E:
mov [rbp+var_4], 2
jmp short loc_118F
loc_1177:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_118B
mov [rbp+var_8], 0
loc_118B:
add [rbp+var_4], 1
loc_118F:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_1177
cmp [rbp+var_8], 0
jz short loc_11A5
mov eax, [rbp+var_18]
jmp short loc_11A8
loc_11A5:
mov eax, [rbp+var_1C]
loc_11A8:
pop rbp
retn
|
long long func0(int a1, unsigned int a2, unsigned int a3)
{
_BOOL4 v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v4 = a1 > 1;
for ( i = 2; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
v4 = 0;
}
if ( v4 )
return a2;
else
return a3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x8],0x1
CMP dword ptr [RBP + -0x14],0x1
JG 0x0010116e
MOV dword ptr [RBP + -0x8],0x0
LAB_0010116e:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010118f
LAB_00101177:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x0010118b
MOV dword ptr [RBP + -0x8],0x0
LAB_0010118b:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x00101177
CMP dword ptr [RBP + -0x8],0x0
JZ 0x001011a5
MOV EAX,dword ptr [RBP + -0x18]
JMP 0x001011a8
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x1c]
LAB_001011a8:
POP RBP
RET
|
int4 func0(int param_1,int4 param_2,int4 param_3)
{
bool bVar1;
int local_c;
bVar1 = 1 < param_1;
for (local_c = 2; local_c * local_c <= param_1; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
bVar1 = false;
}
}
if (bVar1) {
param_3 = param_2;
}
return param_3;
}
|
1,257 |
func0
|
#include <stdio.h>
|
int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, 34, 1234) == 1234);
assert(func0(1, 2, 0) == 0);
assert(func0(2, 2, 0) == 2);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %edx,%r9d
cmp $0x1,%edi
setg %r8b
movzbl %r8b,%r8d
cmp $0x3,%edi
jle 117c <func0+0x33>
mov $0x2,%ecx
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %edx,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1165 <func0+0x1c>
test %r8d,%r8d
cmovne %esi,%r9d
mov %r9d,%eax
retq
|
func0:
endbr64
mov r10d, edx
cmp edi, 1
setnle r8b
movzx r8d, r8b
cmp edi, 3
jle short loc_117F
mov ecx, 2
loc_1165:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, edx
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp r9d, edi
jle short loc_1165
loc_117F:
test r8d, r8d
mov eax, r10d
cmovnz eax, esi
retn
|
long long func0(int a1, unsigned int a2, unsigned int a3)
{
_BOOL4 v3; // r8d
int v4; // ecx
long long result; // rax
v3 = a1 > 1;
if ( a1 > 3 )
{
v4 = 2;
do
{
if ( !(a1 % v4) )
v3 = 0;
++v4;
}
while ( v4 * v4 <= a1 );
}
result = a3;
if ( v3 )
return a2;
return result;
}
|
func0:
ENDBR64
MOV R10D,EDX
CMP EDI,0x1
SETG R8B
MOVZX R8D,R8B
CMP EDI,0x3
JLE 0x0010117f
MOV ECX,0x2
LAB_00101165:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,EDX
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP R9D,EDI
JLE 0x00101165
LAB_0010117f:
TEST R8D,R8D
MOV EAX,R10D
CMOVNZ EAX,ESI
RET
|
int4 func0(int param_1,int4 param_2,int4 param_3)
{
int iVar1;
uint uVar2;
ulong uVar3;
uVar3 = (ulong)(1 < param_1);
uVar2 = (uint)(1 < param_1);
if (3 < param_1) {
iVar1 = 2;
do {
if ((int)((long)param_1 % (long)iVar1) == 0) {
uVar3 = (long)param_1 % (long)iVar1 & 0xffffffff;
}
uVar2 = (uint)uVar3;
iVar1 = iVar1 + 1;
} while (iVar1 * iVar1 <= param_1);
}
if (uVar2 != 0) {
param_3 = param_2;
}
return param_3;
}
|
1,258 |
func0
|
#include <stdio.h>
|
int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, 34, 1234) == 1234);
assert(func0(1, 2, 0) == 0);
assert(func0(2, 2, 0) == 2);
return 0;
}
|
O2
|
c
|
func0:
endbr64
xor %r8d,%r8d
cmp $0x1,%edi
mov %edx,%r10d
setg %r8b
cmp $0x3,%edi
jle 1327 <func0+0x37>
mov $0x2,%ecx
xor %r9d,%r9d
xchg %ax,%ax
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %r9d,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1310 <func0+0x20>
test %r8d,%r8d
cmovne %esi,%r10d
mov %r10d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
mov r11d, edx
cmp edi, 3
jle short loc_1328
mov ecx, 2
mov r8d, 1
xor r10d, r10d
nop word ptr [rax+rax+00h]
loc_1300:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, r10d
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp edi, r9d
jge short loc_1300
test r8d, r8d
mov eax, r11d
cmovnz eax, esi
retn
loc_1328:
xor r8d, r8d
cmp edi, 1
mov eax, r11d
setnle r8b
test r8d, r8d
cmovnz eax, esi
retn
|
long long func0(int a1, unsigned int a2, unsigned int a3)
{
int v3; // ecx
int v4; // r8d
long long result; // rax
if ( a1 <= 3 )
{
result = a3;
if ( a1 > 1 )
return a2;
}
else
{
v3 = 2;
v4 = 1;
do
{
if ( !(a1 % v3) )
v4 = 0;
++v3;
}
while ( a1 >= v3 * v3 );
result = a3;
if ( v4 )
return a2;
}
return result;
}
|
func0:
ENDBR64
MOV R11D,EDX
CMP EDI,0x3
JLE 0x00101328
MOV ECX,0x2
MOV R8D,0x1
XOR R10D,R10D
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,R10D
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP EDI,R9D
JGE 0x00101300
TEST R8D,R8D
MOV EAX,R11D
CMOVNZ EAX,ESI
RET
LAB_00101328:
XOR R8D,R8D
CMP EDI,0x1
MOV EAX,R11D
SETG R8B
TEST R8D,R8D
CMOVNZ EAX,ESI
RET
|
int4 func0(int param_1,int4 param_2,int4 param_3)
{
bool bVar1;
int iVar2;
if (3 < param_1) {
iVar2 = 2;
bVar1 = true;
do {
if (param_1 % iVar2 == 0) {
bVar1 = false;
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
if (bVar1) {
param_3 = param_2;
}
return param_3;
}
if (1 < param_1) {
param_3 = param_2;
}
return param_3;
}
|
1,259 |
func0
|
#include <stdio.h>
|
int func0(int n, int x, int y) {
int isp = 1;
if (n < 2) isp = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) isp = 0;
}
if (isp) return x;
return y;
}
|
#include <assert.h>
int main() {
assert(func0(7, 34, 12) == 34);
assert(func0(15, 8, 5) == 5);
assert(func0(3, 33, 5212) == 33);
assert(func0(1259, 3, 52) == 3);
assert(func0(7919, -1, 12) == -1);
assert(func0(3609, 1245, 583) == 583);
assert(func0(91, 56, 129) == 129);
assert(func0(6, 34, 1234) == 1234);
assert(func0(1, 2, 0) == 0);
assert(func0(2, 2, 0) == 2);
return 0;
}
|
O3
|
c
|
func0:
endbr64
xor %r8d,%r8d
cmp $0x1,%edi
mov %edx,%r10d
setg %r8b
cmp $0x3,%edi
jle 12c7 <func0+0x37>
mov $0x2,%ecx
xor %r9d,%r9d
xchg %ax,%ax
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %r9d,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %eax,%edi
jge 12b0 <func0+0x20>
test %r8d,%r8d
cmovne %esi,%r10d
mov %r10d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
mov r11d, edx
cmp edi, 3
jle short loc_1328
mov ecx, 2
mov r8d, 1
xor r10d, r10d
nop word ptr [rax+rax+00h]
loc_1300:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, r10d
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp edi, r9d
jge short loc_1300
test r8d, r8d
mov eax, r11d
cmovnz eax, esi
retn
loc_1328:
xor r8d, r8d
cmp edi, 1
mov eax, r11d
setnle r8b
test r8d, r8d
cmovnz eax, esi
retn
|
long long func0(int a1, unsigned int a2, unsigned int a3)
{
int v3; // ecx
int v4; // r8d
long long result; // rax
if ( a1 <= 3 )
{
result = a3;
if ( a1 > 1 )
return a2;
}
else
{
v3 = 2;
v4 = 1;
do
{
if ( !(a1 % v3) )
v4 = 0;
++v3;
}
while ( a1 >= v3 * v3 );
result = a3;
if ( v4 )
return a2;
}
return result;
}
|
func0:
ENDBR64
MOV R11D,EDX
CMP EDI,0x3
JLE 0x00101328
MOV ECX,0x2
MOV R8D,0x1
XOR R10D,R10D
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,R10D
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP EDI,R9D
JGE 0x00101300
TEST R8D,R8D
MOV EAX,R11D
CMOVNZ EAX,ESI
RET
LAB_00101328:
XOR R8D,R8D
CMP EDI,0x1
MOV EAX,R11D
SETG R8B
TEST R8D,R8D
CMOVNZ EAX,ESI
RET
|
int4 func0(int param_1,int4 param_2,int4 param_3)
{
bool bVar1;
int iVar2;
if (3 < param_1) {
iVar2 = 2;
bVar1 = true;
do {
if (param_1 % iVar2 == 0) {
bVar1 = false;
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
if (bVar1) {
param_3 = param_2;
}
return param_3;
}
if (1 < param_1) {
param_3 = param_2;
}
return param_3;
}
|
1,260 |
func0
|
#include <stdio.h>
#include <math.h>
|
long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0((const float[]){0.2, 3, 5}, 3) == 34);
long long odd_sum = 0;
float lst[200];
int lst_size = 0;
for (int i = -99; i < 100; i += 2) {
lst[lst_size++] = i + 0.0f;
if (i > 0 && i % 2 == 1) odd_sum += i * i;
}
assert(func0(lst, lst_size) == odd_sum);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movq $0x0,-0x18(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 12cf <func0+0x146>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm2
movsd %xmm2,-0x38(%rbp)
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
callq 1070 <round@plt>
movsd -0x38(%rbp),%xmm2
subsd %xmm0,%xmm2
movapd %xmm2,%xmm0
movq 0xf88(%rip),%xmm1
andpd %xmm0,%xmm1
movsd 0xf8c(%rip),%xmm0
comisd %xmm1,%xmm0
jbe 12cb <func0+0x142>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
pxor %xmm1,%xmm1
comiss %xmm1,%xmm0
jbe 12cb <func0+0x142>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
callq 1070 <round@plt>
cvttsd2si %xmm0,%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 12cb <func0+0x142>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
callq 1070 <round@plt>
cvttsd2si %xmm0,%ebx
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
callq 1070 <round@plt>
cvttsd2si %xmm0,%eax
imul %ebx,%eax
cltq
add %rax,-0x18(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11b1 <func0+0x28>
mov -0x18(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
mov [rbp+var_1C], 0
jmp loc_1311
loc_11B1:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm2, xmm2
cvtss2sd xmm2, xmm0
movsd [rbp+var_38], xmm2
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm3, xmm3
cvtss2sd xmm3, xmm0
movq rax, xmm3
movq xmm0, rax; x
call _round
movapd xmm1, xmm0
movsd xmm0, [rbp+var_38]
subsd xmm0, xmm1
movq xmm1, cs:qword_2170
andpd xmm1, xmm0
movsd xmm0, cs:qword_2180
comisd xmm0, xmm1
jbe loc_130D
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm1, xmm1
comiss xmm0, xmm1
jbe loc_130D
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm4, xmm4
cvtss2sd xmm4, xmm0
movq rax, xmm4
movq xmm0, rax; x
call _round
cvttsd2si edx, xmm0
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_130D
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm5, xmm5
cvtss2sd xmm5, xmm0
movq rax, xmm5
movq xmm0, rax; x
call _round
cvttsd2si ebx, xmm0
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm6, xmm6
cvtss2sd xmm6, xmm0
movq rax, xmm6
movq xmm0, rax; x
call _round
cvttsd2si eax, xmm0
imul eax, ebx
cdqe
add [rbp+var_18], rax
loc_130D:
add [rbp+var_1C], 1
loc_1311:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_2C]
jl loc_11B1
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn
|
long long func0(long long a1, int a2)
{
int v2; // ebx
int i; // [rsp+24h] [rbp-1Ch]
long long v5; // [rsp+28h] [rbp-18h]
v5 = 0LL;
for ( i = 0; i < a2; ++i )
{
if ( fabs(*(float *)(4LL * i + a1) - round(*(float *)(4LL * i + a1))) < 0.0001
&& *(float *)(4LL * i + a1) > 0.0
&& (int)round(*(float *)(4LL * i + a1)) % 2 == 1 )
{
v2 = (int)round(*(float *)(4LL * i + a1));
v5 += v2 * (int)round(*(float *)(4LL * i + a1));
}
}
return v5;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101311
LAB_001011b1:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM2,XMM2
CVTSS2SD XMM2,XMM0
MOVSD qword ptr [RBP + -0x38],XMM2
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM3,XMM3
CVTSS2SD XMM3,XMM0
MOVQ RAX,XMM3
MOVQ XMM0,RAX
CALL 0x00101070
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x38]
SUBSD XMM0,XMM1
MOVQ XMM1,qword ptr [0x00102170]
ANDPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102180]
COMISD XMM0,XMM1
JBE 0x0010130d
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM1,XMM1
COMISS XMM0,XMM1
JBE 0x0010130d
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM4,XMM4
CVTSS2SD XMM4,XMM0
MOVQ RAX,XMM4
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EDX,XMM0
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 0x0010130d
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM5,XMM5
CVTSS2SD XMM5,XMM0
MOVQ RAX,XMM5
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EBX,XMM0
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM6,XMM6
CVTSS2SD XMM6,XMM0
MOVQ RAX,XMM6
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EAX,XMM0
IMUL EAX,EBX
CDQE
ADD qword ptr [RBP + -0x18],RAX
LAB_0010130d:
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101311:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011b1
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
long func0(long param_1,int param_2)
{
float fVar1;
double dVar2;
double dVar3;
int4 local_24;
int8 local_20;
local_20 = 0;
for (local_24 = 0; local_24 < param_2; local_24 = local_24 + 1) {
fVar1 = *(float *)(param_1 + (long)local_24 * 4);
dVar2 = round((double)*(float *)(param_1 + (long)local_24 * 4));
if (((double)(DAT_00102170 & (ulong)((double)fVar1 - dVar2)) < DAT_00102180) &&
(0.0 < *(float *)(param_1 + (long)local_24 * 4))) {
dVar2 = round((double)*(float *)(param_1 + (long)local_24 * 4));
if ((int)dVar2 % 2 == 1) {
dVar2 = round((double)*(float *)(param_1 + (long)local_24 * 4));
dVar3 = round((double)*(float *)(param_1 + (long)local_24 * 4));
local_20 = local_20 + (int)dVar3 * (int)dVar2;
}
}
}
return local_20;
}
|
1,261 |
func0
|
#include <stdio.h>
#include <math.h>
|
long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0((const float[]){0.2, 3, 5}, 3) == 34);
long long odd_sum = 0;
float lst[200];
int lst_size = 0;
for (int i = -99; i < 100; i += 2) {
lst[lst_size++] = i + 0.0f;
if (i > 0 && i % 2 == 1) odd_sum += i * i;
}
assert(func0(lst, lst_size) == odd_sum);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 1224 <func0+0x9b>
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rbp
mov $0x0,%r12d
jmp 11b9 <func0+0x30>
add $0x4,%rbx
cmp %rbp,%rbx
je 122a <func0+0xa1>
movss (%rbx),%xmm3
movss %xmm3,0xc(%rsp)
movaps %xmm3,%xmm0
callq 1070 <roundf@plt>
movss 0xc(%rsp),%xmm3
pxor %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
pxor %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
subsd %xmm2,%xmm1
andpd 0xfa3(%rip),%xmm1
movsd 0xfab(%rip),%xmm4
comisd %xmm1,%xmm4
jbe 11b0 <func0+0x27>
comiss 0xfa6(%rip),%xmm3
jbe 11b0 <func0+0x27>
cvttss2si %xmm0,%eax
mov %eax,%ecx
shr $0x1f,%ecx
lea (%rax,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
jne 11b0 <func0+0x27>
imul %eax,%eax
cltq
add %rax,%r12
jmp 11b0 <func0+0x27>
mov $0x0,%r12d
mov %r12,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
|
func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_1224
mov rbx, rdi
movsxd rsi, esi
lea rbp, [rdi+rsi*4]
mov r12d, 0
jmp short loc_11B8
loc_11AF:
add rbx, 4
cmp rbx, rbp
jz short loc_122A
loc_11B8:
movss xmm3, dword ptr [rbx]
movss [rsp+28h+var_1C], xmm3
movaps xmm0, xmm3; x
call _roundf
movss xmm3, [rsp+28h+var_1C]
pxor xmm1, xmm1
cvtss2sd xmm1, xmm3
pxor xmm2, xmm2
cvtss2sd xmm2, xmm0
subsd xmm1, xmm2
andpd xmm1, cs:xmmword_2160
movsd xmm4, cs:qword_2170
comisd xmm4, xmm1
jbe short loc_11AF
pxor xmm5, xmm5
comiss xmm3, xmm5
jbe short loc_11AF
cvttss2si edx, xmm0
mov ecx, edx
shr ecx, 1Fh
lea eax, [rdx+rcx]
and eax, 1
sub eax, ecx
cmp eax, 1
jnz short loc_11AF
imul edx, edx
movsxd rdx, edx
add r12, rdx
jmp short loc_11AF
loc_1224:
mov r12d, 0
loc_122A:
mov rax, r12
add rsp, 10h
pop rbx
pop rbp
pop r12
retn
|
long long func0(float *a1, int a2)
{
float *v2; // rbx
long long v3; // r12
float v4; // xmm0_4
float v6; // [rsp+Ch] [rbp-1Ch]
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = 0LL;
do
{
v6 = *v2;
v4 = roundf(*v2);
if ( fabs(v6 - v4) < 0.0001 && v6 > 0.0 && (int)v4 % 2 == 1 )
v3 += (int)v4 * (int)v4;
++v2;
}
while ( v2 != &a1[a2] );
return v3;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x00101224
MOV RBX,RDI
MOVSXD RSI,ESI
LEA RBP,[RDI + RSI*0x4]
MOV R12D,0x0
JMP 0x001011b8
LAB_001011af:
ADD RBX,0x4
CMP RBX,RBP
JZ 0x0010122a
LAB_001011b8:
MOVSS XMM3,dword ptr [RBX]
MOVSS dword ptr [RSP + 0xc],XMM3
MOVAPS XMM0,XMM3
CALL 0x00101070
MOVSS XMM3,dword ptr [RSP + 0xc]
PXOR XMM1,XMM1
CVTSS2SD XMM1,XMM3
PXOR XMM2,XMM2
CVTSS2SD XMM2,XMM0
SUBSD XMM1,XMM2
ANDPD XMM1,xmmword ptr [0x00102160]
MOVSD XMM4,qword ptr [0x00102170]
COMISD XMM4,XMM1
JBE 0x001011af
PXOR XMM5,XMM5
COMISS XMM3,XMM5
JBE 0x001011af
CVTTSS2SI EDX,XMM0
MOV ECX,EDX
SHR ECX,0x1f
LEA EAX,[RDX + RCX*0x1]
AND EAX,0x1
SUB EAX,ECX
CMP EAX,0x1
JNZ 0x001011af
IMUL EDX,EDX
MOVSXD RDX,EDX
ADD R12,RDX
JMP 0x001011af
LAB_00101224:
MOV R12D,0x0
LAB_0010122a:
MOV RAX,R12
ADD RSP,0x10
POP RBX
POP RBP
POP R12
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long func0(float *param_1,int param_2)
{
float *pfVar1;
float __x;
int iVar2;
long lVar3;
float fVar4;
if (param_2 < 1) {
lVar3 = 0;
}
else {
pfVar1 = param_1 + param_2;
lVar3 = 0;
do {
__x = *param_1;
fVar4 = roundf(__x);
if ((double)((ulong)((double)__x - (double)fVar4) & _DAT_00102160) < DAT_00102170) {
if ((0.0 < __x) && (iVar2 = (int)fVar4, iVar2 % 2 == 1)) {
lVar3 = lVar3 + iVar2 * iVar2;
}
}
param_1 = param_1 + 1;
} while (param_1 != pfVar1);
}
return lVar3;
}
|
1,262 |
func0
|
#include <stdio.h>
#include <math.h>
|
long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0((const float[]){0.2, 3, 5}, 3) == 34);
long long odd_sum = 0;
float lst[200];
int lst_size = 0;
for (int i = -99; i < 100; i += 2) {
lst[lst_size++] = i + 0.0f;
if (i > 0 && i % 2 == 1) odd_sum += i * i;
}
assert(func0(lst, lst_size) == odd_sum);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 14b0 <func0+0xb0>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %r12d,%r12d
lea 0x4(%rdi,%rax,4),%rbp
nopw 0x0(%rax,%rax,1)
movss (%rbx),%xmm2
movaps %xmm2,%xmm0
movss %xmm2,0xc(%rsp)
callq 1070 <roundf@plt>
movss 0xc(%rsp),%xmm2
pxor %xmm1,%xmm1
pxor %xmm3,%xmm3
movsd 0xd50(%rip),%xmm4
cvtss2sd %xmm0,%xmm3
cvtss2sd %xmm2,%xmm1
subsd %xmm3,%xmm1
andpd 0xd2c(%rip),%xmm1
comisd %xmm1,%xmm4
jbe 1498 <func0+0x98>
pxor %xmm5,%xmm5
comiss %xmm5,%xmm2
jbe 1498 <func0+0x98>
cvttss2si %xmm0,%eax
mov %eax,%ecx
shr $0x1f,%ecx
lea (%rax,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
jne 1498 <func0+0x98>
imul %eax,%eax
cltq
add %rax,%r12
nopl 0x0(%rax)
add $0x4,%rbx
cmp %rbx,%rbp
jne 1428 <func0+0x28>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
nopl (%rax)
add $0x10,%rsp
xor %r12d,%r12d
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
|
func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_1530
movsxd rsi, esi
mov rbx, rdi
xor r12d, r12d
lea rbp, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_14A8:
movss xmm2, dword ptr [rbx]
movaps xmm0, xmm2; x
movss [rsp+28h+var_1C], xmm2
call _roundf
movss xmm2, [rsp+28h+var_1C]
pxor xmm1, xmm1
pxor xmm3, xmm3
movsd xmm4, cs:qword_2190
cvtss2sd xmm3, xmm0
cvtss2sd xmm1, xmm2
subsd xmm1, xmm3
andpd xmm1, cs:xmmword_2160
comisd xmm4, xmm1
jbe short loc_1518
pxor xmm5, xmm5
comiss xmm2, xmm5
jbe short loc_1518
cvttss2si edx, xmm0
mov ecx, edx
shr ecx, 1Fh
lea eax, [rdx+rcx]
and eax, 1
sub eax, ecx
cmp eax, 1
jnz short loc_1518
imul edx, edx
movsxd rdx, edx
add r12, rdx
nop word ptr [rax+rax+00h]
loc_1518:
add rbx, 4
cmp rbp, rbx
jnz short loc_14A8
add rsp, 10h
mov rax, r12
pop rbx
pop rbp
pop r12
retn
loc_1530:
add rsp, 10h
xor r12d, r12d
mov rax, r12
pop rbx
pop rbp
pop r12
retn
|
long long func0(float *a1, int a2)
{
float *v2; // rbx
long long v3; // r12
float v4; // xmm0_4
float v6; // [rsp+Ch] [rbp-1Ch]
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = 0LL;
do
{
v6 = *v2;
v4 = roundf(*v2);
if ( fabs(v6 - v4) < 0.0001 && v6 > 0.0 && (int)v4 % 2 == 1 )
v3 += (int)v4 * (int)v4;
++v2;
}
while ( &a1[a2] != v2 );
return v3;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x00101530
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R12D,R12D
LEA RBP,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_001014a8:
MOVSS XMM2,dword ptr [RBX]
MOVAPS XMM0,XMM2
MOVSS dword ptr [RSP + 0xc],XMM2
CALL 0x00101070
MOVSS XMM2,dword ptr [RSP + 0xc]
PXOR XMM1,XMM1
PXOR XMM3,XMM3
MOVSD XMM4,qword ptr [0x00102190]
CVTSS2SD XMM3,XMM0
CVTSS2SD XMM1,XMM2
SUBSD XMM1,XMM3
ANDPD XMM1,xmmword ptr [0x00102160]
COMISD XMM4,XMM1
JBE 0x00101518
PXOR XMM5,XMM5
COMISS XMM2,XMM5
JBE 0x00101518
CVTTSS2SI EDX,XMM0
MOV ECX,EDX
SHR ECX,0x1f
LEA EAX,[RDX + RCX*0x1]
AND EAX,0x1
SUB EAX,ECX
CMP EAX,0x1
JNZ 0x00101518
IMUL EDX,EDX
MOVSXD RDX,EDX
ADD R12,RDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101518:
ADD RBX,0x4
CMP RBP,RBX
JNZ 0x001014a8
ADD RSP,0x10
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
LAB_00101530:
ADD RSP,0x10
XOR R12D,R12D
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long func0(float *param_1,int param_2)
{
float *pfVar1;
float __x;
int iVar2;
long lVar3;
float fVar4;
if (0 < param_2) {
lVar3 = 0;
pfVar1 = param_1 + param_2;
do {
__x = *param_1;
fVar4 = roundf(__x);
if ((double)((ulong)((double)__x - (double)fVar4) & _DAT_00102160) < DAT_00102190) {
if ((0.0 < __x) && (iVar2 = (int)fVar4, iVar2 % 2 == 1)) {
lVar3 = lVar3 + iVar2 * iVar2;
}
}
param_1 = param_1 + 1;
} while (pfVar1 != param_1);
return lVar3;
}
return 0;
}
|
1,263 |
func0
|
#include <stdio.h>
#include <math.h>
|
long long func0(float lst[], int lst_size) {
long long sum = 0;
for (int i = 0; i < lst_size; i++) {
if (fabs(lst[i] - round(lst[i])) < 1e-4) {
if (lst[i] > 0 && (int)(round(lst[i])) % 2 == 1) {
sum += (int)(round(lst[i])) * (int)(round(lst[i]));
}
}
}
return sum;
}
|
#include <assert.h>
int main() {
assert(func0((const float[]){}, 0) == 0);
assert(func0((const float[]){5, 4}, 2) == 25);
assert(func0((const float[]){0.1, 0.2, 0.3}, 3) == 0);
assert(func0((const float[]){-10, -20, -30}, 3) == 0);
assert(func0((const float[]){-1, -2, 8}, 3) == 0);
assert(func0((const float[]){0.2, 3, 5}, 3) == 34);
long long odd_sum = 0;
float lst[200];
int lst_size = 0;
for (int i = -99; i < 100; i += 2) {
lst[lst_size++] = i + 0.0f;
if (i > 0 && i % 2 == 1) odd_sum += i * i;
}
assert(func0(lst, lst_size) == odd_sum);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 1560 <func0+0xb0>
lea -0x1(%rsi),%eax
mov %rdi,%rbx
xor %r12d,%r12d
lea 0x4(%rdi,%rax,4),%rbp
nopw 0x0(%rax,%rax,1)
movss (%rbx),%xmm2
movaps %xmm2,%xmm0
movss %xmm2,0xc(%rsp)
callq 1070 <roundf@plt>
movss 0xc(%rsp),%xmm2
pxor %xmm1,%xmm1
pxor %xmm3,%xmm3
movsd 0xcc0(%rip),%xmm4
cvtss2sd %xmm0,%xmm3
cvtss2sd %xmm2,%xmm1
subsd %xmm3,%xmm1
andpd 0xc7c(%rip),%xmm1
comisd %xmm1,%xmm4
jbe 1548 <func0+0x98>
pxor %xmm5,%xmm5
comiss %xmm5,%xmm2
jbe 1548 <func0+0x98>
cvttss2si %xmm0,%eax
mov %eax,%ecx
shr $0x1f,%ecx
lea (%rax,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
jne 1548 <func0+0x98>
imul %eax,%eax
cltq
add %rax,%r12
nopl 0x0(%rax)
add $0x4,%rbx
cmp %rbx,%rbp
jne 14d8 <func0+0x28>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
nopl (%rax)
add $0x10,%rsp
xor %r12d,%r12d
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
|
func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_1530
movsxd rsi, esi
mov rbx, rdi
xor r12d, r12d
lea rbp, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_14A8:
movss xmm2, dword ptr [rbx]
movaps xmm0, xmm2; x
movss [rsp+28h+var_1C], xmm2
call _roundf
movss xmm2, [rsp+28h+var_1C]
pxor xmm1, xmm1
pxor xmm3, xmm3
movsd xmm4, cs:qword_2190
cvtss2sd xmm3, xmm0
cvtss2sd xmm1, xmm2
subsd xmm1, xmm3
andpd xmm1, cs:xmmword_2160
comisd xmm4, xmm1
jbe short loc_1518
pxor xmm5, xmm5
comiss xmm2, xmm5
jbe short loc_1518
cvttss2si edx, xmm0
mov ecx, edx
shr ecx, 1Fh
lea eax, [rdx+rcx]
and eax, 1
sub eax, ecx
cmp eax, 1
jnz short loc_1518
imul edx, edx
movsxd rdx, edx
add r12, rdx
nop word ptr [rax+rax+00h]
loc_1518:
add rbx, 4
cmp rbp, rbx
jnz short loc_14A8
add rsp, 10h
mov rax, r12
pop rbx
pop rbp
pop r12
retn
loc_1530:
add rsp, 10h
xor r12d, r12d
mov rax, r12
pop rbx
pop rbp
pop r12
retn
|
long long func0(float *a1, int a2)
{
float *v2; // rbx
long long v3; // r12
float v4; // xmm0_4
float v6; // [rsp+Ch] [rbp-1Ch]
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = 0LL;
do
{
v6 = *v2;
v4 = roundf(*v2);
if ( fabs(v6 - v4) < 0.0001 && v6 > 0.0 && (int)v4 % 2 == 1 )
v3 += (int)v4 * (int)v4;
++v2;
}
while ( &a1[a2] != v2 );
return v3;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x00101530
MOVSXD RSI,ESI
MOV RBX,RDI
XOR R12D,R12D
LEA RBP,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_001014a8:
MOVSS XMM2,dword ptr [RBX]
MOVAPS XMM0,XMM2
MOVSS dword ptr [RSP + 0xc],XMM2
CALL 0x00101070
MOVSS XMM2,dword ptr [RSP + 0xc]
PXOR XMM1,XMM1
PXOR XMM3,XMM3
MOVSD XMM4,qword ptr [0x00102190]
CVTSS2SD XMM3,XMM0
CVTSS2SD XMM1,XMM2
SUBSD XMM1,XMM3
ANDPD XMM1,xmmword ptr [0x00102160]
COMISD XMM4,XMM1
JBE 0x00101518
PXOR XMM5,XMM5
COMISS XMM2,XMM5
JBE 0x00101518
CVTTSS2SI EDX,XMM0
MOV ECX,EDX
SHR ECX,0x1f
LEA EAX,[RDX + RCX*0x1]
AND EAX,0x1
SUB EAX,ECX
CMP EAX,0x1
JNZ 0x00101518
IMUL EDX,EDX
MOVSXD RDX,EDX
ADD R12,RDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101518:
ADD RBX,0x4
CMP RBP,RBX
JNZ 0x001014a8
ADD RSP,0x10
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
LAB_00101530:
ADD RSP,0x10
XOR R12D,R12D
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long func0(float *param_1,int param_2)
{
float *pfVar1;
float __x;
int iVar2;
long lVar3;
float fVar4;
if (0 < param_2) {
lVar3 = 0;
pfVar1 = param_1 + param_2;
do {
__x = *param_1;
fVar4 = roundf(__x);
if ((double)((ulong)((double)__x - (double)fVar4) & _DAT_00102160) < DAT_00102190) {
if ((0.0 < __x) && (iVar2 = (int)fVar4, iVar2 % 2 == 1)) {
lVar3 = lVar3 + iVar2 * iVar2;
}
}
param_1 = param_1 + 1;
} while (pfVar1 != param_1);
return lVar3;
}
return 0;
}
|
1,264 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,5,0,0,0,4}, (const int[]){4,1,1,0,0,-2}, result, 6);
assert(issame(result, (const int[]){4,4,1,0,0,6}, 6));
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,0,0,0,0,0}, (const int[]){0,0,0,0,0,0}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,0,0}, 6));
func0((const int[]){1,2,3}, (const int[]){-1,-2,-3}, result, 3);
assert(issame(result, (const int[]){2,4,6}, 3));
func0((const int[]){1,2,3,5}, (const int[]){-1,2,3,4}, result, 4);
assert(issame(result, (const int[]){2,0,0,1}, 4));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d9 <func0+0x70>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rdx,%rcx
cltd
xor %edx,%eax
sub %edx,%eax
mov %eax,(%rcx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1189 <func0+0x20>
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11DA
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_20]
add rdx, rcx
mov edx, [rdx]
sub eax, edx
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov ecx, eax
neg ecx
cmovns eax, ecx
mov [rdx], eax
add [rbp+var_4], 1
loc_11DA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_1189
nop
nop
pop rbp
retn
|
long long func0(long long a1, long long a2, long long a3, int a4)
{
int v4; // eax
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
v4 = *(_DWORD *)(4LL * (int)i + a1) - *(_DWORD *)(4LL * (int)i + a2);
if ( *(_DWORD *)(4LL * (int)i + a2) - *(_DWORD *)(4LL * (int)i + a1) >= 0 )
v4 = *(_DWORD *)(4LL * (int)i + a2) - *(_DWORD *)(4LL * (int)i + a1);
*(_DWORD *)(4LL * (int)i + a3) = v4;
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011da
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV EDX,dword ptr [RDX]
SUB EAX,EDX
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011da:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101189
NOP
NOP
POP RBP
RET
|
void func0(long param_1,long param_2,long param_3,int param_4)
{
int iVar1;
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
iVar1 = *(int *)(param_1 + (long)local_c * 4) - *(int *)(param_2 + (long)local_c * 4);
if (iVar1 < 1) {
iVar1 = -iVar1;
}
*(int *)(param_3 + (long)local_c * 4) = iVar1;
}
return;
}
|
1,265 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,5,0,0,0,4}, (const int[]){4,1,1,0,0,-2}, result, 6);
assert(issame(result, (const int[]){4,4,1,0,0,6}, 6));
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,0,0,0,0,0}, (const int[]){0,0,0,0,0,0}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,0,0}, 6));
func0((const int[]){1,2,3}, (const int[]){-1,-2,-3}, result, 3);
assert(issame(result, (const int[]){2,4,6}, 3));
func0((const int[]){1,2,3,5}, (const int[]){-1,2,3,4}, result, 4);
assert(issame(result, (const int[]){2,0,0,1}, 4));
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %ecx,%ecx
jle 119d <func0+0x34>
lea -0x1(%rcx),%r9d
mov $0x0,%eax
mov (%rdi,%rax,4),%ecx
sub (%rsi,%rax,4),%ecx
mov %ecx,%r8d
sar $0x1f,%r8d
xor %r8d,%ecx
mov %ecx,(%rdx,%rax,4)
sub %r8d,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r9,%rcx
jne 117a <func0+0x11>
retq
|
func0:
endbr64
mov r9, rdi
test ecx, ecx
jle short locret_119E
movsxd rcx, ecx
lea r8, ds:0[rcx*4]
mov eax, 0
loc_1184:
mov ecx, [r9+rax]
sub ecx, [rsi+rax]
mov edi, ecx
neg edi
cmovns ecx, edi
mov [rdx+rax], ecx
add rax, 4
cmp rax, r8
jnz short loc_1184
locret_119E:
retn
|
void func0(long long a1, long long a2, long long a3, int a4)
{
long long v4; // r8
long long v5; // rax
int v6; // ecx
if ( a4 > 0 )
{
v4 = 4LL * a4;
v5 = 0LL;
do
{
v6 = *(_DWORD *)(a1 + v5) - *(_DWORD *)(a2 + v5);
if ( *(_DWORD *)(a2 + v5) - *(_DWORD *)(a1 + v5) >= 0 )
v6 = *(_DWORD *)(a2 + v5) - *(_DWORD *)(a1 + v5);
*(_DWORD *)(a3 + v5) = v6;
v5 += 4LL;
}
while ( v5 != v4 );
}
}
|
func0:
ENDBR64
MOV R9,RDI
TEST ECX,ECX
JLE 0x0010119e
MOVSXD RCX,ECX
LEA R8,[RCX*0x4]
MOV EAX,0x0
LAB_00101184:
MOV ECX,dword ptr [R9 + RAX*0x1]
SUB ECX,dword ptr [RSI + RAX*0x1]
MOV EDI,ECX
NEG EDI
CMOVNS ECX,EDI
MOV dword ptr [RDX + RAX*0x1],ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x00101184
LAB_0010119e:
RET
|
void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
int iVar2;
if (0 < param_4) {
lVar1 = 0;
do {
iVar2 = *(int *)(param_1 + lVar1) - *(int *)(param_2 + lVar1);
if (iVar2 < 1) {
iVar2 = -iVar2;
}
*(int *)(param_3 + lVar1) = iVar2;
lVar1 = lVar1 + 4;
} while (lVar1 != (long)param_4 * 4);
}
return;
}
|
1,266 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,5,0,0,0,4}, (const int[]){4,1,1,0,0,-2}, result, 6);
assert(issame(result, (const int[]){4,4,1,0,0,6}, 6));
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,0,0,0,0,0}, (const int[]){0,0,0,0,0,0}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,0,0}, 6));
func0((const int[]){1,2,3}, (const int[]){-1,-2,-3}, result, 3);
assert(issame(result, (const int[]){2,4,6}, 3));
func0((const int[]){1,2,3,5}, (const int[]){-1,2,3,4}, result, 4);
assert(issame(result, (const int[]){2,0,0,1}, 4));
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %ecx,%ecx
jle 15b3 <func0+0x33>
lea -0x1(%rcx),%r9d
xor %eax,%eax
xchg %ax,%ax
mov (%rdi,%rax,4),%ecx
sub (%rsi,%rax,4),%ecx
mov %ecx,%r8d
sar $0x1f,%r8d
xor %r8d,%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
sub %r8d,(%rdx,%rax,4)
add $0x1,%rax
cmp %r9,%rcx
jne 1590 <func0+0x10>
retq
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
mov r9, rdi
test ecx, ecx
jle short locret_159A
movsxd rcx, ecx
xor eax, eax
lea r8, ds:0[rcx*4]
nop dword ptr [rax+rax+00000000h]
loc_1580:
mov ecx, [r9+rax]
sub ecx, [rsi+rax]
mov edi, ecx
neg edi
cmovns ecx, edi
mov [rdx+rax], ecx
add rax, 4
cmp r8, rax
jnz short loc_1580
locret_159A:
retn
|
void func0(long long a1, long long a2, long long a3, int a4)
{
long long v4; // rax
long long v5; // r8
int v6; // ecx
if ( a4 > 0 )
{
v4 = 0LL;
v5 = 4LL * a4;
do
{
v6 = *(_DWORD *)(a1 + v4) - *(_DWORD *)(a2 + v4);
if ( *(_DWORD *)(a2 + v4) - *(_DWORD *)(a1 + v4) >= 0 )
v6 = *(_DWORD *)(a2 + v4) - *(_DWORD *)(a1 + v4);
*(_DWORD *)(a3 + v4) = v6;
v4 += 4LL;
}
while ( v5 != v4 );
}
}
|
func0:
ENDBR64
MOV R9,RDI
TEST ECX,ECX
JLE 0x0010159a
MOVSXD RCX,ECX
XOR EAX,EAX
LEA R8,[RCX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101580:
MOV ECX,dword ptr [R9 + RAX*0x1]
SUB ECX,dword ptr [RSI + RAX*0x1]
MOV EDI,ECX
NEG EDI
CMOVNS ECX,EDI
MOV dword ptr [RDX + RAX*0x1],ECX
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101580
LAB_0010159a:
RET
|
void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
int iVar2;
if (0 < param_4) {
lVar1 = 0;
do {
iVar2 = *(int *)(param_1 + lVar1) - *(int *)(param_2 + lVar1);
if (iVar2 < 1) {
iVar2 = -iVar2;
}
*(int *)(param_3 + lVar1) = iVar2;
lVar1 = lVar1 + 4;
} while ((long)param_4 * 4 - lVar1 != 0);
}
return;
}
|
1,267 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* game, int* guess, int* out, int length) {
for (int i = 0; i < length; i++) {
out[i] = abs(game[i] - guess[i]);
}
}
|
#include <assert.h>
#include <string.h>
int issame(int* a, int* b, int length) {
for (int i = 0; i < length; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[6];
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,5,0,0,0,4}, (const int[]){4,1,1,0,0,-2}, result, 6);
assert(issame(result, (const int[]){4,4,1,0,0,6}, 6));
func0((const int[]){1,2,3,4,5,1}, (const int[]){1,2,3,4,2,-2}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,3,3}, 6));
func0((const int[]){0,0,0,0,0,0}, (const int[]){0,0,0,0,0,0}, result, 6);
assert(issame(result, (const int[]){0,0,0,0,0,0}, 6));
func0((const int[]){1,2,3}, (const int[]){-1,-2,-3}, result, 3);
assert(issame(result, (const int[]){2,4,6}, 3));
func0((const int[]){1,2,3,5}, (const int[]){-1,2,3,4}, result, 4);
assert(issame(result, (const int[]){2,0,0,1}, 4));
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %ecx,%ecx
jle 154b <func0+0x11b>
lea 0xf(%rdi),%r8
lea -0x1(%rcx),%eax
sub %rdx,%r8
cmp $0x1e,%r8
seta %r9b
cmp $0x2,%eax
seta %r8b
test %r8b,%r9b
je 1520 <func0+0xf0>
lea 0xf(%rsi),%r8
sub %rdx,%r8
cmp $0x1e,%r8
jbe 1520 <func0+0xf0>
mov %ecx,%r8d
xor %eax,%eax
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax)
movdqu (%rdi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm2
psubd %xmm2,%xmm0
movdqa %xmm0,%xmm1
psrad $0x1f,%xmm1
pxor %xmm1,%xmm0
psubd %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 1480 <func0+0x50>
mov %ecx,%eax
and $0xfffffffc,%eax
test $0x3,%cl
je 154b <func0+0x11b>
mov %eax,%r9d
mov (%rdi,%r9,4),%r8d
sub (%rsi,%r9,4),%r8d
mov %r8d,%r10d
sar $0x1f,%r10d
xor %r10d,%r8d
mov %r8d,(%rdx,%r9,4)
lea 0x1(%rax),%r8d
sub %r10d,(%rdx,%r9,4)
cmp %r8d,%ecx
jle 154b <func0+0x11b>
movslq %r8d,%r8
add $0x2,%eax
mov (%rdi,%r8,4),%r9d
sub (%rsi,%r8,4),%r9d
mov %r9d,%r10d
sar $0x1f,%r10d
xor %r10d,%r9d
mov %r9d,(%rdx,%r8,4)
sub %r10d,(%rdx,%r8,4)
cmp %eax,%ecx
jle 154b <func0+0x11b>
cltq
mov (%rdi,%rax,4),%ecx
sub (%rsi,%rax,4),%ecx
mov %ecx,%esi
sar $0x1f,%esi
xor %esi,%ecx
mov %ecx,(%rdx,%rax,4)
sub %esi,(%rdx,%rax,4)
retq
nopw 0x0(%rax,%rax,1)
mov %eax,%r9d
xor %eax,%eax
nopl (%rax)
mov (%rdi,%rax,4),%ecx
sub (%rsi,%rax,4),%ecx
mov %ecx,%r8d
sar $0x1f,%r8d
xor %r8d,%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
sub %r8d,(%rdx,%rax,4)
add $0x1,%rax
cmp %r9,%rcx
jne 1528 <func0+0xf8>
retq
nopl 0x0(%rax)
|
func0:
endbr64
mov r8, rdi
mov rdi, rdx
movsxd rdx, ecx
mov r9, rsi
test edx, edx
jle locret_136B
lea eax, [rdx-1]
cmp eax, 2
jbe loc_1340
lea rcx, [r8+4]
mov rax, rdi
sub rax, rcx
cmp rax, 8
jbe loc_1340
lea rcx, [rsi+4]
mov rax, rdi
sub rax, rcx
cmp rax, 8
jbe loc_1340
mov ecx, edx
xor eax, eax
shr ecx, 2
shl rcx, 4
nop word ptr [rax+rax+00000000h]
loc_12A0:
movdqu xmm0, xmmword ptr [r8+rax]
movdqu xmm2, xmmword ptr [r9+rax]
psubd xmm0, xmm2
movdqa xmm1, xmm0
psrad xmm1, 1Fh
pxor xmm0, xmm1
psubd xmm0, xmm1
movups xmmword ptr [rdi+rax], xmm0
add rax, 10h
cmp rax, rcx
jnz short loc_12A0
mov ecx, edx
and ecx, 0FFFFFFFCh
test dl, 3
jz locret_136B
mov r10d, ecx
mov esi, [r8+r10*4]
sub esi, [r9+r10*4]
lea rax, ds:0[r10*4]
mov r11d, esi
neg r11d
cmovns esi, r11d
mov [rdi+r10*4], esi
lea esi, [rcx+1]
cmp edx, esi
jle short locret_136B
mov esi, [r8+rax+4]
sub esi, [r9+rax+4]
mov r10d, esi
neg r10d
cmovns esi, r10d
add ecx, 2
mov [rdi+rax+4], esi
cmp edx, ecx
jle short locret_136B
mov edx, [r8+rax+8]
sub edx, [r9+rax+8]
mov ecx, edx
neg ecx
cmovns edx, ecx
mov [rdi+rax+8], edx
retn
loc_1340:
lea rsi, ds:0[rdx*4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1350:
mov edx, [r8+rax]
sub edx, [r9+rax]
mov ecx, edx
neg ecx
cmovns edx, ecx
mov [rdi+rax], edx
add rax, 4
cmp rsi, rax
jnz short loc_1350
locret_136B:
retn
|
void func0(long long a1, long long a2, long long a3, int a4)
{
long long v8; // rax
__m128i v9; // xmm0
__m128i v10; // xmm1
unsigned int v11; // ecx
int v12; // esi
long long v13; // rax
int v14; // esi
int v15; // edx
long long v16; // rax
int v17; // edx
if ( a4 > 0 )
{
if ( (unsigned int)(a4 - 1) <= 2 || (unsigned long long)(a3 - (a1 + 4)) <= 8 || (unsigned long long)(a3 - (a2 + 4)) <= 8 )
{
v16 = 0LL;
do
{
v17 = *(_DWORD *)(a1 + v16) - *(_DWORD *)(a2 + v16);
if ( *(_DWORD *)(a2 + v16) - *(_DWORD *)(a1 + v16) >= 0 )
v17 = *(_DWORD *)(a2 + v16) - *(_DWORD *)(a1 + v16);
*(_DWORD *)(a3 + v16) = v17;
v16 += 4LL;
}
while ( 4LL * a4 != v16 );
}
else
{
v8 = 0LL;
do
{
v9 = _mm_sub_epi32(_mm_loadu_si128((const __m128i *)(a1 + v8)), _mm_loadu_si128((const __m128i *)(a2 + v8)));
v10 = _mm_srai_epi32(v9, 0x1Fu);
*(__m128i *)(a3 + v8) = _mm_sub_epi32(_mm_xor_si128(v9, v10), v10);
v8 += 16LL;
}
while ( v8 != 16LL * ((unsigned int)a4 >> 2) );
v11 = a4 & 0xFFFFFFFC;
if ( (a4 & 3) != 0 )
{
v12 = *(_DWORD *)(a1 + 4LL * v11) - *(_DWORD *)(a2 + 4LL * v11);
v13 = 4LL * v11;
if ( *(_DWORD *)(a2 + v13) - *(_DWORD *)(a1 + v13) >= 0 )
v12 = *(_DWORD *)(a2 + 4LL * v11) - *(_DWORD *)(a1 + 4LL * v11);
*(_DWORD *)(a3 + 4LL * v11) = v12;
if ( a4 > (int)(v11 + 1) )
{
v14 = *(_DWORD *)(a1 + v13 + 4) - *(_DWORD *)(a2 + v13 + 4);
if ( *(_DWORD *)(a2 + v13 + 4) - *(_DWORD *)(a1 + v13 + 4) >= 0 )
v14 = *(_DWORD *)(a2 + v13 + 4) - *(_DWORD *)(a1 + v13 + 4);
*(_DWORD *)(a3 + v13 + 4) = v14;
if ( a4 > (int)(v11 + 2) )
{
v15 = *(_DWORD *)(a1 + v13 + 8) - *(_DWORD *)(a2 + v13 + 8);
if ( *(_DWORD *)(a2 + v13 + 8) - *(_DWORD *)(a1 + v13 + 8) >= 0 )
v15 = *(_DWORD *)(a2 + v13 + 8) - *(_DWORD *)(a1 + v13 + 8);
*(_DWORD *)(a3 + v13 + 8) = v15;
}
}
}
}
}
}
|
func0:
ENDBR64
MOV R8,RDI
MOV RDI,RDX
MOVSXD RDX,ECX
MOV R9,RSI
TEST EDX,EDX
JLE 0x0010136b
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x00101340
LEA RCX,[R8 + 0x4]
MOV RAX,RDI
SUB RAX,RCX
CMP RAX,0x8
JBE 0x00101340
LEA RCX,[RSI + 0x4]
MOV RAX,RDI
SUB RAX,RCX
CMP RAX,0x8
JBE 0x00101340
MOV ECX,EDX
XOR EAX,EAX
SHR ECX,0x2
SHL RCX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_001012a0:
MOVDQU XMM0,xmmword ptr [R8 + RAX*0x1]
MOVDQU XMM2,xmmword ptr [R9 + RAX*0x1]
PSUBD XMM0,XMM2
MOVDQA XMM1,XMM0
PSRAD XMM1,0x1f
PXOR XMM0,XMM1
PSUBD XMM0,XMM1
MOVUPS xmmword ptr [RDI + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x001012a0
MOV ECX,EDX
AND ECX,0xfffffffc
TEST DL,0x3
JZ 0x0010136b
MOV R10D,ECX
MOV ESI,dword ptr [R8 + R10*0x4]
SUB ESI,dword ptr [R9 + R10*0x4]
LEA RAX,[R10*0x4]
MOV R11D,ESI
NEG R11D
CMOVNS ESI,R11D
MOV dword ptr [RDI + R10*0x4],ESI
LEA ESI,[RCX + 0x1]
CMP EDX,ESI
JLE 0x0010136b
MOV ESI,dword ptr [R8 + RAX*0x1 + 0x4]
SUB ESI,dword ptr [R9 + RAX*0x1 + 0x4]
MOV R10D,ESI
NEG R10D
CMOVNS ESI,R10D
ADD ECX,0x2
MOV dword ptr [RDI + RAX*0x1 + 0x4],ESI
CMP EDX,ECX
JLE 0x0010136b
MOV EDX,dword ptr [R8 + RAX*0x1 + 0x8]
SUB EDX,dword ptr [R9 + RAX*0x1 + 0x8]
MOV ECX,EDX
NEG ECX
CMOVNS EDX,ECX
MOV dword ptr [RDI + RAX*0x1 + 0x8],EDX
RET
LAB_00101340:
LEA RSI,[RDX*0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101350:
MOV EDX,dword ptr [R8 + RAX*0x1]
SUB EDX,dword ptr [R9 + RAX*0x1]
MOV ECX,EDX
NEG ECX
CMOVNS EDX,ECX
MOV dword ptr [RDI + RAX*0x1],EDX
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x00101350
LAB_0010136b:
RET
|
void func0(long param_1,long param_2,long param_3,uint param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
long lVar9;
int iVar10;
ulong uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
if (0 < (int)param_4) {
if (((param_4 - 1 < 3) || ((ulong)(param_3 - (param_1 + 4)) < 9)) ||
((ulong)(param_3 - (param_2 + 4)) < 9)) {
lVar9 = 0;
do {
iVar10 = *(int *)(param_1 + lVar9) - *(int *)(param_2 + lVar9);
if (iVar10 < 1) {
iVar10 = -iVar10;
}
*(int *)(param_3 + lVar9) = iVar10;
lVar9 = lVar9 + 4;
} while ((long)(int)param_4 * 4 - lVar9 != 0);
}
else {
lVar9 = 0;
do {
piVar1 = (int *)(param_1 + lVar9);
iVar10 = piVar1[1];
iVar4 = piVar1[2];
iVar5 = piVar1[3];
piVar2 = (int *)(param_2 + lVar9);
iVar6 = piVar2[1];
iVar7 = piVar2[2];
iVar8 = piVar2[3];
uVar12 = *piVar1 - *piVar2 >> 0x1f;
uVar13 = iVar10 - iVar6 >> 0x1f;
uVar14 = iVar4 - iVar7 >> 0x1f;
uVar15 = iVar5 - iVar8 >> 0x1f;
piVar3 = (int *)(param_3 + lVar9);
*piVar3 = (*piVar1 - *piVar2 ^ uVar12) - uVar12;
piVar3[1] = (iVar10 - iVar6 ^ uVar13) - uVar13;
piVar3[2] = (iVar4 - iVar7 ^ uVar14) - uVar14;
piVar3[3] = (iVar5 - iVar8 ^ uVar15) - uVar15;
lVar9 = lVar9 + 0x10;
} while (lVar9 != (ulong)(param_4 >> 2) << 4);
uVar12 = param_4 & 0xfffffffc;
if (((long)(int)param_4 & 3U) != 0) {
uVar11 = (ulong)uVar12;
iVar10 = *(int *)(param_1 + uVar11 * 4) - *(int *)(param_2 + uVar11 * 4);
lVar9 = uVar11 * 4;
if (iVar10 < 1) {
iVar10 = -iVar10;
}
*(int *)(param_3 + uVar11 * 4) = iVar10;
if ((int)(uVar12 + 1) < (int)param_4) {
iVar10 = *(int *)(param_1 + 4 + lVar9) - *(int *)(param_2 + 4 + lVar9);
if (iVar10 < 1) {
iVar10 = -iVar10;
}
*(int *)(param_3 + 4 + lVar9) = iVar10;
if ((int)(uVar12 + 2) < (int)param_4) {
iVar10 = *(int *)(param_1 + 8 + lVar9) - *(int *)(param_2 + 8 + lVar9);
if (iVar10 < 1) {
iVar10 = -iVar10;
}
*(int *)(param_3 + 8 + lVar9) = iVar10;
return;
}
}
}
}
}
return;
}
|
1,268 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++) {
char chr = extension[j];
if (chr >= 'A' && chr <= 'Z') strength++;
if (chr >= 'a' && chr <= 'z') strength--;
}
if (strength > max_strength) {
max_strength = strength;
strongest = extension;
}
}
sprintf(output, "%s.%s", class_name, strongest);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tmp2, 4, result);
assert(strcmp(result, "Boku123.YEs.WeCaNe") == 0);
const char* tmp3[] = {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123NoooneB321"};
func0("__YESIMHERE", tmp3, 6, result);
assert(strcmp(result, "__YESIMHERE.NuLl__") == 0);
const char* tmp4[] = {"Ta", "TAR", "t234An", "cosSo"};
func0("K", tmp4, 4, result);
assert(strcmp(result, "K.TAR") == 0);
const char* tmp5[] = {"Tab", "123", "781345", "-_-"};
func0("__HAHA", tmp5, 4, result);
assert(strcmp(result, "__HAHA.123") == 0);
const char* tmp[] = {"HhAas", "okIWILL123", "WorkOut", "Fails", "-_-"};
func0("YameRore", tmp, 5, result);
assert(strcmp(result, "YameRore.okIWILL123") == 0);
const char* tmp6[] = {"Die", "NowW", "Wow", "WoW"};
func0("finNNalLLly", tmp6, 4, result);
assert(strcmp(result, "finNNalLLly.WoW") == 0);
const char* tmp7[] = {"Bb", "91245"};
func0("_", tmp7, 2, result);
assert(strcmp(result, "_.Bb") == 0);
const char* tmp8[] = {"671235", "Bb"};
func0("Sp", tmp8, 2, result);
assert(strcmp(result, "Sp.671235") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x44(%rbp)
mov %rcx,-0x50(%rbp)
movl $0xfffffc18,-0x20(%rbp)
movq $0x0,-0x10(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 126f <func0+0xc6>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1241 <func0+0x98>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x21(%rbp)
cmpb $0x40,-0x21(%rbp)
jle 122d <func0+0x84>
cmpb $0x5a,-0x21(%rbp)
jg 122d <func0+0x84>
addl $0x1,-0x18(%rbp)
cmpb $0x60,-0x21(%rbp)
jle 123d <func0+0x94>
cmpb $0x7a,-0x21(%rbp)
jg 123d <func0+0x94>
subl $0x1,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 120a <func0+0x61>
mov -0x18(%rbp),%eax
cmp -0x20(%rbp),%eax
jle 126b <func0+0xc2>
mov -0x18(%rbp),%eax
mov %eax,-0x20(%rbp)
mov -0x8(%rbp),%rax
mov %rax,-0x10(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 11df <func0+0x36>
mov -0x10(%rbp),%rcx
mov -0x38(%rbp),%rdx
mov -0x50(%rbp),%rax
lea 0xd7a(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10b0 <sprintf@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov [rbp+s], rcx
mov [rbp+var_20], 0FFFFFC18h
mov [rbp+var_10], 0
mov [rbp+var_1C], 0
jmp loc_126F
loc_11DF:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_40]
add rax, rdx
mov rax, [rax]
mov [rbp+var_8], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_1241
loc_120A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_21], al
cmp [rbp+var_21], 40h ; '@'
jle short loc_122D
cmp [rbp+var_21], 5Ah ; 'Z'
jg short loc_122D
add [rbp+var_18], 1
loc_122D:
cmp [rbp+var_21], 60h ; '`'
jle short loc_123D
cmp [rbp+var_21], 7Ah ; 'z'
jg short loc_123D
sub [rbp+var_18], 1
loc_123D:
add [rbp+var_14], 1
loc_1241:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_120A
mov eax, [rbp+var_18]
cmp eax, [rbp+var_20]
jle short loc_126B
mov eax, [rbp+var_18]
mov [rbp+var_20], eax
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
loc_126B:
add [rbp+var_1C], 1
loc_126F:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_44]
jl loc_11DF
mov rcx, [rbp+var_10]
mov rdx, [rbp+var_38]
mov rax, [rbp+s]
lea rsi, format; "%s.%s"
mov rdi, rax; s
mov eax, 0
call _sprintf
nop
leave
retn
|
int func0(const char *a1, long long a2, int a3, char *a4)
{
char v5; // [rsp+2Fh] [rbp-21h]
int v6; // [rsp+30h] [rbp-20h]
int i; // [rsp+34h] [rbp-1Ch]
int v8; // [rsp+38h] [rbp-18h]
int j; // [rsp+3Ch] [rbp-14h]
const char *v10; // [rsp+40h] [rbp-10h]
long long v11; // [rsp+48h] [rbp-8h]
v6 = -1000;
v10 = 0LL;
for ( i = 0; i < a3; ++i )
{
v11 = *(_QWORD *)(8LL * i + a2);
v8 = 0;
for ( j = 0; *(_BYTE *)(j + v11); ++j )
{
v5 = *(_BYTE *)(j + v11);
if ( v5 > 64 && v5 <= 90 )
++v8;
if ( v5 > 96 && v5 <= 122 )
--v8;
}
if ( v8 > v6 )
{
v6 = v8;
v10 = *(const char **)(8LL * i + a2);
}
}
return sprintf(a4, "%s.%s", a1, v10);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV qword ptr [RBP + -0x50],RCX
MOV dword ptr [RBP + -0x20],0xfffffc18
MOV qword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010126f
LAB_001011df:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101241
LAB_0010120a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
CMP byte ptr [RBP + -0x21],0x40
JLE 0x0010122d
CMP byte ptr [RBP + -0x21],0x5a
JG 0x0010122d
ADD dword ptr [RBP + -0x18],0x1
LAB_0010122d:
CMP byte ptr [RBP + -0x21],0x60
JLE 0x0010123d
CMP byte ptr [RBP + -0x21],0x7a
JG 0x0010123d
SUB dword ptr [RBP + -0x18],0x1
LAB_0010123d:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101241:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010120a
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x0010126b
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_0010126b:
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010126f:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x001011df
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x50]
LEA RSI,[0x102008]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010b0
NOP
LEAVE
RET
|
void func0(int8 param_1,long param_2,int param_3,char *param_4)
{
char cVar1;
long lVar2;
int local_28;
int local_24;
int local_20;
int local_1c;
long local_18;
local_28 = -1000;
local_18 = 0;
for (local_24 = 0; local_24 < param_3; local_24 = local_24 + 1) {
lVar2 = *(long *)(param_2 + (long)local_24 * 8);
local_20 = 0;
for (local_1c = 0; *(char *)(lVar2 + local_1c) != '\0'; local_1c = local_1c + 1) {
cVar1 = *(char *)(lVar2 + local_1c);
if (('@' < cVar1) && (cVar1 < '[')) {
local_20 = local_20 + 1;
}
if (('`' < cVar1) && (cVar1 < '{')) {
local_20 = local_20 + -1;
}
}
if (local_28 < local_20) {
local_28 = local_20;
local_18 = lVar2;
}
}
sprintf(param_4,"%s.%s",param_1,local_18);
return;
}
|
1,269 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++) {
char chr = extension[j];
if (chr >= 'A' && chr <= 'Z') strength++;
if (chr >= 'a' && chr <= 'z') strength--;
}
if (strength > max_strength) {
max_strength = strength;
strongest = extension;
}
}
sprintf(output, "%s.%s", class_name, strongest);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tmp2, 4, result);
assert(strcmp(result, "Boku123.YEs.WeCaNe") == 0);
const char* tmp3[] = {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123NoooneB321"};
func0("__YESIMHERE", tmp3, 6, result);
assert(strcmp(result, "__YESIMHERE.NuLl__") == 0);
const char* tmp4[] = {"Ta", "TAR", "t234An", "cosSo"};
func0("K", tmp4, 4, result);
assert(strcmp(result, "K.TAR") == 0);
const char* tmp5[] = {"Tab", "123", "781345", "-_-"};
func0("__HAHA", tmp5, 4, result);
assert(strcmp(result, "__HAHA.123") == 0);
const char* tmp[] = {"HhAas", "okIWILL123", "WorkOut", "Fails", "-_-"};
func0("YameRore", tmp, 5, result);
assert(strcmp(result, "YameRore.okIWILL123") == 0);
const char* tmp6[] = {"Die", "NowW", "Wow", "WoW"};
func0("finNNalLLly", tmp6, 4, result);
assert(strcmp(result, "finNNalLLly.WoW") == 0);
const char* tmp7[] = {"Bb", "91245"};
func0("_", tmp7, 2, result);
assert(strcmp(result, "_.Bb") == 0);
const char* tmp8[] = {"671235", "Bb"};
func0("Sp", tmp8, 2, result);
assert(strcmp(result, "Sp.671235") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r8
mov %rcx,%rbp
test %edx,%edx
jle 1204 <func0+0x7b>
mov %rsi,%r10
lea -0x1(%rdx),%eax
lea 0x8(%rsi,%rax,8),%rbx
mov $0x0,%r9d
mov $0xfffffc18,%edi
jmp 11ee <func0+0x65>
sub $0x61,%eax
cmp $0x1a,%al
sbb $0x0,%ecx
add $0x1,%rdx
movzbl -0x1(%rdx),%eax
test %al,%al
je 11dc <func0+0x53>
lea -0x41(%rax),%esi
cmp $0x19,%sil
ja 11b5 <func0+0x2c>
add $0x1,%ecx
jmp 11bd <func0+0x34>
mov $0x0,%ecx
cmp %ecx,%edi
jge 11e5 <func0+0x5c>
mov %r11,%r9
mov %ecx,%edi
add $0x8,%r10
cmp %rbx,%r10
je 120a <func0+0x81>
mov (%r10),%r11
movzbl (%r11),%eax
test %al,%al
je 11d7 <func0+0x4e>
lea 0x1(%r11),%rdx
mov $0x0,%ecx
jmp 11c9 <func0+0x40>
mov $0x0,%r9d
lea 0xdf3(%rip),%rcx
mov $0xffffffffffffffff,%rdx
mov $0x1,%esi
mov %rbp,%rdi
mov $0x0,%eax
callq 1090 <__sprintf_chk@plt>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov r8, rdi
mov rbp, rcx
test edx, edx
jle short loc_1226
mov rdi, rsi
movsxd rdx, edx
lea rbx, [rsi+rdx*8]
mov r9d, 0
mov r11d, 0FFFFFC18h
jmp short loc_1210
loc_11D5:
sub eax, 61h ; 'a'
cmp al, 1Ah
sbb ecx, 0
loc_11DD:
add rdx, 1
movzx eax, byte ptr [rdx-1]
test al, al
jz short loc_11FC
loc_11E9:
lea esi, [rax-41h]
cmp sil, 19h
ja short loc_11D5
add ecx, 1
jmp short loc_11DD
loc_11F7:
mov ecx, 0
loc_11FC:
cmp r11d, ecx
jge short loc_1207
mov r9, r10
mov r11d, ecx
loc_1207:
add rdi, 8
cmp rdi, rbx
jz short loc_122C
loc_1210:
mov r10, [rdi]
movzx eax, byte ptr [r10]
test al, al
jz short loc_11F7
lea rdx, [r10+1]
mov ecx, 0
jmp short loc_11E9
loc_1226:
mov r9d, 0
loc_122C:
lea rcx, aSS; "%s.%s"
mov rdx, 0FFFFFFFFFFFFFFFFh
mov esi, 2
mov rdi, rbp
mov eax, 0
call ___sprintf_chk
add rsp, 8
pop rbx
pop rbp
retn
|
long long func0(const char *a1, const char **a2, int a3, long long a4)
{
const char **v6; // rdi
const char **v7; // rbx
const char *v8; // r9
int v9; // r11d
int v10; // ecx
char *v11; // rdx
char v12; // al
if ( a3 <= 0 )
{
v8 = 0LL;
}
else
{
v6 = a2;
v7 = &a2[a3];
v8 = 0LL;
v9 = -1000;
do
{
v12 = **v6;
if ( v12 )
{
v11 = (char *)(*v6 + 1);
v10 = 0;
do
{
if ( (unsigned __int8)(v12 - 65) > 0x19u )
v10 -= (unsigned __int8)(v12 - 97) < 0x1Au;
else
++v10;
v12 = *v11++;
}
while ( v12 );
}
else
{
v10 = 0;
}
if ( v9 < v10 )
{
v8 = *v6;
v9 = v10;
}
++v6;
}
while ( v6 != v7 );
}
return __sprintf_chk(a4, 2LL, -1LL, "%s.%s", a1, v8);
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R8,RDI
MOV RBP,RCX
TEST EDX,EDX
JLE 0x00101226
MOV RDI,RSI
MOVSXD RDX,EDX
LEA RBX,[RSI + RDX*0x8]
MOV R9D,0x0
MOV R11D,0xfffffc18
JMP 0x00101210
LAB_001011d5:
SUB EAX,0x61
CMP AL,0x1a
SBB ECX,0x0
LAB_001011dd:
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX + -0x1]
TEST AL,AL
JZ 0x001011fc
LAB_001011e9:
LEA ESI,[RAX + -0x41]
CMP SIL,0x19
JA 0x001011d5
ADD ECX,0x1
JMP 0x001011dd
LAB_001011f7:
MOV ECX,0x0
LAB_001011fc:
CMP R11D,ECX
JGE 0x00101207
MOV R9,R10
MOV R11D,ECX
LAB_00101207:
ADD RDI,0x8
CMP RDI,RBX
JZ 0x0010122c
LAB_00101210:
MOV R10,qword ptr [RDI]
MOVZX EAX,byte ptr [R10]
TEST AL,AL
JZ 0x001011f7
LEA RDX,[R10 + 0x1]
MOV ECX,0x0
JMP 0x001011e9
LAB_00101226:
MOV R9D,0x0
LAB_0010122c:
LEA RCX,[0x102004]
MOV RDX,-0x1
MOV ESI,0x2
MOV RDI,RBP
MOV EAX,0x0
CALL 0x001010b0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void func0(int8 param_1,int8 *param_2,int param_3,int8 param_4)
{
int8 *puVar1;
char cVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
char *pcVar6;
int iVar7;
if (param_3 < 1) {
pcVar6 = (char *)0x0;
}
else {
puVar1 = param_2 + param_3;
pcVar6 = (char *)0x0;
iVar7 = -1000;
do {
pcVar3 = (char *)*param_2;
cVar2 = *pcVar3;
if (cVar2 == '\0') {
iVar4 = 0;
}
else {
iVar4 = 0;
pcVar5 = pcVar3;
do {
pcVar5 = pcVar5 + 1;
if ((byte)(cVar2 + 0xbfU) < 0x1a) {
iVar4 = iVar4 + 1;
}
else {
iVar4 = iVar4 - (uint)((byte)(cVar2 + 0x9fU) < 0x1a);
}
cVar2 = *pcVar5;
} while (cVar2 != '\0');
}
if (iVar7 < iVar4) {
pcVar6 = pcVar3;
iVar7 = iVar4;
}
param_2 = param_2 + 1;
} while (param_2 != puVar1);
}
__sprintf_chk(param_4,2,0xffffffffffffffff,"%s.%s",param_1,pcVar6);
return;
}
|
1,270 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++) {
char chr = extension[j];
if (chr >= 'A' && chr <= 'Z') strength++;
if (chr >= 'a' && chr <= 'z') strength--;
}
if (strength > max_strength) {
max_strength = strength;
strongest = extension;
}
}
sprintf(output, "%s.%s", class_name, strongest);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tmp2, 4, result);
assert(strcmp(result, "Boku123.YEs.WeCaNe") == 0);
const char* tmp3[] = {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123NoooneB321"};
func0("__YESIMHERE", tmp3, 6, result);
assert(strcmp(result, "__YESIMHERE.NuLl__") == 0);
const char* tmp4[] = {"Ta", "TAR", "t234An", "cosSo"};
func0("K", tmp4, 4, result);
assert(strcmp(result, "K.TAR") == 0);
const char* tmp5[] = {"Tab", "123", "781345", "-_-"};
func0("__HAHA", tmp5, 4, result);
assert(strcmp(result, "__HAHA.123") == 0);
const char* tmp[] = {"HhAas", "okIWILL123", "WorkOut", "Fails", "-_-"};
func0("YameRore", tmp, 5, result);
assert(strcmp(result, "YameRore.okIWILL123") == 0);
const char* tmp6[] = {"Die", "NowW", "Wow", "WoW"};
func0("finNNalLLly", tmp6, 4, result);
assert(strcmp(result, "finNNalLLly.WoW") == 0);
const char* tmp7[] = {"Bb", "91245"};
func0("_", tmp7, 2, result);
assert(strcmp(result, "_.Bb") == 0);
const char* tmp8[] = {"671235", "Bb"};
func0("Sp", tmp8, 2, result);
assert(strcmp(result, "Sp.671235") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbp
mov %rdi,%r8
mov %rcx,%rdi
push %rbx
test %edx,%edx
jle 17e4 <func0+0xa4>
lea -0x1(%rdx),%eax
mov %rsi,%r10
xor %r9d,%r9d
mov $0xfffffc18,%ebx
lea 0x8(%rsi,%rax,8),%rbp
nopw 0x0(%rax,%rax,1)
mov (%r10),%r11
movzbl (%r11),%eax
test %al,%al
je 17e0 <func0+0xa0>
lea 0x1(%r11),%rdx
xor %ecx,%ecx
jmp 1796 <func0+0x56>
nopl 0x0(%rax,%rax,1)
movzbl (%rdx),%eax
add $0x1,%rdx
add $0x1,%ecx
test %al,%al
je 17b2 <func0+0x72>
lea -0x41(%rax),%esi
cmp $0x19,%sil
jbe 1788 <func0+0x48>
sub $0x61,%eax
cmp $0x1a,%al
sbb $0x0,%ecx
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 1796 <func0+0x56>
cmp %ecx,%ebx
jge 17bb <func0+0x7b>
mov %r11,%r9
mov %ecx,%ebx
add $0x8,%r10
cmp %rbp,%r10
jne 1770 <func0+0x30>
pop %rbx
lea 0x838(%rip),%rcx
mov $0xffffffffffffffff,%rdx
pop %rbp
mov $0x1,%esi
xor %eax,%eax
jmpq 1090 <__sprintf_chk@plt>
xor %ecx,%ecx
jmp 17b2 <func0+0x72>
xor %r9d,%r9d
jmp 17c4 <func0+0x84>
nopl 0x0(%rax)
|
func0:
endbr64
push rbp
mov r8, rdi
mov r11, rcx
push rbx
test edx, edx
jle loc_1854
movsxd rdx, edx
xor r9d, r9d
mov ebx, 0FFFFFC18h
lea rbp, [rsi+rdx*8]
nop dword ptr [rax+rax+00h]
loc_17D8:
mov r10, [rsi]
movzx eax, byte ptr [r10]
test al, al
jz short loc_1850
lea rdx, [r10+1]
xor ecx, ecx
jmp short loc_17FE
loc_17F0:
movzx eax, byte ptr [rdx]
add rdx, 1
add ecx, 1
test al, al
jz short loc_181A
loc_17FE:
lea edi, [rax-41h]
cmp dil, 19h
jbe short loc_17F0
sub eax, 61h ; 'a'
cmp al, 1Ah
sbb ecx, 0
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jnz short loc_17FE
loc_181A:
cmp ebx, ecx
jge short loc_1823
mov r9, r10
mov ebx, ecx
loc_1823:
add rsi, 8
cmp rbp, rsi
jnz short loc_17D8
loc_182C:
pop rbx
lea rcx, aSS; "%s.%s"
mov rdx, 0FFFFFFFFFFFFFFFFh
pop rbp
mov esi, 2
mov rdi, r11
xor eax, eax
jmp ___sprintf_chk
loc_1850:
xor ecx, ecx
jmp short loc_181A
loc_1854:
xor r9d, r9d
jmp short loc_182C
|
long long func0(const char *a1, const char **a2, int a3, long long a4)
{
const char *v6; // r9
int v7; // ebx
const char **v8; // rbp
char v9; // al
char *v10; // rdx
int v11; // ecx
if ( a3 <= 0 )
{
v6 = 0LL;
}
else
{
v6 = 0LL;
v7 = -1000;
v8 = &a2[a3];
do
{
v9 = **a2;
if ( v9 )
{
v10 = (char *)(*a2 + 1);
v11 = 0;
do
{
while ( (unsigned __int8)(v9 - 65) <= 0x19u )
{
v9 = *v10++;
++v11;
if ( !v9 )
goto LABEL_8;
}
v11 -= (unsigned __int8)(v9 - 97) < 0x1Au;
v9 = *v10++;
}
while ( v9 );
}
else
{
v11 = 0;
}
LABEL_8:
if ( v7 < v11 )
{
v6 = *a2;
v7 = v11;
}
++a2;
}
while ( v8 != a2 );
}
return _sprintf_chk(a4, 2LL, -1LL, "%s.%s", a1, v6);
}
|
func0:
ENDBR64
PUSH RBP
MOV R8,RDI
MOV R11,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x00101854
MOVSXD RDX,EDX
XOR R9D,R9D
MOV EBX,0xfffffc18
LEA RBP,[RSI + RDX*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001017d8:
MOV R10,qword ptr [RSI]
MOVZX EAX,byte ptr [R10]
TEST AL,AL
JZ 0x00101850
LEA RDX,[R10 + 0x1]
XOR ECX,ECX
JMP 0x001017fe
LAB_001017f0:
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
ADD ECX,0x1
TEST AL,AL
JZ 0x0010181a
LAB_001017fe:
LEA EDI,[RAX + -0x41]
CMP DIL,0x19
JBE 0x001017f0
SUB EAX,0x61
CMP AL,0x1a
SBB ECX,0x0
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JNZ 0x001017fe
LAB_0010181a:
CMP EBX,ECX
JGE 0x00101823
MOV R9,R10
MOV EBX,ECX
LAB_00101823:
ADD RSI,0x8
CMP RBP,RSI
JNZ 0x001017d8
LAB_0010182c:
POP RBX
LEA RCX,[0x102004]
MOV RDX,-0x1
POP RBP
MOV ESI,0x2
MOV RDI,R11
XOR EAX,EAX
JMP 0x00101090
LAB_00101850:
XOR ECX,ECX
JMP 0x0010181a
LAB_00101854:
XOR R9D,R9D
JMP 0x0010182c
|
void func0(int8 param_1,int8 *param_2,int param_3,int8 param_4)
{
int8 *puVar1;
char *pcVar2;
char cVar3;
int iVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
if (param_3 < 1) {
pcVar7 = (char *)0x0;
}
else {
pcVar7 = (char *)0x0;
iVar6 = -1000;
puVar1 = param_2 + param_3;
do {
pcVar2 = (char *)*param_2;
cVar3 = *pcVar2;
if (cVar3 == '\0') {
iVar4 = 0;
}
else {
pcVar5 = pcVar2 + 1;
iVar4 = 0;
do {
while (0x19 < (byte)(cVar3 + 0xbfU)) {
iVar4 = iVar4 - (uint)((byte)(cVar3 + 0x9fU) < 0x1a);
cVar3 = *pcVar5;
pcVar5 = pcVar5 + 1;
if (cVar3 == '\0') goto LAB_0010181a;
}
cVar3 = *pcVar5;
pcVar5 = pcVar5 + 1;
iVar4 = iVar4 + 1;
} while (cVar3 != '\0');
}
LAB_0010181a:
if (iVar6 < iVar4) {
pcVar7 = pcVar2;
iVar6 = iVar4;
}
param_2 = param_2 + 1;
} while (puVar1 != param_2);
}
__sprintf_chk(param_4,2,0xffffffffffffffff,"%s.%s",param_1,pcVar7);
return;
}
|
1,271 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* class_name, const char** extensions, int ext_count, char* output) {
int max_strength = -1000;
const char* strongest = NULL;
for (int i = 0; i < ext_count; i++) {
const char* extension = extensions[i];
int strength = 0;
for (int j = 0; extension[j] != '\0'; j++) {
char chr = extension[j];
if (chr >= 'A' && chr <= 'Z') strength++;
if (chr >= 'a' && chr <= 'z') strength--;
}
if (strength > max_strength) {
max_strength = strength;
strongest = extension;
}
}
sprintf(output, "%s.%s", class_name, strongest);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[50];
const char* tmp1[] = {"tEN", "niNE", "eIGHt8OKe"};
func0("Watashi", tmp1, 3, result);
assert(strcmp(result, "Watashi.eIGHt8OKe") == 0);
const char* tmp2[] = {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"};
func0("Boku123", tmp2, 4, result);
assert(strcmp(result, "Boku123.YEs.WeCaNe") == 0);
const char* tmp3[] = {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123NoooneB321"};
func0("__YESIMHERE", tmp3, 6, result);
assert(strcmp(result, "__YESIMHERE.NuLl__") == 0);
const char* tmp4[] = {"Ta", "TAR", "t234An", "cosSo"};
func0("K", tmp4, 4, result);
assert(strcmp(result, "K.TAR") == 0);
const char* tmp5[] = {"Tab", "123", "781345", "-_-"};
func0("__HAHA", tmp5, 4, result);
assert(strcmp(result, "__HAHA.123") == 0);
const char* tmp[] = {"HhAas", "okIWILL123", "WorkOut", "Fails", "-_-"};
func0("YameRore", tmp, 5, result);
assert(strcmp(result, "YameRore.okIWILL123") == 0);
const char* tmp6[] = {"Die", "NowW", "Wow", "WoW"};
func0("finNNalLLly", tmp6, 4, result);
assert(strcmp(result, "finNNalLLly.WoW") == 0);
const char* tmp7[] = {"Bb", "91245"};
func0("_", tmp7, 2, result);
assert(strcmp(result, "_.Bb") == 0);
const char* tmp8[] = {"671235", "Bb"};
func0("Sp", tmp8, 2, result);
assert(strcmp(result, "Sp.671235") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbp
mov %rdi,%r8
mov %rcx,%rdi
push %rbx
test %edx,%edx
jle 1864 <func0+0xa4>
lea -0x1(%rdx),%eax
mov %rsi,%r10
xor %r9d,%r9d
mov $0xfffffc18,%ebx
lea 0x8(%rsi,%rax,8),%rbp
nopw 0x0(%rax,%rax,1)
mov (%r10),%r11
movzbl (%r11),%eax
test %al,%al
je 1860 <func0+0xa0>
lea 0x1(%r11),%rdx
xor %ecx,%ecx
jmp 1816 <func0+0x56>
nopl 0x0(%rax,%rax,1)
movzbl (%rdx),%eax
add $0x1,%rdx
add $0x1,%ecx
test %al,%al
je 1832 <func0+0x72>
lea -0x41(%rax),%esi
cmp $0x19,%sil
jbe 1808 <func0+0x48>
sub $0x61,%eax
cmp $0x1a,%al
sbb $0x0,%ecx
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 1816 <func0+0x56>
cmp %ecx,%ebx
jge 183b <func0+0x7b>
mov %r11,%r9
mov %ecx,%ebx
add $0x8,%r10
cmp %rbp,%r10
jne 17f0 <func0+0x30>
pop %rbx
lea 0x7b8(%rip),%rcx
mov $0xffffffffffffffff,%rdx
pop %rbp
mov $0x1,%esi
xor %eax,%eax
jmpq 1090 <__sprintf_chk@plt>
xor %ecx,%ecx
jmp 1832 <func0+0x72>
xor %r9d,%r9d
jmp 1844 <func0+0x84>
nopl 0x0(%rax)
|
func0:
endbr64
push rbp
mov r8, rdi
mov r11, rcx
push rbx
test edx, edx
jle loc_1854
movsxd rdx, edx
xor r9d, r9d
mov ebx, 0FFFFFC18h
lea rbp, [rsi+rdx*8]
nop dword ptr [rax+rax+00h]
loc_17D8:
mov r10, [rsi]
movzx eax, byte ptr [r10]
test al, al
jz short loc_1850
lea rdx, [r10+1]
xor ecx, ecx
jmp short loc_17FE
loc_17F0:
movzx eax, byte ptr [rdx]
add rdx, 1
add ecx, 1
test al, al
jz short loc_181A
loc_17FE:
lea edi, [rax-41h]
cmp dil, 19h
jbe short loc_17F0
sub eax, 61h ; 'a'
cmp al, 1Ah
sbb ecx, 0
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jnz short loc_17FE
loc_181A:
cmp ebx, ecx
jge short loc_1823
mov r9, r10
mov ebx, ecx
loc_1823:
add rsi, 8
cmp rbp, rsi
jnz short loc_17D8
loc_182C:
pop rbx
lea rcx, aSS; "%s.%s"
mov rdx, 0FFFFFFFFFFFFFFFFh
pop rbp
mov esi, 2
mov rdi, r11
xor eax, eax
jmp ___sprintf_chk
loc_1850:
xor ecx, ecx
jmp short loc_181A
loc_1854:
xor r9d, r9d
jmp short loc_182C
|
long long func0(const char *a1, const char **a2, int a3, long long a4)
{
const char *v6; // r9
int v7; // ebx
const char **v8; // rbp
char v9; // al
char *v10; // rdx
int v11; // ecx
if ( a3 <= 0 )
{
v6 = 0LL;
}
else
{
v6 = 0LL;
v7 = -1000;
v8 = &a2[a3];
do
{
v9 = **a2;
if ( v9 )
{
v10 = (char *)(*a2 + 1);
v11 = 0;
do
{
while ( (unsigned __int8)(v9 - 65) <= 0x19u )
{
v9 = *v10++;
++v11;
if ( !v9 )
goto LABEL_8;
}
v11 -= (unsigned __int8)(v9 - 97) < 0x1Au;
v9 = *v10++;
}
while ( v9 );
}
else
{
v11 = 0;
}
LABEL_8:
if ( v7 < v11 )
{
v6 = *a2;
v7 = v11;
}
++a2;
}
while ( v8 != a2 );
}
return _sprintf_chk(a4, 2LL, -1LL, "%s.%s", a1, v6);
}
|
func0:
ENDBR64
PUSH RBP
MOV R8,RDI
MOV R11,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x00101854
MOVSXD RDX,EDX
XOR R9D,R9D
MOV EBX,0xfffffc18
LEA RBP,[RSI + RDX*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_001017d8:
MOV R10,qword ptr [RSI]
MOVZX EAX,byte ptr [R10]
TEST AL,AL
JZ 0x00101850
LEA RDX,[R10 + 0x1]
XOR ECX,ECX
JMP 0x001017fe
LAB_001017f0:
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
ADD ECX,0x1
TEST AL,AL
JZ 0x0010181a
LAB_001017fe:
LEA EDI,[RAX + -0x41]
CMP DIL,0x19
JBE 0x001017f0
SUB EAX,0x61
CMP AL,0x1a
SBB ECX,0x0
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JNZ 0x001017fe
LAB_0010181a:
CMP EBX,ECX
JGE 0x00101823
MOV R9,R10
MOV EBX,ECX
LAB_00101823:
ADD RSI,0x8
CMP RBP,RSI
JNZ 0x001017d8
LAB_0010182c:
POP RBX
LEA RCX,[0x102004]
MOV RDX,-0x1
POP RBP
MOV ESI,0x2
MOV RDI,R11
XOR EAX,EAX
JMP 0x00101090
LAB_00101850:
XOR ECX,ECX
JMP 0x0010181a
LAB_00101854:
XOR R9D,R9D
JMP 0x0010182c
|
void func0(int8 param_1,int8 *param_2,int param_3,int8 param_4)
{
int8 *puVar1;
char *pcVar2;
char cVar3;
int iVar4;
char *pcVar5;
int iVar6;
char *pcVar7;
if (param_3 < 1) {
pcVar7 = (char *)0x0;
}
else {
pcVar7 = (char *)0x0;
iVar6 = -1000;
puVar1 = param_2 + param_3;
do {
pcVar2 = (char *)*param_2;
cVar3 = *pcVar2;
if (cVar3 == '\0') {
iVar4 = 0;
}
else {
pcVar5 = pcVar2 + 1;
iVar4 = 0;
do {
while (0x19 < (byte)(cVar3 + 0xbfU)) {
iVar4 = iVar4 - (uint)((byte)(cVar3 + 0x9fU) < 0x1a);
cVar3 = *pcVar5;
pcVar5 = pcVar5 + 1;
if (cVar3 == '\0') goto LAB_0010181a;
}
cVar3 = *pcVar5;
pcVar5 = pcVar5 + 1;
iVar4 = iVar4 + 1;
} while (cVar3 != '\0');
}
LAB_0010181a:
if (iVar6 < iVar4) {
pcVar7 = pcVar2;
iVar6 = iVar4;
}
param_2 = param_2 + 1;
} while (puVar1 != param_2);
}
__sprintf_chk(param_4,2,0xffffffffffffffff,"%s.%s",param_1,pcVar7);
return;
}
|
1,272 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
|
bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp)) {
free(temp);
return true;
}
}
free(temp);
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,-0x10(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
add %eax,%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 12cb <func0+0xe2>
mov -0xc(%rbp),%eax
sub -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x14(%rbp),%eax
movslq %eax,%rcx
mov -0x30(%rbp),%rax
add %rax,%rcx
mov -0x8(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 10b0 <strncpy@plt>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0xc(%rbp),%eax
movslq %eax,%rcx
mov -0x14(%rbp),%eax
cltq
sub %rax,%rcx
mov -0x8(%rbp),%rax
add %rax,%rcx
mov -0x30(%rbp),%rax
mov %rax,%rsi
mov %rcx,%rdi
callq 10b0 <strncpy@plt>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10f0 <strstr@plt>
test %rax,%rax
je 12c7 <func0+0xde>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov $0x1,%eax
jmp 12e8 <func0+0xff>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0xc(%rbp),%eax
jl 123d <func0+0x54>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov $0x0,%eax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+src], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], eax
mov rax, [rbp+src]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add eax, eax
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
mov [rbp+var_14], 0
jmp loc_12CB
loc_123D:
mov eax, [rbp+var_C]
sub eax, [rbp+var_14]
movsxd rdx, eax; n
mov eax, [rbp+var_14]
movsxd rcx, eax
mov rax, [rbp+src]
add rcx, rax
mov rax, [rbp+dest]
mov rsi, rcx; src
mov rdi, rax; dest
call _strncpy
mov eax, [rbp+var_14]
movsxd rdx, eax; n
mov eax, [rbp+var_C]
movsxd rcx, eax
mov eax, [rbp+var_14]
cdqe
sub rcx, rax
mov rax, [rbp+dest]
add rcx, rax
mov rax, [rbp+src]
mov rsi, rax; src
mov rdi, rcx; dest
call _strncpy
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+dest]
add rax, rdx
mov byte ptr [rax], 0
mov rdx, [rbp+dest]
mov rax, [rbp+s]
mov rsi, rdx; needle
mov rdi, rax; haystack
call _strstr
test rax, rax
jz short loc_12C7
mov rax, [rbp+dest]
mov rdi, rax; ptr
call _free
mov eax, 1
jmp short locret_12E8
loc_12C7:
add [rbp+var_14], 1
loc_12CB:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_C]
jl loc_123D
mov rax, [rbp+dest]
mov rdi, rax; ptr
call _free
mov eax, 0
locret_12E8:
leave
retn
|
long long func0(const char *a1, const char *a2)
{
int i; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+24h] [rbp-Ch]
char *dest; // [rsp+28h] [rbp-8h]
strlen(a1);
v4 = strlen(a2);
dest = (char *)malloc(2 * v4 + 1);
for ( i = 0; i < v4; ++i )
{
strncpy(dest, &a2[i], v4 - i);
strncpy(&dest[v4 - (long long)i], a2, i);
dest[v4] = 0;
if ( strstr(a1, dest) )
{
free(dest);
return 1LL;
}
}
free(dest);
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0x10],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EAX
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012cb
LAB_0010123d:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RCX,EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RAX
MOV RDI,RCX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010f0
TEST RAX,RAX
JZ 0x001012c7
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,0x1
JMP 0x001012e8
LAB_001012c7:
ADD dword ptr [RBP + -0x14],0x1
LAB_001012cb:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0xc]
JL 0x0010123d
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,0x0
LAB_001012e8:
LEAVE
RET
|
int8 func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
char *__dest;
char *pcVar3;
int local_1c;
strlen(param_1);
sVar2 = strlen(param_2);
iVar1 = (int)sVar2;
__dest = (char *)malloc((long)(iVar1 * 2 + 1));
local_1c = 0;
while( true ) {
if (iVar1 <= local_1c) {
free(__dest);
return 0;
}
strncpy(__dest,param_2 + local_1c,(long)(iVar1 - local_1c));
strncpy(__dest + ((long)iVar1 - (long)local_1c),param_2,(long)local_1c);
__dest[iVar1] = '\0';
pcVar3 = strstr(param_1,__dest);
if (pcVar3 != (char *)0x0) break;
local_1c = local_1c + 1;
}
free(__dest);
return 1;
}
|
1,273 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
|
bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp)) {
free(temp);
return true;
}
}
free(temp);
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r14
mov %rsi,%r13
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
lea 0x1(%rbx,%rbx,1),%edi
movslq %edi,%rdi
callq 10c0 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
jle 1265 <func0+0x9c>
mov %ebx,%r12d
lea -0x1(%rbx),%r15d
mov $0x0,%ebx
movslq %r12d,%r12
jmp 1220 <func0+0x57>
mov %rax,%rbx
mov %r12,%rdx
sub %rbx,%rdx
lea 0x0(%r13,%rbx,1),%rsi
mov %rbp,%rdi
callq 10a0 <strncpy@plt>
lea 0x0(%rbp,%r12,1),%rdi
sub %rbx,%rdi
mov %rbx,%rdx
mov %r13,%rsi
callq 10a0 <strncpy@plt>
movb $0x0,0x0(%rbp,%r12,1)
mov %rbp,%rsi
mov %r14,%rdi
callq 10d0 <strstr@plt>
test %rax,%rax
jne 1281 <func0+0xb8>
lea 0x1(%rbx),%rax
cmp %r15,%rbx
jne 121d <func0+0x54>
mov %rbp,%rdi
callq 1090 <free@plt>
mov $0x0,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rbp,%rdi
callq 1090 <free@plt>
mov $0x1,%eax
jmp 1272 <func0+0xa9>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+haystack], rdi
mov r14, rsi
mov rdi, rsi; s
call _strlen
mov rbx, rax
lea r13d, [rax+rax+1]
movsxd r13, r13d
mov rdi, r13; size
call _malloc
mov r12, rax
test ebx, ebx
jle short loc_1292
movsxd r15, ebx
lea eax, [rbx-1]
mov [rsp+48h+var_40], rax
mov rbx, r15
mov ebp, 0
jmp short loc_123C
loc_1239:
mov rbp, rax
loc_123C:
lea rsi, [r14+rbp]
mov rcx, r13
mov rdx, rbx
mov rdi, r12
call ___strncpy_chk
cmp r13, rbx
mov rcx, rbx
cmovnb rcx, r13
sub rcx, rbx
lea rdi, [r12+rbx]
mov rdx, rbp
mov rsi, r14
call ___strncpy_chk
mov byte ptr [r12+r15], 0
mov rsi, r12; needle
mov rdi, [rsp+48h+haystack]; haystack
call _strstr
test rax, rax
jnz short loc_12AE
lea rax, [rbp+1]
sub rbx, 1
mov rdx, [rsp+48h+var_40]
cmp rbp, rdx
jnz short loc_1239
loc_1292:
mov rdi, r12; ptr
call _free
mov eax, 0
loc_129F:
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12AE:
mov rdi, r12; ptr
call _free
mov eax, 1
jmp short loc_129F
|
long long func0(const char *a1, const char *a2)
{
size_t v2; // rbx
size_t v3; // r13
char *v4; // r12
long long v5; // r15
long long i; // rbp
size_t v7; // rcx
long long v9; // [rsp+8h] [rbp-40h]
LODWORD(v2) = strlen(a2);
v3 = 2 * (int)v2 + 1;
v4 = (char *)malloc(v3);
if ( (int)v2 <= 0 )
{
LABEL_8:
free(v4);
return 0LL;
}
else
{
v5 = (int)v2;
v9 = (unsigned int)(v2 - 1);
v2 = (int)v2;
for ( i = 0LL; ; ++i )
{
__strncpy_chk(v4, &a2[i], v2, v3);
v7 = v2;
if ( v3 >= v2 )
v7 = v3;
__strncpy_chk(&v4[v2], a2, i, v7 - v2);
v4[v5] = 0;
if ( strstr(a1, v4) )
break;
--v2;
if ( i == v9 )
goto LABEL_8;
}
free(v4);
return 1LL;
}
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RDI
MOV R14,RSI
MOV RDI,RSI
CALL 0x001010b0
MOV RBX,RAX
LEA R13D,[RAX + RAX*0x1 + 0x1]
MOVSXD R13,R13D
MOV RDI,R13
CALL 0x001010d0
MOV R12,RAX
TEST EBX,EBX
JLE 0x00101292
MOVSXD R15,EBX
LEA EAX,[RBX + -0x1]
MOV qword ptr [RSP + 0x8],RAX
MOV RBX,R15
MOV EBP,0x0
JMP 0x0010123c
LAB_00101239:
MOV RBP,RAX
LAB_0010123c:
LEA RSI,[R14 + RBP*0x1]
MOV RCX,R13
MOV RDX,RBX
MOV RDI,R12
CALL 0x001010e0
CMP R13,RBX
MOV RCX,RBX
CMOVNC RCX,R13
SUB RCX,RBX
LEA RDI,[R12 + RBX*0x1]
MOV RDX,RBP
MOV RSI,R14
CALL 0x001010e0
MOV byte ptr [R12 + R15*0x1],0x0
MOV RSI,R12
MOV RDI,qword ptr [RSP]
CALL 0x001010f0
TEST RAX,RAX
JNZ 0x001012ae
LEA RAX,[RBP + 0x1]
SUB RBX,0x1
MOV RDX,qword ptr [RSP + 0x8]
CMP RBP,RDX
JNZ 0x00101239
LAB_00101292:
MOV RDI,R12
CALL 0x001010a0
MOV EAX,0x0
LAB_0010129f:
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012ae:
MOV RDI,R12
CALL 0x001010a0
MOV EAX,0x1
JMP 0x0010129f
|
int8 func0(char *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
char *__needle;
char *pcVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
bool bVar7;
sVar2 = strlen(param_2);
iVar1 = (int)sVar2;
sVar2 = (size_t)(iVar1 * 2 + 1);
__needle = (char *)malloc(sVar2);
if (0 < iVar1) {
uVar5 = (long)iVar1;
uVar6 = 0;
do {
__strncpy_chk(__needle,param_2 + uVar6,uVar5,sVar2);
uVar4 = uVar5;
if (uVar5 <= sVar2) {
uVar4 = sVar2;
}
__strncpy_chk(__needle + uVar5,param_2,uVar6,uVar4 - uVar5);
__needle[iVar1] = '\0';
pcVar3 = strstr(param_1,__needle);
if (pcVar3 != (char *)0x0) {
free(__needle);
return 1;
}
uVar5 = uVar5 - 1;
bVar7 = uVar6 != iVar1 - 1;
uVar6 = uVar6 + 1;
} while (bVar7);
}
free(__needle);
return 0;
}
|
1,274 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
|
bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp)) {
free(temp);
return true;
}
}
free(temp);
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
mov %rsi,%rdi
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
callq 10c0 <strlen@plt>
lea 0x1(%rax,%rax,1),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r15
test %ebx,%ebx
jle 1418 <func0+0xb8>
movslq %ebx,%r14
lea (%rax,%r14,1),%r12
lea -0x1(%rbx),%eax
xor %ebx,%ebx
mov %rax,0x8(%rsp)
jmp 13be <func0+0x5e>
nopl (%rax)
lea 0x1(%rbx),%rax
cmp 0x8(%rsp),%rbx
je 1418 <func0+0xb8>
mov %rax,%rbx
mov %r14,%rdx
lea 0x0(%rbp,%rbx,1),%rsi
mov %r15,%rdi
sub %rbx,%rdx
callq 10b0 <strncpy@plt>
mov %r12,%rdi
mov %rbp,%rsi
mov %rbx,%rdx
sub %rbx,%rdi
callq 10b0 <strncpy@plt>
movb $0x0,(%r12)
mov %r15,%rsi
mov %r13,%rdi
callq 10f0 <strstr@plt>
test %rax,%rax
je 13b0 <func0+0x50>
mov %r15,%rdi
callq 10a0 <free@plt>
add $0x18,%rsp
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov %r15,%rdi
callq 10a0 <free@plt>
add $0x18,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+haystack], rdi
mov rdi, rsi; s
call _strlen
lea ebx, [rax+rax+1]
mov r15, rax
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov rbp, rax
test r15d, r15d
jle loc_1440
movsxd r14, r15d
lea r13, [rax+r14]
lea eax, [r15-1]
xor r15d, r15d
mov [rsp+58h+var_48], r13
mov [rsp+58h+var_40], rax
jmp short loc_13DA
loc_13C0:
mov rdx, [rsp+58h+var_40]
lea rax, [r15+1]
sub r14, 1
cmp r15, rdx
jz short loc_1440
mov r15, rax
lea r13, [rbp+r14+0]
loc_13DA:
lea rsi, [r12+r15]
mov rcx, rbx
mov rdx, r14
mov rdi, rbp
call ___strncpy_chk
cmp rbx, r14
mov rcx, r14
mov rsi, r12
cmovnb rcx, rbx
mov rdi, r13
mov rdx, r15
sub rcx, r14
call ___strncpy_chk
mov rax, [rsp+58h+var_48]
mov rdi, [rsp+58h+haystack]; haystack
mov rsi, rbp; needle
mov byte ptr [rax], 0
call _strstr
test rax, rax
jz short loc_13C0
mov rdi, rbp; ptr
call _free
add rsp, 28h
mov eax, 1
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1440:
mov rdi, rbp; ptr
call _free
add rsp, 28h
xor eax, eax
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
long long func0(const char *a1, const char *a2)
{
int v2; // r15d
size_t v3; // rbx
char *v4; // rax
char *v5; // rbp
size_t v6; // r14
char *v7; // r13
long long v8; // rax
long long v9; // r15
size_t v10; // rcx
char *v12; // [rsp+10h] [rbp-48h]
long long v13; // [rsp+18h] [rbp-40h]
v2 = strlen(a2);
v3 = 2 * v2 + 1;
v4 = (char *)malloc(v3);
v5 = v4;
if ( v2 <= 0 )
{
LABEL_9:
free(v5);
return 0LL;
}
else
{
v6 = v2;
v7 = &v4[v2];
v8 = (unsigned int)(v2 - 1);
v9 = 0LL;
v12 = v7;
v13 = v8;
while ( 1 )
{
__strncpy_chk(v5, &a2[v9], v6, v3);
v10 = v6;
if ( v3 >= v6 )
v10 = v3;
__strncpy_chk(v7, a2, v9, v10 - v6);
*v12 = 0;
if ( strstr(a1, v5) )
break;
--v6;
if ( v9 == v13 )
goto LABEL_9;
++v9;
v7 = &v5[v6];
}
free(v5);
return 1LL;
}
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,RSI
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1 + 0x1]
MOV R15,RAX
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x001010d0
MOV RBP,RAX
TEST R15D,R15D
JLE 0x00101440
MOVSXD R14,R15D
LEA R13,[RAX + R14*0x1]
LEA EAX,[R15 + -0x1]
XOR R15D,R15D
MOV qword ptr [RSP + 0x10],R13
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001013da
LAB_001013c0:
MOV RDX,qword ptr [RSP + 0x18]
LEA RAX,[R15 + 0x1]
SUB R14,0x1
CMP R15,RDX
JZ 0x00101440
MOV R15,RAX
LEA R13,[RBP + R14*0x1]
LAB_001013da:
LEA RSI,[R12 + R15*0x1]
MOV RCX,RBX
MOV RDX,R14
MOV RDI,RBP
CALL 0x001010e0
CMP RBX,R14
MOV RCX,R14
MOV RSI,R12
CMOVNC RCX,RBX
MOV RDI,R13
MOV RDX,R15
SUB RCX,R14
CALL 0x001010e0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBP
MOV byte ptr [RAX],0x0
CALL 0x001010f0
TEST RAX,RAX
JZ 0x001013c0
MOV RDI,RBP
CALL 0x001010a0
ADD RSP,0x28
MOV EAX,0x1
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101440:
MOV RDI,RBP
CALL 0x001010a0
ADD RSP,0x28
XOR EAX,EAX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
int8 func0(char *param_1,char *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *__needle;
char *pcVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
__needle = (char *)malloc(sVar3);
if (0 < iVar2) {
uVar6 = (ulong)iVar2;
pcVar1 = __needle + uVar6;
pcVar4 = pcVar1;
uVar7 = 0;
while( true ) {
__strncpy_chk(__needle,param_2 + uVar7,uVar6,sVar3);
uVar5 = uVar6;
if (uVar6 <= sVar3) {
uVar5 = sVar3;
}
__strncpy_chk(pcVar4,param_2,uVar7,uVar5 - uVar6);
*pcVar1 = '\0';
pcVar4 = strstr(param_1,__needle);
if (pcVar4 != (char *)0x0) {
free(__needle);
return 1;
}
uVar6 = uVar6 - 1;
if (uVar7 == iVar2 - 1) break;
pcVar4 = __needle + uVar6;
uVar7 = uVar7 + 1;
}
}
free(__needle);
return 0;
}
|
1,275 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
|
bool func0(const char *a, const char *b) {
int len_a = strlen(a);
int len_b = strlen(b);
char *temp = (char *)malloc(2 * len_b + 1);
for (int i = 0; i < len_b; i++) {
strncpy(temp, b + i, len_b - i);
strncpy(temp + len_b - i, b, i);
temp[len_b] = '\0';
if (strstr(a, temp)) {
free(temp);
return true;
}
}
free(temp);
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0("xyzw", "xyw") == false);
assert(func0("yello", "ell") == true);
assert(func0("whattup", "ptut") == false);
assert(func0("efef", "fee") == true);
assert(func0("abab", "aabb") == false);
assert(func0("winemtt", "tinem") == true);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
mov %rsi,%rdi
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x18,%rsp
callq 10c0 <strlen@plt>
lea 0x1(%rax,%rax,1),%edi
mov %rax,%rbx
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r15
test %ebx,%ebx
jle 1418 <func0+0xb8>
movslq %ebx,%r14
lea (%rax,%r14,1),%r12
lea -0x1(%rbx),%eax
xor %ebx,%ebx
mov %rax,0x8(%rsp)
jmp 13be <func0+0x5e>
nopl (%rax)
lea 0x1(%rbx),%rax
cmp 0x8(%rsp),%rbx
je 1418 <func0+0xb8>
mov %rax,%rbx
mov %r14,%rdx
lea 0x0(%rbp,%rbx,1),%rsi
mov %r15,%rdi
sub %rbx,%rdx
callq 10b0 <strncpy@plt>
mov %r12,%rdi
mov %rbp,%rsi
mov %rbx,%rdx
sub %rbx,%rdi
callq 10b0 <strncpy@plt>
movb $0x0,(%r12)
mov %r15,%rsi
mov %r13,%rdi
callq 10f0 <strstr@plt>
test %rax,%rax
je 13b0 <func0+0x50>
mov %r15,%rdi
callq 10a0 <free@plt>
add $0x18,%rsp
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov %r15,%rdi
callq 10a0 <free@plt>
add $0x18,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+haystack], rdi
mov rdi, rsi; s
call _strlen
lea ebx, [rax+rax+1]
mov r15, rax
movsxd rbx, ebx
mov rdi, rbx; size
call _malloc
mov rbp, rax
test r15d, r15d
jle loc_1440
movsxd r14, r15d
lea r13, [rax+r14]
lea eax, [r15-1]
xor r15d, r15d
mov [rsp+58h+var_48], r13
mov [rsp+58h+var_40], rax
jmp short loc_13DA
loc_13C0:
mov rdx, [rsp+58h+var_40]
lea rax, [r15+1]
sub r14, 1
cmp r15, rdx
jz short loc_1440
mov r15, rax
lea r13, [rbp+r14+0]
loc_13DA:
lea rsi, [r12+r15]
mov rcx, rbx
mov rdx, r14
mov rdi, rbp
call ___strncpy_chk
cmp rbx, r14
mov rcx, r14
mov rsi, r12
cmovnb rcx, rbx
mov rdi, r13
mov rdx, r15
sub rcx, r14
call ___strncpy_chk
mov rax, [rsp+58h+var_48]
mov rdi, [rsp+58h+haystack]; haystack
mov rsi, rbp; needle
mov byte ptr [rax], 0
call _strstr
test rax, rax
jz short loc_13C0
mov rdi, rbp; ptr
call _free
add rsp, 28h
mov eax, 1
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1440:
mov rdi, rbp; ptr
call _free
add rsp, 28h
xor eax, eax
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
long long func0(const char *a1, const char *a2)
{
int v2; // r15d
size_t v3; // rbx
char *v4; // rax
char *v5; // rbp
size_t v6; // r14
char *v7; // r13
long long v8; // rax
long long v9; // r15
size_t v10; // rcx
char *v12; // [rsp+10h] [rbp-48h]
long long v13; // [rsp+18h] [rbp-40h]
v2 = strlen(a2);
v3 = 2 * v2 + 1;
v4 = (char *)malloc(v3);
v5 = v4;
if ( v2 <= 0 )
{
LABEL_9:
free(v5);
return 0LL;
}
else
{
v6 = v2;
v7 = &v4[v2];
v8 = (unsigned int)(v2 - 1);
v9 = 0LL;
v12 = v7;
v13 = v8;
while ( 1 )
{
__strncpy_chk(v5, &a2[v9], v6, v3);
v10 = v6;
if ( v3 >= v6 )
v10 = v3;
__strncpy_chk(v7, a2, v9, v10 - v6);
*v12 = 0;
if ( strstr(a1, v5) )
break;
--v6;
if ( v9 == v13 )
goto LABEL_9;
++v9;
v7 = &v5[v6];
}
free(v5);
return 1LL;
}
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,RSI
CALL 0x001010b0
LEA EBX,[RAX + RAX*0x1 + 0x1]
MOV R15,RAX
MOVSXD RBX,EBX
MOV RDI,RBX
CALL 0x001010d0
MOV RBP,RAX
TEST R15D,R15D
JLE 0x00101440
MOVSXD R14,R15D
LEA R13,[RAX + R14*0x1]
LEA EAX,[R15 + -0x1]
XOR R15D,R15D
MOV qword ptr [RSP + 0x10],R13
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001013da
LAB_001013c0:
MOV RDX,qword ptr [RSP + 0x18]
LEA RAX,[R15 + 0x1]
SUB R14,0x1
CMP R15,RDX
JZ 0x00101440
MOV R15,RAX
LEA R13,[RBP + R14*0x1]
LAB_001013da:
LEA RSI,[R12 + R15*0x1]
MOV RCX,RBX
MOV RDX,R14
MOV RDI,RBP
CALL 0x001010e0
CMP RBX,R14
MOV RCX,R14
MOV RSI,R12
CMOVNC RCX,RBX
MOV RDI,R13
MOV RDX,R15
SUB RCX,R14
CALL 0x001010e0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBP
MOV byte ptr [RAX],0x0
CALL 0x001010f0
TEST RAX,RAX
JZ 0x001013c0
MOV RDI,RBP
CALL 0x001010a0
ADD RSP,0x28
MOV EAX,0x1
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101440:
MOV RDI,RBP
CALL 0x001010a0
ADD RSP,0x28
XOR EAX,EAX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
int8 func0(char *param_1,char *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *__needle;
char *pcVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
sVar3 = (size_t)(iVar2 * 2 + 1);
__needle = (char *)malloc(sVar3);
if (0 < iVar2) {
uVar6 = (ulong)iVar2;
pcVar1 = __needle + uVar6;
pcVar4 = pcVar1;
uVar7 = 0;
while( true ) {
__strncpy_chk(__needle,param_2 + uVar7,uVar6,sVar3);
uVar5 = uVar6;
if (uVar6 <= sVar3) {
uVar5 = sVar3;
}
__strncpy_chk(pcVar4,param_2,uVar7,uVar5 - uVar6);
*pcVar1 = '\0';
pcVar4 = strstr(param_1,__needle);
if (pcVar4 != (char *)0x0) {
free(__needle);
return 1;
}
uVar6 = uVar6 - 1;
if (uVar7 == iVar2 - 1) break;
pcVar4 = __needle + uVar6;
uVar7 = uVar7 + 1;
}
}
free(__needle);
return 0;
}
|
1,276 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
result[1] = odd_count;
}
|
#include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, 1}, 2));
func0(3452, result);
assert(issame(result, (const int[]){2, 2}, 2));
func0(346211, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-345821, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-2, result);
assert(issame(result, (const int[]){1, 0}, 2));
func0(-45347, result);
assert(issame(result, (const int[]){2, 3}, 2));
func0(0, result);
assert(issame(result, (const int[]){1, 0}, 2));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x14(%rbp),%eax
sar $0x1f,%eax
xor %eax,-0x14(%rbp)
sub %eax,-0x14(%rbp)
mov -0x14(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 11ef <func0+0x66>
addl $0x1,-0xc(%rbp)
jmp 11f3 <func0+0x6a>
addl $0x1,-0x8(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 11b2 <func0+0x29>
mov -0x20(%rbp),%rax
mov -0xc(%rbp),%edx
mov %edx,(%rax)
mov -0x20(%rbp),%rax
lea 0x4(%rax),%rdx
mov -0x8(%rbp),%eax
mov %eax,(%rdx)
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov eax, [rbp+var_14]
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_14], eax
loc_11B3:
mov edx, [rbp+var_14]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_4], edx
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
jnz short loc_11EE
add [rbp+var_C], 1
jmp short loc_11F2
loc_11EE:
add [rbp+var_8], 1
loc_11F2:
mov eax, [rbp+var_14]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jg short loc_11B3
mov rax, [rbp+var_20]
mov edx, [rbp+var_C]
mov [rax], edx
mov rax, [rbp+var_20]
lea rdx, [rax+4]
mov eax, [rbp+var_8]
mov [rdx], eax
nop
pop rbp
retn
|
long long func0(int a1, _DWORD *a2)
{
int v2; // eax
long long result; // rax
int v4; // [rsp+Ch] [rbp-14h]
int v5; // [rsp+14h] [rbp-Ch]
unsigned int v6; // [rsp+18h] [rbp-8h]
v5 = 0;
v6 = 0;
v2 = a1;
if ( a1 <= 0 )
v2 = -a1;
v4 = v2;
do
{
if ( ((v4 % 10) & 1) != 0 )
++v6;
else
++v5;
v4 /= 10;
}
while ( v4 > 0 );
*a2 = v5;
result = v6;
a2[1] = v6;
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
LAB_001011b3:
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x4],EDX
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011ee
ADD dword ptr [RBP + -0xc],0x1
JMP 0x001011f2
LAB_001011ee:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f2:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JG 0x001011b3
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0xc]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RDX],EAX
NOP
POP RBP
RET
|
void func0(int param_1,int *param_2)
{
int local_1c;
int local_14;
int local_10;
local_14 = 0;
local_10 = 0;
local_1c = param_1;
if (param_1 < 1) {
local_1c = -param_1;
}
do {
if ((local_1c % 10 & 1U) == 0) {
local_14 = local_14 + 1;
}
else {
local_10 = local_10 + 1;
}
local_1c = local_1c / 10;
} while (0 < local_1c);
*param_2 = local_14;
param_2[1] = local_10;
return;
}
|
1,277 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
result[1] = odd_count;
}
|
#include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, 1}, 2));
func0(3452, result);
assert(issame(result, (const int[]){2, 2}, 2));
func0(346211, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-345821, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-2, result);
assert(issame(result, (const int[]){1, 0}, 2));
func0(-45347, result);
assert(issame(result, (const int[]){2, 3}, 2));
func0(0, result);
assert(issame(result, (const int[]){1, 0}, 2));
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %edi,%eax
sar $0x1f,%eax
xor %eax,%edi
sub %eax,%edi
mov $0x0,%ecx
mov $0x0,%r8d
jmp 11c3 <func0+0x3a>
add $0x1,%r8d
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
cmp $0x9,%edi
jle 11ce <func0+0x45>
mov %eax,%edi
test $0x1,%dil
je 11a3 <func0+0x1a>
add $0x1,%ecx
jmp 11a7 <func0+0x1e>
mov %r8d,(%rsi)
mov %ecx,0x4(%rsi)
retq
|
func0:
endbr64
mov edx, edi
neg edx
cmovs edx, edi
mov edi, 0
mov r8d, 0
jmp short loc_11C1
loc_11A1:
add r8d, 1
loc_11A5:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
cmp edx, 9
jle short loc_11CB
mov edx, eax
loc_11C1:
test dl, 1
jz short loc_11A1
add edi, 1
jmp short loc_11A5
loc_11CB:
mov [rsi], r8d
mov [rsi+4], edi
retn
|
long long func0(int a1, _DWORD *a2)
{
int v2; // edx
int v3; // edi
int v4; // r8d
long long result; // rax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = 0;
v4 = 0;
while ( 1 )
{
if ( (v2 & 1) != 0 )
++v3;
else
++v4;
result = (unsigned int)(v2 / 10);
if ( v2 <= 9 )
break;
v2 /= 10;
}
*a2 = v4;
a2[1] = v3;
return result;
}
|
func0:
ENDBR64
MOV EDX,EDI
NEG EDX
CMOVS EDX,EDI
MOV EDI,0x0
MOV R8D,0x0
JMP 0x001011c1
LAB_001011a1:
ADD R8D,0x1
LAB_001011a5:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
CMP EDX,0x9
JLE 0x001011cb
MOV EDX,EAX
LAB_001011c1:
TEST DL,0x1
JZ 0x001011a1
ADD EDI,0x1
JMP 0x001011a5
LAB_001011cb:
MOV dword ptr [RSI],R8D
MOV dword ptr [RSI + 0x4],EDI
RET
|
void func0(uint param_1,int *param_2)
{
bool bVar1;
uint uVar2;
int iVar3;
int iVar4;
uVar2 = -param_1;
if (0 < (int)param_1) {
uVar2 = param_1;
}
iVar3 = 0;
iVar4 = 0;
do {
if ((uVar2 & 1) == 0) {
iVar4 = iVar4 + 1;
}
else {
iVar3 = iVar3 + 1;
}
bVar1 = 9 < (int)uVar2;
uVar2 = (int)uVar2 / 10;
} while (bVar1);
*param_2 = iVar4;
param_2[1] = iVar3;
return;
}
|
1,278 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
result[1] = odd_count;
}
|
#include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, 1}, 2));
func0(3452, result);
assert(issame(result, (const int[]){2, 2}, 2));
func0(346211, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-345821, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-2, result);
assert(issame(result, (const int[]){1, 0}, 2));
func0(-45347, result);
assert(issame(result, (const int[]){2, 3}, 2));
func0(0, result);
assert(issame(result, (const int[]){1, 0}, 2));
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov %edi,%eax
xor %edx,%edx
xor %ecx,%ecx
mov $0xcccccccd,%r8d
sar $0x1f,%eax
xor %eax,%edi
sub %eax,%edi
jmp 1412 <func0+0x32>
nopl 0x0(%rax)
imul %r8,%rax
add $0x1,%ecx
shr $0x23,%rax
cmp $0x9,%edi
jle 142a <func0+0x4a>
mov %eax,%edi
mov %edi,%eax
test $0x1,%dil
je 1400 <func0+0x20>
imul %r8,%rax
add $0x1,%edx
shr $0x23,%rax
cmp $0x9,%edi
jg 1410 <func0+0x30>
mov %ecx,(%rsi)
mov %edx,0x4(%rsi)
retq
|
func0:
endbr64
mov edx, edi
mov r8d, 0CCCCCCCDh
neg edx
cmovs edx, edi
xor ecx, ecx
xor edi, edi
jmp short loc_1422
loc_1410:
imul rax, r8
add edi, 1
shr rax, 23h
cmp edx, 9
jle short loc_1439
loc_1420:
mov edx, eax
loc_1422:
mov eax, edx
test dl, 1
jz short loc_1410
imul rax, r8
add ecx, 1
shr rax, 23h
cmp edx, 9
jg short loc_1420
loc_1439:
mov [rsi], edi
mov [rsi+4], ecx
retn
|
unsigned long long func0(int a1, _DWORD *a2)
{
int v2; // edx
int v3; // ecx
int v4; // edi
unsigned long long result; // rax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = 0;
v4 = 0;
while ( (v2 & 1) == 0 )
{
++v4;
result = (unsigned int)v2 / 0xAuLL;
if ( v2 <= 9 )
goto LABEL_8;
LABEL_5:
v2 = result;
}
++v3;
result = (unsigned int)v2 / 0xAuLL;
if ( v2 > 9 )
goto LABEL_5;
LABEL_8:
*a2 = v4;
a2[1] = v3;
return result;
}
|
func0:
ENDBR64
MOV EDX,EDI
MOV R8D,0xcccccccd
NEG EDX
CMOVS EDX,EDI
XOR ECX,ECX
XOR EDI,EDI
JMP 0x00101422
LAB_00101410:
IMUL RAX,R8
ADD EDI,0x1
SHR RAX,0x23
CMP EDX,0x9
JLE 0x00101439
LAB_00101420:
MOV EDX,EAX
LAB_00101422:
MOV EAX,EDX
TEST DL,0x1
JZ 0x00101410
IMUL RAX,R8
ADD ECX,0x1
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101420
LAB_00101439:
MOV dword ptr [RSI],EDI
MOV dword ptr [RSI + 0x4],ECX
RET
|
void func0(uint param_1,int *param_2)
{
uint uVar1;
int iVar2;
ulong uVar3;
int iVar4;
uVar3 = (ulong)-param_1;
if (0 < (int)param_1) {
uVar3 = (ulong)param_1;
}
iVar2 = 0;
iVar4 = 0;
while( true ) {
if ((uVar3 & 1) == 0) {
iVar4 = iVar4 + 1;
uVar1 = (uint)(uVar3 / 10);
}
else {
iVar2 = iVar2 + 1;
uVar1 = (uint)(uVar3 / 10);
}
if ((int)uVar3 < 10) break;
uVar3 = (ulong)uVar1;
}
*param_2 = iVar4;
param_2[1] = iVar2;
return;
}
|
1,279 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int num, int *result) {
int even_count = 0, odd_count = 0;
num = abs(num);
do {
int digit = num % 10;
if (digit % 2 == 0) {
even_count++;
} else {
odd_count++;
}
num /= 10;
} while (num > 0);
result[0] = even_count;
result[1] = odd_count;
}
|
#include <assert.h>
#include <string.h>
int issame(const int *a, const int *b, int size) {
return memcmp(a, b, size * sizeof(int)) == 0;
}
int main() {
int result[2];
func0(7, result);
assert(issame(result, (const int[]){0, 1}, 2));
func0(-78, result);
assert(issame(result, (const int[]){1, 1}, 2));
func0(3452, result);
assert(issame(result, (const int[]){2, 2}, 2));
func0(346211, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-345821, result);
assert(issame(result, (const int[]){3, 3}, 2));
func0(-2, result);
assert(issame(result, (const int[]){1, 0}, 2));
func0(-45347, result);
assert(issame(result, (const int[]){2, 3}, 2));
func0(0, result);
assert(issame(result, (const int[]){1, 0}, 2));
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov %edi,%eax
xor %edx,%edx
xor %ecx,%ecx
mov $0xcccccccd,%r8d
sar $0x1f,%eax
xor %eax,%edi
sub %eax,%edi
jmp 11f2 <func0+0x32>
nopl 0x0(%rax)
imul %r8,%rax
add $0x1,%ecx
shr $0x23,%rax
cmp $0x9,%edi
jle 120a <func0+0x4a>
mov %eax,%edi
mov %edi,%eax
test $0x1,%dil
je 11e0 <func0+0x20>
imul %r8,%rax
add $0x1,%edx
shr $0x23,%rax
cmp $0x9,%edi
jg 11f0 <func0+0x30>
mov %ecx,(%rsi)
mov %edx,0x4(%rsi)
retq
|
func0:
endbr64
mov edx, edi
mov r8d, 0CCCCCCCDh
neg edx
cmovs edx, edi
xor ecx, ecx
xor edi, edi
jmp short loc_11E2
loc_11D0:
imul rax, r8
add edi, 1
shr rax, 23h
cmp edx, 9
jle short loc_11F9
loc_11E0:
mov edx, eax
loc_11E2:
mov eax, edx
test dl, 1
jz short loc_11D0
imul rax, r8
add ecx, 1
shr rax, 23h
cmp edx, 9
jg short loc_11E0
loc_11F9:
mov [rsi], edi
mov [rsi+4], ecx
retn
|
unsigned long long func0(int a1, _DWORD *a2)
{
int v2; // edx
int v3; // ecx
int v4; // edi
unsigned long long result; // rax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = 0;
v4 = 0;
while ( (v2 & 1) == 0 )
{
++v4;
result = (unsigned int)v2 / 0xAuLL;
if ( v2 <= 9 )
goto LABEL_8;
LABEL_5:
v2 = result;
}
++v3;
result = (unsigned int)v2 / 0xAuLL;
if ( v2 > 9 )
goto LABEL_5;
LABEL_8:
*a2 = v4;
a2[1] = v3;
return result;
}
|
func0:
ENDBR64
MOV EDX,EDI
MOV R8D,0xcccccccd
NEG EDX
CMOVS EDX,EDI
XOR ECX,ECX
XOR EDI,EDI
JMP 0x001011e2
LAB_001011d0:
IMUL RAX,R8
ADD EDI,0x1
SHR RAX,0x23
CMP EDX,0x9
JLE 0x001011f9
LAB_001011e0:
MOV EDX,EAX
LAB_001011e2:
MOV EAX,EDX
TEST DL,0x1
JZ 0x001011d0
IMUL RAX,R8
ADD ECX,0x1
SHR RAX,0x23
CMP EDX,0x9
JG 0x001011e0
LAB_001011f9:
MOV dword ptr [RSI],EDI
MOV dword ptr [RSI + 0x4],ECX
RET
|
void func0(uint param_1,int *param_2)
{
uint uVar1;
int iVar2;
ulong uVar3;
int iVar4;
uVar3 = (ulong)-param_1;
if (0 < (int)param_1) {
uVar3 = (ulong)param_1;
}
iVar2 = 0;
iVar4 = 0;
while( true ) {
if ((uVar3 & 1) == 0) {
iVar4 = iVar4 + 1;
uVar1 = (uint)(uVar3 / 10);
}
else {
iVar2 = iVar2 + 1;
uVar1 = (uint)(uVar3 / 10);
}
if ((int)uVar3 < 10) break;
uVar3 = (ulong)uVar1;
}
*param_2 = iVar4;
param_2[1] = iVar2;
return;
}
|
1,280 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
strcat(result, rep[pos]);
number -= num[pos];
}
if (number > 0) pos++;
}
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(strcmp(result, "ccli") == 0);
func0(426, result);
assert(strcmp(result, "cdxxvi") == 0);
func0(500, result);
assert(strcmp(result, "d") == 0);
func0(1, result);
assert(strcmp(result, "i") == 0);
func0(4, result);
assert(strcmp(result, "iv") == 0);
func0(43, result);
assert(strcmp(result, "xliii") == 0);
func0(90, result);
assert(strcmp(result, "xc") == 0);
func0(94, result);
assert(strcmp(result, "xciv") == 0);
func0(532, result);
assert(strcmp(result, "dxxxii") == 0);
func0(900, result);
assert(strcmp(result, "cm") == 0);
func0(994, result);
assert(strcmp(result, "cmxciv") == 0);
func0(1000, result);
assert(strcmp(result, "m") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %edi,-0xc4(%rbp)
mov %rsi,-0xd0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe2d(%rip),%rax
mov %rax,-0x70(%rbp)
lea 0xe24(%rip),%rax
mov %rax,-0x68(%rbp)
lea 0xe1c(%rip),%rax
mov %rax,-0x60(%rbp)
lea 0xe13(%rip),%rax
mov %rax,-0x58(%rbp)
lea 0xe0b(%rip),%rax
mov %rax,-0x50(%rbp)
lea 0xe02(%rip),%rax
mov %rax,-0x48(%rbp)
lea 0xdfa(%rip),%rax
mov %rax,-0x40(%rbp)
lea 0xdf1(%rip),%rax
mov %rax,-0x38(%rbp)
lea 0xde9(%rip),%rax
mov %rax,-0x30(%rbp)
lea 0xde0(%rip),%rax
mov %rax,-0x28(%rbp)
lea 0xdd8(%rip),%rax
mov %rax,-0x20(%rbp)
lea 0xdcf(%rip),%rax
mov %rax,-0x18(%rbp)
lea 0xdc7(%rip),%rax
mov %rax,-0x10(%rbp)
movl $0x3e8,-0xb0(%rbp)
movl $0x384,-0xac(%rbp)
movl $0x1f4,-0xa8(%rbp)
movl $0x190,-0xa4(%rbp)
movl $0x64,-0xa0(%rbp)
movl $0x5a,-0x9c(%rbp)
movl $0x32,-0x98(%rbp)
movl $0x28,-0x94(%rbp)
movl $0xa,-0x90(%rbp)
movl $0x9,-0x8c(%rbp)
movl $0x5,-0x88(%rbp)
movl $0x4,-0x84(%rbp)
movl $0x1,-0x80(%rbp)
movl $0x0,-0xb4(%rbp)
mov -0xd0(%rbp),%rax
movb $0x0,(%rax)
jmp 1353 <func0+0x1aa>
mov -0xb4(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,8),%rdx
mov -0xd0(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcat@plt>
mov -0xb4(%rbp),%eax
cltq
mov -0xb0(%rbp,%rax,4),%eax
sub %eax,-0xc4(%rbp)
mov -0xb4(%rbp),%eax
cltq
mov -0xb0(%rbp,%rax,4),%eax
cmp %eax,-0xc4(%rbp)
jge 12f8 <func0+0x14f>
cmpl $0x0,-0xc4(%rbp)
jle 1353 <func0+0x1aa>
addl $0x1,-0xb4(%rbp)
cmpl $0x0,-0xc4(%rbp)
jg 132c <func0+0x183>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 1371 <func0+0x1c8>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_C4], edi
mov [rbp+dest], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aM; "m"
mov [rbp+src], rax
lea rax, aCm; "cm"
mov [rbp+var_68], rax
lea rax, aD; "d"
mov [rbp+var_60], rax
lea rax, aCd; "cd"
mov [rbp+var_58], rax
lea rax, aC; "c"
mov [rbp+var_50], rax
lea rax, aXc; "xc"
mov [rbp+var_48], rax
lea rax, asc_2017; "l"
mov [rbp+var_40], rax
lea rax, aXl; "xl"
mov [rbp+var_38], rax
lea rax, asc_201C; "x"
mov [rbp+var_30], rax
lea rax, aIx; "ix"
mov [rbp+var_28], rax
lea rax, aV; "v"
mov [rbp+var_20], rax
lea rax, aIv; "iv"
mov [rbp+var_18], rax
lea rax, aI; "i"
mov [rbp+var_10], rax
mov [rbp+var_B0], 3E8h
mov [rbp+var_AC], 384h
mov [rbp+var_A8], 1F4h
mov [rbp+var_A4], 190h
mov [rbp+var_A0], 64h ; 'd'
mov [rbp+var_9C], 5Ah ; 'Z'
mov [rbp+var_98], 32h ; '2'
mov [rbp+var_94], 28h ; '('
mov [rbp+var_90], 0Ah
mov [rbp+var_8C], 9
mov [rbp+var_88], 5
mov [rbp+var_84], 4
mov [rbp+var_80], 1
mov [rbp+var_B4], 0
mov rax, [rbp+dest]
mov byte ptr [rax], 0
jmp short loc_1353
loc_12F8:
mov eax, [rbp+var_B4]
cdqe
mov rdx, [rbp+rax*8+src]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
mov eax, [rbp+var_B4]
cdqe
mov eax, [rbp+rax*4+var_B0]
sub [rbp+var_C4], eax
loc_132C:
mov eax, [rbp+var_B4]
cdqe
mov eax, [rbp+rax*4+var_B0]
cmp [rbp+var_C4], eax
jge short loc_12F8
cmp [rbp+var_C4], 0
jle short loc_1353
add [rbp+var_B4], 1
loc_1353:
cmp [rbp+var_C4], 0
jg short loc_132C
nop
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_1371
call ___stack_chk_fail
locret_1371:
leave
retn
|
unsigned long long func0(int a1, char *a2)
{
int v4; // [rsp+1Ch] [rbp-B4h]
_DWORD v5[16]; // [rsp+20h] [rbp-B0h]
char *src[13]; // [rsp+60h] [rbp-70h]
unsigned long long v7; // [rsp+C8h] [rbp-8h]
v7 = __readfsqword(0x28u);
src[0] = "m";
src[1] = "cm";
src[2] = "d";
src[3] = "cd";
src[4] = "c";
src[5] = "xc";
src[6] = "l";
src[7] = "xl";
src[8] = "x";
src[9] = "ix";
src[10] = "v";
src[11] = "iv";
src[12] = "i";
v5[0] = 1000;
v5[1] = 900;
v5[2] = 500;
v5[3] = 400;
v5[4] = 100;
v5[5] = 90;
v5[6] = 50;
v5[7] = 40;
v5[8] = 10;
v5[9] = 9;
v5[10] = 5;
v5[11] = 4;
v5[12] = 1;
v4 = 0;
*a2 = 0;
while ( a1 > 0 )
{
while ( a1 >= v5[v4] )
{
strcat(a2, src[v4]);
a1 -= v5[v4];
}
if ( a1 > 0 )
++v4;
}
return v7 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV dword ptr [RBP + -0xc4],EDI
MOV qword ptr [RBP + -0xd0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[0x10200a]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[0x10200d]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[0x10200f]
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[0x102012]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0x102014]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[0x102017]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x102019]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[0x10201c]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x10201e]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x102021]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x102023]
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x102026]
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0xb0],0x3e8
MOV dword ptr [RBP + -0xac],0x384
MOV dword ptr [RBP + -0xa8],0x1f4
MOV dword ptr [RBP + -0xa4],0x190
MOV dword ptr [RBP + -0xa0],0x64
MOV dword ptr [RBP + -0x9c],0x5a
MOV dword ptr [RBP + -0x98],0x32
MOV dword ptr [RBP + -0x94],0x28
MOV dword ptr [RBP + -0x90],0xa
MOV dword ptr [RBP + -0x8c],0x9
MOV dword ptr [RBP + -0x88],0x5
MOV dword ptr [RBP + -0x84],0x4
MOV dword ptr [RBP + -0x80],0x1
MOV dword ptr [RBP + -0xb4],0x0
MOV RAX,qword ptr [RBP + -0xd0]
MOV byte ptr [RAX],0x0
JMP 0x00101353
LAB_001012f8:
MOV EAX,dword ptr [RBP + -0xb4]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x70]
MOV RAX,qword ptr [RBP + -0xd0]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0xb4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xb0]
SUB dword ptr [RBP + -0xc4],EAX
LAB_0010132c:
MOV EAX,dword ptr [RBP + -0xb4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xb0]
CMP dword ptr [RBP + -0xc4],EAX
JGE 0x001012f8
CMP dword ptr [RBP + -0xc4],0x0
JLE 0x00101353
ADD dword ptr [RBP + -0xb4],0x1
LAB_00101353:
CMP dword ptr [RBP + -0xc4],0x0
JG 0x0010132c
NOP
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101371
CALL 0x00101080
LAB_00101371:
LEAVE
RET
|
void func0(int param_1,char *param_2)
{
long in_FS_OFFSET;
int local_cc;
int local_bc;
int local_b8 [16];
int *local_78 [4];
int *local_58;
int *local_50;
int *local_48;
int *local_40;
int *local_38;
int *local_30;
int *local_28;
int *local_20;
int *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_78[0] = &DAT_00102008;
local_78[1] = &DAT_0010200a;
local_78[2] = &DAT_0010200d;
local_78[3] = &DAT_0010200f;
local_58 = &DAT_00102012;
local_50 = &DAT_00102014;
local_48 = &DAT_00102017;
local_40 = &DAT_00102019;
local_38 = &DAT_0010201c;
local_30 = &DAT_0010201e;
local_28 = &DAT_00102021;
local_20 = &DAT_00102023;
local_18 = &DAT_00102026;
local_b8[0] = 1000;
local_b8[1] = 900;
local_b8[2] = 500;
local_b8[3] = 400;
local_b8[4] = 100;
local_b8[5] = 0x5a;
local_b8[6] = 0x32;
local_b8[7] = 0x28;
local_b8[8] = 10;
local_b8[9] = 9;
local_b8[10] = 5;
local_b8[0xb] = 4;
local_b8[0xc] = 1;
local_bc = 0;
*param_2 = '\0';
local_cc = param_1;
while (0 < local_cc) {
for (; local_b8[local_bc] <= local_cc; local_cc = local_cc - local_b8[local_bc]) {
strcat(param_2,local_78[local_bc]);
}
if (0 < local_cc) {
local_bc = local_bc + 1;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,281 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
strcat(result, rep[pos]);
number -= num[pos];
}
if (number > 0) pos++;
}
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(strcmp(result, "ccli") == 0);
func0(426, result);
assert(strcmp(result, "cdxxvi") == 0);
func0(500, result);
assert(strcmp(result, "d") == 0);
func0(1, result);
assert(strcmp(result, "i") == 0);
func0(4, result);
assert(strcmp(result, "iv") == 0);
func0(43, result);
assert(strcmp(result, "xliii") == 0);
func0(90, result);
assert(strcmp(result, "xc") == 0);
func0(94, result);
assert(strcmp(result, "xciv") == 0);
func0(532, result);
assert(strcmp(result, "dxxxii") == 0);
func0(900, result);
assert(strcmp(result, "cm") == 0);
func0(994, result);
assert(strcmp(result, "cmxciv") == 0);
func0(1000, result);
assert(strcmp(result, "m") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0xe4f(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xe42(%rip),%rax
mov %rax,0x48(%rsp)
lea 0xe3a(%rip),%rax
mov %rax,0x50(%rsp)
lea 0xe2d(%rip),%rax
mov %rax,0x58(%rsp)
lea 0xe25(%rip),%rax
mov %rax,0x60(%rsp)
lea 0xe18(%rip),%rax
mov %rax,0x68(%rsp)
lea 0xe10(%rip),%rax
mov %rax,0x70(%rsp)
lea 0xe03(%rip),%rax
mov %rax,0x78(%rsp)
lea 0xdfc(%rip),%rax
mov %rax,0x80(%rsp)
lea 0xdec(%rip),%rax
mov %rax,0x88(%rsp)
lea 0xf4b(%rip),%rax
mov %rax,0x90(%rsp)
lea 0xf3b(%rip),%rax
mov %rax,0x98(%rsp)
lea 0xe94(%rip),%rax
mov %rax,0xa0(%rsp)
movl $0x3e8,(%rsp)
movl $0x384,0x4(%rsp)
movl $0x1f4,0x8(%rsp)
movl $0x190,0xc(%rsp)
movl $0x64,0x10(%rsp)
movl $0x5a,0x14(%rsp)
movl $0x32,0x18(%rsp)
movl $0x28,0x1c(%rsp)
movl $0xa,0x20(%rsp)
movl $0x9,0x24(%rsp)
movl $0x5,0x28(%rsp)
movl $0x4,0x2c(%rsp)
movl $0x1,0x30(%rsp)
movb $0x0,(%rsi)
test %edi,%edi
jle 12fa <func0+0x171>
mov %edi,%ebx
mov %rsi,%r13
mov %rsp,%r14
lea 0x40(%rsp),%r12
mov (%r14),%ebp
cmp %ebx,%ebp
jg 12ee <func0+0x165>
mov (%r12),%rsi
mov %r13,%rdi
callq 1090 <strcat@plt>
sub %ebp,%ebx
cmp %ebp,%ebx
jge 12dc <func0+0x153>
add $0x4,%r14
add $0x8,%r12
test %ebx,%ebx
jg 12d5 <func0+0x14c>
mov 0xa8(%rsp),%rax
xor %fs:0x28,%rax
jne 131d <func0+0x194>
add $0xb0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1070 <__stack_chk_fail@plt>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0D8h+var_30], rax
xor eax, eax
lea rax, aCm+1; "m"
mov [rsp+0D8h+var_98], rax
lea rax, aCm; "cm"
mov [rsp+0D8h+var_90], rax
lea rax, aCd+1; "d"
mov [rsp+0D8h+var_88], rax
lea rax, aCd; "cd"
mov [rsp+0D8h+var_80], rax
lea rax, aXc+1; "c"
mov [rsp+0D8h+var_78], rax
lea rax, aXc; "xc"
mov [rsp+0D8h+var_70], rax
lea rax, aXl+1; "l"
mov [rsp+0D8h+var_68], rax
lea rax, aXl; "xl"
mov [rsp+0D8h+var_60], rax
lea rax, s2+2; "x"
mov [rsp+0D8h+var_58], rax
lea rax, s2+1; "ix"
mov [rsp+0D8h+var_50], rax
lea rax, aCmxciv+5; "v"
mov [rsp+0D8h+var_48], rax
lea rax, aCmxciv+4; "iv"
mov [rsp+0D8h+var_40], rax
lea rax, aXliii+4; "i"
mov [rsp+0D8h+var_38], rax
mov [rsp+0D8h+var_D8], 3E8h
mov [rsp+0D8h+var_D4], 384h
mov [rsp+0D8h+var_D0], 1F4h
mov [rsp+0D8h+var_CC], 190h
mov [rsp+0D8h+var_C8], 64h ; 'd'
mov [rsp+0D8h+var_C4], 5Ah ; 'Z'
mov [rsp+0D8h+var_C0], 32h ; '2'
mov [rsp+0D8h+var_BC], 28h ; '('
mov [rsp+0D8h+var_B8], 0Ah
mov [rsp+0D8h+var_B4], 9
mov [rsp+0D8h+var_B0], 5
mov [rsp+0D8h+var_AC], 4
mov [rsp+0D8h+var_A8], 1
mov byte ptr [rsi], 0
test edi, edi
jle short loc_131C
mov ebx, edi
mov r13, rsi
mov r14, rsp
lea r12, [rsp+0D8h+var_98]
jmp short loc_12FF
loc_12F7:
add r14, 4
add r12, 8
loc_12FF:
mov ebp, [r14]
cmp ebp, ebx
jg short loc_12F7
loc_1306:
mov rsi, [r12]; src
mov rdi, r13; dest
call _strcat
sub ebx, ebp
cmp ebx, ebp
jge short loc_1306
test ebx, ebx
jg short loc_12F7
loc_131C:
mov rax, [rsp+0D8h+var_30]
sub rax, fs:28h
jnz short loc_133F
add rsp, 0B0h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_133F:
call ___stack_chk_fail
|
unsigned long long func0(int a1, char *a2)
{
int v2; // ebx
int *v3; // r14
const char **i; // r12
int v5; // ebp
_DWORD v7[16]; // [rsp+0h] [rbp-D8h] BYREF
_QWORD v8[13]; // [rsp+40h] [rbp-98h] BYREF
unsigned long long v9; // [rsp+A8h] [rbp-30h]
v9 = __readfsqword(0x28u);
v8[0] = "m";
v8[1] = "cm";
v8[2] = "d";
v8[3] = "cd";
v8[4] = "c";
v8[5] = "xc";
v8[6] = "l";
v8[7] = "xl";
v8[8] = "x";
v8[9] = "ix";
v8[10] = "v";
v8[11] = "iv";
v8[12] = "i";
v7[0] = 1000;
v7[1] = 900;
v7[2] = 500;
v7[3] = 400;
v7[4] = 100;
v7[5] = 90;
v7[6] = 50;
v7[7] = 40;
v7[8] = 10;
v7[9] = 9;
v7[10] = 5;
v7[11] = 4;
v7[12] = 1;
*a2 = 0;
if ( a1 > 0 )
{
v2 = a1;
v3 = v7;
for ( i = (const char **)v8; ; ++i )
{
v5 = *v3;
if ( *v3 <= v2 )
{
do
{
strcat(a2, *i);
v2 -= v5;
}
while ( v2 >= v5 );
if ( v2 <= 0 )
break;
}
++v3;
}
}
return v9 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RAX,[0x102005]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x48],RAX
LEA RAX,[0x102008]
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[0x102007]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x10200b]
MOV qword ptr [RSP + 0x60],RAX
LEA RAX,[0x10200a]
MOV qword ptr [RSP + 0x68],RAX
LEA RAX,[0x10200e]
MOV qword ptr [RSP + 0x70],RAX
LEA RAX,[0x10200d]
MOV qword ptr [RSP + 0x78],RAX
LEA RAX,[0x102012]
MOV qword ptr [RSP + 0x80],RAX
LEA RAX,[0x102011]
MOV qword ptr [RSP + 0x88],RAX
LEA RAX,[0x10217f]
MOV qword ptr [RSP + 0x90],RAX
LEA RAX,[0x10217e]
MOV qword ptr [RSP + 0x98],RAX
LEA RAX,[0x1020e6]
MOV qword ptr [RSP + 0xa0],RAX
MOV dword ptr [RSP],0x3e8
MOV dword ptr [RSP + 0x4],0x384
MOV dword ptr [RSP + 0x8],0x1f4
MOV dword ptr [RSP + 0xc],0x190
MOV dword ptr [RSP + 0x10],0x64
MOV dword ptr [RSP + 0x14],0x5a
MOV dword ptr [RSP + 0x18],0x32
MOV dword ptr [RSP + 0x1c],0x28
MOV dword ptr [RSP + 0x20],0xa
MOV dword ptr [RSP + 0x24],0x9
MOV dword ptr [RSP + 0x28],0x5
MOV dword ptr [RSP + 0x2c],0x4
MOV dword ptr [RSP + 0x30],0x1
MOV byte ptr [RSI],0x0
TEST EDI,EDI
JLE 0x0010131c
MOV EBX,EDI
MOV R13,RSI
MOV R14,RSP
LEA R12,[RSP + 0x40]
JMP 0x001012ff
LAB_001012f7:
ADD R14,0x4
ADD R12,0x8
LAB_001012ff:
MOV EBP,dword ptr [R14]
CMP EBP,EBX
JG 0x001012f7
LAB_00101306:
MOV RSI,qword ptr [R12]
MOV RDI,R13
CALL 0x001010b0
SUB EBX,EBP
CMP EBX,EBP
JGE 0x00101306
TEST EBX,EBX
JG 0x001012f7
LAB_0010131c:
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010133f
ADD RSP,0xb0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010133f:
CALL 0x00101080
|
void func0(int param_1,char *param_2)
{
int iVar1;
int **ppuVar2;
int *piVar3;
long in_FS_OFFSET;
int local_d8 [16];
int *local_98 [4];
int *local_78;
int *local_70;
int *local_68;
int *local_60;
int *local_58;
int *local_50;
int *local_48;
int *local_40;
int *local_38;
long local_30;
piVar3 = local_d8;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_98[0] = &DAT_00102005;
local_98[1] = &DAT_00102004;
local_98[2] = &DAT_00102008;
local_98[3] = &DAT_00102007;
local_78 = &DAT_0010200b;
local_70 = &DAT_0010200a;
local_68 = &DAT_0010200e;
local_60 = &DAT_0010200d;
local_58 = &DAT_00102012;
local_50 = &DAT_00102011;
local_48 = &DAT_0010217f;
local_40 = &DAT_0010217e;
local_38 = &DAT_001020e6;
local_d8[0] = 1000;
local_d8[1] = 900;
local_d8[2] = 500;
local_d8[3] = 400;
local_d8[4] = 100;
local_d8[5] = 0x5a;
local_d8[6] = 0x32;
local_d8[7] = 0x28;
local_d8[8] = 10;
local_d8[9] = 9;
local_d8[10] = 5;
local_d8[0xb] = 4;
local_d8[0xc] = 1;
*param_2 = '\0';
if (0 < param_1) {
ppuVar2 = local_98;
do {
iVar1 = *piVar3;
if (iVar1 <= param_1) {
do {
strcat(param_2,*ppuVar2);
param_1 = param_1 - iVar1;
} while (iVar1 <= param_1);
if (param_1 < 1) break;
}
piVar3 = piVar3 + 1;
ppuVar2 = ppuVar2 + 1;
} while( true );
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,282 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
strcat(result, rep[pos]);
number -= num[pos];
}
if (number > 0) pos++;
}
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(strcmp(result, "ccli") == 0);
func0(426, result);
assert(strcmp(result, "cdxxvi") == 0);
func0(500, result);
assert(strcmp(result, "d") == 0);
func0(1, result);
assert(strcmp(result, "i") == 0);
func0(4, result);
assert(strcmp(result, "iv") == 0);
func0(43, result);
assert(strcmp(result, "xliii") == 0);
func0(90, result);
assert(strcmp(result, "xc") == 0);
func0(94, result);
assert(strcmp(result, "xciv") == 0);
func0(532, result);
assert(strcmp(result, "dxxxii") == 0);
func0(900, result);
assert(strcmp(result, "cm") == 0);
func0(994, result);
assert(strcmp(result, "cmxciv") == 0);
func0(1000, result);
assert(strcmp(result, "m") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0xac8(%rip),%rax
movb $0x0,(%rsi)
mov %rax,0x40(%rsp)
lea 0xab8(%rip),%rax
mov %rax,0x48(%rsp)
lea 0xab0(%rip),%rax
mov %rax,0x50(%rsp)
lea 0xaa3(%rip),%rax
mov %rax,0x58(%rsp)
lea 0xa9b(%rip),%rax
mov %rax,0x60(%rsp)
lea 0xa8e(%rip),%rax
mov %rax,0x68(%rsp)
lea 0xa86(%rip),%rax
mov %rax,0x70(%rsp)
lea 0xa79(%rip),%rax
mov %rax,0x78(%rsp)
lea 0xa72(%rip),%rax
mov %rax,0x80(%rsp)
lea 0xa62(%rip),%rax
mov %rax,0x88(%rsp)
lea 0xbc1(%rip),%rax
mov %rax,0x90(%rsp)
lea 0xbb1(%rip),%rax
mov %rax,0x98(%rsp)
lea 0xb0a(%rip),%rax
mov %rax,0xa0(%rsp)
movabs $0x1f400000384,%rax
mov %rax,0x4(%rsp)
movabs $0x6400000190,%rax
mov %rax,0xc(%rsp)
movabs $0x320000005a,%rax
mov %rax,0x14(%rsp)
movabs $0xa00000028,%rax
mov %rax,0x1c(%rsp)
movabs $0x500000009,%rax
mov %rax,0x24(%rsp)
movabs $0x100000004,%rax
mov %rax,0x2c(%rsp)
test %edi,%edi
jle 1698 <func0+0x188>
mov %edi,%ebx
mov $0x3e8,%ebp
mov %rsi,%rdx
xor %r13d,%r13d
lea 0x40(%rsp),%r14
cmp %ebx,%ebp
jg 168c <func0+0x17c>
nopl 0x0(%rax,%rax,1)
mov (%r14,%r13,2),%r12
nopl 0x0(%rax)
mov %rdx,%rdi
mov %r12,%rsi
sub %ebp,%ebx
callq 1090 <strcat@plt>
mov %rax,%rdx
cmp %ebx,%ebp
jle 1668 <func0+0x158>
add $0x4,%r13
test %ebx,%ebx
je 1698 <func0+0x188>
mov (%rsp,%r13,1),%ebp
cmp %ebx,%ebp
jle 1660 <func0+0x150>
add $0x4,%r13
jmp 1684 <func0+0x174>
nopw 0x0(%rax,%rax,1)
mov 0xa8(%rsp),%rax
xor %fs:0x28,%rax
jne 16bb <func0+0x1ab>
add $0xb0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1070 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
lea rcx, unk_2005
push r14
movq xmm0, rcx
lea rcx, unk_2008
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
lea rax, unk_2004
mov [rsp+0E8h+var_B8], 1
mov byte ptr [rsi], 0
movq xmm1, rax
lea rax, unk_2007
punpcklqdq xmm0, xmm1
movq xmm2, rax
lea rax, unk_200A
movaps [rsp+0E8h+var_A8], xmm0
movq xmm0, rcx
movq xmm3, rax
lea rcx, unk_200B
punpcklqdq xmm0, xmm2
lea rax, unk_200D
movaps [rsp+0E8h+var_98], xmm0
movq xmm0, rcx
movq xmm4, rax
lea rcx, unk_200E
punpcklqdq xmm0, xmm3
lea rax, unk_2011
movaps [rsp+0E8h+var_88], xmm0
movq xmm0, rcx
movq xmm5, rax
lea rcx, unk_2012
punpcklqdq xmm0, xmm4
lea rax, aCmxciv+4; "iv"
movaps [rsp+0E8h+var_78], xmm0
movq xmm0, rcx
movq xmm6, rax
lea rcx, aCmxciv+5; "v"
punpcklqdq xmm0, xmm5
lea rax, aXliii+4; "i"
movaps [rsp+0E8h+var_68], xmm0
movq xmm0, rcx
punpcklqdq xmm0, xmm6
mov [rsp+0E8h+var_48], rax
movaps [rsp+0E8h+var_58], xmm0
movdqa xmm0, cs:xmmword_21E0
movaps [rsp+0E8h+var_E8], xmm0
movdqa xmm0, cs:xmmword_21F0
movaps [rsp+0E8h+var_D8], xmm0
movdqa xmm0, cs:xmmword_2200
movaps [rsp+0E8h+var_C8], xmm0
test edi, edi
jle short loc_167E
mov ebx, edi
mov rdx, rsi
xor r13d, r13d
mov r14, rsp
lea r15, [rsp+0E8h+var_A8]
nop word ptr [rax+rax+00000000h]
loc_1650:
mov ebp, [r14+r13*4]
cmp ebp, ebx
jg short loc_1678
mov r12, [r15+r13*8]
nop dword ptr [rax+00h]
loc_1660:
mov rdi, rdx; dest
mov rsi, r12; src
sub ebx, ebp
call _strcat
mov rdx, rax
cmp ebx, ebp
jge short loc_1660
test ebx, ebx
jz short loc_167E
loc_1678:
add r13, 1
jmp short loc_1650
loc_167E:
mov rax, [rsp+0E8h+var_40]
sub rax, fs:28h
jnz short loc_16A3
add rsp, 0B8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_16A3:
call ___stack_chk_fail
|
unsigned long long func0(int a1, char *a2)
{
int v2; // ebx
char *v3; // rdx
long long i; // r13
int v5; // ebp
const char *v6; // r12
_OWORD v8[3]; // [rsp+0h] [rbp-E8h]
int v9; // [rsp+30h] [rbp-B8h]
_OWORD v10[6]; // [rsp+40h] [rbp-A8h]
char *v11; // [rsp+A0h] [rbp-48h]
unsigned long long v12; // [rsp+A8h] [rbp-40h]
v12 = __readfsqword(0x28u);
v9 = 1;
*a2 = 0;
v10[0] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2005, (__m128i)(unsigned long long)&unk_2004);
v10[1] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2008, (__m128i)(unsigned long long)&unk_2007);
v10[2] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_200B, (__m128i)(unsigned long long)&unk_200A);
v10[3] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_200E, (__m128i)(unsigned long long)&unk_200D);
v10[4] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2012, (__m128i)(unsigned long long)&unk_2011);
v11 = "i";
v10[5] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"v", (__m128i)(unsigned long long)"iv");
v8[0] = _mm_load_si128((const __m128i *)&xmmword_21E0);
v8[1] = _mm_load_si128((const __m128i *)&xmmword_21F0);
v8[2] = _mm_load_si128((const __m128i *)&xmmword_2200);
if ( a1 > 0 )
{
v2 = a1;
v3 = a2;
for ( i = 0LL; ; ++i )
{
v5 = *((_DWORD *)v8 + i);
if ( v5 <= v2 )
{
v6 = (const char *)*((_QWORD *)v10 + i);
do
{
v2 -= v5;
v3 = strcat(v3, v6);
}
while ( v2 >= v5 );
if ( !v2 )
break;
}
}
}
return v12 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R15
LEA RCX,[0x102005]
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x102008]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
LEA RAX,[0x102004]
MOV dword ptr [RSP + 0x30],0x1
MOV byte ptr [RSI],0x0
MOVQ XMM1,RAX
LEA RAX,[0x102007]
PUNPCKLQDQ XMM0,XMM1
MOVQ XMM2,RAX
LEA RAX,[0x10200a]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVQ XMM0,RCX
MOVQ XMM3,RAX
LEA RCX,[0x10200b]
PUNPCKLQDQ XMM0,XMM2
LEA RAX,[0x10200d]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVQ XMM0,RCX
MOVQ XMM4,RAX
LEA RCX,[0x10200e]
PUNPCKLQDQ XMM0,XMM3
LEA RAX,[0x102011]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVQ XMM0,RCX
MOVQ XMM5,RAX
LEA RCX,[0x102012]
PUNPCKLQDQ XMM0,XMM4
LEA RAX,[0x10217e]
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVQ XMM0,RCX
MOVQ XMM6,RAX
LEA RCX,[0x10217f]
PUNPCKLQDQ XMM0,XMM5
LEA RAX,[0x1020e6]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVQ XMM0,RCX
PUNPCKLQDQ XMM0,XMM6
MOV qword ptr [RSP + 0xa0],RAX
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVDQA XMM0,xmmword ptr [0x001021e0]
MOVAPS xmmword ptr [RSP],XMM0
MOVDQA XMM0,xmmword ptr [0x001021f0]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVDQA XMM0,xmmword ptr [0x00102200]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
TEST EDI,EDI
JLE 0x0010167e
MOV EBX,EDI
MOV RDX,RSI
XOR R13D,R13D
MOV R14,RSP
LEA R15,[RSP + 0x40]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101650:
MOV EBP,dword ptr [R14 + R13*0x4]
CMP EBP,EBX
JG 0x00101678
MOV R12,qword ptr [R15 + R13*0x8]
NOP dword ptr [RAX]
LAB_00101660:
MOV RDI,RDX
MOV RSI,R12
SUB EBX,EBP
CALL 0x00101090
MOV RDX,RAX
CMP EBX,EBP
JGE 0x00101660
TEST EBX,EBX
JZ 0x0010167e
LAB_00101678:
ADD R13,0x1
JMP 0x00101650
LAB_0010167e:
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001016a3
ADD RSP,0xb8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001016a3:
CALL 0x00101070
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int param_1,char *param_2)
{
int iVar1;
char *__src;
long lVar2;
long in_FS_OFFSET;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int4 local_b8;
int *local_a8 [4];
int *local_88;
int *puStack_80;
int *local_78;
int *puStack_70;
int *local_68;
int *puStack_60;
int *local_58;
int *puStack_50;
int *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_b8 = 1;
*param_2 = '\0';
local_a8[0] = &DAT_00102005;
local_a8[1] = &DAT_00102004;
local_a8[2] = &DAT_00102008;
local_a8[3] = &DAT_00102007;
local_88 = &DAT_0010200b;
puStack_80 = &DAT_0010200a;
local_78 = &DAT_0010200e;
puStack_70 = &DAT_0010200d;
local_68 = &DAT_00102012;
puStack_60 = &DAT_00102011;
local_48 = &DAT_001020e6;
local_58 = &DAT_0010217f;
puStack_50 = &DAT_0010217e;
local_e8 = _DAT_001021e0;
uStack_e0 = _UNK_001021e8;
local_d8 = _DAT_001021f0;
uStack_d0 = _UNK_001021f8;
local_c8 = _DAT_00102200;
uStack_c0 = _UNK_00102208;
if (0 < param_1) {
lVar2 = 0;
do {
iVar1 = *(int *)((long)&local_e8 + lVar2 * 4);
if (iVar1 <= param_1) {
__src = local_a8[lVar2];
do {
param_1 = param_1 - iVar1;
param_2 = strcat(param_2,__src);
} while (iVar1 <= param_1);
if (param_1 == 0) break;
}
lVar2 = lVar2 + 1;
} while( true );
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,283 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(int number, char *result) {
const char *rep[] = {"m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i"};
const int num[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
int pos = 0;
result[0] = '\0';
while(number > 0) {
while (number >= num[pos]) {
strcat(result, rep[pos]);
number -= num[pos];
}
if (number > 0) pos++;
}
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[64]; // Buffer large enough for all Roman numeral representations of numbers 1-1000
func0(19, result);
assert(strcmp(result, "xix") == 0);
func0(152, result);
assert(strcmp(result, "clii") == 0);
func0(251, result);
assert(strcmp(result, "ccli") == 0);
func0(426, result);
assert(strcmp(result, "cdxxvi") == 0);
func0(500, result);
assert(strcmp(result, "d") == 0);
func0(1, result);
assert(strcmp(result, "i") == 0);
func0(4, result);
assert(strcmp(result, "iv") == 0);
func0(43, result);
assert(strcmp(result, "xliii") == 0);
func0(90, result);
assert(strcmp(result, "xc") == 0);
func0(94, result);
assert(strcmp(result, "xciv") == 0);
func0(532, result);
assert(strcmp(result, "dxxxii") == 0);
func0(900, result);
assert(strcmp(result, "cm") == 0);
func0(994, result);
assert(strcmp(result, "cmxciv") == 0);
func0(1000, result);
assert(strcmp(result, "m") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
lea 0xae8(%rip),%rcx
mov %rsi,%rdx
push %r14
movq %rcx,%xmm0
lea 0xada(%rip),%rcx
push %r13
xor %r13d,%r13d
push %r12
push %rbp
push %rbx
mov %edi,%ebx
sub $0xb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0xaaa(%rip),%rax
movb $0x0,(%rsi)
mov %rsp,%r14
movq %rax,%xmm1
lea 0xa9b(%rip),%rax
lea 0x40(%rsp),%r15
movl $0x1,0x30(%rsp)
punpcklqdq %xmm1,%xmm0
movq %rax,%xmm2
lea 0xa81(%rip),%rax
movaps %xmm0,0x40(%rsp)
movq %rcx,%xmm0
movq %rax,%xmm3
lea 0xa6c(%rip),%rcx
punpcklqdq %xmm2,%xmm0
lea 0xa63(%rip),%rax
movaps %xmm0,0x50(%rsp)
movq %rcx,%xmm0
movq %rax,%xmm4
lea 0xa4e(%rip),%rcx
punpcklqdq %xmm3,%xmm0
lea 0xa46(%rip),%rax
movaps %xmm0,0x60(%rsp)
movq %rcx,%xmm0
movq %rax,%xmm5
lea 0xa31(%rip),%rcx
punpcklqdq %xmm4,%xmm0
lea 0xb92(%rip),%rax
movaps %xmm0,0x70(%rsp)
movq %rcx,%xmm0
movq %rax,%xmm6
lea 0xb7d(%rip),%rcx
punpcklqdq %xmm5,%xmm0
lea 0xad9(%rip),%rax
movaps %xmm0,0x80(%rsp)
movq %rcx,%xmm0
punpcklqdq %xmm6,%xmm0
mov %rax,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movdqa 0xbca(%rip),%xmm0
movaps %xmm0,(%rsp)
movdqa 0xbce(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movdqa 0xbd1(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
test %edi,%edi
jle 168c <func0+0x17c>
nopl 0x0(%rax,%rax,1)
mov (%r14,%r13,4),%ebp
cmp %ebx,%ebp
jg 16b8 <func0+0x1a8>
mov (%r15,%r13,8),%r12
nopl 0x0(%rax)
mov %rdx,%rdi
mov %r12,%rsi
sub %ebp,%ebx
callq 1090 <strcat@plt>
mov %rax,%rdx
cmp %ebp,%ebx
jge 1670 <func0+0x160>
add $0x1,%r13
test %ebx,%ebx
jne 1660 <func0+0x150>
mov 0xa8(%rsp),%rax
xor %fs:0x28,%rax
jne 16be <func0+0x1ae>
add $0xb8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
add $0x1,%r13
jmp 1660 <func0+0x150>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
push r15
lea rcx, unk_2005
push r14
movq xmm0, rcx
lea rcx, unk_2008
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
lea rax, unk_2004
mov [rsp+0E8h+var_B8], 1
mov byte ptr [rsi], 0
movq xmm1, rax
lea rax, unk_2007
punpcklqdq xmm0, xmm1
movq xmm2, rax
lea rax, unk_200A
movaps [rsp+0E8h+var_A8], xmm0
movq xmm0, rcx
movq xmm3, rax
lea rcx, unk_200B
punpcklqdq xmm0, xmm2
lea rax, unk_200D
movaps [rsp+0E8h+var_98], xmm0
movq xmm0, rcx
movq xmm4, rax
lea rcx, unk_200E
punpcklqdq xmm0, xmm3
lea rax, unk_2011
movaps [rsp+0E8h+var_88], xmm0
movq xmm0, rcx
movq xmm5, rax
lea rcx, unk_2012
punpcklqdq xmm0, xmm4
lea rax, aCmxciv+4; "iv"
movaps [rsp+0E8h+var_78], xmm0
movq xmm0, rcx
movq xmm6, rax
lea rcx, aCmxciv+5; "v"
punpcklqdq xmm0, xmm5
lea rax, aXliii+4; "i"
movaps [rsp+0E8h+var_68], xmm0
movq xmm0, rcx
punpcklqdq xmm0, xmm6
mov [rsp+0E8h+var_48], rax
movaps [rsp+0E8h+var_58], xmm0
movdqa xmm0, cs:xmmword_21E0
movaps [rsp+0E8h+var_E8], xmm0
movdqa xmm0, cs:xmmword_21F0
movaps [rsp+0E8h+var_D8], xmm0
movdqa xmm0, cs:xmmword_2200
movaps [rsp+0E8h+var_C8], xmm0
test edi, edi
jle short loc_167E
mov ebx, edi
mov rdx, rsi
xor r13d, r13d
mov r14, rsp
lea r15, [rsp+0E8h+var_A8]
nop word ptr [rax+rax+00000000h]
loc_1650:
mov ebp, [r14+r13*4]
cmp ebp, ebx
jg short loc_1678
mov r12, [r15+r13*8]
nop dword ptr [rax+00h]
loc_1660:
mov rdi, rdx; dest
mov rsi, r12; src
sub ebx, ebp
call _strcat
mov rdx, rax
cmp ebx, ebp
jge short loc_1660
test ebx, ebx
jz short loc_167E
loc_1678:
add r13, 1
jmp short loc_1650
loc_167E:
mov rax, [rsp+0E8h+var_40]
sub rax, fs:28h
jnz short loc_16A3
add rsp, 0B8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_16A3:
call ___stack_chk_fail
|
unsigned long long func0(int a1, char *a2)
{
int v2; // ebx
char *v3; // rdx
long long i; // r13
int v5; // ebp
const char *v6; // r12
_OWORD v8[3]; // [rsp+0h] [rbp-E8h]
int v9; // [rsp+30h] [rbp-B8h]
_OWORD v10[6]; // [rsp+40h] [rbp-A8h]
char *v11; // [rsp+A0h] [rbp-48h]
unsigned long long v12; // [rsp+A8h] [rbp-40h]
v12 = __readfsqword(0x28u);
v9 = 1;
*a2 = 0;
v10[0] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2005, (__m128i)(unsigned long long)&unk_2004);
v10[1] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2008, (__m128i)(unsigned long long)&unk_2007);
v10[2] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_200B, (__m128i)(unsigned long long)&unk_200A);
v10[3] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_200E, (__m128i)(unsigned long long)&unk_200D);
v10[4] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2012, (__m128i)(unsigned long long)&unk_2011);
v11 = "i";
v10[5] = _mm_unpacklo_epi64((__m128i)(unsigned long long)"v", (__m128i)(unsigned long long)"iv");
v8[0] = _mm_load_si128((const __m128i *)&xmmword_21E0);
v8[1] = _mm_load_si128((const __m128i *)&xmmword_21F0);
v8[2] = _mm_load_si128((const __m128i *)&xmmword_2200);
if ( a1 > 0 )
{
v2 = a1;
v3 = a2;
for ( i = 0LL; ; ++i )
{
v5 = *((_DWORD *)v8 + i);
if ( v5 <= v2 )
{
v6 = (const char *)*((_QWORD *)v10 + i);
do
{
v2 -= v5;
v3 = strcat(v3, v6);
}
while ( v2 >= v5 );
if ( !v2 )
break;
}
}
}
return v12 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH R15
LEA RCX,[0x102005]
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x102008]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
LEA RAX,[0x102004]
MOV dword ptr [RSP + 0x30],0x1
MOV byte ptr [RSI],0x0
MOVQ XMM1,RAX
LEA RAX,[0x102007]
PUNPCKLQDQ XMM0,XMM1
MOVQ XMM2,RAX
LEA RAX,[0x10200a]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVQ XMM0,RCX
MOVQ XMM3,RAX
LEA RCX,[0x10200b]
PUNPCKLQDQ XMM0,XMM2
LEA RAX,[0x10200d]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVQ XMM0,RCX
MOVQ XMM4,RAX
LEA RCX,[0x10200e]
PUNPCKLQDQ XMM0,XMM3
LEA RAX,[0x102011]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVQ XMM0,RCX
MOVQ XMM5,RAX
LEA RCX,[0x102012]
PUNPCKLQDQ XMM0,XMM4
LEA RAX,[0x10217e]
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVQ XMM0,RCX
MOVQ XMM6,RAX
LEA RCX,[0x10217f]
PUNPCKLQDQ XMM0,XMM5
LEA RAX,[0x1020e6]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVQ XMM0,RCX
PUNPCKLQDQ XMM0,XMM6
MOV qword ptr [RSP + 0xa0],RAX
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVDQA XMM0,xmmword ptr [0x001021e0]
MOVAPS xmmword ptr [RSP],XMM0
MOVDQA XMM0,xmmword ptr [0x001021f0]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVDQA XMM0,xmmword ptr [0x00102200]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
TEST EDI,EDI
JLE 0x0010167e
MOV EBX,EDI
MOV RDX,RSI
XOR R13D,R13D
MOV R14,RSP
LEA R15,[RSP + 0x40]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101650:
MOV EBP,dword ptr [R14 + R13*0x4]
CMP EBP,EBX
JG 0x00101678
MOV R12,qword ptr [R15 + R13*0x8]
NOP dword ptr [RAX]
LAB_00101660:
MOV RDI,RDX
MOV RSI,R12
SUB EBX,EBP
CALL 0x00101090
MOV RDX,RAX
CMP EBX,EBP
JGE 0x00101660
TEST EBX,EBX
JZ 0x0010167e
LAB_00101678:
ADD R13,0x1
JMP 0x00101650
LAB_0010167e:
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001016a3
ADD RSP,0xb8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001016a3:
CALL 0x00101070
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int param_1,char *param_2)
{
int iVar1;
char *__src;
long lVar2;
long in_FS_OFFSET;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int4 local_b8;
int *local_a8 [4];
int *local_88;
int *puStack_80;
int *local_78;
int *puStack_70;
int *local_68;
int *puStack_60;
int *local_58;
int *puStack_50;
int *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_b8 = 1;
*param_2 = '\0';
local_a8[0] = &DAT_00102005;
local_a8[1] = &DAT_00102004;
local_a8[2] = &DAT_00102008;
local_a8[3] = &DAT_00102007;
local_88 = &DAT_0010200b;
puStack_80 = &DAT_0010200a;
local_78 = &DAT_0010200e;
puStack_70 = &DAT_0010200d;
local_68 = &DAT_00102012;
puStack_60 = &DAT_00102011;
local_48 = &DAT_001020e6;
local_58 = &DAT_0010217f;
puStack_50 = &DAT_0010217e;
local_e8 = _DAT_001021e0;
uStack_e0 = _UNK_001021e8;
local_d8 = _DAT_001021f0;
uStack_d0 = _UNK_001021f8;
local_c8 = _DAT_00102200;
uStack_c0 = _UNK_00102208;
if (0 < param_1) {
lVar2 = 0;
do {
iVar1 = *(int *)((long)&local_e8 + lVar2 * 4);
if (iVar1 <= param_1) {
__src = local_a8[lVar2];
do {
param_1 = param_1 - iVar1;
param_2 = strcat(param_2,__src);
} while (iVar1 <= param_1);
if (param_1 == 0) break;
}
lVar2 = lVar2 + 1;
} while( true );
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,284 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(func0(48, 55, 73) == 1);
assert(func0(1, 1, 1) == 0);
assert(func0(2, 2, 10) == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss %xmm2,-0xc(%rbp)
movss -0x4(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss %xmm0,%xmm1
movss -0x8(%rbp),%xmm0
mulss %xmm0,%xmm0
addss %xmm0,%xmm1
movss -0xc(%rbp),%xmm0
mulss %xmm0,%xmm0
subss %xmm0,%xmm1
movaps %xmm1,%xmm0
movss 0xfaf(%rip),%xmm1
andps %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd 0xfb0(%rip),%xmm0
comisd %xmm1,%xmm0
ja 1236 <func0+0xed>
movss -0x4(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss %xmm0,%xmm1
movss -0xc(%rbp),%xmm0
mulss %xmm0,%xmm0
addss %xmm0,%xmm1
movss -0x8(%rbp),%xmm0
mulss %xmm0,%xmm0
subss %xmm0,%xmm1
movaps %xmm1,%xmm0
movss 0xf65(%rip),%xmm1
andps %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd 0xf66(%rip),%xmm0
comisd %xmm1,%xmm0
ja 1236 <func0+0xed>
movss -0x8(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss %xmm0,%xmm1
movss -0xc(%rbp),%xmm0
mulss %xmm0,%xmm0
addss %xmm0,%xmm1
movss -0x4(%rbp),%xmm0
mulss %xmm0,%xmm0
subss %xmm0,%xmm1
movaps %xmm1,%xmm0
movss 0xf1f(%rip),%xmm1
andps %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd 0xf20(%rip),%xmm0
comisd %xmm1,%xmm0
jbe 123d <func0+0xf4>
mov $0x1,%eax
jmp 1242 <func0+0xf9>
mov $0x0,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
movss xmm0, [rbp+var_4]
movaps xmm1, xmm0
mulss xmm1, xmm0
movss xmm0, [rbp+var_8]
mulss xmm0, xmm0
addss xmm1, xmm0
movss xmm0, [rbp+var_C]
movaps xmm2, xmm0
mulss xmm2, xmm0
subss xmm1, xmm2
movaps xmm0, xmm1
movss xmm1, cs:dword_2120
andps xmm0, xmm1
pxor xmm1, xmm1
cvtss2sd xmm1, xmm0
movsd xmm0, cs:qword_2130
comisd xmm0, xmm1
ja loc_124B
movss xmm0, [rbp+var_4]
movaps xmm1, xmm0
mulss xmm1, xmm0
movss xmm0, [rbp+var_C]
mulss xmm0, xmm0
addss xmm1, xmm0
movss xmm0, [rbp+var_8]
movaps xmm2, xmm0
mulss xmm2, xmm0
subss xmm1, xmm2
movaps xmm0, xmm1
movss xmm1, cs:dword_2120
andps xmm0, xmm1
pxor xmm1, xmm1
cvtss2sd xmm1, xmm0
movsd xmm0, cs:qword_2130
comisd xmm0, xmm1
ja short loc_124B
movss xmm0, [rbp+var_8]
movaps xmm1, xmm0
mulss xmm1, xmm0
movss xmm0, [rbp+var_C]
mulss xmm0, xmm0
addss xmm1, xmm0
movss xmm0, [rbp+var_4]
movaps xmm2, xmm0
mulss xmm2, xmm0
subss xmm1, xmm2
movaps xmm0, xmm1
movss xmm1, cs:dword_2120
andps xmm0, xmm1
pxor xmm1, xmm1
cvtss2sd xmm1, xmm0
movsd xmm0, cs:qword_2130
comisd xmm0, xmm1
jbe short loc_1252
loc_124B:
mov eax, 1
jmp short loc_1257
loc_1252:
mov eax, 0
loc_1257:
pop rbp
retn
|
_BOOL8 func0(float a1, float a2, float a3)
{
return fabs((float)((float)(a1 * a1) + (float)(a2 * a2)) - (float)(a3 * a3)) < 0.0001
|| fabs((float)((float)(a1 * a1) + (float)(a3 * a3)) - (float)(a2 * a2)) < 0.0001
|| fabs((float)((float)(a2 * a2) + (float)(a3 * a3)) - (float)(a1 * a1)) < 0.0001;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x8]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0xc]
MOVAPS XMM2,XMM0
MULSS XMM2,XMM0
SUBSS XMM1,XMM2
MOVAPS XMM0,XMM1
MOVSS XMM1,dword ptr [0x00102120]
ANDPS XMM0,XMM1
PXOR XMM1,XMM1
CVTSS2SD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102130]
COMISD XMM0,XMM1
JA 0x0010124b
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0xc]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x8]
MOVAPS XMM2,XMM0
MULSS XMM2,XMM0
SUBSS XMM1,XMM2
MOVAPS XMM0,XMM1
MOVSS XMM1,dword ptr [0x00102120]
ANDPS XMM0,XMM1
PXOR XMM1,XMM1
CVTSS2SD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102130]
COMISD XMM0,XMM1
JA 0x0010124b
MOVSS XMM0,dword ptr [RBP + -0x8]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0xc]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM2,XMM0
MULSS XMM2,XMM0
SUBSS XMM1,XMM2
MOVAPS XMM0,XMM1
MOVSS XMM1,dword ptr [0x00102120]
ANDPS XMM0,XMM1
PXOR XMM1,XMM1
CVTSS2SD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102130]
COMISD XMM0,XMM1
JBE 0x00101252
LAB_0010124b:
MOV EAX,0x1
JMP 0x00101257
LAB_00101252:
MOV EAX,0x0
LAB_00101257:
POP RBP
RET
|
int8 func0(float param_1,float param_2,float param_3)
{
int8 uVar1;
if ((((double)(float)((uint)((param_1 * param_1 + param_2 * param_2) - param_3 * param_3) &
DAT_00102120) < DAT_00102130) ||
((double)(float)((uint)((param_1 * param_1 + param_3 * param_3) - param_2 * param_2) &
DAT_00102120) < DAT_00102130)) ||
((double)(float)((uint)((param_2 * param_2 + param_3 * param_3) - param_1 * param_1) &
DAT_00102120) < DAT_00102130)) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
}
|
1,285 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(func0(48, 55, 73) == 1);
assert(func0(1, 1, 1) == 0);
assert(func0(2, 2, 10) == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mulss %xmm0,%xmm0
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps 0xec5(%rip),%xmm3
cvtss2sd %xmm3,%xmm3
mov $0x1,%eax
movsd 0xec4(%rip),%xmm4
comisd %xmm3,%xmm4
ja 119b <func0+0x72>
movaps %xmm0,%xmm3
addss %xmm2,%xmm3
subss %xmm1,%xmm3
andps 0xe9c(%rip),%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 119b <func0+0x72>
addss %xmm2,%xmm1
subss %xmm0,%xmm1
andps 0xe83(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
comisd %xmm1,%xmm4
seta %al
movzbl %al,%eax
retq
|
func0:
endbr64
movaps xmm3, xmm0
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, cs:xmmword_2010
cvtss2sd xmm0, xmm0
mov eax, 1
movsd xmm4, cs:qword_2020
comisd xmm4, xmm0
ja short locret_119E
movaps xmm0, xmm3
addss xmm0, xmm2
subss xmm0, xmm1
andps xmm0, cs:xmmword_2010
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_119E
addss xmm1, xmm2
subss xmm1, xmm3
andps xmm1, cs:xmmword_2010
cvtss2sd xmm1, xmm1
comisd xmm4, xmm1
setnbe al
movzx eax, al
locret_119E:
retn
|
_BOOL8 func0(float a1, float a2, float a3)
{
float v3; // xmm3_4
float v4; // xmm1_4
float v5; // xmm2_4
_BOOL8 result; // rax
v3 = a1 * a1;
v4 = a2 * a2;
v5 = a3 * a3;
result = 1LL;
if ( fabs((float)((float)(a1 * a1) + v4) - v5) >= 0.0001 && fabs((float)(v3 + v5) - v4) >= 0.0001 )
return fabs((float)(v4 + v5) - v3) < 0.0001;
return result;
}
|
func0:
ENDBR64
MOVAPS XMM3,XMM0
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,xmmword ptr [0x00102010]
CVTSS2SD XMM0,XMM0
MOV EAX,0x1
MOVSD XMM4,qword ptr [0x00102020]
COMISD XMM4,XMM0
JA 0x0010119e
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,XMM1
ANDPS XMM0,xmmword ptr [0x00102010]
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x0010119e
ADDSS XMM1,XMM2
SUBSS XMM1,XMM3
ANDPS XMM1,xmmword ptr [0x00102010]
CVTSS2SD XMM1,XMM1
COMISD XMM4,XMM1
SETA AL
MOVZX EAX,AL
LAB_0010119e:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
param_1 = param_1 * param_1;
param_2 = param_2 * param_2;
param_3 = param_3 * param_3;
bVar1 = true;
if ((DAT_00102020 <= (double)(float)((uint)((param_1 + param_2) - param_3) & _DAT_00102010)) &&
(DAT_00102020 <= (double)(float)((uint)((param_1 + param_3) - param_2) & _DAT_00102010))) {
bVar1 = (double)(float)((uint)((param_2 + param_3) - param_1) & _DAT_00102010) < DAT_00102020;
}
return bVar1;
}
|
1,286 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(func0(48, 55, 73) == 1);
assert(func0(1, 1, 1) == 0);
assert(func0(2, 2, 10) == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mulss %xmm0,%xmm0
movsd 0xed0(%rip),%xmm4
movss 0xeb8(%rip),%xmm5
mov $0x1,%eax
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ad <func0+0x6d>
movaps %xmm0,%xmm3
addss %xmm2,%xmm3
subss %xmm1,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ad <func0+0x6d>
addss %xmm2,%xmm1
xor %eax,%eax
subss %xmm0,%xmm1
andps %xmm5,%xmm1
cvtss2sd %xmm1,%xmm1
comisd %xmm1,%xmm4
seta %al
retq
xchg %ax,%ax
|
func0:
endbr64
movaps xmm3, xmm0
movsd xmm4, cs:qword_2020
movss xmm5, cs:dword_2010
mov eax, 1
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11B0
movaps xmm0, xmm3
addss xmm0, xmm2
subss xmm0, xmm1
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11B0
addss xmm1, xmm2
xor eax, eax
subss xmm1, xmm3
andps xmm1, xmm5
cvtss2sd xmm1, xmm1
comisd xmm4, xmm1
setnbe al
locret_11B0:
retn
|
_BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
float v4; // xmm3_4
float v5; // xmm1_4
float v6; // xmm2_4
result = 1LL;
v4 = a1 * a1;
v5 = a2 * a2;
v6 = a3 * a3;
if ( fabs((float)((float)(a1 * a1) + v5) - v6) >= 0.0001 && fabs((float)(v4 + v6) - v5) >= 0.0001 )
return fabs((float)(v5 + v6) - v4) < 0.0001;
return result;
}
|
func0:
ENDBR64
MOVAPS XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102020]
MOVSS XMM5,dword ptr [0x00102010]
MOV EAX,0x1
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011b0
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,XMM1
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011b0
ADDSS XMM1,XMM2
XOR EAX,EAX
SUBSS XMM1,XMM3
ANDPS XMM1,XMM5
CVTSS2SD XMM1,XMM1
COMISD XMM4,XMM1
SETA AL
LAB_001011b0:
RET
|
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
bVar1 = true;
param_1 = param_1 * param_1;
param_2 = param_2 * param_2;
param_3 = param_3 * param_3;
if ((DAT_00102020 <= (double)(float)((uint)((param_1 + param_2) - param_3) & DAT_00102010)) &&
(DAT_00102020 <= (double)(float)((uint)((param_1 + param_3) - param_2) & DAT_00102010))) {
bVar1 = (double)(float)((uint)((param_2 + param_3) - param_1) & DAT_00102010) < DAT_00102020;
}
return bVar1;
}
|
1,287 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float a, float b, float c) {
if (fabs(a*a + b*b - c*c) < 1e-4 || fabs(a*a + c*c - b*b) < 1e-4 || fabs(b*b + c*c - a*a) < 1e-4) return 1;
return 0;
}
|
#include <assert.h>
int main() {
assert(func0(3, 4, 5) == 1);
assert(func0(1, 2, 3) == 0);
assert(func0(10, 6, 8) == 1);
assert(func0(2, 2, 2) == 0);
assert(func0(7, 24, 25) == 1);
assert(func0(10, 5, 7) == 0);
assert(func0(5, 12, 13) == 1);
assert(func0(15, 8, 17) == 1);
assert(func0(48, 55, 73) == 1);
assert(func0(1, 1, 1) == 0);
assert(func0(2, 2, 10) == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mulss %xmm0,%xmm0
movsd 0xed0(%rip),%xmm4
movss 0xeb8(%rip),%xmm5
mov $0x1,%eax
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ad <func0+0x6d>
movaps %xmm0,%xmm3
addss %xmm2,%xmm3
subss %xmm1,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ad <func0+0x6d>
addss %xmm2,%xmm1
xor %eax,%eax
subss %xmm0,%xmm1
andps %xmm5,%xmm1
cvtss2sd %xmm1,%xmm1
comisd %xmm1,%xmm4
seta %al
retq
xchg %ax,%ax
|
func0:
endbr64
movaps xmm3, xmm0
movsd xmm4, cs:qword_2020
movss xmm5, cs:dword_2010
mov eax, 1
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11B0
movaps xmm0, xmm3
addss xmm0, xmm2
subss xmm0, xmm1
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11B0
addss xmm1, xmm2
xor eax, eax
subss xmm1, xmm3
andps xmm1, xmm5
cvtss2sd xmm1, xmm1
comisd xmm4, xmm1
setnbe al
locret_11B0:
retn
|
_BOOL8 func0(float a1, float a2, float a3)
{
_BOOL8 result; // rax
float v4; // xmm3_4
float v5; // xmm1_4
float v6; // xmm2_4
result = 1LL;
v4 = a1 * a1;
v5 = a2 * a2;
v6 = a3 * a3;
if ( fabs((float)((float)(a1 * a1) + v5) - v6) >= 0.0001 && fabs((float)(v4 + v6) - v5) >= 0.0001 )
return fabs((float)(v5 + v6) - v4) < 0.0001;
return result;
}
|
func0:
ENDBR64
MOVAPS XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102020]
MOVSS XMM5,dword ptr [0x00102010]
MOV EAX,0x1
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011b0
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,XMM1
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011b0
ADDSS XMM1,XMM2
XOR EAX,EAX
SUBSS XMM1,XMM3
ANDPS XMM1,XMM5
CVTSS2SD XMM1,XMM1
COMISD XMM4,XMM1
SETA AL
LAB_001011b0:
RET
|
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
bVar1 = true;
param_1 = param_1 * param_1;
param_2 = param_2 * param_2;
param_3 = param_3 * param_3;
if ((DAT_00102020 <= (double)(float)((uint)((param_1 + param_2) - param_3) & DAT_00102010)) &&
(DAT_00102020 <= (double)(float)((uint)((param_1 + param_3) - param_2) & DAT_00102010))) {
bVar1 = (double)(float)((uint)((param_2 + param_3) - param_1) & DAT_00102010) < DAT_00102020;
}
return bVar1;
}
|
1,288 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
unique[len] = words[i][j];
unique[len + 1] = '\0';
unique_count++;
}
}
if (unique_count > maxu || (unique_count == maxu && strcmp(words[i], max) < 0)) {
max = words[i];
maxu = unique_count;
}
}
return max;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(func0(words3, 3), "aaaaaaa") == 0);
char *words4[] = {"abc", "cba"};
assert(strcmp(func0(words4, 2), "abc") == 0);
char *words5[] = {"play", "this", "game", "of", "footbott"};
assert(strcmp(func0(words5, 5), "footbott") == 0);
char *words6[] = {"we", "are", "gonna", "rock"};
assert(strcmp(func0(words6, 4), "gonna") == 0);
char *words7[] = {"we", "are", "a", "mad", "nation"};
assert(strcmp(func0(words7, 5), "nation") == 0);
char *words8[] = {"this", "is", "a", "prrk"};
assert(strcmp(func0(words8, 4), "this") == 0);
char *words9[] = {"b"};
assert(strcmp(func0(words9, 1), "b") == 0);
char *words10[] = {"play", "play", "play"};
assert(strcmp(func0(words10, 3), "play") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x140,%rsp
mov %rdi,-0x138(%rbp)
mov %esi,-0x13c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe0d(%rip),%rax
mov %rax,-0x118(%rbp)
movl $0x0,-0x12c(%rbp)
movl $0x0,-0x128(%rbp)
jmpq 14d7 <func0+0x30e>
movq $0x0,-0x110(%rbp)
movq $0x0,-0x108(%rbp)
movq $0x0,-0x100(%rbp)
movq $0x0,-0xf8(%rbp)
movq $0x0,-0xf0(%rbp)
movq $0x0,-0xe8(%rbp)
movq $0x0,-0xe0(%rbp)
movq $0x0,-0xd8(%rbp)
movq $0x0,-0xd0(%rbp)
movq $0x0,-0xc8(%rbp)
movq $0x0,-0xc0(%rbp)
movq $0x0,-0xb8(%rbp)
movq $0x0,-0xb0(%rbp)
movq $0x0,-0xa8(%rbp)
movq $0x0,-0xa0(%rbp)
movq $0x0,-0x98(%rbp)
movq $0x0,-0x90(%rbp)
movq $0x0,-0x88(%rbp)
movq $0x0,-0x80(%rbp)
movq $0x0,-0x78(%rbp)
movq $0x0,-0x70(%rbp)
movq $0x0,-0x68(%rbp)
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
movq $0x0,-0x40(%rbp)
movq $0x0,-0x38(%rbp)
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
movq $0x0,-0x18(%rbp)
movl $0x0,-0x124(%rbp)
movl $0x0,-0x120(%rbp)
jmpq 141e <func0+0x255>
mov -0x128(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x120(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
lea -0x110(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 10b0 <strchr@plt>
test %rax,%rax
jne 1417 <func0+0x24e>
lea -0x110(%rbp),%rax
mov %rax,%rdi
callq 1090 <strlen@plt>
mov %eax,-0x11c(%rbp)
mov -0x128(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x120(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%edx
mov -0x11c(%rbp),%eax
cltq
mov %dl,-0x110(%rbp,%rax,1)
mov -0x11c(%rbp),%eax
add $0x1,%eax
cltq
movb $0x0,-0x110(%rbp,%rax,1)
addl $0x1,-0x124(%rbp)
addl $0x1,-0x120(%rbp)
mov -0x128(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x120(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 136a <func0+0x1a1>
mov -0x124(%rbp),%eax
cmp -0x12c(%rbp),%eax
jg 14a0 <func0+0x2d7>
mov -0x124(%rbp),%eax
cmp -0x12c(%rbp),%eax
jne 14d0 <func0+0x307>
mov -0x128(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x118(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 10d0 <strcmp@plt>
test %eax,%eax
jns 14d0 <func0+0x307>
mov -0x128(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x118(%rbp)
mov -0x124(%rbp),%eax
mov %eax,-0x12c(%rbp)
addl $0x1,-0x128(%rbp)
mov -0x128(%rbp),%eax
cmp -0x13c(%rbp),%eax
jl 121b <func0+0x52>
mov -0x118(%rbp),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1504 <func0+0x33b>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 140h
mov [rbp+var_138], rdi
mov [rbp+var_13C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, unk_2008
mov [rbp+s2], rax
mov [rbp+var_12C], 0
mov [rbp+var_128], 0
jmp loc_14D7
loc_121B:
mov qword ptr [rbp+s], 0
mov [rbp+var_108], 0
mov [rbp+var_100], 0
mov [rbp+var_F8], 0
mov [rbp+var_F0], 0
mov [rbp+var_E8], 0
mov [rbp+var_E0], 0
mov [rbp+var_D8], 0
mov [rbp+var_D0], 0
mov [rbp+var_C8], 0
mov [rbp+var_C0], 0
mov [rbp+var_B8], 0
mov [rbp+var_B0], 0
mov [rbp+var_A8], 0
mov [rbp+var_A0], 0
mov [rbp+var_98], 0
mov [rbp+var_90], 0
mov [rbp+var_88], 0
mov [rbp+var_80], 0
mov [rbp+var_78], 0
mov [rbp+var_70], 0
mov [rbp+var_68], 0
mov [rbp+var_60], 0
mov [rbp+var_58], 0
mov [rbp+var_50], 0
mov [rbp+var_48], 0
mov [rbp+var_40], 0
mov [rbp+var_38], 0
mov [rbp+var_30], 0
mov [rbp+var_28], 0
mov [rbp+var_20], 0
mov [rbp+var_18], 0
mov [rbp+var_124], 0
mov [rbp+var_120], 0
jmp loc_141E
loc_136A:
mov eax, [rbp+var_128]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_138]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_120]
cdqe
add rax, rdx
movzx eax, byte ptr [rax]
movsx edx, al
lea rax, [rbp+s]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jnz short loc_1417
lea rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_11C], eax
mov eax, [rbp+var_128]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_138]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_120]
cdqe
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_11C]
cdqe
mov [rbp+rax+s], dl
mov eax, [rbp+var_11C]
add eax, 1
cdqe
mov [rbp+rax+s], 0
add [rbp+var_124], 1
loc_1417:
add [rbp+var_120], 1
loc_141E:
mov eax, [rbp+var_128]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_138]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_120]
cdqe
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_136A
mov eax, [rbp+var_124]
cmp eax, [rbp+var_12C]
jg short loc_14A0
mov eax, [rbp+var_124]
cmp eax, [rbp+var_12C]
jnz short loc_14D0
mov eax, [rbp+var_128]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_138]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+s2]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jns short loc_14D0
loc_14A0:
mov eax, [rbp+var_128]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_138]
add rax, rdx
mov rax, [rax]
mov [rbp+s2], rax
mov eax, [rbp+var_124]
mov [rbp+var_12C], eax
loc_14D0:
add [rbp+var_128], 1
loc_14D7:
mov eax, [rbp+var_128]
cmp eax, [rbp+var_13C]
jl loc_121B
mov rax, [rbp+s2]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1504
call ___stack_chk_fail
locret_1504:
leave
retn
|
char * func0(long long a1, int a2)
{
int v3; // [rsp+14h] [rbp-12Ch]
int i; // [rsp+18h] [rbp-128h]
int v5; // [rsp+1Ch] [rbp-124h]
int j; // [rsp+20h] [rbp-120h]
int v7; // [rsp+24h] [rbp-11Ch]
char *s2; // [rsp+28h] [rbp-118h]
char s[8]; // [rsp+30h] [rbp-110h] BYREF
long long v10; // [rsp+38h] [rbp-108h]
long long v11; // [rsp+40h] [rbp-100h]
long long v12; // [rsp+48h] [rbp-F8h]
long long v13; // [rsp+50h] [rbp-F0h]
long long v14; // [rsp+58h] [rbp-E8h]
long long v15; // [rsp+60h] [rbp-E0h]
long long v16; // [rsp+68h] [rbp-D8h]
long long v17; // [rsp+70h] [rbp-D0h]
long long v18; // [rsp+78h] [rbp-C8h]
long long v19; // [rsp+80h] [rbp-C0h]
long long v20; // [rsp+88h] [rbp-B8h]
long long v21; // [rsp+90h] [rbp-B0h]
long long v22; // [rsp+98h] [rbp-A8h]
long long v23; // [rsp+A0h] [rbp-A0h]
long long v24; // [rsp+A8h] [rbp-98h]
long long v25; // [rsp+B0h] [rbp-90h]
long long v26; // [rsp+B8h] [rbp-88h]
long long v27; // [rsp+C0h] [rbp-80h]
long long v28; // [rsp+C8h] [rbp-78h]
long long v29; // [rsp+D0h] [rbp-70h]
long long v30; // [rsp+D8h] [rbp-68h]
long long v31; // [rsp+E0h] [rbp-60h]
long long v32; // [rsp+E8h] [rbp-58h]
long long v33; // [rsp+F0h] [rbp-50h]
long long v34; // [rsp+F8h] [rbp-48h]
long long v35; // [rsp+100h] [rbp-40h]
long long v36; // [rsp+108h] [rbp-38h]
long long v37; // [rsp+110h] [rbp-30h]
long long v38; // [rsp+118h] [rbp-28h]
long long v39; // [rsp+120h] [rbp-20h]
long long v40; // [rsp+128h] [rbp-18h]
unsigned long long v41; // [rsp+138h] [rbp-8h]
v41 = __readfsqword(0x28u);
s2 = (char *)&unk_2008;
v3 = 0;
for ( i = 0; i < a2; ++i )
{
*(_QWORD *)s = 0LL;
v10 = 0LL;
v11 = 0LL;
v12 = 0LL;
v13 = 0LL;
v14 = 0LL;
v15 = 0LL;
v16 = 0LL;
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0LL;
v25 = 0LL;
v26 = 0LL;
v27 = 0LL;
v28 = 0LL;
v29 = 0LL;
v30 = 0LL;
v31 = 0LL;
v32 = 0LL;
v33 = 0LL;
v34 = 0LL;
v35 = 0LL;
v36 = 0LL;
v37 = 0LL;
v38 = 0LL;
v39 = 0LL;
v40 = 0LL;
v5 = 0;
for ( j = 0; *(_BYTE *)(*(_QWORD *)(8LL * i + a1) + j); ++j )
{
if ( !strchr(s, *(char *)(*(_QWORD *)(8LL * i + a1) + j)) )
{
v7 = strlen(s);
s[v7] = *(_BYTE *)(*(_QWORD *)(8LL * i + a1) + j);
s[v7 + 1] = 0;
++v5;
}
}
if ( v5 > v3 || v5 == v3 && strcmp(*(const char **)(8LL * i + a1), s2) < 0 )
{
s2 = *(char **)(8LL * i + a1);
v3 = v5;
}
}
return s2;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x140
MOV qword ptr [RBP + -0x138],RDI
MOV dword ptr [RBP + -0x13c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x118],RAX
MOV dword ptr [RBP + -0x12c],0x0
MOV dword ptr [RBP + -0x128],0x0
JMP 0x001014d7
LAB_0010121b:
MOV qword ptr [RBP + -0x110],0x0
MOV qword ptr [RBP + -0x108],0x0
MOV qword ptr [RBP + -0x100],0x0
MOV qword ptr [RBP + -0xf8],0x0
MOV qword ptr [RBP + -0xf0],0x0
MOV qword ptr [RBP + -0xe8],0x0
MOV qword ptr [RBP + -0xe0],0x0
MOV qword ptr [RBP + -0xd8],0x0
MOV qword ptr [RBP + -0xd0],0x0
MOV qword ptr [RBP + -0xc8],0x0
MOV qword ptr [RBP + -0xc0],0x0
MOV qword ptr [RBP + -0xb8],0x0
MOV qword ptr [RBP + -0xb0],0x0
MOV qword ptr [RBP + -0xa8],0x0
MOV qword ptr [RBP + -0xa0],0x0
MOV qword ptr [RBP + -0x98],0x0
MOV qword ptr [RBP + -0x90],0x0
MOV qword ptr [RBP + -0x88],0x0
MOV qword ptr [RBP + -0x80],0x0
MOV qword ptr [RBP + -0x78],0x0
MOV qword ptr [RBP + -0x70],0x0
MOV qword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x28],0x0
MOV qword ptr [RBP + -0x20],0x0
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x124],0x0
MOV dword ptr [RBP + -0x120],0x0
JMP 0x0010141e
LAB_0010136a:
MOV EAX,dword ptr [RBP + -0x128]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x120]
CDQE
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
LEA RAX,[RBP + -0x110]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x001010b0
TEST RAX,RAX
JNZ 0x00101417
LEA RAX,[RBP + -0x110]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0x11c],EAX
MOV EAX,dword ptr [RBP + -0x128]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x120]
CDQE
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x11c]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x110],DL
MOV EAX,dword ptr [RBP + -0x11c]
ADD EAX,0x1
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x110],0x0
ADD dword ptr [RBP + -0x124],0x1
LAB_00101417:
ADD dword ptr [RBP + -0x120],0x1
LAB_0010141e:
MOV EAX,dword ptr [RBP + -0x128]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x120]
CDQE
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010136a
MOV EAX,dword ptr [RBP + -0x124]
CMP EAX,dword ptr [RBP + -0x12c]
JG 0x001014a0
MOV EAX,dword ptr [RBP + -0x124]
CMP EAX,dword ptr [RBP + -0x12c]
JNZ 0x001014d0
MOV EAX,dword ptr [RBP + -0x128]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x118]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
TEST EAX,EAX
JNS 0x001014d0
LAB_001014a0:
MOV EAX,dword ptr [RBP + -0x128]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x118],RAX
MOV EAX,dword ptr [RBP + -0x124]
MOV dword ptr [RBP + -0x12c],EAX
LAB_001014d0:
ADD dword ptr [RBP + -0x128],0x1
LAB_001014d7:
MOV EAX,dword ptr [RBP + -0x128]
CMP EAX,dword ptr [RBP + -0x13c]
JL 0x0010121b
MOV RAX,qword ptr [RBP + -0x118]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101504
CALL 0x001010a0
LAB_00101504:
LEAVE
RET
|
char * func0(long param_1,int param_2)
{
int iVar1;
char *pcVar2;
size_t sVar3;
long in_FS_OFFSET;
int local_134;
int local_130;
int local_12c;
int local_128;
char *local_120;
char local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_120 = "";
local_134 = 0;
local_130 = 0;
do {
if (param_2 <= local_130) {
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_120;
}
local_118[0] = '\0';
local_118[1] = '\0';
local_118[2] = '\0';
local_118[3] = '\0';
local_118[4] = '\0';
local_118[5] = '\0';
local_118[6] = '\0';
local_118[7] = '\0';
local_118[8] = '\0';
local_118[9] = '\0';
local_118[10] = '\0';
local_118[0xb] = '\0';
local_118[0xc] = '\0';
local_118[0xd] = '\0';
local_118[0xe] = '\0';
local_118[0xf] = '\0';
local_118[0x10] = '\0';
local_118[0x11] = '\0';
local_118[0x12] = '\0';
local_118[0x13] = '\0';
local_118[0x14] = '\0';
local_118[0x15] = '\0';
local_118[0x16] = '\0';
local_118[0x17] = '\0';
local_118[0x18] = '\0';
local_118[0x19] = '\0';
local_118[0x1a] = '\0';
local_118[0x1b] = '\0';
local_118[0x1c] = '\0';
local_118[0x1d] = '\0';
local_118[0x1e] = '\0';
local_118[0x1f] = '\0';
local_118[0x20] = '\0';
local_118[0x21] = '\0';
local_118[0x22] = '\0';
local_118[0x23] = '\0';
local_118[0x24] = '\0';
local_118[0x25] = '\0';
local_118[0x26] = '\0';
local_118[0x27] = '\0';
local_118[0x28] = '\0';
local_118[0x29] = '\0';
local_118[0x2a] = '\0';
local_118[0x2b] = '\0';
local_118[0x2c] = '\0';
local_118[0x2d] = '\0';
local_118[0x2e] = '\0';
local_118[0x2f] = '\0';
local_118[0x30] = '\0';
local_118[0x31] = '\0';
local_118[0x32] = '\0';
local_118[0x33] = '\0';
local_118[0x34] = '\0';
local_118[0x35] = '\0';
local_118[0x36] = '\0';
local_118[0x37] = '\0';
local_118[0x38] = '\0';
local_118[0x39] = '\0';
local_118[0x3a] = '\0';
local_118[0x3b] = '\0';
local_118[0x3c] = '\0';
local_118[0x3d] = '\0';
local_118[0x3e] = '\0';
local_118[0x3f] = '\0';
local_118[0x40] = '\0';
local_118[0x41] = '\0';
local_118[0x42] = '\0';
local_118[0x43] = '\0';
local_118[0x44] = '\0';
local_118[0x45] = '\0';
local_118[0x46] = '\0';
local_118[0x47] = '\0';
local_118[0x48] = '\0';
local_118[0x49] = '\0';
local_118[0x4a] = '\0';
local_118[0x4b] = '\0';
local_118[0x4c] = '\0';
local_118[0x4d] = '\0';
local_118[0x4e] = '\0';
local_118[0x4f] = '\0';
local_118[0x50] = '\0';
local_118[0x51] = '\0';
local_118[0x52] = '\0';
local_118[0x53] = '\0';
local_118[0x54] = '\0';
local_118[0x55] = '\0';
local_118[0x56] = '\0';
local_118[0x57] = '\0';
local_118[0x58] = '\0';
local_118[0x59] = '\0';
local_118[0x5a] = '\0';
local_118[0x5b] = '\0';
local_118[0x5c] = '\0';
local_118[0x5d] = '\0';
local_118[0x5e] = '\0';
local_118[0x5f] = '\0';
local_118[0x60] = '\0';
local_118[0x61] = '\0';
local_118[0x62] = '\0';
local_118[99] = '\0';
local_118[100] = '\0';
local_118[0x65] = '\0';
local_118[0x66] = '\0';
local_118[0x67] = '\0';
local_118[0x68] = '\0';
local_118[0x69] = '\0';
local_118[0x6a] = '\0';
local_118[0x6b] = '\0';
local_118[0x6c] = '\0';
local_118[0x6d] = '\0';
local_118[0x6e] = '\0';
local_118[0x6f] = '\0';
local_118[0x70] = '\0';
local_118[0x71] = '\0';
local_118[0x72] = '\0';
local_118[0x73] = '\0';
local_118[0x74] = '\0';
local_118[0x75] = '\0';
local_118[0x76] = '\0';
local_118[0x77] = '\0';
local_118[0x78] = '\0';
local_118[0x79] = '\0';
local_118[0x7a] = '\0';
local_118[0x7b] = '\0';
local_118[0x7c] = '\0';
local_118[0x7d] = '\0';
local_118[0x7e] = '\0';
local_118[0x7f] = '\0';
local_118[0x80] = '\0';
local_118[0x81] = '\0';
local_118[0x82] = '\0';
local_118[0x83] = '\0';
local_118[0x84] = '\0';
local_118[0x85] = '\0';
local_118[0x86] = '\0';
local_118[0x87] = '\0';
local_118[0x88] = '\0';
local_118[0x89] = '\0';
local_118[0x8a] = '\0';
local_118[0x8b] = '\0';
local_118[0x8c] = '\0';
local_118[0x8d] = '\0';
local_118[0x8e] = '\0';
local_118[0x8f] = '\0';
local_118[0x90] = '\0';
local_118[0x91] = '\0';
local_118[0x92] = '\0';
local_118[0x93] = '\0';
local_118[0x94] = '\0';
local_118[0x95] = '\0';
local_118[0x96] = '\0';
local_118[0x97] = '\0';
local_118[0x98] = '\0';
local_118[0x99] = '\0';
local_118[0x9a] = '\0';
local_118[0x9b] = '\0';
local_118[0x9c] = '\0';
local_118[0x9d] = '\0';
local_118[0x9e] = '\0';
local_118[0x9f] = '\0';
local_118[0xa0] = '\0';
local_118[0xa1] = '\0';
local_118[0xa2] = '\0';
local_118[0xa3] = '\0';
local_118[0xa4] = '\0';
local_118[0xa5] = '\0';
local_118[0xa6] = '\0';
local_118[0xa7] = '\0';
local_118[0xa8] = '\0';
local_118[0xa9] = '\0';
local_118[0xaa] = '\0';
local_118[0xab] = '\0';
local_118[0xac] = '\0';
local_118[0xad] = '\0';
local_118[0xae] = '\0';
local_118[0xaf] = '\0';
local_118[0xb0] = '\0';
local_118[0xb1] = '\0';
local_118[0xb2] = '\0';
local_118[0xb3] = '\0';
local_118[0xb4] = '\0';
local_118[0xb5] = '\0';
local_118[0xb6] = '\0';
local_118[0xb7] = '\0';
local_118[0xb8] = '\0';
local_118[0xb9] = '\0';
local_118[0xba] = '\0';
local_118[0xbb] = '\0';
local_118[0xbc] = '\0';
local_118[0xbd] = '\0';
local_118[0xbe] = '\0';
local_118[0xbf] = '\0';
local_118[0xc0] = '\0';
local_118[0xc1] = '\0';
local_118[0xc2] = '\0';
local_118[0xc3] = '\0';
local_118[0xc4] = '\0';
local_118[0xc5] = '\0';
local_118[0xc6] = '\0';
local_118[199] = '\0';
local_118[200] = '\0';
local_118[0xc9] = '\0';
local_118[0xca] = '\0';
local_118[0xcb] = '\0';
local_118[0xcc] = '\0';
local_118[0xcd] = '\0';
local_118[0xce] = '\0';
local_118[0xcf] = '\0';
local_118[0xd0] = '\0';
local_118[0xd1] = '\0';
local_118[0xd2] = '\0';
local_118[0xd3] = '\0';
local_118[0xd4] = '\0';
local_118[0xd5] = '\0';
local_118[0xd6] = '\0';
local_118[0xd7] = '\0';
local_118[0xd8] = '\0';
local_118[0xd9] = '\0';
local_118[0xda] = '\0';
local_118[0xdb] = '\0';
local_118[0xdc] = '\0';
local_118[0xdd] = '\0';
local_118[0xde] = '\0';
local_118[0xdf] = '\0';
local_118[0xe0] = '\0';
local_118[0xe1] = '\0';
local_118[0xe2] = '\0';
local_118[0xe3] = '\0';
local_118[0xe4] = '\0';
local_118[0xe5] = '\0';
local_118[0xe6] = '\0';
local_118[0xe7] = '\0';
local_118[0xe8] = '\0';
local_118[0xe9] = '\0';
local_118[0xea] = '\0';
local_118[0xeb] = '\0';
local_118[0xec] = '\0';
local_118[0xed] = '\0';
local_118[0xee] = '\0';
local_118[0xef] = '\0';
local_118[0xf0] = '\0';
local_118[0xf1] = '\0';
local_118[0xf2] = '\0';
local_118[0xf3] = '\0';
local_118[0xf4] = '\0';
local_118[0xf5] = '\0';
local_118[0xf6] = '\0';
local_118[0xf7] = '\0';
local_118[0xf8] = '\0';
local_118[0xf9] = '\0';
local_118[0xfa] = '\0';
local_118[0xfb] = '\0';
local_118[0xfc] = '\0';
local_118[0xfd] = '\0';
local_118[0xfe] = '\0';
local_118[0xff] = '\0';
local_12c = 0;
for (local_128 = 0;
*(char *)((long)local_128 + *(long *)(param_1 + (long)local_130 * 8)) != '\0';
local_128 = local_128 + 1) {
pcVar2 = strchr(local_118,
(int)*(char *)((long)local_128 + *(long *)(param_1 + (long)local_130 * 8)));
if (pcVar2 == (char *)0x0) {
sVar3 = strlen(local_118);
local_118[(int)sVar3] =
*(char *)((long)local_128 + *(long *)(param_1 + (long)local_130 * 8));
local_118[(int)sVar3 + 1] = '\0';
local_12c = local_12c + 1;
}
}
if (local_134 < local_12c) {
LAB_001014a0:
local_120 = *(char **)(param_1 + (long)local_130 * 8);
local_134 = local_12c;
}
else if (local_12c == local_134) {
iVar1 = strcmp(*(char **)(param_1 + (long)local_130 * 8),local_120);
if (iVar1 < 0) goto LAB_001014a0;
}
local_130 = local_130 + 1;
} while( true );
}
|
1,289 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
unique[len] = words[i][j];
unique[len + 1] = '\0';
unique_count++;
}
}
if (unique_count > maxu || (unique_count == maxu && strcmp(words[i], max) < 0)) {
max = words[i];
maxu = unique_count;
}
}
return max;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(func0(words3, 3), "aaaaaaa") == 0);
char *words4[] = {"abc", "cba"};
assert(strcmp(func0(words4, 2), "abc") == 0);
char *words5[] = {"play", "this", "game", "of", "footbott"};
assert(strcmp(func0(words5, 5), "footbott") == 0);
char *words6[] = {"we", "are", "gonna", "rock"};
assert(strcmp(func0(words6, 4), "gonna") == 0);
char *words7[] = {"we", "are", "a", "mad", "nation"};
assert(strcmp(func0(words7, 5), "nation") == 0);
char *words8[] = {"this", "is", "a", "prrk"};
assert(strcmp(func0(words8, 4), "this") == 0);
char *words9[] = {"b"};
assert(strcmp(func0(words9, 1), "b") == 0);
char *words10[] = {"play", "play", "play"};
assert(strcmp(func0(words10, 3), "play") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
lea 0xe4c(%rip),%rax
mov %rax,0x10(%rsp)
test %esi,%esi
jle 141a <func0+0x271>
mov %rdi,%r14
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rax
mov %rax,0x18(%rsp)
movl $0x0,0xc(%rsp)
lea 0x20(%rsp),%r12
jmpq 12a0 <func0+0xf7>
mov $0xffffffffffffffff,%rcx
mov %r12,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
movslq %ecx,%rax
mov %bl,0x20(%rsp,%rax,1)
add $0x1,%ecx
movslq %ecx,%rcx
movb $0x0,0x20(%rsp,%rcx,1)
add $0x1,%r13d
add $0x1,%rbp
movzbl -0x1(%rbp),%ebx
test %bl,%bl
je 1254 <func0+0xab>
movsbl %bl,%esi
mov %r12,%rdi
callq 1090 <strchr@plt>
test %rax,%rax
jne 1230 <func0+0x87>
jmp 1207 <func0+0x5e>
mov $0x0,%r13d
mov 0xc(%rsp),%eax
cmp %r13d,%eax
jl 1287 <func0+0xde>
jne 1291 <func0+0xe8>
mov 0x10(%rsp),%rbx
mov %rbx,%rsi
mov %r15,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
cmovns 0xc(%rsp),%r13d
mov %r13d,0xc(%rsp)
cmovns %rbx,%r15
mov %r15,0x10(%rsp)
jmp 1291 <func0+0xe8>
mov %r13d,0xc(%rsp)
mov %r15,0x10(%rsp)
add $0x8,%r14
cmp 0x18(%rsp),%r14
je 141a <func0+0x271>
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
movq $0x0,0x40(%rsp)
movq $0x0,0x48(%rsp)
movq $0x0,0x50(%rsp)
movq $0x0,0x58(%rsp)
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
movq $0x0,0x78(%rsp)
movq $0x0,0x80(%rsp)
movq $0x0,0x88(%rsp)
movq $0x0,0x90(%rsp)
movq $0x0,0x98(%rsp)
movq $0x0,0xa0(%rsp)
movq $0x0,0xa8(%rsp)
movq $0x0,0xb0(%rsp)
movq $0x0,0xb8(%rsp)
movq $0x0,0xc0(%rsp)
movq $0x0,0xc8(%rsp)
movq $0x0,0xd0(%rsp)
movq $0x0,0xd8(%rsp)
movq $0x0,0xe0(%rsp)
movq $0x0,0xe8(%rsp)
movq $0x0,0xf0(%rsp)
movq $0x0,0xf8(%rsp)
movq $0x0,0x100(%rsp)
movq $0x0,0x108(%rsp)
movq $0x0,0x110(%rsp)
movq $0x0,0x118(%rsp)
mov (%r14),%r15
movzbl (%r15),%ebx
test %bl,%bl
je 124e <func0+0xa5>
lea 0x1(%r15),%rbp
mov $0x0,%r13d
jmpq 123c <func0+0x93>
mov 0x128(%rsp),%rax
xor %fs:0x28,%rax
jne 1444 <func0+0x29b>
mov 0x10(%rsp),%rax
add $0x138,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1080 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
lea rax, aAaaaaaa+7; ""
mov [rsp+168h+s2], rax
test esi, esi
jle loc_1430
mov r14, rdi
movsxd rsi, esi
lea rax, [rdi+rsi*8]
mov [rsp+168h+var_150], rax
mov [rsp+168h+var_15C], 0
lea r12, [rsp+168h+var_148]
jmp loc_12B6
loc_1226:
mov rdi, r12; s
call _strlen
movsxd rdx, eax
mov byte ptr [rsp+rdx+168h+var_148], bl
add eax, 1
cdqe
mov byte ptr [rsp+rax+168h+var_148], 0
add r13d, 1
loc_1243:
add rbp, 1
movzx ebx, byte ptr [rbp-1]
test bl, bl
jz short loc_1267
loc_124F:
movsx esi, bl; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_1243
jmp short loc_1226
loc_1261:
mov r13d, 0
loc_1267:
mov eax, [rsp+168h+var_15C]
cmp eax, r13d
jl short loc_129A
jnz short loc_12A4
mov rbx, [rsp+168h+s2]
mov rsi, rbx; s2
mov rdi, r15; s1
call _strcmp
test eax, eax
cmovns r13d, [rsp+168h+var_15C]
mov [rsp+168h+var_15C], r13d
cmovns r15, rbx
mov [rsp+168h+s2], r15
jmp short loc_12A4
loc_129A:
mov [rsp+168h+var_15C], r13d
mov [rsp+168h+s2], r15
loc_12A4:
add r14, 8
mov rax, [rsp+168h+var_150]
cmp r14, rax
jz loc_1430
loc_12B6:
mov [rsp+168h+var_148], 0
mov [rsp+168h+var_140], 0
mov [rsp+168h+var_138], 0
mov [rsp+168h+var_130], 0
mov [rsp+168h+var_128], 0
mov [rsp+168h+var_120], 0
mov [rsp+168h+var_118], 0
mov [rsp+168h+var_110], 0
mov [rsp+168h+var_108], 0
mov [rsp+168h+var_100], 0
mov [rsp+168h+var_F8], 0
mov [rsp+168h+var_F0], 0
mov [rsp+168h+var_E8], 0
mov [rsp+168h+var_E0], 0
mov [rsp+168h+var_D8], 0
mov [rsp+168h+var_D0], 0
mov [rsp+168h+var_C8], 0
mov [rsp+168h+var_C0], 0
mov [rsp+168h+var_B8], 0
mov [rsp+168h+var_B0], 0
mov [rsp+168h+var_A8], 0
mov [rsp+168h+var_A0], 0
mov [rsp+168h+var_98], 0
mov [rsp+168h+var_90], 0
mov [rsp+168h+var_88], 0
mov [rsp+168h+var_80], 0
mov [rsp+168h+var_78], 0
mov [rsp+168h+var_70], 0
mov [rsp+168h+var_68], 0
mov [rsp+168h+var_60], 0
mov [rsp+168h+var_58], 0
mov [rsp+168h+var_50], 0
mov r15, [r14]
movzx ebx, byte ptr [r15]
test bl, bl
jz loc_1261
lea rbp, [r15+1]
mov r13d, 0
jmp loc_124F
loc_1430:
mov rax, [rsp+168h+var_40]
sub rax, fs:28h
jnz short loc_145A
mov rax, [rsp+168h+s2]
add rsp, 138h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_145A:
call ___stack_chk_fail
|
char * func0(const char **a1, int a2)
{
const char **v2; // r14
int v3; // eax
int v4; // r13d
char *v5; // rbp
char v6; // bl
int v7; // eax
const char *v8; // r15
int v10; // [rsp+Ch] [rbp-15Ch]
char *s2; // [rsp+10h] [rbp-158h]
_QWORD v12[41]; // [rsp+20h] [rbp-148h] BYREF
v12[33] = __readfsqword(0x28u);
s2 = (char *)"";
if ( a2 > 0 )
{
v2 = a1;
v10 = 0;
do
{
memset(v12, 0, 256);
v8 = *v2;
v6 = **v2;
if ( v6 )
{
v5 = (char *)(v8 + 1);
v4 = 0;
do
{
if ( !strchr((const char *)v12, v6) )
{
v3 = strlen((const char *)v12);
*((_BYTE *)v12 + v3) = v6;
*((_BYTE *)v12 + v3 + 1) = 0;
++v4;
}
v6 = *v5++;
}
while ( v6 );
}
else
{
v4 = 0;
}
if ( v10 < v4 )
{
v10 = v4;
s2 = (char *)v8;
}
else if ( v10 == v4 )
{
v7 = strcmp(v8, s2);
if ( v7 >= 0 )
v4 = v10;
v10 = v4;
if ( v7 >= 0 )
v8 = s2;
s2 = (char *)v8;
}
++v2;
}
while ( v2 != &a1[a2] );
}
return s2;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[0x102024]
MOV qword ptr [RSP + 0x10],RAX
TEST ESI,ESI
JLE 0x00101430
MOV R14,RDI
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV dword ptr [RSP + 0xc],0x0
LEA R12,[RSP + 0x20]
JMP 0x001012b6
LAB_00101226:
MOV RDI,R12
CALL 0x00101090
MOVSXD RDX,EAX
MOV byte ptr [RSP + RDX*0x1 + 0x20],BL
ADD EAX,0x1
CDQE
MOV byte ptr [RSP + RAX*0x1 + 0x20],0x0
ADD R13D,0x1
LAB_00101243:
ADD RBP,0x1
MOVZX EBX,byte ptr [RBP + -0x1]
TEST BL,BL
JZ 0x00101267
LAB_0010124f:
MOVSX ESI,BL
MOV RDI,R12
CALL 0x001010b0
TEST RAX,RAX
JNZ 0x00101243
JMP 0x00101226
LAB_00101261:
MOV R13D,0x0
LAB_00101267:
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,R13D
JL 0x0010129a
JNZ 0x001012a4
MOV RBX,qword ptr [RSP + 0x10]
MOV RSI,RBX
MOV RDI,R15
CALL 0x001010d0
TEST EAX,EAX
CMOVNS R13D,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0xc],R13D
CMOVNS R15,RBX
MOV qword ptr [RSP + 0x10],R15
JMP 0x001012a4
LAB_0010129a:
MOV dword ptr [RSP + 0xc],R13D
MOV qword ptr [RSP + 0x10],R15
LAB_001012a4:
ADD R14,0x8
MOV RAX,qword ptr [RSP + 0x18]
CMP R14,RAX
JZ 0x00101430
LAB_001012b6:
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x0
MOV qword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x0
MOV qword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x0
MOV qword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x0
MOV qword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x0
MOV qword ptr [RSP + 0xb8],0x0
MOV qword ptr [RSP + 0xc0],0x0
MOV qword ptr [RSP + 0xc8],0x0
MOV qword ptr [RSP + 0xd0],0x0
MOV qword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x0
MOV qword ptr [RSP + 0xe8],0x0
MOV qword ptr [RSP + 0xf0],0x0
MOV qword ptr [RSP + 0xf8],0x0
MOV qword ptr [RSP + 0x100],0x0
MOV qword ptr [RSP + 0x108],0x0
MOV qword ptr [RSP + 0x110],0x0
MOV qword ptr [RSP + 0x118],0x0
MOV R15,qword ptr [R14]
MOVZX EBX,byte ptr [R15]
TEST BL,BL
JZ 0x00101261
LEA RBP,[R15 + 0x1]
MOV R13D,0x0
JMP 0x0010124f
LAB_00101430:
MOV RAX,qword ptr [RSP + 0x128]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010145a
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x138
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010145a:
CALL 0x001010a0
|
char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s1;
int iVar2;
int iVar3;
size_t sVar4;
char *pcVar5;
char cVar6;
char *pcVar7;
int iVar8;
long in_FS_OFFSET;
int local_15c;
char *local_158;
char local_148 [264];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_158 = "";
if (0 < param_2) {
puVar1 = param_1 + param_2;
local_15c = 0;
do {
local_148[0] = '\0';
local_148[1] = '\0';
local_148[2] = '\0';
local_148[3] = '\0';
local_148[4] = '\0';
local_148[5] = '\0';
local_148[6] = '\0';
local_148[7] = '\0';
local_148[8] = '\0';
local_148[9] = '\0';
local_148[10] = '\0';
local_148[0xb] = '\0';
local_148[0xc] = '\0';
local_148[0xd] = '\0';
local_148[0xe] = '\0';
local_148[0xf] = '\0';
local_148[0x10] = '\0';
local_148[0x11] = '\0';
local_148[0x12] = '\0';
local_148[0x13] = '\0';
local_148[0x14] = '\0';
local_148[0x15] = '\0';
local_148[0x16] = '\0';
local_148[0x17] = '\0';
local_148[0x18] = '\0';
local_148[0x19] = '\0';
local_148[0x1a] = '\0';
local_148[0x1b] = '\0';
local_148[0x1c] = '\0';
local_148[0x1d] = '\0';
local_148[0x1e] = '\0';
local_148[0x1f] = '\0';
local_148[0x20] = '\0';
local_148[0x21] = '\0';
local_148[0x22] = '\0';
local_148[0x23] = '\0';
local_148[0x24] = '\0';
local_148[0x25] = '\0';
local_148[0x26] = '\0';
local_148[0x27] = '\0';
local_148[0x28] = '\0';
local_148[0x29] = '\0';
local_148[0x2a] = '\0';
local_148[0x2b] = '\0';
local_148[0x2c] = '\0';
local_148[0x2d] = '\0';
local_148[0x2e] = '\0';
local_148[0x2f] = '\0';
local_148[0x30] = '\0';
local_148[0x31] = '\0';
local_148[0x32] = '\0';
local_148[0x33] = '\0';
local_148[0x34] = '\0';
local_148[0x35] = '\0';
local_148[0x36] = '\0';
local_148[0x37] = '\0';
local_148[0x38] = '\0';
local_148[0x39] = '\0';
local_148[0x3a] = '\0';
local_148[0x3b] = '\0';
local_148[0x3c] = '\0';
local_148[0x3d] = '\0';
local_148[0x3e] = '\0';
local_148[0x3f] = '\0';
local_148[0x40] = '\0';
local_148[0x41] = '\0';
local_148[0x42] = '\0';
local_148[0x43] = '\0';
local_148[0x44] = '\0';
local_148[0x45] = '\0';
local_148[0x46] = '\0';
local_148[0x47] = '\0';
local_148[0x48] = '\0';
local_148[0x49] = '\0';
local_148[0x4a] = '\0';
local_148[0x4b] = '\0';
local_148[0x4c] = '\0';
local_148[0x4d] = '\0';
local_148[0x4e] = '\0';
local_148[0x4f] = '\0';
local_148[0x50] = '\0';
local_148[0x51] = '\0';
local_148[0x52] = '\0';
local_148[0x53] = '\0';
local_148[0x54] = '\0';
local_148[0x55] = '\0';
local_148[0x56] = '\0';
local_148[0x57] = '\0';
local_148[0x58] = '\0';
local_148[0x59] = '\0';
local_148[0x5a] = '\0';
local_148[0x5b] = '\0';
local_148[0x5c] = '\0';
local_148[0x5d] = '\0';
local_148[0x5e] = '\0';
local_148[0x5f] = '\0';
local_148[0x60] = '\0';
local_148[0x61] = '\0';
local_148[0x62] = '\0';
local_148[99] = '\0';
local_148[100] = '\0';
local_148[0x65] = '\0';
local_148[0x66] = '\0';
local_148[0x67] = '\0';
local_148[0x68] = '\0';
local_148[0x69] = '\0';
local_148[0x6a] = '\0';
local_148[0x6b] = '\0';
local_148[0x6c] = '\0';
local_148[0x6d] = '\0';
local_148[0x6e] = '\0';
local_148[0x6f] = '\0';
local_148[0x70] = '\0';
local_148[0x71] = '\0';
local_148[0x72] = '\0';
local_148[0x73] = '\0';
local_148[0x74] = '\0';
local_148[0x75] = '\0';
local_148[0x76] = '\0';
local_148[0x77] = '\0';
local_148[0x78] = '\0';
local_148[0x79] = '\0';
local_148[0x7a] = '\0';
local_148[0x7b] = '\0';
local_148[0x7c] = '\0';
local_148[0x7d] = '\0';
local_148[0x7e] = '\0';
local_148[0x7f] = '\0';
local_148[0x80] = '\0';
local_148[0x81] = '\0';
local_148[0x82] = '\0';
local_148[0x83] = '\0';
local_148[0x84] = '\0';
local_148[0x85] = '\0';
local_148[0x86] = '\0';
local_148[0x87] = '\0';
local_148[0x88] = '\0';
local_148[0x89] = '\0';
local_148[0x8a] = '\0';
local_148[0x8b] = '\0';
local_148[0x8c] = '\0';
local_148[0x8d] = '\0';
local_148[0x8e] = '\0';
local_148[0x8f] = '\0';
local_148[0x90] = '\0';
local_148[0x91] = '\0';
local_148[0x92] = '\0';
local_148[0x93] = '\0';
local_148[0x94] = '\0';
local_148[0x95] = '\0';
local_148[0x96] = '\0';
local_148[0x97] = '\0';
local_148[0x98] = '\0';
local_148[0x99] = '\0';
local_148[0x9a] = '\0';
local_148[0x9b] = '\0';
local_148[0x9c] = '\0';
local_148[0x9d] = '\0';
local_148[0x9e] = '\0';
local_148[0x9f] = '\0';
local_148[0xa0] = '\0';
local_148[0xa1] = '\0';
local_148[0xa2] = '\0';
local_148[0xa3] = '\0';
local_148[0xa4] = '\0';
local_148[0xa5] = '\0';
local_148[0xa6] = '\0';
local_148[0xa7] = '\0';
local_148[0xa8] = '\0';
local_148[0xa9] = '\0';
local_148[0xaa] = '\0';
local_148[0xab] = '\0';
local_148[0xac] = '\0';
local_148[0xad] = '\0';
local_148[0xae] = '\0';
local_148[0xaf] = '\0';
local_148[0xb0] = '\0';
local_148[0xb1] = '\0';
local_148[0xb2] = '\0';
local_148[0xb3] = '\0';
local_148[0xb4] = '\0';
local_148[0xb5] = '\0';
local_148[0xb6] = '\0';
local_148[0xb7] = '\0';
local_148[0xb8] = '\0';
local_148[0xb9] = '\0';
local_148[0xba] = '\0';
local_148[0xbb] = '\0';
local_148[0xbc] = '\0';
local_148[0xbd] = '\0';
local_148[0xbe] = '\0';
local_148[0xbf] = '\0';
local_148[0xc0] = '\0';
local_148[0xc1] = '\0';
local_148[0xc2] = '\0';
local_148[0xc3] = '\0';
local_148[0xc4] = '\0';
local_148[0xc5] = '\0';
local_148[0xc6] = '\0';
local_148[199] = '\0';
local_148[200] = '\0';
local_148[0xc9] = '\0';
local_148[0xca] = '\0';
local_148[0xcb] = '\0';
local_148[0xcc] = '\0';
local_148[0xcd] = '\0';
local_148[0xce] = '\0';
local_148[0xcf] = '\0';
local_148[0xd0] = '\0';
local_148[0xd1] = '\0';
local_148[0xd2] = '\0';
local_148[0xd3] = '\0';
local_148[0xd4] = '\0';
local_148[0xd5] = '\0';
local_148[0xd6] = '\0';
local_148[0xd7] = '\0';
local_148[0xd8] = '\0';
local_148[0xd9] = '\0';
local_148[0xda] = '\0';
local_148[0xdb] = '\0';
local_148[0xdc] = '\0';
local_148[0xdd] = '\0';
local_148[0xde] = '\0';
local_148[0xdf] = '\0';
local_148[0xe0] = '\0';
local_148[0xe1] = '\0';
local_148[0xe2] = '\0';
local_148[0xe3] = '\0';
local_148[0xe4] = '\0';
local_148[0xe5] = '\0';
local_148[0xe6] = '\0';
local_148[0xe7] = '\0';
local_148[0xe8] = '\0';
local_148[0xe9] = '\0';
local_148[0xea] = '\0';
local_148[0xeb] = '\0';
local_148[0xec] = '\0';
local_148[0xed] = '\0';
local_148[0xee] = '\0';
local_148[0xef] = '\0';
local_148[0xf0] = '\0';
local_148[0xf1] = '\0';
local_148[0xf2] = '\0';
local_148[0xf3] = '\0';
local_148[0xf4] = '\0';
local_148[0xf5] = '\0';
local_148[0xf6] = '\0';
local_148[0xf7] = '\0';
local_148[0xf8] = '\0';
local_148[0xf9] = '\0';
local_148[0xfa] = '\0';
local_148[0xfb] = '\0';
local_148[0xfc] = '\0';
local_148[0xfd] = '\0';
local_148[0xfe] = '\0';
local_148[0xff] = '\0';
__s1 = (char *)*param_1;
cVar6 = *__s1;
if (cVar6 == '\0') {
iVar8 = 0;
}
else {
iVar8 = 0;
pcVar7 = __s1;
do {
pcVar7 = pcVar7 + 1;
pcVar5 = strchr(local_148,(int)cVar6);
if (pcVar5 == (char *)0x0) {
sVar4 = strlen(local_148);
local_148[(int)sVar4] = cVar6;
local_148[(int)sVar4 + 1] = '\0';
iVar8 = iVar8 + 1;
}
cVar6 = *pcVar7;
} while (cVar6 != '\0');
}
iVar2 = iVar8;
pcVar7 = __s1;
if (((iVar8 <= local_15c) && (iVar2 = local_15c, pcVar7 = local_158, local_15c == iVar8)) &&
(iVar3 = strcmp(__s1,local_158), iVar2 = iVar8, pcVar7 = __s1, -1 < iVar3)) {
iVar2 = local_15c;
pcVar7 = local_158;
}
local_158 = pcVar7;
local_15c = iVar2;
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_158;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,290 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
unique[len] = words[i][j];
unique[len + 1] = '\0';
unique_count++;
}
}
if (unique_count > maxu || (unique_count == maxu && strcmp(words[i], max) < 0)) {
max = words[i];
maxu = unique_count;
}
}
return max;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(func0(words3, 3), "aaaaaaa") == 0);
char *words4[] = {"abc", "cba"};
assert(strcmp(func0(words4, 2), "abc") == 0);
char *words5[] = {"play", "this", "game", "of", "footbott"};
assert(strcmp(func0(words5, 5), "footbott") == 0);
char *words6[] = {"we", "are", "gonna", "rock"};
assert(strcmp(func0(words6, 4), "gonna") == 0);
char *words7[] = {"we", "are", "a", "mad", "nation"};
assert(strcmp(func0(words7, 5), "nation") == 0);
char *words8[] = {"this", "is", "a", "prrk"};
assert(strcmp(func0(words8, 4), "this") == 0);
char *words9[] = {"b"};
assert(strcmp(func0(words9, 1), "b") == 0);
char *words10[] = {"play", "play", "play"};
assert(strcmp(func0(words10, 3), "play") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
lea 0x995(%rip),%rax
mov %rax,0x18(%rsp)
test %esi,%esi
jle 1807 <func0+0x1a7>
lea -0x1(%rsi),%eax
movl $0x0,0xc(%rsp)
mov %rdi,%rbp
lea 0x20(%rsp),%r15
lea 0x8(%rdi,%rax,8),%rax
mov %rax,0x10(%rsp)
nopl 0x0(%rax)
mov 0x0(%rbp),%r12
pxor %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movzbl (%r12),%r14d
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0x110(%rsp)
test %r14b,%r14b
je 1848 <func0+0x1e8>
lea 0x1(%r12),%r13
xor %ebx,%ebx
jmp 175e <func0+0xfe>
nopl (%rax)
movzbl 0x0(%r13),%r14d
add $0x1,%r13
test %r14b,%r14b
je 17ce <func0+0x16e>
movsbl %r14b,%esi
mov %r15,%rdi
callq 1090 <strchr@plt>
test %rax,%rax
jne 1750 <func0+0xf0>
mov %r15,%rax
mov (%rax),%esi
add $0x4,%rax
lea -0x1010101(%rsi),%edx
not %esi
and %esi,%edx
and $0x80808080,%edx
je 1772 <func0+0x112>
mov %edx,%esi
shr $0x10,%esi
test $0x8080,%edx
cmove %esi,%edx
lea 0x2(%rax),%rsi
cmove %rsi,%rax
mov %edx,%ecx
add %dl,%cl
sbb $0x3,%rax
add $0x1,%r13
add $0x1,%ebx
sub %r15,%rax
movslq %eax,%rdx
add $0x1,%eax
mov %r14b,0x20(%rsp,%rdx,1)
movzbl -0x1(%r13),%r14d
cltq
movb $0x0,0x20(%rsp,%rax,1)
test %r14b,%r14b
jne 175e <func0+0xfe>
cmp %ebx,0xc(%rsp)
jl 1838 <func0+0x1d8>
jne 17f8 <func0+0x198>
mov 0x18(%rsp),%rbx
mov %r12,%rdi
mov %rbx,%rsi
callq 10b0 <strcmp@plt>
test %eax,%eax
cmovns %rbx,%r12
mov %r12,0x18(%rsp)
nopl 0x0(%rax)
add $0x8,%rbp
cmp 0x10(%rsp),%rbp
jne 16c0 <func0+0x60>
mov 0x128(%rsp),%rax
xor %fs:0x28,%rax
jne 184c <func0+0x1ec>
mov 0x18(%rsp),%rax
add $0x138,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %ebx,0xc(%rsp)
mov %r12,0x18(%rsp)
jmp 17f8 <func0+0x198>
nopl 0x0(%rax,%rax,1)
xor %ebx,%ebx
jmp 17ce <func0+0x16e>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov rax, fs:28h
mov [rsp+168h+var_40], rax
lea rax, aAaaaaaa+7; ""
mov [rsp+168h+s2], rax
test esi, esi
jle loc_18A2
movsxd rsi, esi
mov [rsp+168h+var_15C], 0
mov r12, rdi
lea rbx, [rsp+168h+s]
lea rax, [rdi+rsi*8]
mov [rsp+168h+var_158], rax
nop word ptr [rax+rax+00000000h]
loc_1790:
mov r13, [r12]
pxor xmm0, xmm0
movaps xmmword ptr [rsp+168h+s], xmm0
movzx r14d, byte ptr [r13+0]
movaps [rsp+168h+var_138], xmm0
movaps [rsp+168h+var_128], xmm0
movaps [rsp+168h+var_118], xmm0
movaps [rsp+168h+var_108], xmm0
movaps [rsp+168h+var_F8], xmm0
movaps [rsp+168h+var_E8], xmm0
movaps [rsp+168h+var_D8], xmm0
movaps [rsp+168h+var_C8], xmm0
movaps [rsp+168h+var_B8], xmm0
movaps [rsp+168h+var_A8], xmm0
movaps [rsp+168h+var_98], xmm0
movaps [rsp+168h+var_88], xmm0
movaps [rsp+168h+var_78], xmm0
movaps [rsp+168h+var_68], xmm0
movaps [rsp+168h+var_58], xmm0
test r14b, r14b
jz loc_18E0
lea r15, [r13+1]
xor ebp, ebp
jmp short loc_182D
loc_1820:
movzx r14d, byte ptr [r15]
add r15, 1
test r14b, r14b
jz short loc_1869
loc_182D:
movsx esi, r14b; c
mov rdi, rbx; s
call _strchr
test rax, rax
jnz short loc_1820
mov rdi, rbx; s
add r15, 1
add ebp, 1
call _strlen
movsxd rsi, eax
add eax, 1
mov [rsp+rsi+168h+s], r14b
movzx r14d, byte ptr [r15-1]
cdqe
mov [rsp+rax+168h+s], 0
test r14b, r14b
jnz short loc_182D
loc_1869:
cmp [rsp+168h+var_15C], ebp
jl short loc_18D0
jnz short loc_1890
mov r15, [rsp+168h+s2]
mov rdi, r13; s1
mov rsi, r15; s2
call _strcmp
test eax, eax
cmovns r13, r15
mov [rsp+168h+s2], r13
nop dword ptr [rax+00h]
loc_1890:
mov rax, [rsp+168h+var_158]
add r12, 8
cmp r12, rax
jnz loc_1790
loc_18A2:
mov rax, [rsp+168h+var_40]
sub rax, fs:28h
jnz short loc_18E4
mov rax, [rsp+168h+s2]
add rsp, 138h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_18D0:
mov [rsp+168h+var_15C], ebp
mov [rsp+168h+s2], r13
jmp short loc_1890
loc_18E0:
xor ebp, ebp
jmp short loc_1869
loc_18E4:
call ___stack_chk_fail
|
char * func0(const char **a1, int a2)
{
const char **v2; // r12
const char *v3; // r13
char v4; // r14
char *v5; // r15
int v6; // ebp
int v7; // eax
int v9; // [rsp+Ch] [rbp-15Ch]
char *s2; // [rsp+18h] [rbp-150h]
char s[16]; // [rsp+20h] [rbp-148h] BYREF
__int128 v12; // [rsp+30h] [rbp-138h]
__int128 v13; // [rsp+40h] [rbp-128h]
__int128 v14; // [rsp+50h] [rbp-118h]
__int128 v15; // [rsp+60h] [rbp-108h]
__int128 v16; // [rsp+70h] [rbp-F8h]
__int128 v17; // [rsp+80h] [rbp-E8h]
__int128 v18; // [rsp+90h] [rbp-D8h]
__int128 v19; // [rsp+A0h] [rbp-C8h]
__int128 v20; // [rsp+B0h] [rbp-B8h]
__int128 v21; // [rsp+C0h] [rbp-A8h]
__int128 v22; // [rsp+D0h] [rbp-98h]
__int128 v23; // [rsp+E0h] [rbp-88h]
__int128 v24; // [rsp+F0h] [rbp-78h]
__int128 v25; // [rsp+100h] [rbp-68h]
__int128 v26; // [rsp+110h] [rbp-58h]
unsigned long long v27; // [rsp+128h] [rbp-40h]
v27 = __readfsqword(0x28u);
s2 = (char *)"";
if ( a2 > 0 )
{
v9 = 0;
v2 = a1;
do
{
v3 = *v2;
*(_OWORD *)s = 0LL;
v4 = *v3;
v12 = 0LL;
v13 = 0LL;
v14 = 0LL;
v15 = 0LL;
v16 = 0LL;
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0LL;
v25 = 0LL;
v26 = 0LL;
if ( v4 )
{
v5 = (char *)(v3 + 1);
v6 = 0;
do
{
while ( strchr(s, v4) )
{
v4 = *v5++;
if ( !v4 )
goto LABEL_8;
}
++v5;
++v6;
v7 = strlen(s);
s[v7] = v4;
v4 = *(v5 - 1);
s[v7 + 1] = 0;
}
while ( v4 );
}
else
{
v6 = 0;
}
LABEL_8:
if ( v9 < v6 )
{
v9 = v6;
s2 = (char *)v3;
}
else if ( v9 == v6 )
{
if ( strcmp(v3, s2) >= 0 )
v3 = s2;
s2 = (char *)v3;
}
++v2;
}
while ( v2 != &a1[a2] );
}
return s2;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
LEA RAX,[0x102040]
MOV qword ptr [RSP + 0x18],RAX
TEST ESI,ESI
JLE 0x001018a2
MOVSXD RSI,ESI
MOV dword ptr [RSP + 0xc],0x0
MOV R12,RDI
LEA RBX,[RSP + 0x20]
LEA RAX,[RDI + RSI*0x8]
MOV qword ptr [RSP + 0x10],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101790:
MOV R13,qword ptr [R12]
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVZX R14D,byte ptr [R13]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVAPS xmmword ptr [RSP + 0x110],XMM0
TEST R14B,R14B
JZ 0x001018e0
LEA R15,[R13 + 0x1]
XOR EBP,EBP
JMP 0x0010182d
LAB_00101820:
MOVZX R14D,byte ptr [R15]
ADD R15,0x1
TEST R14B,R14B
JZ 0x00101869
LAB_0010182d:
MOVSX ESI,R14B
MOV RDI,RBX
CALL 0x001010b0
TEST RAX,RAX
JNZ 0x00101820
MOV RDI,RBX
ADD R15,0x1
ADD EBP,0x1
CALL 0x00101090
MOVSXD RSI,EAX
ADD EAX,0x1
MOV byte ptr [RSP + RSI*0x1 + 0x20],R14B
MOVZX R14D,byte ptr [R15 + -0x1]
CDQE
MOV byte ptr [RSP + RAX*0x1 + 0x20],0x0
TEST R14B,R14B
JNZ 0x0010182d
LAB_00101869:
CMP dword ptr [RSP + 0xc],EBP
JL 0x001018d0
JNZ 0x00101890
MOV R15,qword ptr [RSP + 0x18]
MOV RDI,R13
MOV RSI,R15
CALL 0x001010d0
TEST EAX,EAX
CMOVNS R13,R15
MOV qword ptr [RSP + 0x18],R13
NOP dword ptr [RAX]
LAB_00101890:
MOV RAX,qword ptr [RSP + 0x10]
ADD R12,0x8
CMP R12,RAX
JNZ 0x00101790
LAB_001018a2:
MOV RAX,qword ptr [RSP + 0x128]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001018e4
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x138
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001018d0:
MOV dword ptr [RSP + 0xc],EBP
MOV qword ptr [RSP + 0x18],R13
JMP 0x00101890
LAB_001018e0:
XOR EBP,EBP
JMP 0x00101869
LAB_001018e4:
CALL 0x001010a0
|
char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s1;
int iVar2;
char *pcVar3;
size_t sVar4;
int iVar5;
char cVar6;
char *pcVar7;
long in_FS_OFFSET;
int local_15c;
char *local_150;
int local_148 [16];
int local_138 [16];
int local_128 [16];
int local_118 [16];
int local_108 [16];
int local_f8 [16];
int local_e8 [16];
int local_d8 [16];
int local_c8 [16];
int local_b8 [16];
int local_a8 [16];
int local_98 [16];
int local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [16];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_150 = "";
if (0 < param_2) {
local_15c = 0;
puVar1 = param_1 + param_2;
do {
__s1 = (char *)*param_1;
local_148 = (int [16])0x0;
cVar6 = *__s1;
local_138 = (int [16])0x0;
local_128 = (int [16])0x0;
local_118 = (int [16])0x0;
local_108 = (int [16])0x0;
local_f8 = (int [16])0x0;
local_e8 = (int [16])0x0;
local_d8 = (int [16])0x0;
local_c8 = (int [16])0x0;
local_b8 = (int [16])0x0;
local_a8 = (int [16])0x0;
local_98 = (int [16])0x0;
local_88 = (int [16])0x0;
local_78 = (int [16])0x0;
local_68 = (int [16])0x0;
local_58 = (int [16])0x0;
if (cVar6 == '\0') {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar7 = __s1 + 1;
do {
while (pcVar3 = strchr(local_148,(int)cVar6), pcVar3 == (char *)0x0) {
iVar5 = iVar5 + 1;
sVar4 = strlen(local_148);
local_148[(int)sVar4] = cVar6;
cVar6 = *pcVar7;
local_148[(int)sVar4 + 1] = 0;
pcVar7 = pcVar7 + 1;
if (cVar6 == '\0') goto LAB_00101869;
}
cVar6 = *pcVar7;
pcVar7 = pcVar7 + 1;
} while (cVar6 != '\0');
}
LAB_00101869:
iVar2 = iVar5;
pcVar7 = __s1;
if (((iVar5 <= local_15c) && (iVar2 = local_15c, pcVar7 = local_150, local_15c == iVar5)) &&
(iVar5 = strcmp(__s1,local_150), pcVar7 = __s1, -1 < iVar5)) {
pcVar7 = local_150;
}
local_150 = pcVar7;
local_15c = iVar2;
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_150;
}
|
1,291 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(char *words[], int count) {
char *max = "";
int maxu = 0;
for (int i = 0; i < count; i++) {
char unique[256] = {0};
int unique_count = 0;
for (int j = 0; words[i][j] != '\0'; j++) {
if (!strchr(unique, words[i][j])) {
int len = strlen(unique);
unique[len] = words[i][j];
unique[len + 1] = '\0';
unique_count++;
}
}
if (unique_count > maxu || (unique_count == maxu && strcmp(words[i], max) < 0)) {
max = words[i];
maxu = unique_count;
}
}
return max;
}
|
#include <assert.h>
#include <string.h>
int main() {
char *words1[] = {"name", "of", "string"};
assert(strcmp(func0(words1, 3), "string") == 0);
char *words2[] = {"name", "enam", "game"};
assert(strcmp(func0(words2, 3), "enam") == 0);
char *words3[] = {"aaaaaaa", "bb", "cc"};
assert(strcmp(func0(words3, 3), "aaaaaaa") == 0);
char *words4[] = {"abc", "cba"};
assert(strcmp(func0(words4, 2), "abc") == 0);
char *words5[] = {"play", "this", "game", "of", "footbott"};
assert(strcmp(func0(words5, 5), "footbott") == 0);
char *words6[] = {"we", "are", "gonna", "rock"};
assert(strcmp(func0(words6, 4), "gonna") == 0);
char *words7[] = {"we", "are", "a", "mad", "nation"};
assert(strcmp(func0(words7, 5), "nation") == 0);
char *words8[] = {"this", "is", "a", "prrk"};
assert(strcmp(func0(words8, 4), "this") == 0);
char *words9[] = {"b"};
assert(strcmp(func0(words9, 1), "b") == 0);
char *words10[] = {"play", "play", "play"};
assert(strcmp(func0(words10, 3), "play") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
lea 0x955(%rip),%rax
mov %rax,0x18(%rsp)
test %esi,%esi
jle 17ef <func0+0x14f>
lea -0x1(%rsi),%eax
movl $0x0,0xc(%rsp)
mov %rdi,%rbp
lea 0x20(%rsp),%r15
lea 0x8(%rdi,%rax,8),%rax
mov %rax,0x10(%rsp)
nopl 0x0(%rax)
mov 0x0(%rbp),%r12
pxor %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movzbl (%r12),%r14d
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0x110(%rsp)
test %r14b,%r14b
je 18a0 <func0+0x200>
lea 0x1(%r12),%r13
xor %ebx,%ebx
nopl 0x0(%rax,%rax,1)
movsbl %r14b,%esi
mov %r15,%rdi
callq 1090 <strchr@plt>
test %rax,%rax
je 1820 <func0+0x180>
movzbl 0x0(%r13),%r14d
add $0x1,%r13
test %r14b,%r14b
jne 1790 <func0+0xf0>
cmp %ebx,0xc(%rsp)
jl 188d <func0+0x1ed>
jne 17e0 <func0+0x140>
mov 0x18(%rsp),%rbx
mov %r12,%rdi
mov %rbx,%rsi
callq 10b0 <strcmp@plt>
test %eax,%eax
cmovns %rbx,%r12
mov %r12,0x18(%rsp)
nopw %cs:0x0(%rax,%rax,1)
add $0x8,%rbp
cmp 0x10(%rsp),%rbp
jne 1700 <func0+0x60>
mov 0x128(%rsp),%rax
xor %fs:0x28,%rax
jne 18a7 <func0+0x207>
mov 0x18(%rsp),%rax
add $0x138,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
mov %r15,%rax
mov (%rax),%esi
add $0x4,%rax
lea -0x1010101(%rsi),%edx
not %esi
and %esi,%edx
and $0x80808080,%edx
je 1823 <func0+0x183>
mov %edx,%esi
shr $0x10,%esi
test $0x8080,%edx
cmove %esi,%edx
lea 0x2(%rax),%rsi
cmove %rsi,%rax
mov %edx,%ecx
add %dl,%cl
sbb $0x3,%rax
add $0x1,%r13
add $0x1,%ebx
sub %r15,%rax
movslq %eax,%rdx
add $0x1,%eax
cltq
mov %r14b,0x20(%rsp,%rdx,1)
movb $0x0,0x20(%rsp,%rax,1)
movzbl -0x1(%r13),%r14d
test %r14b,%r14b
jne 1790 <func0+0xf0>
cmp %ebx,0xc(%rsp)
jge 17b9 <func0+0x119>
mov %ebx,0xc(%rsp)
mov %r12,0x18(%rsp)
jmpq 17e0 <func0+0x140>
nopl 0x0(%rax,%rax,1)
xor %ebx,%ebx
jmpq 17af <func0+0x10f>
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov rax, fs:28h
mov [rsp+168h+var_40], rax
lea rax, aAaaaaaa+7; ""
mov [rsp+168h+s2], rax
test esi, esi
jle loc_1877
movsxd rsi, esi
mov [rsp+168h+var_15C], 0
mov r12, rdi
lea rbx, [rsp+168h+s]
lea rax, [rdi+rsi*8]
mov [rsp+168h+var_158], rax
nop word ptr [rax+rax+00000000h]
loc_1790:
mov r13, [r12]
pxor xmm0, xmm0
movaps xmmword ptr [rsp+168h+s], xmm0
movzx r14d, byte ptr [r13+0]
movaps [rsp+168h+var_138], xmm0
movaps [rsp+168h+var_128], xmm0
movaps [rsp+168h+var_118], xmm0
movaps [rsp+168h+var_108], xmm0
movaps [rsp+168h+var_F8], xmm0
movaps [rsp+168h+var_E8], xmm0
movaps [rsp+168h+var_D8], xmm0
movaps [rsp+168h+var_C8], xmm0
movaps [rsp+168h+var_B8], xmm0
movaps [rsp+168h+var_A8], xmm0
movaps [rsp+168h+var_98], xmm0
movaps [rsp+168h+var_88], xmm0
movaps [rsp+168h+var_78], xmm0
movaps [rsp+168h+var_68], xmm0
movaps [rsp+168h+var_58], xmm0
test r14b, r14b
jz loc_18F0
lea r15, [r13+1]
xor ebp, ebp
nop word ptr [rax+rax+00h]
loc_1820:
movsx esi, r14b; c
mov rdi, rbx; s
call _strchr
test rax, rax
jz short loc_18A8
movzx r14d, byte ptr [r15]
add r15, 1
test r14b, r14b
jnz short loc_1820
loc_183E:
cmp [rsp+168h+var_15C], ebp
jl loc_18E1
loc_1848:
jnz short loc_1868
mov r15, [rsp+168h+s2]
mov rdi, r13; s1
mov rsi, r15; s2
call _strcmp
test eax, eax
cmovns r13, r15
mov [rsp+168h+s2], r13
nop dword ptr [rax]
loc_1868:
add r12, 8
cmp [rsp+168h+var_158], r12
jnz loc_1790
loc_1877:
mov rax, [rsp+168h+var_40]
sub rax, fs:28h
jnz short loc_18F7
mov rax, [rsp+168h+s2]
add rsp, 138h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_18A8:
mov rdi, rbx; s
add r15, 1
add ebp, 1
call _strlen
movsxd rsi, eax
add eax, 1
cdqe
mov [rsp+rsi+168h+s], r14b
mov [rsp+rax+168h+s], 0
movzx r14d, byte ptr [r15-1]
test r14b, r14b
jnz loc_1820
cmp [rsp+168h+var_15C], ebp
jge loc_1848
loc_18E1:
mov [rsp+168h+var_15C], ebp
mov [rsp+168h+s2], r13
jmp loc_1868
loc_18F0:
xor ebp, ebp
jmp loc_183E
loc_18F7:
call ___stack_chk_fail
|
char * func0(const char **a1, int a2)
{
const char **i; // r12
const char *v3; // r13
char v4; // r14
char *v5; // r15
int v6; // ebp
bool v7; // zf
int v9; // eax
int v10; // [rsp+Ch] [rbp-15Ch]
char *s2; // [rsp+18h] [rbp-150h]
char s[16]; // [rsp+20h] [rbp-148h] BYREF
__int128 v13; // [rsp+30h] [rbp-138h]
__int128 v14; // [rsp+40h] [rbp-128h]
__int128 v15; // [rsp+50h] [rbp-118h]
__int128 v16; // [rsp+60h] [rbp-108h]
__int128 v17; // [rsp+70h] [rbp-F8h]
__int128 v18; // [rsp+80h] [rbp-E8h]
__int128 v19; // [rsp+90h] [rbp-D8h]
__int128 v20; // [rsp+A0h] [rbp-C8h]
__int128 v21; // [rsp+B0h] [rbp-B8h]
__int128 v22; // [rsp+C0h] [rbp-A8h]
__int128 v23; // [rsp+D0h] [rbp-98h]
__int128 v24; // [rsp+E0h] [rbp-88h]
__int128 v25; // [rsp+F0h] [rbp-78h]
__int128 v26; // [rsp+100h] [rbp-68h]
__int128 v27; // [rsp+110h] [rbp-58h]
unsigned long long v28; // [rsp+128h] [rbp-40h]
v28 = __readfsqword(0x28u);
s2 = (char *)"";
if ( a2 > 0 )
{
v10 = 0;
for ( i = a1; &a1[a2] != i; ++i )
{
v3 = *i;
*(_OWORD *)s = 0LL;
v4 = *v3;
v13 = 0LL;
v14 = 0LL;
v15 = 0LL;
v16 = 0LL;
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0LL;
v25 = 0LL;
v26 = 0LL;
v27 = 0LL;
if ( v4 )
{
v5 = (char *)(v3 + 1);
v6 = 0;
do
{
while ( strchr(s, v4) )
{
v4 = *v5++;
if ( !v4 )
goto LABEL_7;
}
++v5;
++v6;
v9 = strlen(s);
s[v9] = v4;
s[v9 + 1] = 0;
v4 = *(v5 - 1);
}
while ( v4 );
v7 = v10 == v6;
if ( v10 >= v6 )
{
LABEL_8:
if ( v7 )
{
if ( strcmp(v3, s2) >= 0 )
v3 = s2;
s2 = (char *)v3;
}
continue;
}
}
else
{
v6 = 0;
LABEL_7:
v7 = v10 == v6;
if ( v10 >= v6 )
goto LABEL_8;
}
v10 = v6;
s2 = (char *)v3;
}
}
return s2;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
LEA RAX,[0x102040]
MOV qword ptr [RSP + 0x18],RAX
TEST ESI,ESI
JLE 0x00101877
MOVSXD RSI,ESI
MOV dword ptr [RSP + 0xc],0x0
MOV R12,RDI
LEA RBX,[RSP + 0x20]
LEA RAX,[RDI + RSI*0x8]
MOV qword ptr [RSP + 0x10],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101790:
MOV R13,qword ptr [R12]
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVZX R14D,byte ptr [R13]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVAPS xmmword ptr [RSP + 0x110],XMM0
TEST R14B,R14B
JZ 0x001018f0
LEA R15,[R13 + 0x1]
XOR EBP,EBP
NOP word ptr [RAX + RAX*0x1]
LAB_00101820:
MOVSX ESI,R14B
MOV RDI,RBX
CALL 0x001010b0
TEST RAX,RAX
JZ 0x001018a8
MOVZX R14D,byte ptr [R15]
ADD R15,0x1
TEST R14B,R14B
JNZ 0x00101820
LAB_0010183e:
CMP dword ptr [RSP + 0xc],EBP
JL 0x001018e1
LAB_00101848:
JNZ 0x00101868
MOV R15,qword ptr [RSP + 0x18]
MOV RDI,R13
MOV RSI,R15
CALL 0x001010d0
TEST EAX,EAX
CMOVNS R13,R15
MOV qword ptr [RSP + 0x18],R13
NOP dword ptr [RAX]
LAB_00101868:
ADD R12,0x8
CMP qword ptr [RSP + 0x10],R12
JNZ 0x00101790
LAB_00101877:
MOV RAX,qword ptr [RSP + 0x128]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001018f7
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x138
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001018a8:
MOV RDI,RBX
ADD R15,0x1
ADD EBP,0x1
CALL 0x00101090
MOVSXD RSI,EAX
ADD EAX,0x1
CDQE
MOV byte ptr [RSP + RSI*0x1 + 0x20],R14B
MOV byte ptr [RSP + RAX*0x1 + 0x20],0x0
MOVZX R14D,byte ptr [R15 + -0x1]
TEST R14B,R14B
JNZ 0x00101820
CMP dword ptr [RSP + 0xc],EBP
JGE 0x00101848
LAB_001018e1:
MOV dword ptr [RSP + 0xc],EBP
MOV qword ptr [RSP + 0x18],R13
JMP 0x00101868
LAB_001018f0:
XOR EBP,EBP
JMP 0x0010183e
LAB_001018f7:
CALL 0x001010a0
|
char * func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s1;
int iVar2;
int iVar3;
char *pcVar4;
size_t sVar5;
char cVar6;
char *pcVar7;
long in_FS_OFFSET;
int local_15c;
char *local_150;
int local_148 [16];
int local_138 [16];
int local_128 [16];
int local_118 [16];
int local_108 [16];
int local_f8 [16];
int local_e8 [16];
int local_d8 [16];
int local_c8 [16];
int local_b8 [16];
int local_a8 [16];
int local_98 [16];
int local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [16];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_150 = "";
if (0 < param_2) {
local_15c = 0;
puVar1 = param_1 + param_2;
do {
__s1 = (char *)*param_1;
local_148 = (int [16])0x0;
cVar6 = *__s1;
local_138 = (int [16])0x0;
local_128 = (int [16])0x0;
local_118 = (int [16])0x0;
local_108 = (int [16])0x0;
local_f8 = (int [16])0x0;
local_e8 = (int [16])0x0;
local_d8 = (int [16])0x0;
local_c8 = (int [16])0x0;
local_b8 = (int [16])0x0;
local_a8 = (int [16])0x0;
local_98 = (int [16])0x0;
local_88 = (int [16])0x0;
local_78 = (int [16])0x0;
local_68 = (int [16])0x0;
local_58 = (int [16])0x0;
if (cVar6 == '\0') {
iVar3 = 0;
}
else {
iVar3 = 0;
pcVar7 = __s1 + 1;
do {
while (pcVar4 = strchr(local_148,(int)cVar6), pcVar4 != (char *)0x0) {
cVar6 = *pcVar7;
pcVar7 = pcVar7 + 1;
if (cVar6 == '\0') goto joined_r0x001018db;
}
iVar3 = iVar3 + 1;
sVar5 = strlen(local_148);
local_148[(int)sVar5] = cVar6;
local_148[(int)sVar5 + 1] = 0;
cVar6 = *pcVar7;
pcVar7 = pcVar7 + 1;
} while (cVar6 != '\0');
}
joined_r0x001018db:
iVar2 = iVar3;
pcVar7 = __s1;
if (((iVar3 <= local_15c) && (iVar2 = local_15c, pcVar7 = local_150, local_15c == iVar3)) &&
(iVar3 = strcmp(__s1,local_150), pcVar7 = __s1, -1 < iVar3)) {
pcVar7 = local_150;
}
local_150 = pcVar7;
local_15c = iVar2;
param_1 = param_1 + 1;
} while (puVar1 != param_1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_150;
}
|
1,292 |
func0
|
#include <stdio.h>
|
void func0(int number, int need, int remaining, int result[2]) {
if (need > remaining) {
result[0] = number + remaining;
result[1] = 0;
} else {
result[0] = number + need;
result[1] = remaining - need;
}
}
|
#include <assert.h>
int issame(int a[2], int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0(5, 6, 10, result);
assert(issame(result, (const int[]){11, 4}));
func0(4, 8, 9, result);
assert(issame(result, (const int[]){12, 1}));
func0(1, 10, 10, result);
assert(issame(result, (const int[]){11, 0}));
func0(2, 11, 5, result);
assert(issame(result, (const int[]){7, 0}));
func0(4, 5, 7, result);
assert(issame(result, (const int[]){9, 2}));
func0(4, 5, 1, result);
assert(issame(result, (const int[]){5, 0}));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov %rcx,-0x18(%rbp)
mov -0x8(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 11a4 <func0+0x3b>
mov -0x4(%rbp),%edx
mov -0xc(%rbp),%eax
add %eax,%edx
mov -0x18(%rbp),%rax
mov %edx,(%rax)
mov -0x18(%rbp),%rax
add $0x4,%rax
movl $0x0,(%rax)
jmp 11c2 <func0+0x59>
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %eax,%edx
mov -0x18(%rbp),%rax
mov %edx,(%rax)
mov -0x18(%rbp),%rax
lea 0x4(%rax),%rdx
mov -0xc(%rbp),%eax
sub -0x8(%rbp),%eax
mov %eax,(%rdx)
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov [rbp+var_18], rcx
mov eax, [rbp+var_8]
cmp eax, [rbp+var_C]
jle short loc_11A4
mov edx, [rbp+var_4]
mov eax, [rbp+var_C]
add edx, eax
mov rax, [rbp+var_18]
mov [rax], edx
mov rax, [rbp+var_18]
add rax, 4
mov dword ptr [rax], 0
jmp short loc_11C2
loc_11A4:
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add edx, eax
mov rax, [rbp+var_18]
mov [rax], edx
mov rax, [rbp+var_18]
lea rdx, [rax+4]
mov eax, [rbp+var_C]
sub eax, [rbp+var_8]
mov [rdx], eax
loc_11C2:
nop
pop rbp
retn
|
unsigned long long func0(int a1, int a2, int a3, _DWORD *a4)
{
unsigned long long result; // rax
if ( a2 <= a3 )
{
*a4 = a2 + a1;
result = (unsigned int)(a3 - a2);
a4[1] = result;
}
else
{
*a4 = a3 + a1;
result = (unsigned long long)(a4 + 1);
a4[1] = 0;
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x001011a4
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0xc]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV dword ptr [RAX],0x0
JMP 0x001011c2
LAB_001011a4:
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[RAX + 0x4]
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RDX],EAX
LAB_001011c2:
NOP
POP RBP
RET
|
void func0(int param_1,int param_2,int param_3,int *param_4)
{
if (param_3 < param_2) {
*param_4 = param_1 + param_3;
param_4[1] = 0;
}
else {
*param_4 = param_1 + param_2;
param_4[1] = param_3 - param_2;
}
return;
}
|
1,293 |
func0
|
#include <stdio.h>
|
void func0(int number, int need, int remaining, int result[2]) {
if (need > remaining) {
result[0] = number + remaining;
result[1] = 0;
} else {
result[0] = number + need;
result[1] = remaining - need;
}
}
|
#include <assert.h>
int issame(int a[2], int b[2]) {
return a[0] == b[0] && a[1] == b[1];
}
int main() {
int result[2];
func0(5, 6, 10, result);
assert(issame(result, (const int[]){11, 4}));
func0(4, 8, 9, result);
assert(issame(result, (const int[]){12, 1}));
func0(1, 10, 10, result);
assert(issame(result, (const int[]){11, 0}));
func0(2, 11, 5, result);
assert(issame(result, (const int[]){7, 0}));
func0(4, 5, 7, result);
assert(issame(result, (const int[]){9, 2}));
func0(4, 5, 1, result);
assert(issame(result, (const int[]){5, 0}));
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp %edx,%esi
jle 117d <func0+0x14>
add %edi,%edx
mov %edx,(%rcx)
movl $0x0,0x4(%rcx)
retq
add %esi,%edi
mov %edi,(%rcx)
sub %esi,%edx
mov %edx,0x4(%rcx)
retq
|
func0:
endbr64
cmp esi, edx
jle short loc_117E
add edi, edx
mov edx, 0
loc_1178:
mov [rcx], edi
mov [rcx+4], edx
retn
loc_117E:
add edi, esi
sub edx, esi
jmp short loc_1178
|
void func0(int a1, int a2, int a3, _DWORD *a4)
{
int v4; // edi
int v5; // edx
if ( a2 <= a3 )
{
v4 = a2 + a1;
v5 = a3 - a2;
}
else
{
v4 = a3 + a1;
v5 = 0;
}
*a4 = v4;
a4[1] = v5;
}
|
func0:
ENDBR64
CMP ESI,EDX
JLE 0x0010117e
ADD EDI,EDX
MOV EDX,0x0
LAB_00101178:
MOV dword ptr [RCX],EDI
MOV dword ptr [RCX + 0x4],EDX
RET
LAB_0010117e:
ADD EDI,ESI
SUB EDX,ESI
JMP 0x00101178
|
void func0(int param_1,int param_2,int param_3,int *param_4)
{
if (param_3 < param_2) {
param_1 = param_1 + param_3;
param_3 = 0;
}
else {
param_1 = param_1 + param_2;
param_3 = param_3 - param_2;
}
*param_4 = param_1;
param_4[1] = param_3;
return;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.